Python, strings


Strings

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'

Alguns operadores lógicos também são permitidos.

» palavra1 = 'teste'
» palavra2 = 'Teste'

» palavra1 == palavra2
↳ False

» palavra1 != palavra2
↳ True

» 't' in palavra1
↳ True

» 'y' not in palavra1
↳ True

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
código significado
\’ aspas simples
\” aspas duplas
\\ barra invertida
\n nova linha
\r retorno de “carro”
\t tab, tabulação
\b backspace, volta 1 espaço
\f form feed
\ooo valor octal
\xhh valor hexadecimal
🔺Início do artigo

Continue a leituira: Python, testes, laços e funções

Bibliografia

Consulte a bibliografia no final do primeiro artigo dessa série.

Python, uma introdução

Programação

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:

  1. tire uma bola da caixa,
  2. verifique se é preta,
  3. se for preta faça uma marca para bolas pretas, caso contrário para as brancas,
  4. sem retornar a bola, verifique se ainda restam bolas na caixa,
  5. se ainda restam bolas, volte para a etapa (1),
  6. se acabaram as bolas, conte quantas marcas foram feitas para cada cor,
  7. 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.

Operador Significado Exemplo
> maior que x > y
>= maior ou igual a x ≥ y
< menor que x < y
>= menor ou igual a x ≤ y
== igual a x == y
!= diferente de x != y

Exemplos de uso de operações lógicas:

» num1 = 12
» num2 = 25

» print(num1 > num2)
↳ False

» print(num2 == num1 *2 +1)
↳ True

» string1 = 'isso'
» string2 = 'esse'
» print(string1 != string2)
↳ True

Execução do código em python


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.

Continue lendo…

Python, strings

🔺Início do artigo

Bibliografia

Python.org

Livros

  • Barry, Paul: Head First Python, O’Reilly, Sebastopol, 2011.
  • Ceder, Vernon: The Quick Python Book, 2 ed., Manning Publications Co., Greenwich, 2010.
  • Downey, Allen: How to Think Like a Computer Scientist, Cambridge University Press, Nova Iorque, 2009.
  • Hall, Tim; Stacey, J-P: Python 3 for Absolute Beginners, Apress, Nova Iorque, 2009.
  • Hetland, Magnus Lie: Beginning Python, From Novice to Professional, Apress, Nova Iorque, 2005.
  • Lambert, Kenneth: Fundamentals of Python: From First Programs Through Data Structures, Cengage, Boston, 2010.
  • Lee, Kent D.: Python Programming Fundamentals, Springer-Verlag, Londres, 2011.
  • Lutz, Mark:Learning Python, 4ª Edição, O’Reilly, Sebastopol, 2005.
  • Payne, James: Beginning Python, Using Python 2.6 and Python 3.1, Wiley, Indianoplis, 2010.
  • Summerfield, Mark: Programming in Python 3, a complete introduction to the Python language, Pearson, Boston, 2010.

Recursos na internet

Introdução ao Pandas – Series

O que é pandas?

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.

In [3]: serie1 = pd.Series([-1, 9, 0, 2, 5])
Out[3]:
 0   -1
 1    9
 2    0
 3    2
 4    5

À 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
fillna([value, method, axis, inplace, …]) Substitui valores NA/NaN usando método especificado
first(offset) Seleciona período inicial de uma série temporal usando offset.
first_valid_index() Retorna o índice do primeiro valor não NA/null
floordiv(serie2) Retorna divisão inteira da series por serie2, elemento a elemento
ge(serie2) Retorna serie booleana comparando se series é maior ou igual a serie2, elemento a elemento
get(key) Retorna item correspondente à key
groupby([by, axis, level, as_index, sort, …]) Agrupa a Series
gt(serie2[, level, fill_value, axis]) Retorna serie booleana comparando se series é maior que serie2, elemento a elemento
head([n]) Retorna os n primeiros valores
hist() Plota histograma da series usando matplotlib.
idxmax([axis, skipna]) Retorna o label do item de maior valor
idxmin([axis, skipna]) Retorna o label do item de menor valor
interpolate([method, axis, limit, inplace, …]) Preenche valores NaN usando metodo de interpolação
isin(valores) Booleano, se elementos da Series estão contidos em valores
isna() Booleano, se existem valores ausentes
isnull() Booleano, se existem valores nulos
item() Retorna primeiro elemento dos dados como escalar do Python
items() Iteração (lazy) sobre a tupla (index, value)
iteritems() Iteração (lazy) sobre a tupla (index, value)
keys() Alias de index
kurt([axis, skipna, level, numeric_only]) Retorna kurtosis imparcial
kurtosis([axis, skipna, level, numeric_only]) Retorna kurtosis imparcial
last(offset) Seleciona período final de uma série temporal usando offset
last_valid_index() Retorna o índice do último valor não NA/null
le(serie2) Retorna serie booleana comparando se series é menor ou igual a serie2, elemento a elemento
lt(serie2[, level, fill_value, axis]) Retorna serie booleana comparando se series é menor que serie2, elemento a elemento
mad([axis, skipna, level]) Retorna o desvio médio absoluto dos valores da series
mask(cond[, serie2, inplace, axis, level, …]) Substitui valores sob condição dada
max([axis, skipna, level, numeric_only]) Retorna o valor máximo
mean([axis, skipna, level, numeric_only]) Retorna a média dos valores
median([axis, skipna, level, numeric_only]) Retorna a mediana dos valores
memory_usage([index, deep]) Retorna a memória usada pela Series
min([axis, skipna, level, numeric_only]) Retorna o menor dos valores da series
mod(serie2[, level, fill_value, axis]) Retorna Modulo de series por serie2, elemento a elemento
mode([dropna]) Retorna a moda da Series
mul(serie2[, level, fill_value, axis]) Retorna a multiplicação de series por serie2, elemento a elemento
multiply(serie2[, level, fill_value, axis]) Retorna a multiplicação de series por serie2, elemento a elemento
ne(serie2[, level, fill_value, axis]) Retorna comparação booleana de series com serie2, elemento a elemento
nlargest([n, keep]) Retorna os n maiores elementos
notna() Booleano, se existem valores não faltantes ou nulos
notnull() Idem
nsmallest([n, keep]) Retorna os n menores elementos
nunique([dropna]) Retorna quantos elementos únicos existem na series
pad([axis, inplace, limit, downcast]) O mesmo que DataFrame.fillna() usando method=’ffill’
plot O mesmo que pandas.plotting._core.PlotAccessor
pop(item) Elimina valor da série com indice=item e retorna valor eliminado
pow(serie2) Retorna exponential de series por serie2, elemento a elemento
prod([axis, skipna, level, numeric_only, …]) Retorna o produto dos elemetos da series
product([axis, skipna, level, numeric_only, …]) Idem
quantile([q, interpolation]) Retorna valor na quantil dado
ravel([order]) Retorna os dados como um ndarray
rdiv(serie2[, level, fill_value, axis]) Executa a divisão de ponto flutuante de series por serie2, elemento a elemento
rdivmod(serie2) Retorna divisão inteira e módulo de series por serie2, elemento a elemento
reindex([index]) Ajusta a Series ao novo índice
reindex_like(serie2[, method, copy, limit, …]) Retorna um objeto com índices em acordo com serie2
rename([index, axis, copy, inplace, level, …]) Altera o nome ou labels dos índices
reorder_levels(order) Reajusta níveis de índices usando order
repeat(repeats[, axis]) Repete elementos da Series
replace([to_replace, value, inplace, limit, …]) Substitui valores em to_replace por value
reset_index([level, drop, name, inplace]) Gera nova Series reinicializando os índices
rfloordiv(serie2[, level, fill_value, axis]) Retorna divisão inteira de series por serie2, elemento a elemento
rmod(serie2[, level, fill_value, axis]) Retorna Modulo da divisão da series por serie2, elemento a elemento
rmul(serie2[, level, fill_value, axis]) Retorna multiplicação da series por serie2, elemento a elemento
round([n]) Arredonda valores da Series para n casas decimais.
rpow(serie2[, level, fill_value, axis]) Retorna a exponential de series por serie2, elemento a elemento
rsub(serie2[, level, fill_value, axis]) Retorna subtraction da series por serie2, elemento a elemento
rtruediv(serie2[, level, fill_value, axis]) Retorna divisão de ponto flutuante de series por serie2, elemento a elemento
sample([n, frac, replace, weights, …]) Retorna uma amostra randomizada de items da Series
searchsorted(value[, side, sorter]) Encontra índices de elementos de devem ser inseridos para manter a ordem
sem([axis, skipna, level, ddof, numeric_only]) Retorna erro padrão imparcial da média
skew([axis, skipna, level, numeric_only]) Retorna inclinação imparcial
sort_index([axis, level, ascending, …]) Reorganiza Series usando os labels dos índices
sort_values([axis, ascending, inplace, …]) Reorganiza Series usando seus valores
std([axis, skipna, level, ddof, numeric_only]) Retorna o desvio padrão da amostra
str Utiliza funções de string sobre elementos das series (se string). Ex. series.str.split(“-“)
sub(serie2) Retorna subtração de series por serie2, elemento a elemento
subtract(serie2) Idem
sum([axis, skipna, level, numeric_only, …]) Retorna soma dos valores da Series
tail([n]) Retorna os últimos n elemetnos
to_clipboard([excel, sep]) Copia o object para o clipboard do sistema
to_csv([path_or_buf, sep, na_rep, …]) Grava o object como arquivo csv (valores separados por vírgula)
to_dict([into]) Converte a Series para dicionário {label -> value}
to_excel(excel_writer[, sheet_name, na_rep, …]) Grava objeto como uma planilha do Excel
to_frame([name]) Converte Series em DataFrame
to_hdf(path_or_buf, key[, mode, complevel, …]) Grava dados da Series em arquivo HDF5 usando HDFStore
to_json([path_or_buf, orient, date_format, …]) Converte o objeto em uma string JSON
to_latex([buf, columns, col_space, header, …]) Renderiza objeto para LaTeX tabular, longtable, ou table/tabular aninhado.
to_lista() Retorna a lista dos valores
to_markdown([buf, mode, index, storage_options]) Escreve a Series em formato Markdown
to_numpy([dtype, copy, na_value]) Converte a series em NumPy ndarray
to_pickle(path[, compression, protocol, …]) Grava objeto serializado em arquivo Pickle
to_sql(name, con[, schema, if_exists, …]) Grava elementos em forma de um database SQL
to_string([buf, na_rep, float_format, …]) Constroi uma representação string da Series
tolist() Retorna uma lista dos valores
transform(func[, axis]) Executa func sobre elementos da serie
truediv(serie2) Retorna divisão de ponto flutuante de series por serie2, elemento a elemento
truncate([before, after, axis, copy]) Trunca a Series antes e após índices dados
unique() Retorna os valores da Series, sem repetições
update(serie2) Modifica a Series usando valores em serie2, sob índices especificados
value_counts([normalize, sort, ascending, …]) Retorna Series com a contagem de valores únicos
var([axis, skipna, level, ddof, numeric_only]) Retorna a variância imparcial dos valores da Series
view([dtype]) Cria uma nova “view” da Series
where(cond[, serie2, inplace, axis, level, …]) Substitui valores a condição cond é False
🔺Início do artigo

Bibliografia

  • 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.
  • Pandas: página oficial, acessada em janeiro de 2021.
  • Pandas User Guide, acessada em fevereiro de 2021.
  • Miller, Curtis: On Data Analysis with NumPy and pandas, Packt Publishing, Birmingham, 2018.

Marcação de Texto com Markdown

O que é Markdown

> “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
<ol>
<li>Primeiro item</li>
<li>Segundo item</li>
<li>Terceiro item</li>
<li>Quarto item</li>
</ol>
  1. Primeiro item
  2. Segundo item
  3. Terceiro item
  4. Quarto item
1. Primeiro item
1. Segundo item
1. Terceiro item
1. Indentado item
1. Indentado item
1. Quarto item
<ol>
<li>Primeiro item</li>
<li>Segundo item</li>
<li>Terceiro item
<ol>
<li>Indentado item</li>
<li>Indentado item</li>
</ol>
</li>
<li>Quarto item</li>
</ol>
  1. Primeiro item
  2. Segundo item
  3. Terceiro item
    1. Indentado item
    2. Indentado item
  4. Quarto item

Observe que não é necessário usar a numeração correta nas listas. Alguns editores completam automaticamente esses números.

Listas não numeradas são criadas com os sinais *, + ou - antes dos itens.

Markdown html Output obtido
– Primeiro item
– Segundo item
– Terceiro item
– Quarto item
<ul>
<li>Primeiro item</li>
<li>Segundo item</li>
<li>Terceiro item</li>
<li>Quarto item</li>
</ul>
  • Primeiro item
  • Segundo item
  • Terceiro item
  • Quarto item
– Primeiro item
– Segundo item
– Terceiro item
– Indentado item
– Indentado item
– Quarto item
<ul>
<li>Primeiro item</li>
<li>Segundo item</li>
<li>Terceiro item
<ul>
<li>Indentado item</li>
<li>Indentado item</li>
</ul>
</li>
<li>Quarto item</li>
</ul>
  • Primeiro item
  • Segundo item
  • Terceiro item
    • Indentado item
    • Indentado item
  • Quarto item
Blocos de código

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.

Markdown Output obtido
“` json
{
“nome”: “José”,
“sobrenome”: “Garcia”,
“idade”: 45
}
“`
{
  “nome”: “José”,
  “sobrenome”: “Garcia”,
  “idade”: 45
}

