Pandas – Dataframes


🔻Final do artigo

Dataframes do pandas


Um dataframe é uma forma de armazenar dados em forma tabular, como em uma planilha. O dataframe do pandas consiste em uma coleção de Series que são dispostas como suas colunas. A cada linha está associado um índice que serve para ordenar e selecionar dados. Como Series, cada coluna tem um tipo definido. No entanto, não é necessário que todas as colunas tenham o mesmo tipo e portanto dados de tipos diferentes podem ser armazenados.

Muitas operações com dataframes levam em consideração o eixo ou axis. O default é axis = 0 (ou axis = 'index') o que indica operação sobre as linhas. axis = 1 (ou axis = 'column') indica operação realizada sobre as colunas.

O método mais comum de se criar um dataframe consiste em passar um dicionário e uma lista de índices para o construtor.

In [1]: import pandas as pd
In [2]: import numpy as np
In [3]: dados = {
                'nome': ['Pedro', 'Maria', 'Janaina', 'Wong', 'Roberto', 'Marco', 'Paula'],
                'cidade': ['São Paulo', 'São Paulo', 'Rio de Janeiro', 'Brasília',
                           'Salvador', 'Curitiba', 'Belo Horizonte'],
                'idade': [34, 23, 32, 43, 38, 31, 34],
                'nota': [83.0, 59.0, 86.0, 89.0, 98.0, 61.0, 44.0]
                }

In [4]: ids = [10, 11, 12, 13, 14, 15, 16]
In [5]: dfAlunos = pd.DataFrame(data=dados, index=ids)
Out[5]:

nome cidade idade nota
10 Pedro São Paulo 34 83.0
11 Maria São Paulo 23 59.0
12 Janaina Rio de Janeiro 32 86.0
13 Wong Brasília 43 89.0
14 Roberto Salvador 38 98.0
15 Marco Curitiba 31 61.0
16 Paula Belo Horizonte 34 44.0

No caso acima usamos um dict onde as chaves são os nomes dos campos ou colunas. À cada chave está associada uma lista cujos valores se tornam os valores das linhas, em cada coluna. A lista de índices foi fornecida separadamente. Se a lista ids não tivesse sido fornecida os índices do dataframe seriam inteiros, começando em 0.

Dataframes possuem a propriedade shape que contém as dimensões do objeto e os métodos head(n) e tail(n) que permitem, respectivamente, a visualização das n primeiras ou últimas linhas. Ao carregar um dataframe é sempre útil visualizar suas primeiras linhas e nomes de colunas. Também pode ser útil visualizar a matriz sob forma transposta, dada por dfAlunos.T.

In [6]: dfAlunos.shape
Out[6]: (7, 4)
# o que significa que temos 7 linhas, com 4 campos ou colunas.

# para visualizar apenas as 2 primeiras linhas
In [7]: dfAlunos.head(2)
Out[7]:
nome cidade idade nota
10 Pedro São Paulo 34 83.0
11 Maria São Paulo 23 59.0
# para visualizar apenas as 2 últimas linhas
In [8]: dfAlunos.tail(2)
Out[8]:
nome cidade idade nota
15 Marco Curitiba 31 61.0
16 Paula Belo Horizonte 34 44.0
# A transposta:
In [9]: dfAlunos.T
Out[9]:
10 11 12 13 14 15 16
nome Pedro Maria Janaina Wong Roberto Marco Paula
cidade São Paulo São Paulo Rio de Janeiro Brasília Salvador Curitiba Belo Horizonte
idade 34 23 32 43 38 31 34
nota 83 59 86 89 98 61 44

Os nomes das colunas podem ser obtidos em uma lista, em um nome específico. Devemos nos lembrar que cada coluna do dataframe é uma Series. Portanto valem para elas os métodos e propriedades das Series.

In[10]: dfAlunos.columns
Out[10]:
Index(['nome', 'cidade', 'idade', 'nota'], dtype='object')

# O nome da segunda coluna (lembrando que se conta a partir de 0)
In [10]: dfAlunos.columns[1]
Out[10]: 'cidade'

# Selecionando a coluna 'cidade'
In [11]: dfAlunos['cidade']
Out[11]:
10         São Paulo
11         São Paulo
12    Rio de Janeiro
13          Brasília
14          Salvador
15          Curitiba
16    Belo Horizonte
Name: cidade, dtype: object

# cada coluna é uma Series
In [12]: type(dfAlunos['cidade'])
Out[12]: pandas.core.series.Series

# os métodos das Series se aplicam
In [13]: dfAlunos['cidade'].value_counts()
Out[13]:
São Paulo         2
Curitiba          1
Rio de Janeiro    1
Belo Horizonte    1
Salvador          1
Brasília          1
Name: cidade, dtype: int64

# valores únicos podem ser obtidos com unique()
In [14]: dfAlunos['cidade'].unique()
Out[14]:
array(['São Paulo', 'Rio de Janeiro', 'Brasília', 'Salvador', 'Curitiba',
       'Belo Horizonte'], dtype=object)

# também podemos transformar esses valores em um set
In [15]: set(dfAlunos['cidade'])
Out[15]:
{'Belo Horizonte',
 'Brasília',
 'Curitiba',
 'Rio de Janeiro',
 'Salvador',
 'São Paulo'}

Observe que dfAlunos['cidade'] retorna uma Series, que é a coluna especificada do DF. Já o comando dfAlunos[['cidade']] retorna um dataframe com uma única coluna. É sempre importante saber com que tipo de objeto estamos lidando. Para isso podemos usar type() para conhecer esse tipo. Por exemplo, type(dfAlunos[['cidade']]) retorna pandas.core.frame.DataFrame . Observe que strings são listadas apenas como objects (sem discriminação de serem strings).

Também se pode usar a notação de ponto, dfAlunos.cidade, para obter a mesma coluna.

Como dissemos, o objeto DataFrame do pandas é formado por colunas que são Series, cada uma delas contendo elementos do mesmo tipo. As linhas podem, portanto, conter elementos de tipos diferentes. Para ver os tipos de cada coluna podemos examinar a propriedade dtype ou o método .info() que fornece uma visão geral sobre os dados, inclusive sobre a existência de valores nulos nos dados.

In [16]: dfAlunos.dtypes
Out[16]:
nome       object
cidade     object
idade       int64
nota      float64
dtype: object

# Uma visão geral sobre os dados pode ser obtido com .info()
In [17]: dfAlunos.info()
Out[17]:
<class 'pandas.core.frame.DataFrame'>
Int64Index: 7 entries, 10 to 16
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   nome    7 non-null      object
 1   cidade  7 non-null      object
 2   idade   7 non-null      int64
 3   nota    7 non-null      float64
dtypes: float64(1), int64(1), object(2)
memory usage: 600.0+ bytes

A descrição estatística dos campos numéricos é obtida com .describe() que fornece a contagem de itens, o valor médio, o desvio padrão, os quantis e máximos e mínimos. O método .corr() fornece o Coeficiente de Correlação de Pearson para todas as colunas numéricas da tabela. O resultado é um número no intervalo [-1, 1] que descreve a relação linear entre as variáveis.

# describe: resumo estatístico dos campos numéricos
In [18]: dfAlunos.describe()
Out[18]:
idade nota
count 7.000000 7.000000
mean 33.571429 74.285714
std 6.187545 19.661420
min 23.000000 44.000000
25% 31.500000 60.000000
50% 34.000000 83.000000
75% 36.000000 87.500000
max 43.000000 98.000000
In [19]: dfAlunos.corr()
Out[19]:
idade nota
idade 1.000000 0.564238
nota 0.564238 1.000000

Para acrescentar uma ou mais linhas (registros) ao dataframe podemos criar um novo dataframe com quantas linhas forem necessárias e concatená-lo com o antigo usando o método .concat().

# criamos dataframe para a aluna Juliana e seus dados
In [20]: dfInserir = pd.DataFrame([('Juliana','Curitiba',28,80.0)],
                             columns=['nome','cidade','idade','nota'],
                             index=[100])
In [21]: pd.concat([dfAlunos, dfInserir])
Out[21]:
nome cidade idade nota
10 Pedro São Paulo 34 83.0
11 Maria São Paulo 23 59.0
12 Janaina Rio de Janeiro 32 86.0
13 Wong Brasília 43 89.0
14 Roberto Salvador 38 98.0
15 Marco Curitiba 31 61.0
16 Paula Belo Horizonte 34 44.0
100 Juliana Curitiba 28 80.0

Observe que o dataframe original não foi modificado. Caso se pretenda que modificação se torne permanente você deve atribuir o resultado retornado a uma novo (ou o mesmo) dataframe, como em dfAlunos = pd.concat([dfAlunos, dfInserir]).

Muitas vezes queremos que a novo dataframe criado ignore os índice das duas tabelas concatenadas. Nesse caso podemos ignorar os índices antigos e substituí-los por novos índices fornecidos, ou deixar que sejam preenchidos automaticamente.

In [22]: df = pd.concat([dfAlunos, dfInserir], ignore_index=True)
In [23]: df.index
Out[23]:
RangeIndex(start=0, stop=8, step=1)
# os índices são inteiros de 0 até 8 (exclusive)

Uma nova coluna pode ser inserida, inclusive usando valores obtidos nas linhas. Na operação abaixo inserimos o campo ‘calculado’ que é igual à multiplicação dos campos ‘nota’ * ‘idade’, que não tem significado e é feito apenas como demonstração.

In [24]: dfAlunos['calculado']=dfAlunos['nota'] * dfAlunos['idade']
In [25]: dfAlunos
Out[24]:
nome cidade idade nota calculado
10 Pedro São Paulo 34 83.0 2822.0
11 Maria São Paulo 23 59.0 1357.0
12 Janaina Rio de Janeiro 32 86.0 2752.0
13 Wong Brasília 43 89.0 3827.0
14 Roberto Salvador 38 98.0 3724.0
15 Marco Curitiba 31 61.0 1891.0
16 Paula Belo Horizonte 34 44.0 1496.0

Como essa nova coluna não tem nenhum significado vamos apagá-la usando .drop().

# a operação seguinte retorna o dataframe sem a coluna 'calculado', mas não altera a original
In [26]: dfAlunos.drop(['calculado'], axis=1)
# para alterar o dataframe usamos o parâmetro inplace=True
In [27]: dfAlunos.drop(['calculado'], axis=1, inplace=True)

Agora o dataframe tem a mesma estrutura de colunas original. Muitas operações do pandas retornam o resultado sobre o objeto sem alterá-lo. Algumas delas admitem o parâmetro inplace que, se True, faz a alteração do objeto in loco.

Para selecionar mais de uma coluna passamos uma lista com os nomes dos campos entre os colchetes.

In [28]: lista = ['nome','idade']
# a linha abaixo é idêntica à dfAlunos[['nome','idade']]
In [29]: dfAlunos[lista]
Out[29]:
nome idade
10 Pedro 34
11 Maria 23
12 Janaina 32
13 Wong 43
14 Roberto 38
15 Marco 31
16 Paula 34


Podemos obter somas dos termos, tanto no sentido das linhas quanto das colunas, o que servirá como exemplo do uso do parâmetro axis. Relembrando:

axis = 0 (axis = ‘index’) opera sobre todas as linhas de cada coluna
axis = 1 (axis = ‘column’) opera sobre todas as colunas de cada linha

Para mostrar isso vamos construir um dataframe contendo apenas os dados numéricos, com os campos ‘idade’ e ‘nota’. Em seguida aplicamos sum(axis=0) para obter a soma das idades e notas, e sum(axis=1) para a soma
de cada linha.

In [30]: dfNumerico=dfAlunos[['idade', 'nota']]
In [31]: dfNumerico.sum(axis=0)
Out[31]:
idade         235.0
nota          520.0
dtype: float64

In [32]: dfNumerico.sum(axis=1)
Out[32]:
10    117.0
11     82.0
12    118.0
13    132.0
14    136.0
15     92.0
16     78.0
dtype: float64

Importando um arquivo externo

É comum que os dados estejam inicialmente em forma de texto com os dados gravados em linhas e com valores separados por vírgula (um arquivo csv, comma separated values) ou outros separadores, tais como tabulação ou ponto e vírgula (;). Também não é raro que dados importados de outras fontes possam ser convertidos nesse formato.

Suponha que tenhamos no disco, na pasta de trabalho de sua sessão, um arquivo com o seguinte conteúdo:

id, nome, cidade, idade, nota
10, Pedro, São Paulo, 34, 83.0
11, Maria, São Paulo, 23, 59.0
12, Janaina, Rio de Janeiro, 32, 86.0
13, Wong, Brasília, 43, 89.0
14, Roberto, Salvador, 38, 98.0
15, Marco, Curitiba, 31, 61.0
16, Paula, Belo Horizonte, 34, 44.0

Não é importante que as colunas estejam organizadas em forma de colunas. Para importar esses dados para dentro de um dataframe usamos o método do pandas .read_csv(arq), onde arq é o nome completo do arquivo a ser lido (inclusive com seu caminho).

In [30]: dfNovoAlunos = pd.read_csv('./alunos.csv')
In [32]: dfNovoAlunos
Out[32]:
id nome cidade idade nota
0 10 Pedro São Paulo 34 83.0
1 11 Maria São Paulo 23 59.0
2 12 Janaina Rio de Janeiro 32 86.0
3 13 Wong Brasília 43 89.0
4 14 Roberto Salvador 38 98.0
5 15 Marco Curitiba 31 61.0
6 16 Paula Belo Horizonte 34 44.0

Vemos que o campo ‘id’ foi lido como um campo comum. Ele pode ser transformado por meio da seguinte operação que transforma esse campo em índice efetivo:

# torne o campo id o índice
In [33]: dfNovoAlunos.set_index('id', inplace=True)
In [34]: dfNovoAlunos.head(2)
Out[34]: 
nome cidade idade nota
id
10 Pedro São Paulo 34 83.0
11 Maria São Paulo 23 59.0

Alternativamente podemos ler o arquivo csv usando diretamente a primeira coluna como índice, informado pelo parâmetro index_col. Se o arquivo não contiver vírgulas separando os campos e sim outro sinal qualquer, como ; ou tabulações, passamos essa informação usando o parâmetro sep. Na última importação usamos url, a URL completa do arquivo, que pode estar em qualquer ponto disponivel da rede.

# para usar a 1a coluna como índice
dfNovoAlunos = pd.read_csv('./alunos.csv', index_col=0)
# para ler arquivo em url, usando tab como separador
dfOutroDF = pd.read_csv(url, sep='\t')

Vimos que, se nenhum argumento for passado, a primeira linha do arquivo é tomada como contendo os nomes (ou headers) das colunas. Para evitar isso passamos o parâmetro header = None. Nesse caso o nome das colunas é substituído por números.

Suponha que o arquivo nums.csv esteja gravado no disco.

nums.csv
11,12,13,14
21,22,23,24
31,32,33,34
# informa que 1a linha não é header
In [35]: dfNone = pd.read_csv('./dados/nums.csv', header=None)

# insere o nome ou labels para as colunas
In [36]: dfNames = pd.read_csv('./dados/nums.csv', names=('A', 'B', 'C', 'D'))

# exibe os dois dataframes
In [37]: display('sem headers:', dfNone, 'com headers:', dfNames)
Out[37]:

‘sem headers:’

0 1 2 3
0 11 12 13 14
1 21 22 23 24
2 31 32 33 34

‘com headers:’

A B C D
0 11 12 13 14
1 21 22 23 24
2 31 32 33 34

Finalmente, se o cabeçalho contendo os títulos das colunas não está na primeira linha podemos passar o parâmetro header=n. A n-ésima linha será tomada como cabeçalho e todas as linhas anteriores serão ignoradas.

In [38]: dfPula2 = pd.read_csv('./dados/nums.csv', header=2)

Gravando o dataframe em arquivos pickle

Após várias manipulações, que podem ser demoradas dependendo do tamanho dos dataframes e complexidade das operações, temos um novo dataframe que, para ser recuperado em uma sessão posterior, deve passar por todas as etapas realizadas. Para evitar isso e garantir o armazenamento desses dados podemos gravá-lo em um pickle

pd.to_pickle(dfNovoAlunos, './dados/Alunos.pkl')
In [39]: del dfNovoAlunos
In [40]: dfLido = pd.read_pickle('./dados/Alunos.pkl')

dfLido será um dataframe idêntico ao dfNovoAlunos gravado em etapa anterior. A pasta de destino deve existir ou uma exceção será lançada.

to_pickle Grava um objeto do pandas em arquivo pickled
read_pickle Ler arquivo pickle recuperando objeto
DataFrame.to_hdf Grava um objeto do pandas em arquivo HDF5
read_hdf Ler arquivo hdf recuperando objeto
DataFrame.to_sql Grava dataframe em um banco de dados sql
read_sql Ler arquivo sql recuperando objeto
DataFrame.to_parquet Grava dataframe em formato parquet binário.
read_parquet Ler arquivo parquet recuperando objeto
🔺Início do artigo

Bibliografia

Consulte bibliografia completa em Pandas, Introdução neste site.

Nesse site:

Introdução ao Pandas – Series

🔻Final do artigo

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.

pandas e sql comparados

🔻Final do artigo



Esse texto descreve os dataframes do pandas em comparação com as consultas SQL (Structured Query Language), explorando similaridades e diferenças entre os dois sistemas de consulta e extração de dados. Ele serve para descrever as funcionalidades de busca e edição do pandas e pode ser particularmente útil para aqueles que conhecem SQL e pretendem usar o pandas.

Para realizar os experimentos abaixo usamos o Jupyter Notebook, um aplicativo que roda dentro de um navegador, que pode ser facilmente instalado e permite a reprodução se todo o código aqui descrito. Você pode ler mais sobre Jupyter Notebook e Linguagem de Consultas SQL nesse site.

Esse texto é baseado em parte do manual do pandas e expandido. Ele usa um conjunto de dados baixados do github renomeado aqui para dfGorjeta. Nomes e valores dos campos foram traduzidos para o português.

# importar as bibliotecas necessárias
import pandas as pd
import numpy as np

url = "https://raw.github.com/pandas-dev/pandas/master/pandas/tests/io/data/csv/tips.csv"

dfGorjeta = pd.read_csv(url)
dfGorjeta.head()
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4

