Strings são variáveis usadas para armazenar texto. No Python elas são sequências, coleções de caracteres ordenada por posição. A manipulação de strings é um dos pontos fortes do python e existem diversas funções para isso.
No python strings são definidas com aspas simples (') ou aspas duplas ("). Aspas triplas (''' ou """) podem ser usadas para definir strings longas. String dentro de parentêses são concatenadas, o que é útil para se escrever uma string longa sem perder a legibilidade.
» string_1 = 'casa'
» string_2 = ' da mãe Joana'
» string_longa = '''
este é um
exemplo de uma
string longa!
'''
» print(string_longa)
↳ este é um
exemplo de uma
string longa!
» outra_longa = (
'https://www.phylos.net/'
'2020-12-16/'
'pacote-factoranalyser/'
)
» print(outra_longa)
↳ 'https://www.phylos.net/2020-12-16/pacote-factoranalyser/'
Vamos ver alguns exemplos de strings e de suas manipulações:
# a sequência pode ser percorrida
» for letra in "banana":
» print(letra, end=' ')
↳ b a n a n a
# usamos end=' ' para evitar quebras de linhas e inserir espaços no lugar
# definimos uma variável de string
» palavra = 'Pindamonhangaba!'
# len() fornece seu comprimento (quantos caracteres)
» len(palavra)
↳ 16
# um caracter pode ser obtido por seu índice
» print(palavra[0], palavra[15])
↳ P !
# índices negativos contam do fim para o início
» print(palavra[-1])
↳ !
» print(palavra[-2])
↳ a
# palavra[-1] equivale a
» palavra[len(palavra)-1]
↳ '!'
# uma 'fatia' (slice)
» palavra[1:4]
↳ 'ind'
# se o segundo índice for omitido a fatia vai até o fim
» palavra[5:]
↳ 'monhangaba!'
# se o primeiro índice for omitido a fatia começa no início
» palavra[:5]
↳ 'Pinda'
» palavra[:]
↳ 'Pindamonhangaba!'
» len(palavra[1:4])
↳ 3
Vimos nos exemplos acima que uma fatia (ou slice) palavra[i:f] se inicia em i e termina em f, exclusive. Os índices, e todas as contagens em python se iniciam em 0. A posição final não é incluida de forma que len(palavra[i:j]) = j-1.
Os operadores + e * (adição e multiplicação) tem significado especial quando os operandos são strings. + promove a concatenação de strings e * retorna uma repetição.
# Operações com palavras
» p1 = 'casa'
» p2 = 'da mãe Joana'
# '+' faz uma concatenação
» p1 + ' ' + p2
↳ 'casa da mãe Joana'
# '*' repete a string
» p1 * 5
↳ 'casacasacasacasacasa'
Observe que nenhuma das operações realizadas até agora afetam o conteúdo da variável. Ao contrário, cada uma delas produz uma nova string. Dizemos que strings são imutáveis no python. Como são imutáveis uma string não pode ser alterada in loco. No exemplo abaixo, para alterar ‘rato’ para ‘pato’ é necessário construir nova string e atribuí-la à variável.
# Strings são imutáveis
» str = 'rato'
» str[0]
↳ 'r'
# a tentativa de alterar a string resulta em erro
» str[0] = 'p'
↳ TypeError: 'str' object does not support item assignment
# para trocar 'r' por 'p'
» str = 'p' + str[1:]
» str
↳ 'pato'
Métodos das strings
Claro que o leitor não precisa se preocupar em memorizar todas essas funções. Uma leitura serve para se ter conhecimento das possibilidades.
Como objetos, as strings possuem métodos e propriedades (coisas que veremos com mais detalhes mais tarde). A lista abaixo contém alguns métodos.
Método
descrição
capitalize()
converte 1º caracter em maiúsculo
casefold()
converte string em minúsculas
center()
retorna string centralizada
count()
retorna número de ocorrências de um valor especificado na string
endswith()
retorna True se string termina com valor especificado
find()
busca por valor especificado na string e retorna the posição se encontrado
format()
Formata de acordo com valores especificados†
index()
busca por valor especificado na string e retorna the posição se encontrado
isalnum()
retorna True se todos os caracteres são alfa-numéricos
isalpha()
retorna True se todos os caracteres são alfabéticos
isdecimal()
retorna True se todos os caracteres são decimais
isdigit()
retorna True se todos os caracteres são dígitos
islower()
retorna True se todos os caracteres são minúsculos
isnumeric()
retorna True se todos os caracteres são numéricos
isspace()
retorna True se todos os caracteres são espaços
istitle()
retorna True se a string segue regra de títulos
isupper()
retorna True se todos os caracteres são maiúsculos
join()
reune elementos de um iterável no final da string
ljust()
retorna a string justificada à esquerda
lower()
converte a string para minúsculas
lstrip()
retorna a string sem espaços à esquerda
partition()
retorna tuple partindo a string em 3 partes
replace()
substitui trecho da string por outro especificado
rfind()
busca trecho especificado value e retorna última posição
rindex()
busca trecho especificado value e retorna última posição
rjust()
retorna string justificada à direita
rsplit()
quebra a string no separador especificado, retornando lista
rstrip()
retorna a string sem espaços à direita
split()
quebra a string no separador especificado, retornando lista
splitlines()
quebra a string nas quebras de linha, retornando lista
startswith()
retorna True se string começa com valor especificado
strip()
retorna a string sem espaços laterais
swapcase()
inverte minúsculas e maiúsculas
title()
converte em maiúscula o 1º caracter de cada palavra
upper()
converte a string em maiúsculas
zfill()
preencha com número de zeros especificado, no início
Nota sobre † o método format() abaixo. Alguns exemplos de uso são apresentados a seguir.
» str = 'uma palavra qualquer'
# tornar a primeira letra maiúscula
» str.capitalize()
↳ 'Uma palavra qualquer'
# contar quantas letras 'a' existem na string
» str.count('a')
↳ 5
# a string termina com 'r'?
» str.endswith('r')
↳ True
# em que posição 'qu' está na string
» str.find('qu')
↳ 12
# se o trecho procurado não existe na string
» str.find('y')
↳ -1
» str.isnumeric()
↳ False
» '1234567890'.isnumeric()
↳ True
» str.replace('palavra','coisa')
'uma coisa qualquer'
» str.startswith('un')
↳ False
# join é usada para concatenar strings
» uma_tupla = ('Carro', 'Casa', 'Gado')
» x = '-'.join(uma_tupla)
» print(x)
↳ Carro-Casa-Gado
# exemplo de uso para join, construindo uma tabela html
» html = '<table><tr><td>'
» html += '</td><td>'.join(uma_tupla)
» html += '</td></tr></table>'
» print(html)
↳ <table><tr><td>Carro</td><td>Casa</td><td>Gado</td></tr></table>
# lembrando que x = 'Carro-Casa-Gado'
» for txt in x.split('-'):
» print(txt)
↳ Carro
Casa
Gado
# quebrando uma frase em palavras
» frase = 'A segunda palavra da frase'
» frase.split(' ')[1]
↳ 'segunda'
No exemplo abaixo str é quebrada nos espaços, pegando cada palavra em separado. O primeiro caso imprime a palavra que começa com ‘r’ e termina com ‘a’. O segundo imprime a palavra que começa com ‘p’ e não termina com ‘a’.
» str = 'pato pata rato rata'
» for palavra in str.split(' '):
» if palavra.startswith('r') and palavra.endswith('a'):
» print(palavra)
↳ rata
» for palavra in str.split(' '):
» if palavra.startswith('p') and not palavra.endswith('a'):
» print(palavra)
↳ pato
Existem alguns mecanismos de apoio à formatação de strings, particularmente útil na impressão de resultados. Os sinais especiais %d e %s podem ser usados na montagem de strings, o primeiro como substituto de um dígito, o segundo de texto. %f informa a substituição por número de ponto flutuante %.nf ponto flutuante com n casas decimais, %E de número com notação científica (usando potências de 10).
» s1 = 'Uma string com um dígito e texto: dígito: %d; texto: %s' % (10, 'dez')
» print(s1)
↳ Uma string com um dígito e texto: dígito: 10; texto: dez
print('Um inteiro convertido em ponto flutuante: %f' % 5)
↳ Um inteiro convertido em ponto flutuante: 5.000000
print('Exibir o número %.02f com 2 casas decimais' % 25.123456)
↳ Exibir o número 25.12 com 2 casas decimais
print('Um número com notação científica: %E' % 6.789E7)
↳ Um número com notação científica: 6.789000E+07
† Um método mais moderno de formatação consiste um usar string.format(), que permite código mais legível.
# marcadores nomeados são supridos por format
» txt1 = "Eu me chamo {nome} e tenho {idade} anos.".format(nome = 'João', idade = 36)
# os lugares podem ser marcados numericamente
» txt2 = "Moro em {0}, {1} há {2} anos.".format('Brasília', 'DF', 20)
# ou marcados apenas por sua ordem de aparecimento
» txt3 = "{} são convertidos em {}. Exemplo: {}.".format('Dígitos', 'strings', 100)
» print(txt1)
↳ Eu me chamo João e tenho 36 anos.
» print(txt2)
↳ Moro em Brasília, DF há 20 anos.
» print(txt3)
↳ Dígitos são convertidos em strings. Exemplo: 100.
# controle do número de casas decimais
» txt4 = 'Esse livro custa R$ {preco:.2f} com desconto!'.format(preco = 49.8)
» print(txt4)
↳ Esse livro custa R$ 49.80 com desconto!
Também existe o chamado método de interpolação de strings que usa o prefixo f para que a string possa incorporar variáveis.
» nome = 'Albert'
» sobrenome = 'Einstein'
» ano = 1879
» print(f'O físico {nome} {sobrenome} nasceu em {ano}')
↳ O físico Albert Einstein nasceu em 1879
# podemos inserir operações dentro da string de formatação
» a = 214
» b = 3
» print(f'{a} multiplicado por {b} é {a * b}.')
↳ 214 multiplicado por 3 é 642.
Observe que strings justapostas são concatenadas. No entanto isso gera um código menos claro. O método de interpolação torna o código de mais fácil entendimento.
print('Paul ''Adrien ''Maurice ''Dirac' ' nascido em ' '1902')
Paul Adrien Maurice Dirac nascido em 1902
fisico = 'P. A. M. Dirac'
ano = 1902
print(f'O físico {fisico} nascem em {ano}' )
O físico P. A. M. Dirac nascem em 1902
Caracteres de escape
Caracteres especiais podem ser inseridos em uma string por meio de “escapes”. Por exemplo, para usar aspas em uma string podemos fazer o seguinte:
# inserindo aspas simples em string
» print('O cara se chama O\'Maley')
↳ O cara se chama O'Maley
# o mesmo poderia ser feito com aspas duplas
» print("O cara se chama O'Maley")
↳ O cara se chama O'Maley
» print("E seu primeiro nome é \"George\"")
↳ E seu primeiro nome é "George"
# quebra de linha
» print('linha1\nlinha2')
↳ linha1
↳ linha2
Um computador é uma máquina eletrônica com capacidade para armazenar valores numéricos em formato binário e instruções de manipulação desses valores armazenados. Informações não numéricas, como letras, palavras e imagens, precisam ser convertidas em binários para que possam ser tratados. Nos primeiros tempos da computação a interação com as máquinas era muito difícil e um programador tinha que escrever códigos muito complexos, como diretamente em linguagem de máquina ou assembly. Hoje, após muito aperfeiçoamento, as linguagens modernas abstraem as camadas mais complexas de interação com o computador. O código tem a aparência de uma linguagem natural humana e pode ser lido quase como um texto comum.
Um exemplo pode ilustrar essa descrição. Considere que uma pessoa possui uma caixa cheia de bolas pretas e brancas. Ela quer saber qual é a porcentagem de bolas pretas, no total. Uma possível solução seria o seguinte procedimento, usando um bloco de notas para registrar bolas pretas e brancas:
tire uma bola da caixa,
verifique se é preta,
se for preta faça uma marca para bolas pretas, caso contrário para as brancas,
sem retornar a bola, verifique se ainda restam bolas na caixa,
se ainda restam bolas, volte para a etapa (1),
se acabaram as bolas, conte quantas marcas foram feitas para cada cor,
calcule porcentagem = pretas/(pretas+brancas)*100 e anote esse resultado.
Esse procedimento é chamado de algoritmo. A lista de tarefas é análoga à um programa de computador. As marcas feitas para contagem das bolas brancas e pretas são análogas às variáveis do programa.
Jupyter
O Python pode ser executado de várias formas diferentes. Existem bons editores e IDEs (Integrated Devolopment Environment) tais como o Pycharm, Geany, Spyder. Para esse tutorial usaremos o Jupyter Notebook. Para maiores informações sobre o Jupyter leia nesse site sobre sua instalação e execução.
Resumindo, sua instalação pode ser feita instalando-se o Anaconda:
Baixe a versão mais recente do Anaconda aqui. Existem instaladores gráficos para Linux, Windows e MacOS.
Instale seguindo as instruções na página de download ou contidas no arquivo instalador executável.
ou … usuários que conhecem Python e que preferem gerenciar seus pacotes manualmente, pode apenas usar: pip3 install jupyter.
Python
Python é uma linguagem de programação de alto nível, interpretada e de propósito geral, criada por Guido van Rossum em 1985 e em franco desenvolvimento desde então. Ela está disponível sob a licença GPL (GNU General Public License). Ela permite o uso interativo, com o usuário digitando as linhas de código e obtendo o resultado imediatamente, ou através de lotes (batches), com as linhas de código armazenadas em arquivos e executadas em grupo. Apesar de ser chamada de linguagem de script é possível criar aplicativos completos, na web ou para desktop, com interfaces gráficas modernas e eficientes. Além disso existe a possibilidade de gerar arquivos compilados e executáveis usando Cython.
Uma grande quantidade de bibliotecas ou módulos que podem ser importados e executados nas sessões do python o tornam atraente para o gerenciamento de bancos de dados, de imagens, a mineração de dados, análise e plotagem sofisticada, inteligência artificial e aprendizado de máquina, além de várias outras aplicações. Você pode procurar por bibliotecas em
Find, install and publish Python packages with the Python Package Index
Python é uma linguagem orientada a objetos (um conceito a ser estudado mais tarde) e todos de seus elementos são objetos. Seus conceitos básicos são de rápido aprendizado, apesar da existência das várias bibliotecas para uso específico que podem ser um pouco mais complexas, como ocorre com o pandas.
Variáveis e operações básicas
Convenção: Usaremos nesse texto a seguinte convenção: linhas iniciadas com » marcam o código inserido para execução. No Jupyter Notebook são as linhas de código dentro das células. ↳ marca os outputs, as linhas de resposta do código. Linhas, ou trechos de linha, iniciadas com # são comentários não executados.
# Essa linha é um comentário
» x = 15 # inserindo um inteiro
» print(x)
↳ 15
Você pode usar o python para fazer operações matemáticas como um calculadora, embora isso raramente seja algo muito útil. Mais interessante é a possibilidade de criar variáveis que armazenam dados. No python uma variável é criada no momento em que se atribui a ela um valor, sem necessidade de informar de que tipo será (o que chamamos de tipagem dinâmica).
# inicializamos duas variáveis numéricas e uma com uma palavra
» x = 15 # um número inteiro
» y = 4.2 # um número de ponto flutuante
» z = 'Pedro' # uma palavra ou 'string'
# para ver o conteúdo das variáveis podemos usar o método print
» print(x)
↳ 15
» print(y)
↳ 4.2
» print(z)
↳ Pedro
# podemos ver de que tipo são essas variáveis
» print(type(x))
↳ <class 'int'>
» print(type(y))
↳ <class 'float'>
» print(type(z))
↳ <class 'str'>
# variáveis podem ser apagadas com
» del x
» print(x)
↳ NameError: name 'x' is not defined
O comando print() é uma função interna do python, e serve para exibir o conteúdo de seu parâmetro, no caso as variáveis x, y, z. Quando usamos o Jupyter Notebook uma variável ou expressão avaliada na última linha de uma célula é exibida quando a célula é executada, sem a necessidade de print.
Usamos type() para ver o tipo de conteúdo armazendo. Os tipos básicos do Python são:
Tipo
Exemplos
Nome no Python
Inteiros
1, -1, 67, -9900
int
Inteiros longos
123L, -999L
long integer
Ponto flutuante
1.0, 3.14, 345.6, -99.9
double float
Complexos
complex(1, 3), complex(“1+2j”), 1 + j
complex
Booleano
True, False
bool
String
‘casa’, “teste de string”
string, object
Com esses tipos básicos se constroi objetos mais complexos, como
Tipo
Exemplos
Nome no Python
Lista
[‘a’, ‘b’, ‘c’, ‘d’], [1, 2, 3]
list
Tupla
(‘a’, ‘b’, ‘c’, ‘d’), (1, 2, 3)
tuple
Dicionário
{1: ‘um’, 2: ‘dois’}
dictionary
Qualquer objeto do python pode ser associado a uma variável, que passa a ser uma representante ou “referência de acesso” a esse objeto. Os nomes de variáveis devem obedecer a algumas regras:
só podem conter números, letras e sublinhados (underscores)(A-z, 0-9 e _)
deve começar com uma letra ou sublinhado
maiúsculas e minúsculas são diferenciadas
A diferenciação de maiúsculas de minúsculas é válida para toda a linguagem. As variáveis idade, Idade, IDADE são três variáveis diferentes. Além disso existem as palavras reservadas (keywords) que são nomes que fazem parte da sintaxe da linguagem e não podem ser utilizadas para nomes de variáveis:
Palavras reservadas do python
and
except
lambda
with
as
finally
nonlocal
while
assert
false
None
yield
break
for
not
class
from
or
continue
global
pass
def
if
raise
del
import
return
elif
in
True
else
is
try
Como assumem o lugar dos objetos as variáveis podem ser usadas em lugar deles. Por ex., a operação abaixo faz um cálculo usando 2 variáveis e atribuindo o valor à uma terceria.
» largura = 2.20
» altura = 1.10
» area_retangulo = largura * altura
» print("A área de retângulo é: " , area_retangulo)
↳ A área de retângulo é: 2.42
Nomes de variáveis devem ser escolhidos de forma concisa e elucidativa de seu uso.
Os seguintes operadores matemáticos formam a base para as operações numéricas usuais.
Operador
significado
exemplo
+
Adição
x + y
–
Subtração
x – y
*
Multiplicação
x * y
/
Divisão
x / y
%
Módulo (resto da divisão inteira)
x % y
**
Exponentiação
x ** y
//
divisão inteira
x // y
Para verificar seu comportamento vamos fazer alguns testes.
# no python se pode declarar 2 variáveis (ou mais) simultaneamente
» x, y = 3, 8
» x+y
↳ 11
» x-y
↳ -5
» x*y
↳ 24
» y**x
↳ 512
» x/y
↳ 0.375
# 3 dividido por 8 é 0, com resto 3
» x % y
↳ 0
» x//y
↳ 3
Terminologia: Um comando ou declaração (statement, em inglês) é uma linha com uma instrução única. No código abaixo temos 4 declarações:
» incremento = 0.2
» valor = 10
» valor = valor + incremento
» print (valor)
↳ 10.20
Observe que, diferente das operações matemáticas usuais, a declaração x = x + 1 significa “somar 1 ao valor de x e substituir o resultado em x“.
Um atalho ou shortcut possível e muito usado é o seguinte:
# ao invés de escrever
» i = i + 1
# podemos escrever, como o mesmo efeito
» i += 1
# portanto
» valor = valor + incremento
# pode ser escrito como
» valor += incremento
Outros operadores análogos podem ser usados.
Operador
Exemplo
Equivale a
+=
Soma
a += 2
a = a + 2
-=
Subtração
a -= 2
a = a – 2
*=
Multiplicação
a *= 2
a = a * 2
/=
Divisão
a /= 2
a = a / 2
%=
Módulo
a %= 2
a = a % 2
**=
Expoente
a **= 2
a = a ** 2
//=
Divisão inteira
a //= 2
a = a // 2
Além dos operadores matemáticos temos os operadores lógicos. Os resultados de operações lógicas são booleanos (True ou False) e eles são a base das decisões feitas em códigos. Alguns desses operadores podem ser usados, como veremos, em outros objetos que não apenas números.
Foi sugerido o uso do Jupyter Notebook para o aprendizado do conteúdo nesse artigo. Isso permite interatividade e facilidade de instalação dos pacotes, bem como uma boa visualização das saídas de código. No entanto muitas vezes é necessário rodar blocos grandes de código sem preocupação com resultados e saídas intermediárias.
Arquivos contendo comandos python e gravados com a extensão *.py podem ser executados em qualquer máquina que tenha o intérprete instalado. Por exemplo, suponha que temos na pasta de trabalho ativa o arquivo teste.csv e queremos alterar o seu nome. Usando um editor ASCII qualquer, como o Notepad do Windows, Geany ou Gedit no Linux e TextEdit no Mac, gravamos um arquivo com o nome de alterarNome.py, com o seguinte conteúdo:
#!/usr/bin/env python
import os
for arq in os.listdir():
print(arq)
nome_antigo = 'teste.csv'
nome_novo = 'teste_novo.csv'
os.rename(nome_antigo, nome_novo)
Para executar esse arquivo abrimos uma sessão do terminal e digitamos:
» python alterarNome.py
A primeira linha contém o shebang (#!) com a instrução de onde está instalado o python em seu computador. Depois é importada a biblioteca os que contém comandos de interação com o sistema operacional. Seu método os.listdir() retorna uma lista com os arquivos na pasta atual, que são impressos dento do laço for. Se existir na pasta um arquivo teste.csv ele será renomeado para teste_novo.csv. Uma mensagem de erro será exibida se o arquivo teste.csv não existir.
Pandas é uma biblioteca do Python, de código aberto e com licença BSD, desenvolvida e mantida pelo PуDаtа Dеvеlорmеnt Tеаm. Ela fornece ferramentas de manipulação e análise estatística de dados, com capacidade de exibição gráfica, com extração de dados análogos (mas não idênticos) aos de consultas sql. [veja nesse site, sql.]
A biblioteca foi construída com Cython e, por isso, é bastante rápida. Ela se destinava inicialmente ao uso no setor financeiro para análise de séries temporiais, tendo se tornado uma ferramenta de uso comum na manipulação de dados, particularmente em data science e machine learning. Ela tem sido usada para substituir as planilhas do Excel, para processar dados sob forma tabular, importando com facilidade dados de arquivos csv ou json.
Os experimentos abaixo foram realizados no Jupyter Notebook. Você encontra nesse site um artigo sobre instalação e uso do Jupyter Notebook. As linhas de código e suas respostas, quando existirem, serão representadas da seguinte forma:
# Linhas de comentários (não serão numeradas)
In [n]: Linha de input n
Out[n]: Output da linha n
NumPy e matplotlib
NumPy é a abreviação de Numerical Python, a biblioteca base da computação numérica em Python. Ela fornece as estruturas de dados e algoritmos necessários para a maioria das aplicações científicas e de engenharia utilizando cálculo numérico. Entre outros objetos NumPy NumPy fornece
o objeto multidimensional ndarray onde se pode aplicar operações vetorializadas rápidas e eficientes,
um conjunto de funções para cálculos elementares com vetores e matrizes,
ferramentas de leitura e gravação de dados,
operações da álgebra linear, transformada de Fourier e geração de números aleatórios,
interação com C e C++.
Para dados numéricos as matrizes do NumPy são armazenadas e manipuladas de modo mais eficiente do que as demais estruturas do Python. Além disso códigos escritos em linguagens de baixo nível, como C ou Fortran, podem operar diretamente nos dados armazenados com o NumPy. Por isso muitas ferramentas de computação numérica do Python usam as matrizes NumPy como um estrutura de dados primária.
matplotlib é a biblioteca Python mais popular usada para a produção de gráficos e visualização de dados. Ela pode ser usada na geração de gráficos estáticos ou animados e visualização interativa.
Pandas
O pandas se utiliza basicamente de 3 objetos de armazenamento de dados com as seguintes estuturas:
Estrutura de dados dos objetos do pandas
Nome
dimensões
tabela
Series
1D
coluna (vetor)
DataFrame
2D
tabela (matriz)
Panel
3D
várias tabelas (matriz multidimensional)
As series e os dataframes são utilizados com maior frequência.
Para usar as bibliotecas dentro do código começamos com as importações
In [1]: import pandas as pd
In [2]: import numpy as np
Series
Uma series é um objeto unidimensional tipo um vetor que contém uma sequência de objetos do mesmo tipo. A essa sequência está associado um outro vetor de labels chamado de índice (index). O método básico de criação de séries é da seguinte forma:
s = pd.Series(data, index=index)
onde data pode ser um dict (um dicionário do Python), uma lista ou ndarray do numPy ou um escalar. index é uma lista de índices que, se omitida, é preenchida com inteiros iniciando em 0.
À esquerda estão listados os índices que, por default, são uma lista de inteiros começando por 0. Os valores podem ser listados com .values e os índices com .index.
In [4]: serie1.values
Out[4]: array([-1, 9, 0, 2, 5])
In [5]: serie1.index
Out[5]: RangeIndex(start=0, stop=5, step=1)
Os índices podem ser inseridos manualmente e não precisam ser inteiros. No input [8] um valor da serie é recuperado por seu índice, que é um string.
In [6]: serie2 = pd.Series([4, 7, -5, 3], index=['a', 'b', 'c', 'd'])
In [7]: serie2
Out[7]:
a 4
b 7
c -5
d 3
dtype: int64
In [8]: serie2['c']
Out[8]: -5
Uma série pode ser filtrada por meio de um argumento passado como outra serie booleana. Além disso operações podem ser realizadas sobre todos os elementos da série.
# O teste seguinte gera uma série de booleanos
In [9]: serie2 > 3
Out[9]:
a True
b True
c False
d False
dtype: bool
# Essa serie de True e False filtra a serie original
In [10]: serie2[serie2 > 3]
Out[10]:
a 4
b 7
dtype: int64
# Operações podem, ser realizadas sobre todos os elementos
In [11]: serie2 * 3
Out[11]: a 12
b 21
c -15
d 9
dtype: int64
# Numpy tem a função exponencial
In [12]: np.exp(serie2)
Out[12]:
a 54.598150
b 1096.633158
c 0.006738
d 20.085537
dtype: float64
Uma série se comporta, em muitos sentidos, como um dicionário. Uma série pode ser criada passando-se um dicionário como argumento para pd.Series().
In [13]: populacao = {
'Sudeste': 89012240,
'Nordeste': 57374243,
'Sul': 30192315,
'Norte': 18672591,
'Centro-Oeste':16504303
}
In [14]: serie3 = pd.Series(populacao)
In [15]: serie3
Out[15]:
Sudeste 89012240
Nordeste 57374243
Sul 30192315
Norte 18672591
Centro-Oeste 16504303
dtype: int64
# A ordem dos itens na série pode ser alterada fornecendo uma lista para o argumento index:
In [16]: ordem_alfabetica = ['Brasil', 'Nordeste', 'Norte', 'Centro-Oeste', 'Sudeste', 'Sul']
In [17]: serie4 = pd.Series(populacao, index=ordem_alfabetica)
In [18]: serie4
Out[18]:
Brasil NaN
Nordeste 57374243
Norte 18672591
Centro-Oeste 16504303
Sudeste 89012240
Sul 30192315
dtype: int64
# para verificar queis valores são nulos (NaN)
In [19]: pd.isnull(serie4)
Out[19]:
Brasil True
Nordeste False
Norte False
Centro-Oeste False
Sudeste False
Sul False
dtype: bool
# os seguintes registros são NaN
In [20]: serie4[pd.isnull(serie4)]
Out[20]:
Brasil NaN
dtype: float64
In [21]: serie4[pd.notnull(serie4)]
Out[20]:
Nordeste 57374243.0
Norte 18672591.0
Centro-Oeste 16504303.0
Sudeste 89012240.0
Sul 30192315.0
dtype: float64
In [21]: 'Brasil' in serie4
Out[21]: True
In [22]'USA' in serie4
Out[22] False
In [23]: serie4['USA']
Out[23]: KeyError
Como não existe no dicionário um valor para o índice ‘Brasil’ a série atribuiu o valor NaN (Not a Number para essa chave, a forma de NumPy e pandas parea indicar a ausência de um valor. O método retorna True ou False para cada item da série e pd.notnull() o seu inverso booleano. Alternativamente se pode usar o método das séries serie4.isnull().
Em diversos aspectos uma serie se parece com um dict. Por ex., podemos testar a existência de uma chave usando o comando in, como em In[21]. A tentativa de recuperar um valor com índice não existente, em In [23], gera uma exceção (um erro do Python).
Observe que uma series tem propriedades de numpy ndarray, mas é um objeto de tipo diferente. Se um ndarray é necessário use .to_numpy().
In [24]: type(serie4)
Out[24]: pandas.core.series.Series
In [25]: type(serie4.to_numpy())
Out[25]: numpy.ndarray
Series podem ser fatiadas com a notação serie[i:f] onde serão retornadas a i-ésima linha até a f-ésima, exclusive. Se i for omitido a lista se inicia em 0, se f for omitido ela termina no final.
In [26]: serie4
Out[26]:
Brasil NaN
Nordeste 57374243.0
Norte 18672591.0
Centro-Oeste 16504303.0
Sudeste 89012240.0
Sul 30192315.0
dtype: float64
In [27]: serie4[2:5]
Out[27]:
Norte 18672591.0
Centro-Oeste 16504303.0
Sudeste 89012240.0
dtype: float64
In [28]: serie4[:2]
Out[28]:
Brasil NaN
Nordeste 57374243.0
dtype: float64
In [29]: serie4[4:]
Out[29]:
Sudeste 89012240.0
Sul 30192315.0
dtype: float64
O resultado de operações envolvendo mais de uma serie alinha os valores por chaves (como uma UNION). Valores não presentes em um dos operandos terá NaN como resultado.
In [29]: serie5 = pd.Series([2, -1, -2, 1], index=['a', 'b', 'c', 'd'])
In [29]: serie6 = pd.Series([3, 4, 7, -1], index=['e', 'c', 'b', 'f'])
Out[29]: display(serie5, serie6)
a 2
b -1
c -2
d 1
dtype: int64
e 3
c 4
b 7
f -1
dtype: int64
In [29]: serie5 + serie6
Out[29]:
a NaN
b 6.0
c 2.0
d NaN
e NaN
f NaN
dtype: float64
Series possuem a propriedade name que pode ser atribuída na construção ou posteriormente com .rename().
In [30]: serie7 = pd.Series(np.random.randn(5), name='randomica')
In [31]: serie7
Out[31]:
0 -1.703662
1 1.406167
2 0.966557
3 -0.557846
4 -0.264914
Name: randomica, dtype: float64
In [32]: serie7.name
Out[32]:
'randomica'
In [33]: serie7= serie7.rename('aleatoria')
In [34]: serie7.name
Out[34]:
'aleatoria'
O nome de uma série se torna seu índice ou nome de coluna caso ela seja usada para formar um DataFrame.
Atributos e Métodos das Series
Os atributos e métodos mais comuns e úteis das Series estão listados abaixo. Para uma lista completa consulte pandas.Series: API Reference.
Atributos
Atributo
Descrição
at
Accesso a um valor específico em uma par linha/coluna
attrs
Retorna ditionario de atributos globais da series
axes
Retorna lista de labels do eixo das linhas
dtype
Retorna o tipo (dtype) dos objetos armazenados
flags
Lista as propriedades do objeto
hasnans
Informa se existem NaNs
iat
Acessa valor usando um inteiro como índice
iloc
Seleciona por posição usando índice inteiro
index
Retorna lita de índices
is_monotonic
Booleano: True se valores crescem de forma monotônica
is_monotonic_decreasing
Booleano: True se valores decrescem de forma monotônica
is_unique
Booleano: True se valores na series são únicos
loc
Acessa linhas e colunas por labels oo array booleano
name
O nome da Series
nbytes
Número de bytes nos dados armazenados
shape
Retorna uma tuple com forma (dimensões) dos dados
size
Número de elementos nos dados
values
Retorna Series como ndarray
Métodos
Método
Descrição
abs()
Retorna a Series com valor absoluto para cada elemento
add(serie2)
Soma a serie com serie2, elemento a elemento
add_prefix(‘prefixo’)
Adiciona prefixo aos labels com string ‘prefixo’
add_suffix(‘sufixo’)
Adiciona sufixo aos labels com string ‘sufixo’
agg([func, axis])
Agrega usando func sobre o eixo especificado
align(serie2)
Alinha 2 objetos em seus eixos usando método especificado
all([axis, bool_only, skipna, level])
Retorna se todos os elementos são True
any([axis, bool_only, skipna, level])
Retorna se algum elemento é True
append(to_append[, ignore_index, …])
Concatena 2 ou mais Series
apply(func[, convert_dtype, args])
Aplica func sobre todos os valores da series
argmax([axis, skipna])
Retorna posição (índice inteiro) do valor mais alto da Series.
argmin([axis, skipna])
Retorna posição (índice inteiro) do menor valor da Series.
argsort([axis, kind, order])
Retorna índices inteiros que ordenam valores da Series
asfreq(freq)
Converte TimeSeries para frequência especificada.
asof(where[, subset])
Retorna última linha anterores à ocorrência de NaNs antes de ‘where’
astype(dtype[, copy, errors])
Transforma objeto object para um dtype
at_time(time[, asof, axis])
Seleciona valores em determinada hora (ex., 9:30AM)
backfill([axis, inplace, limit, downcast])
Alias para DataFrame.fillna() usando method=’bfill’
between(min, max)
Retorna Series booleana satisfazendo min <= series <= max.
between_time(inicio, fim)
Seleciona valores com tempo entre inicio e fim
bfill([axis, inplace, limit, downcast])
Alias para DataFrame.fillna() usando method=’bfill’
clip([min, max, axis, inplace])
Inclui apenas valores no intervalo
combine(serie2, func[, fill_value])
Combina a Series com serie2 ou escalar, usando func
compare(serie2[, align_axis, keep_shape, …])
Compara com serie2 exibindo differenças
copy([deep])
Faça uma cópia desse objeto, índices e valores
corr(serie2)
Calcula a correlação com serie2, excluindo NaNs
count([level])
Retorna número de observações na Series, excluindo NaN/nulls
cov(serie2[, min_periods, ddof])
Calcula covariância da Series, excluindo NaN/nulls
cummax([axis, skipna])
Retorna máximo cumulativo
cummin([axis, skipna])
Retorna mínimo cumulativo
cumprod([axis, skipna])
Retorna o produto cumulativo
cumsum([axis, skipna])
Retorna a soma cumulativa
describe([percentiles, include, exclude, …])
Gera descrição estatística
div(serie2)
Retorna divisão de ponto flutuante da series por serie2, elemento a elemento
divmod(serie2)
Retorna divisão inteira e módulo da séries por serie2, elemento a elemento
dot(serie2)
Calcula o produto interno entre a Series e serie2
drop([labels])
Retorna Series com labels removidos
drop_duplicates([keep, inplace])
Retorna Series após remoção de valores duplicados
dropna()
Retorna Series após remoçaõ de valores faltantes
duplicated([keep])
Mostra os valores duplicados na Series
eq(serie2)
Retorna Series de boolenos comparando elemento a elemento com serie2
equals(serie2)
Boolenao: True se os dois objetos contém os mesmos elementos
ewm([com, span, halflife, alpha, …])
Calcula exponencial com peso
explode([ignore_index])
Transforma cada elemento de um objeto tipo lista em uma linha
Blair,Steve: Python Data Science, The Ultimate Handbook for Beginners on How to Explore NumPy for Numerical Data, Pandas for Data Analysis, IPython, Scikit-Learn and Tensorflow for Machine Learning and Business, edição do autor disponível na Amazon, 2019.
Harrison, Matt: Learning Pandas, Python Tools for Data Munging, Data Analysis, and Visualization,
edição do autor, 2016.
McKinney, Wes: pandas: powerful Python data analysistoolkit, Release 1.2.1
publicação do Pandas Development Team, revisado em 2021.
McKinney, Wes: Python for Data Analysis, Data Wrangling with Pandas, NumPy,and IPython
O’Reilly Media, 2018.
> “O poeta é um fingidor. Finge tão completamente que chega a fingir que é dor a dor que deveras sente.”
> ― Fernando Pessoa, Autopsicografia.
Markdown é uma linguagem de marcação de texto. Ele permite a insercão de códigos em ASCII que são renderizados em formatos mais sofisticados. Além disso ela permite a conversão para textos em HTML, que podem ser distribuídos pela web (ou localmente) e lidos por browsers. A marcação foi concebida para deixar o texto simples e legível. Markdown é software livre, disponível sob uma licença BSD de código aberto.
Markdown é uma linguagem de marcação de texto. Ele permite a insercão de códigos em ASCII que são renderizados em formatos mais sofisticados. Além disso ela permite a conversão para textos em HTML, que podem ser distribuídos pela web (ou localmente) e lidos por browsers. A marcação foi concebida para deixar o texto simples e legível. Markdown é software livre, disponível sob uma licença BSD de código aberto.
Markdown é uma linguagem de marcação de texto. Ele permite a insercão de códigos em ASCII que são renderizados em formatos mais sofisticados. Além disso ela permite a conversão para textos em HTML, que podem ser distribuídos pela web (ou localmente) e lidos por browsers. A marcação foi concebida para deixar o texto simples e legível. Markdown é software livre, disponível sob uma licença BSD de código aberto.
Títulos (Headings)
Para criar títulos use sinais # em frente ao texto (um para cada nível).
Markdown
html
Output obtido
# Título de nível 1
<h1>Título de nível 1</h1>
(título de nível 1)
## Título de nível 2
<h2>Título de nível 2</h2>
(título de nível 2)
### Título de nível 3
<h3>Título de nível 3</h3>
(título de nível 3)
#### Título de nível 4
<h4>Título de nível 4</h4>
(título de nível 4)
##### Título de nível 5
<h5>Título de nível 5</h5>
(título de nível 5)
###### Título de nível 6
<h6>Título de nível 6</h6>
(título de nível 6)
Parágrafos
Parágrafos são linhas de texto separadas por linhas vazias.
Markdown
html
Output obtido
Markdown é simples.
Vou usá-lo sempre!
<p>Markdown é simples.</p>
<p>Vou usá-lo sempre!</p>
Markdown é simples.
Vou usá-lo sempre!
Quebra de linhas
Para quebrar uma linha termine a linha com 2 ou mais espaços (⎵ ⎵) seguidos de return (↲).
Markdown
html
Output obtido
Essa é a primeira linha. ⎵⎵↲
Essa é a segunda linha.
<p>Essa é a primeira linha.<br>
Essa é a segunda linha.</p>
Essa é a primeira linha.
Essa é a segunda linha.
Negrito e itálico
Texto em negrito é obtido com asteriscos ou traços baixos (underscores) envolvendo o texto a negritar. Letras dentro da palavra também podem ser negritadas com duplos asteriscos.
Markdown
html
Output obtido
Precisamos de **negrito**.
Precisamos de <strong>negrito</strong>.
Precisamos de negrito.
Precisamos de __negrito__.
Precisamos de <b>negrito</b>.
Precisamos de negrito.
abcdef**GH**ij
abcdef<strong>GH</strong>ij
abdcefGHij
Textos em itálico são obtidos com um asterisco ou uma traço baixo (underscores) envolvendo o texto. Letras dentro da palavra também podem ser tornadas itálicos com um asterisco.
Markdown
html
Output obtido
Texto *em itálico*.
Texto <em>em itálico</em>.
Texto em itálico.
Texto _em itálico_.
Texto <i>em itálico</i>.
Texto em itálico.
a*bcd*ef
a<em>bcd</em>ef
abcdef
Texto em negrito e itálico simultâneos são obtidos com três asteriscos ou traços baixos (underscores) envolvendo o texto. Letras dentro da palavra também podem ser negritadas com três asteriscos.
Markdown
html
Output obtido
Um texto ***muito importante***.
Um texto <strong><em>muito importante</em></strong>.
Um texto muito importante.
Um texto ___muito importante___.
Um texto <b><i>muito importante</i></b>.
Um texto muito importante.
Um texto __*muito importante*__.
Um texto <i><b>muito importante</b></i>.
Um texto muito importante.
Um texto **_muito importante_**.
…idem…
Um texto muito importante.
Texto***muito***importante.
Texto<strong><em>muito</em></strong>importante.
Textomuitoimportante.
Textos riscados são obtidos com dois “tils” ˜˜ anterior e posterior ao texto.
Markdown
html
Output obtido
Texto ˜˜riscado˜˜.
Texto <del>riscado</del>.
Texto riscado.
Linha horizontal
Linhas horizontais são inseridas com três ou mais asteriscos (***), ‘dashes’ (---), ou ‘underscores’ (___) em uma linha.
Markdown
html
Output obtido
***
<hr>
Blocos
Para criar blocos destacados (citações) coloque > na frente do parágrafo.
> “O poeta é um fingidor. Finge tão completamente que chega a fingir que é dor a dor que deveras sente.”
> ― Fernando Pessoa, Autopsicografia.
“O poeta é um fingidor. Finge tão completamente que chega a fingir que é dor a dor que deveras sente.”
― Fernando Pessoa, Autopsicografia.
Blocos destacados podem conter muitos parágrafos. Para isso basta inserir > em cada linha branca entre as parágrafos.
> “Nós, os mortais, alcançamos a imortalidade nas coisas que criamos em comum e que estão atrás de nós.”
>
> “A coisa mais bela que podemos experimentar é o mistério. Essa é a fonte de toda a arte e ciências verdadeiras.”
> ― Albert Einstein.
“Nós, os mortais, alcançamos a imortalidade nas coisas que criamos em comum e que estão atrás de nós.”
“A coisa mais bela que podemos experimentar é o mistério. Essa é a fonte de toda a arte e ciências verdadeiras”.
― Albert Einstein.
Blocos ou citações podem ser aninhadas. Para isso coloque >> na frente do parágrafo com segunda indentação.
> “Eu jamais iria para a fogueira por uma opinião minha pois não tenho certeza alguma. Porém, eu iria pelo
direito de ter e mudar de opinião, quantas vezes quisesse.”
>
>> ”Sem música a vida seria um erro.”
> ― Friedrich Nietzsche
“Eu jamais iria para a fogueira por uma opinião minha pois não tenho certeza alguma. Porém, eu iria pelo direito de ter e mudar de opinião, quantas vezes quisesse.”
“Sem música a vida seria um erro.”
― Friedrich Nietzsche
Listas
Listas ordenadas são criadas numerando-se as linhas, cada número seguido de ponto. Qualquer número serve para isso:
Markdown
html
Output obtido
1. Primeiro item
2. Segundo item
3. Terceiro item
4. Quarto item
Uma anotação apropriada para código, principalmente de programação, é uma característica muito útil no markdown. A indentação correta para blocos de código pode ser conseguida com linhas precedidas por 4 espaços (⎵) ou 1 tab. Dentro de uma lista essas linhas são precedidas por 8 espaços ou 2 tabs. No exemplo abaixo usamos ⎵ como marcação para espaços:
Markdown
html
Output obtido
⎵⎵⎵⎵def soma(a,b):
⎵⎵⎵⎵⎵⎵⎵⎵return a + b
⎵⎵⎵⎵print (soma(5, 7))
<pre>
def soma(a,b):
return a + b
print (soma(5, 7))
</pre>
def soma(a,b):
return a + b
print (soma(5, 7))
Alternativamente, blocos de código também podem ser colocados entre três acentos graves, backticks, ```:
Markdown
Output obtido
“`
function factorial(n) {
if (n === 0) return 1; // 0! = 1
return n * factorial(n – 1);
}
factorial(3); // returns 6}
“`
function factorial(n) {
if (n === 0) return 1; // 0! = 1
return n * factorial(n – 1);
}
factorial(3); // returns 6}
Nesse formato de bloco de código é possível marcar o código com cores, de acordo com a linguagem selecionada (syntax highlighting). Essa característica depende do processador usado. No exemplo seguinte o código é marcado como JSON, o que é informado após o primeiro grupo de acentos graves.
A tabela (2) ilustra o uso dos sinais de alinhamento: à esquerda (:‐‐), centralizado (:‐‐:) (centralizado) e à direita (‐‐:). Os itens da tabela não precisam estar bem alinhados no markdown e as barras laterais são dispensáveis, como é mostrado na tabela (3). Dentro das tabelas o texto pode conter links, negrito e itálico e código.
Links
Links para outras páginas, locais ou na web, podem ser inseridos dentro de colchetes (ex.: [Duck Duck Go]) seguidos da URL entre parênteses. Por ex. (https://duckduckgo.com)).
Markdown
html
Output obtido
Recomendo o mecanismo de busca_ _
[Duck Duck Go](https://duckduckgo.com).
Recomendo o mecanismo de busca <br>
<a href=”https://duckduckgo.com”>Duck Duck Go</a>.
Segue um exemplo de texto com notas de pé de página.
Use a seguinte notação para criar pés de página[^1], que também pode conter textos mais longos e várias parágrafos[^2].
Os marcadores não precisam ser números[^t].[^1]: O pé de página fica no final do texto.
[^2]: Um pé de página pode ter vários parágrafos.
Todos os parágrafos dentro da mesma nota devem ser indentados.
`{ function teste(a, b): # pode conter código e outras formatações. }`
[^t]: Outro pé de página.
Esse código é renderizado da seguinte forma (com os links efetivos):
Use a seguinte notação para criar pés de página[1], que também pode conter textos mais longos e várias parágrafos[2].
Os marcadores não precisam ser números[3].
1. O pé de página fica no final do texto.↵
2. Um pé de página pode ter vários parágrafos.
Todo o texto dentro do mesma anotação deve ser indentado. { function teste(a, b): # pode conter código e outras formatações. }↵
3. Outro pé de página.↵
Lista de tarefas
O código abaixo gera a lista mostrada à direita.
## Lista de Tarefas
- [x] Tarefa primeira (completa)
- [ ] Tarefa segunda
- [ ] Arranjar outras **tarefas**
Lista de Tarefas
☑ Tarefa primeira (completa)
☐ Tarefa segunda
☐ Arranjar outras tarefas
HTML
Vários dos aplicativos que usam Markdown, entre eles o Jupyter Notebook, podem renderizar corretamente diversas tags de marcação html. Isso é útil para usuários familiarizados com html, principalmente quando se pretende inserir texto com formatos mais sofisticados, tais como como texto colorido, com variação de tamanho, caixas coloridas, etc.
Como exemplo, o código abaixo produzirá uma barra vermelha, útil para marcar o ponto de parada dentro de um notebook (Jupyter). Outro exemplo consiste na produção de texto sublinhado. Como não há código markdown específico para isso você pode conseguir texto sublinhado com as tags html.
LaTeX é uma linguagem de composição de texto para a produção de documentos científicos. Vários editores de Markdown podem renderizar equações matemáticas e símbolos Latex para reproduzir notação matemática. Em particular o Jupyter Notebook reconhece código LaTeX escrito nas células de Markdown e os renderiza corretamente no navegador usando a biblioteca JavaScript MathJax. Para inserir uma fórmula matemática em uma linha use o símbolo $expressão$. Para equações isoladas em uma linha e centralizadas use $$expressão$$.
A identidade de Euler é $e^{i \pi} + 1 = 0$.
As equações de Einstein são: $$
R_{\mu\nu}-\frac{1}{2} Rg_{\mu\nu} +\Lambda g_{\mu\nu} = \frac{8 \pi G}{c^4} T_{\mu\nu}. $$
A definição da derivada de primeira ordem é: $$
f'(x) = \lim\limits_{h \rightarrow 0} \frac{f(x+h) – f(x)}{h} $$
A identidade de Euler é \(e^{i \pi} + 1 = 0\).
As equações de Einstein são:
$$
R_{\mu\nu}-\frac{1}{2} Rg_{\mu\nu} +\Lambda g_{\mu\nu} = \frac{8 \pi G}{c^4} T_{\mu\nu}.
$$
A definição da derivada de primeira ordem é:
$$
f'(x) = \lim\limits_{h \rightarrow 0} \frac{f(x+h) – f(x)}{h}
$$
Entidades HTML são códigos usados para a exibição de símbolos que não estão diretamente acessíveis pelo teclado, dentro de uma página de HTML (páginas da WEB). Eles podem representar caracteres técnicos, matemáticos, símbolos de moedas, sinais gráficos e muitos outros. A tabela lista os códigos htmlhexadecimal e decimal. Por exemplo, a página:
<html>
<body>
<h1>Exibindo html </h1>
<p>Símbolo de um naipe espada de baralho: ♣ - ♣ - &♣; - ♣.</p>
<p>Símbolo matemático da integral de contorno: ∮ - ∮ - ∮ - ∮.
</body>
</html>
seria exibida da seguinte forma (dependendo, é claro, das instruções css da página:
Exibindo html
Símbolo de um naipe espada de baralho: ♣ – ♣ – ♣ – ♣.
Símbolo matemático, integral de contorno: ∮ – ∮ – ∮ – ∮.
Nem todos os browsers podem exibir corretamente todos os símbolos. Um código na primeira coluna da tabela representa uma falha de exibição. Passe o mouse sobre os caracteres da 1ª coluna para ampliar.
Esta é uma seção mais técnica que pode ser lida por último. Nesse caso pule para a seção Aquisição de Dados.
Esta seção apresenta uma formalização um pouco mais rigorosa dos conceitos do R como linguagem de programação. Em uma primeira leitura, para aqueles que ainda estão se familiarizando com a linguagem, ela pode ser pulada e lida mais tarde. Ela contém um pouco de repetição do material já visto, para fins de completeza.
Objetos
R é uma linguagem de programação de array, funcional e orientada a objeto. Todos os elementos de R, variáveis de dados e funções, são objetos. Não se pode acessar locais da memória diretamente e todos os objetos usados na execução de um programa são armazenados em memória RAM. Isso acaba tendo um peso importante quando se processa um grande volume de dados.
Linguagens de programação de arrays (também chamadas de linguagens vetoriais ou multidimensionais) são linguagens onde operações sobre objetos multidimensionais (vetores, matrizes, etc.) generalizam as operações sobre escalares de forma transparente. Elas permitem um código mais conciso e legível.
Todos os objetos possuem atributos que são meta-dados descrevendo suas características. Estes atributos podem ser listados com a função attributes() e definidos com a função attr(). Um desses atributos, bastante importante, é a classe de um objeto pois as funções de R usam essa informação para determinar como o objeto deve ser manipulado. A classe de um objeto pode ser lida ou alterada com a função class().
Existem os seguintes tipos de dados: Lógico ou booleano (logic), numérico (numeric), inteiro (integer), complexo (complex), caracter (character) e Raw.
Estes dados podem ser agrupados em estruturas de dados. Existem dois tipos fundamentais de estruturas: vetores atômicos e vetores genéricos. Vetores atômicos são matrizes de qualquer dimensão contendo um único tipo de dados. Vetores genéricos são também chamados de listas e são compostas por vetores atômicos. Listas são recursivas, no sentido de que podem conter outras listas.
Uma variável não precisa ser inicializada nem seu tipo declarado, sendo determinado implicitamente a partir do conteúdo do objeto. Seu tamanho é alterado dinamicamente.
Não existe o tipo “escalar” em R. Um escalar é simplesmente um vetor com um único elemento. Portanto a atribuição u <- 1 é apenas um atalho para u <- c(1).
Uma matriz é um vetor atômico acrescentado de um atributo dim com dois elementos (o número de linhas e de colunas). No exemplo seguinte, um vetor é transformado em uma matriz e depois recuperado como vetor:
> v <- 1:12
> print(v)
[1] 1 2 3 4 5 6 7 8 9 10 11 12
> class(v)
[1] "integer"
> x <- c(1,2,3,4,5,6,7,8)
> class(x)
[1] "numeric"
> attr(v, "dim") <- c(2,6)
> print(v)
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 3 5 7 9 11
[2,] 2 4 6 8 10 12
> class(v)
[1] "matrix"
> # Um atributo arbitrário pode ser incluído
> attr(v, "nome") <- "minha matriz"
> attributes(v)
$dim
[1] 2 6
$nome
[1] "minha matriz"
> attr(v, "nome") <- NULL # o atributo é removido
> attributes(v)
$dim
[1] 2 6
> # Um atributo pode ser alterado
> dim(v) <- c(3,4)
> print(v)
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> # Removido o atributo "dim" v volta a ser um vetor
> attr(v, "dim") <- NULL
> v
[1] 1 2 3 4 5 6 7 8 9 10 11 12
A atribuição v <- 1:4 é idêntica à v <- c(1:4) e análoga, mas não idêntica à v <- c(1, 2, 3, 4). Nos dois primeiros casos o resultado é um vetor de inteiros. No terceiro temos um vetor numérico (de ponto flutuante).
Existem funções para a marcação de atributos: dim(), dimnames(), names(), row.names(), class() e tsp() (usado para a criação de séries temporais). Estas funções são preferíveis à simplesmente usar attr(vetor, "atributo") porque fazem um tratamento e análise dos parâmetros usados, emitindo notificações de erros mais detalhadas.
A igualdade entre objetos atômicos pode ser testada com o uso do operador ==, que verifica recursivamente a identidade de cada um dos elementos dos objetos comparados, ou da função identical(), que verifica a igualdade completa entre os dois objetos.
> a <- c(1,3,5); b <- c(1,3,5); c <- c(1,2,5)
> a==b
[1] TRUE TRUE TRUE
> a==c
[1] TRUE FALSE TRUE
> identical(a,b)
[1] TRUE
> identical(a,c)
[1] FALSE
Listas e Data Frames
As listas são coleções de vetores atômicos, não necessariamente de mesmo tipo. Elas são recursivas no sentido de que podem ter outras listas como seus elementos. Data frames são listas onde todos os vetores possuem o mesmo comprimento. Muitas funções recebem listas como argumentos ou retornam listas.
Para exemplificar vamos usar uma lista contendo as 5 primeiras observações do data frame warpbreaks, com 3 variáveis.
> quebras <- head(warpbreaks, n=5)
> quebras
breaks wool tension
1 26 A L
2 30 A L
3 54 A L
4 25 A L
5 70 A L
> # Usamos unclass() para ver seus componentes
> unclass(quebras)
$breaks
[1] 26 30 54 25 70
$wool
[1] A A A A A
Levels: A B
$tension
[1] L L L L L
Levels: L M H
attr(,"row.names")
[1] 1 2 3 4 5
> # Usamos attributes() para ver seus atributos
> attributes(quebras)
$names
[1] "breaks" "wool" "tension"
$row.names
[1] 1 2 3 4 5
$class
[1] "data.frame"
A igualdade entre objetos não atômicos não é implementado com o operador ==. Neste caso é necessário usar a função identical(), que verifica a igualdade completa entre os dois objetos.
> u <- list(v1=1,v2=2); v <- u
> v==u
Error in v == u : comparison of these types is not implemented
> identical(u,v)
[1] TRUE
> # identical testa a identidade entre quaisquer dois objetos:
> f <- function(x,y) x+y; g <- function(x,y) x+y
> identical(f,g)
[1] TRUE
Agrupamento k-means é um método de agrupamento de dados muito utilizado em data mining que busca realizar uma partição de um número de observações em k grupos próximos de uma média comum. O resultado é o particionamento do espaço de dados nas chamadas células de Voronoi.
A função unclass() retorna uma cópia de seu argumento sem seus atributos de classe. attributes() retorna uma lista com os atributos de seu argumento.
Selecionar partes de uma lista é uma operação importante em R. Para ilustrar algumas operações vamos usar o data frameiris que é uma lista contendo 5 vetores atômicos. Ela contém os campos (ou observações) Sepal.Length, Sepal.Width, Petal.Length, Petal.Width e Species. Relembrando, a função unclass(iris) exibe todos os valores em cada campo e seus atributos, separadamente. A função attributes(iris) exibe apenas os atributos. No exemplo abaixo aplicamos o agrupamento K-means usando a função kmeans(). Em seguida exploramos o objeto retornado que é uma lista.
> head(iris, n=2)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1 5.1 3.5 1.4 0.2 setosa
2 4.9 3.0 1.4 0.2 setosa
> # Para selecionar apenas os 4 primeiros campos usamos iris[1:4]
> kGrupo <- kmeans(iris[1:4],3)
> typeof(kGrupo) # para ver de que tipo é o objeto
[1] "list"
> length(kGrupo) # kGrupo é uma lista com 9 elementos
[1] 9
> print(kGrupo) # para listar todos os elementos do objeto
K-means clustering with 3 clusters of sizes 50, 38, 62
Cluster means:
Sepal.Length Sepal.Width Petal.Length Petal.Width
1 5.006000 3.428000 1.462000 0.246000
2 6.850000 3.073684 5.742105 2.071053
3 5.901613 2.748387 4.393548 1.433871
Clustering vector:
[1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
[31] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 3 3 2 3 3 3 3 3 3 3
[61] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 3 3 3 3 3 3 3 3 3 3 3 3
[91] 3 3 3 3 3 3 3 3 3 3 2 3 2 2 2 2 3 2 2 2 2 2 2 3 3 2 2 2 2 3
[121] 2 3 2 3 2 2 3 3 2 2 2 2 2 3 2 2 2 2 3 2 2 2 3 2 2 2 3 2 2 3
Within cluster sum of squares by cluster:
[1] 15.15100 23.87947 39.82097
(between_SS / total_SS = 88.4 %)
Available components:
[1] "cluster" "centers" "totss" "withinss" "tot.withinss" "betweenss"
[7] "size" "iter" "ifault"
> str(kGrupo)
List of 9
$ cluster : int [1:150] 1 1 1 1 1 1 1 1 1 1 ...
$ centers : num [1:3, 1:4] 5.01 6.85 5.9 3.43 3.07 ...
..- attr(*, "dimnames")=List of 2
.. ..$ : chr [1:3] "1" "2" "3"
.. ..$ : chr [1:4] "Sepal.Length" "Sepal.Width" "Petal.Length" "Petal.Width"
$ totss : num 681
$ withinss : num [1:3] 15.2 23.9 39.8
$ tot.withinss: num 78.9
$ betweenss : num 603
$ size : int [1:3] 50 38 62
$ iter : int 2
$ ifault : int 0
- attr(*, "class")= chr "kmeans"
> # A lista contém os seguintes atributos
> attributes(kGrupo)
$names
[1] "cluster" "centers" "totss" "withinss" "tot.withinss"
[6] "betweenss" "size" "iter" "ifault"
$class
[1] "kmeans"
> # sapply(objeto, class) exibe a classe de cada elemento na lista
> # A função sapply é tratada com maiores detalhes na próxima seção
> sapply(kGrupo, class)
cluster centers totss withinss tot.withinss betweenss
"integer" "matrix" "numeric" "numeric" "numeric" "numeric"
size iter ifault
"integer" "integer" "integer"
> # Podemos visualizar simultaneamente o segundo elemento, "centers"
> # que fornece uma matriz com os valores do centro de cada agrupamento
> e size, 7º elemento, com o número de pontos em cada grupo
> kGrupo[c(2,7)]
$centers
Sepal.Length Sepal.Width Petal.Length Petal.Width
1 5.006000 3.428000 1.462000 0.246000
2 6.850000 3.073684 5.742105 2.071053
3 5.901613 2.748387 4.393548 1.433871
$size
[1] 50 38 62
> # Para visualizar o segundo componente da lista kGrupo,
> # que é uma matriz, usamos
> kGrupo[2]
$centers
Sepal.Length Sepal.Width Petal.Length Petal.Width
1 5.006000 3.428000 1.462000 0.246000
2 6.850000 3.073684 5.742105 2.071053
3 5.901613 2.748387 4.393548 1.433871
> # Para ver apenas os componentes desta matriz:
> kGrupo[[2]]
Sepal.Length Sepal.Width Petal.Length Petal.Width
1 5.006000 3.428000 1.462000 0.246000
2 6.850000 3.073684 5.742105 2.071053
3 5.901613 2.748387 4.393548 1.433871
> # O mesmo resultado seria obtido por kGrupo$centers
> # Para listar a primeira linha da matriz
> kGrupo[[2]][,1]
1 2 3
5.006000 6.850000 5.901613
> # Para listar a primeira coluna da matriz
> kGrupo[[2]][1,]
Sepal.Length Sepal.Width Petal.Length Petal.Width
5.006 3.428 1.462 0.246
> # Para listar o primeiro elemento da primeira linha
> kGrupo[[2]][1,1]
[1] 5.006
> # que é o mesmo que kGrupo$centers[1,1]
Funções em R
Quase tudo em R é uma função. Até os operadores comuns são funções. A declaração 2 + 3 é, na verdade, uma forma sintética para "+"(2, 3).
> '+'(2,3)
[1] 5
> "*"(13, 9)
[1] 117
Em funções, parâmetros são passados por valor e não por referência. Isso significa que um objeto passado como parâmetro é copiado e a cópia passada para a função. O objeto original não é alterado. Além disso variáveis definidas no corpo de funções são locais e não podem ser usadas fora dela. Para tornar globa uma variável usada dentro de uma função podemos usar o operador de "super atribuição" <<-. Considere, por exemplo, o código abaixo.
> f <- function(x) x <- x^2
> u <- c(1,2,3)
> v <- f(u)
> v
[1] 1 4 9
> u
[1] 1 2 3
> # x é local à função
> print(x)
Error: object 'x' not found
> # Se necessário tornar x global fazemos
> f <- function(x) x <<- x^2
> v <- f(x)
> x
[1] 1 4 9
Funções podem ser usadas recursivamente (ou sejam, podem fazer chamadas a si mesmas). Dois exemplos são mostrados abaixo: o primeiro calcula o fatorial de um inteiro, o segundo exibe a sequência de Fibonacci com n elementos.
> fatorial <- function(x) {
if (x == 0) return (1)
else return (x * fatorial(x-1))
}
> fatorial(0)
[1] 1
> fatorial(6)
[1] 720
> # Obs.: a mesma função poderia ser definida em forma mais compacta como
> fatorial <- function(x) ifelse (x == 0, 1, x * fatorial(x-1))
> # A sequência de Fibonacci:
> fibonacci <- function(n) {
if(n <= 0) return("Nada")
fib <- function(m) ifelse(m <= 1, m, fib(m-1) + fib(m-2))
seq <- c(0)
if (n>1) { for(i in 1:(n-1)) seq[i+1] <- fib(i) }
print("Sequência de Fibonacci:")
print(seq)
}
> fibonacci(9)
[1] "Sequência de Fibonacci:"
[1] 0 1 1 2 3 5 8 13 21
Funções apply(), lapply(), sapply(), tapply()
A função apply() recebe como argumentos uma coleção de objetos (data frame, lista, vetor, etc.), o parâmetro MARGIN (que informa onde será aplicada a função) e uma função (qualquer função pode ser usada). Ela serve para executar alguma operação sobre essa coleção. Seu objetivo é principalmente o de evitar o uso de laços ou loops. Ela tem a seguinte estrutura:
apply(X, MARGIN, FUN)
onde:
x: uma matriz ou array
MARGIN=n : onde n = 1 ou 2, definindo onde a função será aplicada:
se n=1: a função será aplicada nas linhas
se n=2: função aplicada nas colunas
se n=c(1,2): função aplicada nas linhas e colunas
FUN: define função a ser usada.
Podem ser funções internas (mean, median, sum, min, max, ...)
ou definidas pelo usuário
> # Usando a matriz v, já definida:
> print(v)
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> # A média das colunas
> apply(v,2,mean)
[1] 2 5 8 11
> # A soma das colunas
> apply(v,2,sum)
[1] 6 15 24 33
> minimosNasLinhas <- apply(v, 1, min)
> print(minimosNasLinhas)
[1] 1 2 3
A função lapply() recebe como argumentos uma coleção de objetos (data frame, lista, etc.) e uma função. Ela executa a função sobre todos os elementos da coleçao e retorna um objeto do tipo lista:
lapply(X, FUN)
onde:
X: vetor, lista, data frame, ...
FUN: Função a ser aplicada a cada elemento de X
Podem ser funções internas ou definidas pelo usuário
Para exemplificar aplicaremos a função tolower() para reduzir a letras minúsculas todas as palavras de um vetor de caracteres:
> partes <- c("RODAS","MOTOR","CARBURADOR","PNEUS")
> partesMinuscula <- lapply(partes, tolower)
> print(partesMinuscula)
[[1]]
[1] "rodas"
[[2]]
[1] "motor"
[[3]]
[1] "carburador"
[[4]]
[1] "pneus"
> # Esta lista pode ser convertida em um vetor usando-se unlist:
> partesMinuscula <- unlist(partesMinuscula)
> print(partesMinuscula)
[1] "rodas" "motor" "carburador" "pneus"
A função sapply() recebe como argumentos uma coleção de objetos (data frame, lista, etc.) e uma função. Ela age da mesma forma que lapply() mas retorna um vetor ou uma matriz:
sapply(X, FUN)
onde:
X: vetor, lista, data frame, ...
FUN: Função a ser aplicada a cada elemento de X
Podem ser funções internas ou definidas pelo usuário
Usaremos a função sapply() com o data frame cars que traz uma coleção de observações sobre velocidades e distâncias percorridas até repouso em cada velocidade em automóveis (em 1920) para encontrar os valores mínimos em cada coluna:
> # para ver a estrutura do data frame:
> str(cars)
'data.frame': 50 obs. of 2 variables:
$ speed: num 4 4 7 7 8 9 10 10 10 11 ...
$ dist : num 2 10 4 22 16 10 18 26 34 17 ...
> lMinimos <- lapply(cars, max)
> sMinimos <- sapply(cars, max)
> print(lMinimos)
$speed
[1] 25
$dist
[1] 120
> print(sMinimos)
speed dist
25 120
O exemplo abaixo mostra o uso de lapply() e sapply() junto com uma função do usuário. Ela retorna os valores do data frame que estão abaixo da média em cada coluna. Neste caso elas retornam valores iguais, como se pode ver com o uso de identical():
A função tapply() calcula um valor usando uma função (mean, median, min, max, ...) sobre os dados de um objeto agrupados para cada valor de uma variável de fator dada.
tapply(X, INDEX, FUN = NULL)
onde:
X: um objeto, geralmente um vetor
INDEX: uma lista contendo fatores
FUN: a função a ser aplicada sobre os elementos de X
Para ilustrar o uso desta função vamos usar o data frame irisCalculamos primeiro a média dos comprimentos de sépalas para todas as espécies. Depois calculamos as médias para cada espécie em separado, setosa, versicolor, virginica.
Em seguida usamos o data frame mtcars para calcular o consumo médio dos carros, agrupados por número de cilindros (cyl = 4, 6, 8) e tipos de transmissão, am = 0 (automático), 1 = (manual).
> attach(iris)
> # O comprimento médio de todas as sépalas é
> mean(Sepal.Length)
[1] 5.843333
> # O comprimento médio das sépalas agrupadas por espécie:
> tapply(Sepal.Length, Species, mean)
setosa versicolor virginica
5.006 5.936 6.588
> detach(iris)
> # Usando mtcars:
> attach(mtcars)
> # O consumo médio para todos os carros é
> mean(mtcars$mpg)
[1] 20.09062
> # O consumo médio dos carros, agrupados por cilindros e tipo de transmissão
> tapply(mpg, list(cyl, am), mean)
0 1
4 22.900 28.07500
6 19.125 20.56667
8 15.050 15.40000
> # Para efeito de conferência, calculamos a media de mpg para am=0 e cyl=8
> L <- mtcars[cyl==8 & am==0,]
> # L contém apenas carros com am=0 e cyl=8
> mean(L$mpg)
[1] 15.05
> detach(mtcars)
Lembramos que em R os índices começam em 1 e não 0, como em muitas outras linguagens.
Ambientes (environments) e escopo
R armazena seus objetos em memória RAM dentro de ambientes ou environments. Um environment fica definido por uma lista que associa os nomes dos objetos nele carregados com seus valores. Eles existem principalmente para organizar estes objetos e a forma como R os encontra. Cada ambiente está ligado a um pai (um parent environment) fazendo com que os ambientes formem uma estrutura de árvore que termina no ambiente de nível mais alto que se chama R_EmptyEnv. Quando se inicia uma sessão o R se encontra no ambiente global, global environment, denominado R_GlobalEnv, também chamado de área de trabalho do usuário. Quando o nome de um objeto é invocado em código o interpretador de R busca na lista do ambiente atual, que pode ser visto com a função environment(). Se não encontrado o nome é procurado no ambiente pai, e assim sucessivamente, até que o último é alcançado.
Um novo ambiente pode ser criado com a função new.env() e objetos dentro deste ambiente com a função assign(). Estes objetos podem ser recuperados através da função get() ou da notação ambiente$variavel. A função exists("variavel", envir = ambiente) verifica a existência de variavel no ambiente, enquanto os objetos em um ambiente são listados com ls(ambiente), como se ilustra abaixo:
> environment() # exibe ambiente atual
<environment: R_GlobalEnv>
> var <- "este objeto está em Global Env" # cria objeto em Global_Env
> novoEnv <- new.env()
> assign(var, "novo objeto em novoEnv", env=novoEnv)
> ls()
[1] "novoEnv" "var"
> var
[1] "este objeto está em Global Env"
> get(var, env=novoEnv)
[1] "novo objeto em novoEnv"
> # A notação de "$" pode ser usada:
> novoEnv$var <- " outro valor para objeto em novoEnv"
> var
[1] " este objeto está em Global_env"
> novoEnv$var
[1] " outro valor para objeto em novoEnv"
> cat("var em global_env -->", var, "\nvar em novoEnv -->", novoEnv$var)
var em global_env --> este objeto está em Global Env
var em novoEnv --> novo objeto em novoEnv
> # Para ver o ambiente pai de novoEnv
> parent.env(novoEnv)
<environment: R_GlobalEnv>
> novoEnv$x <- 1 $ insere nova variável no ambiente
> ls(envir=novoEnv)
[1] "var" "x"
> exists("x", envir = novoEnv)
[1] TRUE
> # Um ambiente pode ser criado como filho de qualquer outro ambiente
> e2 <- new.env(parent = outroEnv)
> parent.env(e2)
> # Uma variável será criada em e2
> e2$teste <- 123
> # e2 é filho de novoEnv que está em R_GlobalEnv
> # A variável teste não será encontrada em R_GlobalEnv (pois reside em um nível abaixo)
> teste
Error: object 'teste' not found
> # O objeto está no ambiente e2
> e2$teste
[1] 123
> # Para testar se um objeto é um ambiente
> is.environment(e2)
[1] TRUE
> # Observe que a variável que contém o ambiente global é .GlobalEnv
> is.environment(.GlobalEnv)
[1] TRUE
> # Seu atributo name é "R_GlobalEnv"
> environmentName(environment())
[1] "R_GlobalEnv"
A função abaixo percorre os ambientes de modo hierárquico à partir de R_GlobalEnv subindo para os pais até o último ambiente, R_EmptyEnv que é o último ambiente, sem pai. A função search() exibe os ambientes na ordem hierárquica, a mesma ordem usada para a procura de um objeto.
> exibirArvore <- function() {
a <- environment()
repeat {
print(environmentName(a))
if (environmentName(a) == "R_EmptyEnv") break
a <- parent.env(a)
}
}
> exibirArvore()
[1] ""
[1] "R_GlobalEnv"
[1] "tools:rstudio"
[1] "package:stats"
[1] "package:graphics"
[1] "package:grDevices"
[1] "package:utils"
[1] "package:datasets"
[1] "package:methods"
[1] "Autoloads"
[1] "base"
[1] "R_EmptyEnv"
> # A função environment() permite descobrir em que
> # ambiente está uma função:
> environment(exibirArvore)
<environment: R_GlobalEnv>
> search()
[1] ".GlobalEnv" "tools:rstudio" "package:stats" "package:graphics"
[5] "package:grDevices" "package:utils" "package:datasets" "package:methods"
[9] "Autoloads" "package:base"
Observe que a primeira chamada à função environmentName(a) retorna um string vazio, que é o nome do ambiente interno à função. Quando uma função é criada ela gera a criação de um ambiente próprio onde ficam as variáveis definidas em seu corpo. Para exemplificar a existência deste ambiente dedicado à definição da função criamos abaixo a função minhaFuncao(x) que retorna outra função que soma x ao seu argumento. O valor de x passado na definição da função não é alterado com uma definição de seu valor fora do corpo da função.
> f <- function() {
x <- 1
print(environment())
print(parent.env(environment()))
}
> f()
<environment: 0xd31ee80>
<environment: R_GlobalEnv>
> minhaFuncao <- function(x) { function(y) x+y }
> h <- minhaFuncao(100)
> h(10)
[1] 110
> x <- 3
> h(2)
[1] 102
> # Internamente ao ambiente de h, x = 100
> # h vive no ambiente environment(h).
> # Neste ambiente existe apenas a variável:
> ls(environment(h))
[1] "x"
No caso acima o R criou o ambiente "0xd31ee80" que é filho de R_GlobalEnv. A variável x só existe dentro do ambiente da função.
Uma função (e seu ambiente) podem ser colocados em qualquer outro ambiente usando-se a função environment(funcao ) <- outroAmbiente. No exemplo abaixo a variável anos é definida em .GlobalEnv e dentro do corpo da função quantosAnos. Três outras funções são definidas dentro desta primeira: anosLocal (que usa a variável local, a=10), anosGlobal (que usa a variável em globalEnv, a=10). Na execução da função semBusca a variável está localmente definida, a=1 e nenhuma busca é necessária para a sua execução.
O exemplo abaixo mostra que quando a função f1 é gerada seu ambiente foi armazenado junto com ela. Nele estão as variáveis a=2, b=3. Este ambiente fica inalterado mesmo depois que a variável global a foi alterado.
> funcaoSoma <- function(a, b) {
f <- function(x) return( x + a + b )
return( f )
}
> a <- 2; b <- 3
> f1 <- funcaoSoma(a, b)
> f1(3)
[1] 8
> a <- 4
> f2 <- criarFuncao(a, b)
> f2(3)
[1] 10
> f1(3)
[1] 8
> # Para forçar a permanência de uma variável após
> # a conclusão da função usamos a atribuição "<<-"
> f <- function(){w<-13}
> f() # não há retorno
> w
Error: object 'w' not found
> f <- function(){w<<-13}
> f()
> w
[1] 13
Para alocar explicitamente variáveis para um determinado ambiente, além da notação de "$" pode ser usado:
Se o nome da biblioteca onde está uma função é previamente conhecido é possível evitar a busca pela definição de uma função usando o operador ::. O mesmo procedimento pode ser usado para forçar o uso de uma função específica quando existem outras de mesmo nome definidas. Se o pacote não está carregado o operador ::: pode ser usado.
> x <- c(123, 234, 345, 242, 34, 100)
> stats::sd(x)
[1] 113.9731
> Wilks
Error: object 'Wilks' not found
> stats:::Wilks
> # ... A definição da função é exibida
> # Para verificar o que significa o operador :::
> `:::`
function (pkg, name)
{
pkg <- as.character(substitute(pkg))
name <- as.character(substitute(name))
get(name, envir = asNamespace(pkg), inherits = FALSE)
}
Decorre do que foi dito que o escopo de uma variável em R é o seguinte: a variável deve estar definida no ambiente local em que é usada ou em algum ambiente pai. Se variáveis com o mesmo nome estão definidas dentro da hierarquia de ambientes será usada aquela que for encontrada primeiro, ou seja, no ambiente de menor posição.
Muitas linguagens de programação não permitem (ou dsencorajam) o uso de variáveis globais pois elas podem tornar tornar o código mais frágil, sujeito a erros. No R elas podem ser usadas e funções podem acessar variáveis em ambientes acima delas. Mas essa não é sempre uma boa prática. Para projetos com algum nível de complexidade é recomendado que se passe todas as variáveis necessárias na definição da função ou se faça uma verificação rigorosa de escopos, oferecendo alternativas para o caso em que essas variáveios estão ausentes ou tenham tipos não apropriados. Caso as variáveis globais sejam usadas é uma boa prática dar a elas nomes identificadores tais como global.var para evitar que conflituem com outras definidas localmente.
Otimização e Pesquisa de Erros (debugging)
É possível pré-compilar uma função usando a biblioteca compiler (e sua função cmpfun()) que gera uma versão em byte-code. Nas linhas abaixo, fizemos uma medida dos tempos gastos nas funções f e sua versão pré-compilada g.
Algumas práticas podem ser aplicadas se um código estiver demorando muito para ser executado. Uma delas consiste em envolver o código a ser verificado com os comandos Rprof() e Rprof(NULL) e depois executar a função summaryRprof() para ver um resumo dos tempos gastos na execução de cada funcão.
> library(compiler)
> f <- function(n, x) { for (i in 1:n) x <- x + (1 + x)^(-1)}
> g <- cmpfun(f)
> medirTempos <- function() {
Rprof()
inicio <- Sys.time()
f(10000000,1)
duracao1 <- Sys.time() - inicio
print(duracao1)
inicio <- Sys.time()
g(10000000,1)
duracao2 <- Sys.time() - inicio
print(duracao2)
print(duracao1 - duracao2)
Rprof(NULL)
summaryRprof()
}
> # Executamos a função para medir os tempos gastos
> medirTempos()
Time difference of 1.003972 secs
Time difference of 0.9667881 secs
Time difference of 0.03718424 secs
$by.self
self.time self.pct total.time total.pct
"f" 1.00 51.02 1.00 51.02
"g" 0.96 48.98 0.96 48.98
$by.total
total.time total.pct self.time self.pct
"medirTempos" 1.96 100.00 0.00 0.00
"f" 1.00 51.02 1.00 51.02
"g" 0.96 48.98 0.96 48.98
$sample.interval
[1] 0.02
$sampling.time
[1] 1.96
A função compilada g é um pouco mais rápida que sua original. Em blocos maiores e mais demorados de código a diferença pode ser significativa.
Quando dados são importados para uma sessão de R sempre é uma boa prática ler apenas os campos necessários. Por exemplo, suponha que se deseje importar dados de uma tabela contido em um arquivo de texto arquivo.txt que contém 5 variáveis, a primeira de caracter e as 4 demais numéricas, mas apenas as duas primeiras serão usadas. A importação seletiva pode ser obtida usando-se o parâmetro colClasses. Colunas associadas com NULL serão ignoradas:
> # Para importar todos os dados usamos:
> dfLeitura <- read.table(arquivo.txt, header=TRUE, sep=',')
> # Seria mais eficiente e rápido selecionar apenas os campos desejados:
> dfLeitura <- read.table(arquivo.txt, header=TRUE, sep=',',
colClasses=c("character", "numeric", NULL, NULL, NULL))
A execução de uma operação vetorializada é mais ágil do que percorrer um laço sobre os elementos de um vetor ou matriz. Isso é obtido com o uso de funções projetadas para lidar com vetores de forma otimizada. Alguns exemplo na instalação básica são as funções colSums(), colMeans(), rowSums(),
e rowMeans(). O pacote matrixStats, plyr, dplyr, reshape2, data.table também incluem diversas funções otimizadas para esse tipo de operação.
Para mostrar isso usamos, desta vez, a função system.time(operação) que mede o tempo de execução da operação.
> partes <- 1:100000000
> soma1 <- function(x) print(sum(x))
> soma2 <- function(x) {
s <- 0
for (u in x) s <- s + u
print(s)
}
> system.time(soma1(partes))
[1] 5e+15
user system elapsed
0 0 0
> system.time(soma2(partes))
[1] 5e+15
user system elapsed
4.775 0.000 4.775
Em outro exemplo fazemos a soma dos elementos de uma matriz com 1000 colunas e 1000 linhas (portanto com 1 milhão de elementos).
> set.seed(1234)
> # Cria uma matriz 10000 x 10000
> matriz <- matrix(rnorm(100000000), ncol=10000)
> # Cria função para somar elementos de cada coluna
> somar <- function(x) {
somando <- numeric(ncol(x))
for (i in 1:ncol(x)) {
for (k in 1:nrow(x)) {
somando[i] <- somando[i] + x[k,i]
}
}
}
> # Executa a função e mede o tempo gasto
> system.time(somar(matriz))
user system elapsed
17.231 0.000 17.230
> # mede o tempo de execução de colSums
> system.time(colSums(matriz))
user system elapsed
0.108 0.000 0.107
Como vimos o cálculo é realizado aproximadamente 160 vezes mais rapidamente pela função vetorializada. Essa diferença pode ser muito maior, dependendo da situação analisada.
Sempre é mais eficiente inicializar um objeto em seu tamanho final e depois preenchê-lo de que partir de um objeto vazio e ajustar seu tamanho progressivamente.
> set.seed(1234)
> u <- rnorm(1000000)
> uQuadrado <- 0
> system.time(for (i in 1:length(u)) uQuadrado[i] <- u[i]^2)
user system elapsed
0.361 0.000 0.361
> # Tempo de execução para a mesma operação com
> # a variável inicializada em seu tamenho final
> rm(uQuadrado)
> uQuadrado <- numeric(length=1000000)
> system.time(for (i in 1:length(u)) uQuadrado[i] <- u[i]^2)
user system elapsed
0.11 0.00 0.11
> # Usando a função vetorializada
> uQuadrado <- numeric(length=1000000)
> system.time(uQuadrado <- u^2)
user system elapsed
0.002 0.000 0.001
A operação é muito mais rápida quando se usa a função vetorializada. Além da exponenciação, as funções adição, multiplicação e outras operações binárias do tipo são todas vetorializadas.
Gerenciamento de memória
Como já mencionado, R mantém em memória RAM todos os seus objetos em uso, o que pode introduzir lentidão ou mesmo a impossibilidade de realizar alguma operação. Mensagens de erro sobre a insuficiência de espaço de memória indicam que o limite foi excedido. Este limite depende, é claro, do hardware usado, do sistema operacional e da compilação de R (a versão de 64 bits é mais eficiente). Para grandes volumes de dados é preciso procurar escrever um código eficiente para acelerar a execução com o eventual armazenando dados em meio externo para diminuir a sobrecarga na memória RAM e através do uso de rotinas estatísticas especializadas, escritas para maximar a eficiência no manipulação de dados.
Para uma programação mais eficiente é recomendável aplicar operações sobre vetores sempre que possível. As funções internas para manipulação vetores, matrizes e listas (tais como ifelse, colMeans e rowSums) são mais eficientes que loops (for e while). Matrizes usam menos recursos que data frames. No uso de read.table() para carregar dados externos para um data frame especifique as opções colClasses e nrows explicitamente, defina comment.char = "" e marque como NULL as colunas não necessárias. Ao ler dados externos para uma matriz, use a função scan().
Como mencionado, sempre que possível crie objetos com seu tamanho final ao invés de aumentar seu tamanho gradualmente, inserindo valores. Teste seu código usando uma amostra de dados menor para otimizá-lo e remover erros. Exclua objetos temporários ou desnecessários usando rm(objeto). Após a remoção use gc() para iniciar a coleta de lixo. Use a função .ls.objects() para listar objetos no espaço de trabalho e encontrar o que ocupa mais memória e o que pode ser removido.
Use as funções Rprof(), summaryRprof() e system.time() para cronometrar o tempo e gasto em cada função e descobrir qual delas você deveria procurar otimizar. Rotinas externas compiladas podem ajudar a acelerar a execução do programa. Com o pacote Rcpp você pode transferir objetos de R para funções C++ e voltar quando são necessárias sub-rotinas otimizadas.
Para volumes de dados for muito grandes existem bibliotecas que incluem a funcionalidade de descarregar dados em bancos de dados externos ou arquivos binários simples e acessar parte deles. Alguns exemplos são:
Biblioteca
Descrição
bigmemory
grava e acessa matrizes em arquivos no disco.
ff
fornece estruturas de dados que podem ser grabadas em disco, agindo como se permanecessem em RAM.
filehash
implementa uma base de dados simples tipo chave-valor gravada em disco
ncdf, ncdf4
fornece interface para arquivos Unidata netCDF
RODBC, RMySQL, ROracle, RPostgreSQL, RSQLite
acesso aos respectivos DBMS externos.
No que se refere à análise dos dados em grandes volumes estão disponíveis:
Pacotes biglm e speedglm: ajuste de modelos lineares lineares e generalizados para grandes conjuntos de dados de uma maneira eficiente em termos de memória. Incluem as funções lm() e glm() para lidar com grandes conjuntos de dados.
Diversos pacotes oferecem funções para operações sobre grandes matrizes produzidas pelo pacote bigmemory. biganalytics oferece agrupamento k-means, estatísticas de coluna e um wrapper para biglm. O pacote bigrf pode ser usado para se adequar às florestas de classificação e regressão. bigtabulate fornece funcionalidade table(), split() e tapply(). O pacote bigalgebra inclui funções avançadas da álgebra linear.
biglars oferece cálculo de regressão para conjuntos grande, usado juntamente com o pacote ff.
O pacote data.table introduz uma versão melhorada de um data frame, com métodos mais rápidos e eficientes para: agregação de dados; junções de intervalo; adição, modificação e exclusão de colunas por referência (sem cópias). Um data.table pode ser usado em qualquer função que receba um data frame como argumento.
Depuração de Erros (debugging)
Qualquer projeto de programação com algum grau de complexidade está sujeito a erros. Depuração de erros ou debugging é o processo de se encontrar e resolver as falhas no código. Por mais interessante que seja escrever um bloco de código para resolver algum problema, encontrar erros pode ser tedioso e demorado. Existem erros que impedem a execução do código causando a emissão de mensagens de erros. Estes são, em geral, os mais fáceis de se encontrar. Mas também existem situações em que o código roda perfeitamente mas produz resultados inesperados e incorretos.
As táticas de debugging envolvem rodar as linhas de código interativamente verificando o valor das variáveis, testar o efeito sobre um conjunto de dados que produzem resultados conhecidos, análise do fluxo do código e do estado da memória a cada instante da execução.
Na programação em R erros são geralmente causados por digitação incorreta do nome de variáveis ou funções e chamadas à funções com parâmetros de tipo incorretos, inclusive quando objetos importados de fontes externas contém partes que são NULL, NaN ou NA e são passados como parâmetros para funções que não fazem a verificação para a existência desses valores.
Função
Efeito
debug()
Marca uma função para debugging.
undebug()
Desmarca uma função para debugging.
browser()
Permite percorrer o código de execução de uma função passo a passo.
trace()
Modifica a função para permite a inserção temporária de de código auxiliar.
untrace()
Cancela a função anterior e remove o código temporário.
traceback()
Imprime a sequência de chamadas a funções que produziram o último erro não capturado.
Durante a depuração com o uso de browser() a tecla executa a linha sob o cursor e passa o foco para a próxima linha. Teclar força a execução até o final da função sem pausas. Digitar exible a pilha de execução (call stack) e interrompe a execução e desloca o foco para o nível imediatamente superior. Também é possível usar comandos como ls(), print() e atribuições no prompt do depurador.
Atualizando R e suas Bibliotecas
A atualização de R pode ser um pouco trabalhosa. Seguem algumas sugestões para usuários de Windows e Linux.
No Windows
Uma forma possível e prática para atualizar a instalação do R no Windows consiste em usar a biblioteca installr. Para isso a bliblioteca deve ser instalada e executada de dentro do próprio console (ou do Rstudio, ou outra IDE).
Como eu não utilizo o Windows esta opção está mencionada aqui como uma sugestão, que eu não experimentei. Ela foi extraída da página R-statistics blog.
> # instalando e carregando a biblioteca
> install.packages("installr")
> require(installr)
> updateR()
A função updateR() iniciará o processo de atualização, verificando se novas versões estão disponíveis. Se a versão instalada for a mais recente a função termina e retorna FALSE. Caso contrário será perguntado se o usuário deseja prosseguir, após a exibição de um sumário das novidades na versão.
Será oferecida ao usuário a opção de copiar as bibliotecas instaladas para a nova versão e, em seguida, a de atualizar estas bibliotecas.
Mac e Linux
A atualização pode ser feita manualmente usando pacotes no website da CRAN.
Tanto no Windows quanto no Linux para atualizar apenas as bibliotecas que foram instaladas com install.packages() basta usar, no console a função update.packages(). A função perguntará quais as bibliotecas você deseja atualizar. Para executar a atualização de todas elas, sem o prompt de consulta digite update.packages(ask = FALSE).
Além de update.packages() existem as funções old.packages() que informa quais as bibliotecas possuem versões mais atuais nos repositórios versões aplicáveis e new.packages() que procura por novas bibliotecas disponíveis e ainda não instaladas, oferecendo a opção de instalá-las.
Obs.: Pacotes instalados por devtools::install_github() não são atualizados pelos procedimento descritos. No Windows eles podem ser atualizados por installr.
No RStudio
Para atualizar o RStudio use o item de Menu: Help > Check for Updates. Para atualizar as bibliotecas use Menu: Tools > Check for Packages updates.
Uma parte importante da análise de dados esta na visualização destes dados em forma gráfica. A representação visual de dados permite, muitas vêzes, o reconhecimento de padrões que dificilmente seriam percebidos apenas com tabelas e números. R fornece várias funções para representar dados graficamente, tanto em gráficos bidimensionais quanto tridimensionais. Em particular dá-se ênfase aos gráficos estatísticos, tais como histogramas, curvas de distribuições, gráfico de barras e outros. Existem métodos gerais que se aplicam à diversas formas básicas de gráficos. Pode-se incluir títulos, nomes para os eixos, cores, representações por pontos linhas e sinais variados e anotações.
A função plot() é a mais básica na geração de um gráfico.
> x <- -10:10; y <- x^2; plot(x,y) # resultado na figura 1
> # Parâmetro para tornar a linha contínua
> plot(x,y, type="l") # resultado na figura 2
Alguns dos parâmetros são listados abaixo:
plot(x, y, ...)
x
coordenadas horizontais dos pontos. Pode ser um objeto numerado.
y
coordenadas verticais dos pontos. Omitido se x é um objeto numerado.
…
Argumentos adicionais (parâmetros gráficos).
Entre os argumentos adicionais:
type =
“p” (pontos), “l” (linhas), “b” (ambos),
“h” (histograma), “s” (degraus), “n” (em branco)
main =
título principal
sub =
subtítulo
xlab =
título para eixo x
ylab =
título para eixo y
asp =
aspecto (razão y/x).
Observe que, se u é um objeto ordenado, então plot usa como coordenada x a ordem dos elementos. Por exemplo:
> u <- rnorm(10)
> # Os dois gráficos seguintes são idênticos
> plot(u)
> plot(1:10, u)
Algumas funções sobreescrevem o gráfico já traçado. É o caso da função lines. É possível alterar características das linhas com os parâmetros lwd (largura da linha) e lty (tipo da linha), como se mostra no exemplo:
> a <- 1:20; b <- a^2
> plot(a, .1*b ,type="l") # linha 1
> lines(a, .2*b , lwd=4 ) # linha 2
> lines(a, .3*b , lwd=2) # linha 3
> lines(a, .4*b , lty=3) # linha 4
> points(a,.5*b, pch=3) # pontos 5
> text(10, 2, "Título do gráfico") # título na posição 10 , 2
As linhas acima resultam no gráfico:
Se vários gráficos devem ser analisados ao mesmo tempo, uma nova instância da janela de saída gráfica pode ser aberta com o comando dev.new() ou X11() (apenas para sistemas tipo Unix). Pode-se navegar entre “devices” gráficos abertos usando dev.new(), dev.next(), dev.prev(), dev.set() e dev.off().
> plot(rnorm(10)) # plota o primeiro gráfico
> dev.new() # abre nova janela
> plot(rnorm(20)) # plota o segundo gráfico
Os gráficos podem ser enviados diretamente para arquivos nos formatos JPEG, BMP, PDF, TIFF, PNG, entre outros. Como exemplo, direcionamos a saída gráfica para um arquivo JPEG:
> # grava arquivo hiperbole.jpg
> jpeg(file='hiperbole.jpg')
> # plota gráfico
> plot(x<- -100:100, 1/x, type='l', main="hipérbole")
> # fecha janela gráfica
> dev.off()
> # Grava arquivo jpeg com a imagem à direita.
Outras funções capazes de escrever por cima de um gráfico já plotado são locator(n) e identify(). A primeira serve para que o se selecione regiões do gráfico utilizando o botão esquerdo do mouse até que se tenha um número n de pontos selecionados (ou até pressionar o botão direito do mouse, para terminar). A cada clique dado com o botão esquerdo do mouse a função retorna no console as coordenadas do clique. Por exemplo:
> x <- 1:100; y <- sqrt(x)
> plot(x,y, type="l")
> text(locator(1), "x é aqui!")
> text(locator(1), "y é aqui!")
> text(locator(5), paste("<", 1:4, ">")
> # A linha acima marca 4 pontos
> # no gráfico, com o texto:
> # "<1>", "<2>", "<3>", "<4>"
> # respectivamente
Para os próximos passos usaremos o dataframe carregado por padrão no R de nome mtcars. Este é um conjunto de dados sobre automóveis com campos mpg, cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb. Antes de prosseguir, observe que as quatro formas de notação abaixo são equivalentes:
Na quarta forma usamos y ~ x para representar x como variável independente, y como variável dependente.
Aproveitamos a oportunidade para conhecer uma sintaxe especial. O comando plot( cyl ~ ., data= mtcars ) realiza a plotagem de todos os gráficos de cyl como função de todos os demais campos de mtcars. O promptHit to see next plot: aparece entre as operações.
> attach(mtcars)
> plot(mpg ~ wt)
> abline(lm(mpg ~ wt))
> title("Regressão Linear de Consumo por Peso")
> detach(mtcars)
Para enviar este gráfico para um arquivo pdf basta cercar todas as linhas acima pelos comandos pdf("NomeArquivo.pdf") e dev.off().
A função abline(a,b) traça uma reta sobre o gráfico, recebendo os parâmetros a como a interseção da reta com o eixo y (x = 0) e b como a inclinação da reta. Ela recebe como argumento lm(y~x) que retorna diversos dados sobre a regressão linear da função y~x, entre eles os parâmetros a e b necessários para definar a reta.
A função abline possui outros parâmetros. Entre eles:
abline(a=NULL, b=NULL, h=NULL, v=NULL, col=, ...)
a = interseção com eixo y
b = inclinação da reta
h = y (traça reta horizontal por y)
v = x (traça reta vertical por x)
col = cor: "red", "blue", etc; ou rgb(x,y,z), onde x, y, z ∈ [0, 1]
ou hexadecimal #abcdef; a, ..., f ∈ [0, f], hexadecimal.
Alguns exemplos de uso de abline(). O código seguinte gera os gráficos abaixo:
> plot(x<- 0:10, x) # plotar uma reta
> title("Reta y = x")
> abline(v=4) # reta vertical por x = 4
> abline(v=6, col="blue") # reta vertical por x = 6, azul
> abline(h=8, col="#779900") # outra cor
> # Usando a tabela cars (embutida em R)
> dev.new()
> plot(cars)
> abline(v=c(15,20), col=c("blue", "red"), lty=c(1,2), lwd=c(1, 3), h=40)
Parâmetros Gráficos
O conjunto de parâmetros para construção de gráficos podem ser lidos e (alguns deles) alterados através da função par(). Podem ser características como fonts, cores, eixos e títulos.
par(..., no.readonly = FALSE)
Argumentos:
no.readonly = Booleano. Se TRUE apenas parâmetros que podem ser
alterados pelo usuário são exibidos.
... Outros parâmetros são passados na forma:
par1 = valor1, ..., parn = valorn
Se nenhum parâmetro for fornecido par() exibe uma lista dos parâmetros atuais, par(no.readonly = TRUE) exibe uma lista dos parâmetros que podem ser alterados. Valores alterados dessa forma permanecem válidos durante a sessão.
Para exemplificar suponha que pretendemos ter nossos gráficos plotados com quadrados sólidos ligados por retas. O seguinte código pode ser usado:
> # parâmetros default são armazenados
> oldPar <- par(no.readonly=TRUE)
> par(lty=1, pch=15)
> plot(cars$dist ~ cars$speed, type="b")
> title("Usando quadrados e retas")
> # parâmetros default são restaurados
> par(oldPar)
> # Claro que o mesmo efeito seria obtido com
> plot(cars$dist ~ cars$speed, type="b", lty=1, pch=15)
Alguns parâmetros são listados na tabela:
Parâmetro
Descrição
pch
símbolo usado para marcar pontos.
cex
tamanho do símbolo, relativo ao default. 1 = default, 1.5 is 50% maior, etc.
lty
tipo da linha.
lwd
largura da linha, relativa ao default. Ex.: lwd=2 dupla largura.
Valores de pch, lty
As cores que podem ser alteradas nos gráficos estão listas na tabela seguinte:
Parâmetro
Descrição
col
cor default do gráfico.
col.axis
cor para texto nos eixos.
col.lab
cor para labels nos eixos.
col.main
cor do título.
col.sub
cor do subtítulo.
fg
cor do primeiro plano.
bg
cor de fundo.
Para o parâmetro col algumas funções aceitam valores reciclados. Por ex., se col=c("blue", "green") e três curvas são exibidas então a primeira e a terceira serão azuis, a segunda verde. Cores podem ser especificadas por índice, nome, valores hexadecimais, RGB e HSV. A função colors() exibe uma lista de todas as cores disponíveis, por nome.
Algumas funções permitem a criação de palhetas, vetores com n cores contíguas:
rainbow(n, s = 1, v = 1, start = 0, end = max(1, n - 1)/n, alpha = 1,
heat.colors(n, alpha = 1),
terrain.colors(n, alpha = 1),
topo.colors(n, alpha = 1),
cm.colors(n, alpha = 1))
Parâmetros:
n
número (≥ 1) de cores no vetor.
s, v
“saturação” e “valor” no formato HSV.
start
[0,1] cor inicial para o arco-íris (rainbow).
end
[0,1] cor final para o arco-íris (rainbow).
alpha
[0,1], transparência.
Vamos explorar o uso destas palhetas de cores na próxima seção.
Para especificar o estilo, tamanho e família das fontes os seguintes parâmetros gráficos podem ser usados:
Parâmetro
Descrição
cex
magnificação do texto: 1 = default, 1.5 = 50% maior; 0.5 = 50% menor, etc.
cex.axis
magnificação dos eixos, relativo a cex.
cex.lab
magnificação do texto nos eixos, relativo a cex.
cex.main
magnificação do texto do título, relativo a cex.
cex.main
magnificação do texto do subtítulo, relativo a cex.
família da fonte. Os padrões são serif, sans e mono
Por exemplo, após a aplicação dos parâmetros: par(cex.main=3, cex.lab=1.5, font.lab=2, font.main=4, font.sub=3)
o texto nos gráficos serão representados com: títulos com fontes 3 vezes maior que o padrão definido em cex, eixos magnificados em 1.5, labels em negrito nos eixos, títulos em negrito itálico e subtítulos em itálico.
Para controle das dimensões do gráfico e margens usamos:
Parâmetro
Descrição
pin
largura e altura do gráfico, em polegadas.
mai
vetor com larguras das margens, c(inferior, esquerda, superior, direita) em polegadas.
mai
vetor com larguras das margens, c(inferior, esquerda, superior, direita) em linhas. [default = c(5, 4, 4, 2) + 0.1].
Função barplot()
A função barplot() permite a exibição de gráficos de barras. Um resumo de seus parâmetros está mostrado abaixo.
barplot(height, width = 1, space = NULL, names.arg = NULL,
horiz = FALSE, density = NULL, col = NULL, border = par("fg"),
main = NULL, sub = NULL, xlab = NULL, ylab = NULL, axes = TRUE)
Parâmetros:
height
vetor ou matriz contendo altura das barras.
width
vetor com largura das barras.
space
espaço deixado antes da barras (uma fração da largura).
A função bar plot pode receber uma matriz como argumento. Para ilustrar vamos usar a função table() para tabelar dados no data frame mtcars. Este data frame possui o campo mtcars$carbs que lista o número de carburadores de uma lista de automóveis. Em seguida criamos uma tabela com um teste clínico hipotético para o tratamento da gripe usando um antiviral, vitammina C e um “chazinho”.
> carburadores <- table(mtcars$carb)
> carburadores
1 2 3 4 6 8
7 10 3 10 1 1
> # A tabela mostra que existem 7 modelos com 1 carburador, 10 com 2, etc.
> barplot(carburadores, main="Modelos x carburadores", horiz=TRUE,
names.arg=c("1", "2", "3","4", "6", "8"), xlab="Quantos modelos",
ylab="Número de carburadores", col=rainbow(6))
> testeClinico <- matrix(c(45,9,12,4,31,31,1,10,7), ncol=3, byrow=TRUE)
> cores <-c("#5FC0A0", "#DE7A6B", "#6BA0DE")
> colnames(testeClinico) <- c("Antiviral","Vitamina C","Chazinho")
> rownames(testeClinico) <- c("Melhorou","Sem alteração","Piorou")
> testeClinico
Antiviral Vitamina C Chazinho
Melhorou 45 9 12
Sem alteração 4 31 31
Piorou 1 10 7
> resultado <- as.table(testeClinico)
> barplot(resultado, main="Gripe: teste clínico", xlab="Medicamento",
ylab="Eficácia", col=cores, legend=rownames(resultado))
O código acima gera os gráficos:
O mesmo gráfico, com os dados agrupados por tipo de medicamento testado pode ser obtido ao se acrescentar o parâmetro beside=TRUE que força a exibição de dados lado à lado para uma mesma coluna:
Usando funções de agregamento e passando o resultado para barplot() pode-se representar médias, medianas, desvios padrões e outros em gráficos de barras.
Para experimentar com esta funcionalidade usaremos o dataset embutido com o R denomidado states (US State Facts and Figures). Ele contém dados antigos sobre os 50 estados americanos. Em particular usaremos state.region, um fator contendo as regiões de cada estado (Northeast, South, North Central, West) e state.x77, uma matriz com 50 linhas e 8 colunas com informações sobre os estados. O campo state.x77$Illiteracy contém taxas de analfabetismo nos estados americanos em 1970, como porcentagem da população.
> # Carregamos uma palheta de 4 cores
> cor <- c("#F3E16E", "#6EC6F3", "#6FF36E", "#F36E84")
> reg <- state.region
> levels(reg) # as regiões estão em inglês
[1] "Northeast" "South" "North Central" "West"
# Para traduzir para o português alteramos os levels:
> levels(reg) <- c("Nordeste","Sul","Central Norte","Oeste")
> levels(reg)
[1] "Nordeste" "Sul" "Central Norte" "Oeste"
> # Usamos apenas a 3a. coluna de state.x77 (analfabetismo %)
> analfabetismo <- state.x77[,3]
> # Criamos um dataframe com informações: regiões x analfabetismo
> estados <- data.frame(reg, analfabetismo)
> # Agregamos a informação sobre analfabetismo por região,
> # usando a função mean (média)
> media <- aggregate(estados$analfabetismo, by=list(estados$reg), FUN=mean)
> # para alterar os nomes das colunas
> names(media) <- c("regiao", "taxa")
> # Ordenamos o resultado por taxa de analfabetismo
> media <- media[order(media$taxa),]
> View(media) # resulta na tabela 1
> # plotando o gráfico de barras
> barplot(media$taxa, names.arg=media$regiao, col=cor)
> title("Analfabetismo nos EUA / por região"
> # resultado no gráfico abaixo
O código acima gera o gráfico:
Função pie()
Gráficos de setores ou gráficos de pizza (pie charts) também são úteis para a representação de dados.
vetor de valores, exibidos como áreas dos setores no gráfico.
labels
nomes para legendas dos setores. NA ou “” = sem legenda.
edges
borda externa é um polígono com este número de lados.
clockwise
booleano. Sentido horário ou não das fatias.
init.angle
ângulo inicial (da primeira fatia).
col
vetor de cores de preenchimento das fatias.
main
título do gráfico.
> z <- (-10:10)^2 - 50
> barplot(z, col=rainbow(25), main="Gráfico de barras", ylab="y=x^2-50")
> dev.new()
> legenda <- paste("fatia ",1:16) # gera vetor fatia 1, ..., fatia 16
> cores <- c("#F3E16E", "#6EC6F3", "#6FF36E", "#F36E84")
> pie(rep(1,16), col=cores, labels=legenda, main="Setores")
O seguinte gráfico é gerado: Gráfico de Setores
O código abaixo gera três gráficos de setores (pie charts). As populações listadas para os cinco países mais populosos são dadas em milhões. No gráfico-2 os percentuais (apenas entre estes 5 países) são exibidas. No terceiro gráfico a packageplotrix é usada para desenhar um gráfico em 3 dimensões.
> populacao <- c(1420, 1368, 329, 269, 212)
> pais <- c("China", "India", "EUA", "Indonesia" , "Brasil")
> pie(populacao, labels=pais, main = "população em milhões")
> # Gera Gráfico-1
> pc <- round(populacao/sum(populacao)*100)
> pc # porcentagem de população (entre estes 5 países)
[1] 39 38 9 7 6
> label <- paste(pais, "-", pc, "%", sep="")
> label
[1] "China-39%" "India-38%" "EUA-9%" "Indonesia-7%" "Brasil-6%"
> pie(populacao, labels=label, col=rainbow(length(labels)), main = "população em milhões (%)")
> # Observe que length(labels)=5 e temos 5 cores geradas
> # Gera Gráfico-2
> library(plotrix) # deve ser instalado com install.packages("plotrix")
> pie3D(populacao, labels=label,explode=0.1, main="3D Gráfico setores")
> # Gera Gráfico-3
Os gráficos de setores são podem ser úteis para uma visualização rápida de uma relação entre valores. No entanto podem dificultar a análise mais minuciosa destes dados. Por exemplo, se dois setores tem aproximadamente o mesma área pode ser difícil perceber qual é maior. Em geral o uso de barras é mais recomendado.
Uma alternativa atraente é o fan.plot, carregado junto com a library plotrix. Neste tipo de gráfico os setores são sobrepostos e seus raios variados para que todos apareçam na representação.
> library(plotrix)
> populacao <- c(1420, 1368, 329, 269, 212)
> pais <- c("China", "India", "EUA",
"Indonesia" , "Brasil")
> fan.plot(populacao, labels=pais,
main = "Usando o fan.plot",
col=rainbow(5))
> # O gráfico à direita é gerado.
Histogramas com a função hist()
Histogramas (ou distribuições de frequências) são uma forma de exibir a distribuição de uma variável contínua. A faixa de valores a serem analisados é dividida em classes (que podem ser ou não uniformes). A base de cada retângulo na representação é dada pela extensão da classe e a altura pela quantidade de dados (frequências) dentro de cada classe. Histogramas são criados com a função hist(v) onde v é um vetor numérico.
O parâmetro freq=FALSE gera um gráfico baseado em densidades de probabilidade e não em frequências. O parâmetro break informa em quantos classes os dados devem ser divididos. Por default as classes são divididas uniformemente.
> distUniforme <- runif(1000, 0, 10)
> # gera 1000 valores distribuídos uniformemente, com média 0 e desvio padrão 1
> hist(distUniforme, col=rainbow(10))
> # plota o histograma dessa distribuição
> distNormal <- rnorm(100000, 0, sd=2)
> # gera 10^5 valores distribuídos aleatóriamente com distribuição normal,
> # com média 0 e desvio padrão 2
> hist(distNormal, col=rainbow(12))
> # plota o histograma dessa distribuição
Para os exemplos que se seguem usaremos o data frame faithful, embutido na instalação do R. Este é um data frame contendo 272 observações, registradas em 2 variáveis numéricas: eruptions, tempo de erupção, e waiting intervalo entre erupções ambas em minutos.
> attach(faithful)
> hist(eruptions)
> # Gera o primeiro histograma abaixo
> hist(faithful$eruptions, seq(1.6, 5.2, 0.2), prob=TRUE, col=rainbow(18))
> lines(density(faithful$eruptions, bw=0.1))
> rug(faithful$eruptions)
> # Gera o segundo histograma abaixo
> # Os efeitos de lines() e rug() estão marcados no gráfico
> detach(faithful)
Gráficos de densidade kernel
Dada uma variável aleatória discreta, a estimativa de densidade kernel (EDK) é uma técnica para se estimar a função de densidade de probabilidade que melhor se ajusta à esta variável. Ela busca suavizar dados discretos fazendo inferências sobre uma amostra finita de dados. Desta forma é possível extrapolar dados discretos, fazendo previsões para valores não diretamente medidos. O kernel (ou núcleo) é uma função simétrica, suave. Tipicamente se usa a gaussiana, embora outras funções podem ser escolhidas. No R um gráfico de densidade kernel para o vetor x pode ser obtido com plot(density(x, )).
> attach(mtcars)
> # Construimos uma densidade usando
> # mtcars$mpg (milhas por galão)
> d <- density(mpg)
> plot(d,
main="Milhas/galão (densidade kernel)")
> # Para colorir a área sob a curva
> polygon(d, col="lightblue", border="black")
> # Para inserir marcas nos valores
> # discretos que geraram a densidade
> rug(mpg, col="red")
> detach(mtcars)
A função polygon() desenha um polígono com vértices x, y, neste caso os pares fornecidos pela densidade. rug() marca os valores presentes no vetor mtcars$mpg.
Gráficos de densidade kernel podem ser usados para comparar dados em grupos distintos. Para isso usaremos o pacote sm. Nesse pacote usamos
a função sm.density.compare() para sobrepor gráficos nos grupos dentro de fatores cyl.f, que são, no caso, 4, 6 e 8. O formato é sm.density.compare(x, factor) onde x é um vetor numérico e o fator fornece a variável de agrupamento.
> install.package("sm")
> library(sm)
> attach(mtcars)
> cyl.f <- factor(cyl, levels= c(4,6,8),
labels = c("4 cilindros", "6 cilindros", "8 cilindros"))
> sm.density.compare(mpg, cyl, xlab="Milhas por galão")
> title(main="Consumo x Cilindros")
> cores<-c(2:(1+length(levels(cyl.f))))
> legend(locator(1), levels(cyl.f), fill=cores)
> # locator(1) faz com que o quadro de legendas
> # fique ancorado no ponto clicado pelo usuário.
> detach(mtcars)
O código acima gera o gráfico:
Gráficos de caixas boxplot()
Um gráficos de caixas (boxplot()) é uma ferramenta muita usada para analisar e comparar a variação de uma variável entre diferentes grupos de dados. Ela representa uma variável traçando as mesmas informações obtidas em sumário de cinco números:
o mínimo, o quartil inferior (percentil 25), a mediana (percentil 50), o quartil superior (percentil 75) e o máximo. Ele também pode ser usado para mostrar outliers (ou discrepantes, que são valores fora do intervalo de ± 1,5 * IQR, onde IQR é o intervalo interquartil definido como o quartil superior menos o menor quartil).
Aproveitamos, nas linhas de código abaixo, para rever algumas funções estatísticas básicas, como median(), quantil() e summary().
Boxplots podem ser usados para comparar grupos de variáveis dentro de um dataframe ou lista. O formato para isto é: boxplot(formula, data=dataframe) onde formula é uma relação entre campos do dataframe. Um exemplo de fórmula é y ~ A, onde A é uma variável categórica. Neste caso um plot separado de y é traçado para cada valor de A. A fórmula y ~ A*B resultaria em plots separados de y para cada combinação dos níveis nas variáveis categóricas A e B.
O opção varwidth=TRUE faz com que as caixas tenham larguras proportionais à raiz quadrada do tamanho das amostras. O parâmetro horizontal=TRUE (não usado no gráfico acima) produz a reversão da orientação dos eixos.
Visualizações interativas
O R fornece muitas formas de exibir gráficos que podem ser modificados por interações com o usuário. Vamos exibir aqui apenas alguns exemplos.
O leaflet é uma biblioteca javascript voltada para a visualização interativa de mapas. O código abaixo carrega uma sessão com o leaflet. A função addTiles() insere uma camada com um mapa ao leaflet inicializado.
> library(dplyr)
> library(leaflet)
> leaflet() %>% addTiles()
> # O gráfico 1 é desenhado.
> # Inserindo a latitude e a longitude da
> # Praça da Liberdade, em Belo Horizonte, MG.
> # (que foi encontrada no Google Maps)
> pcaLiberdade <- data.frame(longitude = -43.938023, latitude= -19.931743)
> pcaLiberdade$titulo <- "Praça da Liberdade, BH!"
> # pcaLiberdade é um data frame com campos:
> pcaLiberdade
longitude latitude titulo
1 -43.93802 -19.93174 Praça da Liberdade, BH!
> leaflet(pcaLiberdade)
%>% addTiles()
%>% addMarkers(lat = ~latitude, lng = ~longitude, popup = ~titulo)
> # O gráfico 2 é desenhado
Lembrando: as bibliotecas dplyr e leaflet devem ser instaladas. Observe as linhas de retorno na instalação para verificar sucesso ou erro. A biblioteca iplots, por exemplo, depende de Java.
A url mostrada (no caso “http://127.0.0.1:6260”) deve ser visualizada no Browser. A cada clique de mouse as coordenadas do cursor são exibidas na caixa abaixo, como mostra a figura.
Biblioteca plotly
O código abaixo utiliza o data frame diamonds que contém informações sobre cor, clareza, medidas, carat, preço de diamantes. O ponto clicado abre um pop-up com dados sobre a posição no gráfico e a clareza do diamante.
> library(plotly)
> set.seed(100)
> d <- diamonds[sample(nrow(diamonds), 1000), ]
> plot_ly(d, x = carat, y = price, text = paste("Clareza: ", clarity),
mode = "markers", color = carat, size = carat)
Sobre operadores em R
Em R o programador pode criar aperadores ou alterar o significado de operadores nativos usando o sinal “`” (backtick ou acento grave).
Por exemplo: `+` <- function(a, b) paste(a, b, sep="") "a"+"v" # retorna "av"
O sinal "+" se transformou no operador de concatenação.
Em geral se pode programar %X% (qualquer X) para qualquer funcionalidade. `%@%` <- function(a, b) a^b `%*%` <- function(x, y) x/y 2 %@% 3 # retorna 8 15 %*% 3 # retorna 5
As bibliotecas magrittr e dplyr definem o operador %>% com o seguinte significado: `%>%` <- function(x, FUN) FUN(x)
Isso quer dizer que x %>% hist
é o mesmo que hist(x)
Por exemplo: iris$Sepal.Length %>% hist # traça o histograma do vetor mtcars$mpg %>% hist(col=rainbow(5)) # histograma de mtcars$mpg usando 5 cores.
Gráficos tridimensionais
Existem muitas bibliotecas em R para a geração de gráficos 3D. Entre eles estão: RGL, car, lattice e scatterplot3d (e muitos outras).
Gráfico de dispersão em 3D com scatterplot3d
scatterplot3d é uma biblioteca de uso simples, com formato básico:
scatterplot3d(x, y=NULL, z=NULL)
onde x, y, z são as coordenadas dos pontos a serem plotados. Os argumentos y e z são opcionais, dependendo da estrutura de x.
Se x é uma fórmula (como em zvar ~ xvar + yvar) então xvar, yvar e zvar são usados como valores para x, y e z.
Se x é uma matriz com pelo menos 3 colunas então as variáveis x, y e z são lidas diretamente da matriz.
> library("scatterplot3d")
> data(iris)
> flor <- iris[1:50,1:3] # 50 linhas, 3 primeiras colunas
> names(flor) <- c("comprimentoSepala", "larguraSepala", "comprimentoPepala")
> # A forma mais simples de uso:
> scatterplot3d(flor)
> scatterplot3d(flor, pch = 20,
main="Gráfico dispersão 3D",
xlab = "Comprimento sétala (cm)",
ylab = "Largura sétala (cm)",
zlab = "Comprimento pétala (cm)", color="steelblue")
> # O gráfico 1 é gerado. (pch=20 usa símbolo bola cheia)
> scatterplot3d(flor, pch = 8, main="pch = 8 -> estrela",
color="#E8582D", angle=55, grid=TRUE, box=FALSE)
> # O gráfico 2 é gerado. pch=8 usa símbolo estrela,
> # o gráfico é girado de 55º, com grid e sem a caixa envelope.
> z <- seq(-10, 10, 0.01)
> x <- cos(z)
> y <- sin(z)
> scatterplot3d(x, y, z, highlight.3d = T, col.axis = "blue",
col.grid = "lightblue", main = "Hélice", pch = 20)
O gráfico ao lado é gerado.
Mais informações sobre scatterplot3d no site STHDA.
Mais informações sobre 3d scatterplots no site STHDA.
Outras visualizações em 3D com scatter3d
O formato básico para scatter3d, com alguns de seus parâmetros, é o seguinte:
Como a principal motivação para o uso do software R está na análise de dados e exibição gráfica de resultados é necessário ter formas eficientes para promover a leitura de dados para dentro de nosso ambiente.
Edição básica de tabelas
Já vimos que objetos como data frames podem ser editados por meio dos comandos edit(objeto) ou fix(objeto) que abrem uma janela para a alteração em forma de grade, permitindo inclusive a inserção de novos campos ou a alteração de nomes dos campos já existentes. Esta pode ser uma boa estratégia para se fazer pequenas alterações nas tabelas.
Outra função usada para leitura de dados do usuário ou à partir da leitura de um arquivo é scan().
scan(file = "", what = double(), n = -1, sep = "")
Valores listados para os parâmetros são default. Existem muitos outros parâmetros. file = "" indica que a leitura será feita do teclado. Se file = "arquivo" este arquivo será lido.
what indica o tipo de dado a ser lido. what=character() significa que strings serão lidas. n é o número de dados que serão inserido. n = -1 significa um número ilimitado. Neste caso a inserção (para n=-1) termina com dois <ENTER> seguidos.
sep = "" é o tipo de separador esperado. O default é um espaço em branco.
> x <- scan(n=3) # insere 3 valores do teclado
1: 12 2: 23 3: 34
Read 3 items
> x
[1] 12 23 34
Arquivos CSV
Para a leitura de bases de dados mais extensas outras formas estão disponíveis. Uma delas consiste em realizar a leitura de um arquivo csv (valores separados por vírgula, em inglês comma separated values). Este tipo de arquivo consiste em uma lista de linhas, cada uma delas contendo um número constante de valores, separados por vírgula (ou outro sinal). Estes arquivos podem ser lidos por gerenciadores de planilhas tais como o Excel ou o CALC, do Libre Office. Eles podem também ser gerados por estes aplicativos.
Vamos criar um arquivo para efeito de aprendizado dessa importação de dados. Em um editor de texto ASCII qualquer digitamos os valores seguintes:
id, Nome, Sobrenome, Idade, Sexo
1, Marta, Rocha, 24, F
2, Pedro, Souza, 12, M
3, José, Marciano, 15, M
4, Joana, Santos, 21, F
5, Lucas, Pereira, 20, M
O espaçamento entre os campos não é necessário. Digamos que gravamos este arquivo com o nome alunos.csv na pasta de trabalho em uso (ou em outra qualquer).
Estes dados podem ser lidos com o comando read.table:
Aqui o parâmetro header=TRUE indica que a primeira linha do arquivo contém títulos para as colunas, sep="," indica que as valores estão separados por vírgula (poderiam estar separados por outro caracter, como “;”) e dec="." indica que o ponto é o separador numérico de decimais.
Se o arquivo não estiver na pasta de trabalho atual o nome completo ("caminho/nomearquivo.csv") deve ser fornecido.Para a conveniência do usuário, diversas funções do R são acompanhadas de outras com nomes diversos que realizam as mesmas operações mas usam parâmetros default diferentes. É o caso de read.table() e read.csv().
Consulte a ajuda para ver quais são estes parâmetros.
Por default ítens numéricos são lidos como variáveis numéricas e texto como fatores, embora este comportamento possa ser alterado se necessário. A primeira linha (o cabeçalho) alimenta os valores de nomes de colunas.
> dir()
[1] "alunos.csv"
> alunos <- read.table("alunos.csv", header=TRUE, sep=",", dec=".")
> alunos
id Nome Sobrenome Idade Sexo
1 1 Marta Rocha 24 F
2 2 Pedro Souza 12 M
3 3 José Marciano 15 M
4 4 Joana Santos 21 F
5 5 Lucas Pereira 20 M
> class(alunos)
[1] "data.frame"
> fix(alunos) # permite a edição em uma tabela de alunos
> names(alunos) # lista propriedades names
[1] "id" "Nome" "Sobrenome" "Idade" "Sexo"
> dim(alunos) # dimensões da lista (5 linhas com 5 campos)
[1] 5 5
> alunos[1,] # primeira linha da lista
id Nome Sobrenome Idade Sexo
1 1 Marta Rocha 24 F
> # O parâmetro row.names permite usar uma coluna para nomear as linhas:
> outroAlunos <- read.table("alunos.csv", header=TRUE, row.names="id", sep=",")
> outroAlunos
N Nome Sobrenome Idade Sexo
1 Marta Rocha 24 F
2 Pedro Souza 12 M
3 José Marciano 15 M
4 Joana Santos 21 F
5 Lucas Pereira 20 M
Em muitos casos precisamos executar a operação inversa: exportamos os dados em uma tabela para um arquivo csv para transferir dados e utilizá-los em outro aplicativo. Para isso usaremos, a seguir, a função write.csv()
> # Para recordar, criamos uma nova tabela, semelhante à alunos:
> alunos2 <- data.frame(
id =1:5,
Nome = c("Marta","Pedro","José","Joana","Lucas"),
Sobrenome = c("Rocha","Souza","Marciano","Santos","Pereira"),
Idade = c(24, 12, 15, 21, 20),
Sexo = c("F", "M","M", "F", "M")
)
> # Para gravar esta tabela em disco, como um arquivo csv:
> write.csv(alunos2, file="alunos2.csv")
> # Se o parâmetro file for omitido a saída é para o console
> write.csv(alunos2)
"","id", "Nome", "Sobrenome", "Idade","Sexo"
"1", 1, "Marta", "Rocha", 24, "F"
"2", 2, "Pedro", "Souza", 12, "M"
"3", 3, "José", "Marciano", 15, "M"
"4", 4, "Joana", "Santos", 21, "F"
"5", 5, "Lucas", "Pereira", 20, "M"
Para gravar o objeto alunos2 (uma lista) para uso futuro usamos save(). O objeto pode ser recuperado para o projeto através da função load().
> save(alunos2, file="alunos2.Rdata")
> dir() # Para verificar quais são os aqruivos na pasta
[1] "alunos.csv" "alunos2.Rdata"
> rm(alunos2) # alunos2 não existe mais na sessão
> load('alunos2.Rdata') # recupera alunos2
> str(alunos2)
'data.frame': 5 obs. of 5 variables:
$ id : int 1 2 3 4 5
$ Nome : Factor w/ 5 levels "Joana","José",..: 4 5 2 1 3
$ Sobrenome: Factor w/ 5 levels "Marciano","Pereira",..: 3 5 1 4 2
$ Idade : num 24 12 15 21 20
$ Sexo : Factor w/ 2 levels "F","M": 1 2 2 1 2
Alternativamente, podemos ler uma variável de texto para dentro de uma tabela.
> dados <- " idade sexo altura 13 F 1.25 15 F 1.60 10 M 1.40 "
> tabela <- read.table(header=TRUE, text=dados)
> str(tabela)
'data.frame': 3 obs. of 3 variables:
$ idade : int 13 15 10
$ sexo : Factor w/ 2 levels "F","M": 1 1 2
$ altura: num 1.25 1.6 1.4
Nos exemplos anteriores os tipos das colunas foram inferidos à partir dos dados lidos. Os campos de texto foram convertidos em fatores. O parâmetro colClasses permite que sejam informados previamente o tipo de cada coluna lida.
> alunosNotas <- "
id| aluno |nota |bolsista
1 | Marco | 5.2 |sim
2 | Ana | 7.5 |nao
3 | Celia | 2.5 |sim"
> notas <- read.table(header=TRUE, text=alunosNotas,
row.names="id", sep="|",
colClasses=c("numeric", "character", "numeric", "character"))
> str(notas)
'data.frame': 3 obs. of 3 variables:
$ aluno : chr " Marco " " Ana " " Celia "
$ nota : num 5.2 7.5 2.5
$ bolsista: chr "sim" "nao" "sim"
> # A coluna bolsista foi importada como strings.
> # Para transformá-la em uma coluna de valores lógicos podemos fazer
> notas$bolsista <- notas$bolsista=="sim"
> str(notas)
'data.frame': 3 obs. of 3 variables:
$ aluno : chr " Marco " " Ana " " Celia "
$ nota : num 5.2 7.5 2.5
$ bolsista: logi TRUE FALSE TRUE
Se um arquivo *.csv se encontra na web, disponível através de protocolo http (como o arquivo na url usada abaixo, do site Sample Videos) podemos usar sua url:
> url <- "https://www.sample-videos.com/csv/Sample-Spreadsheet-10-rows.csv"
> dadosCsv <- read.csv(url)
> # A função carrega um data frame em dadosCsv
Se a página da web usa o protocolo https (mais seguro que o anterior) podemos usar o pacote RCurl. Como exemplo vamos baixar um arquivo diponibilizado pela cidade de Seattle, EUA (King County Open Data), contendo dados sobre animais de estimação perdidos:
Com frequência dados baixados da internet contém falhas como, por exemplo, uma entrada em texto em uma coluna numérica. Estes dados precisam ser visualizados e tratados antes de uma análise de sua informação. Podemos vizualizar estes dados de forma gráfica usando a função View() que exibe em tabela um dataframe.
Importando planilhas
O pacote xlsx depende para seu funcionamento dos pacotes rJava e xlsxjars, bem como uma instalação funcional do Java em seu computador.
Para importar uma planilha do Excel ou Libre Office Spreadsheet podemos exportar estes dados para um arquivo *.csv e importá-lo usando as técnicas já descritas. Alternativamente é possível importar diretamente estas planilhas usando o pacote xlsx, que deve ser instalado antes do uso. Planilhas podem ser importadas com as funções read.xlsx e read.xlsx2 que têm a seguinte sintaxe:
vetor numérico indicando linhas a serem extrarídas. Se NULL todas as linhas, exceto se startRow, endRow são especificados.
colIndex
vetor numérico indicando colunas a serem extrarídas. Se NULL todas as colunas.
as.data.frame
valor lógico. Se TRUE os dados serão montados em um data.frame. Se FALSE, uma lista, com um elemento por coluna.
header
valor lógico indicando que a primeira linha contém os nomes das colunas.
colClasses
(read.xlsx) vetor de strings com a classe de cada coluna.
keepFormulas
valor lógico. Se TRUE as fórmulas do excel são mostradas como texto e não avaliadas.
encoding
codificação para strings na planilha.
startRow
numérico, especificando índice da 1ª linha. (Ativo se rowIndex=NULL).
endRow
numérico, especificando índice da última linha. Se NULL, todas as linhas. (Ativo se rowIndex=NULL).
password
senha para a pasta de trabalho.
…
outros argumentos para a data.frame. Ex. stringsAsFactors
A função read.xlsx procura adequar o tipo lido com o da planilha de acordo com cada coluna, preservando o tipo de dado lido. read.xlsx2 é mais rápida, adequada para ser usada em planilhas muito grandes, acima de 100 mil células. Ambas podem ser usadas para ler arquivos *.xlsx ou *.xls.
> library(xlsx)
> xlFrame <- read.xlsx("planilha.xlsx",1, header=TRUE); xlFrame
Data Local Crédito Débito
1 43223 Casa Coral 1002.56 65.45
2 43224 Fornecedor 1 23.34 NA
3 43225 Cliente 2 24.34 33.00
4 43226 Fornecedor 2 15.23 54.00
> # Valor não existente na planilha foi lido como 'NA'
> # A data foi lida como um campo numérico.
Gravando dados em uma planilha Excel
As funções write.xlsx e write.xlsx2 podem ser usadas para gravar dados de uma tabela em uma pasta de trabalho Excel. A segunda delas atinge uma performance melhor para planilhas longas, acima de 100 mil células.
valor lógico. Se TRUE os nomes das colunas de x são escritos no arquivo.
row.names
valor lógico. Se TRUE os nomes das linhas de x são escritos no arquivo.
append
valor lógico. Se TRUE o arquivo é lido no disco e incrementado.
showNA
valor lógico. Se FALSE valores NA são gravados em branco.
password
senha para a pasta de trabalho.
…
outros argumentos passados para addDataFrame (no caso de read.xlsx2).
Para exibir o comportamento destas funções usamos o data.frame USArrests (que vem instalado no pacote básico de R).
Primeiro criamos uma planilha com nome USA-ARRESTS. Depois gravamos em outra planilha na mesma pasta o dataframe alunos que temos carregado em nossa sessão.
O resultado é a gravação, em disco, de uma pasta de trabalho com duas planilhas com nomes USA-ARRESTS e alunos.
Existem outros pacotes destinados à manipulação de arquivos de planilhas. Entre eles citamos os pacotes XLConnect e openxlsx. Este último não depende de Java.
Manipulação de arquivos XML
XML (Extensible Markup Language) é um formato de transmissão de dados bastante usado na internet e computação em geral, usando apenas texto puro (ASCII). Ele contém tags de marcação que descrevem a estrutura dos dados.
Instale o pacote usando
install.packages("XML")
No R se pode ler e escrever em arquivos XML usando o pacote "XML". Para experimentar com a biblioteca usaremos um arquivo ASCII com o conteúdo abaixo, que gravaremos no disco com o nome livros.xml.
<biblioteca>
<livro>
<id>1</id>
<titulo>A Dança do Universo</titulo>
<autor>Marcelo Gleiser</autor>
</livro>
<livro>
<id>2</id>
<titulo>DNA: O Segredo da Vida</titulo>
<autor>James D. Watson</autor>
</livro>
<livro>
<id>3</id>
<titulo>Uma breve história do tempo</titulo>
<autor>Stephen W. Hawking</autor>
</livro>
<livro>
<id>4</id>
<titulo>Como a mente funciona</titulo>
<autor>Steven Pinker</autor>
</livro>
<livro>
<id>5</id>
<titulo>A falsa medida do homem</titulo>
<autor>Stephen Jay Gould</autor>
</livro>
<livro>
<id>6</id>
<titulo>O último teorema de Fermat</titulo>
<autor>Simon Singh</autor>
</livro>
</biblioteca>
O código seguinte carrega este arquivo para um objeto do R e o manipula.
> # Carrega os pacotes necessários
> library("XML", "methods")
> # Importa dados para um objeto de R
> livros <- xmlParse(file="livros.xml", encoding="UTF8" )
> class(livros) # "XMLInternalDocument" "XMLAbstractDocument"
> print(livros)
<biblioteca>
<livro>
<id>1</id>
<titulo>A Dança do Universo</titulo>
<autor>Marcelo Gleiser</autor>
</livro>
... (outros 5 livros)
</biblioteca>
> xmlTop <- xmlRoot(livros) # node principal > class(xmlTop)
[1] "XMLInternalElementNode" "XMLInternalNode" "XMLAbstractNode"
> xmlName(xmlTop) # nome do node principal
[1] "biblioteca"
> xmlSize(xmlTop) # tamanho do node principal
[1] 6
> xmlName(xmlTop[[1]]) # nome do primeiro node
[1] "livro"
> xmlSize(xmlTop[[1]]) # tamanho do primeiro node
[1] 3
> print(xmlTop[[2]]) # exibe o segundo node
<livro>
<id>2</id>
<titulo>DNA: O Segredo da Vida</titulo>
<autor>James D. Watson</autor>
</livro>
> xmlTop[[3]][[2]] # segundo ítem do terceiro node
<titulo>Uma breve história do tempo</titulo>
> # Dados podem ser recuperados usando-se o nome dos nodes
> xmlTop[["livro"]][["autor"]]
<autor>Marcelo Gleiser</autor>
> # Convert um objeto xml para um dataframe
> dfLivros <- xmlToDataFrame(livros) > # Visualiza o dataframe
> View(df.livros, "Dataframe Livros")
A função View() exibe o dataframe como na figura abaixo:
Conexão com banco de dados
Naturalmente, grande parte dos dados a serem analisados estão armazendos em bancos de dados relacionais. R pode se relacionar com diversos dos sistemas de gerenciamento, entre eles os mais populares como SQL Server, Access, MySQL, Oracle, PostgreSQL e SQLite. Existem pacotes que permitem o acesso direto aos drivers nativos destes sistemas e outros que permitem esse acesso via ODBC ou JDBC. Desta forma o poder das consultas SQL amplia bastante o potencial de R na análise de dados.
Usando a interface ODBC
Uma forma comum de acessar bancos de dados de dentro do R é através do pacote RODBC que permite a conexão com qualquer DBMS (Data Base Management System) que admite conexão com o driver ODBC (como é o caso de todos os sistemas listados acima). Para isso é necessário instalar o driver ODBC apropriado para o banco de dados a ser usado, na plataforma específica. Em seguida se instala o pacote ODBC, usando install.packages("RODBC"). As funções básicas do pacote são:
escreve ou atualiza um data frame para tabela da base
sqlDrop(channel,sqltable)
remove uma tabela do bando de dados
close(channel)
fecha a conexão
O pacote RODBC permite a comunicação bidirecional entre R e o banco de dados, que pode ser lido ou alterado. Suponha que um banco de dados possua duas tabelas possua, digamos debito e credito. É possível importá-las para dentro de uma sessão fazendo:
Nem todos os pacotes estão disponíveis em todas as plataformas. Confira a documentação do CRAN.
A função sqlQuery() pode ser usada para a aplicação de qualquer instrução SQL, permite uma seleção detalhada de variáveis, a criação de novos campos, alteração e inserção de dados no banco.
Usando o pacote DBI
O pacote DBI (DataBase Interface) fornece outra forma de acesso à DBMS com suporte à diversos drivers. Entre eles estão os pacotes RJDBC (acesso ao driver JDBC), RMySQL, ROracle, RPostgreSQL e RSQLite.
> library(DBI)
> library(RSQLite)
> banco <- "chinook.db"
> driver <- dbDriver("SQLite")
> db <- dbConnect(driver, banco)
> # Para exibir qual banco está associado a este objeto:
> db
<SQLiteConnection>
Path: /home/guilherme/Projetos/R/Aprendendo/chinook.db
Extensions: TRUE
> # Lista de tabelas em chinook.db
> dbListTables(db)
[1] "albums" "artists" "customers" "employees" "genres"
[6] "invoice_items" "invoices" "media_types" "playlist_track" "playlists"
[11]"sqlite_sequence" "sqlite_stat1" "sqlite_stat4" "tracks"
> # Lista de campos na tabela 'albums'
> dbListFields(db, "albums")
[1] "AlbumId" "Title" "ArtistId"
> sql <- "SELECT AlbumId, Title FROM albums"
> db <- dbConnect(driver, banco)
> rs <- dbSendQuery(db, sql)
> rs
<SQLiteResult>
SQL SELECT AlbumId, Title FROM albums
ROWS Fetched: 0 [incomplete]
Changed: 0
> dbColumnInfo(rs)
name type
1 AlbumId integer
2 Title character
> dbGetStatement(rs)
[1] "SELECT AlbumId, Title FROM albums"
> albuns <- fetch(rs, n = 5) > albuns
AlbumId Title
1 1 For Those About To Rock We Salute You
2 2 Balls to the Wall
3 3 Restless and Wild
4 4 Let There Be Rock
5 5 Big Ones
> # Lista de campos na tabela 'artists'
> dbListFields(db, "artists")
[1] "ArtistId" "Name"
> sql <- "SELECT a.Title, b.Name FROM albums
a INNER JOIN artists b ON a.ArtistId = b.ArtistId
WHERE b.Name LIKE \"Iron%\""
> # O resultado de uma consulta fica armazenado em rs:
> rs <- dbSendQuery(db, sql)
> # rs tem as seguintes colunas
> dbColumnInfo(rs)
name type
1 Title character
2 Name character
> # rs foi gerada pela consulta (sql query)
> dbGetStatement(rs)
[1] "SELECT a.Title, b.Name FROM albums a
INNER JOIN artists b
ON a.ArtistId = b.ArtistId
WHERE b.Name LIKE \"Iron%\""
> # O número de colunas alteradas
> dbGetRowsAffected(rs)
[1] 0
> # Para ler 5 linhas deste resultado
> linhas <- fetch(rs, n = 5) > linha
Title Name
1 A Matter of Life and Death Iron Maiden
2 A Real Dead One Iron Maiden
3 A Real Live One Iron Maiden
4 Brave New World Iron Maiden
5 Dance Of Death Iron Maiden
> dbGetRowCount(rs) # quantas colunas
[1] 5
> # Liberando o 'resultset' e a conexão
> dbClearResult(rs); dbDisconnect(db)
No código abaixo está mostrado como abrir e manipular um banco de dados PostgreSQL que deve estar instalado na máquina local. Ele lê uma tabela no banco de nome Notas que tem uma tabela categorias com campos id, idPai, categoria. Em seguida ele usa o data frame alunos que já está carregado na sessão de R com campos id, Nome, Sobrenome, Idade, Sexo e grava esta tabela no banco de dados, com nome “alunos”. Finalmente uma consulta de atualização é feita usando a conexão aberta.
> library(DBI)
> conn <- dbConnect(odbc::odbc(),
driver = "PostgreSQL Unicode",
database = "Notas",
uid = "nomeUsuario",
pwd = "senhaUsuario",
host = "localhost",
port = 5432)
> # Este db possui uma tabela 'categorias'
> categorias <- dbReadTable(conn, "categorias")
> categorias
id idPai categoria
1 10 0 Ciência
2 14 0 Literatura
3 15 14 Ficção Científica
4 11 10 Física
...
> # Uma consulta SQL
> sql <- "SELECT id, categoria FROM categorias ORDER BY categoria"
> categ <- dbSendQuery(conn, sql)
> primeiros_3 <- dbFetch(categ, n = 3) # primeiros 3 registros
> primeiros_3
id categoria
1 13 Biologia
2 10 Ciência
3 17 Phylos.net
> restante <- dbFetch(catg) # lê os demais registros
> # Gravando o data frame alunos no banco de dados, com nome "alunos"
> # data contém booleano com sucesso da operação
> data <- dbWriteTable(conn, "alunos", alunos)
> # Uma query de atualização na tabela Categorias
> sql <- "UPDATE Categorias SET categoria ='Nova categoria' WHERE id=17"
> dbSendQuery(conn, sql) # altera categoria com id = 17
O código a seguir cria um banco de dados virtual (que existe apenas na memória). Ele pode ser útil para teste, para operações provisórias ou mesmo para a criação completa de um banco até que ele esteja pronto para ser gravado em disco.
> library(DBI)
> # Cria um banco de dados SQL virtual
> conn <- dbConnect(RSQLite::SQLite(), dbname=":memory:") > dbListTables(conn)
character(0)
> dbWriteTable(conn, "mtcars", mtcars)
> dbListTables(conn)
[1] "mtcars"
> dbListFields(conn, "mtcars")
[1] "mpg" "cyl" "disp" "hp" "drat" "wt"
[7] "qsec" "vs" "am" "gear" "carb"
> dbReadTable(conn, "mtcars")
mpg cyl disp hp drat wt qsec vs am gear carb
1 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4
2 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4
3 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
> # Todas as linhas podem ser recuperadas de uma vez:
> rs <- dbSendQuery(conn, "SELECT * FROM mtcars WHERE cyl = 4")
> dbFetch(rs)
mpg cyl disp hp drat wt qsec vs am gear carb
1 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
2 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
3 22.8 4 140.8 95 3.92 3.150 22.90 1 0 4 2
4 32.4 4 78.7 66 4.08 2.200 19.47 1 1 4 1
5 30.4 4 75.7 52 4.93 1.615 18.52 1 1 4 2
(... continua, 32 linhas ...)
> dbClearResult(res)
> # Lendo o banco por partes
> rs <- dbSendQuery(conn, "SELECT * FROM mtcars WHERE cyl = 4")
> while(!dbHasCompleted(res)) {
parte <- dbFetch(res, n = 5)
print(nrow(parte))
}
[1] 5 [1] 5 [1] 1
> # Fecha o resultset e a conexão
> dbClearResult(rs); dbDisconnect(conn)
Um resumo das funções disponíveis no pacote DBI estão listadas abaixo. Para uma lista completa, com descrição detalhada de cada função e seus parâmetros consulte a R Database Interface (versão 0.5-1) na página R Documentation.
Função
Descrição
dbDriver
carrega e descarrega drivers
dbColumnInfo
informa sobre tipos em resultados
dbExecute
executa uma query e fecha o result set
dbCallProc
chama uma “stored procedure”
dbClearResult
limpa uma result set
dbDisconnect
fecha uma conexão
dbConnect
cria conexão com uma DBMS
dbDataType
determina o tipo (SQL) de um objeto
dbGetStatement
verifica a query associada a um result set
dbGetRowCount
número de linhas recuperadas até o momento
dbGetQuery
envia query, retorna resultado e limpa o result set
Uma grande quantidade de dados se encontra hoje disponível na internet. Por isso é importante aprender a acessá-los e selecionar aqueles que nos interessam. Esta busca e seleção de dados é denominada web scraping.
Embora existam dados em formato estruturado, como tabelas e até mesmos bancos de dados, muita informação na Web está sob formato não estruturado, como ocorre em muitas páginas de texto HTML. É necessário, portanto, converter essa informação em formatos mais úteis.
Em muitos casos copiar e colar conteúdo de uma página em arquivo local pode ser suficiente. Em arquivos pequenos eles podem ser organizados manualmente e os dados postos em forma de uma tabela, por exemplo com os campos separados por vírgula. Em outros casos uma página pode ser analisada por meio de reconhecimento de padrões, usando expressões regulares ou outro processo.
Muitos sites importantes, como Facebook, Twitter e LinkedIn, fornecem APIs públicas ou privadas, que facilitam a leitura de seus dados. Além disso as páginas da web são alimentadas para os browers dentro de estruturas DOM (Document Object Model), o que facilita a garimpagem de dados.
Se os dados já estão estruturados, sob a forma de um arquivo csv (por exemplo) então eles podem ser importados para a sessão de R com a função read.table ou read.csv. Em seguida eles podem ser manipulados de acordo com a conveniência da análise desejada.
> # Há um arquivo csv de teste no endereço abaixo:
> url <- "https://www.sample-videos.com/csv/Sample-Spreadsheet-100-rows.csv"
> dados <- read.table(url, sep=",")
> # A lista está disponível. Os dois primeiros elementos do campo V3 são:
> head(dados$V3, n=2)
[1] Muhammed MacIntyre Barry French
> # Arquivo sem títulos nas colunas: os campos ficam nomeados V1 até v10
> # Independente da formatação uma página pode ser baixada com:
> download.file("https://endereco_url.html", "caminhoOndeSalvar/arquivo.html")
Usando o pacote rvest
O pacotervest foi escrito por Hadley Wickham e é inspirado em bibliotecas como a Beautiful Soup, do Python. Um bom tutorial pode ser encontrado na página do Data Camp sobre o rvest.
XPath (XML Path Language) é uma especificação de pesquisa em nodes de um documento XML. Existem aplicativos e plugins nos principais browsers para facilitar esta localização. Para o Chrome uma boa ferramenta é o SelectorGadget.
No Firefox podemos usar o inspector, um ítem de menu em web developer, que pode ser aberto com CTRL-SHIFT-C.
Para ler uma página na web e analisar seu conteúdo podemos usar o pacote rvest. Nele encontramos a função read_html() que retorna um documento XML que contém toda a informação sobre a página.
Primeiro procuramos uma página na web contendo as informações que desejamos extrair. Para efeito de nosso aprendizado usamos uma páginas simples onde se exibe uma tabela dos estados brasileiros com suas populações e PIBs. Usaremos a página Lista de Estados Brasileiros com população e PIB em Excel. Ignoramos, claro, a possibilidade disponível nessa página de baixar diretamente a tabela em formato Excel. Abrindo esta página no browser abrimos (no Firefox) o web developer, inspector. Na janela de inspecção procuramos a tabela desejada. Ao movimentar o cursor do mouse sobre o elemento html a tabela fica sombreada. Clique na tabela e pressione o botão direito selecionando copy xpath. xpath é um localizador de posição dentro da página, que fica armazenado na área de transfrência. No nosso caso temos xpath = "/html/body/div[3]/div[1]/table", indicando que queremos extrair a tabela única dentro do primeiro div, dentro do terceiro div no corpo do documento html. Em seguida baixamos o conteúdo sob forma xml e depois selecionamos o node desejado usando html_nodes(xpath).
> library(rvest)
> url <- "http://www.servicos.blog.br/listas/lista-de-estados-brasileiros-com-populacao-e-pib-em-excel/"
> xPath <- "/html/body/div[3]/div[1]/table"
> # O seguinte comando armazena o conteúdo do elemento em xPath como
> populacao <- url %>%
read_html() %>%
html_nodes(xpath=xPath) %>%
html_table()
> # Da forma como foi obtida, populacao é uma lista com um elemento
> # Este elemento único é a tabela desejada
> populacao <- populacao[[1]]
> View(populacao)
O útimo comando abre a visualização da tabela:
Veremos em breve um pouco mais sobre o funcionamento do pipe%>%. Por enquanto basta saber que ele faz parte do pacote magrittr e facilita a notação para operações encadeadas, como a composição de funções:
x %>% f é equivalente a f(x)
x %>% f(y) é equivalente a f(x, y)
x %>% f %>% g %>% h é equivalente a h(g(f(x)))
Portanto a linha contendo pipes é idêntica aos seguintes comandos:
> pop <- read_html(url)
> pop2 <- html_nodes(pop, xpath=xPath)
> pop3 <- html_table(pop2) # pop3 é o mesmo que populacao, acima.
O interpretador de R processa as linhas de comandos de modo sequencial, uma linha após a outra. Muitas vezes é necessário bifurcar o código ou repetir um conjunto de linhas, dependendo de certas condições. Para isso temos os laços (loops) e testes lógicos.
Teste lógico if() e else
if(condicao){
Instruções1
} else {
Instruções2
}
A condição para o teste deve ser uma comparação lógica resultando em TRUE ou FALSE. Instruções1 serão executadas se a condição for verdadeira, Instruções2 caso contrário.
Teste vetorizado ifelse()
ifelse(condicão, valor1, valor1)
Retorna valor1 se condicao = TRUE, valor2 caso contrário.
Instrução switch()
switch(expr, valor1, ..., valorn)
Se expr é um inteiro i, retorna valori (o i-ésimo valor)
Se expr é um string os demais argumentos devem nomeados e switch
retorna valor correspondente ao name = expr.
Por exemplo:
> # Teste if/else
> n <- 17
> if (n %% 2 == 0) {
print(paste(m, " é par"))
} else {
print(paste(m, " é ímpar"))
}
[1] "17 é ímpar"
> # ifelse
> m <- 4
> ifelse(m==3, "é", "não é")
[1] "não é"
> m <- 3
> ifelse(m==3, "é", "não é")
[1] "é"
> # A função ifelse realiza internamente um
> # loop nos componentes de um vetor (ou outro objeto)
> teste <- c(1,2.3,4,5.5, 2.3, 7.3, 0.9)
> resultado <- ifelse(teste > 5, "aprovado", "reprovado")
> resultado
[1] "reprovado" "reprovado" "reprovado" "aprovado" "reprovado" "aprovado" "reprovado"
> # A operação acima tem idêntico resultado à:
> teste <- c(1,2.3,4,5.5, 2.3, 7.3, 0.9)
> resultado <- NULL
> for (i in 1:length(teste)) {
if (teste[i]>5) resultado[i] <-"aprovado"
else resultado[i]<- "reprovado"
}
> resultado
[1] "reprovado" "reprovado" "reprovado" "aprovado" "reprovado" "aprovado" "reprovado"
> # A primeira forma, além de mais compacta, é mais eficiente e rápida.
> # Uso de switch() com argumento inteiro:
> print(switch(3,"um", "dois", "três", "quatro"))
[1] "três"
> # Outros exemplos de uso de switch() abaixo, com a instrução for
Laço for()
for(condicao) {
Instruções1 ...
}
A condição para os laços for devem ser sempre do tipo var in seq, onde a variável var percorre uma sequência.
Laço while()
while(condicao) {
Instruções ...
}
Executa as instruções enquanto a condição for verdadeira. Deve-se ter o cuidado de providenciar um mecanismo de saída para este laço.
Laço repeat()
repeat() {
Instruções ...
}
Executa as instruções indefinidamente. Uma saída para este laço pode ser forçada com a instrução break.
As seguintes instruções são usados juntamente com os laços for, while e repeat
Instrução
Efeito
break
força a saída de um laço
next
pula uma iteração do laço (retornando para seu início)
return
retorna o valor de uma função
> # laço for
> for(i in c(1,3,5,7)) {print(paste(i,"^2 = ",i^2, sep =""))}
[1] "1^2 = 1"
[1] "3^2 = 9"
[1] "5^2 = 25"
[1] "7^2 = 49"
> # Laço while
> n <- 1
> while(n < 5) {
print(paste(n, "< 5"))
n<-n+1
}
[1] "1 < 5"
[1] "2 < 5"
[1] "3 < 5"
[1] "4 < 5"
> # Laço repeat, o mesmo que while(TRUE)
n <- 1
> repeat {
print(paste(n, "< 4"))
n <- n+1
if(n == 4) break
}
[1] "1 < 4"
[1] "2 < 4"
[1] "3 < 4"
> # Saltando dentro de um laço
> for (i in 1:10) {
if(i<4 | i>6) next
print(i)
}
[1] 4
[1] 5
[1] 6
> # Observe que a variável continua existindo após o loop
> print(i)
[1] 10
> # Uso de switch() com argumento inteiro:
> for (i in 1:4) print(switch(i,"um", "dois", "três", "quatro" ))
[1] "um"
[1] "dois"
[1] "três"
[1] "quatro"
> # Uso de switch() com argumento de string:
> sinto <- c("medo", "alegria")
> for (i in sinto) {
print(switch(i, triste = "alegre-se", medo = "calma", alegria = "aproveita") )
}
[1] "calma"
[1] "aproveita"
Funções do Usuário
O usuário pode criar funções em R de acordo com suas necessidades. Elas geralmente servem para armazenar uma série de instruções que será utilizada repetidamente ou apenas para organizar um bloco de código mais complexo. Funções possuem a seguinte estrutura básica:
funcao <- function(arg1, ..., argn) {
lista de Instruções
return(objeto)
}
A instrução return é opcional. Se omitida a função retornará o resultado da última operação realizada. Os colchetes podem também ser omitidos se a função consiste em apenas uma linha de código.
A função é chamada fornecendo-se seus argumentos
funcao(varg1, …, argn)
Quando ela retorna um valor que será usado em seguida atribuímos seu valor a uma variável:
var <- funcao(arg1, …, argn)
Qualquer objeto, ou nenhum, pode ser retornado pela função. Quanto aos argumentos eles podem ou não ser nomeados. Argumentos não nomeados devem ser identificados pela sua posição na chamada da função. Se forem nomeados eles podem receber valores default na definição da função que serão usados caso sejam omitidos quando a função é invocada.
> funcao1 <- function(x, y) {
z <- x+y
return(x + y^z) }
> funcao1(2, 3)
[1] 245
> # O mesmo resultado seria obtido se omitíssemos a instrução return:
> funcao1 <- function(x, y) x + y^(x+y)
> # Com argumentos nomeados e com valores default:
> funcao2 <- function(inicio=1,fim=10) {
v <- inicio:fim
return(v) }
> funcao2()
[1] 1 2 3 4 5 6 7 8 9 10
> funcao2(5) # apenas o primeiro arg é fornecido
[1] 5 6 7 8 9 10
> funcao2(,5) # segundo arg é reconhecido pela posição
[1] 1 2 3 4 5
> funcao2(fim=13) # segundo arg é reconhecido pelo nome
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13
> # A instrução return não é obrigatória,
> # nem os colchetes para uma função de única linha
modulo <- function(z) sqrt(Re(z)^2 + Im(z)^2)
> modulo(4+5i)
[1] 6.40312
> # A função tratará, sempre que possível, qualquer tipo de argumento
> funcao3 <- function(x, y) { return(x + y) }
> funcao3(c(1,2,3), c(4,5,6))
[1] 5 7 9
> # Você pode visualizar a constituição de uma função
> funcao1
function(inicio=1,fim=10) {return(inicio:fim)}
> # Para exibir seus argumento use:
> args(funcao1)
function (inicio = 1, fim = 10)
NULL
A função args() pode ser usada em sessões interativas para mostrar os argumentos de uma função. Para descobrir quais são esses argumentos e seus valores default programaticamente use a função formals().
Pode-se também especificar que um argumento é nulo se não for declarado explicitamente na chamada da função como, por exemplo, em:
f <- function(a, b = 1, c = NULL) {...}.
Neste caso deve-se testar no corpo da função se o argumento foi fornecido, antes de usá-lo. É importante notar que uma variável inicializada dentro do corpo de definição da função tem seu escopo limitado à esta função (e não pode ser usada fora dela).
A instrução de return, embora não obrigatória, pode ser útil para interromper o fluxo de comandos, forçando o término da função. No exemplo abaixo calculamos, apenas como exercício, o fatorial de um escalar. Claro que R já tem uma função fatorial embutida que calcula fatorial em vetores e matrizes.
> fat <- function(n) {
m <- as.integer(n)
if (length(n)!=1) return("O argumento deve ser um escalar")
if (m!=n) return("O argumento deve ser inteiro")
if (m<0) return("O argumento deve ser positivo")
return(ifelse(m==0, 1, prod(1:m))
}
> fat(4.3)
[1] "O argumento deve ser inteiro"
> fat(-3)
[1] "O argumento deve ser positivo"
> fat(1:2)
[1] "O argumento deve ser um escalar"
> fat(0)
[1] 1
> fat(9)
[1] 362880
> # Usando factorial
> u <- 1:9
> dim(u)<-c(3,3)
> u
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
> factorial(u)
[,1] [,2] [,3]
[1,] 1 24 5040
[2,] 2 120 40320
[3,] 6 720 362880
O argumento ... (3 pontos) tem um significado especial em R. Ele indica que um número indeterminado de argumento podem ser passados para a função e é particularmente útil quando existe outra função aninhada (com muitos argumentos) no corpo da primeira.
Observação: Fizemos uso das funções is.character(var) e is.null(var) que testam, respectivamente, se a variável var é do tipo character ou null. Muitas outras funções de teste existem e são muito úteis, principalmente em scripts. Associadas a elas estão as funções de conversão que forçam a transformação de um tipo em outro, quando possível.
Algumas destas funções estão listadas abaixo:
Os seguintes operadores matemáticos estão definidos em R:
Operador
Descrição
Exemplo
+
adição
–
subtração
*
multiplicação
/
divisão
3/2 = 1.5;
^ ou **
exponenciação
3^2 = 6, 2**3 = 8
%%
módulo
9 %% 2 = 1
%/%
divisão inteira
9 %/% 2 = 4
Os seguintes operadores lógicos estão definidos:
Operador
Descrição
Exemplo
<
menor que
5 < 7 = TRUE
<=
menor ou igual
3 <= 9 = TRUE
>
maior que
5 > 7 = FALSE
>=
maior ou igual
7 >= 7 = TRUE
==
igual
3 == 5 = FALSE
!=
diferente
3 != 5 = TRUE
!x
não x
!(7 < 3) = TRUE
x | y
x ou y
c(T, T, F) & c(T, F, F) = (T, T, F)
x || y
ou (apenas 1º elemento examinado)
c(T, F, F) || c(F, F, F) = TRUE
x & y
x e y
c(T, T, F) & c(T, F, F) = (T, F, F)
x & y
e (apenas 1º elemento examinado)
c(T, F, F) && c(F, F, F) = FALSE
isTRUE(x)
verifica se x é TRUE
isTRUE(7 < 9) = TRUE
Outros operadores:
Operador
Descrição
Exemplo
: (dois pontos)
cria uma sequência de números
2:6 = (2, 3, 4, 5, 6)
%in%
pertence
3 %in% 1:4 = TRUE,5 %in% 1:4 = FALSE
%*%
multiplicação de matrizes por sua transposta
A %*% t(A)
any(condição sobre x)
TRUE se algum elemento de x satisfaz a condição
any(x==9)
all(condição sobre x)
TRUE se todos os elementos de x satisfazem a condição
all(x!=9)
Nos elementos de um vetor as operações ocorrem entre componentes de mesma posição em cada vetor.
> # Usando dois vetores de mesmo comprimento
> u <- c(1,2,3,4,5) > v <- c(5,4,3,2,1) > u+v
[1] 6 6 6 6 6
> u-v
[1] -4 -2 0 2 4
> u*v
[1] 5 8 9 8 5
> u**v
[1] 1 16 27 16 5
> u %% v
[1] 1 2 0 0 0
> u %/% v
[1] 0 0 1 2 5
> media <- (u + v) / 2 > media
[1] 3 3 3 3 3
> # Se os operandos têm comprimentos diferentes então um deve
> # ter comprimento múltiplo do outro. n cópias do vetor menor
> # serão usadas na operação e o resultado terá o tamanho do maior.
> u + c(1,2,3)
[1] 2 4 6 5 7
Warning message:
In u + c(1, 2, 3) :
longer object length is not a multiple of shorter object length
> u + 10
[1] 11 12 13 14 15
> w <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) > u+w
[1] 2 4 6 8 10 7 9 11 13 15
w/u
[1] 1.000000 1.000000 1.000000 1.000000 1.000000
[6] 6.000000 3.500000 2.666667 2.250000 2.000000
># Lembrando que u = (1,2,3,4,5)
> any(u > 4)
[1] TRUE
> any(u > 5)
[1] FALSE
> all(u < 4)
[1] FALSE
Comparações lógicas entre vetores também são efetuadas entre elementos, um a um.
> u > v
[1] FALSE FALSE FALSE TRUE TRUE
> x <- 1:10 > x
[1] 1 2 3 4 5 6 7 8 9 10
> x[x < 3 | x > 7]
[1] 1 2 8 9 10
> x[x > 2 & x < 8] [1] 3 4 5 6 7 >
> # O operador %in% busca valores entre todos de um vetor
> # Lembrando que u = (1, 2, 3, 4, 5)
> 1 %in% u
[1] TRUE
> 6 %in% u
[1] FALSE
Lembrando que x = 1:10, vamos verificar com maior detalhe a operação:
x[x < 3 | x > 7] = (1, 2, 8, 9, 10)
Por partes:
x < 3 = (T, T, F, F, F, F, F, F, F, F)
x > 7 = (F, F, F, F, F, F, F, T, T, T)
x < 3 | x > 7 = (T, T, F, F, F, F, F, T, T, T)
Finalmente
x[(T, T, F, F, F, F, F, T, T, T)] = (1, 2, 8, 9, 10)
Portanto selecionamos os componentes do vetor x que são menores que 3 ou maiores que 7.
Operações pode ser realizadas entre membros de outros objetos compostos. Por exemplo, usando um data frame:
> mdata<-data.frame(x = c(2, 2, 6, 4), y = c(3, 4, 2, 8)) > mdata
x y
1 2 3
2 2 4
3 6 2
4 4 8
> attach(mdata)
> mdata$soma <- x + y > mdata$media <- (x + y)/2 > detach(mdata)
> # As operações acima acrescentaram dois novos campos à mdata:
> mdata
x y soma media
1 2 3 5 2.5
2 2 4 6 3.0
3 6 2 8 4.0
4 4 8 12 6.0
> # O mesmo tipo de operação pode ser feita de forma
> # alternativa usando-se a função transform
> valores <- data.frame(x=c(1,4,6,8), y=c(1,3,5,7))
> valores <- transform(valores, soma = x+y, media = (x+y)/2, teste = x>y)
> valores
x y soma media teste
1 1 1 2 1.0 FALSE
2 4 3 7 3.5 TRUE
3 6 5 11 5.5 TRUE
4 8 7 15 7.5 TRUE
Funções internas
Quase toda a funcionalidade do R é obtida através de funções. Um grande número delas faz parte do bloco básico, carregado por default, e muitas outras podem ser utilizadas através da instalação de pacotes (packages).
Funções numéricas
Função
Descrição
abs(x)
\(\left|x\right|\), valor absoluto
sqrt(x)
\(\sqrt x\), raiz quadrada
ceiling(x)
menor inteiro acima: ceiling(3.475) = 4
floor(x)
maior inteiro abaixo: floor(3.475) = 3
trunc(x)
truncamento: trunc(5.99) is 5
round(x, digits=n)
arredondamento: round(3.475, digits=2) = 3.48
signif(x, digits=n)
n dígitos significantes: signif(3.475, digits=2) = 3.5
cos(x), sin(x), tan(x)
funções trigonométricas, seno, cosseno, tangente
acos(x), cosh(x), acosh(x)
outras funções trigonométricas
log(x)
\(\ln(x)\) logaritmo natural (base e)
log10(x)
\(\log(x)\), logaritmo de base 10
exp(x)
\(e^x\), exponencial
Funções de texto
Função
Descrição
substr(x, a, b)
retorna ou substitui parte de uma string x, da posição a até b.
sub(texto1, texto2, x)
substitui, na string x, o texto1 pelo texto2.
grep(padrao, x , ignore.case=FALSE, fixed=FALSE)
Procura padrao em x. Se fixed = FALSE o padrão é uma expressão regular, caso contrário um texto simples. Retorna índice de localização.
strsplit(x, sep)
Quebra o vetor x em sep.
paste(…, sep=”-“)
Concatena strings usando a string sep como separador.
paste(…, collapse=”-“)
Monta uma única string com partes do argumento, usando collapse como separador.
toupper(x)
retorna texto em letras maiúsculas
tolower(x)
retorna texto em letras minúsculas
nchar(x)
retorna o comprimento da string x
> # Retornar uma substring
> substr("abcdef",3,5)
[1] "cde"
> cores <- c("azul escuro", "verde escuro", "preto")
> substr(cores, 1, 5)
[1] "azul " "verde" "preto"
> # Substituir caracteres
> sub("strings", "texto", "Trocar strings")
[1] "Trocar texto"
> # A substituição pode ser feita em todos os componentes do vetor
> sub("escuro", "claro", cores)
[1] "azul claro" "verde claro" "preto"
> # Partir texto
> strsplit("as casas de maria", " ")
[[1]]
[1] "as" "casas" "de" "maria"
> strsplit("ABCDEF", "BC")
[[1]]
[1] "A" "DEF"
> strsplit("ABCDEF", "")
[[1]]
[1] "A" "B" "C" "D" "E" "F"
> # As funções agem em todos os comonentes do objeto
> x <- c("estudar", "R", "no site") > substr(x,1,2)
[1] "es" "R" "no"
> # Uso se expressão regular
> s <- "www.phylos.net" > sub("p.+s","filosofia", s)
[1] "www.filosofia.net"
> toupper("falando alto")
[1] "FALANDO ALTO"
> tolower("Não GRITE")
[1] "não grite"
> # Para juntar strings:
> paste("primeiro", "segundo", "terceiro")
[1] "primeiro segundo terceiro"
> paste("primeiro", "segundo", "terceiro", sep = ", ")
[1] "primeiro, segundo, terceiro"
> # Valores numéricos são convertidos em strings
> paste(1,2,3, sep="-")
[1] "1-2-3"
> paste(1,2,3, sep="")
[1] "123"
> paste("tentativa", 1)
[1] "tentativa 1"
> tent <- paste("tentativa", 1:5) > tent[5]
[1] "tentativa 5"
Funções Auxiliares Úteis
Função
Descrição
seq(from, to, by)
gera sequência numérica (início, fim, passo)
rep(x, times=n)
repete x n vezes
cut(x, n)
divide variável contínua (numérica) em fator com n níveis
pretty(x,n)
divide variável contínua em n intervalos
cat(… , file = nomeArquivo, append = FALSE)
concatena objectos em …e os envia para o console ou arquivo nomeArquivo (se existir)
> seq(12, 30, 2)
[1] 12 14 16 18 20 22 24 26 28 30
> # Forçando o resultado a ter 5 elementos
> seq(from=0, to=20, length.out=5)
[1] 0 5 10 15 20
> rep("ha", times=4)
[1] "ha" "ha" "ha" "ha"
> # Repetindo cada elemento n vezes
> rep(c(1,2,3), each=2)
[1] 1 1 2 2 3 3
> $ Repete o primeiro elemento 4 x, o segundo 2 x
> rep(c("a", "b"), times = c(4,2))
[1] "a" "a" "a" "a" "b" "b"
> # cut permite a criação de fator. Abaixo, com 4 níveis:
> idades <- c(12, 14, 16, 17, 34, 32, 12, 12, 11) > cut(idades, breaks=4)
[1] (11,16.8] (11,16.8] (11,16.8] (16.8,22.5] (28.2,34]
[5] (28.2,34] (11,16.8] (11,16.8] (11,16.8]
Levels: (11,16.8] (16.8,22.5] (22.5,28.2] (28.2,34]
> # Uso de pretty
> pretty(1:20, n=2)
[1] 0 10 20
> pretty(1:20, n=10)
[1] 0 2 4 6 8 10 12 14 16 18 20
> # Uso de cat
> nome <- "Ana" > cat("Olá",nome,"\b.\n", "\t \"Bom dia!\"")
Olá Ana.
"Bom dia!"
Usamos na linha de demonstração de cat() usamos as sequências de escape\n (newline), \b (backspace), \t (tab), \" (aspas duplas)
Funções úteis para a manipulação de Objetos
Listamos em seguida algumas das funções importantes para a leitura e edição de objetos.
Função
Descrição
length(obj)
retorna o número de elementos ou componentes do objeto
dim(obj)
retorna as dimensões do objeto.
str(obj)
exibe a estrutura do objeto.
head()
lista os seis primeiros elementos do objeto
tail()
lista os seis últimas elementos do objeto
class(obj)
retorna a classe do objeto.
mode(obj)
exibe como o objeto foi armazenado
names(obj)
exibe os nomes de componentes do objeto
c(obj1, …, objn)
concatena objetos em um vector
cbind(obj1, …, objn)
combina objetos em colunas
rbind(obj1, …, objn)
combina objetos em linhas
obj, print(obj)
exibe / imprime objeto.
head(obj)
lista a primeira parte do objeto
tail(obj)
lista a parte final do objeto
ls()
exibe lista dos objetos carregados, equivalenta à função objects()
rm(obj1, …, objn)
remove um ou mais objetos
rm(list = ls())
)remove todos os objetos
novoObj <- edit(obj)
edita objeto e o armazena como novoObj
fix(obj)
edita objeto salvando nele as alterações
Data e Hora
Datas são armazenadas internamente no R como o número de dias decorridos desde 01/01/1970. Datas anteriores são representadas como números negativos.
Função
Descrição
as.Date(string)
converte a string em uma data
Sys.Date( )
retorna a data de hoje
date()
retorna data e hora corrente
data2 – data1
retorna a diferença entre data1 e data2 em dias
as.character(data)
retorna a data como um string
format(data, format=strDeFormato)
formata a data segundo o string de formatação
weekdays(data)
dia da semana correspondente a data (ou datas)
months(data)
mês não abreviado correspondente a data (ou datas)
quarters(data)
Quarter (Q1, Q2, Q3, Q4)
seq(from=data1, to=data2, by=n)
sequência de datas de data1 até data2, em passos n (dias)
> # Data do sistema (um string, formato ano/mês/dia)
> Sys.Date()
[1] "2018-11-23"
> # Transforma esta string em uma data
> data1 <- as.Date(Sys.Date()) > # Soma 250 dias à data1
> data2 <- data1 + 250 > data2 - data1
[1] Time difference of 250 days
> # Sequência de datas começando em data1 até data2 com passos de 50 dias
> seq(from=data1, to=data2, by=50)
[1] "2018-11-23" "2019-01-12" "2019-03-03"
[4] "2019-04-22" "2019-06-11" "2019-07-31"
> # Produz sequência de datas de data1 até data2 com 5 elementos
> seq(from=data1, to=data3, length.out=5)
[1] "2018-11-23" "2019-01-24" "2019-03-28"
[4] "2019-05-29" "2019-07-31"
> weekdays(data1)
[1] "sexta"
> months(data1)
[1] "novembro"
> quarters(data1)
[1] "Q4"
> format(data1, "%d/%m/%y")
[1] "23/11/18"
> format(data1, "%d/%m/%Y")
[1] "23/11/2018"
> format(data1, "%A, %d de %B de %Y")
[1] "sexta, 23 de novembro de 2018"
> # As funções se aplicam a vetores e outros objetos
> strData <- c("01/05/1965", "08/16/1975")
> datas <- as.Date(strDatas, "%m/%d/%Y") > datas
[1] "1965-01-05" "1975-08-16"
> Para lidar com o formato brasileiro de dia/mes/ano podemos fazer
> dBr <- as.Date("23/11/2018", "%d/%m/%Y") > dBr
[1] "2018-11-23"
Os seguintes símbolos (ou máscaras) podem ser usados com datas. Os resultados dependem das configurações de data/hora locais, que podem ser visualizadas com o comando Sys.localeconv().
Símbolo
Descrição
Exemplo
%d
dia, numérico
01 a 31
%a
dia da semana, abreviado
Mon, (Seg)
%A
dia da semana por extenso
Monday (segunda)
%m
mês, numérico
01 a 12
%b
nome do mês, abreviado
Feb, (Fev)
%B
nome do mês por extenso
February, (Fevereiro)
%y
ano em 2 dígitos
18
%Y
ano em 4 dígitos
2018
Funções Estatísticas
Função
Descrição
mean(x, trim=0,na.rm=FALSE)
média do objeto x
sd(x)
desvio padrão do objeto x
var(x)
variância
mad(x)
desvio absoluto médio
median(x)
mediana
quantile(x, probs)
quantil de x, probs= vetor numérico com probabilidades em [0,1]
range(x)
intervalo
sum(x)
soma
diff(x, lag=1)
diferenças defasadas, lag = defasagem a usar
min(x)
mínimo de x
max(x)
máximo de x
scale(x, center=TRUE, scale=TRUE)
centro da coluna ou padronizar uma matriz
> x <- c(123, 234, 345, 242, 34, 100, NA)
> mean(x)
[1] NA
> # mesma operação ignorando valor NA
> mean(x, na.rm=TRUE)
[1] 179.6667
> # redefinindo x
> x <- c(123, 234, 345, 242, 34, 100)
> sum(x)
[1] 1078
> range(x)
[1] 34 345
> min(x)
[1] 34
> max(x)
[1] 345
> mean(x)
[1] 179.6667
> # Eliminando valores 20% nas bordas da amostra
> mean(x, trim=.2)
[1] 174.75
> sd(x)
[1] 113.9731
> var(x)
[1] 12989.87
> mad(x)
[1] 105.2646
> median(x)
[1] 178.5
A tabela seguinte lista funções relacionadas com distribuições probabilísticas. Para gerar sequências pseudo-randômicas (que podem ser replicadas mais tarde) use set.seed(1234) (ou outro inteiro).
Distribuição uniforme, segue mesmo padrão
que a distribuição normal acima.
Voltaremos ao estudos destas funções mais tarde.
A Distribuição Normal
Por completeza listamos aqui algumas funções de distribuição de probabilidades. As funções de densidade, de distribuição, quantil e a geração aleatória para a distribuição normal podem ser obtidas com média e desvio padrão especificados.
A função rnorm gera dados aleatórios com distribuição normal:
onde \(\mu\) é a média da distribuição e \(\sigma\) é o desvio padrão.
dnorm fornece a densidade, pnorm a função de distribuição, qnorm a função quantil, rnorm gera os desvios aleatórios. O comprimento do resultado é determinado por n para rnorm. Para as demais funções ele é igual ao maior comprimento dos argumentos numéricos.
Os argumentos numéricos (exceto de n) são reciclados para o tamanho do resultado. Apenas os primeiros elementos dos argumentos lógicos são usados.
> x <- pretty(c(-3,3), 100)
> y <- dnorm(x)
> plot(x, y, type = "l", xlab = "Desvio Normal", ylab = "Densidade")
Distribuição normal
Este código gera o gráfico exibido à direita. Veremos em breve maiores detalhes sobre o uso da função plot() usada para gerar o gráfico.
A distribuição normal é uma das mais utilizadas na modelagem dos fenômenos naturais e das ciências naturais e sociais. Ela é também chamada de distribuição de Gauss ou de Laplace–Gauss, em referência aos matemáticos Pierre-Simon Laplace (1749-1827) e Carl Friedrich Gauss (1777-1855).
Vimos nos exemplos acima que uma fatia (ou slice) palavra[i:f] se inicia em i e termina em f, exclusive. Os índices, e todas as contagens em python se iniciam em 0. A posição final não é incluida de forma que 
O Python pode ser executado de várias formas diferentes. Existem bons editores e IDEs (Integrated Devolopment Environment) tais como o Pycharm, Geany, Spyder. Para esse tutorial usaremos o 
Python é uma linguagem de programação de alto nível, interpretada e de propósito geral, criada por Guido van Rossum em 1985 e em franco desenvolvimento desde então. Ela está disponível sob a licença GPL (GNU General Public License). Ela permite o uso interativo, com o usuário digitando as linhas de código e obtendo o resultado imediatamente, ou através de lotes (batches), com as linhas de código armazenadas em arquivos e executadas em grupo. Apesar de ser chamada de linguagem de script é possível criar aplicativos completos, na web ou para desktop, com interfaces gráficas modernas e eficientes. Além disso existe a possibilidade de gerar arquivos compilados e executáveis usando 
NumPy
Nem todos os browsers podem exibir corretamente todos os símbolos. Um código na primeira coluna da tabela representa uma falha de exibição. Passe o mouse sobre os caracteres da 1ª coluna para ampliar.
Aquisição de Dados
> # grava arquivo hiperbole.jpg
> jpeg(file='hiperbole.jpg')
> # plota gráfico
> plot(x<- -100:100, 1/x, type='l', main="hipérbole")
> # fecha janela gráfica
> dev.off()
> # Grava arquivo jpeg com a imagem à direita.
> x <- 1:100; y <- sqrt(x)
> plot(x,y, type="l")
> text(locator(1), "x é aqui!")
> text(locator(1), "y é aqui!")
> text(locator(5), paste("<", 1:4, ">")
> # A linha acima marca 4 pontos
> # no gráfico, com o texto:
> # "<1>", "<2>", "<3>", "<4>"
> # respectivamente
> attach(mtcars)
> plot(mpg ~ wt)
> abline(lm(mpg ~ wt))
> title("Regressão Linear de Consumo por Peso")
> detach(mtcars)
cores <-c("#5FC0A0", "#DE7A6B", "#6BA0DE")
> barplot(resultado,
main="Gripe: teste clínico",
xlab="Medicamento",
ylab="Eficácia",
col=cores, beside=TRUE)
> # Ordenamos o resultado por taxa de analfabetismo
> media <- media[order(media$taxa),]
> View(media) # resulta na tabela 1
> # plotando o gráfico de barras
> barplot(media$taxa, names.arg=media$regiao, col=cor)
> title("Analfabetismo nos EUA / por região"
> # resultado no gráfico abaixo
> library(plotrix)
> populacao <- c(1420, 1368, 329, 269, 212)
> pais <- c("China", "India", "EUA",
"Indonesia" , "Brasil")
> fan.plot(populacao, labels=pais,
main = "Usando o fan.plot",
col=rainbow(5))
> # O gráfico à direita é gerado.
> attach(mtcars)
> # Construimos uma densidade usando
> # mtcars$mpg (milhas por galão)
> d <- density(mpg)
> plot(d,
main="Milhas/galão (densidade kernel)")
> # Para colorir a área sob a curva
> polygon(d, col="lightblue", border="black")
> # Para inserir marcas nos valores
> # discretos que geraram a densidade
> rug(mpg, col="red")
> detach(mtcars)
Programação com R