Para denotar texto em código, uma ou mais palavras, coloque-as entre acentos graves (backticks, `).

Markdown html Output obtido
Digite no prompt de comando: `nano`. Digite no prompt de comando: <code>nano</code>. Digite no prompt de comando: nano.

Imagens

Para acrescentar uma imagem use a seguinte sintaxe:


![Imagem 1](caminho/images/tux.png “Título a ser exibido”)

Tabelas

Tabelas são criadas usando-se a barra vertical | e hífens. Por exemplo, as três tabelas abaixo mostram o uso do código markdown.

Tabela (1)

| Título 1 | Título 2 | T3 |
| ‐‐‐‐‐‐‐‐‐‐‐‐| ‐‐‐‐‐‐‐‐‐‐‐‐|‐‐-‐|
| célula 1, 1 | célula 1, 2 | 1 |
| célula 2, 1 | célula 2, 2 | 2 |

Tabela (2)

| Alinhamento | Alinhamento | Alinhamento |
| :‐‐‐‐‐‐‐‐‐‐ | :‐‐‐‐‐‐‐‐‐: | ‐‐‐‐‐‐‐‐‐‐: |
| Esquerda | Centro | Direita |
| 1 | 2 | 3 |

Tabela (3)

Título | N
-|-
a|b

renderizam as tabelas (1), (2) e (3) abaixo:

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>.
Recomendo o mecanismo de busca
Duck Duck Go.
Notas de Pés de Página

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.

<u>Texto 1 sublinhado</u> ou <ins>Texto 2 sublinhado</ins><div style=”border:1px solid black; padding:10px; color:white; background-color:red;”>parei aqui &curarr;</div>


Texto 1 sublinhado ou Texto 2 sublinhado

parei aqui ↷
Latex

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}
$$

Bibliografia

Entidades HTML

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 html hexadecimal e decimal. Por exemplo, a página:

<html>
<body>
<h1>Exibindo html </h1>
<p>Símbolo de um naipe espada de baralho: &clubs; - &clubsuit; - &♣; - &#9827;.</p>
<p>Símbolo matemático da integral de contorno: &conint; - &oint; - &#x0222e; - &#8750;.
</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.

Caracteres comuns: Pontuação
Caracter HTML HEX DEC Descrição
" &quot; &#x00022; &#34; aspas
, &comma; &#x0002c; &#44; vírgula
. &period; &#x0002e; &#46; ponto final
: &colon; &#x0003a; &#58; dois pontos
; &semi; &#x0003b; &#59; ponto e vírgula
? &quest; &#x0003f; &#63; ponto de interrogação
¿ &iquest; &#x000bf; &#191; ponto de interrogação invertido
! &excl; &#x00021; &#33; ponto de exclamação
¡ &iexcl; &#x000a1; &#161; ponto de exclamação invertido
Barras e Aspas
Caracter HTML HEX DEC Descrição
&hyphen; &dash; &#x02010; &#8208; hífen
&ndash; &#x02013; &#8211; en dash
&mdash; &#x02014; &#8212; travessão
&horbar; &#x02015; &#8213; barra horizontal
| &verbar; &vert; &#x02016; &#8214; barra vertical
/ &sol; &#x0002f; &#47; barra, travessa ou tranca
\ &bsol; &#x0005c; &#92; barra reversa
_ &lowbar; &#x0005f; &#95; linha baixa
¦ &brvbar; &#x000a6; &#166; barra quebrada
&lsquo; &opencurlyquote; &#x02018; &#8216; aspas simples esquerda
&rsquo; &rsquor; &closecurlyquote; &#x02019; &#8217; aspas simples direitas
&lsquor; &sbquo; &#x0201a; &#8218; aspas baixas simples
&ldquo; &opencurlydoublequote; &#x0201c; &#8220; aspas duplas esquerdas
&rdquo; &rdquor; &closecurlydoublequote; &#x0201d; &#8221; aspas duplas direitas
&ldquor; &bdquo; &#x0201e; &#8222; aspas baixas duplas
« &laquo; &#x000ab; &#171; aspa dupla angular esquerda
» &raquo; &#x000bb; &#187; aspa dupla angular direita
Sinais Tipográficos
Caracter HTML HEX DEC Descrição
§ &sect; &#x000a7; &#167; seção (parágrafo)
&para; &#x000b6; &#182; marca de parágrafo, alínea
&blank; &#x02423; &#9251; caixa aberta
Abreviaturas
Caracter HTML HEX DEC Descrição
# &num; &#x00023; &#35; número
$ &dollar; &#x00024; &#36; cifrão
% &percnt; &#x00025; &#37; porcentagem
@ &commat; &#x00040; &#64; comercial em (arroba)
® &reg; &#x000ae; &#174; marca registrada
° &deg; &#x000b0; &#176; grau
¢ &cent; &#x000a2; &#162; 1 centésimo
¤ &curren; &#x000a4; &#164; moeda
&euro; &#x020ac; &#8364; sinal do euro
£ &pound; &#x000a3; &#163; libra
¥ &yen; &#x000a5; &#165; iene
& &amp; &#x00026; &#38; e comercial
* &ast; &midast; &#x0002a; &#42; asterisco
¬ &not; &#x000ac; &#172; negação (not)
­ &shy; &#x000ad; &#173; hífen suave
¯ &macr; &strns; &#x000af; &#175; mácron
· &middot; &#x000b7; &#183; ponto central
Espaçamento e controles
Caracter HTML HEX DEC Descrição
tab &tab; &#x00009; &#9; caracter de tabulação
newline &newline; &#x0000a; &#10; alimentação de linha (lf)
&nbsp; &nonbreakingspace; &#x000a0; &#160; espaço sem quebra | |
&ensp; &#x02002; &#8194; espaço | |
&emsp; &#x02003; &#8195; espaço | |
&emsp13; &#x02004; &#8196; espaço 1 terço | |
&emsp14; &#x02005; &#8197; espaço 1 quarto | |
&numsp; &#x02007; &#8199; espaço de figura | |
&puncsp; &#x02008; &#8200; espaço de pontuação | |
&thinsp; &thinspace; &#x02009; &#8201; espaço pequeno | |
&hairsp; &verythinspace; &#x0200a; &#8202; espaço muito pequeno | |
&zerowidthspace; &negativethickspace; &#x0200b; &#8203; espaço de largura zero |​|
&zwnj; &#x0200c; &#8204; largura zero não grudado |‌|
&zwj; &#x0200d; &#8205; largura zero grudado |‍|
&mediumspace; &#x0205f; &#8287; espaço matemático médio | |
&nobreak; &#x02060; &#8288; juntador de palavras
&invisibletimes; &it; &#x02062; &#8290; multiplicação invisível
&invisiblecomma; &ic; &#x02063; &#8291; vírgula invisível
&lrm; &#x0200e; &#8206; marca da esquerda para a direita
&rlm; &#x0200f; &#8207; marca da direita para a esquerda
&elinters; &#x023e7; &#9191; intersecção elétrica
Ícones, Símbolos
Caracter HTML HEX DEC Descrição
&starf; &bigstar; &#x02605; &#9733; estrela preta
&star; &#x02606; &#9734; estrela branca
&spades; &spadesuit; &#x02660; &#9824; naipe paus preto
&clubs; &clubsuit; &#x02663; &#9827; naipe espada preto
&hearts; &heartsuit; &#x02665; &#9829; naipe copa preto
&diams; &diamondsuit; &#x02666; &#9830; naipe ouro preto
&loz; &#9674; &#x25CA; losango branco
&sung; &#x0266a; &#9834; oitava nota
&flat; &#x0266d; &#9837; bemol musical
&natur; &natural; &#x0266e; &#9838; natural de música
&sharp; &#x0266f; &#9839; sharp, sustenido músical
&check; &checkmark; &#x02713; &#10003; marca de verificação
&cross; &#x02717; &#10007; seleção x
&malt; &maltese; &#x02720; &#10016; cruz maltesa
&sext; &#x02736; &#10038; estrela preta de seis pontas
&lozf; &blacklozenge; &#x029eb; &#10731; losango preto
© &copy; &#x000a9; &#169; direitos autorais
&os; &circleds; &#x024c8; &#9416; letra latina s maiúscula circulada
Símbolos Matemáticos: Operadores
Caracter HTML HEX DEC Descrição
+ &plus; &#x0002b; &#43; soma, mais
± &plusmn; &pm; &#x000b1; &#177; mais ou menos
× &times; &#x000d7; &#215; multiplicação
÷ &divide; &div; &#x000f7; &#247; divisão
= &equals; &#x0003d; &#61; igual
< &lt; &#x0003c; &#60; menor que
> &gt; &#x0003e; &#62; maior que
&minus; &#x02212; &#8722; menos (subtração)
&mnplus; &mp; &minusplus; &#x02213; &#8723; menos ou mais
&plusdo; &dotplus; &#x02214; &#8724; ponto mais
&radic; &sqrt; &#x0221a; &#8730; raiz quadrada
&setmn; &setminus; &ssetmn; &#x02216; &#8726; menos de conjunto
&lowast; &#x02217; &#8727; operador asterisco
&compfn; &smallcircle; &#x02218; &#8728; operador anel
&oplus; &circleplus; &#x02295; &#8853; mais circulado
&ominus; &circleminus; &#x02296; &#8854; menos circulado
&otimes; &circletimes; &#x02297; &#8855; vezes circulado
&osol; &#x02298; &#8856; divisão circulada
&odot; &circledot; &#x02299; &#8857; ponto circulado
&ocir; &circledcirc; &#x0229a; &#8858; operador de anel circular
&oast; &circledast; &#x0229b; &#8859; asterisco circulado
&odash; &circleddash; &#x0229d; &#8861; traço circulado
&plusb; &boxplus; &#x0229e; &#8862; mais quadrado
&minusb; &boxminus; &#x0229f; &#8863; menos quadrado
&timesb; &boxtimes; &#x022a0; &#8864; vezes quadrado
&sdotb; &dotsquare; &#x022a1; &#8865; ponto quadrado
&xodot; &bigodot; &#x02a00; &#10752; operador de ponto circulado n-ário
&xoplus; &bigoplus; &#x02a01; &#10753; operador n-áry com círculo plus
&xotime; &bigotimes; &#x02a02; &#10754; operador de tempos circulados n-ário
&xuplus; &biguplus; &#x02a04; &#10756; operador de união n-ária com mais
&xsqcup; &bigsqcup; &#x02a06; &#10758; operador de união quadrada n-ária
&forall; &#x02200; &#8704; para todos
&comp; &complement; &#x02201; &#8705; complemento
&part; &partiald; &#x02202; &#8706; diferencial parcial
&exist; &exists; &#x02203; &#8707; existe
&nexist; &nexists; &#x02204; &#8708; não existe
&empty; &emptyset; &emptyv; &#x02205; &#8709; conjunto vazio
&nabla; &del; &#x02207; &#8711; nabla
&isin; &isinv; &element; &in; &#x02208; &#8712; elemento de
&notin; &notelement; &notinva; &#x02209; &#8713; não é elemento de
&niv; &reverseelement; &ni; &suchthat; &#x0220b; &#8715; contém como membro
&notni; &notniva; &notreverseelement; &#x0220c; &#8716; não contém como membro
&prod; &product; &#x0220f; &#8719; produtória
&coprod; &coproduct; &#x02210; &#8720; coprodutório
&sum; &#x02211; &#8721; somatório
Operações e Relações em Conjuntos
Caracter HTML HEX DEC Descrição
&uplus; &unionplus; &#x0228e; &#8846; união de conjuntos
&xcap; &intersection; &bigcap; &#x022c2; &#8898; interseção de conjuntos
&xcup; &union; &bigcup; &#x022c3; &#8899; união de conjuntos
&sub; &subset; &#x02282; &#8834; subconjunto de
&sup; &supset; &superset; &#x02283; &#8835; superconjunto de
&nsub; &#x02284; &#8836; não é um subconjunto de
&nsup; &#x02285; &#8837; não um superconjunto de
&sube; &subsetequal; &subseteq; &#x02286; &#8838; subconjunto de ou igual a
&supe; &supseteq; &supersetequal; &#x02287; &#8839; superconjunto de ou igual a
&nsube; &nsubseteq; &notsubsetequal; &#x02288; &#8840; nem um subconjunto de nem igual a
&nsupe; &nsupseteq; &notsupersetequal; &#x02289; &#8841; nem um superconjunto de nem igual a
&subne; &subsetneq; &#x0228a; &#8842; subconjunto de com não igual a
&supne; &supsetneq; &#x0228b; &#8843; superconjunto de com não igual a
&cupdot; &#x0228d; &#8845; multiplicação de conjuntos
Caracteres Especiais
Caracter HTML HEX DEC Descrição
ı &imath; &inodot; &#x00131; &#305; i sem ponto (mat.)
ȷ &jmath; &#x00237; &#567; j sem ponto (mat)
ƒ &fnof; &#x00192; &#402; f cortado
¹ &sup1; &#x000b9; &#185; um sobrescrito
&iinfin; &#x029dc; &#10716; infinito incompleto
&infintie; &#x029dd; &#10717; ligadura sobre infinito
&nvinfin; &#x029de; &#10718; infinito negado com barra vertical
µ &micro; &#x000b5; &#181; micro
Frações
Caracter HTML HEX DEC Descrição
¼ &frac14; &#x000bc; &#188; fração um quarto
½ &frac12; &half; &#x000bd; &#189; fração metade
¾ &frac34; &#x000be; &#190; fração três quartos
&frac13; &#x02153; &#8531; fração um terço
&frac23; &#x02154; &#8532; fração dois terços
&frac15; &#x02155; &#8533; fração um quinto
&frac25; &#x02156; &#8534; fração dois quintos
&frac35; &#x02157; &#8535; fração três quintos
&frac45; &#x02158; &#8536; fração quatro quintos
&frac16; &#x02159; &#8537; fração um sexto
&frac56; &#x0215a; &#8538; fração cinco sextos
&frac18; &#x0215b; &#8539; fração um oitavo
&frac38; &#x0215c; &#8540; fração três oitavos
&frac58; &#x0215d; &#8541; fração cinco oitavos
&frac78; &#x0215e; &#8542; fração sete oitavos
Sobrescritos
Caracter HTML HEX DEC Descrição
² &sup2; &#x000b2; &#178; dois sobrescrito
³ &sup3; &#x000b3; &#179; três sobrescrito
ª &ordf; &#x000aa; &#170; ordinal feminino
º &ordm; &#x000ba; &#186; ordinal masculino
Delimitadores
Caracter HTML HEX DEC Descrição
( &lpar; &#x00028; &#40; parêntese esquerdo
) &rpar; &#x00029; &#41; parêntese direito
[ &lsqb; &lbrack; &#x0005b; &#91; colchete esquerdo
] &rsqb; &rbrack; &#x0005d; &#93; colchete direito
{ &lcub; &lbrace; &#x0007b; &#123; chave esquerda
} &rcub; &rbrace; &#x0007d; &#125; chave direita
| &verbar; &vert; &#x0007c; &#124; linha vertical
&lang; &leftanglebracket; &langle; &#x027e8; &#10216; colchete angular esquerdo
&rang; &rightanglebracket; &rangle; &#x027e9; &#10217; colchete angular direito
&lang; &#x027ea; &#10218; colchete angular esquerdo duplo
&rang; &#x027eb; &#10219; colchete angular direito duplo
&verticalseparator; &#x02758; &#10072; barra vertical leve
Delimitadores Decorativos
Caracter HTML HEX DEC Descrição
&lbbrk; &#x02772; &#10098; chave ornamental esquerda clara
&rbbrk; &#x02773; &#10099; chave ornamental direita clara
&lobrk; &leftdoublebracket; &#x027e6; &#10214; colchete branco esquerdo
&robrk; &rightdoublebracket; &#x027e7; &#10215; colchete branco direito
&loang; &#x027ec; &#10220; colchete branco esquerdo
&roang; &#x027ed; &#10221; colchete branco direito
&ufisht; &#x0297e; &#10622; rabo de peixe
⥿ &dfisht; &#x0297f; &#10623; cauda de peixe para baixo
&lopar; &#x02985; &#10629; parêntese branco esquerdo
&ropar; &#x02986; &#10630; parêntese branco direito
&lbrke; &#x0298b; &#10635; colchete esquerdo com barra inferior
&rbrke; &#x0298c; &#10636; colchete direito com barra inferior
&lbrkslu; &#x0298d; &#10637; colchete esquerdo com marca no canto superior
&rbrksld; &#x0298e; &#10638; colchete direito com marca no canto inferior
&lbrksld; &#x0298f; &#10639; colchete esquerdo com marca no canto inferior
&rbrkslu; &#x02990; &#10640; colchete direito com marca no canto superior
&langd; &#x02991; &#10641; colchete angular esquerdo com ponto
&rangd; &#x02992; &#10642; colchete angular direito com ponto
&lparlt; &#x02993; &#10643; arco esquerdo menor que colchete
&rpargt; &#x02994; &#10644; arco direito maior que colchete
&gtlpar; &#x02995; &#10645; arco esquerdo duplo maior que colchete
&ltrpar; &#x02996; &#10646; arco direito duplo menor que colchete
Integrais
Caracter HTML HEX DEC Descrição
&int; &integral; &#x0222b; &#8747; integral
&int; &#x0222c; &#8748; integral dupla
&tint; &iiint; &#x0222d; &#8749; integral triplo
&conint; &oint; &contourintegral; &#x0222e; &#8750; integral de contorno
&conint; &doublecontourintegral; &#x0222f; &#8751; integral de superfície
&cwint; &#x02231; &#8753; integral no sentido horário
&awint; &#x02a11; &#10769; integração anti-horário
&cwconint; &#x02232; &#8754; integral de contorno no sentido horário
&awconint; &#x02233; &#8755; integral de contorno anti-horário
&qint; &iiiint; &#x02a0c; &#10764; operador quádruplo integral
&fpartint; &#x02a0d; &#10765; parte finita integral
&cirfnint; &#x02a10; &#10768; função de circulação
&rppolint; &#x02a12; &#10770; integral com caminho retangular em torno do pólo
&scpolint; &#x02a13; &#10771; integral com caminho semicircular em torno do pólo
&npolint; &#x02a14; &#10772; integração de linha não incluindo o pólo
&pointint; &#x02a15; &#10773; integral em torno de um operador de ponto
&quatint; &#x02a16; &#10774; operador integral de quatérnio
&intlarhk; &#x02a17; &#10775; integral com seta esquerda com gancho
Setas
Caracter HTML HEX DEC Descrição
&larr; &leftarrow; &leftarrow; &slarr; &#x02190; &#8592; seta esquerda
&uarr; &uparrow; &uparrow; &shortuparrow; &#x02191; &#8593; seta para cima
&rarr; &rightarrow; &rightarrow; &srarr; &#x02192; &#8594; seta direita
&darr; &downarrow; &downarrow; &shortdownarrow; &#x02193; &#8595; seta para baixo
&harr; &leftrightarrow; &leftrightarrow; &#x02194; &#8596; seta esquerda-direita
&nlarr; &#x0219a; &#8602; seta esquerda cortada
&nrarr; &nrightarrow; &#x0219b; &#8603; seta direita cortada
&rarrw; &rightsquigarrow; &#x0219d; &#8605; seta ondulada para a direita
&larr; &twoheadleftarrow; &#x0219e; &#8606; seta de duas pontas esquerda
&uarr; &#x0219f; &#8607; seta de duas pontas para cima
&rarr; &twoheadrightarrow; &#x021a0; &#8608; seta de duas pontas para a direita
&darr; &#x021a1; &#8609; seta de duas pontas para baixo
&larrtl; &leftarrowtail; &#x021a2; &#8610; seta esquerda com cauda
&rarrtl; &rightarrowtail; &#x021a3; &#8611; seta direita com cauda
&leftteearrow; &mapstoleft; &#x021a4; &#8612; seta esquerda barra
&upteearrow; &mapstoup; &#x021a5; &#8613; seta para cima, barra
&map; &rightteearrow; &mapsto; &#x021a6; &#8614; seta direita, barra
&ruledelayed; &#x029f4; &#10740; dois pontos, seta direita; rule-delayed
&larrlp; &looparrowleft; &#x021ab; &#8619; seta esquerda com laço
&rarrlp; &looparrowright; &#x021ac; &#8620; seta direita com laço
&harrw; &leftrightsquigarrow; &#x021ad; &#8621; seta onda esquerda direita
&nharr; &nleftrightarrow; &#x021ae; &#8622; seta esquerda direita, traço
&lsh; &#x021b0; &#8624; seta para cima com ponta para a esquerda
&rsh; &#x021b1; &#8625; seta para cima com ponta para a direita
&ldsh; &#x021b2; &#8626; seta para baixo com ponta para a esquerda
&rdsh; &#x021b3; &#8627; seta para baixo com ponta para a direita
&crarr; &#x021b5; &#8629; seta para baixo com canto esquerdo
&cularr; &curvearrowleft; &#x021b6; &#8630; seta semicírculo superior anti-horária
&curarr; &curvearrowright; &#x021b7; &#8631; seta de semicírculo superior horária
&olarr; &circlearrowleft; &#x021ba; &#8634; seta circular aberta anti-horária
&orarr; &circlearrowright; &#x021bb; &#8635; seta circular aberta horária
&lharu; &leftvector; &leftharpoonup; &#x021bc; &#8636; arpão esquerda, farpa para cima
&lhard; &leftharpoondown; &downleftvector; &#x021bd; &#8637; arpão esquerda, farpa para baixo
&uharr; &upharpoonright; &rightupvector; &#x021be; &#8638; arpão para cima, farpa para a direita
&uharl; &upharpoonleft; &leftupvector; &#x021bf; &#8639; arpão para cima, farpa para a esquerda
&rharu; &rightvector; &rightharpoonup; &#x021c0; &#8640; arpão direita, farpa para cima
&rhard; &rightharpoondown; &downrightvector; &#x021c1; &#8641; arpão direita, farpa para baixo
&dharr; &rightdownvector; &downharpoonright; &#x021c2; &#8642; arpão para baixo, farpa para a direita
&dharl; &leftdownvector; &downharpoonleft; &#x021c3; &#8643; arpão para baixo, farpa para a esquerda
&rlarr; &rightleftarrows; &rightarrowleftarrow; &#x021c4; &#8644; seta direita sobre seta esquerda
&udarr; &uparrowdownarrow; &#x021c5; &#8645; seta para cima para a esquerda da seta para baixo
&lrarr; &leftrightarrows; &leftarrowrightarrow; &#x021c6; &#8646; seta esquerda sobre seta direita
&llarr; &leftleftarrows; &#x021c7; &#8647; duas setas, esquerda
&uuarr; &upuparrows; &#x021c8; &#8648; duas setas para cima
&rrarr; &rightrightarrows; &#x021c9; &#8649; duas setas para a direita
&ddarr; &downdownarrows; &#x021ca; &#8650; duas setas para baixo
&lrhar; &reverseequilibrium; &leftrightharpoons; &#x021cb; &#8651; arpão esquerda sobre o arpão direita
&rlhar; &rightleftharpoons; &equilibrium; &#x021cc; &#8652; arpão da direita sobre arpão da esquerda
&nlarr; &nleftarrow; &#x021cd; &#8653; seta dupla para a esquerda cortada
&nharr; &nleftrightarrow; &#x021ce; &#8654; seta dupla esquerda direita cortada
&nrarr; &nrightarrow; &#x021cf; &#8655; seta dupla para a direita com traço
&larr; &leftarrow; &doubleleftarrow; &#x021d0; &#8656; seta dupla para a esquerda
&uarr; &uparrow; &doubleuparrow; &#x021d1; &#8657; seta dupla para cima
&rarr; &rightarrow; &implies; &doublerightarrow; &#x021d2; &#8658; seta dupla para a direita
&darr; &downarrow; &doubledownarrow; &#x021d3; &#8659; seta dupla para baixo
&harr; &leftrightarrow; &doubleleftrightarrow; &iff; &#x021d4; &#8660; seta dupla esquerda direita
&laarr; &lleftarrow; &#x021da; &#8666; seta tripla para a esquerda
&raarr; &rrightarrow; &#x021db; &#8667; seta tripla para a direita
&zigrarr; &#x021dd; &#8669; seta zigzag para a direita
&larrb; &leftarrowbar; &#x021e4; &#8676; seta esquerda para barra
&rarrb; &rightarrowbar; &#x021e5; &#8677; seta direita para barra
&duarr; &downarrowuparrow; &#x021f5; &#8693; seta para baixo para a esquerda da seta para cima
&loarr; &#x021fd; &#8701; seta de cabeça aberta para a esquerda
&roarr; &#x021fe; &#8702; seta de cabeça aberta para a direita
&hoarr; &#x021ff; &#8703; seta esquerda direita aberta
&xlarr; &longleftarrow; &longleftarrow; &#x027f5; &#10229; seta longa para a esquerda
&xlarr; &longleftarrow; &doublelongleftarrow; &#x027f8; &#10232; seta dupla longa para a esquerda
&xrarr; &longrightarrow; &longrightarrow; &#x027f6; &#10230; seta longa para a direita
&xharr; &longleftrightarrow; &longleftrightarrow; &#x027f7; &#10231; seta longa esquerda direita
&xrarr; &longrightarrow; &doublelongrightarrow; &#x027f9; &#10233; seta dupla longa para a direita
&xharr; &longleftrightarrow; &#x027fa; &#10234; seta dupla longa esquerda direita
&xmap; &longmapsto; &#x027fc; &#10236; seta longa para a direita da barra
&dzigrarr; &#x027ff; &#10239; seta longa para a direita
&nvlarr; &#x02902; &#10498; seta dupla para a esquerda com traço vertical
&nvrarr; &#x02903; &#10499; seta dupla para a direita com traço vertical
&nvharr; &#x02904; &#10500; seta dupla esquerda direita com traço vertical
&map; &#x02905; &#10501; seta de duas pontas para a direita da barra
&lbarr; &#x0290c; &#10508; seta esquerda com traço duplo
&rbarr; &bkarow; &#x0290d; &#10509; seta direita com traço duplo
&lbarr; &#x0290e; &#10510; seta de traço triplo para a esquerda
&rbarr; &dbkarow; &#x0290f; &#10511; seta de traço triplo para a direita
&rbarr; &drbkarow; &#x02910; &#10512; seta de duas pontas para a direita com traço triplo
&ddotrahd; &#x02911; &#10513; seta direita com haste pontilhada
&uparrowbar; &#x02912; &#10514; seta para cima para barra
&downarrowbar; &#x02913; &#10515; seta para baixo para barra
&rarrtl; &#x02916; &#10518; seta de duas pontas para a direita com cauda
&latail; &#x02919; &#10521; cauda de seta esquerda
&ratail; &#x0291a; &#10522; cauda de seta direita
&latail; &#x0291b; &#10523; cauda de seta dupla para a esquerda
&ratail; &#x0291c; &#10524; cauda de seta dupla para a direita
&larrfs; &#x0291d; &#10525; seta esquerda para diamante preto
&rarrfs; &#x0291e; &#10526; seta direita para diamante preto
&larrbfs; &#x0291f; &#10527; seta esquerda da barra ao diamante preto
&rarrbfs; &#x02920; &#10528; seta direita da barra para o diamante preto
&nwarhk; &#x02923; &#10531; seta noroeste com gancho
&nearhk; &#x02924; &#10532; flecha nordeste com gancho
&searhk; &hksearow; &#x02925; &#10533; seta sudeste com gancho
&swarhk; &hkswarow; &#x02926; &#10534; seta sudoeste com gancho
&nwnear; &#x02927; &#10535; seta noroeste e seta nordeste
&nesear; &toea; &#x02928; &#10536; seta nordeste e seta sudeste
&seswar; &tosa; &#x02929; &#10537; seta sudeste e seta sudoeste
&swnwar; &#x0292a; &#10538; seta sudoeste e seta noroeste
&rarrc; &#x02933; &#10547; seta ondulada para a direita
&ldca; &#x02936; &#10550; seta para baixo e curvando para a esquerda
&rdca; &#x02937; &#10551; seta para baixo e curvando para a direita
&cudarrl; &#x02938; &#10552; arco do lado direito seta no sentido horário
&larrpl; &#x02939; &#10553; arco do lado esquerdo no sentido anti-horário
&curarrm; &#x0293c; &#10556; arco superior seta no sentido horário com menos
&cularrp; &#x0293d; &#10557; seta do arco superior no sentido anti-horário com mais
&rarrpl; &#x02945; &#10565; seta direita com mais abaixo
&harrcir; &#x02948; &#10568; seta esquerda direita através de círculo
&uarrocir; &#x02949; &#10569; seta de duas pontas para cima do círculo
&lurdshar; &#x0294a; &#10570; farpa esquerda para cima direita farpa para baixo arpão
&ldrushar; &#x0294b; &#10571; farpa esquerda para baixo direita farpa para cima arpão
&leftrightvector; &#x0294e; &#10574; farpa esquerda para cima direita farpa para arpão
&rightupdownvector; &#x0294f; &#10575; para cima farpa direita para baixo farpa arpão direito
&downleftrightvector; &#x02950; &#10576; farpa esquerda para baixo direita farpa para baixo arpão
&leftupdownvector; &#x02951; &#10577; cima farpa esquerda baixo farpa esquerda arpão
&leftvectorbar; &#x02952; &#10578; arpão esquerda com farpa até a barra
&rightvectorbar; &#x02953; &#10579; arpão direita com farpa até a barra
&rightupvectorbar; &#x02954; &#10580; arpão para cima com farpa direita na barra
&rightdownvectorbar; &#x02955; &#10581; arpão para baixo com farpa à direita da barra
&downleftvectorbar; &#x02956; &#10582; arpão esquerda com farpa até a barra
&downrightvectorbar; &#x02957; &#10583; arpão direita com farpa até a barra
&leftupvectorbar; &#x02958; &#10584; arpão para cima com farpa da esquerda para a barra
&leftdownvectorbar; &#x02959; &#10585; arpão para baixo com farpa da esquerda para a barra
&leftteevector; &#x0295a; &#10586; arpão esquerda com farpa para cima da barra
&rightteevector; &#x0295b; &#10587; arpão direita com farpa para cima da barra
&rightupteevector; &#x0295c; &#10588; arpão para cima com farpa direto da barra
&rightdownteevector; &#x0295d; &#10589; arpão para baixo com farpa direto da barra
&downleftteevector; &#x0295e; &#10590; arpão esquerda com farpa para baixo da barra
&downrightteevector; &#x0295f; &#10591; arpão direita com farpa para baixo da barra
&leftupteevector; &#x02960; &#10592; arpão para cima com farpa esquerda da barra
&leftdownteevector; &#x02961; &#10593; arpão para baixo com farpa esquerda da barra
&lhar; &#x02962; &#10594; arpão esquerda com farpa para cima acima do arpão esquerda com farpa para baixo
&uhar; &#x02963; &#10595; arpão para cima com farpa esquerda ao lado arpão para cima com farpa direita
&rhar; &#x02964; &#10596; arpão direita com farpa para cima acima para arpão direita com farpa para baixo
&dhar; &#x02965; &#10597; arpão para baixo com farpa esquerda ao lado arpão para baixo com farpa direita
&luruhar; &#x02966; &#10598; arpão esquerda com farpa para cima acima do arpão direita com farpa para cima
&ldrdhar; &#x02967; &#10599; arpão esquerda com farpa para baixo acima do arpão direita com farpa para baixo
&ruluhar; &#x02968; &#10600; arpão direita com farpa para cima acima do arpão esquerda com farpa para cima
&rdldhar; &#x02969; &#10601; arpão direita com farpa para baixo acima do arpão esquerda com farpa para baixo
&lharul; &#x0296a; &#10602; arpão esquerda com farpa acima do longo traço
&llhard; &#x0296b; &#10603; arpão esquerda com farpa abaixo do longo traço
&rharul; &#x0296c; &#10604; arpão direita com farpa acima do longo traço
&lrhard; &#x0296d; &#10605; arpão direita com farpa abaixo do longo traço
&udhar; &upequilibrium; &#x0296e; &#10606; arpão p/ cima com farpa esquerda ao lado arpão para baixo com farpa direita
&duhar; &reverseupequilibrium; &#x0296f; &#10607; arpão para baixo com farpa esquerda ao lado arpão para cima com farpa direita
&roundimplies; &#x02970; &#10608; seta dupla direita com cabeça arredondada
&erarr; &#x02971; &#10609; igual acima da seta direita
&simrarr; &#x02972; &#10610; operador til acima da seta direita
&larrsim; &#x02973; &#10611; seta esquerda acima do operador til
&rarrsim; &#x02974; &#10612; seta direita acima do operador til
&rarrap; &#x02975; &#10613; seta direita acima quase igual a
&ltlarr; &#x02976; &#10614; seta esquerda menor que acima
&gtrarr; &#x02978; &#10616; maior do que acima da seta direita
&subrarr; &#x02979; &#10617; subconjunto acima da seta direita
&suplarr; &#x0297b; &#10619; superconjunto acima da seta esquerda
&lfisht; &#x0297c; &#10620; cauda de peixe esquerda
&rfisht; &#x0297d; &#10621; cauda de peixe direita
Emoticons
Caracter HTML HEX DEC Descrição
&cudarrr; &#x02935; &#10549; seta para a direita e curvando para baixo
&larrhk; &hookleftarrow; &#x021a9; &#8617; seta esquerda com gancho
&rarrhk; &hookrightarrow; &#x021aa; &#8618; seta direita com gancho
&varr; &updownarrow; &updownarrow; &#x02195; &#8597; seta para cima e para baixo
&nwarr; &nwarrow; &#x02196; &#8598; seta noroeste
&nearr; &nearrow; &#x02197; &#8599; seta nordeste
&searr; &searrow; &#x02198; &#8600; seta sudeste
&swarr; &swarrow; &#x02199; &#8601; seta sudoeste
&phone; &#x0260e; &#9742; telefone preto
&female; &#x02640; &#9792; signo feminino
&male; &#x02642; &#9794; signo masculino
Caracteres Gráficos: Desenho
Caracter HTML HEX DEC Descrição
&boxh; &horizontalline; &#x02500; &#9472; parte de caixa: linha horizontal
&boxv; &#x02502; &#9474; parte de caixa: linha vertical
&boxdr; &#x0250c; &#9484; parte de caixa: canto superior esquerdo
&boxdl; &#x02510; &#9488; desenho da caixa canto superior direito
&boxur; &#x02514; &#9492; parte de caixa: canto inferior esquerdo
&boxul; &#x02518; &#9496; parte de caixa: canto inferior direito
&boxvr; &#x0251c; &#9500; parte de caixa: linha central direita
&boxvl; &#x02524; &#9508; parte de caixa: linha central esquerda
&boxhd; &#x0252c; &#9516; parte de caixa: linha para baixo e horizontal
&boxhu; &#x02534; &#9524; parte de caixa: iluminados e horizontais
&boxvh; &#x0253c; &#9532; parte de caixa: de linha vertical e horizontal
&boxh; &#x02550; &#9552; parte de caixa: dupla horizontal
&boxv; &#x02551; &#9553; parte de caixa: dupla vertical
&boxdr; &#x02552; &#9554; parte de caixa: para baixo simples e duplo direito
&boxdr; &#x02553; &#9555; parte de caixa: para baixo duplo e único direito
&boxdr; &#x02554; &#9556; os desenhos da caixa dobram para baixo e para a direita
&boxdl; &#x02555; &#9557; parte de caixa: para baixo simples e duplo esquerdo
&boxdl; &#x02556; &#9558; parte de caixa: para baixo duplo e único esquerdo
&boxdl; &#x02557; &#9559; desenhos da caixa dobrar para baixo e para a esquerda
&boxur; &#x02558; &#9560; parte de caixa: s simples e duplas à direita
&boxur; &#x02559; &#9561; caixa de desenhos dupla e direita simples
&boxur; &#x0255a; &#9562; os desenhos da caixa dobram e correm
&boxul; &#x0255b; &#9563; parte de caixa: para cima simples e duplo esquerdo
&boxul; &#x0255c; &#9564; parte de caixa: duplo e esquerdo simples
&boxul; &#x0255d; &#9565; os desenhos da caixa dobram e saem
&boxvr; &#x0255e; &#9566; parte de caixa: vertical simples e duplo direito
&boxvr; &#x0255f; &#9567; parte de caixa: vertical duplo e direito simples
&boxvr; &#x02560; &#9568; parte de caixa: dupla vertical e direita
&boxvl; &#x02561; &#9569; parte de caixa: vertical simples e duplo esquerdo
&boxvl; &#x02562; &#9570; parte de caixa: dupla vertical e esquerda simples
&boxvl; &#x02563; &#9571; parte de caixa: duplo vertical e esquerdo
&boxhd; &#x02564; &#9572; parte de caixa: para baixo simples e duplo horizontal
&boxhd; &#x02565; &#9573; parte de caixa: para baixo duplo e horizontal simples
&boxhd; &#x02566; &#9574; parte de caixa: dobrar para baixo e horizontal
&boxhu; &#x02567; &#9575; parte de caixa: para cima simples e duplo horizontal
&boxhu; &#x02568; &#9576; parte de caixa: duplo e horizontal simples
&boxhu; &#x02569; &#9577; parte de caixa: dobrados e horizontais
&boxvh; &#x0256a; &#9578; parte de caixa: vertical simples e horizontal duplo
&boxvh; &#x0256b; &#9579; parte de caixa: dupla vertical e simples horizontal
&boxvh; &#x0256c; &#9580; parte de caixa: duplo vertical e horizontal
&uhblk; &#x02580; &#9600; meio bloco superior
&lhblk; &#x02584; &#9604; meio bloco inferior
&block; &#x02588; &#9608; bloco completo
&blk14; &#x02591; &#9617; sombra clara
&blk12; &#x02592; &#9618; tom médio
&blk34; &#x02593; &#9619; sombra escura
Figuras Geométricas
Caracter HTML HEX DEC Descrição
&squ; &square; &square; &#x025a1; &#9633; quadrado branco
&squf; &squarf; &blacksquare; &filledverysmallsquare; &#x025aa; &#9642; quadrado pequeno preto
&emptyverysmallsquare; &#x025ab; &#9643; quadrado pequeno branco
&rect; &#x025ad; &#9645; retângulo branco
&marker; &#x025ae; &#9646; retângulo preto vertical
&fltns; &#x025b1; &#9649; paralelogramo branco
&xutri; &bigtriangleup; &#x025b3; &#9651; triângulo branco para cima
&utrif; &blacktriangle; &#x025b4; &#9652; triângulo pequeno preto para cima
&utri; &triangle; &#x025b5; &#9653; triângulo pequeno branco para cima
&rtrif; &blacktriangleright; &#x025b8; &#9656; triângulo pequeno preto para a direita
&rtri; &triangleright; &#x025b9; &#9657; triângulo pequeno branco para a direita
&xdtri; &bigtriangledown; &#x025bd; &#9661; triângulo branco para baixo
&dtrif; &blacktriangledown; &#x025be; &#9662; triângulo pequeno preto para baixo
&dtri; &triangledown; &#x025bf; &#9663; ponto baixo branco
&ltrif; &blacktriangleleft; &#x025c2; &#9666; triângulo pequeno preto para a esquerda
&ltri; &triangleleft; &#x025c3; &#9667; triângulo pequeno branco para a esquerda
&loz; &lozenge; &#x025ca; &#9674; pastilha
&cir; &#x025cb; &#9675; círculo branco
&tridot; &#x025ec; &#9708; triângulo branco para cima com ponto
&xcirc; &bigcirc; &#x025ef; &#9711; grande círculo
&ultri; &#x025f8; &#9720; triângulo superior esquerdo
&urtri; &#x025f9; &#9721; triângulo superior direito
&lltri; &#x025fa; &#9722; triângulo inferior esquerdo
&emptysmallsquare; &#x025fb; &#9723; quadrado médio branco
&filledsmallsquare; &#x025fc; &#9724; quadrado médio preto
Acentos
Caracter HTML HEX DEC Descrição
´ &acute; &diacriticalacute; &#x000b4; &#180; acento agudo
^ &hat; &#x0005e; &#94; acento circunflexo
ˆ &circ; &#x002c6; &#710; acento circunflexo
` &grave; &diacriticalgrave; &#x00060; &#96; acento grave
˘ &breve; &#x002d8; &#728; breve
¸ &cedil; &cedilla; &#x000b8; &#184; cedilha
¨ &dot; &die; &uml; &#x000a8; &#168; trema
&apos; &#x00027; &#39; apóstrofe
˜ &tilde; &#x002dc; &#732; til pequeno
˙ &dot; &#x002d9; &#729; ponto acima
ˇ &caron; &#x002c7; &#711; caron
˚ &ring; &#x002da; &#730; anel acima
˛ &ogon; &#x002db; &#731; ogonek
˝ &dblac; &#x002dd; &#733; acento agudo duplo
_ &UnderBar; &#x00332; &#818; traço subescrito
Caracteres Acentuados
Caracter HTML HEX DEC Descrição
À &Agrave; &#x000c0; &#192; A grave
Á &Aacute; &#x000c1; &#193; A agudo
 &Acirc; &#x000c2; &#194; A circunflexo
à &Atilde; &#x000c3; &#195; A til
Ä &Auml; &#x000c4; &#196; A trema
Å &Aring; &#x000c5; &#197; A anel
&Aelig; &Aelig; &#x000c6; &#198; Ae
à &agrave; &#x000e0; &#224; a grave
á &aacute; &#x000e1; &#225; a agudo
â &acirc; &#x000e2; &#226; a circunflexo
ã &atilde; &#x000e3; &#227; a til
ä &auml; &#x000e4; &#228; a trema
å &aring; &#x000e5; &#229; a anel acima
æ &aelig; &#x000e6; &#230; ae
Ā &Amacr; &#x00100; &#256; A mácron
ā &amacr; &#x00101; &#257; a mácron
Ă &Abreve; &#x00102; &#258; A breve
ă &abreve; &#x00103; &#259; a breve
Ą &Aogon; &#x00104; &#260; A ogonek
ą &aogon; &#x00105; &#261; a ogonek
Ć &Cacute; &#x00106; &#262; C com agudo
ć &cacute; &#x00107; &#263; c com agudo
Ĉ &Ccirc; &#x00108; &#264; C com circunflexo
ĉ &ccirc; &#x00109; &#265; c com circunflexo
Ċ &Cdot; &#x0010a; &#266; C com ponto acima
ċ &cdot; &#x0010b; &#267; c com ponto acima
č &ccaron; &#x0010c; &#268; maiúscula c com caron
č &ccaron; &#x0010d; &#269; minúscula c com caron
ç &ccedil; &#x000c7; &#199; c com cedilha
Ď &Dcaron; &#x0010e; &#270; D caron
ď &dcaron; &#x0010f; &#271; d caron
Đ &Dstrok; &#x00110; &#272; D com traço
đ &dstrok; &#x00111; &#273; d com traço
È &Egrave; &#x000e8; &#232; E grave
è &egrave; &#x000c8; &#200; e com grave
é &eacute; &#x000c9; &#201; e com agudo
é &eacute; &#x000e9; &#233; e agudo
ê &ecirc; &#x000ea; &#234; e circunflexo
ê &ecirc; &#x000ca; &#202; e com circunflexo
Ë &Euml; &#x000cb; &#203; E com trema
ë &euml; &#x000eb; &#235; e trema
Ē &Emacr; &#x00112; &#274; E mácron
ē &emacr; &#x00113; &#275; e mácron
Ė &Edot; &#x00116; &#278; E ponto
ė &edot; &#x00117; &#279; e ponto
Ę &Eogon; &#x00118; &#280; E com ogonek
ę &eogon; &#x00119; &#281; e com ogonek
Ě &Ecaron; &#x0011a; &#282; E caron
ě &ecaron; &#x0011b; &#283; e caron
ð &eth; &#x000f0; &#240; eth minúsculo
&Eth; &Eth; &#x000d0; &#208; eth maiúsculo
Ĝ &Gcirc; &#x0011c; &#284; G circunflexo
ĝ &gcirc; &#x0011d; &#285; g circunflexo
Ğ &Gbreve; &#x0011e; &#286; G breve
ğ &gbreve; &#x0011f; &#287; g breve
Ġ &Gdot; &#x00120; &#288; G com ponto acima
ġ &gdot; &#x00121; &#289; g com ponto acima
ǵ &gacute; &#x001f5; &#501; g com agudo
Ĥ &Hcirc; &#x00124; &#292; H circunflexo
ĥ &hcirc; &#x00125; &#293; h circunflexo
Ħ &Hstrok; &#x00126; &#294; H com traço
ħ &hstrok; &#x00127; &#295; h com traço
ì &igrave; &#x000ec; &#236; i grave
í &iacute; &#x000ed; &#237; i agudo
î &icirc; &#x000ee; &#238; i circunflexo
ï &iuml; &#x000ef; &#239; i trema
Ĩ &itilde; &#x00129; &#297; I til
ĩ &itilde; &#x00128; &#296; i til
Ī &Imacr; &#x0012a; &#298; I com mácron
ī &imacr; &#x0012b; &#299; i com mácron
Į &Iogon; &#x0012e; &#302; I com ogonek
į &iogon; &#x0012f; &#303; i com ogonek
İ &Idot; &#x00130; &#304; I com ponto
IJ &IJlig; &#x00132; &#306; ligadura IJ
ij &ijlig; &#x00133; &#307; ligadura ij
Ĵ &Jcirc; &#x00134; &#308; J circunflexo
ĵ &jcirc; &#x00135; &#309; j circunflexo
Ķ &Kcedil; &#x00136; &#310; K com cedilha
ķ &kcedil; &#x00137; &#311; k com cedilha
ĸ &kgreen; &#x00138; &#312; kra minúsculo
Ĺ &Lacute; &#x00139; &#313; L agudo
ĺ &lacute; &#x0013a; &#314; l agudo
Ļ &Lcedil; &#x0013b; &#315; L com cedilha
ļ &lcedil; &#x0013c; &#316; l com cedilha
Ľ &Lcaron; &#x0013d; &#317; L com caron
ľ &lcaron; &#x0013e; &#318; l com caron
Ŀ &Lmidot; &#x0013f; &#319; L com ponto
ŀ &lmidot; &#x00140; &#320; l com ponto
Ł &Lstrok; &#x00141; &#321; L com traço
ł &lstrok; &#x00142; &#322; l com traço
Ń &Nacute; &#x00143; &#323; N com agudo
ń &nacute; &#x00144; &#324; n com agudo
Ņ &Ncedil; &#x00145; &#325; N com cedilha
ņ &ncedil; &#x00146; &#326; n com cedilha
Ň &Ncaron; &#x00147; &#327; N com caron
ň &ncaron; &#x00148; &#328; n com caron
ʼn &napos; &#x00149; &#329; n precedida de apóstrofo
ñ &ntilde; &#x000d1; &#209; n com til
ò &ograve; &#x000f2; &#242; o grave
ó &oacute; &#x000f3; &#243; o agudo
ô &ocirc; &#x000f4; &#244; o circunflexo
õ &otilde; &#x000f5; &#245; o til
ö &ouml; &#x000f6; &#246; o com trema
ø &oslash; &#x000f8; &#248; o com traço
Ō &Omacr; &#x0014c; &#332; O com macron
ō &omacr; &#x0014d; &#333; o com mácron
Ő &Odblac; &#x00150; &#336; O com duplo agudo
ő &odblac; &#x00151; &#337; o com duplo agudo
&Oegig; &Oelig; &#x00152; &#338; ligadura OE maiúscula
œ &oelig; &#x00153; &#339; ligadura oe minúscula
Ŕ &Racute; &#x00154; &#340; R com agudo
ŕ &racute; &#x00155; &#341; r com agudo
Ŗ &Rcedil; &#x00156; &#342; R com cedilha
ŗ &rcedil; &#x00157; &#343; r com cedilha
Ř &Rcaron; &#x00158; &#344; R com caron
ř &rcaron; &#x00159; &#345; r minúscula com caron
Ś &Sacute; &#x0015a; &#346; S com agudo
ś &sacute; &#x0015b; &#347; s com agudo
Ŝ &Scirc; &#x0015c; &#348; S com circunflexo
ŝ &scirc; &#x0015d; &#349; s com circunflexo
Ş &Scedil; &#x0015e; &#350; S com cedilha
ş &scedil; &#x0015f; &#351; s com cedilha
Š &Scaron; &#x00160; &#352; S s com caron
š &scaron; &#x00161; &#353; s com caron
Ţ &Tcedil; &#x00162; &#354; T com cedilha
ţ &tcedil; &#x00163; &#355; t com cedilha
Ť &Tcaron; &#x00164; &#356; T com caron
ť &tcaron; &#x00165; &#357; t com caron
Ŧ &Tstrok; &#x00166; &#358; T com traço
ŧ &tstrok; &#x00167; &#359; t com traço
ù &ugrave; &#x000f9; &#249; u grave
ú &uacute; &#x000fa; &#250; u agudo
û &ucirc; &#x000fb; &#251; u circunflexo
ü &uuml; &#x000fc; &#252; u com trema
Ũ &Utilde; &#x00168; &#360; U com til
ũ &utilde; &#x00169; &#361; u com til
Ū &Umacr; &#x0016a; &#362; U com mácron
ū &umacr; &#x0016b; &#363; u com mácron
Ŭ &Ubreve; &#x0016c; &#364; U breve
ŭ &ubreve; &#x0016d; &#365; u breve
Ů &Uring; &#x0016e; &#366; U com anel
ů &uring; &#x0016f; &#367; u com anel
Ű &Udblac; &#x00170; &#368; U com duplo agudo
ű &udblac; &#x00171; &#369; u com duplo agudo
Ų &Uogon; &#x00172; &#370; U com ogonek
ų &uogon; &#x00173; &#371; u com ogonek
Ŵ &Wcirc; &#x00174; &#372; W com circunflexo
ŵ &wcirc; &#x00175; &#373; w com circunflexo
Ŷ &Ycirc; &#x00176; &#374; Y com circunflexo
ŷ &ycirc; &#x00177; &#375; y com circunflexo
Ÿ &Yuml; &#x00178; &#376; Y com trema
ÿ &yuml; &#x000ff; &#255; y com trema
Ý &Yacute; &#x000dd; &#221; Y com agudo
ý &yacute; &#x000fd; &#253; y com agudo
Ź &Zacute; &#x00179; &#377; Z com agudo
ź &zacute; &#x0017a; &#378; z com agudo
Ż &Zdot; &#x0017b; &#379; Z com ponto acima
ż &zdot; &#x0017c; &#380; z com ponto acima
Ž &Zcaron; &#x0017d; &#381; Z com caron
ž &zcaron; &#x0017e; &#382; z com caron
Ƶ &imped; &#x001b5; &#437; Z cortado
Ligaduras de Carateres Latinos
Caracter HTML HEX DEC Descrição
IJ &IJlig; &#x00132; &#306; ligadura IJ (maiúsculo)
ij &ijlig; &#x00133; &#307; ligadura ij (minúsculo)
Œ &OElig; &#x00152; amp;Œ; ligadura OE maiúscula
œ &oelig; &#x00153; &#339; ligadura oe minúscula
&fflig; &#x0fb00; &#64256; ligadura ff
&filig; &#x0fb01; &#64257; ligadura fi
&fllig; &#x0fb02; &#64258; ligadura fl
&ffilig; &#x0fb03; &#64259; ligadura ffi
&ffllig; &#x0fb04; &#64260; ligadura ffl
Carateres Não Latinos
Caracter HTML HEX DEC Descrição
ŋ &eng; &#x0014b; &#331; minúscula eng
Þ &Thorn; &#x000de; &#222; ‘thorn’ maiúsculo
þ &thorn; &#x000fe; &#254; ‘thorn’ minúsculo
ß &szlig; &#x000df; &#223; ‘eszett’ alemão
Caracteres script
Caracter HTML HEX DEC Descrição
𝒶 &ascr; &#x1d49c; &#119964; a minúsculo
𝒷 &bscr; &#x1d49D; &#119965; b
𝒸 &cscr; &#x1d49e; &#119966; c
𝒹 &dscr; &#x1d49f; &#119967; d
&escr; &#x1d4a0; &#119968; e
𝒻 &fscr; &#x1d4a1; &#119969; e
&gscr; &#x1d4a2; &#119970; g
𝒽 &hscr; &#x1d4a3; &#119971; h
𝒾 &iscr; &#x1d4a4; &#119972; i
𝒿 &jscr; &#x1d4a5; &#119973; j
𝓀 &kscr; &#x1d4a6; &#119974; k
𝓁 &lscr; &#x1d4a7; &#119975; l
𝓂 &mscr; &#x1d4a8; &#119976; m
𝓃 &nscr; &#x1d4a9; &#119977; n
&oscr; &#x1d4aa; &#119978; o
𝓅 &pscr; &#x1d4ab; &#119979; p
𝓆 &qscr; &#x1d4ac; &#119980; q
𝓇 &rscr; &#x1d4ad; &#119981; r
𝓈 &sscr; &#x1d4ae; &#119982; s
𝓉 &tscr; &#x1d4af; &#119983; t
𝓊 &uscr; &#x1d4b0; &#119984; u
𝓋 &vscr; &#x1d4b1; &#119985; v
𝓌 &wscr; &#x1d4b2; &#119986; w
𝓍 &xscr; &#x1d4b3; &#119987; x
𝓎 &yscr; &#x1d4b4; &#119988; y
𝓏 &zscr; &#x1d4b5; &#119989; z
Caracter HTML HEX DEC Descrição
𝒜 &Ascr; &#x1d4b6; &#119989; A maiúsculo
&Bscr; &#x1d4b7; &#119990; B
𝒞 &Cscr; &#x1d4b8; &#119991; C
𝒟 &Dscr; &#x1d4b9; &#119992; D
&Escr; &#x1d4ba; &#119993; E
&Fscr; &#x1d4bb; &#119994; F
𝒢 &Gscr; &#x1d4bc; &#119995; G
&Hscr; &#x1d4bd; &#119996; H
&Iscr; &#x1d4be; &#119997; I
𝒥 &Jscr; &#x1d4bf; &#119998; J
𝒦 &Kscr; &#x1d4c0; &#119999; K
&Lscr; &#x1d4c1; &#120000; L
&Mscr; &#x1d4c2; &#120001; M
𝒩 &Nscr; &#x1d4c3; &#120002; N
𝒪 &Oscr; &#x1d4c4; &#120003; O
𝒫 &Pscr; &#x1d4c5; &#120004; P
𝒬 &Qscr; &#x1d4c6; &#120005; Q
&Rscr; &#x1d4c7; &#120006; R
𝒮 &Sscr; &#x1d4c8; &#120007; S
𝒯 &Tscr; &#x1d4c9; &#120008; T
𝒰 &Uscr; &#x1d4ca; &#120009; U
𝒱 &Vscr; &#x1d4cb; &#120010; V
𝒲 &Wscr; &#x1d4cc; &#120011; W
𝒳 &Xscr; &#x1d4cd; &#120012; X
𝒴 &Yscr; &#x1d4ce; &#120013; Y
𝒵 &Zscr; &#x1d4ce; &#120014; Z
Caracteres Fraktur
Caracter HTML HEX DEC Descrição
𝔞 &afr; &#x1d504; &#120068; a minúsculo
𝔟 &bfr; &#x1d505; &#120069; b
𝔠 &cfr; &#x1d506; &#120070; c
𝔡 &dfr; &#x1d507; &#120071; d
𝔢 &efr; &#x1d508; &#120072; e
𝔣 &ffr; &#x1d509; &#120073; f
𝔤 &gfr; &#x1d50a; &#120074; g
𝔥 &hfr; &#x1d50b; &#120075; h
𝔦 &ifr; &#x1d50c; &#120076; i
𝔧 &jfr; &#x1d50d; &#120077; j
𝔨 &kfr; &#x1d50e; &#120078; k
𝔩 &lfr; &#x1d50f; &#120079; l
𝔪 &mfr; &#x1d510; &#120080; m
𝔫 &nfr; &#x1d511; &#120081; n
𝔬 &ofr; &#x1d512; &#120082; o
𝔭 &pfr; &#x1d513; &#120083; p
𝔮 &qfr; &#x1d514; &#120084; q
𝔯 &rfr; &#x1d515; &#120085; r
𝔰 &sfr; &#x1d516; &#120086; s
𝔱 &tfr; &#x1d517; &#120087; t
𝔲 &ufr; &#x1d518; &#120088; u
𝔳 &vfr; &#x1d519; &#120089; v
𝔴 &wfr; &#x1d51a; &#120090; w
𝔵 &xfr; &#x1d51b; &#120091; x
𝔶 &yfr; &#x1d51c; &#120092; y
𝔷 &zfr; &#x1d51d; &#120093; z
Caracter HTML HEX DEC Descrição
𝔄 &Afr; &#x1d51e; &#120094; A maiúsculo
𝔅 &Bfr; &#x1d51f; &#120095; B
&Cfr; &#x1d520; &#120096; C
𝔇 &Dfr; &#x1d521; &#120097; D
𝔈 &Efr; &#x1d522; &#120098; E
𝔉 &Ffr; &#x1d523; &#120099; F
𝔊 &Gfr; &#x1d524; &#120100; G
&Hfr; &#x1d525; &#120101; H
&Ifr; &#x1d526; &#120102; I
𝔍 &Jfr; &#x1d527; &#120103; J
𝔎 &Kfr; &#x1d528; &#120104; K
𝔏 &Lfr; &#x1d529; &#120105; L
𝔐 &Mfr; &#x1d52a; &#120106; M
𝔑 &Nfr; &#x1d52b; &#120107; N
𝔒 &Ofr; &#x1d52c; &#120108; O
𝔓 &Pfr; &#x1d52d; &#120109; P
𝔔 &Qfr; &#x1d52e; &#120110; Q
&Rfr; &#x1d52f; &#120111; R
𝔖 &Sfr; &#x1d530; &#120112; S
𝔗 &Tfr; &#x1d531; &#120113; T
𝔘 &Ufr; &#x1d532; &#120114; U
𝔙 &Vfr; &#x1d533; &#120115; V
𝔚 &Wfr; &#x1d534; &#120116; W
𝔛 &Xfr; &#x1d535; &#120117; X
𝔜 &Yfr; &#x1d536; &#120118; Y
&Zfr; &#x1d537; &#120119; Z
Caracteres de traço duplo
Caracter HTML HEX DEC Descrição
𝕒 &aopf; &#x1d538; &#120120; a minúsculo
𝕓 &bopf; &#x1d539; &#120121; b
𝕔 &copf; &#x1d539; &#120122; c
𝕕 &dopf; &#x1d53b; &#120123; d
𝕖 &eopf; &#x1d53c; &#120124; e
𝕗 &fopf; &#x1d53d; &#120125; f
𝕘 &gopf; &#x1d53e; &#120126; g
𝕙 &hopf; &#x1d53e; &#120127; h
𝕚 &iopf; &#x1d540; &#120128; i
𝕛 &jopf; &#x1d541; &#120129; j
𝕜 &kopf; &#x1d542; &#120130; k
𝕝 &lopf; &#x1d543; &#120131; l
𝕞 &mopf; &#x1d544; &#120132; m
𝕟 &nopf; &#x1d545; &#120133; n
𝕠 &oopf; &#x1d546; &#120134; o
𝕡 &popf; &#x1d547; &#120135; p
𝕢 &qopf; &#x1d548; &#120136; q
𝕣 &ropf; &#x1d549; &#120137; r
𝕤 &sopf; &#x1d54a; &#120138; s
𝕥 &topf; &#x1d54b; &#120139; t
𝕦 &uopf; &#x1d54c; &#120140; u
𝕧 &vopf; &#x1d54d; &#120141; v
𝕨 &wopf; &#x1d54e; &#120142; w
𝕩 &xopf; &#x1d54f; &#120143; x
𝕪 &yopf; &#x1d550; &#120144; y
𝕫 &zopf; &#x1d551; &#120145; z
Caracter HTML HEX DEC Descrição
𝔸 &Aopf; &#x1d552; &#120146; A maiúsculo
𝔹 &Bopf; &#x1d553; &#120147; B
&Copf; &#x1d554; &#120148; C
𝔻 &Dopf; &#x1d555; &#120149; D
𝔼 &Eopf; &#x1d556; &#120150; E
𝔽 &Fopf; &#x1d557; &#120151; F
𝔾 &Gopf; &#x1d558; &#120152; G
&Hopf; &#x1d559; &#120153; H
𝕀 &Iopf; &#x1d55a; &#120154; I
𝕁 &Jopf; &#x1d55b; &#120155; J
𝕂 &Kopf; &#x1d55c; &#120156; K
𝕃 &Lopf; &#x1d55d; &#120157; L
𝕄 &Mopf; &#x1d55e; &#120158; M
&Nopf; &#x1d55f; &#120159; N
𝕆 &Oopf; &#x1d560; &#120160; O
&Popf; &#x1d561; &#120161; P
&Qopf; &#x1d562; &#120162; Q
&Ropf; &#x1d563; &#120163; R
𝕊 &Sopf; &#x1d564; &#120164; S
𝕋 &Topf; &#x1d565; &#120165; T
𝕌 &Uopf; &#x1d566; &#120166; U
𝕍 &Vopf; &#x1d567; &#120167; V
𝕎 &Wopf; &#x1d568; &#120168; W
𝕏 &Xopf; &#x1d569; &#120169; X
𝕐 &Yopf; &#x1d56a; &#120170; Y
&Zopf; &#x1d56b; &#120171; Z
Caracteres Gregos
Caracter HTML HEX DEC Descrição
α &alpha; &#x00391; &#913; alfa maiúsculo grego
β &beta; &#x00392; &#914; beta maiúsculo grego
γ &gamma; &#x00393; &#915; gama grega maiúscula
δ &delta; &#x00394; &#916; letra maiúscula grega delta
ε &epsilon; &#x00395; &#917; epsilon com letra maiúscula grega
ζ &zeta; &#x00396; &#918; zeta letra maiúscula grega
η &eta; &#x00397; &#919; letra maiúscula grega eta
θ &theta; &#x00398; &#920; teta maiúscula grega
ι &iota; &#x00399; &#921; letra maiúscula iota
κ &kappa; &#x0039a; &#922; kappa maiúscula
λ &lambda; &#x0039b; &#923; lamda letra maiúscula
μ &mu; &#x0039c; &#924; letra maiúscula mu
ν &nu; &#x0039d; &#925; nu maiúsculo
ξ &xi; &#x0039e; &#926; letra maiúscula xi
ο &omicron; &#x0039f; &#927; omicron maiúsculo
π &pi; &#x003a0; &#928; pi maiúscula
ρ &rho; &#x003a1; &#929; rho maiúsculo
σ &sigma; &#x003a3; &#931; sigma maiúsculo
τ &tau; &#x003a4; &#932; tau maiúsculo
υ &upsilon; &#x003a5; &#933; upsilon maiúsculo
φ &phi; &#x003a6; &#934; letra maiúscula phi
χ &chi; &#x003a7; &#935; maiúsculo chi
ψ &psi; &#x003a8; &#936; letra maiúscula psi
ω &omega; &#x003a9; &#937; ômega letra maiúscula
α &alpha; &#x003b1; &#945; alfa minúsculo
β &beta; &#x003b2; &#946; beta letra minúscula
γ &gamma; &#x003b3; &#947; gama minúscula
δ &delta; &#x003b4; &#948; letra delta
ϵ ε &epsiv; &epsilon; &#x003b5; &#949; epsilon minúsculo
ζ &zeta; &#x003b6; &#950; zeta letra minúscula
η &eta; &#x003b7; &#951; letra minúscula eta
θ &theta; &#x003b8; &#952; letra minúscula teta
ι &iota; &#x003b9; &#953; letra minúscula iota
κ &kappa; &#x003ba; &#954; kappa minúsculo
λ &lambda; &#x003bb; &#955; lamda minúscula
μ &mu; &#x003bc; &#956; letra mi minúscula
ν &nu; &#x003bd; &#957; nu minúsculo
ξ &xi; &#x003be; &#958; letra minúscula xi
ο &omicron; &#x003bf; &#959; omicron minúsculo
π &pi; &#x003c0; &#960; pi minúsculo
ρ &rho; &#x003c1; &#961; minúsculo rho
ς &sigmav; &varsigma; &sigmaf; &#x003c2; &#962; final sigma minúsculo
σ &sigma; &#x003c3; &#963; sigma minúsculo
τ &tau; &#x003c4; &#964; tau minúsculo
υ &upsi; &upsilon; &#x003c5; &#965; letra minúscula upsilon
φ &phi; &phiv; &varphi; &#x003c6; &#966; letra minúscula phi
χ &chi; &#x003c7; &#967; letra minúscula chi
ψ &psi; &#x003c8; &#968; letra minúscula psi
ω &omega; &#x003c9; &#969; letra minúscula ômega
ϑ &thetav; &vartheta; &thetasym; &#x003d1; &#977; letra minúscula theta
υ ϒ &upsi; &upsih; &#x003d2; &#978; Upsilon com símbolo de gancho
φ &straightphi; &#x003d5; &#981; letra minúscula phi
ϖ &piv; &varpi; &#x003d6; &#982; letra minúscula pi
ϝ &gammad; &#x003dc; &#988; letra digamma
ϰ &kappav; &varkappa; &#x003f0; &#1008; símbolo kappa
ϱ &rhov; &varrho; &#x003f1; &#1009; letra rho
ε &epsi; &straightepsilon; &#x003f5; &#1013; épsilon semilunar
϶ &bepsi; &backepsilon; &#x003f6; &#1014; épsilon semilunar invertido
Caracteres Cirílicos
Caracter HTML HEX DEC Descrição
ё &iocy; &#x00401; &#1025; cirílico maiúsculo io
ђ &djcy; &#x00402; &#1026; dje cirílico maiúsculo
ѓ &gjcy; &#x00403; &#1027; cirílico maiúsculo gje
є &jukcy; &#x00404; &#1028; cirílico maiúsculo ucraniano, isto é
ѕ &dscy; &#x00405; &#1029; cirílico maiúsculo dze
і &iukcy; &#x00406; &#1030; cirílico maiúsculo bielorrussa-ucraniana i
ї &yicy; &#x00407; &#1031; cirílico maiúsculo yi
ј &jsercy; &#x00408; &#1032; cirílico maiúsculo je
љ &ljcy; &#x00409; &#1033; cirílico maiúsculo lje
њ &njcy; &#x0040a; &#1034; cirílico maiúsculo nje
ћ &tshcy; &#x0040b; &#1035; cirílico maiúsculo tshe
ќ &kjcy; &#x0040c; &#1036; cirílico maiúsculo kje
ў &ubrcy; &#x0040e; &#1038; cirílico maiúsculo curta u
џ &dzcy; &#x0040f; &#1039; cirílico maiúsculo dzhe
а &acy; &#x00410; &#1040; cirílico maiúsculo a
б &bcy; &#x00411; &#1041; cirílico maiúsculo seja
в &vcy; &#x00412; &#1042; cirílico maiúsculo ve
г &gcy; &#x00413; &#1043; cirílico maiúsculo ghe
д &dcy; &#x00414; &#1044; cirílico maiúsculo de
е &iecy; &#x00415; &#1045; cirílico maiúsculo , ou seja
ж &zhcy; &#x00416; &#1046; cirílico maiúsculo zhe
з &zcy; &#x00417; &#1047; cirílico maiúsculo ze
и &icy; &#x00418; &#1048; cirílico maiúsculo i
й &jcy; &#x00419; &#1049; cirílico maiúsculo curto i
к &kcy; &#x0041a; &#1050; cirílico maiúsculo ka
л &lcy; &#x0041b; &#1051; cirílico maiúsculo el
м &mcy; &#x0041c; &#1052; cirílico maiúsculo em
н &ncy; &#x0041d; &#1053; cirílico maiúsculo en
о &ocy; &#x0041e; &#1054; cirílico maiúsculo o
п &pcy; &#x0041f; &#1055; cirílico maiúsculo pe
р &rcy; &#x00420; &#1056; cirílico maiúsculo
с &scy; &#x00421; &#1057; letras maiúsculas cirílicas
т &tcy; &#x00422; &#1058; cirílico maiúsculo te
у &ucy; &#x00423; &#1059; cirílico maiúsculo u
ф &fcy; &#x00424; &#1060; cirílico maiúsculo ef
х &khcy; &#x00425; &#1061; cirílico maiúsculo ha
ц &tscy; &#x00426; &#1062; cirílico maiúsculo tse
ч &chcy; &#x00427; &#1063; cirílico maiúsculo che
ш &shcy; &#x00428; &#1064; cirílico maiúsculo sha
щ &shchcy; &#x00429; &#1065; cirílico maiúsculo shcha
ъ &hardcy; &#x0042a; &#1066; cirílico maiúsculo
ы &ycy; &#x0042b; &#1067; cirílico maiúsculo yeru
ь &softcy; &#x0042c; &#1068; signo suave em cirílico maiúsculo
э &ecy; &#x0042d; &#1069; cirílico maiúsculo e
ю &yucy; &#x0042e; &#1070; cirílico maiúsculo yu
я &yacy; &#x0042f; &#1071; cirílico maiúsculo ya
а &acy; &#x00430; &#1072; cirílico minúsculo a
б &bcy; &#x00431; &#1073; cirílico minúsculo seja
в &vcy; &#x00432; &#1074; cirílico minúsculo ve
г &gcy; &#x00433; &#1075; cirílico minúsculo ghe
д &dcy; &#x00434; &#1076; cirílico minúsculo de
е &iecy; &#x00435; &#1077; cirílico minúsculo , isto é
ж &zhcy; &#x00436; &#1078; cirílico minúsculo zhe
з &zcy; &#x00437; &#1079; letra minúscula ze cirílica
и &icy; &#x00438; &#1080; cirílico minúsculo i
й &jcy; &#x00439; &#1081; cirílico minúsculo curta i
к &kcy; &#x0043a; &#1082; letra minúscula ka cirílica
л &lcy; &#x0043b; &#1083; letra minúscula el cirílica
м &mcy; &#x0043c; &#1084; em minúsculo cirílico
н &ncy; &#x0043d; &#1085; cirílico minúsculo en
о &ocy; &#x0043e; &#1086; minúsculo cirílico o
п &pcy; &#x0043f; &#1087; pe minúsculo cirílico
р &rcy; &#x00440; &#1088; cirílico minúsculo er
с &scy; &#x00441; &#1089; letras minúsculas cirílicas
т &tcy; &#x00442; &#1090; cirílico minúsculo te
у &ucy; &#x00443; &#1091; letra minúscula você em cirílico
ф &fcy; &#x00444; &#1092; cirílico minúsculo ef
х &khcy; &#x00445; &#1093; cirílico minúsculo ha
ц &tscy; &#x00446; &#1094; cirílico minúsculo tse
ч &chcy; &#x00447; &#1095; cirílico minúsculo che
ш &shcy; &#x00448; &#1096; letra minúscula em cirílico sha
щ &shchcy; &#x00449; &#1097; cirílico minúsculo shcha
ъ &hardcy; &#x0044a; &#1098; letra minúscula cirílico duro
ы &ycy; &#x0044b; &#1099; cirílico minúsculo yeru
ь &softcy; &#x0044c; &#1100; signo macio de letra minúscula cirílico
э &ecy; &#x0044d; &#1101; letra minúscula e cirílica
ю &yucy; &#x0044e; &#1102; letra minúscula em cirílico, você
я &yacy; &#x0044f; &#1103; cirílico minúsculo sim
ё &iocy; &#x00451; &#1105; cirílico minúsculo io
ђ &djcy; &#x00452; &#1106; dje cirílico minúsculo
ѓ &gjcy; &#x00453; &#1107; cirílico minúsculo gje
є &jukcy; &#x00454; &#1108; cirílico minúsculo ucraniana, ie
ѕ &dscy; &#x00455; &#1109; cirílico minúsculo dze
і &iukcy; &#x00456; &#1110; cirílico minúsculo bielorrussa-ucraniana i
ї &yicy; &#x00457; &#1111; letra minúscula em cirílico yi
ј &jsercy; &#x00458; &#1112; je minúsculo cirílico
љ &ljcy; &#x00459; &#1113; cirílico minúsculo lje
њ &njcy; &#x0045a; &#1114; nje minúsculo cirílico
ћ &tshcy; &#x0045b; &#1115; cirílico minúsculo tshe
ќ &kjcy; &#x0045c; &#1116; kje minúsculo cirílico
ў &ubrcy; &#x0045e; &#1118; cirílico minúsculo curta u
џ &dzcy; &#x0045f; &#1119; dzhe minúsculo cirílico
Miscelânia de Caracteres
Caracter HTML HEX DEC Descrição
&vzigzag; &#x0299a; &#10650; linha em ziguezague vertical
&vangrt; &#x0299c; &#10652; variante de ângulo reto com quadrado
&angrtvbd; &#x0299d; &#10653; ângulo reto medido com ponto
&ange; &#x029a4; &#10660; ângulo com barra
&range; &#x029a5; &#10661; ângulo invertido com barra inferior
&dwangle; &#x029a6; &#10662; ângulo oblíquo abrindo
&uwangle; &#x029a7; &#10663; abertura de ângulo oblíquo para baixo
&angmsdaa; &#x029a8; &#10664; medida de ângulo, seta nordeste
&angmsdab; &#x029a9; &#10665; medida de ângulo, seta oeste
&angmsdac; &#x029aa; &#10666; medida de ângulo, seta sudeste
&angmsdad; &#x029ab; &#10667; medida de ângulo, seta sudoeste
&angmsdae; &#x029ac; &#10668; medida de ângulo, seta nordeste
&angmsdaf; &#x029ad; &#10669; medida de ângulo, seta oeste
&angmsdag; &#x029ae; &#10670; medida de ângulo, seta sudeste
&angmsdah; &#x029af; &#10671; medida de ângulo, seta nordeste
&bemptyv; &#x029b0; &#10672; conjunto vazio invertido
&demptyv; &#x029b1; &#10673; conjunto vazio com barra superior
&cemptyv; &#x029b2; &#10674; conjunto vazio com círculo acima
&raemptyv; &#x029b3; &#10675; conjunto vazio com a seta direita acima
&laemptyv; &#x029b4; &#10676; conjunto vazio com seta esquerda acima
&ohbar; &#x029b5; &#10677; círculo com barra horizontal
&omid; &#x029b6; &#10678; barra vertical circulada
&opar; &#x029b7; &#10679; circulado paralelo
&operp; &#x029b9; &#10681; circular perpendicular
&olcross; &#x029bb; &#10683; círculo com x sobreposto
&odsold; &#x029bc; &#10684; divisão girado no sentido anti-horário
&olcir; &#x029be; &#10686; bala branca circulada
⦿ &ofcir; &#x029bf; &#10687; bala circulada
&olt; &#x029c0; &#10688; circulou menos que
&ogt; &#x029c1; &#10689; circulado maior que
&cirscir; &#x029c2; &#10690; círculo com círculo menor à direita
&cire; &#x029c3; &#10691; círculo com dois traços horizontais para a direita
&solb; &#x029c4; &#10692; barra diagonal ascendente quadrada
&bsolb; &#x029c5; &#10693; quadrado caindo barra diagonal
&boxbox; &#x029c9; &#10697; dois quadrados unidos
&trisb; &#x029cd; &#10701; triângulo com serifas na parte inferior
&rtriltri; &#x029ce; &#10702; triângulo direito acima do triângulo esquerdo
&lefttrianglebar; &#x029cf; &#10703; triângulo esquerdo ao lado da barra vertical
&righttrianglebar; &#x029d0; &#10704; barra vertical ao lado do triângulo retângulo
∽̱ &race; &#x029da; &#10714; cerca esquerda dupla ondulada
&eparsl; &#x029e3; &#10723; é igual a sinal e paralelo inclinado
&smeparsl; &#x029e4; &#10724; é igual ao sinal e inclinado paralelo ao til acima
&eqvparsl; &#x029e5; &#10725; idêntico e inclinado paralelo
&dsol; &#x029f6; &#10742; barra com traço superior
&pluscir; &#x02a22; &#10786; mais com ponto acima
&plusacir; &#x02a23; &#10787; mais com circunflexo acima
&simplus; &#x02a24; &#10788; mais com til acima
&plusdu; &#x02a25; &#10789; mais com ponto abaixo
&plussim; &#x02a26; &#10790; mais com til abaixo
&plustwo; &#x02a27; &#10791; mais com subscrito dois
&mcomma; &#x02a29; &#10793; menos com vírgula acima
&minusdu; &#x02a2a; &#10794; menos com ponto abaixo
&loplus; &#x02a2d; &#10797; mais no semicírculo esquerdo
&roplus; &#x02a2e; &#10798; mais no semicírculo direito
&cross; &#x02a2f; &#10799; vetor ou produto vetorial
&timesd; &#x02a30; &#10800; multiplicação com ponto acima
&timesbar; &#x02a31; &#10801; multiplicação com barra inferior
&smashp; &#x02a33; &#10803; esmagar produto
&lotimes; &#x02a34; &#10804; multiplicação no semicírculo esquerdo
&rotimes; &#x02a35; &#10805; multiplicação no semicírculo direito
&otimesas; &#x02a36; &#10806; multiplicação circulado com acento circunflexo
&otimes; &#x02a37; &#10807; multiplicação em círculo duplo
&odiv; &#x02a38; &#10808; divisão circulado
&triplus; &#x02a39; &#10809; mais no triângulo
&triminus; &#x02a3a; &#10810; menos no triângulo
&tritime; &#x02a3b; &#10811; multiplicação em triângulo
⨼ ⨼ &iprod; &intprod; &#x02a3c; &#10812; produto interior
⨿ &amalg; &#x02a3f; &#10815; amalgamação ou coproduto
&capdot; &#x02a40; &#10816; intersecção com ponto
&ncup; &#x02a42; &#10818; união com barra superior
&ncap; &#x02a43; &#10819; intersecção com barra superior
&capand; &#x02a44; &#10820; intersecção com lógica e
&cupor; &#x02a45; &#10821; união com lógica ou
&cupcap; &#x02a46; &#10822; união acima da interseção
&capcup; &#x02a47; &#10823; intersecção acima da união
&cupbrcap; &#x02a48; &#10824; união acima da barra acima da interseção
&capbrcup; &#x02a49; &#10825; intersecção acima da barra acima da união
&cupcup; &#x02a4a; &#10826; união ao lado e juntou-se a união
&capcap; &#x02a4b; &#10827; intersecção ao lado e junta com intersecção
&ccups; &#x02a4c; &#10828; união fechada com serifas
&ccaps; &#x02a4d; &#10829; interseção fechada com serifas
&ccupssm; &#x02a50; &#10832; união fechada com serifas e produto esmagado
&and; &#x02a53; &#10835; duplo lógico e
&or; &#x02a54; &#10836; duplo lógico ou
&andand; &#x02a55; &#10837; dois lógicos que se cruzam e
&oror; &#x02a56; &#10838; dois lógicos que se cruzam ou
&orslope; &#x02a57; &#10839; grande inclinado ou
&andslope; &#x02a58; &#10840; inclinado grande e
&andv; &#x02a5a; &#10842; lógico e com haste intermediária
&orv; &#x02a5b; &#10843; lógico ou com haste intermediária
&andd; &#x02a5c; &#10844; lógico e com traço horizontal
&ord; &#x02a5d; &#10845; lógico ou com traço horizontal
&wedbar; &#x02a5f; &#10847; lógico e com barra inferior
&sdote; &#x02a66; &#10854; é igual ao sinal com o ponto abaixo
&simdot; &#x02a6a; &#10858; Operador til com ponto acima
&congdot; &#x02a6d; &#10861; congruente com o ponto acima
&easter; &#x02a6e; &#10862; é igual a asterisco
&apacir; &#x02a6f; &#10863; quase igual a com acento circunflexo
&ape; &#x02a70; &#10864; aproximadamente igual ou igual a
&eplus; &#x02a71; &#10865; igual acima do mais
&pluse; &#x02a72; &#10866; mais acima do igual
&esim; &#x02a73; &#10867; igual ao sinal acima do operador til
&colone; &#x02a74; &#10868; dois pontos duplos iguais
&equal; &#x02a75; &#10869; dois sinais de igual consecutivos
&eddot; &ddotseq; &#x02a77; &#10871; é igual ao sinal com dois pontos acima e dois pontos abaixo
&equivdd; &equivdd; &#x02a78; &#10872; equivalente com quatro pontos acima
&ltcir; &#x02a79; &#10873; menos do que com um círculo dentro
&gtcir; &#x02a7a; &#10874; maior do que com um círculo dentro
&ltquest; &#x02a7b; &#10875; menos do que com ponto de interrogação acima
&gtquest; &#x02a7c; &#10876; maior do que com ponto de interrogação acima
&les; &lessslantequal; &leqslant; &#x02a7d; &#10877; menor ou inclinado igual a
&ges; &greaterslantequal; &geqslant; &#x02a7e; &#10878; maior que ou inclinado igual a
⩿ &lesdot; &#x02a7f; &#10879; menor que ou inclinado igual a com ponto dentro
&gesdot; &#x02a80; &#10880; maior que ou inclinado igual a com ponto dentro
&lesdoto; &#x02a81; &#10881; menor que ou inclinado igual ao ponto acima
&gesdoto; &#x02a82; &#10882; maior que ou inclinado igual ao ponto acima
&lesdotor; &#x02a83; &#10883; menor que ou inclinado igual a com ponto acima à direita
&gesdotol; &#x02a84; &#10884; maior que ou inclinado igual ao ponto acima à esquerda
&lap; &lessapprox; &#x02a85; &#10885; menor ou aproximado
&gap; &gtrapprox; &#x02a86; &#10886; maior que ou aproximado
&lne; &lneq; &#x02a87; &#10887; menor que e linha única não igual a
&gne; &gneq; &#x02a88; &#10888; maior que e linha única diferente de
&lnap; &lnapprox; &#x02a89; &#10889; inferior e não aproximado
&gnap; &gnapprox; &#x02a8a; &#10890; maior que e não aproximado
&leg; &lesseqqgtr; &#x02a8b; &#10891; menor que acima linha dupla igual acima maior que
&gel; &gtreqqless; &#x02a8c; &#10892; maior que acima linha dupla igual acima menor que
&lsime; &#x02a8d; &#10893; menor que acima semelhante ou igual
&gsime; &#x02a8e; &#10894; maior do que acima semelhante ou igual
&lsimg; &#x02a8f; &#10895; menor que acima semelhante acima maior que
&gsiml; &#x02a90; &#10896; maior que acima semelhante acima menor que
&lge; &lge; &#x02a91; &#10897; menor que acima maior que acima linha dupla igual
&gle; &gle; &#x02a92; &#10898; maior que acima menor que acima linha dupla igual
&lesges; &#x02a93; &#10899; menor que acima inclinado igual acima maior que acima inclinado igual
&gesles; &#x02a94; &#10900; maior que acima inclinado igual acima menor que acima inclinado igual
&els; &eqslantless; &#x02a95; &#10901; inclinado igual ou menor que
&egs; &eqslantgtr; &#x02a96; &#10902; inclinado igual ou maior que
&elsdot; &#x02a97; &#10903; inclinado igual ou menor do que com ponto dentro
&egsdot; &#x02a98; &#10904; inclinado igual ou maior que com ponto dentro
&el; &#x02a99; &#10905; linha dupla igual ou menor que
&eg; &#x02a9a; &#10906; linha dupla igual ou maior que
&siml; &#x02a9d; &#10909; semelhante ou inferior
&simg; &#x02a9e; &#10910; semelhante ou maior que
&simle; &simle; &#x02a9f; &#10911; semelhante acima menos-que acima é igual ao sinal
&simge; &simge; &#x02aa0; &#10912; semelhante acima maior do que acima é igual ao sinal
&lessless; &lessless; &#x02aa1; &#10913; duplo aninhado menor que
&greatergreater; &greatergreater; &#x02aa2; &#10914; aninhado duplo maior que
&glj; &#x02aa4; &#10916; maior que sobreposição menor que
&gla; &#x02aa5; &#10917; maior que ao lado menor que
&ltcc; &#x02aa6; &#10918; menos que fechado por curva
&gtcc; &#x02aa7; &#10919; maior que fechado por curva
&lescc; &#x02aa8; &#10920; menos que fechado pela curva acima inclinado igual
&gescc; &#x02aa9; &#10921; maior que fechado por curva acima inclinado igual
&smt; &#x02aaa; &#10922; menor que
&lat; &#x02aab; &#10923; maior que
&smte; &#x02aac; &#10924; menor ou igual a
&late; &#x02aad; &#10925; maior ou igual a
&bumpe; &#x02aae; &#10926; é igual ao sinal com irregular acima
&pre; &preceq; &precedesequal; &#x02aaf; &#10927; precede acima do igual de linha única
&sce; &succeq; &succeedsequal; &#x02ab0; &#10928; sucede acima do igual de linha única
&pre; &#x02ab3; &#10931; precede o igual
&sce; &#x02ab4; &#10932; sucede acima do igual
&prne; &precneqq; &#x02ab5; &#10933; precede acima não é igual a
&scne; &succneqq; &#x02ab6; &#10934; sucede acima não igual a
&prap; &precapprox; &#x02ab7; &#10935; precede acima quase igual a
&scap; &succapprox; &#x02ab8; &#10936; sucede acima de quase igual a
&prnap; &precnapprox; &#x02ab9; &#10937; precede acima, não quase igual a
&scnap; &succnapprox; &#x02aba; &#10938; sucede acima, não quase igual a
&pr; &#x02abb; &#10939; o dobro precede
&sc; &#x02abc; &#10940; sucesso duplo
&subdot; &#x02abd; &#10941; subconjunto com ponto
&supdot; &#x02abe; &#10942; superconjunto com ponto
⪿ &subplus; &#x02abf; &#10943; subconjunto com mais abaixo
&supplus; &#x02ac0; &#10944; superconjunto com mais abaixo
&submult; &#x02ac1; &#10945; subconjunto com multiplicação abaixo
&supmult; &#x02ac2; &#10946; superconjunto com multiplicação abaixo
&subedot; &#x02ac3; &#10947; subconjunto de ou igual a com ponto acima
&supedot; &#x02ac4; &#10948; superconjunto de ou igual a com ponto acima
&sube; &subseteqq; &#x02ac5; &#10949; subconjunto de igual acima
&supe; &supseteqq; &#x02ac6; &#10950; superconjunto de igual acima
&subsim; &#x02ac7; &#10951; subconjunto do operador til acima
&supsim; &#x02ac8; &#10952; superconjunto do operador til acima
&subne; &subsetneqq; &#x02acb; &#10955; subconjunto de acima não igual a
&supne; &supsetneqq; &#x02acc; &#10956; superconjunto de acima não igual a
&csub; &#x02acf; &#10959; subconjunto fechado
&csup; &#x02ad0; &#10960; superconjunto fechado
&csube; &#x02ad1; &#10961; subconjunto fechado ou igual a
&csupe; &#x02ad2; &#10962; superconjunto fechado ou igual a
&subsup; &#x02ad3; &#10963; subconjunto acima do superconjunto
&supsub; &#x02ad4; &#10964; superconjunto acima do subconjunto
&subsub; &#x02ad5; &#10965; subconjunto acima do subconjunto
&supsup; &#x02ad6; &#10966; superconjunto acima do superconjunto
&suphsub; &#x02ad7; &#10967; superconjunto ao lado do subconjunto
&supdsub; &#x02ad8; &#10968; superconjunto ao lado e unido por traço com subconjunto
&forkv; &#x02ad9; &#10969; elemento de abertura para baixo
&topfork; &#x02ada; &#10970; forcado com camiseta
&mlcp; &#x02adb; &#10971; intersecção transversal
&dashv; &doublelefttee; &#x02ae4; &#10980; barra vertical dupla catraca esquerda
&vdashl; &#x02ae6; &#10982; traço longo do membro esquerdo da vertical dupla
&barv; &#x02ae7; &#10983; amura curta com barra superior
&vbar; &#x02ae8; &#10984; amura curta com barra inferior
&vbarv; &#x02ae9; &#10985; amura curta acima da amura curta
&vbar; &#x02aeb; &#10987; dobrar a aderência
¬ &not; &#x02aec; &#10988; traço duplo não sinal
&bnot; &#x02aed; &#10989; traço duplo invertido sem sinal
&rnmid; &#x02aee; &#10990; não divide com barra de negação invertida
&cirmid; &#x02aef; &#10991; linha vertical com círculo acima
&midcir; &#x02af0; &#10992; linha vertical com círculo abaixo
&topcir; &#x02af1; &#10993; rumo para baixo com círculo abaixo
&nhpar; &#x02af2; &#10994; paralelo com traço horizontal
&parsim; &#x02af3; &#10995; paralelo com operador til
&parsl; &#x02afd; &#11005; operador barra dupla
Sinais Gráficos
Caracter HTML HEX DEC Descrição
&dagger; &#x02020; &#8224; punhal
&dagger; &ddagger; &#x02021; &#8225; punhal duplo
&bull; &bullet; &#x02022; &#8226; bala
&nldr; &#x02025; &#8229; líder de dois pontos
&hellip; &mldr; &#x02026; &#8230; elipse horizontal
&permil; &#x02030; &#8240; por milhar
&pertenk; &#x02031; &#8241; por dez mil
&prime; &#x02032; &#8242; aspas
&prime; &#x02033; &#8243; aspas dupla
&tprime; &#x02034; &#8244; aspas tripla
&qprime; &#x02057; &#8279; aspas quádruplas
&bprime; &backprime; &#x02035; &#8245; aspas invertida
&lsaquo; &#x02039; &#8249; única aspa angular esquerda
&rsaquo; &#x0203a; &#8250; única aspa angular direita
&oline; &#x0203e; &#8254; overline
&caret; &#x02041; &#8257; ponto de inserção acento circunflexo
&hybull; &#x02043; &#8259; hífen marcador
&frasl; &#x02044; &#8260; barra de fração
&bsemi; &#x0204f; &#8271; ponto e vírgula invertido
&applyfunction; &af; &#x02061; &#8289; aplicação de função
&tdot; &tripledot; &#x020db; &#8411; combinando três pontos acima
𝕔 &copf; &complexes; &#x02102; &#8450; c maiúsculo duplo
&incare; &#x02105; &#8453; aos cuidados de
&gscr; &#x0210a; &#8458; script g minúsculo
&hamilt; &hilbertspace; &hscr; &#x0210b; &#8459; script h maiúsculo
𝔥 &hfr; &poincareplane; &#x0210c; &#8460; letra preta h maiúsculo
𝕙 &quaternions; &hopf; &#x0210d; &#8461; H maiúsculo duplo
&planckh; &#x0210e; &#8462; constante de planck
&planck; &hbar; &plankv; &hslash; &#x0210f; &#8463; Planck cortado
&iscr; &imagline; &#x02110; &#8464; script I maiúsculo
&image; &im; &imagpart; &ifr; &#x02111; &#8465; letra preta i maiúscula
&lscr; &lagran; &laplacetrf; &#x02112; &#8466; script l maiúsculo
&ell; &#x02113; &#8467; roteiro pequeno l
𝕟 ℕ &nopf; &naturals; &#x02115; &#8469; n maiúsculo duplo
&numero; &#x02116; &#8470; sinal numero
&copysr; &#x02117; &#8471; gravação de som copyright
&weierp; &wp; &#x02118; &#8472; script p
𝕡 ℙ &popf; &primes; &#x02119; &#8473; p maiúsculo duplo
ℚ 𝕢 &rationals; &qopf; &#x0211a; &#8474; Q maiúsculo duplo
&rscr; &realine; &#x0211b; &#8475; script r maiúsculo
ℜ 𝔯 &real; &re; &realpart; &rfr; &#x0211c; &#8476; reais
ℝ 𝕣 &reals; &ropf; &#x0211d; &#8477; r maiúsculo duplo
&rx; &#x0211e; &#8478; receita
&trade; &trade; &#x02122; &#8482; marca registrada
&integers; &zopf; &#x02124; &#8484; z maiúsculo duplo
Ω &ohm; &#x02126; &#8486; ohm (resistência)
&mho; &#x02127; &#8487; ohm invertido
𝔷 ℨ &zfr; &zeetrf; &#x02128; &#8488; preta z maiúscula
&iiota; &#x02129; &#8489; minúsculo iota
Å &angst; &#x0212b; &#8491; angstrom
&bernou; &bernoullis; &#x0212c; &#8492; script b maiúsculo
𝔠 &cfr; &cayleys; &#x0212d; &#8493; letra preta c maiúscula
&escr; &#x0212f; &#8495; script e pequeno
&escr; &expectation; &#x02130; &#8496; script e maiúsculo
𝒻 &fscr; &fouriertrf; &#x02131; &#8497; script f maiúsculo
ℳ 𝓂 &phmmat; &mellintrf; &mscr; &#x02133; &#8499; script m
&order; &orderof; &oscr; &#x02134; &#8500; script pequeno o
ℵ ℵ &alefsym; &aleph; &#x02135; &#8501; símbolo alef
&beth; &#x02136; &#8502; símbolo de aposta
&gimel; &#x02137; &#8503; símbolo gimel
&daleth; &#x02138; &#8504; símbolo dalet
&dD; &#x02145; &#8517; itálico duplo traçado d
&dd; &#x02146; &#8518; itálico duplo traçado pequeno d
&exponentiale; &exponentiale; &ee; &#x02147; &#8519; e pequeno itálico duplo traçado
&imaginaryi; &ii; &#x02148; &#8520; itálico duplo traçado pequeno i
&prop; &propto; &vprop; &#x0221d; &#8733; proporcional a
&infin; &#x0221e; &#8734; infinito
&angrt; &#x0221f; &#8735; ângulo reto
&ang; &#x02220; &#8736; ângulo
&angmsd; &measuredangle; &#x02221; &#8737; ângulo medido
&angsph; &#x02222; &#8738; ângulo esférico
&mid; &smid; &shortmid; &#x02223; &#8739; divide
&nmid; &nsmid; &nshortmid; &#x02224; &#8740; não divide
&par; &parallel; &spar; &#x02225; &#8741; paralelo a
&npar; &nparallel; &#x02226; &#8742; não paralelo a
&and; &wedge; &#x02227; &#8743; lógico e
&or; &vee; &#x02228; &#8744; lógico ou
&cap; &#x02229; &#8745; interseção
&cup; &#x0222a; &#8746; união
&there4; &therefore; &therefore; &#x02234; &#8756; portanto
&becaus; &because; &because; &#x02235; &#8757; porque
&ratio; &#x02236; &#8758; razão
: &colon; &proportion; &#x02237; &#8759; proporção
&minusd; &dotminus; &#x02238; &#8760; ponto menos
&homtht; &#x0223b; &#8763; homotético
&sim; &thksim; &thicksim; &#x0223c; &#8764; operador til
&bsim; &backsim; &#x0223d; &#8765; til invertido
&ac; &mstpos; &#x0223e; &#8766; S invertido
&acd; &#x0223f; &#8767; senoidal
&wreath; &verticaltilde; &wr; &#x02240; &#8768; produto de coroa
&nsim; &nottilde; &#x02241; &#8769; til cortado
&esim; &equaltilde; &eqsim; &#x02242; &#8770; menos til
&sime; &tildeequal; &simeq; &#x02243; &#8771; assintoticamente igual a
&nsime; &nsimeq; &nottildeequal; &#x02244; &#8772; não assintoticamente igual a
&cong; &tildefullequal; &#x02245; &#8773; aproximadamente igual a
&simne; &#x02246; &#8774; aproximadamente, mas não exatamente igual
&ncong; &nottildefullequal; &#x02247; &#8775; nem aproximado nem igual a
&asymp; &ap; &approx; &thkap; &thickapprox; &#x02248; &#8776; quase igual
&nap; &nottildetilde; &napprox; &#x02249; &#8777; não quase igual
&ape; &approxeq; &#x0224a; &#8778; quase igual ou igual
&apid; &#x0224b; &#8779; triplo till
&bcong; &backcong; &#x0224c; &#8780; todos iguais a
&asympeq; &cupcap; &#x0224d; &#8781; equivalente a
&bump; &humpdownhump; &bumpeq; &#x0224e; &#8782; geometricamente equivalente a
&bumpe; &humpequal; &bumpeq; &#x0224f; &#8783; diferença entre
&esdot; &dotequal; &doteq; &#x02250; &#8784; aproxima-se do limite
ė &edot; &doteqdot; &#x02251; &#8785; geometricamente igual a
&colone; &coloneq; &#x02254; &#8788; dois pontos igual
&ecolon; &eqcolon; &#x02255; &#8789; igual dois pontos
&ecir; &eqcirc; &#x02256; &#8790; anel igual a
&cire; &circeq; &#x02257; &#8791; anel igual a
&wedgeq; &#x02259; &#8793; estimativas
&veeeq; &#x0225a; &#8794; equiangular para
&trie; &triangleq; &#x0225c; &#8796; delta igual
&equest; &questeq; &#x0225f; &#8799; igual questionado
&ne; &notequal; &#x02260; &#8800; não é igual a (diferente)
&equiv; &congruent; &#x02261; &#8801; idêntico a
&nequiv; &notcongruent; &#x02262; &#8802; não idêntico a
&le; &leq; &#x02264; &#8804; menor ou igual
&ge; &greaterequal; &geq; &#x02265; &#8805; maior ou igual
&le; &lessfullequal; &leqq; &#x02266; &#8806; menor que, igual
&ge; &greaterfullequal; &geqq; &#x02267; &#8807; maior do, igual
&lne; &lneqq; &#x02268; &#8808; menor que, diferente
&gne; &gneqq; &#x02269; &#8809; maior que, diferente
< &lt; &nestedlessless; &ll; &#x0226a; &#8810; muito menor que
> &gt; &nestedgreatergreater; &gg; &#x0226b; &#8811; muito maior que
&twixt; &between; &#x0226c; &#8812; entre
&nlt; &notless; &nless; &#x0226e; &#8814; não menor que
&ngt; &notgreater; &ngtr; &#x0226f; &#8815; não maior que
&nle; &notlessequal; &nleq; &#x02270; &#8816; nem menor que nem igual a
&nge; &notgreaterequal; &ngeq; &#x02271; &#8817; nem maior que nem igual a
&lsim; &lesstilde; &lesssim; &#x02272; &#8818; menor ou equivalente a
&gsim; &gtrsim; &greatertilde; &#x02273; &#8819; maior que ou equivalente a
&nlsim; &notlesstilde; &#x02274; &#8820; nem menor que nem equivalente a
&ngsim; &notgreatertilde; &#x02275; &#8821; nem maior que nem equivalente a
&lg; &lessgtr; &lessgreater; &#x02276; &#8822; menor ou maior que
&gl; &gtrless; &greaterless; &#x02277; &#8823; maior ou menor que
&ntlg; &notlessgreater; &#x02278; &#8824; nem menor que nem maior que
&ntgl; &notgreaterless; &#x02279; &#8825; nem maior que nem menor que
&pr; &precedes; &prec; &#x0227a; &#8826; precede
&sc; &succeeds; &succ; &#x0227b; &#8827; sucede
&prcue; &precedesslantequal; &preccurlyeq; &#x0227c; &#8828; precede ou igual a
&sccue; &succeedsslantequal; &succcurlyeq; &#x0227d; &#8829; sucede ou igual
&prsim; &precsim; &precedestilde; &#x0227e; &#8830; precede ou equivalente a
&scsim; &succsim; &succeedstilde; &#x0227f; &#8831; sucede ou equivalente a
&npr; &nprec; &notprecedes; &#x02280; &#8832; não precede
&nsc; &nsucc; &notsucceeds; &#x02281; &#8833; não sucede
&sqsub; &squaresubset; &sqsubset; &#x0228f; &#8847; imagem quadrada de
&sqsup; &squaresuperset; &sqsupset; &#x02290; &#8848; quadrado original de
&sqsube; &squaresubsetequal; &sqsubseteq; &#x02291; &#8849; imagem quadrada de ou igual a
&sqsupe; &squaresupersetequal; &sqsupseteq; &#x02292; &#8850; quadrado original de ou igual a
&sqcap; &squareintersection; &#x02293; &#8851; chapeu quadrado
&sqcup; &squareunion; &#x02294; &#8852; copo quadrado
&vdash; &righttee; &#x022a2; &#8866; rumo direito
&dashv; &lefttee; &#x022a3; &#8867; rumo esquerdo
&top; &downtee; &#x022a4; &#8868; aderência
&bottom; &bot; &perp; &uptee; &#x022a5; &#8869; aderência
&models; &#x022a7; &#8871; modela
&vdash; &doublerighttee; &#x022a8; &#8872; verdadeiro
&vdash; &#x022a9; &#8873; forças
&vdash; &#x022ab; &#8875; barra vertical dupla catraca direita dupla
&nvdash; &#x022ac; &#8876; não prova
&nvdash; &#x022ad; &#8877; Não é verdade
&nvdash; &#x022ae; &#8878; não força
&nvdash; &#x022af; &#8879; torniquete duplo direito barra vertical dupla negada
&prurel; &#x022b0; &#8880; precede em relação
&vltri; &vartriangleleft; &lefttriangle; &#x022b2; &#8882; subgrupo normal de
&vrtri; &vartriangleright; &righttriangle; &#x022b3; &#8883; contém como subgrupo normal
&ltrie; &trianglelefteq; &lefttriangleequal; &#x022b4; &#8884; subgrupo normal ou igual a
&rtrie; &trianglerighteq; &righttriangleequal; &#x022b5; &#8885; contém como subgrupo normal ou igual a
&origof; &#x022b6; &#8886; original de
&imof; &#x022b7; &#8887; imagem de
&mumap; &multimap; &#x022b8; &#8888; multimapa
&hercon; &#x022b9; &#8889; matriz conjugada hermitiana
&intcal; &intercal; &#x022ba; &#8890; intercalar
&veebar; &#x022bb; &#8891; xor lógico
&barvee; &#x022bd; &#8893; nor lógico
&angrtvb; &#x022be; &#8894; ângulo reto com arco
&lrtri; &#x022bf; &#8895; triângulo retângulo
&xwedge; &wedge; &bigwedge; &#x022c0; &#8896; n-ário lógico e
&xvee; &vee; &bigvee; &#x022c1; &#8897; n-ário lógico ou
&diam; &diamond; &diamond; &#x022c4; &#8900; operador de diamante
&sdot; &#x022c5; &#8901; operador de ponto
&sstarf; &star; &#x022c6; &#8902; operador estrela
&divonx; &divideontimes; &#x022c7; &#8903; vezes divisão
&bowtie; &#x022c8; &#8904; gravata-borboleta
&ltimes; &#x022c9; &#8905; produto semidireto de fator normal esquerdo
&rtimes; &#x022ca; &#8906; produto semidireto de fator normal correto
&lthree; &leftthreetimes; &#x022cb; &#8907; produto semidireto esquerdo
&rthree; &rightthreetimes; &#x022cc; &#8908; produto semidireto certo
&bsime; &backsimeq; &#x022cd; &#8909; til invertido é igual a
&cuvee; &curlyvee; &#x022ce; &#8910; ou lógico curvo
&cuwed; &curlywedge; &#x022cf; &#8911; e lógico curvo
&sub; &subset; &#x022d0; &#8912; subconjunto duplo
&sup; &supset; &#x022d1; &#8913; superconjunto duplo
&cap; &#x022d2; &#8914; cruzamento duplo
&cup; &#x022d3; &#8915; união dupla
&fork; &pitchfork; &#x022d4; &#8916; forquilha
&epar; &#x022d5; &#8917; igual e paralelo a
&ltdot; &lessdot; &#x022d6; &#8918; menos do que com ponto
&gtdot; &gtrdot; &#x022d7; &#8919; maior do que com ponto
&ll; &#x022d8; &#8920; muito menos do que
&gg; &ggg; &#x022d9; &#8921; muito maior do que
&leg; &lessequalgreater; &lesseqgtr; &#x022da; &#8922; menor que igual ou maior que
&gel; &gtreqless; &greaterequalless; &#x022db; &#8923; maior que igual ou menor que
&cuepr; &curlyeqprec; &#x022de; &#8926; igual a ou precede
&cuesc; &curlyeqsucc; &#x022df; &#8927; igual ou sucede
&nprcue; &notprecedesslantequal; &#x022e0; &#8928; não precede ou é igual
&nsccue; &notsucceedsslantequal; &#x022e1; &#8929; não sucede ou igual
&nsqsube; &notsquaresubsetequal; &#x022e2; &#8930; imagem não quadrada ou igual a
&nsqsupe; &notsquaresupersetequal; &#x022e3; &#8931; não quadrado original ou igual a
&lnsim; &#x022e6; &#8934; menor que, mas não equivalente a
&gnsim; &#x022e7; &#8935; maior que, mas não equivalente a
&prnsim; &precnsim; &#x022e8; &#8936; precede, mas não é equivalente a
&scnsim; &succnsim; &#x022e9; &#8937; sucede, mas não equivalente a
&nltri; &ntriangleleft; &notlefttriangle; &#x022ea; &#8938; subgrupo não normal de
&nrtri; &ntriangleright; &notrighttriangle; &#x022eb; &#8939; não contém um subgrupo normal
&nltrie; &ntrianglelefteq; &notlefttriangleequal; &#x022ec; &#8940; subgrupo não normal ou igual a
&nrtrie; &ntrianglerighteq; &notrighttriangleequal; &#x022ed; &#8941; não contém subgrupo normal ou igual
&vellip; &#x022ee; &#8942; elipse vertical
&ctdot; &#x022ef; &#8943; elipse horizontal da linha média
&utdot; &#x022f0; &#8944; elipse diagonal direita
&dtdot; &#x022f1; &#8945; elipse diagonal direita para baixo
&disin; &#x022f2; &#8946; elemento de com longo curso horizontal
&isinsv; &#x022f3; &#8947; elemento de com barra vertical no final do curso horizontal
&isins; &#x022f4; &#8948; pequeno elemento de com barra vertical no final do traço horizontal
&isindot; &#x022f5; &#8949; elemento de com ponto acima
&notinvc; &#x022f6; &#8950; elemento de com barra superior
&notinvb; &#x022f7; &#8951; pequeno elemento de com barra superior
&nisd; &#x022fa; &#8954; contém com longo curso horizontal
&xnis; &#x022fb; &#8955; contém com barra vertical no final do traço horizontal
&nis; &#x022fc; &#8956; pequeno contém com barra vertical no final do traço horizontal
&notnivc; &#x022fd; &#8957; contém com barra superior
&notnivb; &#x022fe; &#8958; pequeno contém com barra superior
&barwed; &barwedge; &#x02305; &#8965; projetivo
&barwed; &doublebarwedge; &#x02306; &#8966; perspectiva
&lceil; &leftceiling; &#x02308; &#8968; teto esquerdo
&rceil; &rightceiling; &#x02309; &#8969; teto direito
&lfloor; &leftfloor; &#x0230a; &#8970; chão esquerdo
&rfloor; &rightfloor; &#x0230b; &#8971; chão certo
&drcrop; &#x0230c; &#8972; corte inferior direito
&dlcrop; &#x0230d; &#8973; corte inferior esquerdo
&urcrop; &#x0230e; &#8974; corte superior direito
&ulcrop; &#x0230f; &#8975; corte superior esquerdo
&bnot; &#x02310; &#8976; invertido, não assinar
&profline; &#x02312; &#8978; arco
&profsurf; &#x02313; &#8979; segmento
&telrec; &#x02315; &#8981; gravador de telefone
&target; &#x02316; &#8982; indicador de posição
&ulcorn; &ulcorner; &#x0231c; &#8988; canto superior esquerdo
&urcorn; &urcorner; &#x0231d; &#8989; canto superior direito
&dlcorn; &llcorner; &#x0231e; &#8990; canto inferior esquerdo
&drcorn; &lrcorner; &#x0231f; &#8991; canto inferior direito
&frown; &sfrown; &#x02322; &#8994; carranca
&smile; &ssmile; &#x02323; &#8995; sorriso
&cylcty; &#x0232d; &#9005; cilindricidade
&profalar; &#x0232e; &#9006; perfil generalizado
&topbot; &#x02336; &#9014; símbolo funcional apl i-beam
&ovbar; &#x0233d; &#9021; estilo de círculo de símbolo funcional apl
&solbar; &#x0233f; &#9023; barra de barra de símbolo funcional apl
&angzarr; &#x0237c; &#9084; ângulo reto com seta em zigue-zague para baixo
&lmoust; &lmoustache; &#x023b0; &#9136; seção superior esquerda ou inferior direita das chaves
&rmoust; &rmoustache; &#x023b1; &#9137; seção superior direita ou inferior esquerda das chaves
&tbrk; &overbracket; &#x023b4; &#9140; colchete superior
&bbrk; &underbracket; &#x023b5; &#9141; colchete inferior
&bbrktbrk; &#x023b6; &#9142; colchete inferior sobre colchete superior
&trpezium; &#x023e2; &#9186; trapézio branco

Tabela ASCII

Programação com R

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

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 frame iris 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():

> abaixoDaMedia <- function(x) {
                   media <- mean(x)
                   return(x[x < media])
                   }
> abaixoDaMedia(c(1,2,3,40,50))
 [1] 1 2 3
> minSapply <- sapply(cars, abaixoDaMedia)
> minLapply <- lapply(cars, abaixoDaMedia)
[1] TRUE
> minSapply
$speed
 [1]  4  4  7  7  8  9 10 10 10 11 11 12 12 12 12 13 13 13 13 14 14 14 14 15
[25] 15 15
$dist
 [1]  2 10  4 22 16 10 18 26 34 17 28 14 20 24 28 26 34 34 26 36 20 26 32 40
[25] 32 40 42 36 32

> # Os valores retornados são iguais (embora em objetos distintos):
> identical(minSapply, minLapply)
 [1] TRUE

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.

> anos <- 100
> quantosAnos <- function() { 
      anos <- 10
      anosLocal <- function() { print( anos + 5 ) } 
      anosGlobal <- function() { print( anos + 5 ) } 
      semBusca <-  function() { anos <- 1; print( anos + 5 ) } 
      environment( anosGlobal ) <- .GlobalEnv 
      anosLocal() 
      anosGlobal()
      semBusca() 
  }
> quantosAnos()
[1] 15
[1] 105
[1] 6

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:

> ls(outroEnv) # o ambiente está vazio
character(0)
> with(outroEnv, {a <- 1; txt <- "texto" })
> ls(outroEnv)
[1] "a"   "txt"
> with(outroEnv, {print(a); print(txt)})
[1] 1
[1] "texto"
> # Alternativamente,
> outroEnv$a; outroEnv$txt
[1] 1
[1] "texto"

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.

$ sudo apt-key adv --keyserver keyserver.ubuntu.com
                   --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
$ sudo add-apt-repository
       'deb https://cloud.r-project.org/bin/linux/ubuntu bionic-cran35/'
$ sudo apt update
$ sudo apt install r-base

As linhas acima, para cada entrada no prompt, não devem ser quebradas.

Mais informações sobre instalações no Debian, Red Hat, SUSE e Ubuntu no site See CRAN-R Linux.

Para compilar à partir do código fonte consulte a página CRAN-R Installation and Administration.

Atualizando as bibliotecas

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.


Aquisição de Dados

Gráficos

Gráficos com plot

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:

> # ------------------------------ (1)
> plot( mtcars$mpg, mtcars$cyl)
> # ------------------------------ (2)
> attach(mtcars)
> plot( mpg, cyl)
> detach(mtcars)
> # ------------------------------ (3)
> attach(mtcars)
> plot(cyl ~ mpg)
> detach(mtcars)
> # ------------------------------ (4)
> plot( cyl ~ mpg, data= mtcars )

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 prompt Hit 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.
font inteiro para fonte: 1 = simples, 2 = negrito, 3 = itálico, 4 = negrito itálico, 5=símbolo.
font.axis fonte nos eixos.
font.lab fonte nos labels de eixos.
font.main fonte nos títulos.
font.sub fonte nos subtítulos.
ps tamanho do ponto na fonte (~1/72 polegada).
family 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).
names.arg vetor de nomes para barras.
horiz booleano. FALSE = barras verticais; TRUE = barras horizontais.
density vetor, densidade do hachurado. NULL= sem hachura.
col vetor de cores das barras.
border cor das bordas das barras.
main,sub título e subtítulo
xlab texto para o eixo x.
ylab texto para o eixo y.
axes booleano. Se eixos são desenhados