Para efeito de testar os comandos do dataframe vamos alterar os nomes dos campos e traduzir os conteúdos dos dados. Para descobrir quais são os valores dos campos, sem repetições, transformamos as séries em sets, uma vez que valores de um set (conjunto) não se repetem.

print(set(dfGorjeta["sexo"]))
print(set(dfGorjeta["fumante"]))
print(set(dfGorjeta["dia"]))
print(set(dfGorjeta["hora"]))
{‘Male’, ‘Female’}
{‘No’, ‘Yes’}
{‘Sat’, ‘Sun’, ‘Fri’, ‘Thur’}
{‘Lunch’, ‘Dinner’}

No código seguinte alteramos os nomes de campos e traduzimos o conteúdo. A sintaxe da operação de edição do dataframe será discutida mais tarde no artigo:

# muda os nomes dos campos
dfGorjeta.rename(columns={"total_bill":"valor_conta", "tip":"gorjeta",
                        "smoker":"fumante", "sex":"sexo","day":"dia",
                        "time":"hora","size":"pessoas"}, inplace=True)

# traduzindo os valores dos campos:
dfGorjeta.loc[dfGorjeta["fumante"] == "No", "fumante"] = "não"
dfGorjeta.loc[dfGorjeta["fumante"] == "Yes", "fumante"] = "sim"
dfGorjeta.loc[dfGorjeta["sexo"] == "Female", "sexo"] = "mulher"
dfGorjeta.loc[dfGorjeta["sexo"] == "Male", "sexo"] = "homem"
dfGorjeta.loc[dfGorjeta["hora"] == "Dinner", "hora"] = "jantar"
dfGorjeta.loc[dfGorjeta["hora"] == "Lunch", "hora"] = "almoço"
dfGorjeta.loc[dfGorjeta["dia"] == "Fri", "dia"] = "sex"
dfGorjeta.loc[dfGorjeta["dia"] == "Sat", "dia"] = "sab"
dfGorjeta.loc[dfGorjeta["dia"] == "Sun", "dia"] = "dom"
dfGorjeta.loc[dfGorjeta["dia"] == "Thur", "dia"] = "qui"

# Temos agora o seguinte dataframe
dfGorjeta
valor_conta gorjeta sexo fumante dia hora pessoas
0 16.99 1.01 mulher não dom jantar 2
1 10.34 1.66 homem não dom jantar 3
2 21.01 3.50 homem não dom jantar 3
3 23.68 3.31 homem não dom jantar 2
4 24.59 3.61 mulher não dom jantar 4
239 29.03 5.92 homem não sab jantar 3
240 27.18 2.00 mulher sim sab jantar 2
241 22.67 2.00 homem sim sab jantar 2
242 17.82 1.75 homem não sab jantar 2
243 18.78 3.00 mulher não qui jantar 2

As consultas SQL realizadas a seguir pressupõe a existência de um banco de dados com o mesmo nome, a mesma estrutura e dados que o dataframe dfGorjetas.

SELECT

Nas consultas SQL as seleções são feitas com uma lista de nomes de campos que se deseja retornar, separados por vírgula, ou através do atalho * (asterisco) para selecionar todas as colunas. No pandas a seleção de colunas é feita passando-se uma lista de nomes de campos para o DataFrame. Uma chamada ao dataframe sem uma lista de nomes de colunas resulta no retorno de todas as colunas, da mesma forma que usar * no SQL.

–– sql: consulta (query) usando select
SELECT valor_conta, gorjeta, fumante, hora FROM dfGorjeta LIMIT 5;
# pandas:
dfGorjeta[["valor_conta", "gorjeta", "hora"]].head()
valor_conta gorjeta hora
0 16.99 1.01 jantar
1 10.34 1.66 jantar
2 21.01 3.50 jantar
3 23.68 3.31 jantar
4 24.59 3.61 jantar

O método head(n) limita o retorno do dataframe às n primeiras linhas. n = 5 é o default. Para listar as últimas linhas usamos tail(n). Linhas também podem ser selecionadas por chamadas ao sei indice.

# Para acessar as últimas linhas do dataframe podemos usar
# dfGorjeta[["valor_conta", "gorjeta", "hora"]].tail()

# selecionando linhas por meio de seu índice.
dfGorjeta.iloc[[1,239,243]]
valor_conta gorjeta sexo fumante dia hora pessoas
1 10.34 1.66 homem não dom jantar 3
239 29.03 5.92 homem não sab jantar 3
243 18.78 3.00 mulher não qui jantar 2

Os dataframes possuem a propriedade shape que contém sua dimensionalidade. No nosso caso temos

dfGorjeta.shape
(244, 7)

o que significa que são 244 linhas em 7 campos.

No SQL você pode retornar uma coluna resultado de um cálculo usando elementos de outras colunas. No pandas podemos usar o método assign() para inserir uma coluna calculada:

–– sql:
SELECT *, gorjeta/valor_conta*100 as percentual FROM dfGorjeta LIMIT 4;
# pandas: método assign()
dfGorjeta.assign(percentual = dfGorjeta["gorjeta"] / dfGorjeta["valor_conta" *100]).head(4)
valor_conta gorjeta sexo fumante dia hora pessoas percentual
0 16.99 1.01 mulher não dom jantar 2 5.944673
1 10.34 1.66 homem não dom jantar 3 16.054159
2 21.01 3.50 homem não dom jantar 3 16.658734
3 23.68 3.31 homem não dom jantar 2 13.978041

Essa coluna é retornada mas não fica anexada ao dataframe. Para anexar uma coluna ao dataframe podemos atribuir o resultado do cálculo a uma nova coluna:

dfGorjeta["percentual"] = dfGorjeta["gorjeta"] / dfGorjeta["valor_conta"] * 100
print("Nessa estapa temos as colunas:\n", dfGorjeta.columns)

# Vamos apagar a coluna recém criada para manter a simplicidade da tabela
dfGorjeta.drop(["percentual"], axis=1, inplace=True)
Nessa estapa temos as colunas:
Index([‘valor_conta’, ‘gorjeta’, ‘sexo’, ‘fumante’, ‘dia’, ‘hora’, ‘pessoas’, ‘percentual’],
dtype=’object’)

WHERE


Filtragem de dados em consultas SQL são feitas através da cláusula WHERE. DataFrames podem ser filtrados de várias formas diferentes. O indexamento com valores booleanos é provavelmente o mais simples:

–– cláusula WHERE do sql
SELECT * FROM dfGorjeta WHERE hora = “jantar” LIMIT 5;
# filtragem por indexamento no pandas
dfGorjeta[dfGorjeta["hora"] == "jantar"].head(5)
valor_conta gorjeta sexo fumante dia hora pessoas
0 16.99 1.01 mulher não dom jantar 2
1 10.34 1.66 homem não dom jantar 3
2 21.01 3.50 homem não dom jantar 3
3 23.68 3.31 homem não dom jantar 2
4 24.59 3.61 mulher não dom jantar 4

A consulta acima funciona da seguinte forma:

# is_jantar é uma série contendo True e False (True para jantares, False para almoços)
is_jantar = dfGorjeta["hora"] == "jantar"
# usamos display para exibir a contagem de falsos/verdadeiros
display("Quantos jantares/almoços:", is_jantar.value_counts())

# para negar a série inteira, invertendo True ↔ False usamos ~ (til)
# a linha abaixo imprime o número de almoços na tabela
print("A lista contém %d almoços" % dfGorjeta[~is_jantar]["hora"].count())

# também podemos obter a lista das entradas que não correspondem a "jantar" usando
# dfGorjeta[dfGorjeta["hora"] != "jantar"]
‘Quantos jantares/almoços:’
True 176
False 68
Name: hora, dtype: int64A lista contém 68 almoços

Quando essa série é passada para o dataframe apenas as linhas correspondentes à True são retornados. A última consulta é equivalente à dfGorjeta[~is_jantar].head().

No SQL podemos procurar por partes de uma string com a cláusula LIKE. No pandas transformamos o campo dfGorjeta["sexo"]em uma string que possui o método startswith("string").

–– sql: SELECT TOP 2 sexo, valor_conta FROM dfGorjeta WHERE sexo LIKE ‘ho%’;
dfGorjeta.loc[dfGorjeta['sexo'].str.startswith('ho'),['sexo','valor_conta']].head(2)

que retorna as 2 primeiras linhas em que o campo sexo começa com o texto “ho”.

Também podemos procurar por campos que estão incluidos em um conjunto de valores:

–– sql:
SELECT * FROM dfGorjeta WHERE dia IN (‘sab’, ‘dom’);
dfGorjeta.loc[dfGorjeta['dia'].isin(["dom", "sab"])]

que retorna todas as linhas em que o campo dia é “dom” ou “sab”.

Assim como se pode usar operadores lógicos AND e OR nas consultas SQL para inserir múltiplas condições, o mesmo pode ser feito com dataframes usando | (OR) e & (AND). Por ex., para listar as gorjetas com valor superior à $5.00 dadas em jantares:

–– SQL: múltiplas condições em WHERE
SELECT * FROM dfGorjeta WHERE hora = ‘jantar’ AND gorjeta > 6.00;
# no pandas
dfGorjeta[(dfGorjeta["hora"] == "jantar") & (dfGorjeta["gorjeta"] > 6.00)]
valor_conta gorjeta sexo fumante dia hora pessoas
23 39.42 7.58 homem não sab jantar 4
59 48.27 6.73 homem não sab jantar 4
170 50.81 10.00 homem sim sab jantar 3
183 23.17 6.50 homem sim dom jantar 4
212 48.33 9.00 homem não sab jantar 4
214 28.17 6.50 mulher sim sab jantar 3

Podemos obter uma lista dos dados correspondentes a gorjetas dadas por grupos com 5 ou mais pessoas ou com contas de valor acima de $45.00, limitada aos 4 primeiros registros:

–– SQL:
SELECT * FROM dfGorjeta WHERE pessoas >= 5 OR valor_conta > 45 LIMIT 4;
# pandas
dfGorjeta[(dfGorjeta["pessoas"] >= 5) | (dfGorjeta["valor_conta"] > 45)].head(4)
valor_conta gorjeta sexo fumante dia hora pessoas
59 48.27 6.73 homem não sab jantar 4
125 29.80 4.20 mulher não qui almoço 6
141 34.30 6.70 homem não qui almoço 6
142 41.19 5.00 homem não qui almoço 5

Dados ausentes são representados por NULL no, uma marca especial para indicar que um valor não existe no banco de dados. Nos dataframes do pandas o mesmo papel é desempenhado por NaN (Not a Number). Esses marcadores podem surgir, por ex., na leitura de um arquivo csv (valores separados por vírgulas) quando um valor está ausente ou não é um valor numérico em uma coluna de números. Para verificar o comportamento do pandas com NaN criamos um dataframe com valores ausentes. Verificações de nulos é feita com os métodos notna() e isna().

frame = pd.DataFrame({"col1": ["A", "B", np.NaN, "C", "D"], "col2": ["F", np.NaN, "G", "H", "I"]})
frame
col1 col2
0 A F
1 B NaN
2 NaN G
3 C H
4 D I

Se temos um banco de dados SQLcom essa estrutura e conteúdo podemos extrair as linhas onde col2 é NULL usando a consulta:

–– sql
SELECT * FROM frame WHERE col2 IS NULL;
# no case do pandas usamos
frame[frame["col2"].isna()]
col1 col2
1 B NaN

De forma análoga, podemos extrair as linhas para as quais col1 não é NULL. No pandas usamos notna().

–– sql
SELECT * FROM frame WHERE col1 IS NOT NULL;
# pandas: linhas em que col1 não é nula
frame[frame["col1"].notna()]
col1 col2
0 A F
1 B NaN
3 C H
4 D I

GROUP BY


No SQL consultas com agrupamentos são feitas usando-se as operações GROUP BY. No pandas existe o método groupby() que tipicamente particiona o conjunto de dados em grupos e aplica alguma função (em geral de agregamento), combinando depois os grupos resultantes.

Um exemplo comum é o de particionar os dados em grupos menores e contar os elementos desses grupos. Voltando ao nosso dataframe dfGorjeta podemos consultar quantas gorjetas foram dadas por grupos de cada sexo:

–– sql
SELECT sexo, count(*) FROM dfGorjeta GROUP BY sexo;
# o equivalente em pandas seria
dfGorjeta.groupby("sexo").size()
sexo
mulher 87
homem 157
dtype: int64

O resultado é uma series cujos valores podem ser retornados por seu nome de index ou pelo número desse indice.

print("A lista contém %d homens" % dfGorjeta.groupby("sexo").size()[0])
print("\t\t e %d mulheres" % dfGorjeta.groupby("sexo").size()["mulher"])
A lista contém 157 homens
e 87 mulheres

É possível aplicar o método count() para cada coluna, individualmente:

dfGorjeta.groupby("sexo").count()
valor_conta gorjeta fumante almoço hora pessoas
sexo
mulher 87 87 87 87 87 87
homem 157 157 157 157 157 157

Observe que no código do pandas usamos size() e não count(). Isso foi feito porque o método count() é aplicado sobre cada coluna e retorna tantos valores quantas colunas existem, com valores não null.

Também se pode aplicar o método count() para uma coluna específica:

# para contar valores em uma única coluna primeiro ela é selecionada, depois contada
dfGorjeta.groupby("sexo")["valor_conta"].count()
sexo
mulher 87
homem 157
Name: valor_conta, dtype: int64

Existem diversas funções de agregamento. São elas:

função descrição
mean() calcula médias para cada grupo
sum() soma dos valores do grupo
size() *tamanhos dos grupos
count() número de registros no grupo
std() desvio padrão dos grupos
var() variância dos grupos
sem() erro padrão da média dos grupos
describe() gera estatísticas descritivas
first() primeiro valor no grupo
last() último valor no grupo
nth() n-ésimo valor (ou subconjunto se n for uma lista)
min() valor mínimo no grupo
max() valor máximo no grupo

* A função size() retorna o número de linhas em uma serie e o número de linhas × colunas em dataframes.

Para obter um resumo estatístico relativo ao campo gorjeta, agrupado pelo campo sexo podemos usar:

dfGorjeta.groupby("sexo")["gorjeta"].describe()
count mean std min 25% 50% 75% max
sexo
homem 157.0 3.089618 1.489102 1.0 2.0 3.00 3.76 10.0
mulher 87.0 2.833448 1.159495 1.0 2.0 2.75 3.50 6.5

Múltiplas funções podem ser aplicadas de uma vez. Suponha que queremos determinar como os valores das gorjetas variam por dia da semana. O método agg() (de agregar) permite que se passe um dicionário para o dataframe agrupado, indicando que função deve ser aplicada a cada coluna.

–– sql (agrupe os dados por dia, calcule a média para cada dia e o número de entradas contadas)
SELECT dia, AVG(gorjeta), COUNT(*) FROM dfGorjeta GROUP BY dia;
# na pandas, use mean no campo gorjeta, size no campo dia
dfGorjeta.groupby("dia").agg({"gorjeta": np.mean, "dia": np.size})
gorjeta dia
dia
dom 3.255132 76
qui 2.771452 62
sab 2.993103 87
sex 2.734737 19

Também é possível realizar o agrupamento por mais de uma coluna. Para fazer isso passamos uma lista de colunas para o método groupby().

–– agrupe primeiro por “fumante”, depois por “dia”
–– realize a contagem dos registros e a média das gorjetas
SELECT fumante, dia, COUNT(*), AVG(gorjeta) FROM dfGorjeta GROUP BY fumante, dia;
# no pandas
dfGorjeta.groupby(["fumante", "dia"]).agg({"gorjeta": [np.size, np.mean]})
gorjeta
size mean
fumante dia
não dom 57.0 3.167895
qui 45.0 2.673778
sab 45.0 3.102889
sex 4.0 2.812500
sim dom 19.0 3.516842
qui 17.0 3.030000
sab 42.0 2.875476
sex 15.0 2.714000

JOIN

No SQL tabelas podem ser juntadas ou agrupadas através da cláusula JOIN. Junções podem ser LEFT, RIGHT, INNER, FULL. No pandas se usa os métodos join() ou merge(). Por defaultjoin() juntará os DataFrames por seus índices. Cada método tem parâmetros que permitem escolher o tipo da junção (LEFT, RIGHT, INNER, FULL), ou as colunas que devem ser juntadas (por nome das colunas ou índices). [Linguagem de Consultas SQL]

# para os exercícios que se seguem criamos os dataframes
df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value":  [11, 12, 13, 14]})
df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value":  [21, 22, 23, 24]})
# para exibir esses dataframes com formatação usamos display()
display(df1)
display(df2)
key value
0 A 11
1 B 12
2 C 13
3 D 14
key value
0 B 21
1 D 22
2 D 23
3 E 24

Como antes supomos a existência de duas tabelas de dados sql como as mesmas estruturas e dados para considerarmos as várias formas de JOINs.

INNER JOIN

–– junção das duas tabelas ligadas por suas chaves – key
SELECT * FROM df1 INNER JOIN df2 ON df1.key = df2.key;
# por default merge() faz um INNER JOIN
pd.merge(df1, df2, on="key")
key value_x value_y
0 B 12 21
1 D 14 22
2 D 14 23

O método merge() também oferece parâmetros para que sejam feitas junções de uma coluna de um dataframe com o índice de outro dataframe. Para ver isso vamos criar outro dataframe a partir de df2, usando o campo key como índice.

# novo dataframe tem campo "key" como índice
df2_indice = df2.set_index("key")
display(df2_indice)
pd.merge(df1, df2_indice, left_on="key", right_index=True)
value
key
B 21
D 22
D 23
E 24
key value_x value_y
1 B 12 21
3 D 14 22
3 D 14 23

LEFT OUTER JOIN

A junção LEFT OUTER JOIN recupera todos as campos à esquerda, existindo ou não uma linha correspondente à direita. O parâmetro how="left" é o equivalente no pandas.

–– sql: recupera todos os valores de df1 existindo ou não correspondente em df2
SELECT * FROM df1 LEFT OUTER JOIN df2 ON df1.key = df2.key;
# pandas: how="left" equivale a LEFT OUTER JOIN
pd.merge(df1, df2, on="key", how="left")
key value_x value_y
0 A 11 NaN
1 B 12 21
2 C 13 NaN
3 D 14 22
4 D 14 23