O código acima gera o gráfico de barras abaixo:

Gráfico de barras

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:


cores <-c("#5FC0A0", "#DE7A6B", "#6BA0DE")
> barplot(resultado,
          main="Gripe: teste clínico",
          xlab="Medicamento",
          ylab="Eficácia",
          col=cores, beside=TRUE)

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.

pie(x, labels = names(x), edges = 200, clockwise = FALSE,
    init.angle = if(clockwise) 90 else 0,
    col = NULL, main = NULL, ...)
Parâmetros:
x 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 package plotrix é 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().

> u <- mtcars$mpg
> min(u)
[1] 10.4
> max(u)
[1] 33.9
> median(u)
[1] 19.2
> quantile(u)
    0%    25%    50%    75%   100%
10.400 15.425 19.200 22.800 33.900
> quantile(u, .25)
   25%
15.425
> quantile(u, .75)
 75%
22.8
> quantile(u, .25, .5,.75)
   25%
15.425
> quantile(u, c(.25, .5, .75))
   25%    50%    75%
15.425 19.200 22.800
> fivenum(u)
[1] 10.40 15.35 19.20 22.80 33.90
> summary(u)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
  10.40   15.43   19.20   20.09   22.80   33.90
> boxplot(u, main="Box plot", ylab="Milhas/galão")

O gráfico é gerado:

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.

> boxplot(mpg ~ cyl, data=mtcars,
          main="Dados de Consumo",
          xlab="Número de Cilindros",
          ylab="Milhas/galão", col=c("red", "blue", "green"), varwidth=TRUE)
> legend(locator(1), levels(cyl.f), fill=c("red", "blue", "green"))


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.

Gráficos interativos com iplots

> library(iplots)
> attach(mtcars)
> cyl.f <- factor(cyl)
> gear.f <- factor(gear)
> ihist(mpg) # histograma
> ibar(carb) # gráfico de barras
> iplot(mpg, wt) # gráfico de pontos
> ibox(mtcars[c("qsec","disp","hp")]) # boxplots
> ipcp(mtcars[c("mpg","wt","hp")]) # coordenadas paralelas
> imosaic(cyl.f,gear.f) # gráfico mosaico

Gráfico gerado por ihist(mpg). O colorido foi feito após a geração do gráfico usando-se o item de menu View > Set color(rainbow).

Leaflet

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.

Biblioteca shiny

> library(shiny)
> ui <- basicPage(
        plotOutput("plot1", click = "plot_click"),
        verbatimTextOutput("info")
  )
> server <- function(input, output) {
     output$plot1 <- renderPlot({
         plot(mtcars$wt, mtcars$mpg)
     })

     output$info <- renderText({
         paste0("x=", input$plot_click$x, "\ny=", input$plot_click$y)
     })
}
> shinyApp(ui, server)
Listening on http://127.0.0.1:6260

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:

scatter3d(formula, data, subset, radius, xlab, ylab, zlab, ...)
ou
scatter3d(x, y, z,
          xlab, ylab, zlab, revolutions=0,  speed=1,
          bg.col=c("white", "black"), axis.scales=TRUE,
          axis.col, surface=TRUE, surface.col=carPalette()[-1],
          fill=TRUE, point.col="yellow", text.col=axis.col,
          radius=1, groups=NULL, fill=TRUE, grid=TRUE,
          ellipsoid=FALSE, sphere.size=1, radius=1, threshold=0.01,
          parallel=TRUE, ellipsoid=FALSE, id=FALSE, ...)

onde

formula fórmula y ~ x + z. Para plotar os pontos por grupos use y ~ x + z | g onde g é o fator que distingue grupos.
data data frame usado para avaliação da fórmula.
x, y, z coordenadas dos pontos a serem plotados. Os argumentos y e z são opcionais, dependendo da estrutura de x.
subset expressão definindo subconjunto das observações a serem usadas.
xlab, ylab, zlab labels nos eixos.
radius raios das esferas representando pontos.
axis.scales Se TRUE, nomeia valores nas pontas dos eixos.
revolutions quantas revoluções a figura fará (animação).
bg.col cor de fundo.
axis.col cores para eixos.
surface.col vetor de cores para os planos.
point.col cores dos pontos.
text.col cores dos eixos.
grid.col colour of grid lines on the regression surface(s).
surface lógico, plotar superfícies.
fill lógico. Preencher superfícies com cores.
grid lógico. Plotar lines da grade nas superfícies de regressão.
grid.lines número de linhas nas grades.
speed velocidade de revolução.
fov controla ângulo da perspectiva.
groups Se NULL nenhum grupo é definido. Se um fator uma superfície diferente é desenhada para cada nível.
parallel lógico. Se as superfícies para grupos devem ser paralelas.
ellipsoid lógico. Concentração elipsóide para pontos.
labels texto para labels nos pontos. Default são os índices da observação.
col cores para labels em pontos.
outros argumentos.
> install.packages(c("rgl", "car"))
> library(rgl, car)
> data(iris)
> sep.l <- iris$Sepal.Length
> sep.w <- iris$Sepal.Width
> pet.l <- iris$Petal.Length
> scatter3d(x = sep.l, y = pet.l, z = sep.w)           # plota Gráfico-1
> scatter3d(x = sep.l, y = pet.l, z = sep.w,
            point.col = "steelblue", surface=FALSE)    # plota Gráfico-2