Observe que df2 não possui campos com key = "A" ou key = "C" e, por isso o dataframe resultante tem NaN nessas entradas. key = "A". Como df2 tem 2 linhas para key = "D" a linha aparece duplicada para essa key em df1.

RIGHT JOIN

A junção RIGH OUTER JOIN recupera todos as campos à direita, existindo ou não uma linha correspondente à esquerda. O parâmetro how="right" é o equivalente no pandas.

–– sql: recupera todos os registros em df2
SELECT * FROM df1 RIGHT OUTER JOIN df2 ON df1.key = df2.key;
# pandas: how="right" equivale a RIGHT OUTER JOIN
pd.merge(df1, df2, on="key", how="right")
key value_x value_y
0 B 12 21
1 D 14 22
2 D 14 23
3 E NaN 24

FULL JOIN

A junção FULL OUTER JOIN recupera todos as campos à direita ou à esquerda, representando como NaN os valores ausentes em uma ou outra. Todos as linhas das duas tabelas são retornadas com junção onde a campo key existe em ambas. O parâmetro how="outer" é o equivalente no pandas. Observe que nem todos os gerenciadores de bancos de dados permitem essa operação.

–– sql: retorna todos os registros em ambas as tabelas
SELECT * FROM df1 FULL OUTER JOIN df2 ON df1.key = df2.key;
# pandas: how="outer" é o equivalente em dataframes
pd.merge(df1, df2, on="key", how="outer")
key value_x value_y
0 A 11 NaN
1 B 12 21
2 C 13 NaN
3 D 14 22
4 D 14 23
5 E NaN 24

UNION

Para os exemplos seguintes definimos mais 2 dataframes:

df3 = pd.DataFrame({"cidade": ["Rio de Janeiro", "São Paulo", "Belo Horizonte"], "nota": [1, 2, 3]})
df4 = pd.DataFrame({"cidade": ["Rio de Janeiro", "Curitiba", "Brasília"], "nota": [1, 4, 5]})

No SQL a clásula UNION ALL é usada para juntar as linhas retornadas em dois (ou mais) instruções de SELECT. Linhas duplicadas são mantidas. O mesmo efeito pode ser conseguido no pandas usando-se o método concat().

–– sql: UNION ALL
SELECT city, rank FROM df3 UNION ALL SELECT cidade, nota FROM df4;
# pandas: concat
pd.concat([df3, df4])
cidade nota
0 Rio de Janeiro 1
1 São Paulo 2
2 Belo Horizonte 3
0 Rio de Janeiro 1
1 Curitiba 14
2 Brasília 5

No SQL a cláusula UNION tem o mesmo efeito que UNION ALL mas remove as linhas duplicadas. No pandas isso pode ser conseguido se fazendo a conactenação concat() seguida de drop_duplicates().

–– SQL UNION
SELECT city, rank FROM df1 UNION SELECT city, rank FROM df2;
–– o registro duplicado no Rio de Janeiro fica excluído
# pandas: concat() seguido de drop_duplicates()
pd.concat([df1, df2]).drop_duplicates()
cidade nota
0 Rio de Janeiro 1
1 São Paulo 2
2 Belo Horizonte 3
1 Curitiba 14
2 Brasília 5

Outras funções analíticas e de agregamento

Para os próximos exemplos vamos retornar ao nosso dataframe dfGorjeta: para listar as 5 gorjetas mais altas, no MySQL (a sintaxe varia de um para outro gerenciador).

–– MySQL: retorna todos os campos em ordem decrescente, 5 linhas
SELECT * FROM dfGorjeta ORDER BY gorjeta DESC LIMIT 10 OFFSET 5;
# pandas: seleciona 15 maiores e exibe as 10 de menor valor
dfGorjeta.nlargest(15, columns="gorjeta").tail(10)
valor_conta gorjeta sexo fumante dia hora pessoas
183 23.17 6.50 homem sim Dom jantar 4
214 28.17 6.50 mulher sim sab jantar 3
47 32.40 6.00 homem não Dom jantar 4
239 29.03 5.92 homem não sab jantar 3
88 24.71 5.85 homem não Thur almoço 2
181 23.33 5.65 homem sim Dom jantar 2
44 30.40 5.60 homem não Dom jantar 4
52 34.81 5.20 mulher não Dom jantar 4
85 34.83 5.17 mulher não Thur almoço 4
211 25.89 5.16 homem sim sab jantar 4

UPDATE

Há muitas formas de alterar um valor em um campo de um dataframe. Por exemplo, abaixo realizamos uma alteração em todos os valores de gorjeta sempre que gorjeta < 2.

–– sql: em todas as linhas duplique a gorjeta se gorjeta for menor que 1.1
UPDATE dfGorjeta SET gorjeta = gorjeta*2 WHERE gorjeta < 1.1;
# pandas: o mesmo resultado pode ser obtido da aseguinte forma
# dfGorjeta.loc[dfGorjeta["gorjeta"] < 1.1, "gorjeta"] *= 2

Para explicar com mais detalhes o funcionamento deste código, armazenamos abaixo a lista dos índices das linhas de gorjetas mais baixas e exibimos essas linhas. Em seguida multiplicamos apenas as gorjetas dessas linhas por 2 e examinamos o resultado:

indices = dfGorjeta[dfGorjeta["gorjeta"] < 1.1].index
print("Índices de gorjetas < 1.1:", indices)
display("Lista de gorjetas < 1.1", dfGorjeta.iloc[indices])
# multiplica essas gorjetas por 2
dfGorjeta.loc[dfGorjeta["gorjeta"] < 1.1, "gorjeta"] *= 2
# lista as mesmas linhas após a operação
display("Gorjetas após a operação:", dfGorjeta.iloc[indices])
Índices de gorjetas < 1.1: Int64
Index([0, 67, 92, 111, 236], dtype=’int64′)
‘Lista de gorjetas < 1.1’

valor_conta gorjeta sexo fumante dia hora pessoas
0 16.99 1.01 mulher não dom jantar 2
67 3.07 1.00 mulher sim sab jantar 1
92 5.75 1.00 mulher sim sex jantar 2
111 7.25 1.00 mulher não sab jantar 1
236 12.60 1.00 homem sim sab jantar 2

‘Gorjetas após a operação:’

valor_conta gorjeta sexo fumante dia hora pessoas
0 16.99 2.02 mulher não dom jantar 2
67 3.07 2.00 mulher sim sab jantar 1
92 5.75 2.00 mulher sim sex jantar 2
111 7.25 2.00 mulher não sab jantar 1
236 12.60 2.00 homem sim sab jantar 2
–– sql: alterar um campo de uma linha específica (supondo a existência de um campo id)
UPDATE dfGorjeta SET sexo = ‘NI’ WHERE id = 239
# para alterar o campo sexo para 'NI' (não informado)
dfGorjeta.loc[239, 'sexo'] ='NI'

DELETE

Existem muitas formas de se excluir linhas de um dataframe mas é comum a prática de selecionar as linhas que devem ser mantidas e copiar para um novo dataframe.

–– sql: linhas são apagadas sob um certo critério
DELETE FROM dfGorjeta WHERE gorjeta > 9;
# pandas: como novo dataframe tem o mesmo nome do original, o antigo é sobrescrito e perdido
dfTop = dfGorjeta.loc[dfGorjeta["gorjeta"] > 9]
dfTop
valor_conta gorjeta sexo fumante dia hora pessoas
170 50.81 10.0 homem sim sab jantar 3

Também é possível apagar linhas usando seu índice:

# apagar linha com index = 4, inplace para substituir o dataframe
dfGorjeta.drop(index=4, inplace=True)
# apagar linhas com index = 0 até 3
dfGorjeta.drop(index=[0, 1, 2, 3], inplace=True)
dfGorjeta.head()
valor_conta gorjeta sexo fumante dia hora pessoas
5 25.29 4.71 homem não dom jantar 4
6 8.77 12.00 homem não dom jantar 2
7 26.88 3.12 homem não dom jantar 4
8 15.04 1.96 homem não dom jantar 2
9 14.78 3.23 homem não dom jantar 2
🔺Início do artigo

Bibliografia

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

Pacote FactorAnalyser



FactorAnalyzer é um módulo Python para realizar análise fatorial exploratórias (AFE) e confirmatória (AFC). Na análise exploratória se pode usar várias técnicas de estimativa. É possível executar AFE usando (1) solução residual mínima (MINRES), (2) uma solução de máxima verossimilhança ou (3) uma solução de fator principal. A análise confirmatória só pode ser executada usando uma solução de máxima verossimilhança.

As classes do pacote são compatíveis com a biblioteca scikit-learn. Partes do código são portadas da biblioteca psych do R, e a classe AFC foi baseada no pacote sem. A classe factor_analyzer.factor_analyzer.FactorAnalyzer se utiliza de sklearn.base.BaseEstimator e sklearn.base.TransformerMixin.

Na AFE as matrizes de carga fatorial são geralmente submetidas a rotações após o modelo de análise fatorial ser estimado, buscando-se produzir uma estrutura mais simples e de fácil interpretação na identificação das variáveis que estão carregando em um determinado fator.

Os dois tipos mais comuns de rotações são:

  • Rotação ortogonal varimax, que gira a matriz de cargas fatoriais de forma a maximizar a soma da variância das cargas quadradas, preservando a ortogonalidade da matriz de carga.
  • A rotação oblíqua promax, baseada na rotação varimax, mas buscando maior correlaçãp dos fatores.

Esse pacote inclui o módulo analisador de fatores com a classe FactorAnalyzer. Essa classe inclui os métodos fit() e transform() para realizar a análise e pontuar novos dados usando o modelo de fatores ajustados. Rotações opcionais podem ser realizadas sobre a matriz de cargas fatoriais com a classe Rotator.

Os seguintes métodos de rotação estão disponíveis tanto para FactorAnalyzer quanto para Rotator:

  • varimax (rotação ortogonal),
  • promax (oblíqua),
  • oblimin (oblíqua),
  • oblimax (ortogonal),
  • quartimin (oblíqua),
  • quartimax (ortogonal),
  • equamax (ortogonal),
  • geomin_obl (oblíqua),
  • geomin_ort (ortogonal).

O pacote também inclui o módulo confirmatory_factor_analyzer com a classe ConfirmatoryFactorAnalyzer. A classe contém os métodos fit() e transform() que realizam análises fatoriais confirmatórias e pontuam novos dados usando o modelo ajustado. A execução do CFA requer que os usuários especifiquem previamente o modelo com as relações de carga fatorial esperadas, o que pode ser feito usando a classe ModelSpecificationParser.

# O pacote pode ser instalado usando pip:
$ pip install factor_analyzer

# ou conda:
$ conda install -c ets factor_analyzer

Ele depende de Python 3.4 (ou superior), numpy, pandas, scipy, scikit-learn.

A classe factor_analyzer possui um método para ajustar um modelo de análise e fazer a análise fatorial usando solução residual mínima (MINRES), solução de máxima verossimilhança ou (3) solução de fator principal. Retorna a matriz de cargas fatoriais. Por default não realiza nenhuma rotação. Opcionalmente pode realizar uma rotação usando os métodos citados abaixo.

Análise Fatorial Exploratória

Módulo factor_analyzer.factor_analyzer

class
factor_analyzer.factor_analyzer.FactorAnalyzer(n_factors=3, rotation=’promax’, method=’minres’,
use_smc=True, is_corr_matrix=False, bounds=(0.005, 1),
impute=’median’, rotation_kwargs=None)
Parâmetros:
n_factors
(int, opcional) – Número de fatores a ajustar. Default: 3.
rotation
(str, opcional) – Default: None.
Define o tipo de rotação a realizar após o ajuste do modelo. Nenhuma rotação será realizada se rotation = None e nenhuma normalização de Kaiser será aplicada. Os seguintes métodos de rotação estão disponíveis:

  • varimax (rotação ortogonal),
  • promax (oblíqua),
  • oblimin (oblíqua),
  • oblimax (ortogonal),
  • quartimin (oblíqua),
  • quartimax (ortogonal),
  • equamax (ortogonal),

sendo rotation = ‘promax’ o default.

method
({‘minres’, ‘ml’, ‘principal’}, opcional) – Método de ajuste a ser usado: solução residual mínima (MINRES), uma solução de máxima verossimilhança ou de fator principal. Default: minres.
use_smc
(bool, opcional) – Uso de correlação multipla quadrada (SMC, square multiple correlation) como ponto de partida para a análise. Default: True.
bounds
(tuple, opcional) – Limites inferior e superior das variáveis para a otimização “L-BFGS-B”. Default: (0.005, 1).
impute
({‘drop’, ‘mean’, ‘median’}, opcional) – Se existem valores faltantes nos dados usar apagamento na lista inteira (‘drop’) ou substituir valores usando a mediana (‘median’) ou a média (‘mean’) da coluna.
use_corr_matrix
(bool, opcional) – Ajuste para Verdadeiro se os dados de entrada já são a matriz de correlação. Default: False.
rotation_kwargs
(opcional) – argumentos adicionais passados para o método de rotação.
Propriedades:
loadings
A matriz de cargas fatoriais. Default: None se o método fit() não foi chamado.
Tipo: numpy array
corr
A matriz original de correlação. Default: None se o método fit() não foi chamado.
Tipo: numpy array
rotation_matrix
A matriz de rotação, se uma rotação não foi executada.
Tipo: numpy array
structure
A estrutura da matriz de cargas fatoriais. (Só existe se rotação for promax).
Tipo: numpy array ou None
psi
A matriz de fatores de correlação. (Só existe se rotação for oblíqua).
Tipo: numpy array ou None
Métodos:
fit(X, y=None)
Faz a análise fatorial sobre os dados de X usando ‘minres’, ‘ml’, ou ‘principal solutions’. Default: SMC (correlação múltipla quadrada)
Parâmetros:
     X (variável tipo array) – Dados originais a serem analisados.
     y (não é utilizado).
get_communalities()
Calcula as comunalidades, dada uma matriz de cargas fatoriais.
Retorna: communalities (numpy array), as comunalidades.
get_eigenvalues()
Calcula os autovalores, dada uma matriz de correlações fatoriais.
Retorna: original_eigen_values (numpy array), os autovalores originais.
    common_factor_eigen_values(numpy array), os autovalores dos fatores comuns.
get_factor_variance()
Calcula informações de variância, inclusive a variância, variância proporcional e cumulativa para cada fator.
Retorna: variance (numpy array) – A variância dos fatores.
    proportional_variance (numpy array) – A variância proporcional dos fatores.
    cumulative_variances (numpy array) – A variância cumulativa dos fatores.
get_uniquenesses()
Calcula a unicidade, dada uma matriz de cargas fatoriais.
Retorna: uniquenesses (numpy array) – A unicidade da matriz de cargas fatoriais.
transform(X)
Retorna a pontuação de fatores para um novo conjunto de dados.
Parâmetros: X (variável de array, shape (n_amostras, n_características)) – Os dados a pontuar usando o modelo de fatores ajustado.
Retorna: X_new – As variáveis latentes de X. (um numpy array, shape (n_amostras, n_componentes))

Testes de Bartlett e KMO

factor_analyzer.factor_analyzer.calculate_bartlett_sphericity(x)

Testa a hipótese de que a matriz de correlação é igual à matriz identidade (o que significa que não há correlação entre as variáveis).

Parâmetro
X (variável de array) – Dados sobre os quais calcular a esfericidade.
Retorna:
statistic (float) – O valor de chi-quadrado, \chi^2.
p_value (float) – O valor de p-value associado ao teste.
factor_analyzer.factor_analyzer.calculate_kmo(x)

Calcula o critério de Kaiser-Meyer-Olkin para cada fator individual e para o conjunto fatores. Essa estatística representa o grau com que cada variável observada pode ser predita, sem erro, pelas demais variáveis. Na maior parte dos casos KMO < 0.6 é considerado inadequado.

Parâmetros:
x (variável de array) – Dados sobre os quais calcular coeficientes KMOs.
Retorna:
kmo_per_variable (array numpy) – O KMO para cada item.
kmo_total (float) – A pontuação KMO geral.

Análise Fatorial Confirmatória

Módulo factor_analyzer.confirmatory_factor_analyzer

class
factor_analyzer.confirmatory_factor_analyzer.ConfirmatoryFactorAnalyzer(specification=None,
n_obs=None, is_cov_matrix=False, bounds=None, max_iter=200,
tol=None, impute=’median’, disp=True)

A classe ConfirmatoryFactorAnalyzer ajusta um modelo de análise fatorial confirmatória usando o modelo de máxima verosimelhança (maximum likelihood).

Parâmetros:
specification
(ModelSpecification object ou None, opcional) – Um modelo de especificação ModelSpecification ou None. Se None for fornecido o ModelSpecification será gerado supondo que o número de fatores n_factors é o mesmo que o número de variáveis, n_variables, e que todas as variáveis carregam em todos os fatores. Note que isso pode significa que o modelo não foi identificado e a otimização poderá falhar. Default: None.
n_obs
(int ou None, opcional) – Número de observações no conjunto original de dados. Se não for passado e is_cov_matrix=True um erro será lançado. Default: None.
is_cov_matrix
(bool, opcional) – Informa se a matriz de entrada X é a matriz de covariância. Se False o conjunto completo de dados é considerado. Default: False.
bounds
(lista de tuplas ou None, opcional) – Uma lista de limites mínimos e máximos para cada elemento do array de entrada. Deve ser igual a x0 que é o array de entrada do modelo de especificação.