> scatter3d(x = sep.l, y = pet.l, z = sep.w,
            groups = iris$Species)                     # plota Gráfico-3

> scatter3d(x = sep.l, y = pet.l, z = sep.w, groups = iris$Species,
         grid = FALSE, fit = "smooth")                 # plota Gráfico-4
         
> scatter3d(x = sep.l, y = pet.l, z = sep.w, groups = iris$Species,
           surface=FALSE, ellipsoid = TRUE)            # plota Gráfico-5

> scatter3d(x = sep.l, y = pet.l, z = sep.w,
            groups = iris$Species, surface=FALSE,
            grid = FALSE, ellipsoid = TRUE)            # plota Gráfico-6

> # Para gravar estes gráficos nos formatos png e pdf podemos usar

> rgl.snapshot(filename = "plot.png")
> rgl.postscript("plot.pdf",fmt="pdf")

Todos os gráficos podem ser girados e redimensionados com o arraste de mouse.

Continuaremos o estudo sobre gráficos na próxima sessão, usando ggplot2.

 


Aprofundando as técnicas sobre Gráficos

Aquisição de Dados


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:

read.table("nomeArquivo.csv", header=TRUE, sep=",", dec=".")

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:

> install.packages("RCurl")
> library (RCurl)
> url <- "https://data.kingcounty.gov/api/views/yaai-7frk/rows.csv?accessType=DOWNLOAD"
> dw <- getURL(url)
> dados <- read.csv (text = dw)
> class(dados)
[1] "data.frame"
> View(dados)

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:

read.xlsx(file, sheetIndex, sheetName=NULL, rowIndex=NULL,
          startRow=NULL, endRow=NULL, colIndex=NULL,
          as.data.frame=TRUE, header=TRUE, colClasses=NA,
          keepFormulas=FALSE, encoding="unknown", password=NULL, ...)

read.xlsx2(file, sheetIndex, sheetName=NULL, startRow=1,
          colIndex=NULL, endRow=NULL, as.data.frame=TRUE, header=TRUE,
          colClasses="character", password=NULL, ...)
Argumento Descrição
file arquivo (com caminho) a ser lido.
sheetIndex número da planilha dentro da pasta de trabalho.
sheetName nome da planilha.
rowIndex 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.

Elas têm a sintaxe:

write.xlsx(x, file, sheetName="Sheet1",
          col.names=TRUE, row.names=TRUE,
          append=FALSE, showNA=TRUE, password=NULL)write.xlsx2(x, file, sheetName="Sheet1",
          col.names=TRUE, row.names=TRUE,
          append=FALSE, password=NULL, ...)

São seus argumentos:

Argumento Descrição
x data.frame a ser escrito como pasta de trabalho.
file arquivo (com caminho) a ser escrito.
sheetName nome da planilha.
col.names 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.

> write.xlsx(USArrests, file="pastaTrabalho.xlsx",
             sheetName="USA-ARRESTS", append=FALSE)
> write.xlsx(alunos, file="pastaTrabalho.xlsx",
             sheetName="alunos", append=TRUE)

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:

Função Descrição
odbcConnect(dsn,uid=””,pwd=””) abre uma conexão com o driver ODBC
sqlFetch(channel,sqltable) lê uma tabela e a carrega em um data frame
sqlQuery(channel,query) submete uma consulta sql e retorna os resultados
sqlSave(channel,mydf,tablename= sqltable,append=FALSE) 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:

> library(RODBC)
> conn <- odbcConnect("dsn", uid="usr", pwd="senha")
> debito <- sqlFetch(conn, debito)
> credito <- sqlQuery(conn, "select * from credito")
> close(myconn)
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.

Para o exemplo que se segue usamos o banco de dados chinook.db que pode ser baixado no site do SQLite Tutorial.

> 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
dbHasCompleted status de realização de uma query
dbGetRowsAffected número de linhas afetada
dbExistsTable booleano, retorna existência da tabela
dbIsValid booleano, o DBMS é um objeto válido?
dbListConnections lista conexões abertas
dbListResults lista resultados pendentes
dbListFields lista nomes de campos de uma tabela
dbSendQuery executa consulta sobre uma conexão
dbRemoveTable remove uma tabela do banco de dados
dbFetch recupera registros de consulta já realizada
transactions inicia/commit/rollback transações SQL
sqlAppendTable insere linhas em uma tabela
sqlCreateTable cria uma tabela

Obtendo dados na Internet

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 pacote rvest 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.


Operadores e Funções Internas

Controle de Fluxo e Funções do Usuário

Laços: Controle de Fluxo

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.

> montarLinha <- function(x, ...){
				 print(paste("Existem ", x, "cores:", ...))
				 }
> montarLinha(3, "vermelho", "verde", "azul")
[1] "Existem  3 cores: vermelho verde azul"

Função podem ser aninhadas, ou seja, é possível chamar uma função de dentro de outra funcão:

> funcao1 <- function(txt) { return(paste("modificação 1: ",txt))}
> funcao2 <- function(txt, t2=NULL) {
			 retorna <- ""
			 if (is.character(txt)) {
				 retorna <- paste("modificação2: ", funcao1(txt))
			 } else {
				 retorna <- "Argumento deve ser um string..."
			 }
			 if (!is.null(t2)) retorna <- paste(retorna,"!")
			 return(retorna)
  }
> print(funcao2(2))
[1] "Argumento deve ser um string..."
> print(funcao2("testando"))
[1] "modificação2:  modificação 1:  testando"
> print(funcao2("Inserindo o 2o argumento", 1))
[1] "modificação2:  modificação 1:  Inserindo o 2o argumento !"

Funções podem retornar qualquer um dos objetos de R, inclusive outras funções:

> potencia <- function(ordem) {
			  f <- function(x) {x ^ ordem}
			  return(f)
			  }
> quarta <- potencia(4)    # define a função f(x) = x^4
> quarta(2)
[1] 16
> quadrado <- potencia(2)  # define a função f(x) = x^2
> quadrado(15)
[1] 225

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:

Teste Conversão
is.numeric() as.numeric()
is.character() as.character()
is.vector() as.vector()
is.matrix() as.matrix()
is.data.frame() as.data.frame()
is.factor() as.factor()
is.logical() as.logical()
is(var, type) as(var, type)
> is.character("1")            #  TRUE
> is("1", "character")         #  TRUE
> is("1", "numeric")           #  FALSE
> is(1, "numeric")             #  TRUE
> is(1i, "complex")            #  TRUE
> n <- as("125", "numeric")    #  n = 125
> is.logical(1==2)             #  TRUE
> is.vector(1:2)               #  TRUE
> is.vector("1")               #  TRUE (um vetor com um componente)
> as.logical(1)                #  TRUE (as.logical(0) = FALSE
> dt<- as.Date("2018-11-25")   #  dt = "2018-11-25"
> class(dt)                    #  "Date"


Programação com R


Aquisição de Dados

Operadores e Funções Internas

Operadores

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).

Função Descrição
dbinom(x, size, prob)
pbinom(q, size, prob)
qbinom(p, size, prob)
rbinom(n, size, prob)
distribuição binomial,
onde size = tamanho da amostra e prob é probabilidade
de sucesso em cada experimento.
dpois(x, lambda)
ppois(q, lambda)
qpois(p, lambda)
rpois(n, lambda)
Distribuição de Poisson com m=std=lambda
dunif(x, min=0, max=1)
punif(q, min=0, max=1)
qunif(p, min=0, max=1)
runif(n, min=0, max=1)
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:

    dnorm(x, mean = 0, sd = 1, log = FALSE)
    pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
    qnorm(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
    rnorm(n, mean = 0, sd = 1)

São argumentos:

x, q vetor de quantils.
p vetor de probabilidades.
n número de observações. Se length(n) > 1, the length is taken to be the number required.
mean vetor de médias.
sd vetor de desvios padrão.
log, log.p logical; se TRUE, probabilidades são dadas como log(p).
lower.tail logical; se TRUE (default), probabilidades são P[X ≤ x]; caso contrário, P[X > x].

Se a média e o desvio padrão não são especificados eles assumem o valor default 0 e 1, respectivamente.

A distribuição normal tem densidade:

$$
f(x) = \frac{1}{\sigma \sqrt{2\pi}} \text{e}^{-\frac{(x-\mu)^2}{2\sigma ^2}}
$$

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).


Controle de Fluxo e Funções do Usuário