O comprimento é: ((n_factors * n_variables) + n_variables + n_factors + (((n_factors * n_factors) – n_factors) // 2)

Se bounds=None nenhum limite será tomado. Default: None.

max_iter
(int, opcional) – Número máximo de iterações na rotina de otimização. Default: 200.
tol
(float ou None, opcional) – Tolerância para a convergência. Default: None.
disp
(bool, opcional) – Se a mensagem da otimização do scipy fmin é enviado para o standard output. Default: True.
Exceção levantada
ValueError – Se is_cov_matrix = True e n_obs não é fornecido.
Propriedades:
model
Objeto modelo de especificação.
Tipo: ModelSpecification.
loadings_
A Matriz da Cargas fatoriais.
Tipo: numpy array
error_vars_
A matriz de variância de erros (Tipo: numpy array).
factor_varcovs_
A Matriz de covariância. (Tipo: numpy array).
log_likelihood_
O log de verossimilhança da rotina de otimização. (Tipo: float).
aic_
O critério de informação de Akaike. (Tipo: float).
bic_
O critério de informação Bayesiano. (Tipo: float).
Métodos:
fit(X, y=None)
realiza a análise fatorial confirmatória sobre os dados de X usando máxima verossimilhança.
Parâmetros:
X (variável tipo array) – Dados originais a serem analisados. Se X for a matriz de covariância é necessário marcar is_cov_matrix = True.
y (não é utilizado)
Exceção levantada:
ValueError – Se a especificação não é um objeto ModelSpecification nem None.
AssertionError – Se is_cov_matrix = True e a matriz fornecida não é quadrada.
AssertionError – If len(bounds) != len(x0)
get_model_implied_cov()
Retorna a matriz de covariância implícita no modelo, se o modelo foi estimado. (numpy array)
get_standard_errors()
Lê os erros padrão da matriz de covariância implícita e das médias implícitas.
Retorna:
loadings_se (numpy array) – Os erros padrões para os cargas fatoriais.
error_vars_se (numpy array) – Os erros padrões para as variâncias de erros.
transform(X)
Lê as pontuações para os fatores do novo conjunto de dados.
Parâmetros: X (tipo array, shape (n_amostras, n_características)) – Os dados a serem pontuados usando o modelo fatorial ajustado.
Retorna: pontuações – As variáveis latentes de X (um numpy array, shape (n_amostras, n_componentes))
class
factor_analyzer.confirmatory_factor_analyzer.ModelSpecification(loadings, n_factors, n_variables,
factor_names=None, variable_names=None)

Uma classe para encapsular a especificação do modelo para a análise confirmatória. Esta classe contém várias propriedades de especificação que são usadas no procedimento AFC.

Parâmetros:
loadings
(tipo array) – Especificação de cargas fatoriais.
error_vars (array-like) – Especificação de variância do erro
factor_covs (tipo array) – Especificação da covariância do fator.
factor_names (lista de str ou None) – uma lista de nomes de fatores, se disponível. Default: None.
variable_names (lista de str ou None) – Uma lista de nomes de variáveis, se disponível. Default: None.
Propriedades:
loadings
Especificação das cargas fatoriais. (Tipo: numpy array)
error_vars
Especificação da variância de erros. (Tipo: numpy array)
factor_covs
Especificação do fator de covariância. (Tipo: numpy array)
n_factors
Número de fatores. (Tipo: int).
n_variables
Número de variáveis. (Tipo: int).
n_lower_diag
Número de elementos no array factor_covs, igual à diagonal inferior da matriz de covariância fatorial. (Tipo: int).
loadings_free
Índices dos parâmetros de cargas fatoriais “livres”. (Tipo: numpy array)
error_vars_free
Índices dos parâmetros de variância de erros “livres”. (Tipo: numpy array)
factor_covs_free
Índices dos parâmetros de covariância de fator “livre”. (Tipo: numpy array)
factor_names
Lista dos nomes dos fatores, se disponível. (Tipo: lista de str ou None).
variable_names
Lista dos nomes das variáveis, se disponível. (Tipo: lista de str ou None).
error_vars
error_vars_free
factor_covs
factor_covs_free
factor_names
Métodos:
get_model_specification_as_dict()
Retorna model_specification – O modelo de especificações, chaves e valores, como um dicionario (dict).
copy()
Retorna uma “deep copy” do objeto.
loadings
loadings_free
n_factors
n_lower_diag
n_dtiables
dtiable_names

Analisador de especificação de modelo

class factor_analyzer.confirmatory_factor_analyzer.ModelSpecificationParser

Uma classe para gerar a especificação do modelo para Análise Fatorial Confirmatória. Inclui dois métodos estáticos para gerar o objeto ModelSpecification a partir de um dicionário ou de um array numpy.

static parse_model_specification_from_array(X, specification=None)

Gera a especificação do modelo a partir de um array. As colunas devem corresponder aos fatores e as linhas às variáveis. Se este método for usado para criar a ModelSpecification nenhum nome de fator ou nome de variável serão adicionadoa como propriedades desse objeto.

Parâmetros:
X (tipo array) – O conjunto de dados será usado para a AFC.
specification (tipo array or None) – Array com os detalhes das cargas.
Se specification = None a matriz será criada supondo-se que todas as variáveis carregam em todos os fatores. Default: None.
Retorna:
Objeto modelo de especificação, ModelSpecification.
Exceção levantada:
ValueError se especificação não está no formato esperado.
static parse_model_specification_from_dict(X, specification=None)

Gere a especificação do modelo a partir de um dicionário. As chaves no dicionário devem ser os nomes dos fatores e os valores devem ser os nomes das características (features). Se esse método for usado para criar uma ModelSpecification os nomes dos fatores e das variáveis serão adicionados como propriedades a esse objeto.

Parâmetros:
X (tipo array) – O conjunto de dados será usado para a AFC.
specification (tipo array or None) – Dicionário com os detalhes das cargas. Se None a matriz será criada supondo-se que todas as variáveis carregam em todos os fatores. Defaults = None.
Retorna: Objeto modelo de especificação, ModelSpecification.
Exceção levantada: ValueError se especificação não está no formato esperado.

Módulo factor_analyzer.rotator

Classe para executar diversas rotações nas matrizes de cargas fatoriais. Os métodos de rotação listados abaixo estão disponíveis tanto para FactorAnalyzer quanto para Rotator.

class
factor_analyzer.rotator.Rotator(method=’varimax’, normalize=True, power=4,
kappa=0, gamma=0, delta=0.01, max_iter=500, tol=1e-05)
Parâmetros:
method
(str, opcional). Métodos de rotação disponíveis: Default: ‘varimax’.

  • varimax (rotação ortogonal),
  • promax (oblíqua),
  • oblimin (oblíqua),
  • oblimax (ortogonal),
  • quartimin (oblíqua),
  • quartimax (ortogonal),
  • equamax (ortogonal),
  • geomin_obl (oblíqua),
  • geomin_ort (ortogonal).
normalize
(bool ou None, opcional) – Informa se uma normalização de Kaiser e de-normalização devem ser efetuadas antes e após a rotação. Usada para as rotações varimax e promax. Se None o default para promax é False, default para varimax é True. Default: None.
power
(int, opcional) – Potência das gargas de promax (menos 1). Geralmente na faixa entre 2 e 4. Default: 4.
kappa
(int, opcional) – Valor kappa para o objetivo equamax. Ignorado se método não for ‘equamax’. Default: 0.
gamma
(int, opcional) – Nível gamma para o objetivo ‘oblimin’. Ignorado se método não for ‘oblimin’. Default: 0.
delta
(float, opcional) – Nível delta level para o objetivo ‘geomin’. Ignorado se método não for ‘geomin_*’. Default: 0.01.
max_iter
(int, opcional) – Número máximo de iterações. Usado para método ‘varimax’ e rotações oblíquas. Default: 1000.
tol
(float, opcional) – Limite (threshold) de convergência. Usado para método ‘varimax’ e rotações oblíquas. Default: 1e-5.
Propriedades:
loadings_
A matriz de carregamentos. (Tipo: numpy array, shape (n_características, n_fatores)

rotation_

Matriz de rotação. (Tipo: numpy array, shape (n_fatores, n_fatores))

psi_

Matriz de correlações fatoriais. Existe apenas se a rotação é oblíqua. (Tipo: numpy array ou None)

Métodos:
fit(X, y=None)
Computa o fator de rotação model_specification – O modelo de especificações, chaves e valores, como um dicionario (dict).

Parâmetros
X (tipo array) – A matriz (n_características, n_fatores) de cargas fatoriais
y (não utilizado)
Retorna
self
fit_transform(X, y=None)
Computa o fator de rotação e retorna a nova matriz de cargas fatoriais.

Parâmetros
X (tipo array) – A matriz (n_características, n_fatores) de cargas fatoriais
y (não utilizado)
Retorna
loadings_, a matriz (n_características, n_fatores) de cargas fatoriais (numpy array)
Erro levantado
ValueError – se o método não está na lista de métodos aceitáveis.

Bibliografia

Jupyter Notebook

O que é o Jupyter Notebook?

Jupyter Notebook é uma ferramenta poderosa para o desenvolvimento projetos de ciência de dados de forma interativa que é executada de dentro de seu browser. Além da execução interativa de código ele pode ser usado para a preparação de apresentações dinâmicas onde texto pode ser bem formatado contendo imagens, gráficos interativos e fórmulas matemáticas. O conteúdo das linhas de código e seus outputs (as respostas produzidas pelo código) ficam bem delimitadas.

Ele faz parte do Projeto Jupyter de código aberto e free software. É possível baixar e instalar gratuitamente o Jupyter Notebooks separadamente ou como parte do kit de ferramentas de ciência de dados Anaconda. Com ele se pode usar vários ambientes de execução (kernels ou núcleos) com linguagens de programação como o Python, R, Julia, C++, Scheme, Haskell e Ruby.

O Jupyter Notebook está se tornando uma interface muito popular para a computação na nuvem e muitos dos provedores desse tipo de serviço o adotaram como interface front-end para seus usuários. Entre eles estão o SageMaker Notebooks da Amazon, o Colaboratory do Google e o Azure Notebook da Microsoft. O Colaboratory (também chamado de Colab) é um ambiente gratuito que armazena e roda notebooks no Google Drive.

Os arquivos no Notebook são armazenados no formato JSON com a extensão *.ipynb. Eles podem ser lidos pelo aplicativo instalado (que usa o browser para sua exibição), e exportado para várias formatos, entre eles: html, markdown, pdf, latex e slides Reveal.js. O arquivo consiste de várias células que são exibidas como uma página usual de html. Algumas células são de código e seus resultados, outras de texto, imagens ou outras mídias. Alternativamente eles podem ser lidos e exibidos (de forma não interativa) pelo nbviewer (na web).

Instalação

A forma mais simples de instalação do Jupyter Notebooks consiste em instalar o Anaconda, a distribuição Python mais usada para ciência de dados. Esta instalação inclui as princiais bibliotecas e ferramentas mais populares, como NumPy, Pandas e Matplotlib.

Para obter 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.

Executando e Criando um Notebook

No Windows na MacOS ou Linux um atalho para Jupyter Notebook é criado no menu do sistema. Caso nenhum atalho tenha sido criado você pode criar um ou iniciar usando o console. No Linux se digita jupyter-notebook no console. Uma janela com a seguinte aparência é aberta no browser padrão:

A primeira página exibe o painel de controle do Jupyter (dashboard). Ele dá acesso aos arquivos e subpastas que estão na pasta de inicialização do Jupyter. Esta pasta, no entanto, pode ser alterada. O painel de controle tem uma interface amigável por onde você pode controlar suas pastas e notebooks. Toda a descrição que usamos aqui se refere à aparência default dos notebooks. Essa aparência pode ser alterada modificando-se o arquivo css em /home/nome-usuario/.jupyter/custom/custom.css (no Linux).

O Jupyter Notebook fica aberto no navegador usando uma URL especial, do tipo “http://localhost:8888/tree”. Isso indica que o servidor dessa página esta em sua máquina local.

Você pode criar uma pasta nova para seus projetos clicando em New Folder. Depois pode renomear sua pasta selecionado e clicando em Rename. Clique na pasta para abrí-la e depois em New: Python 3 (notebook). Um notebook vazio e sem nome é criado. Clique nele e em File | Rename e dê um nome apropriado para o seu notebook. Vários notebooks podem ser abertos ao mesmo tempo.

Um notebook aberto apresenta a seguinte interface:

Os menus superiores dão acesso as funcionalidades de gravar arquivo, importar e exportar para diferentes formatos, etc. O item File | Save and Checkpoint (Ctrl-S) permite guardar o estado as sessão no momento de forma a poder ser recuperada mais tarde por meio de File | Revert to Checkpoint. Para fechar uma sessão não basta fechar a aba do navegador pois isso deixaria ativa a tarefa na memória do computador. Para isso você pode usar File | Close and Halt ou Kernel | Shutdown. Também se pode clicar em LOGOUT no canto superior direito.

Ainda na barra de menus você pode clicar em Help | User interface tour para ver alguns pontos relevantes no notebook. Help | Keyboard Shortcuts exibe os atalhos de teclado predefinidos, observando que eles podem ser modificados pelo usuário. O menu de ajuda também contém links diretos para as documentações do Python, IPython, NumPy, SciPy, Matplotlib, SymPy, pandas e markdown. O ícone de teclado abre uma ajuda com os atalhos mais usados.

Notebooks são iniciados com uma célula vazia. Cada célula possui dois modos de uso: modo de edição e modo de comando. Clicando dentro da célula ela fica com borda verde e entra no modo de edição onde se pode inserir texto e códigos. Use a caixa de seleção na caixa de ferramentas do notebook para selecionar entre ‘code’, ‘markdown’ ou ‘Raw NBConvert’. (A opção ‘heading’ está em desuso e é desnecessária). Se ‘code’ está selecionado você pode digitar um comando como, por ex.,

print('Olá galera!')
Olá galera!

Comandos dentro de uma célula de código são executados todos de uma vez. Para isso pressione:
shift-enter: o código é executado e uma nova célula é aberta no mode de edição, ou
ctrl-enter: o código é executado e a mesma célula fica selecionada no modo de comando.

Em ambos os casos o output, se existir, é mostrado abaixo da célula. O botão ▶ Run na barra de ferramentas tem o mesmo efeito que shift-enter.

Os modos de edição e de comando são alternados com o uso de ESC (passa de comando para edição) e enter (de edição para comando).

Quando no modo de comando (a célula fica com a borda azul) os seguintes atalhos ficam habilitados:

Comando Ação
ESC/enter Alterna entre modos de edição / comando
Barra de espaço Rolar tela para baixo
Shift-Barra de espaço Rolar tela para cima
A Inserir célula acima
B Inserir célula abaixo
D, D Apagar células selecionadas
Z Desfazer apagamento
Shift-L Exibir/ocultar numeração das linhas de código
Y Alterar célula para código
M Alterar célula para markdown
R Alterar célula para raw
H Exibir Help | keyboard shortcuts
Teclas 🔼 ou 🔽 Rolar para cima e para baixo nas células
Shift 🔼 ou 🔽 Selecionar várias células de uma vez.
Shift M Mesclar várias células selecionadas em uma única.
Ctrl Shift – Dividir célula ativa na posição do cursor (no modo de edição).
Shift clique na margem esquerda da célula Selecionar várias células de uma vez.

Um lista completa desses atalhos pode ser vista no menu Help | keyboard shortcuts.

Células no formato de texto

Células podem ser marcadas como texto puro, sem qualquer formatação, no modo Raw NBConvert. Esse texto é exibido como está e não passará por renderização de nenhuma forma nem na exibição dentro do notebook nem na exportação para outros formatos, como o pdf.

Markdown

Markdown é uma linguagem de marcação limitada mas bastante simples de se aprender e usar. Ela tem sintaxe diferente de html mas guarda uma correspondência com suas tags. Você pode encontrar uma descrição mais completa de Markdown na página Marcação de Texto com Markdown.

Além da marcação markdown se pode usar um conjunto restrito de tags html nas caixas de texto. Por exemplo, o código à esquerda produzirá a barra vermelha à direita, útil para marcar o ponto de parada dentro de um notebook.

parei aqui ↷
<div style=”border:1px solid black;
padding:10px; color:white; background-color:red;”>
parei aqui ↷
</div>

O Jupyter Notebook pode renderizar Latex (para isso usa a biblioteca javascript Mathjax) em suas células de Markdown.


A identidade de Euler é \(e^{i \pi} + 1 = 0\).
A definição da derivada de primeira ordem é:
$$
f'(x) = \lim\limits_{h \rightarrow 0} \frac{f(x+h) – f(x)}{h}
$$

Células de código

Células de código contém as instruções a serem executadas pelo kernel. À esquerda de uma célula de código aparece o sinal In[n] que significa Input [n], onde n é a ordem de execução das linhas. Uma célula em exibição é marcada pelo sinal In[*], o que é importante observar quando se tem uma execução mais demorada de código. Em geral o notebook continua responsivo mas novas instruções devem aguardar o término das primeiras para serem executados. O resultado da computação da célula, quando existir, aparece abaixo com o sinal Out[n].

O código em um célula ativa (com bordas azuis) é executado com ctrl-enter ou shift-enter (alternativamente com botão ▶ Run na barra de ferramentas). A barra de menu contém as opções Cell | Run All, Cell | Run All Above Cell | Run All Below.

É importante notar que as células são executadas no kernel e seu estado persiste ao longo da execução. O estado do kernel se refere ao notebook como um todo e não às células individuais. Se você importar bibliotecas ou declarar variáveis ​​em uma célula elas estarão disponíveis em toda a seção e não apenas nas células abaixo da declaração. A ordem em que inputs e outputs aparecem pode ser enganosa: se você declarar uma variável em uma célula, digamos g = 5 e voltar para uma célula anterior a variável g ainda terá o mesmo valor. O que importa é a ordem de execução, marcada por In[n]. Por isso é preciso ter cuidado ao fazer alterações nas células. Idealmente se deve manter a ordem sequencial e, ao fazer alterações importantes, executar todo o notebook novamente.

Existem várias opções relativas à execução no menu Kernel:

Kernel | Interrupt Interromper o kernel,
Kernel | Restart Reinicializar o kernel,
Kernel | Restart & clear outputs Reinicializar kernel e limpar outputs,
Kernel | Restart & Run All Reinicializar kernel e executar todas as células.

A opção de reinicializar o kernel limpando as saídas e executar novamente todas as células pode ser útil quando muitas células foram alteradas. No entanto, dependendo das operações a serem executadas, ela pode ser uma operação demorada.

É possível escolher e rodar e Jupyter Notebook com diferentes opções de kernel, com diferentes versões de Python e muitas outras linguagens, incluindo Java, C, R e Julia.

O Notebook é salvo ao se pressionar Ctrl S. Isso renova o arquivo de ponto de verificação que é criado junto com o Notebook. Esse arquivo, que também tem extensão .ipynb fica localizado em pasta oculta e pode ser usado na recuperação da sessão caso algum erro inesperado cause a perda do notebook atual. Por padrão o Jupyter salva automaticamente o bloco de notas a cada 120 segundos sem alterar o arquivo de bloco de notas principal.Para reverter para um ponto de verificação use o menu via File | Revert to Checkpoint.

Tendo escolhido um notebook com kernel python 3, podemos experimentar um resultado com a execução de código que fornece um output de texto e gráfico:

# importe as bibliotecas necessárias
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(1, 15, 0.1);
y = np.sin(x)/np.cos(x)
z = np.cos(x)/np.sin(x)
print("x em [1, 15] \ny=seno/cosseno; z=cosseno/seno")
plt.plot(x, y)
plt.plot(x, z)
x em [1, 15]
y=seno/cosseno; z=cosseno/seno

É importante observar que a última variável listada em uma célula é exibida no output sem necessidade de um comando print. Por ex., no código abaixo importamos uma tabela disponível na web no formato *.csv para a construção de um dataframe do pandas. O dataframe é exibido com uma formatação amigável no final da célula.

1  import pandas as pd
2  bfi ='https://vincentarelbundock.github.io/Rdatasets/csv/psych/bfi.csv'
3  df = pd.read_csv(bfi)
4  # head exibirá apenas as 5 primeiras linhas do dataframe
5  df.head()
Unnamed: 0 A1 A2 A3 A4 A5 C1 C2 C3 C4 N4 N5 O1 O2 O3 O4 O5 gender education age
0 61617 2.0 4.0 3.0 4.0 4.0 2.0 3.0 3.0 4.0 2.0 3.0 3.0 6 3.0 4.0 3.0 1 NaN 16
1 61618 2.0 4.0 5.0 2.0 5.0 5.0 4.0 4.0 3.0 5.0 5.0 4.0 2 4.0 3.0 3.0 2 NaN 18
2 61620 5.0 4.0 5.0 4.0 4.0 4.0 5.0 4.0 2.0 2.0 3.0 4.0 2 5.0 5.0 2.0 2 NaN 17
3 61621 4.0 4.0 6.0 5.0 5.0 4.0 4.0 3.0 5.0 4.0 1.0 3.0 3 4.0 3.0 5.0 2 NaN 17
4 61622 2.0 3.0 3.0 4.0 5.0 4.0 4.0 5.0 3.0 4.0 3.0 3.0 3 4.0 3.0 3.0 1 NaN 17

2800 rows × 29 columns

Ajuda

É sempre útil lembrar os mecanismos de se conseguir ajuda no python e no Jupyter. A função help do python é útil para se ver documentação sobre um tipo de variável ou uma bliblioteca importada. (Em ambos os casos a saída exibida está truncada.)

# ajuda sobre dictionaries
help(dict)
Help on class dict in module builtins:
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object’s
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
import math
help(math)
Help on module math:
FUNCTIONS
acos(x, /)
Return the arc cosine (measured in radians) of x.
acosh(x, /)
Return the inverse hyperbolic cosine of x.
asin(x, /)
Return the arc sine (measured in radians) of x.

O comando help() usado sem argumento abre uma janela de busca interativa do tópico de ajuda.

Além disso escrever o nome de uma biblioteca, método ou variável precedido de ? provocará a exibição da docstring relativa ao item, o que é uma boa forma de conferir uso e sintaxe.

import pandas as pd
?pd
Type: module
String form: <module ‘pandas’ from ‘/home/guilherme/.anaconda3/lib/python3.7/site-packages/pandas/__init__.py’>
File: ~/.anaconda3/lib/python3.7/site-packages/pandas/__init__.py
Docstring:
pandas – a powerful data analysis and manipulation library for Python
=====================================================================
**pandas** is a Python package providing fast, flexible, and expressive data
structures [… texto truncado …]

Células e Linhas Mágicas em Jupyter

Uma sintaxe especial dos notebooks consiste em inserir comandos iniciados por %% para “mágica” na célula inteira e % para “mágica” na linha. Por exemplo %matplotlib inline faz com que gráficos do matplotlib sejam renderizados dentro do próprio notebook. Os sinais % e %%indicam respectivamente “mágica” na linha ou na célula. Digitar %lsmagic na célula e executá-la exibirá uma lista de todos os comandos mágicos de célula e de linha, informando ainda se automagic está ativado. Se automagic = ON os prefixos %% e % são desnecessários.

Alguns exemplos de “mágicas”:

Mágica Efeito
%run Roda um script externo como parte da célula.
Ex.: %run meu_codigo.py
executa meu_codigo.py como parte da célula.
%timeit Conta os loops, mede e exibe o tempo de execução da célula.
%prun Mostra o tempo de execução de uma função.
%%writefile Salva o conteúdo da célula para um arquivo.
Ex.: %%writefile meu_output.py
salva o código da célula no arquivo meu_output.py.
%%pycat Lê e exibe o conteúdo de um arquivo.
Ex.: %%pycat meu_output.py
lê o conteúdo gravada antes em meu_output.py.
%macro Define uma macro para execução posterior.
%store Salva a variável para uso em outro notebook.
%pwd Exibe a pasta default de trabalho.
%who Exibe varáveis ativas.
%matplotlib inline Exibe gráficos matplotlib inline.
%lsmagic Exibe lista de comandos “mágicos”.
%automagic Liga/desliga automagica (necessidade de %).
%%javascript Roda a célula como código JavaScript.
%%html Exibe código html renderizado.
%pdb Aciona o Python Debugger.
%<comando>? Mostra ajuda sobre a %<comando>
%%script python2
import sys
print 'Esse comando foi executado no Python %s' % sys.version
# output---> Esse comando foi executado no Python 2.7.18 (default, data / hora) 
%%script python3
import sys
print('Comando executado no Python: %s' % sys.version)
# output---> Esse comando foi executado no Python 3.8.5 (default, data / hora) 
%%bash
echo "O conteúdo de minha variável BASH: $BASH"
# output---> O conteúdo de minha variável BASH: /usr/bin/bash
# Definição de fatorial usando recursão	
def fatorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
fatorial(40)      # resulta em 87178291200
# Claro que a mesma coisa seria obtida com a função
import math
print(math.factorial(14))    # 87178291200

Para medir o tempo de execução da célula ao rodar a função fatorial usamos %timeit

%timeit fatorial(14)

1.78 µs ± 16.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Executando comandos da SHELL

Usando o prefixo ! você pode enviar comandos diretamente para a shell de seu sistema operacional. Os comandos dependerão, claro, de seu sistema. No exemplo seguinte uso o bash do linux.

! ls *.ipynb     # vai listar todos os arquivos ipynb
! ls *.py        # lista meu_output.py gravado no exemplo anterior 

# mv é o comando bash para renomear arquivos
! mv meu_output.py novo_nome.py 
! ls *.py        # lista novo_nome.py

# Se você tem pip instalado pode gerenciar pacotes python de dentro do notebook:
!pip install --upgrade nome_do_pacote

Extensões do Jupyter Notebook


Extensões são recursos adicionais que estendem a funcionalidade dos Notebooks. Elas podem melhorar sua funcionalidade como uma IDE (um ambiente integrado de desenvolvimento), permitindo o acompanhamento de variáveis para fins de debugging, formatando o código automaticamente ou alterando sua aparência. Elas também permitem a inserção de widgets, que geralmente são objetos com representação gráfica no navegador, tais como caixas de texto, sliders e outras ferramentas interativas. Elas adicionam funcionalidades GUIs nos notebooks.

Uma extensão muito usada é a Nbextensions que pode ser instalada à partir do código seguinte, inserido no próprio notebook.

conda install -c conda-forge jupyter_contrib_nbextensions
conda install -c conda-forge jupyter_nbextensions_configurator 

A instalação de extensões pode variar de acordo com o seu ambiente de trabalho.

Jupyter Widgets

Widgets são objetos do python que possuem uma representação visual no navegador e permitem interação do usuário. Eles podem ser simples como uma caixa de texto ou um controle de arrastar, ou objetos sofisticados como os controles sobre uma tabela de dados ou sobre um mapa.

Slider é um widget útil para receber um valor do usuário por meio do mouse ou toque de tela. O objeto possui propriedades que podem ser alteradas e lidas, e métodos.
No exemplo abaixo um slider é criado, algumas de suas propriedades são ajustadas e depois é exibido.

import ipywidgets as ipw
# Inicializar um slider
slid = ipw.IntSlider()
slid.min = 0
slid.max = 50
slid.description = "Avalie:"
display(slid) # Exibe o slider ( figura a)

# O objeto pode ser inicializado com as propriedades desejadas
slid2 = ipw.IntSlider(
    value=0,
    min=0,
    max=10,
    step=2,
    description='Só pares:',
    disabled=False,
    continuous_update=True,
    orientation='horizontal',
    readout=True,
    readout_format='d'
)
display(slid2) # Exibe o slider ( figura b)

Button é um widget que pode armazenar interação do usuário em resposta binária (sim/não, por ex.).

ipw.Button (
    description='Clica aí',
    disabled=False,
    tooltip='clica...',
    button_style='success', # pode ser 'success', 'info', 'warning', 'danger' ou ''
    icon='check'
)
# Exibe o botão (figura c)

Text apresenta uma caixa de texto a ser preenchida pelo usuário:

ipw.Text (
    placeholder='Digite seu nome',
    description='Nome:',
)
# Exibe a caixa de texto ( figura d)

Progress Bar mostra uma barra de progresso:

ipw.IntProgress (
    min=0,
    max=10,
    value=7,
    description='Realizado %',
    bar_style='success', # pode ser 'success', 'info', 'warning', 'danger' ou ''
    orientation='horizontal'
)
# Exibe a barra de progresso ( figura e)

Para serem úteis as widgets devem interagir com o código. Como ex. vamos criar uma barra de progresso atribuindo o objeto a uma variável.

pb = ipw.IntProgress (
    min=0,
    max=10,
    value=7,
    description='Realizado%',
    bar_style='success', # pode ser 'success', 'info', 'warning', 'danger' ou ''
    orientation='horizontal'
)

print('valor inicial = ', pb.value) # value é uma propriedade de pb. Neste caso seu valor é 7

pb.value = 10                       # que pode ser alterada no código
display(pb)	                        # exibe uma barra de progesso cheia

No exemplo seguinte fazemos uma interação entre os valores da barra de progresso com o clique de dois botões. O código usa o evento on_click dos botões para acionar as funções que aumentam e diminuem o valor da barra.

def aumentaBarra(s):
    pb.value +=1

def diminuiBarra(s):
    pb.value -=1

botaoMais = ipw.Button(description='Aumenta barra')
botaoMais.on_click(aumentaBarra)

botaoMenos = ipw.Button(description='Diminue barra')
botaoMenos.on_click(diminuiBarra)
# display(botaoMenos, botaoMais, pb)
# -- isso exibiria os controles um sobre o outro

# Para exibir os controles em uma linha única com título
# usamos HBox, Label

from ipywidgets import HBox, Label
HBox([Label('Em uma linha única:'), botaoMenos, botaoMais, pb])         # exibe figura (f)

Existem widgets mais sofisticados para formatação dos controles, inclusive com o uso de html e formatação css. Apenas para mostrar um exemplo segue o código abaixo, que usa HBox para construir uma linha e VBox para construir uma coluna de controles.

from ipywidgets import HBox, VBox, Label	
linha1 = HTML('<h2 style="color: red;">Use controles para modificar <i>progress box</i> </h2>')
linha2 = HBox([Label('Botões de controle:'), botaoMenos, botaoMais])
linha3 = pb
VBox([linha1, linha2, linha3]) # exibe figura (g)

Um clique no primeiro botão faz a barra de progressa avançar, no segundo faz a barra regredir.

Observe importamos os controles HBox,VBox e Label de ipywidget e, portanto eles podem ser usados diretamente sem menção à biblioteca de origem. Poderíamos usar a notação ipw.HBox para usar a caixa horizontal, sem precisar da importação explícita.

Outras informações sobre formatação dos widgets em
Layout and Styling of Jupyter widgets
.

Outros Widgets Úteis

HTMLMath serve para exibir equações matemáticas:

equacao = ipw.HTMLMath(
    value = r"Widgets podem ser usados para exibir equações inline \(x^2\) e destacadas $$\frac{x^2-1}{x-1}= x+1$$",
    placeholder='HTML',
    description='MathML:',
)
display(equacao)
MathML: Widgets podem ser usados para exibir equações inline \(x^2\) e destacadas $$\frac{x^2-1}{x-1}= x+1$$

ipyleaflet é uma biblioteca para a criação de mapas interativos que permitem marcação, arraste e ampliação. Em muitos casos, para executar um biblioteca recém instalada, pode ser necessário reinicializar o kernel.

# A biblioteca pode ser instalada com condas:
conda install -c conda-forge ipyleaflet

from ipyleaflet import Map
# inserindo as coordenadas da Praça da Liberdade em Belo Horizonte, MG
Map(center=[-19.932252,-43.9381638], zoom=15)

BeakerX é um pacote com widgets destinados a representar tabelas, gráficos, formulários de modo interativo. O widget de tabela reconhece e exibe dataframes do pandas. Ele facilita a pesquisa, e permite classificar, arrastar, filtrar, formatar ou selecionar células na tabela. Ele também permite a exportação para CSV ou área de transferência e a representação gráfica dos dados. O widget de tabela é mostrado abaixo, em imagem estática. Mais informações em Beakerx.

# Instalação do pacote
conda install -c conda-forge beakerx ipywidgets

import pandas as pd
from beakerx import *
pd.read_csv("UScity.csv")
# Instalando o pacote
conda install -c conda-forge k3d	

import k3d
plot = k3d.plot()
plot += k3d.points([0, 0, 0, 1, 1, 1])
plot.display()

A figura dentro do Notebook é dinâmica, podendo ser girada, ampliada, exportada, etc.

Modificando o estilo do Notebook

Jupyter Notebooks são enviados para o navegador como páginas html e são formatadas e estilizadas por meio de arquivos css (cascade style sheets) padrões. Para quem conhece html e css pode ser interessante editar diretamente esse arquivo. (Não se esqueça de fazer cópias de segurança dos arquivos que vai modificar).

Se sua instalação não contém a pasta “.jupyter” execute o comando jupyter notebook --generate-config no terminal. No Linux o arquivo de estilos está em /home/usuario/.jupyter/custom/custom.css, no Windows em pasta.do.python\Lib\site-packages\notebook\static\custom\custom.css, embora isso possa ser alterado ou ser diferente para outras instalações. Para ver a pasta onde está o arquivo de configurações você pode usar:

import jupyter_core
jupyter_core.paths.jupyter_config_dir()

Existem muitas folhas de estilo prontas para baixar, por exemplo no GitHub. Elas podem ser baixadas e copiadas para a pasta citada.

Para modificar apenas o estilo do Notebook aberto, sem alterar a aparência dos demais você pode usar:

# Importe biblioteca 
from IPython.core.display import HTML
HTML("<style> instruções de estilo </style>")
# Alternativamente se pode usar "mágica" em uma célula
%%html "<style> estilos - CSS </style>"

# Por exemplo, para atribuir margens laterais de 10% do tamanho da página use
display(HTML("<style>.container { margin: 0 10% 0 10% !important; }<style>"))

# Para exibir outputs em negrito
display(HTML("<style>.output_wrapper { font-weight: bold !important; }</style>"))

De dentro de um Notebook você pode carregar uma folha de estilo particular que passa a valer para aquele documento. Esse método é útil para formatar documentos de um tipo específico, por exemplo para uma apresentação ou páginas com estilos incomuns.

from IPython.core.display import HTML
def css_styling():
    styles = open("../styles/custom.css", "r").read()
    return HTML(styles)
css_styling()

Finalmente você pode instalar extensões tais como Jupyter themes.

Exportando e Compartilhando Notebooks


Notebooks podem ser exportados para diversos formatos tais como HTML e PDF e vários outros formatos. Isso pode ser encontrado no menu File | Download as. Se estiver trabalhando na nuvem a importação no formato nativo .ipynb serve para baixar para seu computador uma cópia do notebook. Ao subir uma cópia para o GitHub ou para o Colab você pode disponibilizar a sessão para outros colaboradores. Slides são úteis para aulas e apresentações.

NBViewer: NBViewer é um renderizador de notebooks, útil para quem quer ver uma sessão sem ter que necessariamente instalar o Jupyter. Esse é um serviço gratuito oferecido pelo Projeto Jupyter, disponível em nbviewer.jupyter.org. Ele recebe uma URL do notebook e o renderiza como página da web.

Bibliografia

  • Wintjen, Marc: Practical Data Analysis Using Jupyter Notebook: Learn how to speak the language of data by extracting useful and actionable insights using Python, Packt Publishing, Birmingham, UK, 2020.
  • Taieb, David: Thoughtful Data Science, , Packt Publishing, Birmingham, UK, 2018.
  • Dataquest: Advanced Jupyter Notebooks Tutorial, acessado em novembro de 2020.
  • Real Python: Jupyter Notebook Introduction, acessado em novembro de 2020.
  • Jupyter.org: Jupyter Main Site, acessado em novembro de 2020.
  • jupyter.org: Jupyter Widgets, acessado em novembro de 2020.

Marcação de Texto com Markdown

O que é Markdown

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

Análise Fatorial Usando Python

🔻Final do artigo

Para dar um exemplo de análise de fatores usaremos o módulo factor_analyser do Python. Os dados usados são originados do Synthetic Aperture Personality Assessment (SAPA) que contém 25 questões de auto-avaliação pessoais disponíveis na web na página de Vincent Arel-Bundock, no Github.

SAPA e BFI

SAPA, Synthetic Aperture Personality Assessment, é um método usado para avaliar diferenças de personalidade individuais, muito utilizado para pesquisas online. O sujeito testado recebe um subconjunto aleatório dos itens em estudo com o objetivo de reunir grande volume de dados suficientes para a montagem de grandes matrizes de covariância (de relacionamento entre os dados verificados). O teste online foi desenvolvido por William Revelle e é mantido pela Northwestern University, Ilinois, EUA.

O teste consiste dos seguintes ítens:

A1: Sou indiferente aos sentimentos das outras pessoas.
A2: Sempre pergunto sobre o bem-estar dos outros.
A3: Sei como confortar os outros.
A4: Adoro crianças.
A5: Faço as pessoas se sentirem à vontade.
 
C1: Sou exigente no meu trabalho.
C2: Continuo minhas tarefas até que tudo esteja perfeito.
C3: Faço as coisas de acordo com um plano.
C4: Deixo tarefas semi-acabadas.
C5: Desperdiço meu tempo.
 
E1: Não falo muito.
E2: Tenho dificuldades para abordar outras pessoas.
E3: Sei como cativar as pessoas.
E4: Faço amigos facilmente.
E5: Assumo o controle das situações.
 

Os itens estão organizados por fatores esperados
(a serem verificados pela análise):
Agreeableness, (Amabilidade),
Conscientiousness, (Conscienciosidade),
Extroversion, (Extroversão),
Neuroticism, (Neuroticismo) e
Opennness, (Abertura).

N1: Fico com raiva facilmente.
N2: Irrito-me facilmente.
N3: Tenho alterações de humor frequentes.
N4: Muitas vezes me sinto triste.
N5: Entro em pânico facilmente.
 
O1: Sempre tenho muitas ideias.
O2: Evito leituras complexas.
O3: Procuro levar as conversas para um nível elevado.
O4: Passo algum tempo refletindo sobre as coisas.
O5: Nunca me detenho a avaliar um assunto profundamente.

A escala para respostas usada foi:
1. Totalmente falso
2. Moderadamente falso
3. Um pouco falso
4. Um pouco correto
5. Moderadamente correto
6. Totalmente correto

Diversos itens contribuem em grau maior ou menor para os fatores ou variáveis latentes.

 

O arquivo de respostas disponível foi baixado como o nome bfi.csv e salvo na pasta do projeto, subpasta ./dbs. Esse arquivo contém dados no formato *.csv (valores separados por vírgula) relativos a 2800 sujeitos com 3 campos adicionais de dados demográficos: sexo, educação e idade.

As questões demográficas estão codificadas da seguinte forma:
Gênero: Masculino = 1, Feminino = 2
Idade: a idade (em anos).
Educação:

  1. Nível médio incompleto,
  2. Nível médio completo,
  3. Nível superior incompleto,
  4. Nível superior completo,
  5. Pós-graduação.

Jupyter Notebook e convenções usadas

Você pode ler sobre Jupyter Notebook nessa página.

Jupyter Notebook é uma aplicação web e opensource que permite sessões colaborativas e documentos compartilhados contendo código que pode ser executado dentro da página, equações bem formatadas, visualização gráfica e texto narrativo que podem ser postas sob forma de apresentações ou usadas para desenvolvimento. Seu uso inclui tratamento, transformação e visualização de dados, simulações numéricas, modelagem estatística, machine learning entre outras aplicações.

O projeto será rodado em uma sessão do Jupyter Notebook. Nessa página usamos as seguintes convenções: células de código do Jupyter Notebook aparecem dentro de caixas como a exibida abaixo. Nos notebooks (como no Python) linhas iniciadas pelo sinal “#” são comentários. Apenas nessas páginas outputs simples e compactos podem aparecer como um comentário após o comando como mostrado abaixo (diferente do que ocorre nos notebooks). Outpus mais complexos aparecem em caixas separadas.

# Exemplo de exibição das células do Jupyter Notebook.
print('output simples')    # Esse comando imprime 'output simples'

# Outpus mais complexos aparecem em caixas separadas:
print('Outputs do Jupyter Notebook, gráficos e dataframes exibidos aparecem como nesse quadro...')
Outputs do Jupyter Notebook, gráficos e dataframes exibidos aparecem como nesse quadro…

Factor Analyser

Veja mais sobre a documentação do Factor Analyser nessa página.

Factor Analyser é um módulo desenvolvido em Python por Jeremy Biggs e Nitin Madnani, publicado em 2017 para realizar análise fatorial exploratória e confirmatória (AFE, AFC). As classes do pacote são compatíveis com a biblioteca scikit-learn. Partes do código são portadas da biblioteca psych do R.

Tratamento dos dados do bsi por meio do factor_analyser

# Instalação do módulo factor_analyzer dentro do ambiente Jupyter:
conda install -c ets factor_analyzer

# Importando bibliotecas (libraries) necessárias
import pandas as pd
import numpy as np
from factor_analyzer import FactorAnalyzer
import matplotlib.pyplot as plt

# A leitura do arquivo de dados para dentro de um dataframe (do pandas)
df = pd.read_csv('./dbs/bfi.csv')

# Renomear a primeira coluna (que está sem nome) para 'id'
df.rename(columns = {'Unnamed: 0':'id'}, inplace = True) 
print('A tabela importada contém %d linhas, %d colunas' % df.shape)
print('contendo as seguintes colunas:\n', df.columns)

# Para visualizar a tabela importada:
df.head()
A tabela importada contém 2800 linhas, 29 colunas
contendo as seguintes colunas:
Index([‘id’, ‘A1’, ‘A2’, ‘A3’, ‘A4’, ‘A5’, ‘C1’, ‘C2’, ‘C3’, ‘C4’, ‘C5’, ‘E1’,
‘E2’, ‘E3’, ‘E4’, ‘E5’, ‘N1’, ‘N2’, ‘N3’, ‘N4’, ‘N5’, ‘O1’, ‘O2’, ‘O3’,
‘O4’, ‘O5’, ‘gender’, ‘education’, ‘age’],
dtype=’object’)

id A1 A2 A3 A4 A5 C1 C2 C3 C4 N4 N5 O1 O2 O3 O4 O5 gender education age
0 61617 2.0 4.0 3.0 4.0 4.0 2.0 3.0 3.0 4.0 2.0 3.0 3.0 6 3.0 4.0 3.0 1 NaN 16
1 61618 2.0 4.0 5.0 2.0 5.0 5.0 4.0 4.0 3.0 5.0 5.0 4.0 2 4.0 3.0 3.0 2 NaN 18
2 61620 5.0 4.0 5.0 4.0 4.0 4.0 5.0 4.0 2.0 2.0 3.0 4.0 2 5.0 5.0 2.0 2 NaN 17
3 61621 4.0 4.0 6.0 5.0 5.0 4.0 4.0 3.0 5.0 4.0 1.0 3.0 3 4.0 3.0 5.0 2 NaN 17
4 61622 2.0 3.0 3.0 4.0 5.0 4.0 4.0 5.0 3.0 4.0 3.0 3.0 3 4.0 3.0 3.0 1 NaN 17

2800 rows × 29 columns

Como em qualquer outro uso de dados, principalmente quando importados de fontes externas, fazemos uma verificação de estrutura e completeza ou a existência de valores ausentes (NaN). Os dados demográficos são armazendos em outro dataframe enquanto a avaliação das questões em si são deixadas no dataframe df depois de eliminados os campos relativos a dados demográficos.

# Tabela dfDemografico armazena id, sexo, educação e idade
dfDemografico = df[['id', 'gender', 'education', 'age']]

# Colunas desnecessárias são eliminadas de df
df.drop(['id', 'gender', 'education', 'age'],axis=1,inplace=True)

# Possíveis dados ausentes são eliminados
df.dropna(inplace=True)

# Para verificar as colunas de df
df.head(2)
A1 A2 A3 A4 A5 C1 C2 C3 C4 C5 N1 N2 N3 N4 N5 O1 O2 O3 O4 O5
0 2.0 4.0 3.0 4.0 4.0 2.0 3.0 3.0 4.0 4.0 3.0 4.0 2.0 2.0 3.0 3.0 6 3.0 4.0 3.0
1 2.0 4.0 5.0 2.0 5.0 5.0 4.0 4.0 3.0 4.0 3.0 3.0 3.0 5.0 5.0 4.0 2 4.0 3.0 3.0

2 rows × 25 columns

# Uma visão geral dos dados no dataframe df pode ser vista:
df.info()
<class ‘pandas.core.frame.DataFrame’>
Int64Index: 2436 entries, 0 to 2799
Data columns (total 25 columns):
# Column Non-Null Count Dtype
—————————————————————————————
0 A1 2436 non-null float64
1 A2 2436 non-null float64
2 A3 2436 non-null float64
3 A4 2436 non-null float64
4 A5 2436 non-null float64
Grupos C, E, N omitidos
20 O1 2436 non-null float64
21 O2 2436 non-null int64
22 O3 2436 non-null float64
23 O4 2436 non-null float64
24 O5 2436 non-null float64
dtypes: float64(24), int64(1)
memory usage: 494.8 KB

Observamos que apenas o campo O2 tem tipo de variável int64. Apenas para ter todos os campos do mesmo tipo fazemos a conversão para float64.

# Converter o campo O2 em float
df['O2'] = df['O2'].astype(np.float64)

type(df['O2'][0])    # Agora o campo é do tipo numpy.float64

Considerando que em operações que faremos podemos perder o nome das colunas, vamos armazenar esses nomes em uma varável (que nesse caso é uma série).

itens=df.columns
print(itens)
Index([‘A1’, ‘A2’, ‘A3’, ‘A4’, ‘A5’, ‘C1’, ‘C2’, ‘C3’, ‘C4’, ‘C5’, ‘E1’, ‘E2’,
‘E3’, ‘E4’, ‘E5’, ‘N1’, ‘N2’, ‘N3’, ‘N4’, ‘N5’, ‘O1’, ‘O2’, ‘O3’, ‘O4’,
‘O5′],
dtype=’object’)

Estamos prontos para encontrar a matriz de correlação entre as variáveis. Cada célula dessa matriz mostra a correlação entre duas variáveis, listadas como labels das linhas e colunas. Por isso ele tem os valores da diagonal iguais a 1 (que é a correlação da variável consigo mesma). A matriz de correlação fornece uma visão geral de interrelacionamento dos dados e é usada como input para análises mais advançadas.

A correlação .corr é um método de dataframes do pandas. Por default o método corr usa os coeficientes de Pearson mas também pode usar os coeficientes Tau de Kendall ou coefficientes de Spearman.

# A matriz de correlação entre todas as respostas na tabela
corrMatriz = df.corr()

# Para ver apenas as correlações entre variáveis do grupo A
corrMatriz[["A1", "A2","A3", "A4","A5"]].head(5)
A1 A2 A3 A4 A5
A1 1.000000 -0.350905 -0.273636 -0.156754 -0.192698
A2 -0.350905 1.000000 0.503041 0.350856 0.397400
A3 -0.273636 0.503041 1.000000 0.384918 0.515679
A4 -0.156754 0.350856 0.384918 1.000000 0.325644
A5 -0.192698 0.397400 0.515679 0.325644 1.000000

Em seguida fazemos o gráfico de calor (heatmap) da matriz de correlação. Usamos a biblioteca seaborn para isso. Um heatmap associa uma cor a cada valor na matriz de correção. Tons mais escuros de azul (nesse caso) são valores mais perto de 1, tons mais claros são valores mais perto de -1.

import seaborn as sns
plt.figure(figsize=(12,12))
sns.set(font_scale=1)
sns.heatmap(corrMatriz, linewidths=.1, linecolor='#ffffff',
            cmap='YlGnBu', xticklabels=1, yticklabels=1)

A mera análise do gráfico de calor permite que algumas características da pesquisa sejam visualmente reconhecidas. Duas variáveis diferentes com índice de correlação muito alto podem ser, na verdade, a mesma variável escrita de forma diversa. Nesse caso o pesquisador pode preferir retirar uma delas. Uma ou mais variáveis com nível de correlação muito baixo com todas as demais podem indicar a medida de elementos isolados e fora de contexto com o modelo explorado. Nesse caso vemos agrupamentos claros entre as variáveis A2, A3, A4, A5 e todas as do grupo N, só para citar alguns exemplos.

Análise Fatorial

Análise Fatorial Exploratória, AFE

Podemos agora dar início ao uso específico da Análise Fatorial, começando pela Análise Fatorial Exploratória, AFE, usando o módulo factor_analyzer. O primeiro passo para isso é a avaliação da fatorabilidade dos dados. Isso significa que os dados coletados podem ser agrupados em fatores, que são as nossas variáveis ocultas com o poder de sintetizar e melhor descrever o objeto estudado. Para isso o módulo factor_analyzer oferece dois testes: o Teste de Bartlett e o Teste de Kaiser-Meyer-Olkin.

O Teste da esfericidade de Bartlett verifica se as variáveis estão correlacionadas entre si, comparando a matriz de correlação com a matriz identidade (que representaria variáveis completamente não correlacionadas).

# Importa o módulo que realiza o teste de Bartlett
from factor_analyzer.factor_analyzer import calculate_bartlett_sphericity
chi_square_value, p_value = calculate_bartlett_sphericity(df)
print('Teste da Esfericidade de Bartlett: chi² = %d,  p_value = %d' % (chi_square_value, p_value))
Teste da Esfericidade de Bartlett: chi2 = 18170.966350869272 p_value = 0.

No nosso caso o teste de Bartlett resulta em p-value = 0, o que indica que os dados podem ser fatorados e a matriz de correlação observada não é a identidade.

O Teste de Kaiser-Meyer-Olkin (KMO) fornece uma técnica de avaliação se os dados colhidos são apropriados para esta análise fatorial. Ele realiza um teste para cada variável observada e para o conjunto completo de variáveis. O resultado representa o grau em que cada variável observada pode ser predita, sem erros, pelas demais variáveis no conjunto de dados. KMO é uma estimativa da proporção de variância entre todas as variáveis. Os valores de KMO podem estar entre 0 e 1 e valores abaixo de 0.6 são consideredos inadequados.

# Importa calculate_kmo
from factor_analyzer.factor_analyzer import calculate_kmo
kmo_all,kmo_model = calculate_kmo(df)

print('Valores de kmo_all =\n', kmo_all, '\n')
print('KMO =', kmo_model)
Valores de kmo_all =
[0.75391928 0.8363196 0.87010963 0.87795367 0.90348747 0.84325413
0.79568263 0.85186857 0.82647206 0.86401687 0.83801873 0.88380544
0.89697008 0.87731273 0.89332158 0.77933902 0.78025018 0.86229919
0.88518467 0.86014155 0.85858672 0.78019798 0.84434957 0.77003158
0.76144469]KMO = 0.848539722194922

Todos os valores de kmo_all são superiores a 0,7 e o KMO geral é KMO = 0.8485 o que são considerados valores muito favoráveis para a análise dos fatores.

Prosseguimos criando uma instância do objeto factor_analysis, tentativamente com 5 fatores

# Criamos objeto factor_analysis, sem rotação e usando 5 fatores (tentativamente)
fa = FactorAnalyzer(5, rotation=None)

# Aplicamos o método fit (ajuste) desse objeto no dataframe
fa.fit(df)

# Depois desse ajuste podemos coletar os autovetores e autovalores
ev, v = fa.get_eigenvalues()
print('São ' + str(len(ev)) + ' autovalores:\n', ev)
São 25 eigenvalues:
[5.13431118 2.75188667 2.14270195 1.85232761 1.54816285 1.07358247
0.83953893 0.79920618 0.71898919 0.68808879 0.67637336 0.65179984
0.62325295 0.59656284 0.56309083 0.54330533 0.51451752 0.49450315
0.48263952 0.448921 0.42336611 0.40067145 0.38780448 0.38185679
0.26253902]

Usando os autovalores calculados traçamos um Screeplot que é um gráfico que lista os autovalores em ordem decrescente, usado para determinar o número de fatores a serem retidos em uma análise fatorial exploratória. O teste, introduzido por R.B. Cattell em 1966, sugere manter tantos fatores quantos forem as autovalores anteriores a uma “dobra mais acentuada” ou “cotovelo” no gráfico. Também é sugerido manter o mesmo número de fatores quantos autovalores existirem maiores que 1.

from bokeh.plotting import figure, output_notebook, show
output_notebook()

eixoX = range(1, len(ev)+1)   # de 1 0 26
eixoY = ev
p = figure(title="Scree Plot", x_axis_label='n-ésimo autovalor',y_axis_label='autovalor',
           x_range=[0,25], y_range=(0, 6), plot_width=600, plot_height=400,
           background_fill_color="#c9b2dd")

p.line(eixoX, eixoY, line_width=1, color = 'black')
p.circle(eixoX, eixoY, size=8, fill_color='red', color="black")

show(p)

Algumas críticas são dirigidas ao teste feito dessa forma pois ele insere uma decisão pouco objetiva. Mais de um cotovelo podem aparecer no gráfico. De qualquer forma, como veremos no presente caso, o bom senso e a análise posterior dos agrupamentos de fatores podem sugerir uma alteração nesse número.

Prosseguimos criando um objeto FactorAnalyzer com 6 fatores (tentativamente) e usando o método de rotação varimax.

# 6 fatores
fa = FactorAnalyzer( 6, rotation="varimax")

# o objeto tem o método fit para análise do dataframe
fa.fit(df)

# Desse extraimos as cargas fatoriais (factor loadings)
# Observe que fa.loadings_ é um numpy.array com shape (25,6). Usamos o método
# do pandas pd.DataFrame.from_records para convertê-lo em um dataframe
factorLoadings = pd.DataFrame.from_records(fa.loadings_)

# Para ver a dataframe gerado:
factorLoadings.head(4)
0 1 2 3 4 5
0 0.095220 0.040783 0.048734 -0.530987 -0.113057 0.161216
1 0.033131 0.235538 0.133714 0.661141 0.063734 -0.006244
2 -0.009621 0.343008 0.121353 0.605933 0.033990 0.160106
3 -0.081518 0.219717 0.235140 0.404594 -0.125338 0.086356

Vemos que os nomes dos itens, de A1 até O5, foram perdidos no cálculo. Vamos renomear tanto esses itens quanto os nomes das colunas (que são os fatores) para ter uma visualização mais clara do que obtivemos até aqui:

# Substitue as linhas pelo nomes dos itens
factorLoadings.index=itens

# Renomeia as colunas
factorLoadings.rename(columns = {0:'Fator 1',
                                 1:'Fator 2',
                                 2:'Fator 3',
                                 3:'Fator 4',
                                 4:'Fator 5',
                                 5:'Fator 6'}, inplace = True)

# Exibe o resultado
factorLoadings
Fator 1 Fator 2 Fator 3 Fator 4 Fator 5 Fator 6
A1 0.095220 0.040783 0.048734 -0.530987 -0.113057 0.161216
A2 0.033131 0.235538 0.133714 0.661141 0.063734 -0.006244
A3 -0.009621 0.343008 0.121353 0.605933 0.033990 0.160106
A4 -0.081518 0.219717 0.235140 0.404594 -0.125338 0.086356
A5 -0.149616 0.414458 0.106382 0.469698 0.030977 0.236519
C1 -0.004358 0.077248 0.554582 0.007511 0.190124 0.095035
C2 0.068330 0.038370 0.674545 0.057055 0.087593 0.152775
C3 -0.039994 0.031867 0.551164 0.101282 -0.011338 0.008996
C4 0.216283 -0.066241 -0.638475 -0.102617 -0.143846 0.318359
C5 0.284187 -0.180812 -0.544838 -0.059955 0.025837 0.132423
E1 0.022280 -0.590451 0.053915 -0.130851 -0.071205 0.156583
E2 0.233624 -0.684578 -0.088497 -0.116716 -0.045561 0.115065
E3 -0.000895 0.556774 0.103390 0.179396 0.241180 0.267291
E4 -0.136788 0.658395 0.113798 0.241143 -0.107808 0.158513
E5 0.034490 0.507535 0.309813 0.078804 0.200821 0.008747
N1 0.805806 0.068011 -0.051264 -0.174849 -0.074977 -0.096266
N2 0.789832 0.022958 -0.037477 -0.141134 0.006726 -0.139823
N3 0.725081 -0.065687 -0.059039 -0.019184 -0.010664 0.062495
N4 0.578319 -0.345072 -0.162174 0.000403 0.062916 0.147551
N5 0.523097 -0.161675 -0.025305 0.090125 -0.161892 0.120049
O1 -0.020004 0.225339 0.133201 0.005178 0.479477 0.218690
O2 0.156230 -0.001982 -0.086047 0.043989 -0.496640 0.134693
O3 0.011851 0.325954 0.093880 0.076642 0.566128 0.210777
O4 0.207281 -0.177746 -0.005671 0.133656 0.349227 0.178068
O5 0.063234 -0.014221 -0.047059 -0.057561 -0.576743 0.135936

Vamos montar mais um heatmap com essa tabela.

# A bibioteca seaborn já foi importada como sns
plt.figure(figsize=(8,6))
sns.set(font_scale=.9)
sns.heatmap(factorLoadings,  linewidths=1, linecolor='#ffffff', cmap="YlGnBu", xticklabels=1, yticklabels=1)

Lembrando que as cores mais escuras indicam correlação direta e as mais claras correlação inversa, percebemos que existem cargas mais fortes entre os itens N1, N2, N3, N4 e N5 com o fator 1, E1 até E5 no fator 2, etc. Nenhum dos itens, no entanto, tem carga relevante no sexto fator. Isso indica que podemos refazer o cálculo de cargas fatoriais com apenas 5 fatores.

# Refazendo o cáculo com 5 fatores apenas
# Apaga a variável fa
del fa

fa = FactorAnalyzer( 5, rotation="varimax")
fa.fit(df)
factorLoadings = pd.DataFrame.from_records(fa.loadings_)

# Renomeia itens
factorLoadings.index=itens

# Renomeia as colunas (fatores)
factorLoadings.rename(columns = {0:'Fator 1',
                                 1:'Fator 2',
                                 2:'Fator 3',
                                 3:'Fator 4',
                                 4:'Fator 5'}, inplace = True)

# Exibe o resultado
factorLoadings
Fator 1 Fator 2 Fator 3 Fator 4 Fator 5
A1 0.111126 0.040465 0.022798 -0.428166 -0.077931
A2 0.029588 0.213716 0.139037 0.626946 0.062139
A3 0.009357 0.317848 0.109331 0.650743 0.056196
A4 -0.066476 0.204566 0.230584 0.435624 -0.112700
A5 -0.122113 0.393034 0.087869 0.537087 0.066708
C1 0.010416 0.070184 0.545824 0.038878 0.209584
C2 0.089574 0.033270 0.648731 0.102782 0.115434
C3 -0.030855 0.023907 0.557036 0.111578 -0.005183
C4 0.240410 -0.064984 -0.633806 -0.037498 -0.107535
C5 0.290318 -0.176395 -0.562467 -0.047525 0.036822
E1 0.042819 -0.574835 0.033144 -0.104813 -0.058795
E2 0.244743 -0.678731 -0.102483 -0.112517 -0.042010
E3 0.024180 0.536816 0.083010 0.257906 0.280877
E4 -0.115614 0.646833 0.102023 0.306101 -0.073422
E5 0.036145 0.504069 0.312899 0.090354 0.213739
N1 0.786807 0.078923 -0.045997 -0.216363 -0.084704
N2 0.754109 0.027301 -0.030568 -0.193744 -0.010304
N3 0.731721 -0.061430 -0.067084 -0.027712 -0.004217
N4 0.590602 -0.345388 -0.178902 0.005886 0.075225
N5 0.537858 -0.161291 -0.037309 0.100931 -0.149769
O1 -0.002224 0.213005 0.115080 0.061550 0.504907
O2 0.175788 0.004560 -0.099729 0.081809 -0.468925
O3 0.026736 0.310956 0.076873 0.126889 0.596007
O4 0.220582 -0.191196 -0.021906 0.155475 0.369012
O5 0.085401 -0.005347 -0.062730 -0.010384 -0.533778

Construimos o heatmap com essa tabela de 5 fatores.

plt.figure(figsize=(8,6))
sns.set(font_scale=.9)
sns.heatmap(factorLoadings,  linewidths=1, linecolor='#ffffff', cmap="YlGnBu", xticklabels=1, yticklabels=1)
Os retângulos de borda
preta indicando grupos
de correlação foram
acrescentados manualmente.

Pelo heatmap percebemos que o grupo de itens N está associado ao fator 1 (Neuroticismo), E ao fator 2 (Extroversão), C ao fator 3 (Conscienciosidade), A ao fator 4 (Amabilidade) e O ao fator 5 (Abertura), previamente identificados. É claro que essa identificação do fator foi realizada pelos pesquisadores no caso dessa pesquisa em particular. Para uma pesquisa nova seria necessário um estudo para o entendimento da natureza de cada fator.

Observe ainda que correlação negativa é correlação. É o que ocorre, por exemplo entre os itens A1 (Sou indiferente aos sentimentos das outras pessoas) e A2 (Sempre pergunto sobre o bem-estar dos outros). A correlação entre eles pode ser obtida da matriz de correlação, corrMatriz['A1']['A2'] = -0.35091.

Observamos que existem as seguintes correspondências entre os grupos de questões e os fatores propostos:

Fator Grupo Descrição
1 N Neuroticismo
2 E Extroversão
3 C Conscienciosidade
4 A Amabilidade
5 O Abertura

Vamos, portanto, renomear as colunas de nossa matriz de cargas fatoriais para refletir esse entendimento:

# Renomeia as colunas (fatores)
factorLoadings.rename(columns = {'Fator 1':'Neuroticismo',
                                 'Fator 2':'Extroversão',
                                 'Fator 3':'Conscienciosidade',
                                 'Fator 4':'Amabilidade',
                                 'Fator 5':'Abertura'}, inplace = True)

# Exibe o resultado (só duas linhas)
factorLoadings.head(2)	
Neuroticismo Extroversão Conscienciosidade Amabilidade Abertura
A1 0.111126 0.040465 0.022798 -0.428166 -0.077931
A2 0.029588 0.213716 0.139037 0.626946 0.062139

Comunalidades

Comunalidades são a soma das cargas fatoriais ao quadrado de cada variável medida. Denotando por \(l_{ij}\) os elementos da matriz da cargas fatoriais a comunalidade da i-ésima variável é \(h_i^2\) dado por
$$
h_i^2 =\Sigma_{j=1}^n l_{ij}^2
$$
Por exemplo, a comunalidade relativa à questão A1 é a soma dos elementos (ao quadrado) da primeira linha da matriz de cargas fatoriais acima:

(0.111126)**2 + (0.040465)**2 + (0.022798)**2 + (-0.428166)**2 +(-0.077931)**2
0.203905517222

As comunalidades relativas a todas as variáveis podem ser obtidas com get_communalities() que retorna um numpy.ndarray com dimensões (25,):

fa.get_communalities()
array([0.20390517, 0.46280338, 0.53969218, 0.30190473, 0.47002029,
0.34839471, 0.45387181, 0.32428892, 0.47669926, 0.43538283,
0.34780933, 0.545502 , 0.44105495, 0.54125654, 0.40714621,
0.68139838, 0.60800298, 0.54447487, 0.50580328, 0.34931564,
0.31733902, 0.26745151, 0.47464268, 0.2460347 , 0.29628368])

A soma de todos os valores de comunalidade é o valor de comunalidade total:

fa.get_communalities().sum()
10.590479059488883

Para exibir uma tabela com os nomes da variáveis e suas respectivas comunalidades vamos construir um dataframe contendo esses dados. Lembrando que já temos a variável itens = ['A1', 'A2', ..., 'O4','O5']:

dfComunalidades = pd.DataFrame(comunalidades)
dfComunalidades.index = itens
Variável Comunalidade
A1 0.203905
A2 0.462803
A3 0.539692
A4 0.301905
A5 0.470020
C1 0.348395
C2 0.453872
C3 0.324289
C4 0.476699
C5 0.435383
Variável Comunalidade
E1 0.347809
E2 0.545502
E3 0.441055
E4 0.541257
E5 0.407146
N1 0.681398
N2 0.608003
N3 0.544475
N4 0.505803
N5 0.349316
Variável Comunalidade
O1 0.317339
O2 0.267452
O3 0.474643
O4 0.246035
O5 0.296284
 
 
Total 10.5905
Como temos 25 fatores:
Total/25 0.4236

Podemos pensar na comunalidade de uma variável como a proporção de variação nessa variável explicada pelos fatores propostos no modelo. Por exemplo, a variável N1 tem a maior comunalidade (0.681398) nesse modelo, indicando que aproximadamente 69% da variação nas respostas para “N1: Fico com raiva facilmente” é explicada pelo modelo de 5 fatores proposto enquanto esse valor é de apenas 20% para “A1: Sou indiferente aos sentimentos das outras pessoas”.

Comunalidades servem para avaliar o desempenho do modelo. Valores mais próximos de um indicam que o modelo explica a maior parte da variação para essas variáveis. Nesse caso o modelo está melhor ajustado para as variáveis do grupo N (neuroticismo)​ e menos eficiente para as variáveis do grupo O (abertura)​.

A Comunalidade total é de 10.5905 que, dividido entre as 25 variáveis indica uma média de 10.5905/25 = 0.4236 geral para o modelo, ou seja, uma eficiência média de 42% do modelo em explicar a variação de cada variável do teste.

🔺Início do artigo

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

Linguagem de Consulta SQL

Definições

Banco de dados relacional é um banco de dados digital baseado no modelo relacional proposto por E. F. Codd em 1970. Sistema de software usados para construir e manter bancos de dados relacionais são chamados Sistema de Gerenciamento de Banco de Dados Relacionais (RDBMS).

SQL, (Structured Query Language) ou Linguagem de Consultas Estruturada é uma linguagem de programação usada para manipular de bancos de dados relacionais. Usando SQL é possível construir o BD, estabelecer relações entre dados nas tabelas, fazer consultas, inserir, apagar ou editar dados.

Um banco de dados consiste em várias tabelas e das relações predefinidas entre elas. Cada tabela contém colunas ou campos, cada uma delas com seu nome exclusivo e tipos de dados definido. Elas podem ter atributos que definem a funcionalidade da coluna (se é uma chave primária, se há um valor default, etc.). As linhas da tabela, ou registros, contêm os dados.

Para que serve a SQL?

Consultas SQL podem ser feitas dentro de diversos aplicativos tais como em suites MS Office, em particular no MS Access, e seus equivalentes open source. Elas também são frequentes em programas de gerenciamento de banco de dados, Business Inteligence e análises de dados tais como Qlikview e MS PowerBI. A maior parte dos sistemas de gerenciamento de conteúdo usados em sites na Internet, como WordPress e Joomla usam bancos de dados controlados por SQL.

As diversas linguagens de programação fornecem interfaces com as diversas variantes de bancos de dados SQL. Finalmente você pode instalar um Sistema Gerenciador de Banco de Dados (DBMS) em seu computador, seja ele um servidor ou sua desktop pessoal. Estes sistemas estão disponíveis em diversos sistemas operacionais. Os DBMS mais populares são: SQLite, MySQL, PostgreSQL, LibreOffice Base (todos eles open source) e Microsoft Access, SQL Server, FileMaker, Oracle (proprietários).

Comandos e instruções do SQL

Uma escola pode manter um banco de dados com informações sobre alunos, professores, funcionários, disciplinas lecionadas, salas de aulas, e a descrição de relacionamentos entre eles. Segue um exemplo simples de uma tabela de em banco de dados contendo o dados (simplificados e fictícios) de alunos. A primeira linha, listada em negrito, contém os nomes das colunas da tabela:

Tabela (1): Alunos
Matricula Nome Sobrenome email Nascimento Fone
734236 João Santos joao@yahoo.com 02-04-1998 61 123455667
789234 George Pereira george@gmail.com 04-04-2000 41 345678987
654987 Paula Torres ptorres@globo.com 25-01-2004 31 987854543
765098 Marcos Melo mamelo@gmail.com 25-10-2004 31 987843231

Nessa tabela Matricula é um campo numérico, Nome, Sobrenome, email e Fone são campos de strings, Nascimento é um campo de datas.

SELECT

A instrução SELECT é usada para recuperar (ler e retornar) dados de uma tabela. Ela tem a seguinte sintaxe geral:

SELECT Coluna1, ..., Colunan FROM Tabela1
SELECT * FROM Tabela1

A primeira linha retorna todos os registros da Tabela1, da Coluna1, …, Colunan, sem qualquer critério de seleção. A segunda retorna todos os campos da Tabela1 (* substitui a lista de todos os campos). A declaração explícita de quais campos se quer usar torna a consulta mais eficiente (rápida).

Por exemplo:

-- Para retornar todos os Nomes e Sobrenomes da tabela
SELECT Nome, Sobrenome FROM Alunos
Tabela (2):
Nome Sobrenome
João Santos
George Pereira
Paula Torres
Marcos Melo

O sinal -- inicia um comentário em SQL, uma parte da instrução que será ignorada. Comandos SQL podem ser em maiúsculas ou minúscula, embora seja costume usar letras maiúsculas.

Cláusula WHERE

A Cláusula WHERE é uma modificação da consulta com SELECT especificando condições de retorno. Ela restringe os dados retornados para apenas aqueles satisfeitos pela cláusula. Por exemplo, supondo que o campo matrícula seja numérico:

SELECT Nome, Sobrenome, email FROM Alunos WHERE Matricula = 654987

retorna

Tabela (3):
Nome Sobrenome email
Paula Torres ptorres@globo.com

Ou

SELECT Matricula, email FROM Alunos WHERE Nome = 'Marcos'

retorna

Tabela (4):
Matricula email
765098 mamelo@gmail.com

Os seguintes operadores de comparação podem ser usados com WHERE: = (igual, usado acima), <> (diferente),
> (maior que), >= (maior ou igual), < (menor que), =< (menor ou igual),
LIKE (similar), BETWEEN (define uma faixa).

SELECT Matricula, Nome, Sobrenome FROM Alunos WHERE Matricula > 740000
Tabela (5):
Matricula Nome Sobrenome
789234 George Pereira
765098 Marcos Melo
SELECT Matricula, Nome, Sobrenome FROM Alunos WHERE Nascimento <> '25-01-2004'
Tabela (6):
Matricula Nome Sobrenome
734236 João Santos
789234 George Pereira

O mesmo procedimento é usado para os demais operadores.

O Operador LIKE pode ser usado junto com %, um wildcard ou coringa que representa qualquer string (um ou mais caracteres). Ele pode ser posto em qualquer lugar, quantas vezes for necessário.

SELECT * FROM Alunos WHERE Nome LIKE 'PA%'
-- Nomes que começam com 'PA'
Tabela (7):
Matricula Nome Sobrenome email Nascimento Fone
654987 Paula Torres ptorres@globo.com 25-01-2004 31 987854543

O Operador BETWEEN possui sintaxe um pouco diferente para cada RDBMS. Em geral é algo do tipo:

SELECT * FROM Alunos WHERE Nascimento BETWEEN '01-01-2002' AND '01-01-2005'
-- Nascidos no intervalo
Tabela (8):
Matricula Nome Sobrenome email Nascimento Fone
654987 Paula Torres ptorres@globo.com 25-01-2004 31 987854543
765098 Marcos Melo mamelo@gmail.com 25-01-2004 31 987843231

O coringa _ representa um único caracter e [] uma faixa de valores. Por exemplo, a consulta seguinte retorna todos os registros onde Fone começa com 3, 4, 5 ou 6 e tem qualquer segundo dígito. No caso de nossa tabela Alunos seriam todos os registros.

SELECT * FROM Alunos WHERE Fone LIKE '[3-6]_%'

SELECT DISTINCT

Se você quiser obter valores únicos de uma tabela, sem repetições, use a cláusula DISTINCT.

SELECT DISTINCT Nascimento FROM Alunos 
Tabela (9):
Nascimento
02-04-1998
04-04-2000
25-01-2004

ORDER BY

A cláusula ORDER BY é usada junto com SELECT para ordenar os resultados de uma consulta. Ela tem a seguinte sintaxe geral:

SELECT campo1, ..., campon FROM Tabela1 ORDER BY (lista de campos)

Por exemplo:

-- Para retornar todos os Nomes e Sobrenomes da tabela, em ordem de Nome
SELECT Nome, Sobrenome FROM Alunos ORDER BY Nome
Tabela (10):
Nome Sobrenome
George Pereira
João Santos
Marcos Melo
Paula Torres

ORDER BY pode ser usada com os modificadores ASC ou DESC, para produzir a lista em ordem crescente ou descendente. ASC é o default e não precisa ser especificado. Para obter a mesma lista anterior em ordem descendente no sobrenome:

-- Para retornar todos os Nomes e Sobrenomes da tabela, em ordem de Nome
SELECT Nome, Sobrenome FROM Alunos ORDER BY Sobrenome DESC
Tabela (11):
Nome Sobrenome
Paula Torres
João Santos
George Pereira
Marcos Melo

TOP

A cláusula TOP é usada junto com SELECT e, geralmente com ORDER BY para selecionar apenas um número fixo de resultados retornados por uma consulta. Ela tem a seguinte sintaxe geral:

SELECT TOP número| % campo1, ..., campon FROM Tabela1 ORDER BY (lista de campos)

Por exemplo:

-- Para retornar os dois últimos Nomes da tabela, em ordem de Nome
SELECT TOP 2 Nome, Sobrenome FROM Alunos ORDER BY Nome DESC
Tabela (12):
Nome Sobrenome
Paula Torres
Marcos Melo

Para ver 10% dos primeiros registros de uma lista podemos usar:

SELECT TOP 10% * FROM Tabela ORDER BY campo

Operadores lógicos AND e OR

Mais de uma condição podem ser anexadas à cláusula WHERE usando os operadores AND e OR.

SELECT * FROM Alunos WHERE Matricula > 700000 AND Fone LIKE '31%'
Tabela (13):
Matricula Nome Sobrenome email Nascimento Fone
765098 Marcos Melo mamelo@gmail.com 25-10-2004 31 987843231
SELECT * FROM Alunos WHERE Matricula > 700000 OR Sobrenome = 'Torres'

Na última consulta todos os registros serial retornados.

Condições mais complexas podem ser expressas usando-se parênteses.

SELECT Matricula, Nome, Sobrenome FROM Alunos
   WHERE (Nome = 'George' OR Nome = 'Paula') AND Sobrenome = 'Pereira'
Tabela (14):
Matricula Nome Sobrenome
789234 George Pereira

Operador lógico IN

O operador IN é usado junto com WHERE para selecionar um campo com valor dentro de um conjunto de valores discretos. A sintaxe é

SELECT campo1, ..., campon
   FROM Tabela
   WHERE campo1 IN (valor1, ..., valorr)
SELECT * FROM Alunos WHERE Matricula IN (654987, 765098)
Tabela (15):
Matricula Nome Sobrenome
654987 Paula Torres
765098 Marcos Melo

SELECT INTO

A instrução SELECT INTO é usada para selecionar registros e campos de uma tabela e copiar o resultado retornado em uma nova tabela.

SELECT Coluna1, ..., Colunan INTO Tabela2 FROM Tabela1	WHERE <condições>

A Tabela2 será criada com os mesmos campos e relacionamentos da tabela inicial. Alguns casos são listados a seguir:

-- Faça uma cópia backup de Alunos
SELECT * INTO AlunosBackup FROM ALunos;

-- Faça uma cópia backup de Alunos cujo nome começa com 'Pa'
SELECT * INTO AlunosBackup FROM ALunos WHERE Nome LIKE 'PA%';

-- Faça uma cópia backup de Alunos em outro banco de dados (BDCopia)
SELECT * INTO AlunosBackup IN 'BDCopia' FROM ALunos;

-- Cria tabela vazia novoAlunos com estrutura idêntica a de Alunos
SELECT * INTO novoAlunos FROM Alunos WHERE 1 = 0;

INSERT INTO

A instrução INSERT INTO é usada para inserir novos registros em uma tabela. Ele pode ser usado em dois formatos:

INSERT INTO Tabela1 VALUES (valor1, ..., valorn)
-- ou
INSERT INTO Tabela1 (campo1, ..., campon)  VALUES (valor1, ..., valorn)

No primeiro caso \(n\), o número de valores inseridos deve ser igual ao número de campos da tabela e devem estar na ordem default. No segundo caso a ordem pode ser alterada mas campon) deve corresponder à valorn. Em ambos os casos o tipo de dado do campo deve ser respeitado. Por exemplo: as seguintes instruções aplicadas sobre a tabela Alunos:

-- Inserindo todos os campos
INSERT INTO Alunos VALUES (854254, 'João', 'Alves', 'jalves@yahoo.com', '15-03-2004', '31 885466112')
-- Inserindo alguns campos
INSERT INTO Alunos (Matricula, Nome, Sobrenome) VALUES (785294, 'Marta', 'Soares')

alteraria a tabela para

Tabela (16):
Matricula Nome Sobrenome email Nascimento Fone
734236 João Santos joao@yahoo.com 02-04-1998 61 123455667
789234 George Pereira george@gmail.com 04-04-2000 41 345678987
654987 Paula Torres ptorres@globo.com 25-01-2004 31 987854543
765098 Marcos Melo mamelo@gmail.com 25-01-2004 31 987843231
854254 João Alves jalves@yahoo.com 15-03-2004 31 885466112
785294 Marta Soares

Os valores de campos não fornecidos na última instrução ficam nulos (null, inexistência de valor) ou assumem um valor default definido na construção da estrutura da tabela.

UPDATE

A instrução UPDATE é usada para alterar registros já inseridos em uma tabela. Ela tem a sintax geral:

UPDATE Tabela1
   SET campo1 = valor1, ..., campon = valorn
   WHERE <condições>

O formato acima mostra que podemos quebrar as linhas de uma instrução SQL para torná-la mais legível. A cláusula WHERE <condições> limita quais os registros serão alterados. Sem ela todos os registros (todas as linhas da tabela) seriam alterados.

Por exemplo, podemos completar o registro relativo à aluna Marta em nossa tabela:

UPDATE Alunos
   SET Sobrenome = 'Alves', email = 'marta123@yahoo.com', Nascimento = '14-03-2001', fone = '21 956855441'
   WHERE Matricula = 785294
-- Para ver o resultado (os demais registros ficam inalterados)
SELECT * FROM Alunos WHERE Matricula = 785294

O resultado seria a tabela:

Tabela (17):
Matricula Nome Sobrenome email Nascimento Fone
785294 Marta Alves marta123@yahoo.com 14-03-2001 21 956855441

Novamente, se não tivéssemos especificado a condição Matricula = 785294 todos os registros, de todos os alunos seriam alterados.

Suponha que, por algum motivo, a escola tenha decido alterar o padrão de numeração das matrículas acrescentando o dígito 1 à esquerda de todas as matrículas. Isso seria o mesmo que somar 1000000 à todas as matrículas. Podemos conseguir isso com a seguinte operação:

UPDATE Alunos SET Matricula = Matricula + 1000000
-- Para ver o resultado (os demais campos ficam inalterados)
SELECT Matricula FROM Alunos
Tabela (18):
Matricula
1734236
1789234
1654987
1765098
1854254
1785294

DELETE

A instrução DELETE permite o apagamento de registros em uma tabela. Ela tem a sintax geral:

DELETE FROM Tabela1 WHERE <condições>

O formato acima mostra que podemos quebrar as linhas de uma instrução SQL para torná-la mais legível. A cláusula WHERE <condição> limita quais os registros serão apagados. Sem ela todos os registros (todas as linhas da tabela) seriam apagadas.

Por exemplo, podemos apagar os registros relativos aos alunos com sobrenome “Alves” de nossa nossa tabela:

DELETE FROM Alunos WHERE Sobrenome = 'Alves'

Dois alunos seriam removidos da tabela que ficaria assim:

Tabela (19):
Matricula Nome Sobrenome email Nascimento Fone
1734236 João Santos joao@yahoo.com 02-04-1998 61 123455667
1789234 George Pereira george@gmail.com 04-04-2000 41 345678987
1654987 Paula Torres ptorres@globo.com 25-01-2004 31 987854543
1765098 Marcos Melo mamelo@gmail.com 25-01-2004 31 987843231

Se não tivéssemos especificado uma condição para o apagamento todos os registros seriam apagados. A linha abaixo apagaria todos os registros da tabela Alunos:

DELETE FROM Alunos

A tabela e sua estrutura continuaria existindo.

Aliases

Aliases (nomes alternativos) são usados para simplificar uma consulta. Nossa tabela de exemplo é uma tabela pequena e simples. Na prática os bancos de dados e tabelas podem conter muitos campos. A possibilidade de renomear tabelas e campos pode ser muito útil, principalmente quando a consulta envolve mais de uma tabela e a consulta se refere às tabelas e campos mais de uma vez.

Por exemplo considerando que nossa tabela está no estado da Tabela (19) a consulta

SELECT Matricula, Nome + ', ' + Sobrenome AS NomeCompleto FROM Alunos

resulta em

Tabela (20):
Matricula NomeCompleto
1734236 João Santos
1789234 George Pereira
1654987 Paula Torres
1765098 Marcos Melo

Aqui foi feita uma concatenação das strings Nome + Sobrenome e o resultado renomeado como NomeCompleto.

Quando usamos várias tabelas de um banco de dados pode ocorrer que mais de uma delas tenha um campo com o mesmo nome. Nesse caso é obrigatória descriminar a que tabela nos referimos. A mesma consulta acima pode ser colocada na seguinte forma, com o mesmo resultado:

SELECT a.Matricula, a.Nome + ', ' + a.Sobrenome AS NomeCompleto FROM Alunos a

Aqui a tabela Alunos ganhou o alias a. a.Matricula se refere ao campo Matricula da tabela Alunos.

Agrupamentos e funções de grupos

Vamos acrescentar novas tabelas para considerar os agrupamentos. Suponha que a escola possui 4 funcionários identificados por um id único (um número de indentificação). Uma tabela armazena a relação entre id e nome (nome do funcionário). Outras tabela contém o número de horas trabalhadas por dia, para cada funcionário.

Tabela (21): Horas_trabalhadas
id dia horas
36 ’01-03-2019′ 6
41 ’01-03-2019′ 8
48 ’01-03-2019′ 2
58 ’01-03-2019′ 8
36 ’02-03-2019′ 5
41 ’02-03-2019′ 8
48 ’02-03-2019′ 1
58 ’02-03-2019′ 4
Tabela (22): Funcionarios
id Nome
36 Mariana Goulart
41 Tânia Ferreira
48 Humberto Torres
58 Francisco Pedroso

Diversas operações são permitidas sobre as linhas de uma tabela. Em particular

Instrução Efeito
GROUP BY Agrupa registros por valores do campo
Função Efeito
COUNT Conta o número de ocorrências do campo
MAX Fornece o valor máximo do campo
MIN Fornece o valor mínimo do campo
AVG Fornece a média dos valores do campo
SUM Fornece a soma dos valores do campo

Por exemplo, para calcular o número de horas trabalhadas por todos os funcionários podemos usar a consulta

SELECT SUM(horas) as soma FROM Horas_trabalhadas

que resulta em um único registro para um único campo:

Tabela (23):
soma
42

Para calcular o número de horas trabalhadas por cada funcionário fazemos a soma das horas com os campos de horas agrupados por cada funcionário.

SELECT id, SUM(horas) as soma
   FROM Horas_trabalhadas
   GROUP BY id
Tabela (24): Horas_trabalhadas
id horas
36 11
41 16
48 3
58 12

A consulta a seguir mostra o cálculo da média de horas trabalhadas por funcionário e de quantos dias cada um trabalhou.

SELECT id, AVG(horas) as media, COUNT(id) as numDias
   FROM Horas_trabalhadas
   GROUP BY id
Tabela (25): Média e número de dias trabalhados
id media numDias
36 5.5 2
41 8 2
48 1.5 2
58 6 2

Cláusula HAVING

A cláusula HAVING é usada para se estabelecer critérios sobre valores obtidos em funções agregadas. No SQL não é permitido usar WHERE para restringir resultados de uma consulta agregada. A consulta seguinte resultaria em erro:

SELECT id, SUM (horas)
   FROM Horas_trabalhadas
   WHERE SUM (horas) > 11   -- Isso geraria um erro
   GROUP BY id

Para esse efeito usamos HAVING, uma forma de se especificar condições sobre o resultado de uma função agregada.

SELECT id, SUM (horas) as soma
   FROM Horas_trabalhadas
   GROUP BY id
   HAVING soma > 11

Essa consulta gera a seguinte tabela, que é uma modificação da Tabela (24), satisfeita a condição soma > 11:

 

Tabela (24): Horas_trabalhadas
id soma
41 16
58 12

Instrução JOIN

É claro que a última tabela ficaria mais fácil de interpretar se, ao invés de conter apenas ids, ela contivesse também os nomes dos funcionários. Essa informação está contida na Tabela (22): Funcionarios. A instrução JOIN serve para ler dados relacionados, gravados em mais de uma tabela. Sua forma geral é:

SELECT tabela1.campo11, tabela1.campo12, tabela2.campo21, tabela2.campo22, ...
   FROM tabela1 INNER JOIN tabela2 ON tabela1.id1 = tabela2.id2

Esse comando seleciona todos os campo11 e campo12 da tabela1, campo21, campo22, … da tabela2, relacionados pela condição tabela1.id1 = tabela2.id2. OS campos id1 e id2 podem ter ou não os mesmos nomes. Usando aliáses essa consulta pode ser deixada mais clara (e isso se torna mais importante para consultas mais longas envolvendos muitos campos e tabelas):

SELECT t1.campo11, t1.campo12, t2.campo21, t2.campo22, ...
   FROM tabela1 t1 INNER JOIN tabela2 t2 ON t1.id1 = t2.id2

Por exemplo, se quisermos uma tabela com os mesmos resultados da tabela (24) mas incluindo nomes dos funcionários fazemos

SELECT ht.id, f.Nome, SUM(horas) as soma
   FROM Horas_trabalhadas ht
   INNER JOIN Funcionarios f ON ht.id = f.id
   GROUP BY ht.id HAVING soma > 11

Com o resultado:

Tabela (25): Horas trabalhadas por funcionário
id Nome soma
41 Tânia Ferreira 16
58 Francisco Pedroso 12

Existem outros tipos de junções ou JOINs no SQL:

  • (INNER) JOIN: Retorna registros com valores correspondentes nas duas tabelas.
  • LEFT (OUTER) JOIN: Retorna registros da tabela esquerda (a primeira na query) e os correspondentes na tabela direita.
  • RIGHT (OUTER) JOIN: Retorna registros da tabela direita e os registros correspondentes da tabela esquerda.
  • FULL (OUTER) JOIN: Retorna registros quando houver correspondência em qualquer uma das tabelas.
Variantes do operador JOIN

Sugestões de Leitura

  • Faroult, Stéphane; Robson, Peter: The Art of SQL, O’Reilly Media, Sebastopol, CA, 2006.
  • Taylor,Allen: SQL For Dummies, 9th Edition John Wiley & Sons, New Jersey, 2019.

O Futuro da Inteligência Artificial

Expectativa e Desafio Futuro

No campo das expectativas para um futuro muito próximo podemos mencionar as interfaces entre cérebro e computador mediadas por IAs, conectados à máquinas externas tais como exoesqueletos. Esses sistemas estarão disponíveis para pacientes com acidentes cérebro-vasculares, com traumas, doenças neurológicas, ou simplesmente como uma extensão de habilidades de uma pessoa saudável.

Nenhuma nova tecnologia é introduzida sem apresentar simultaneamente problemas e desafios em seu uso. Estima-se que um número relevante de empregos será perdido para a automação inteligente. Diferente das máquinas mecânicas, que substituíram o trabalhador braçal, agora é razoável considerar que computadores farão o trabalho de profissionais com níveis mais elevados de qualificação. Investimento em equipamentos, e não em pessoas, provavelmente aumentará o problema do desemprego e da concentração de renda.

O uso das máquinas para recomendações de conteúdo, por exemplo, tem se mostrado problemático em algumas plataformas. Buscando atrair a atenção do usuário e mantê-lo por mais tempo conectado e fidelizado as redes apresentam como sugestões conteúdos cada vez mais contundentes, muitas vezes envolvendo violência e intolerância. A indicação de conteúdo de fácil aceitação, em geral aprovado por muitos usuários, tende a esconder aqueles de menor circulação ou de gosto mais elaborado. Como resultado se observa a tendência de uniformização e formação de guetos, com a consequente inclinação à radicalização e intolerância. Junta-se a isso a facilidade para a geração inteligente de imagens, áudios e vídeos falsos que torna as campanhas de desinformação ainda mais nocivas e de difícil deteção.

Os problemas envolvendo a indústria da propaganda nos meios virtuais ficam exacerbados pelas práticas ilegais e imorais do roubo de dados. Dados se tornaram um produto valioso e a ausência de uma legislação atualizada estimula a prática da invasão de computadores e telefones pessoais e corporativos. Redes sociais importantes já foram flagradas vendendo informações sobre seus usuários que são usadas para o mero estímulo ao consumo ou para o atingimento de metas políticas muitas vezes obscuras e antidemocráticas.

A habilidade das IAs de reconhecer texto escrito e falado e extrair conteúdo das linguagens naturais agrava a ameaça à privacidade. Uma espionagem feita pelo microfone de um celular pode não apenas indicar que tipo de propaganda deve ser oferecida ao usuário mas também revelar traços que essa pessoa gostaria de manter privados, tais como traços de comportamentos íntimos ou a presença de uma doença.

Questões éticas, usualmente difíceis, ficam mais complexas na presença de IAs. Quem deve ser responsabilizado se um médico autômato comete um erro em seu diagnóstico ou procedimento? Quanta autonomia se pode atribuir à um juiz máquina ou a um automóvel auto-guiado? É aceitável permitir que um drone armado dispare contra um grupo que ele considera perigoso?

Provavelmente a afirmação do falecido físico Stephen Hawkings de que “O desenvolvimento de uma inteligência artificial completa pode determinar o fim da raça humana” seja pessimista em excesso.

É inegável, no entanto, que vigilância e responsabilidade devem ser elementos comuns no uso de toda nova tecnologia.

Referências

CHOLLET, F.. Deep Learning with Python. Nova Iorque: Manning Publications Co., 2018.

GOODFELLOW, I.; BENGIO, Y.; COURVILLE, A. Deep Learning: Cambridge, MA : MIT Press, 2017.

UNESCO. Artificial Intelligence in Education: Challenges and Opportunities for Sustainable Development, United Nations Educational, Scientific and Cultural Organization, Paris, 2019.