Python Pandas - Guia rápido

Pandas é uma biblioteca Python de código aberto que fornece manipulação de dados de alto desempenho e ferramenta de análise usando suas poderosas estruturas de dados. O nome Pandas é derivado da palavra Panel Data - uma Econometria de dados multidimensionais.

Em 2008, o desenvolvedor Wes McKinney começou a desenvolver pandas quando precisava de uma ferramenta flexível de alto desempenho para análise de dados.

Antes do Pandas, o Python era usado principalmente para preparação e preparação de dados. Teve muito pouca contribuição para a análise de dados. O Pandas resolveu esse problema. Usando o Pandas, podemos realizar cinco etapas típicas no processamento e análise de dados, independentemente da origem dos dados - carregar, preparar, manipular, modelar e analisar.

Python com Pandas é usado em uma ampla variedade de campos, incluindo domínios acadêmicos e comerciais, incluindo finanças, economia, estatística, análise, etc.

Principais recursos do Pandas

• Objeto DataFrame rápido e eficiente com indexação padrão e personalizada.
• Ferramentas para carregar dados em objetos de dados na memória de diferentes formatos de arquivo.
• Alinhamento de dados e tratamento integrado de dados ausentes.
• Remodelagem e rotação de conjuntos de datas.
• Fatiamento baseado em rótulo, indexação e subconjunto de grandes conjuntos de dados.
• As colunas de uma estrutura de dados podem ser excluídas ou inseridas.
• Agrupe por dados para agregação e transformações.
• Mesclagem e junção de dados de alto desempenho.
• Funcionalidade de série temporal.

A distribuição padrão do Python não vem com o módulo Pandas. Uma alternativa leve é ​​instalar o NumPy usando o instalador de pacote Python popular,pip.

pip install pandas

Se você instalar o pacote Anaconda Python, o Pandas será instalado por padrão com o seguinte -

janelas

• Anaconda (por https://www.continuum.io) é uma distribuição Python gratuita para a pilha SciPy. Também está disponível para Linux e Mac.

• Canopy (https://www.enthought.com/products/canopy/) está disponível como distribuição gratuita e comercial com pilha SciPy completa para Windows, Linux e Mac.

• Python(x, y) é uma distribuição Python gratuita com pilha SciPy e Spyder IDE para Windows OS. (Pode ser baixado dehttp://python-xy.github.io/)

Linux

Os gerenciadores de pacotes das respectivas distribuições Linux são usados ​​para instalar um ou mais pacotes na pilha SciPy.

For Ubuntu Users

sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-nose

For Fedora Users

sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-devel

O Pandas lida com as três estruturas de dados a seguir -

• Series
• DataFrame
• Panel

Essas estruturas de dados são construídas em cima do array Numpy, o que significa que são rápidas.

Dimensão e descrição

A melhor maneira de pensar nessas estruturas de dados é que a estrutura de dados de dimensão superior é um contêiner de sua estrutura de dados de dimensão inferior. Por exemplo, DataFrame é um contêiner de Series, Panel é um contêiner de DataFrame.

Estrutura de dados	Dimensões	Descrição
Series	1	Matriz homogênea marcada 1D, tamanho imutável.
Frames de dados	2	Estrutura tabular rotulada em 2D geral, com tamanho mutável com colunas potencialmente heterogeneamente tipadas.
Painel	3	Matriz rotulada em 3D geral, com tamanho mutável.

Construir e lidar com dois ou mais arrays dimensionais é uma tarefa tediosa, pois o usuário tem que considerar a orientação do conjunto de dados ao escrever funções. Mas usando as estruturas de dados do Pandas, o esforço mental do usuário é reduzido.

Por exemplo, com dados tabulares (DataFrame), é semanticamente mais útil pensar no index (as linhas) e o columns em vez do eixo 0 e eixo 1.

Mutabilidade

Todas as estruturas de dados do Pandas são mutáveis ​​por valor (podem ser alteradas) e, exceto Series, todas são mutáveis ​​por tamanho. A série tem tamanho imutável.

Note- DataFrame é amplamente utilizado e uma das estruturas de dados mais importantes. O painel é usado muito menos.

Series

A série é uma estrutura semelhante a uma matriz unidimensional com dados homogêneos. Por exemplo, a série a seguir é uma coleção de inteiros 10, 23, 56, ...

10

23

56

17

52

61

73

90

26

72

Pontos chave

• Dados homogêneos
• Tamanho imutável
• Valores de dados mutáveis

Quadro de dados

DataFrame é uma matriz bidimensional com dados heterogêneos. Por exemplo,

Nome	Era	Gênero	Avaliação
Steve	32	Masculino	3,45
Lia	28	Fêmea	4,6
Vin	45	Masculino	3,9
Katie	38	Fêmea	2,78

A tabela representa os dados de uma equipe de vendas de uma organização com sua classificação geral de desempenho. Os dados são representados em linhas e colunas. Cada coluna representa um atributo e cada linha representa uma pessoa.

Tipo de dados das colunas

Os tipos de dados das quatro colunas são os seguintes -

Coluna	Tipo
Nome	Corda
Era	Inteiro
Gênero	Corda
Avaliação	Flutuador

Pontos chave

• Dados heterogêneos
• Tamanho mutável
• Dados mutáveis

Painel

Painel é uma estrutura de dados tridimensional com dados heterogêneos. É difícil representar o painel em representação gráfica. Mas um painel pode ser ilustrado como um contêiner de DataFrame.

Pontos chave

• Dados heterogêneos
• Tamanho mutável
• Dados mutáveis

Series é um array rotulado unidimensional capaz de conter dados de qualquer tipo (inteiro, string, float, objetos python, etc.). Os rótulos dos eixos são chamados coletivamente de índice.

pandas.Series

Uma série pandas pode ser criada usando o seguinte construtor -

pandas.Series( data, index, dtype, copy)

Os parâmetros do construtor são os seguintes -

Sr. Não	Parâmetro e Descrição
1	data os dados assumem várias formas, como ndarray, lista, constantes
2	index Os valores do índice devem ser únicos e hashable, mesmo comprimento que os dados. Padrãonp.arange(n) se nenhum índice for passado.
3	dtype dtype é para tipo de dados. Se nenhum, o tipo de dados será inferido
4	copy Copie os dados. Falso padrão

Uma série pode ser criada usando várias entradas como -

• Array
• Dict
• Valor escalar ou constante

Crie uma série vazia

Uma série básica que pode ser criada é uma série vazia.

Exemplo

#import the pandas library and aliasing as pd
import pandas as pd
s = pd.Series()
print s

Está output é o seguinte -

Series([], dtype: float64)

Crie uma série de ndarray

Se os dados forem um ndarray, o índice transmitido deve ter o mesmo comprimento. Se nenhum índice for passado, então, por padrão, o índice serárange(n) Onde n é o comprimento da matriz, ou seja, [0,1,2,3…. range(len(array))-1].

Exemplo 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print s

Está output é o seguinte -

0   a
1   b
2   c
3   d
dtype: object

Não passamos nenhum índice, então, por padrão, ele atribuiu os índices que variam de 0 a len(data)-1, ou seja, 0 a 3.

Exemplo 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
print s

Está output é o seguinte -

100  a
101  b
102  c
103  d
dtype: object

Passamos os valores do índice aqui. Agora podemos ver os valores indexados personalizados na saída.

Crie uma série de dict

UMA dictpode ser passado como entrada e, se nenhum índice for especificado, as chaves do dicionário são obtidas em uma ordem de classificação para construir o índice. E seindex for passado, os valores nos dados correspondentes aos rótulos no índice serão retirados.

Exemplo 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print s

Está output é o seguinte -

a 0.0
b 1.0
c 2.0
dtype: float64

Observe - As chaves de dicionário são usadas para construir o índice.

Exemplo 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a'])
print s

Está output é o seguinte -

b 1.0
c 2.0
d NaN
a 0.0
dtype: float64

Observe - A ordem do índice é persistida e o elemento ausente é preenchido com NaN (não é um número).

Crie uma série de escalar

Se os dados forem um valor escalar, um índice deve ser fornecido. O valor será repetido para corresponder ao comprimento deindex

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print s

Está output é o seguinte -

0  5
1  5
2  5
3  5
dtype: int64

Acessando Dados de Série com Posição

Os dados da série podem ser acessados ​​de forma semelhante a uma ndarray.

Exemplo 1

Recupere o primeiro elemento. Como já sabemos, a contagem começa do zero para a matriz, o que significa que o primeiro elemento é armazenado em zero ^ª posição e assim por diante.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first element
print s[0]

Está output é o seguinte -

1

Exemplo 2

Recupere os três primeiros elementos da Série. Se: for inserido na frente dele, todos os itens desse índice em diante serão extraídos. Se dois parâmetros (com: entre eles) forem usados, os itens entre os dois índices (sem incluir o índice de parada)

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first three element
print s[:3]

Está output é o seguinte -

a  1
b  2
c  3
dtype: int64

Exemplo 3

Recupere os últimos três elementos.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the last three element
print s[-3:]

Está output é o seguinte -

c  3
d  4
e  5
dtype: int64

Recuperar dados usando rótulo (índice)

Série A é como um tamanho fixo dict em que você pode obter e definir valores por rótulo de índice.

Exemplo 1

Recupere um único elemento usando o valor do rótulo do índice.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve a single element
print s['a']

Está output é o seguinte -

1

Exemplo 2

Recupere vários elementos usando uma lista de valores de rótulo de índice.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s[['a','c','d']]

Está output é o seguinte -

a  1
c  3
d  4
dtype: int64

Exemplo 3

Se um rótulo não estiver contido, uma exceção será gerada.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s['f']

Está output é o seguinte -

…
KeyError: 'f'

Um quadro de dados é uma estrutura de dados bidimensional, ou seja, os dados são alinhados de forma tabular em linhas e colunas.

Recursos do DataFrame

• Potencialmente, as colunas são de tipos diferentes
• Tamanho - Mutável
• Eixos rotulados (linhas e colunas)
• Pode realizar operações aritméticas em linhas e colunas

Estrutura

Vamos supor que estamos criando um quadro de dados com os dados do aluno.

Você pode pensar nisso como uma tabela SQL ou uma representação de dados de planilha.

pandas.DataFrame

Um DataFrame pandas pode ser criado usando o seguinte construtor -

pandas.DataFrame( data, index, columns, dtype, copy)

Os parâmetros do construtor são os seguintes -

Sr. Não	Parâmetro e Descrição
1	data os dados assumem várias formas como ndarray, série, mapa, listas, dict, constantes e também outro DataFrame.
2	index Para os rótulos de linha, o Índice a ser usado para o quadro resultante é Padrão Opcional np.arange (n) se nenhum índice for passado.
3	columns Para rótulos de coluna, a sintaxe padrão opcional é - np.arange (n). Isso só é verdade se nenhum índice for passado.
4	dtype Tipo de dados de cada coluna.
5	copy Este comando (ou seja lá o que for) é usado para copiar dados, se o padrão for False.

Criar DataFrame

Um DataFrame do pandas pode ser criado usando várias entradas como -

• Lists
• dict
• Series
• Numpy ndarrays
• Outro DataFrame

Nas seções subsequentes deste capítulo, veremos como criar um DataFrame usando essas entradas.

Crie um DataFrame vazio

Um DataFrame básico, que pode ser criado, é um Dataframe Vazio.

Exemplo

#import the pandas library and aliasing as pd
import pandas as pd
df = pd.DataFrame()
print df

Está output é o seguinte -

Empty DataFrame
Columns: []
Index: []

Crie um DataFrame a partir de listas

O DataFrame pode ser criado usando uma única lista ou uma lista de listas.

Exemplo 1

import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df

Está output é o seguinte -

0
0    1
1    2
2    3
3    4
4    5

Exemplo 2

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print df

Está output é o seguinte -

Name      Age
0     Alex      10
1     Bob       12
2     Clarke    13

Exemplo 3

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print df

Está output é o seguinte -

Name     Age
0     Alex     10.0
1     Bob      12.0
2     Clarke   13.0

Note - Observe, o dtype parâmetro muda o tipo de coluna Age para ponto flutuante.

Crie um DataFrame a partir de Dict of ndarrays / Lists

Todos ndarraysdeve ter o mesmo comprimento. Se o índice for passado, o comprimento do índice deve ser igual ao comprimento das matrizes.

Se nenhum índice for passado, então, por padrão, o índice será o intervalo (n), onde n é o comprimento da matriz.

Exemplo 1

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print df

Está output é o seguinte -

Age      Name
0     28        Tom
1     34       Jack
2     29      Steve
3     42      Ricky

Note- Observe os valores 0,1,2,3. Eles são o índice padrão atribuído a cada um usando o intervalo de funções (n).

Exemplo 2

Vamos agora criar um DataFrame indexado usando arrays.

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print df

Está output é o seguinte -

Age    Name
rank1    28      Tom
rank2    34     Jack
rank3    29    Steve
rank4    42    Ricky

Note - Observe, o index parâmetro atribui um índice para cada linha.

Crie um DataFrame a partir da Lista de Dictos

A lista de dicionários pode ser passada como dados de entrada para criar um DataFrame. As chaves do dicionário são, por padrão, consideradas nomes de coluna.

Exemplo 1

O exemplo a seguir mostra como criar um DataFrame passando uma lista de dicionários.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df

Está output é o seguinte -

a    b      c
0   1   2     NaN
1   5   10   20.0

Note - Observe, NaN (não é um número) é acrescentado nas áreas ausentes.

Exemplo 2

O exemplo a seguir mostra como criar um DataFrame passando uma lista de dicionários e os índices de linha.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print df

Está output é o seguinte -

a   b       c
first   1   2     NaN
second  5   10   20.0

Exemplo 3

O exemplo a seguir mostra como criar um DataFrame com uma lista de dicionários, índices de linha e índices de coluna.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]

#With two column indices, values same as dictionary keys
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])

#With two column indices with one index with other name
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print df1
print df2

Está output é o seguinte -

#df1 output
         a  b
first    1  2
second   5  10

#df2 output
         a  b1
first    1  NaN
second   5  NaN

Note- Observe, df2 DataFrame é criado com um índice de coluna diferente da chave de dicionário; assim, anexou o NaN no lugar. Enquanto df1 é criado com índices de coluna iguais às chaves de dicionário, então NaN é anexado.

Crie um DataFrame a partir do Dict of Series

O Dicionário de Séries pode ser passado para formar um DataFrame. O índice resultante é a união de todos os índices de série passados.

Exemplo

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df

Está output é o seguinte -

one    two
a     1.0    1
b     2.0    2
c     3.0    3
d     NaN    4

Note - Observe, para a série um, não há rótulo ‘d’ passou, mas no resultado, para o d rótulo, NaN é anexado com NaN.

Vamos entender agora column selection, addition, e deletion por meio de exemplos.

Seleção de coluna

Vamos entender isso selecionando uma coluna do DataFrame.

Exemplo

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df ['one']

Está output é o seguinte -

a     1.0
b     2.0
c     3.0
d     NaN
Name: one, dtype: float64

Adição de coluna

Vamos entender isso adicionando uma nova coluna a um quadro de dados existente.

Exemplo

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)

# Adding a new column to an existing DataFrame object with column label by passing new series

print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print df

print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']

print df

Está output é o seguinte -

Adding a new column by passing as Series:
     one   two   three
a    1.0    1    10.0
b    2.0    2    20.0
c    3.0    3    30.0
d    NaN    4    NaN

Adding a new column using the existing columns in DataFrame:
      one   two   three    four
a     1.0    1    10.0     11.0
b     2.0    2    20.0     22.0
c     3.0    3    30.0     33.0
d     NaN    4     NaN     NaN

Exclusão de coluna

As colunas podem ser excluídas ou removidas; vamos dar um exemplo para entender como.

Exemplo

# Using the previous DataFrame, we will delete a column
# using del function
import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']), 
   'three' : pd.Series([10,20,30], index=['a','b','c'])}

df = pd.DataFrame(d)
print ("Our dataframe is:")
print df

# using del function
print ("Deleting the first column using DEL function:")
del df['one']
print df

# using pop function
print ("Deleting another column using POP function:")
df.pop('two')
print df

Está output é o seguinte -

Our dataframe is:
      one   three  two
a     1.0    10.0   1
b     2.0    20.0   2
c     3.0    30.0   3
d     NaN     NaN   4

Deleting the first column using DEL function:
      three    two
a     10.0     1
b     20.0     2
c     30.0     3
d     NaN      4

Deleting another column using POP function:
   three
a  10.0
b  20.0
c  30.0
d  NaN

Seleção, adição e exclusão de linhas

Agora entenderemos a seleção, adição e exclusão de linhas por meio de exemplos. Comecemos com o conceito de seleção.

Seleção por Rótulo

As linhas podem ser selecionadas passando o rótulo da linha para um loc função.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.loc['b']

Está output é o seguinte -

one 2.0
two 2.0
Name: b, dtype: float64

O resultado é uma série com rótulos como nomes de colunas do DataFrame. E o Nome da série é o rótulo com o qual é recuperado.

Seleção por localização inteira

As linhas podem ser selecionadas passando a localização do inteiro para um iloc função.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.iloc[2]

Está output é o seguinte -

one   3.0
two   3.0
Name: c, dtype: float64

Fatiar linhas

Várias linhas podem ser selecionadas usando o operador ':'.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df[2:4]

Está output é o seguinte -

one  two
c  3.0    3
d  NaN    4

Adição de linhas

Adicione novas linhas a um DataFrame usando o appendfunção. Esta função irá anexar as linhas no final.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)
print df

Está output é o seguinte -

a  b
0  1  2
1  3  4
0  5  6
1  7  8

Exclusão de linhas

Use o rótulo de índice para excluir ou descartar linhas de um DataFrame. Se o rótulo estiver duplicado, várias linhas serão eliminadas.

Se você observar, no exemplo acima, os rótulos estão duplicados. Vamos eliminar um rótulo e ver quantas linhas serão eliminadas.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)

# Drop rows with label 0
df = df.drop(0)

print df

Está output é o seguinte -

a b
1 3 4
1 7 8

No exemplo acima, duas linhas foram eliminadas porque essas duas contêm o mesmo rótulo 0.

UMA panelé um contêiner 3D de dados. O termoPanel data é derivado da econometria e é parcialmente responsável pelo nome pandas - pan(el)-da(ta)-s.

Os nomes dos 3 eixos têm como objetivo dar algum significado semântico à descrição de operações envolvendo dados de painel. Eles são -

• items - eixo 0, cada item corresponde a um DataFrame contido nele.

• major_axis - eixo 1, é o índice (linhas) de cada um dos DataFrames.

• minor_axis - eixo 2, são as colunas de cada um dos DataFrames.

pandas.Panel ()

Um painel pode ser criado usando o seguinte construtor -

pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)

Os parâmetros do construtor são os seguintes -

Parâmetro	Descrição
dados	Os dados assumem várias formas, como ndarray, série, mapa, listas, dict, constantes e também outro DataFrame
Itens	eixo = 0
eixo principal	eixo = 1
eixo menor	eixo = 2
tipo d	Tipo de dados de cada coluna
cópia de	Copie os dados. Padrão,false

Criar Painel

Um painel pode ser criado de várias maneiras, como -

• De ndarrays
• Do dicionário de DataFrames

De 3D ndarray

# creating an empty panel
import pandas as pd
import numpy as np

data = np.random.rand(2,4,5)
p = pd.Panel(data)
print p

Está output é o seguinte -

<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
Items axis: 0 to 1
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 4

Note - Observe as dimensões do painel vazio e do painel acima, todos os objetos são diferentes.

De dict de DataFrame Objects

#creating an empty panel
import pandas as pd
import numpy as np

data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p

Está output é o seguinte -

Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

Crie um painel vazio

Um painel vazio pode ser criado usando o construtor de painel da seguinte forma -

#creating an empty panel
import pandas as pd
p = pd.Panel()
print p

Está output é o seguinte -

<class 'pandas.core.panel.Panel'>
Dimensions: 0 (items) x 0 (major_axis) x 0 (minor_axis)
Items axis: None
Major_axis axis: None
Minor_axis axis: None

Selecionando os dados do painel

Selecione os dados do painel usando -

• Items
• Major_axis
• Minor_axis

Usando itens

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p['Item1']

Está output é o seguinte -

0          1          2
0    0.488224  -0.128637   0.930817
1    0.417497   0.896681   0.576657
2   -2.775266   0.571668   0.290082
3   -0.400538  -0.144234   1.110535

Temos dois itens e recuperamos o item1. O resultado é um DataFrame com 4 linhas e 3 colunas, que são oMajor_axis e Minor_axis dimensões.

Usando major_axis

Os dados podem ser acessados ​​usando o método panel.major_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)

Está output é o seguinte -

Item1       Item2
0   0.417497    0.748412
1   0.896681   -0.557322
2   0.576657       NaN

Usando menor_axis

Os dados podem ser acessados ​​usando o método panel.minor_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)

Está output é o seguinte -

Item1       Item2
0   -0.128637   -1.047032
1    0.896681   -0.557322
2    0.571668    0.431953
3   -0.144234    1.302466

Note - Observe as mudanças nas dimensões.

Até agora, aprendemos sobre as três estruturas de dados do Pandas e como criá-las. Vamos nos concentrar principalmente nos objetos DataFrame devido à sua importância no processamento de dados em tempo real e também discutir algumas outras DataStructures.

Funcionalidade básica da série

Sr. Não.	Atributo ou método e descrição
1	axes Retorna uma lista dos rótulos dos eixos das linhas
2	dtype Retorna o dtype do objeto.
3	empty Retorna True se a série estiver vazia.
4	ndim Retorna o número de dimensões dos dados subjacentes, por definição 1.
5	size Retorna o número de elementos nos dados subjacentes.
6	values Retorna a série como ndarray.
7	head() Retorna as primeiras n linhas.
8	tail() Retorna as últimas n linhas.

Vamos agora criar uma série e ver a operação de todos os atributos tabulados acima.

Exemplo

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print s

Está output é o seguinte -

0   0.967853
1  -0.148368
2  -1.395906
3  -1.758394
dtype: float64

eixos

Retorna a lista de rótulos da série.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("The axes are:")
print s.axes

Está output é o seguinte -

The axes are:
[RangeIndex(start=0, stop=4, step=1)]

O resultado acima é um formato compacto de uma lista de valores de 0 a 5, ou seja, [0,1,2,3,4].

vazio

Retorna o valor booleano informando se o objeto está vazio ou não. True indica que o objeto está vazio.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("Is the Object empty?")
print s.empty

Está output é o seguinte -

Is the Object empty?
False

ndim

Retorna o número de dimensões do objeto. Por definição, uma série é uma estrutura de dados 1D, então ela retorna

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The dimensions of the object:")
print s.ndim

Está output é o seguinte -

0   0.175898
1   0.166197
2  -0.609712
3  -1.377000
dtype: float64

The dimensions of the object:
1

Tamanho

Retorna o tamanho (comprimento) da série.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(2))
print s
print ("The size of the object:")
print s.size

Está output é o seguinte -

0   3.078058
1  -1.207803
dtype: float64

The size of the object:
2

valores

Retorna os dados reais da série como uma matriz.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The actual data series is:")
print s.values

Está output é o seguinte -

0   1.787373
1  -0.605159
2   0.180477
3  -0.140922
dtype: float64

The actual data series is:
[ 1.78737302 -0.60515881 0.18047664 -0.1409218 ]

Cabeça e cauda

Para visualizar uma pequena amostra de um objeto Series ou DataFrame, use os métodos head () e tail ().

head() retorna o primeiro nlinhas (observe os valores do índice). O número padrão de elementos a serem exibidos é cinco, mas você pode passar um número personalizado.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The first two rows of the data series:")
print s.head(2)

Está output é o seguinte -

The original series is:
0   0.720876
1  -0.765898
2   0.479221
3  -0.139547
dtype: float64

The first two rows of the data series:
0   0.720876
1  -0.765898
dtype: float64

tail() retorna o último nlinhas (observe os valores do índice). O número padrão de elementos a serem exibidos é cinco, mas você pode passar um número personalizado.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The last two rows of the data series:")
print s.tail(2)

Está output é o seguinte -

The original series is:
0 -0.655091
1 -0.881407
2 -0.608592
3 -2.341413
dtype: float64

The last two rows of the data series:
2 -0.608592
3 -2.341413
dtype: float64

Funcionalidade básica do DataFrame

Vamos agora entender o que é DataFrame Basic Functionality. As tabelas a seguir listam os atributos ou métodos importantes que ajudam na funcionalidade básica do DataFrame.

Sr. Não.	Atributo ou método e descrição
1	T Transpõe linhas e colunas.
2	axes Retorna uma lista com os rótulos do eixo da linha e rótulos do eixo da coluna como os únicos membros.
3	dtypes Retorna os dtypes neste objeto.
4	empty Verdadeiro se NDFrame estiver totalmente vazio [sem itens]; se algum dos eixos tiver comprimento 0.
5	ndim Número de eixos / dimensões da matriz.
6	shape Retorna uma tupla que representa a dimensionalidade do DataFrame.
7	size Número de elementos no NDFrame.
8	values Representação numpy de NDFrame.
9	head() Retorna as primeiras n linhas.
10	tail() Retorna as últimas n linhas.

Vamos agora criar um DataFrame e ver como funcionam os atributos mencionados acima.

Exemplo

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data series is:")
print df

Está output é o seguinte -

Our data series is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

T (transpor)

Retorna a transposição do DataFrame. As linhas e colunas serão trocadas.

import pandas as pd
import numpy as np
 
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.T

Está output é o seguinte -

The transpose of the data series is:
         0     1       2      3      4      5       6
Age      25    26      25     23     30     29      23
Name     Tom   James   Ricky  Vin    Steve  Smith   Jack
Rating   4.23  3.24    3.98   2.56   3.2    4.6     3.8

eixos

Retorna a lista de rótulos de eixo de linha e rótulos de eixo de coluna.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Row axis labels and column axis labels are:")
print df.axes

Está output é o seguinte -

Row axis labels and column axis labels are:

[RangeIndex(start=0, stop=7, step=1), Index([u'Age', u'Name', u'Rating'],
dtype='object')]

dtypes

Retorna o tipo de dados de cada coluna.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("The data types of each column are:")
print df.dtypes

Está output é o seguinte -

The data types of each column are:
Age     int64
Name    object
Rating  float64
dtype: object

vazio

Retorna o valor booleano informando se o objeto está vazio ou não; True indica que o objeto está vazio.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Is the object empty?")
print df.empty

Está output é o seguinte -

Is the object empty?
False

ndim

Retorna o número de dimensões do objeto. Por definição, DataFrame é um objeto 2D.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndim

Está output é o seguinte -

Our object is:
      Age    Name     Rating
0     25     Tom      4.23
1     26     James    3.24
2     25     Ricky    3.98
3     23     Vin      2.56
4     30     Steve    3.20
5     29     Smith    4.60
6     23     Jack     3.80

The dimension of the object is:
2

forma

Retorna uma tupla que representa a dimensionalidade do DataFrame. Tupla (a, b), onde a representa o número de linhas eb representa o número de colunas.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The shape of the object is:")
print df.shape

Está output é o seguinte -

Our object is:
   Age   Name    Rating
0  25    Tom     4.23
1  26    James   3.24
2  25    Ricky   3.98
3  23    Vin     2.56
4  30    Steve   3.20
5  29    Smith   4.60
6  23    Jack    3.80

The shape of the object is:
(7, 3)

Tamanho

Retorna o número de elementos no DataFrame.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The total number of elements in our object is:")
print df.size

Está output é o seguinte -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The total number of elements in our object is:
21

valores

Retorna os dados reais no DataFrame como um NDarray.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The actual data in our data frame is:")
print df.values

Está output é o seguinte -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80
The actual data in our data frame is:
[[25 'Tom' 4.23]
[26 'James' 3.24]
[25 'Ricky' 3.98]
[23 'Vin' 2.56]
[30 'Steve' 3.2]
[29 'Smith' 4.6]
[23 'Jack' 3.8]]

Cabeça e cauda

Para visualizar uma pequena amostra de um objeto DataFrame, use o head() e os métodos tail (). head() retorna o primeiro nlinhas (observe os valores do índice). O número padrão de elementos a serem exibidos é cinco, mas você pode passar um número personalizado.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The first two rows of the data frame is:")
print df.head(2)

Está output é o seguinte -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The first two rows of the data frame is:
   Age   Name   Rating
0  25    Tom    4.23
1  26    James  3.24

tail() retorna o último nlinhas (observe os valores do índice). O número padrão de elementos a serem exibidos é cinco, mas você pode passar um número personalizado.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]), 
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The last two rows of the data frame is:")
print df.tail(2)

Está output é o seguinte -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The last two rows of the data frame is:
    Age   Name    Rating
5   29    Smith    4.6
6   23    Jack     3.8

Um grande número de métodos calcula coletivamente estatísticas descritivas e outras operações relacionadas no DataFrame. A maioria dessas são agregações comosum(), mean(), mas alguns deles, como sumsum(), produz um objeto do mesmo tamanho. De um modo geral, esses métodos levam umaxisargumento, assim como ndarray. {sum, std, ...}, mas o eixo pode ser especificado por nome ou inteiro

• DataFrame - “índice” (eixo = 0, padrão), “colunas” (eixo = 1)

Vamos criar um DataFrame e usar esse objeto ao longo deste capítulo para todas as operações.

Exemplo

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df

Está output é o seguinte -

Age  Name   Rating
0   25   Tom     4.23
1   26   James   3.24
2   25   Ricky   3.98
3   23   Vin     2.56
4   30   Steve   3.20
5   29   Smith   4.60
6   23   Jack    3.80
7   34   Lee     3.78
8   40   David   2.98
9   30   Gasper  4.80
10  51   Betina  4.10
11  46   Andres  3.65

soma()

Retorna a soma dos valores do eixo solicitado. Por padrão, o eixo é índice (eixo = 0).

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.sum()

Está output é o seguinte -

Age                                                    382
Name     TomJamesRickyVinSteveSmithJackLeeDavidGasperBe...
Rating                                               44.92
dtype: object

Cada coluna individual é adicionada individualmente (Strings são anexadas).

eixo = 1

Esta sintaxe fornecerá a saída conforme mostrado abaixo.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
 
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum(1)

Está output é o seguinte -

0    29.23
1    29.24
2    28.98
3    25.56
4    33.20
5    33.60
6    26.80
7    37.78
8    42.98
9    34.80
10   55.10
11   49.65
dtype: float64

significar()

Retorna o valor médio

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.mean()

Está output é o seguinte -

Age       31.833333
Rating     3.743333
dtype: float64

std ()

Retorna o desvio padrão de Bressel das colunas numéricas.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.std()

Está output é o seguinte -

Age       9.232682
Rating    0.661628
dtype: float64

Funções e descrição

Vamos agora entender as funções em Estatística Descritiva em Python Pandas. A tabela a seguir lista as funções importantes -

Sr. Não.	Função	Descrição
1	contagem()	Número de observações não nulas
2	soma()	Soma de valores
3	significar()	Média dos Valores
4	mediana()	Mediana de Valores
5	modo()	Modo de valores
6	std ()	Desvio Padrão dos Valores
7	min ()	Valor mínimo
8	max ()	Valor máximo
9	abdômen()	Valor absoluto
10	prod ()	Produto de Valores
11	cumsum ()	Soma Cumulativa
12	cumprod ()	Produto Cumulativo

Note- Uma vez que DataFrame é uma estrutura de dados heterogênea. As operações genéricas não funcionam com todas as funções.

• Funções como sum(), cumsum()trabalhar com elementos de dados numéricos e de caracteres (ou) de string sem nenhum erro. Apesarn prática, agregações de caracteres nunca são usadas geralmente, essas funções não lançam nenhuma exceção.

• Funções como abs(), cumprod() lançar exceção quando o DataFrame contém dados de caractere ou string porque tais operações não podem ser executadas.

Resumindo Dados

o describe() função calcula um resumo das estatísticas pertencentes às colunas DataFrame.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe()

Está output é o seguinte -

Age         Rating
count    12.000000      12.000000
mean     31.833333       3.743333
std       9.232682       0.661628
min      23.000000       2.560000
25%      25.000000       3.230000
50%      29.500000       3.790000
75%      35.500000       4.132500
max      51.000000       4.800000

Esta função dá o mean, std e IQRvalores. E a função exclui as colunas de caracteres e o resumo fornecido sobre as colunas numéricas.'include'é o argumento usado para passar informações necessárias sobre quais colunas precisam ser consideradas para o resumo. Pega a lista de valores; por padrão, 'número'.

• object - Resume colunas String
• number - Resume as colunas numéricas
• all - Resume todas as colunas juntas (não deve ser passado como um valor de lista)

Agora, use a seguinte instrução no programa e verifique a saída -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe(include=['object'])

Está output é o seguinte -

Name
count       12
unique      12
top      Ricky
freq         1

Agora, use a seguinte instrução e verifique a saída -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df. describe(include='all')

Está output é o seguinte -

Age          Name       Rating
count   12.000000        12    12.000000
unique        NaN        12          NaN
top           NaN     Ricky          NaN
freq          NaN         1          NaN
mean    31.833333       NaN     3.743333
std      9.232682       NaN     0.661628
min     23.000000       NaN     2.560000
25%     25.000000       NaN     3.230000
50%     29.500000       NaN     3.790000
75%     35.500000       NaN     4.132500
max     51.000000       NaN     4.800000

Para aplicar as suas próprias funções ou as funções de outra biblioteca aos objetos Pandas, você deve estar ciente dos três métodos importantes. Os métodos foram discutidos abaixo. O método apropriado a ser usado depende se sua função espera operar em um DataFrame inteiro, linha ou coluna, ou elemento.

• Aplicação da função table wise: pipe ()
• Aplicação de função inteligente de linha ou coluna: apply ()
• Aplicação de função elementar: applymap ()

Aplicação de função table-wise

As operações personalizadas podem ser realizadas passando a função e o número apropriado de parâmetros como argumentos de canal. Assim, a operação é realizada em todo o DataFrame.

Por exemplo, adicione um valor 2 a todos os elementos no DataFrame. Então,

função adicionador

A função somadora adiciona dois valores numéricos como parâmetros e retorna a soma.

def adder(ele1,ele2):
   return ele1+ele2

Agora usaremos a função personalizada para conduzir a operação no DataFrame.

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)

Vamos ver o programa completo -

import pandas as pd
import numpy as np

def adder(ele1,ele2):
   return ele1+ele2

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
print df.apply(np.mean)

Está output é o seguinte -

col1       col2       col3
0   2.176704   2.219691   1.509360
1   2.222378   2.422167   3.953921
2   2.241096   1.135424   2.696432
3   2.355763   0.376672   1.182570
4   2.308743   2.714767   2.130288

Aplicação de função inteligente de linha ou coluna

Funções arbitrárias podem ser aplicadas ao longo dos eixos de um DataFrame ou Painel usando o apply()método, que, como os métodos de estatística descritiva, leva um argumento de eixo opcional. Por padrão, a operação é executada em colunas, tomando cada coluna como um array.

Exemplo 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
print df.apply(np.mean)

Está output é o seguinte -

col1   -0.288022
col2    1.044839
col3   -0.187009
dtype: float64

Passando axis parâmetro, as operações podem ser realizadas em linha.

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean,axis=1)
print df.apply(np.mean)

Está output é o seguinte -

col1    0.034093
col2   -0.152672
col3   -0.229728
dtype: float64

Exemplo 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(lambda x: x.max() - x.min())
print df.apply(np.mean)

Está output é o seguinte -

col1   -0.167413
col2   -0.370495
col3   -0.707631
dtype: float64

Aplicativo de função do elemento sábio

Nem todas as funções podem ser vetorizadas (nem as matrizes NumPy que retornam outra matriz nem qualquer valor), os métodos applymap() no DataFrame e analogously map() em Series aceita qualquer função Python recebendo um único valor e retornando um único valor.

Exemplo 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])

# My custom function
df['col1'].map(lambda x:x*100)
print df.apply(np.mean)

Está output é o seguinte -

col1    0.480742
col2    0.454185
col3    0.266563
dtype: float64

Exemplo 2

import pandas as pd
import numpy as np

# My custom function
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.applymap(lambda x:x*100)
print df.apply(np.mean)

Está output é o seguinte -

col1    0.395263
col2    0.204418
col3   -0.795188
dtype: float64

Reindexingaltera os rótulos de linha e de coluna de um DataFrame. Para reindexar meios para se conformar os dados para coincidir com um determinado conjunto de etiquetas ao longo de um eixo particular.

Várias operações podem ser realizadas por meio de indexação como -

• Reordene os dados existentes para corresponder a um novo conjunto de rótulos.

• Insira marcadores de valor ausente (NA) em locais de etiqueta onde não existiam dados para a etiqueta.

Exemplo

import pandas as pd
import numpy as np

N=20

df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
})

#reindex the DataFrame
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])

print df_reindexed

Está output é o seguinte -

A    C     B
0  2016-01-01  Low   NaN
2  2016-01-03  High  NaN
5  2016-01-06  Low   NaN

Reindexar para alinhar com outros objetos

Você pode querer pegar um objeto e reindexar seus eixos para serem rotulados da mesma forma que outro objeto. Considere o seguinte exemplo para entender o mesmo.

Exemplo

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])

df1 = df1.reindex_like(df2)
print df1

Está output é o seguinte -

col1         col2         col3
0    -2.467652    -1.211687    -0.391761
1    -0.287396     0.522350     0.562512
2    -0.255409    -0.483250     1.866258
3    -1.150467    -0.646493    -0.222462
4     0.152768    -2.056643     1.877233
5    -1.155997     1.528719    -1.343719
6    -1.015606    -1.245936    -0.295275

Note - Aqui, o df1 DataFrame é alterado e reindexado como df2. Os nomes das colunas devem ser correspondidos ou então NAN será adicionado para todo o rótulo da coluna.

Preencher enquanto ReIndexar

reindex() usa um método de parâmetro opcional que é um método de preenchimento com os valores a seguir -

• pad/ffill - Preencher valores adiante

• bfill/backfill - Preencher valores para trás

• nearest - Preencher com os valores de índice mais próximos

Exemplo

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill:")
print df2.reindex_like(df1,method='ffill')

Está output é o seguinte -

col1        col2       col3
0    1.311620   -0.707176   0.599863
1   -0.423455   -0.700265   1.133371
2         NaN         NaN        NaN
3         NaN         NaN        NaN
4         NaN         NaN        NaN
5         NaN         NaN        NaN

Data Frame with Forward Fill:
         col1        col2        col3
0    1.311620   -0.707176    0.599863
1   -0.423455   -0.700265    1.133371
2   -0.423455   -0.700265    1.133371
3   -0.423455   -0.700265    1.133371
4   -0.423455   -0.700265    1.133371
5   -0.423455   -0.700265    1.133371

Note - As últimas quatro linhas são preenchidas.

Limites de enchimento durante reindexação

O argumento limite fornece controle adicional sobre o preenchimento durante a reindexação. Limite especifica a contagem máxima de correspondências consecutivas. Vamos considerar o seguinte exemplo para entender o mesmo -

Exemplo

import pandas as pd
import numpy as np
 
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill limiting to 1:")
print df2.reindex_like(df1,method='ffill',limit=1)

Está output é o seguinte -

col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2         NaN         NaN         NaN
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Data Frame with Forward Fill limiting to 1:
         col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2   -0.055713   -0.021732   -0.174577
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Note- Observe, apenas a 7ª linha é preenchida pela 6ª linha anterior. Então, as linhas são deixadas como estão.

Renomeando

O método rename () permite que você renomeie um eixo com base em algum mapeamento (um dicionário ou série) ou uma função arbitrária.

Vamos considerar o seguinte exemplo para entender isso -

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print df1

print ("After renaming the rows and columns:")
print df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})

Está output é o seguinte -

col1        col2        col3
0    0.486791    0.105759    1.540122
1   -0.990237    1.007885   -0.217896
2   -0.483855   -1.645027   -1.194113
3   -0.122316    0.566277   -0.366028
4   -0.231524   -0.721172   -0.112007
5    0.438810    0.000225    0.435479

After renaming the rows and columns:
                c1          c2        col3
apple     0.486791    0.105759    1.540122
banana   -0.990237    1.007885   -0.217896
durian   -0.483855   -1.645027   -1.194113
3        -0.122316    0.566277   -0.366028
4        -0.231524   -0.721172   -0.112007
5         0.438810    0.000225    0.435479

O método rename () fornece um inplaceparâmetro nomeado, que por padrão é False e copia os dados subjacentes. Passarinplace=True para renomear os dados no local.

O comportamento da iteração básica sobre os objetos Pandas depende do tipo. Ao iterar em uma série, ela é considerada semelhante a uma matriz e a iteração básica produz os valores. Outras estruturas de dados, como DataFrame e Panel, seguem odict-like convenção de iteração sobre o keys dos objetos.

Em suma, iteração básica (para i no objeto) produz -

• Series - valores

• DataFrame - rótulos de coluna

• Panel - rótulos de itens

Iterando um DataFrame

A iteração de um DataFrame fornece nomes de coluna. Vamos considerar o seguinte exemplo para entender o mesmo.

import pandas as pd
import numpy as np
 
N=20
df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
   })

for col in df:
   print col

Está output é o seguinte -

A
C
D
x
y

Para iterar nas linhas do DataFrame, podemos usar as seguintes funções -

• iteritems() - para iterar nos pares (chave, valor)

• iterrows() - itera sobre as linhas como pares (índice, série)

• itertuples() - itera sobre as linhas como duplas nomeadas

iteritems ()

Itera em cada coluna como chave, par de valores com rótulo como chave e valor da coluna como um objeto Series.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
   print key,value

Está output é o seguinte -

col1 0    0.802390
1    0.324060
2    0.256811
3    0.839186
Name: col1, dtype: float64

col2 0    1.624313
1   -1.033582
2    1.796663
3    1.856277
Name: col2, dtype: float64

col3 0   -0.022142
1   -0.230820
2    1.160691
3   -0.830279
Name: col3, dtype: float64

Observe que cada coluna é iterada separadamente como um par de valores-chave em uma série.

iterrows ()

iterrows () retorna o iterador produzindo cada valor de índice junto com uma série contendo os dados em cada linha.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
   print row_index,row

Está output é o seguinte -

0  col1    1.529759
   col2    0.762811
   col3   -0.634691
Name: 0, dtype: float64

1  col1   -0.944087
   col2    1.420919
   col3   -0.507895
Name: 1, dtype: float64
 
2  col1   -0.077287
   col2   -0.858556
   col3   -0.663385
Name: 2, dtype: float64
3  col1    -1.638578
   col2     0.059866
   col3     0.493482
Name: 3, dtype: float64

Note - porque iterrows()iterar nas linhas, não preserva o tipo de dados na linha. 0,1,2 são os índices de linha e col1, col2, col3 são índices de coluna.

itertuples ()

O método itertuples () retornará um iterador que produz uma tupla nomeada para cada linha no DataFrame. O primeiro elemento da tupla será o valor do índice correspondente da linha, enquanto os valores restantes são os valores da linha.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
    print row

Está output é o seguinte -

Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)

Pandas(Index=1, col1=-0.94408735763808649, col2=1.4209186418359423, col3=-
0.50789517967096232)

Pandas(Index=2, col1=-0.07728664756791935, col2=-0.85855574139699076, col3=-
0.6633852507207626)

Pandas(Index=3, col1=0.65734942534106289, col2=-0.95057710432604969,
col3=0.80344487462316527)

Note- Não tente modificar nenhum objeto durante a iteração. A iteração é destinada à leitura e o iterador retorna uma cópia do objeto original (uma visualização), portanto, as alterações não refletirão no objeto original.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])

for index, row in df.iterrows():
   row['a'] = 10
print df

Está output é o seguinte -

col1       col2       col3
0  -1.739815   0.735595  -0.295589
1   0.635485   0.106803   1.527922
2  -0.939064   0.547095   0.038585
3  -1.016509  -0.116580  -0.523158

Observe, nenhuma mudança refletida.

Existem dois tipos de classificação disponíveis no Pandas. Eles são -

• Por etiqueta
• Por valor real

Vamos considerar um exemplo com uma saída.

import pandas as pd
import numpy as np

unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns=['col2','col1'])
print unsorted_df

Está output é o seguinte -

col2       col1
1  -2.063177   0.537527
4   0.142932  -0.684884
6   0.012667  -0.389340
2  -0.548797   1.848743
3  -1.044160   0.837381
5   0.385605   1.300185
9   1.031425  -1.002967
8  -0.407374  -0.435142
0   2.237453  -1.067139
7  -1.445831  -1.701035

Dentro unsorted_df, a labels e a valuesnão estão classificados. Vamos ver como eles podem ser classificados.

Por etiqueta

Usando o sort_index(), passando os argumentos do eixo e a ordem de classificação, DataFrame pode ser classificado. Por padrão, a classificação é feita nos rótulos das linhas em ordem crescente.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df=unsorted_df.sort_index()
print sorted_df

Está output é o seguinte -

col2       col1
0   0.208464   0.627037
1   0.641004   0.331352
2  -0.038067  -0.464730
3  -0.638456  -0.021466
4   0.014646  -0.737438
5  -0.290761  -1.669827
6  -0.797303  -0.018737
7   0.525753   1.628921
8  -0.567031   0.775951
9   0.060724  -0.322425

Ordem de classificação

Ao passar o valor booleano para o parâmetro ascendente, a ordem da classificação pode ser controlada. Vamos considerar o seguinte exemplo para entender o mesmo.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df = unsorted_df.sort_index(ascending=False)
print sorted_df

Está output é o seguinte -

col2        col1
9    0.825697    0.374463
8   -1.699509    0.510373
7   -0.581378    0.622958
6   -0.202951    0.954300
5   -1.289321   -1.551250
4    1.302561    0.851385
3   -0.157915   -0.388659
2   -1.222295    0.166609
1    0.584890   -0.291048
0    0.668444   -0.061294

Classifique as colunas

Ao passar o argumento do eixo com valor 0 ou 1, a classificação pode ser feita nos rótulos das colunas. Por padrão, eixo = 0, classificar por linha. Vamos considerar o seguinte exemplo para entender o mesmo.

import pandas as pd
import numpy as np
 
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])
 
sorted_df=unsorted_df.sort_index(axis=1)

print sorted_df

Está output é o seguinte -

col1        col2
1   -0.291048    0.584890
4    0.851385    1.302561
6    0.954300   -0.202951
2    0.166609   -1.222295
3   -0.388659   -0.157915
5   -1.551250   -1.289321
9    0.374463    0.825697
8    0.510373   -1.699509
0   -0.061294    0.668444
7    0.622958   -0.581378

Por valor

Como classificação de índice, sort_values()é o método de classificação por valores. Ele aceita um argumento 'por' que usará o nome da coluna do DataFrame com o qual os valores serão classificados.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by='col1')

print sorted_df

Está output é o seguinte -

col1  col2
1    1    3
2    1    2
3    1    4
0    2    1

Observe, os valores col1 são classificados e o respectivo valor col2 e índice da linha serão alterados junto com col1. Portanto, eles parecem não classificados.

'by' argumento leva uma lista de valores de coluna.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by=['col1','col2'])

print sorted_df

Está output é o seguinte -

col1 col2
2   1   2
1   1   3
3   1   4
0   2   1

Algoritmo de classificação

sort_values()fornece uma opção para escolher o algoritmo de mergesort, heapsort e quicksort. Mergesort é o único algoritmo estável.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')

print sorted_df

Está output é o seguinte -

col1 col2
1    1    3
2    1    2
3    1    4
0    2    1

Neste capítulo, discutiremos as operações de string com nossa Série / Índice básico. Nos capítulos subsequentes, aprenderemos como aplicar essas funções de string no DataFrame.

O Pandas oferece um conjunto de funções de string que facilitam a operação com dados de string. Mais importante ainda, essas funções ignoram (ou excluem) valores ausentes / NaN.

Quase, todos esses métodos funcionam com funções de string Python (consulte: https://docs.python.org/3/library/stdtypes.html#string-methods) Portanto, converta o objeto de série em objeto de seqüência de caracteres e execute a operação.

Vamos agora ver o desempenho de cada operação.

Sr. Não	Descrição da função
1	lower() Converte strings na série / índice em minúsculas.
2	upper() Converte strings na série / índice em maiúsculas.
3	len() Calcula o comprimento da string ().
4	strip() Ajuda a remover espaços em branco (incluindo nova linha) de cada string na série / índice de ambos os lados.
5	split(' ') Divide cada string com o padrão fornecido.
6	cat(sep=' ') Concatena os elementos da série / índice com o separador fornecido.
7	get_dummies() Retorna o DataFrame com valores One-Hot Encoded.
8	contains(pattern) Retorna um valor booleano True para cada elemento se a substring contiver o elemento, caso contrário, False.
9	replace(a,b) Substitui o valor a com o valor b.
10	repeat(value) Repete cada elemento com o número especificado de vezes.
11	count(pattern) Retorna a contagem da aparência do padrão em cada elemento.
12	startswith(pattern) Retorna verdadeiro se o elemento na Série / Índice começar com o padrão.
13	endswith(pattern) Retorna verdadeiro se o elemento na Série / Índice terminar com o padrão.
14	find(pattern) Retorna a primeira posição da primeira ocorrência do padrão.
15	findall(pattern) Retorna uma lista de todas as ocorrências do padrão.
16	swapcase Troca a caixa entre inferior / superior.
17	islower() Verifica se todos os caracteres em cada string na Série / Índice estão em minúsculas ou não. Retorna Boolean
18	isupper() Verifica se todos os caracteres em cada string na Série / Índice estão em maiúsculas ou não. Retorna Boolean.
19	isnumeric() Verifica se todos os caracteres em cada string na Série / Índice são numéricos. Retorna Boolean.

Vamos agora criar uma série e ver como todas as funções acima funcionam.

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s

Está output é o seguinte -

0            Tom
1   William Rick
2           John
3        Alber@t
4            NaN
5           1234
6    Steve Smith
dtype: object

mais baixo()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.lower()

Está output é o seguinte -

0            tom
1   william rick
2           john
3        alber@t
4            NaN
5           1234
6    steve smith
dtype: object

superior()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.upper()

Está output é o seguinte -

0            TOM
1   WILLIAM RICK
2           JOHN
3        ALBER@T
4            NaN
5           1234
6    STEVE SMITH
dtype: object

len ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()

Está output é o seguinte -

0    3.0
1   12.0
2    4.0
3    7.0
4    NaN
5    4.0
6   10.0
dtype: float64

faixa()

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After Stripping:")
print s.str.strip()

Está output é o seguinte -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

After Stripping:
0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

divisão (padrão)

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("Split Pattern:")
print s.str.split(' ')

Está output é o seguinte -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

Split Pattern:
0   [Tom, , , , , , , , , , ]
1   [, , , , , William, Rick]
2   [John]
3   [Alber@t]
dtype: object

gato (sep = padrão)

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.cat(sep='_')

Está output é o seguinte -

Tom _ William Rick_John_Alber@t

get_dummies ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.get_dummies()

Está output é o seguinte -

William Rick   Alber@t   John   Tom
0             0         0      0     1
1             1         0      0     0
2             0         0      1     0
3             0         1      0     0

contém ()

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.contains(' ')

Está output é o seguinte -

0   True
1   True
2   False
3   False
dtype: bool

substituir (a, b)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After replacing @ with $:") print s.str.replace('@','$')

Está output é o seguinte -

0   Tom
1   William Rick
2   John
3   Alber@t
dtype: object

After replacing @ with $: 0 Tom 1 William Rick 2 John 3 Alber$t
dtype: object

repetir (valor)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.repeat(2)

Está output é o seguinte -

0   Tom            Tom
1   William Rick   William Rick
2                  JohnJohn
3                  Alber@tAlber@t
dtype: object

contagem (padrão)

import pandas as pd
 
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("The number of 'm's in each string:")
print s.str.count('m')

Está output é o seguinte -

The number of 'm's in each string:
0    1
1    1
2    0
3    0

começa com (padrão)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("Strings that start with 'T':")
print s.str. startswith ('T')

Está output é o seguinte -

0  True
1  False
2  False
3  False
dtype: bool

endswith (padrão)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')

Está output é o seguinte -

Strings that end with 't':
0  False
1  False
2  False
3  True
dtype: bool

encontrar (padrão)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.find('e')

Está output é o seguinte -

0  -1
1  -1
2  -1
3   3
dtype: int64

"-1" indica que esse padrão não está disponível no elemento.

findall (padrão)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.findall('e')

Está output é o seguinte -

0 []
1 []
2 []
3 [e]
dtype: object

Lista nula ([]) indica que esse padrão não está disponível no elemento.

swapcase ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()

Está output é o seguinte -

0  tOM
1  wILLIAM rICK
2  jOHN
3  aLBER@T
dtype: object

é inferior()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.islower()

Está output é o seguinte -

0  False
1  False
2  False
3  False
dtype: bool

isupper ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isupper()

Está output é o seguinte -

0  False
1  False
2  False
3  False
dtype: bool

isnumeric ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isnumeric()

Está output é o seguinte -

0  False
1  False
2  False
3  False
dtype: bool

Pandas fornecem API para personalizar alguns aspectos de seu comportamento, a exibição está sendo usada principalmente.

A API é composta por cinco funções relevantes. Eles são -

• get_option()
• set_option()
• reset_option()
• describe_option()
• option_context()

Vamos agora entender como as funções operam.

get_option (param)

get_option recebe um único parâmetro e retorna o valor conforme fornecido na saída abaixo -

display.max_rows

Exibe o número padrão de valor. O intérprete lê esse valor e exibe as linhas com esse valor como o limite superior a ser exibido.

import pandas as pd
print pd.get_option("display.max_rows")

Está output é o seguinte -

60

display.max_columns

Exibe o número padrão de valor. O intérprete lê esse valor e exibe as linhas com esse valor como o limite superior a ser exibido.

import pandas as pd
print pd.get_option("display.max_columns")

Está output é o seguinte -

20

Aqui, 60 e 20 são os valores dos parâmetros de configuração padrão.

set_option (param, valor)

set_option leva dois argumentos e define o valor para o parâmetro conforme mostrado abaixo -

display.max_rows

Usando set_option(), podemos alterar o número padrão de linhas a serem exibidas.

import pandas as pd

pd.set_option("display.max_rows",80)

print pd.get_option("display.max_rows")

Está output é o seguinte -

80

display.max_columns

Usando set_option(), podemos alterar o número padrão de linhas a serem exibidas.

import pandas as pd

pd.set_option("display.max_columns",30)

print pd.get_option("display.max_columns")

Está output é o seguinte -

30

reset_option (param)

reset_option recebe um argumento e define o valor de volta para o valor padrão.

display.max_rows

Usando reset_option (), podemos mudar o valor de volta para o número padrão de linhas a serem exibidas.

import pandas as pd

pd.reset_option("display.max_rows")
print pd.get_option("display.max_rows")

Está output é o seguinte -

60

describe_option (param)

describe_option imprime a descrição do argumento.

display.max_rows

Usando reset_option (), podemos mudar o valor de volta para o número padrão de linhas a serem exibidas.

import pandas as pd
pd.describe_option("display.max_rows")

Está output é o seguinte -

display.max_rows : int
   If max_rows is exceeded, switch to truncate view. Depending on
   'large_repr', objects are either centrally truncated or printed as
   a summary view. 'None' value means unlimited.

   In case python/IPython is running in a terminal and `large_repr`
   equals 'truncate' this can be set to 0 and pandas will auto-detect
   the height of the terminal and print a truncated object which fits
   the screen height. The IPython notebook, IPython qtconsole, or
   IDLE do not run in a terminal and hence it is not possible to do
   correct auto-detection.
   [default: 60] [currently: 60]

option_context ()

o gerenciador de contexto option_context é usado para definir a opção em with statementtemporariamente. Os valores das opções são restaurados automaticamente quando você sai dowith block -

display.max_rows

Usando option_context (), podemos definir o valor temporariamente.

import pandas as pd
with pd.option_context("display.max_rows",10):
   print(pd.get_option("display.max_rows"))
   print(pd.get_option("display.max_rows"))

Está output é o seguinte -

10
10

Veja, a diferença entre a primeira e a segunda declaração de impressão. A primeira instrução imprime o valor definido poroption_context() que é temporário dentro do with contextem si. Depois dewith context, a segunda instrução de impressão imprime o valor configurado.

Parâmetros usados ​​com frequência

Sr. Não	Parâmetro e Descrição
1	display.max_rows Exibe o número máximo de linhas para exibir
2	2 display.max_columns Exibe o número máximo de colunas para exibir
3	display.expand_frame_repr Exibe DataFrames para esticar páginas
4	display.max_colwidth Exibe a largura máxima da coluna
5	display.precision Exibe precisão para números decimais

Neste capítulo, discutiremos como fatiar e dividir a data e, geralmente, obter o subconjunto do objeto pandas.

Os operadores de indexação Python e NumPy "[]" e o operador de atributo "." fornecem acesso rápido e fácil às estruturas de dados do Pandas em uma ampla variedade de casos de uso. No entanto, como o tipo de dados a ser acessado não é conhecido com antecedência, o uso direto de operadores padrão tem alguns limites de otimização. Para código de produção, recomendamos que você tire vantagem dos métodos otimizados de acesso a dados do pandas explicados neste capítulo.

O Pandas agora oferece suporte a três tipos de indexação Multi-eixos; os três tipos são mencionados na tabela a seguir -

Sr. Não	Indexação e descrição
1	.loc() Com base em rótulo
2	.iloc() Baseado em inteiro
3	.ix() Com base em rótulo e número inteiro

.loc ()

Pandas fornecem vários métodos para ter puramente label based indexing. Ao fatiar, o limite inicial também é incluído. Os inteiros são rótulos válidos, mas eles se referem ao rótulo e não à posição.

.loc() tem vários métodos de acesso como -

• Um único rótulo escalar
• Uma lista de rótulos
• Um objeto de fatia
• Uma matriz booleana

locleva dois operadores únicos / lista / intervalo separados por ','. O primeiro indica a linha e o segundo indica as colunas.

Exemplo 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

#select all rows for a specific column
print df.loc[:,'A']

Está output é o seguinte -

a   0.391548
b  -0.070649
c  -0.317212
d  -2.162406
e   2.202797
f   0.613709
g   1.050559
h   1.122680
Name: A, dtype: float64

Exemplo 2

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select all rows for multiple columns, say list[]
print df.loc[:,['A','C']]

Está output é o seguinte -

A           C
a    0.391548    0.745623
b   -0.070649    1.620406
c   -0.317212    1.448365
d   -2.162406   -0.873557
e    2.202797    0.528067
f    0.613709    0.286414
g    1.050559    0.216526
h    1.122680   -1.621420

Exemplo 3

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select few rows for multiple columns, say list[]
print df.loc[['a','b','f','h'],['A','C']]

Está output é o seguinte -

A          C
a   0.391548   0.745623
b  -0.070649   1.620406
f   0.613709   0.286414
h   1.122680  -1.621420

Exemplo 4

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select range of rows for all columns
print df.loc['a':'h']

Está output é o seguinte -

A           B          C          D
a    0.391548   -0.224297   0.745623   0.054301
b   -0.070649   -0.880130   1.620406   1.419743
c   -0.317212   -1.929698   1.448365   0.616899
d   -2.162406    0.614256  -0.873557   1.093958
e    2.202797   -2.315915   0.528067   0.612482
f    0.613709   -0.157674   0.286414  -0.500517
g    1.050559   -2.272099   0.216526   0.928449
h    1.122680    0.324368  -1.621420  -0.741470

Exemplo 5

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# for getting values with a boolean array
print df.loc['a']>0

Está output é o seguinte -

A  False
B  True
C  False
D  False
Name: a, dtype: bool

.iloc ()

O Pandas fornece vários métodos para obter indexação puramente baseada em inteiros. Como python e numpy, estes são0-based indexação.

Os vários métodos de acesso são os seguintes -

• Um inteiro
• Uma lista de inteiros
• Uma gama de valores

Exemplo 1

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# select all rows for a specific column
print df.iloc[:4]

Está output é o seguinte -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.iloc[:4]
print df.iloc[1:5, 2:4]

Está output é o seguinte -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

           C          D
1  -0.813012   0.631615
2   0.025070   0.230806
3   0.826977  -0.026251
4   1.423332   1.130568

Exemplo 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Slicing through list of values
print df.iloc[[1, 3, 5], [1, 3]]
print df.iloc[1:3, :]
print df.iloc[:,1:3]

Está output é o seguinte -

B           D
1   0.890791    0.631615
3  -1.284314   -0.026251
5  -0.512888   -0.518930

           A           B           C           D
1  -0.685354    0.890791   -0.813012    0.631615
2  -0.783192   -0.531378    0.025070    0.230806

           B           C
0   0.256239   -1.270702
1   0.890791   -0.813012
2  -0.531378    0.025070
3  -1.284314    0.826977
4  -0.460729    1.423332
5  -0.512888    0.581409
6  -1.204853    0.098060
7  -0.947857    0.641358

.ix ()

Além de baseado em rótulo puro e baseado em inteiro, Pandas fornece um método híbrido para seleções e subconjuntos do objeto usando o operador .ix ().

Exemplo 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.ix[:4]

Está output é o seguinte -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Index slicing
print df.ix[:,'A']

Está output é o seguinte -

0   0.699435
1  -0.685354
2  -0.783192
3   0.539042
4  -1.044209
5  -1.415411
6   1.062095
7   0.994204
Name: A, dtype: float64

Uso de notações

Obter valores do objeto Pandas com indexação Multi-eixos usa a seguinte notação -

Objeto	Indexadores	Tipo de Devolução
Series	s.loc [indexador]	Valor escalar
Quadro de dados	df.loc [row_index, col_index]	Objeto de série
Painel	p.loc [item_index, major_index, minor_index]	p.loc [item_index, major_index, minor_index]

Note − .iloc() & .ix() aplica as mesmas opções de indexação e valor de retorno.

Vamos agora ver como cada operação pode ser executada no objeto DataFrame. Usaremos o operador de indexação básico '[]' -

Exemplo 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df['A']

Está output é o seguinte -

0  -0.478893
1   0.391931
2   0.336825
3  -1.055102
4  -0.165218
5  -0.328641
6   0.567721
7  -0.759399
Name: A, dtype: float64

Note - Podemos passar uma lista de valores para [] para selecionar essas colunas.

Exemplo 2

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df[['A','B']]

Está output é o seguinte -

A           B
0  -0.478893   -0.606311
1   0.391931   -0.949025
2   0.336825    0.093717
3  -1.055102   -0.012944
4  -0.165218    1.550310
5  -0.328641   -0.226363
6   0.567721   -0.312585
7  -0.759399   -0.372696

Exemplo 3

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[2:2]

Está output é o seguinte -

Columns: [A, B, C, D]
Index: []

Acesso de Atributo

As colunas podem ser selecionadas usando o operador de atributo '.'.

Exemplo

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df.A

Está output é o seguinte -

0   -0.478893
1    0.391931
2    0.336825
3   -1.055102
4   -0.165218
5   -0.328641
6    0.567721
7   -0.759399
Name: A, dtype: float64

Os métodos estatísticos auxiliam na compreensão e análise do comportamento dos dados. Vamos agora aprender algumas funções estatísticas, que podemos aplicar em objetos Pandas.

Mudança percentual

Series, DatFrames e Panel, todos têm a função pct_change(). Esta função compara cada elemento com seu elemento anterior e calcula a porcentagem de alteração.

import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,4])
print s.pct_change()

df = pd.DataFrame(np.random.randn(5, 2))
print df.pct_change()

Está output é o seguinte -

0        NaN
1   1.000000
2   0.500000
3   0.333333
4   0.250000
5  -0.200000
dtype: float64

            0          1
0         NaN        NaN
1  -15.151902   0.174730
2  -0.746374   -1.449088
3  -3.582229   -3.165836
4   15.601150  -1.860434

Por padrão, o pct_change()opera em colunas; se você quiser aplicar a mesma linha, useaxis=1() argumento.

Covariância

A covariância é aplicada aos dados da série. O objeto Series tem um método cov para calcular a covariância entre os objetos da série. NA será excluído automaticamente.

Cov Series

import pandas as pd
import numpy as np
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print s1.cov(s2)

Está output é o seguinte -

-0.12978405324

Método de covariância quando aplicado em um DataFrame, calcula cov entre todas as colunas.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()

Está output é o seguinte -

-0.58312921152741437

           a           b           c           d            e
a   1.780628   -0.583129   -0.185575    0.003679    -0.136558
b  -0.583129    1.297011    0.136530   -0.523719     0.251064
c  -0.185575    0.136530    0.915227   -0.053881    -0.058926
d   0.003679   -0.523719   -0.053881    1.521426    -0.487694
e  -0.136558    0.251064   -0.058926   -0.487694     0.960761

Note - Observe o cov entre a e b coluna na primeira instrução e o mesmo é o valor retornado por cov no DataFrame.

Correlação

A correlação mostra a relação linear entre quaisquer duas matrizes de valores (séries). Existem vários métodos para calcular a correlação, como Pearson (padrão), Spearman e Kendall.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])

print frame['a'].corr(frame['b'])
print frame.corr()

Está output é o seguinte -

-0.383712785514

           a          b          c          d           e
a   1.000000  -0.383713  -0.145368   0.002235   -0.104405
b  -0.383713   1.000000   0.125311  -0.372821    0.224908
c  -0.145368   0.125311   1.000000  -0.045661   -0.062840
d   0.002235  -0.372821  -0.045661   1.000000   -0.403380
e  -0.104405   0.224908  -0.062840  -0.403380    1.000000

Se qualquer coluna não numérica estiver presente no DataFrame, ela será excluída automaticamente.

Classificação de dados

A classificação de dados produz uma classificação para cada elemento na matriz de elementos. Em caso de empate, atribui a classificação média.

import pandas as pd
import numpy as np

s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()

Está output é o seguinte -

a  1.0
b  3.5
c  2.0
d  3.5
e  5.0
dtype: float64

A classificação opcionalmente leva um parâmetro crescente que por padrão é verdadeiro; quando falso, os dados são classificados de forma reversa, com valores maiores atribuídos a uma classificação menor.

Rank suporta diferentes métodos de desempate, especificados com o parâmetro method -

• average - classificação média do grupo empatado

• min - classificação mais baixa no grupo

• max - classificação mais alta do grupo

• first - classificações atribuídas na ordem em que aparecem na matriz

Para trabalhar com dados numéricos, o Pandas fornece algumas variantes, como pesos de rolagem, expansão e movimentação exponencial para estatísticas de janela. Entre estes estãosum, mean, median, variance, covariance, correlation, etc.

Agora aprenderemos como cada um deles pode ser aplicado em objetos DataFrame.

Função .rolling ()

Esta função pode ser aplicada a uma série de dados. Especifique owindow=n argumento e aplique a função estatística apropriada sobre ele.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.rolling(window=3).mean()

Está output é o seguinte -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.628267   -0.047040   -0.287467   -0.161110
2000-01-05   0.398233    0.003517    0.099126   -0.405565
2000-01-06   0.641798    0.656184   -0.322728    0.428015
2000-01-07   0.188403    0.010913   -0.708645    0.160932
2000-01-08   0.188043   -0.253039   -0.818125   -0.108485
2000-01-09   0.682819   -0.606846   -0.178411   -0.404127
2000-01-10   0.688583    0.127786    0.513832   -1.067156

Note - Como o tamanho da janela é 3, para os dois primeiros elementos há nulos e a partir do terceiro o valor será a média do n, n-1 e n-2elementos Assim, também podemos aplicar várias funções conforme mencionado acima.

Função .expanding ()

Esta função pode ser aplicada a uma série de dados. Especifique omin_periods=n argumento e aplique a função estatística apropriada sobre ele.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()

Está output é o seguinte -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.743328   -0.198015   -0.852462   -0.262547
2000-01-05   0.614776   -0.205649   -0.583641   -0.303254
2000-01-06   0.538175   -0.005878   -0.687223   -0.199219
2000-01-07   0.505503   -0.108475   -0.790826   -0.081056
2000-01-08   0.454751   -0.223420   -0.671572   -0.230215
2000-01-09   0.586390   -0.206201   -0.517619   -0.267521
2000-01-10   0.560427   -0.037597   -0.399429   -0.376886

Função .ewm ()

ewmé aplicado em uma série de dados. Especifique qualquer um dos com, span,halflifeargumento e aplique a função estatística apropriada sobre ele. Ele atribui os pesos exponencialmente.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.ewm(com=0.5).mean()

Está output é o seguinte -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.865131   -0.453626   -1.137961    0.058747
2000-01-03  -0.132245   -0.807671   -0.308308   -1.491002
2000-01-04   1.084036    0.555444   -0.272119    0.480111
2000-01-05   0.425682    0.025511    0.239162   -0.153290
2000-01-06   0.245094    0.671373   -0.725025    0.163310
2000-01-07   0.288030   -0.259337   -1.183515    0.473191
2000-01-08   0.162317   -0.771884   -0.285564   -0.692001
2000-01-09   1.147156   -0.302900    0.380851   -0.607976
2000-01-10   0.600216    0.885614    0.569808   -1.110113

As funções de janela são usadas principalmente para encontrar as tendências nos dados graficamente, suavizando a curva. Se houver muita variação nos dados diários e muitos pontos de dados estiverem disponíveis, pegar as amostras e plotar é um método e aplicar os cálculos da janela e plotar o gráfico nos resultados é outro método. Por meio desses métodos, podemos suavizar a curva ou a tendência.

Depois de rolar, expandir e ewm objetos são criados, vários métodos estão disponíveis para realizar agregações em dados.

Aplicação de agregações no DataFrame

Vamos criar um DataFrame e aplicar agregações nele.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])

print df
r = df.rolling(window=3,min_periods=1)
print r

Está output é o seguinte -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.790670   -0.387854   -0.668132    0.267283
2000-01-03  -0.575523   -0.965025    0.060427   -2.179780
2000-01-04   1.669653    1.211759   -0.254695    1.429166
2000-01-05   0.100568   -0.236184    0.491646   -0.466081
2000-01-06   0.155172    0.992975   -1.205134    0.320958
2000-01-07   0.309468   -0.724053   -1.412446    0.627919
2000-01-08   0.099489   -1.028040    0.163206   -1.274331
2000-01-09   1.639500   -0.068443    0.714008   -0.565969
2000-01-10   0.326761    1.479841    0.664282   -1.361169

Rolling [window=3,min_periods=1,center=False,axis=0]

Podemos agregar passando uma função para todo o DataFrame ou selecionar uma coluna por meio do padrão get item método.

Aplicar agregação em um Dataframe inteiro

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)

Está output é o seguinte -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

                    A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

Aplicar agregação em uma única coluna de um Dataframe

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate(np.sum)

Está output é o seguinte -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
2000-01-01   1.088512
2000-01-02   1.879182
2000-01-03   1.303660
2000-01-04   1.884801
2000-01-05   1.194699
2000-01-06   1.925393
2000-01-07   0.565208
2000-01-08   0.564129
2000-01-09   2.048458
2000-01-10   2.065750
Freq: D, Name: A, dtype: float64

Aplicar agregação em várias colunas de um DataFrame

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate(np.sum)

Está output é o seguinte -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A           B
2000-01-01   1.088512   -0.650942
2000-01-02   1.879182   -1.038796
2000-01-03   1.303660   -2.003821
2000-01-04   1.884801   -0.141119
2000-01-05   1.194699    0.010551
2000-01-06   1.925393    1.968551
2000-01-07   0.565208    0.032738
2000-01-08   0.564129   -0.759118
2000-01-09   2.048458   -1.820537
2000-01-10   2.065750    0.383357

Aplicar múltiplas funções em uma única coluna de um DataFrame

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])

Está output é o seguinte -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                  sum       mean
2000-01-01   1.088512   1.088512
2000-01-02   1.879182   0.939591
2000-01-03   1.303660   0.434553
2000-01-04   1.884801   0.628267
2000-01-05   1.194699   0.398233
2000-01-06   1.925393   0.641798
2000-01-07   0.565208   0.188403
2000-01-08   0.564129   0.188043
2000-01-09   2.048458   0.682819
2000-01-10   2.065750   0.688583

Aplicar várias funções em várias colunas de um DataFrame

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate([np.sum,np.mean])

Está output é o seguinte -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A                      B
                  sum       mean         sum        mean
2000-01-01   1.088512   1.088512   -0.650942   -0.650942
2000-01-02   1.879182   0.939591   -1.038796   -0.519398
2000-01-03   1.303660   0.434553   -2.003821   -0.667940
2000-01-04   1.884801   0.628267   -0.141119   -0.047040
2000-01-05   1.194699   0.398233    0.010551    0.003517
2000-01-06   1.925393   0.641798    1.968551    0.656184
2000-01-07   0.565208   0.188403    0.032738    0.010913
2000-01-08   0.564129   0.188043   -0.759118   -0.253039
2000-01-09   2.048458   0.682819   -1.820537   -0.606846
2000-01-10   2.065750   0.688583    0.383357    0.127786

Aplicar diferentes funções a diferentes colunas de um dataframe

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(3, 4),
   index = pd.date_range('1/1/2000', periods=3),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate({'A' : np.sum,'B' : np.mean})

Está output é o seguinte -

A          B          C         D
2000-01-01  -1.575749  -1.018105   0.317797  0.545081
2000-01-02  -0.164917  -1.361068   0.258240  1.113091
2000-01-03   1.258111   1.037941  -0.047487  0.867371
                    A          B
2000-01-01  -1.575749  -1.018105
2000-01-02  -1.740666  -1.189587
2000-01-03  -0.482555  -0.447078

Dados ausentes são sempre um problema em cenários da vida real. Áreas como aprendizado de máquina e mineração de dados enfrentam problemas graves na precisão de suas previsões de modelo devido à baixa qualidade dos dados causada por valores ausentes. Nessas áreas, o tratamento de valor faltante é o principal ponto de foco para tornar seus modelos mais precisos e válidos.

Quando e por que os dados estão perdidos?

Vamos considerar uma pesquisa online para um produto. Muitas vezes, as pessoas não compartilham todas as informações relacionadas a elas. Poucas pessoas compartilham sua experiência, mas não há quanto tempo estão usando o produto; poucas pessoas compartilham há quanto tempo estão usando o produto, sua experiência, mas não suas informações de contato. Assim, de uma forma ou de outra sempre falta uma parte dos dados, e isso é muito comum em tempo real.

Vamos agora ver como podemos lidar com valores ausentes (digamos NA ou NaN) usando o Pandas.

# import the pandas library
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df

Está output é o seguinte -

one        two      three
a   0.077988   0.476149   0.965836
b        NaN        NaN        NaN
c  -0.390208  -0.551605  -2.301950
d        NaN        NaN        NaN
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g        NaN        NaN        NaN
h   0.085100   0.532791   0.887415

Usando a reindexação, criamos um DataFrame com valores ausentes. Na saída,NaN significa Not a Number.

Verifique se há valores ausentes

Para tornar a detecção de valores ausentes mais fácil (e entre diferentes tipos de matriz), o Pandas fornece o isnull() e notnull() funções, que também são métodos em objetos Series e DataFrame -

Exemplo 1

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].isnull()

Está output é o seguinte -

a  False
b  True
c  False
d  True
e  False
f  False
g  True
h  False
Name: one, dtype: bool

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].notnull()

Está output é o seguinte -

a  True
b  False
c  True
d  False
e  True
f  True
g  False
h  True
Name: one, dtype: bool

Cálculos com dados ausentes

• Ao somar os dados, NA será tratado como Zero
• Se os dados forem todos NA, o resultado será NA

Exemplo 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].sum()

Está output é o seguinte -

2.02357685917

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame(index=[0,1,2,3,4,5],columns=['one','two'])
print df['one'].sum()

Está output é o seguinte -

nan

Limpeza / preenchimento de dados ausentes

O Pandas fornece vários métodos para limpar os valores ausentes. A função fillna pode “preencher” os valores NA com dados não nulos de algumas maneiras, que ilustramos nas seções a seguir.

Substitua NaN por um valor escalar

O programa a seguir mostra como você pode substituir "NaN" por "0".

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])

df = df.reindex(['a', 'b', 'c'])

print df
print ("NaN replaced with '0':")
print df.fillna(0)

Está output é o seguinte -

one        two     three
a  -0.576991  -0.741695  0.553172
b        NaN        NaN       NaN
c   0.744328  -1.735166  1.749580

NaN replaced with '0':
         one        two     three
a  -0.576991  -0.741695  0.553172
b   0.000000   0.000000  0.000000
c   0.744328  -1.735166  1.749580

Aqui, estamos preenchendo com valor zero; em vez disso, também podemos preencher com qualquer outro valor.

Preencher NA para frente e para trás

Usando os conceitos de preenchimento discutidos no Capítulo ReIndexação, preencheremos os valores ausentes.

Sr. Não	Método e Ação
1	pad/fill Métodos de preenchimento para frente
2	bfill/backfill Métodos de preenchimento para trás

Exemplo 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='pad')

Está output é o seguinte -

one        two      three
a   0.077988   0.476149   0.965836
b   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
d  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='backfill')

Está output é o seguinte -

one        two      three
a   0.077988   0.476149   0.965836
b  -0.390208  -0.551605  -2.301950
c  -0.390208  -0.551605  -2.301950
d  -2.000303  -0.788201   1.510072
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g   0.085100   0.532791   0.887415
h   0.085100   0.532791   0.887415

Abandone os valores ausentes

Se você deseja simplesmente excluir os valores ausentes, use o dropna funcionar junto com o axisargumento. Por padrão, eixo = 0, ou seja, ao longo da linha, o que significa que se qualquer valor dentro de uma linha for NA, toda a linha é excluída.

Exemplo 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna()

Está output é o seguinte -

one        two      three
a   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna(axis=1)

Está output é o seguinte -

Empty DataFrame
Columns: [ ]
Index: [a, b, c, d, e, f, g, h]

Substituir Valores Ausentes (ou) Genéricos

Muitas vezes, temos que substituir um valor genérico por algum valor específico. Podemos conseguir isso aplicando o método de substituição.

Substituir NA por um valor escalar é um comportamento equivalente do fillna() função.

Exemplo 1

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})

print df.replace({1000:10,2000:60})

Está output é o seguinte -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Exemplo 2

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})

Está output é o seguinte -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Qualquer groupbyoperação envolve uma das seguintes operações no objeto original. Eles são -

• Splitting o objeto

• Applying uma função

• Combining os resultados

Em muitas situações, dividimos os dados em conjuntos e aplicamos algumas funcionalidades em cada subconjunto. Na funcionalidade de aplicação, podemos realizar as seguintes operações -

• Aggregation - calcular uma estatística resumida

• Transformation - realizar alguma operação específica do grupo

• Filtration - descartar os dados com alguma condição

Vamos agora criar um objeto DataFrame e realizar todas as operações nele -

#import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df

Está output é o seguinte -

Points   Rank     Team   Year
0      876      1   Riders   2014
1      789      2   Riders   2015
2      863      2   Devils   2014
3      673      3   Devils   2015
4      741      3    Kings   2014
5      812      4    kings   2015
6      756      1    Kings   2016
7      788      1    Kings   2017
8      694      2   Riders   2016
9      701      4   Royals   2014
10     804      1   Royals   2015
11     690      2   Riders   2017

Dividir dados em grupos

O objeto Pandas pode ser dividido em qualquer um de seus objetos. Existem várias maneiras de dividir um objeto como -

• obj.groupby('key')
• obj.groupby(['key1','key2'])
• obj.groupby(key,axis=1)

Vamos agora ver como os objetos de agrupamento podem ser aplicados ao objeto DataFrame

Exemplo

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team')

Está output é o seguinte -

<pandas.core.groupby.DataFrameGroupBy object at 0x7fa46a977e50>

Ver Grupos

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').groups

Está output é o seguinte -

{'Kings': Int64Index([4, 6, 7],      dtype='int64'),
'Devils': Int64Index([2, 3],         dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11],  dtype='int64'),
'Royals': Int64Index([9, 10],        dtype='int64'),
'kings' : Int64Index([5],            dtype='int64')}

Exemplo

Group by com várias colunas -

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby(['Team','Year']).groups

Está output é o seguinte -

{('Kings', 2014): Int64Index([4], dtype='int64'),
 ('Royals', 2014): Int64Index([9], dtype='int64'),
 ('Riders', 2014): Int64Index([0], dtype='int64'),
 ('Riders', 2015): Int64Index([1], dtype='int64'),
 ('Kings', 2016): Int64Index([6], dtype='int64'),
 ('Riders', 2016): Int64Index([8], dtype='int64'),
 ('Riders', 2017): Int64Index([11], dtype='int64'),
 ('Devils', 2014): Int64Index([2], dtype='int64'),
 ('Devils', 2015): Int64Index([3], dtype='int64'),
 ('kings', 2015): Int64Index([5], dtype='int64'),
 ('Royals', 2015): Int64Index([10], dtype='int64'),
 ('Kings', 2017): Int64Index([7], dtype='int64')}

Iterando por grupos

Com o groupby objeto em mãos, podemos iterar por meio do objeto semelhante a itertools.obj.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')

for name,group in grouped:
   print name
   print group

Está output é o seguinte -

2014
   Points  Rank     Team   Year
0     876     1   Riders   2014
2     863     2   Devils   2014
4     741     3   Kings    2014
9     701     4   Royals   2014

2015
   Points  Rank     Team   Year
1     789     2   Riders   2015
3     673     3   Devils   2015
5     812     4    kings   2015
10    804     1   Royals   2015

2016
   Points  Rank     Team   Year
6     756     1    Kings   2016
8     694     2   Riders   2016

2017
   Points  Rank    Team   Year
7     788     1   Kings   2017
11    690     2  Riders   2017

Por padrão, o groupby objeto tem o mesmo nome de rótulo que o nome do grupo.

Selecione um Grupo

Usando o get_group() método, podemos selecionar um único grupo.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped.get_group(2014)

Está output é o seguinte -

Points  Rank     Team    Year
0     876     1   Riders    2014
2     863     2   Devils    2014
4     741     3   Kings     2014
9     701     4   Royals    2014

Agregações

Uma função agregada retorna um único valor agregado para cada grupo. Uma vez ogroup by objeto é criado, várias operações de agregação podem ser realizadas nos dados agrupados.

Um óbvio é a agregação por meio do agregado ou equivalente agg método -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)

Está output é o seguinte -

Year
2014   795.25
2015   769.50
2016   725.00
2017   739.00
Name: Points, dtype: float64

Outra maneira de ver o tamanho de cada grupo é aplicando a função size () -

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

Attribute Access in Python Pandas
grouped = df.groupby('Team')
print grouped.agg(np.size)

Está output é o seguinte -

Points   Rank   Year
Team
Devils        2      2      2
Kings         3      3      3
Riders        4      4      4
Royals        2      2      2
kings         1      1      1

Aplicação de múltiplas funções de agregação de uma só vez

Com as séries agrupadas, você também pode passar um list ou dict of functions para fazer agregação e gerar DataFrame como saída -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
print grouped['Points'].agg([np.sum, np.mean, np.std])

Está output é o seguinte -

Team      sum      mean          std
Devils   1536   768.000000   134.350288
Kings    2285   761.666667    24.006943
Riders   3049   762.250000    88.567771
Royals   1505   752.500000    72.831998
kings     812   812.000000          NaN

Transformações

A transformação em um grupo ou coluna retorna um objeto indexado com o mesmo tamanho daquele que está sendo agrupado. Portanto, a transformação deve retornar um resultado do mesmo tamanho que o de um bloco de grupo.

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)

Está output é o seguinte -

Points        Rank        Year
0   12.843272  -15.000000  -11.618950
1   3.020286     5.000000   -3.872983
2   7.071068    -7.071068   -7.071068
3  -7.071068     7.071068    7.071068
4  -8.608621    11.547005  -10.910895
5        NaN          NaN         NaN
6  -2.360428    -5.773503    2.182179
7  10.969049    -5.773503    8.728716
8  -7.705963     5.000000    3.872983
9  -7.071068     7.071068   -7.071068
10  7.071068    -7.071068    7.071068
11 -8.157595     5.000000   11.618950

Filtração

A filtragem filtra os dados em um critério definido e retorna o subconjunto de dados. ofilter() função é usada para filtrar os dados.

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').filter(lambda x: len(x) >= 3)

Está output é o seguinte -

Points  Rank     Team   Year
0      876     1   Riders   2014
1      789     2   Riders   2015
4      741     3   Kings    2014
6      756     1   Kings    2016
7      788     1   Kings    2017
8      694     2   Riders   2016
11     690     2   Riders   2017

Na condição de filtro acima, estamos solicitando o retorno das equipes que participaram três ou mais vezes do IPL.

O Pandas tem operações de junção na memória de alto desempenho e com recursos completos, de forma idiomática, muito semelhantes a bancos de dados relacionais como SQL.

O Pandas oferece uma única função, merge, como o ponto de entrada para todas as operações de junção de banco de dados padrão entre objetos DataFrame -

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)

Aqui, usamos os seguintes parâmetros -

• left - Um objeto DataFrame.

• right - Outro objeto DataFrame.

• on- Colunas (nomes) para unir. Deve ser encontrado nos objetos DataFrame esquerdo e direito.

• left_on- Colunas do DataFrame esquerdo para usar como chaves. Podem ser nomes de colunas ou matrizes com comprimento igual ao comprimento do DataFrame.

• right_on- Colunas do DataFrame certo para usar como chaves. Podem ser nomes de colunas ou matrizes com comprimento igual ao comprimento do DataFrame.

• left_index - se True,use o índice (rótulos de linha) do DataFrame esquerdo como sua (s) chave (s) de junção. No caso de um DataFrame com MultiIndex (hierárquico), o número de níveis deve corresponder ao número de chaves de junção do DataFrame correto.

• right_index - Mesmo uso que left_index para o DataFrame correto.

• how- Um de 'esquerda', 'direita', 'externo', 'interno'. O padrão é interno. Cada método foi descrito abaixo.

• sort- Classifique o DataFrame de resultado pelas chaves de junção em ordem lexicográfica. O padrão é True, definir como False melhorará o desempenho substancialmente em muitos casos.

Vamos agora criar dois DataFrames diferentes e realizar as operações de fusão neles.

# import the pandas library
import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame(
   {'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print left
print right

Está output é o seguinte -

Name  id   subject_id
0   Alex   1         sub1
1    Amy   2         sub2
2  Allen   3         sub4
3  Alice   4         sub6
4  Ayoung  5         sub5

    Name  id   subject_id
0  Billy   1         sub2
1  Brian   2         sub4
2  Bran    3         sub3
3  Bryce   4         sub6
4  Betty   5         sub5

Mesclar dois DataFrames em uma chave

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on='id')

Está output é o seguinte -

Name_x   id  subject_id_x   Name_y   subject_id_y
0  Alex      1          sub1    Billy           sub2
1  Amy       2          sub2    Brian           sub4
2  Allen     3          sub4     Bran           sub3
3  Alice     4          sub6    Bryce           sub6
4  Ayoung    5          sub5    Betty           sub5

Mesclar dois DataFrames em várias chaves

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on=['id','subject_id'])

Está output é o seguinte -

Name_x   id   subject_id   Name_y
0    Alice    4         sub6    Bryce
1   Ayoung    5         sub5    Betty

Mesclar usando o argumento 'como'

o howargumento para mesclar especifica como determinar quais chaves devem ser incluídas na tabela resultante. Se uma combinação de teclas não aparecer nas tabelas da esquerda ou da direita, os valores na tabela associada serão NA.

Aqui está um resumo do how opções e seus nomes equivalentes em SQL -

Método de fusão	SQL equivalente	Descrição
esquerda	LEFT OUTER JOIN	Use as chaves do objeto esquerdo
direito	DIREITO OUTER JOIN	Use as chaves do objeto certo
exterior	FULL OUTER JOIN	Use a união de chaves
interior	JUNÇÃO INTERNA	Use a interseção de chaves

Associação à esquerda

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='left')

Está output é o seguinte -

Name_x   id_x   subject_id   Name_y   id_y
0     Alex      1         sub1      NaN    NaN
1      Amy      2         sub2    Billy    1.0
2    Allen      3         sub4    Brian    2.0
3    Alice      4         sub6    Bryce    4.0
4   Ayoung      5         sub5    Betty    5.0

Junção certa

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='right')

Está output é o seguinte -

Name_x  id_x   subject_id   Name_y   id_y
0      Amy   2.0         sub2    Billy      1
1    Allen   3.0         sub4    Brian      2
2    Alice   4.0         sub6    Bryce      4
3   Ayoung   5.0         sub5    Betty      5
4      NaN   NaN         sub3     Bran      3

Junção Externa

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, how='outer', on='subject_id')

Está output é o seguinte -

Name_x  id_x   subject_id   Name_y   id_y
0     Alex   1.0         sub1      NaN    NaN
1      Amy   2.0         sub2    Billy    1.0
2    Allen   3.0         sub4    Brian    2.0
3    Alice   4.0         sub6    Bryce    4.0
4   Ayoung   5.0         sub5    Betty    5.0
5      NaN   NaN         sub3     Bran    3.0

Junção interna

A adesão será realizada no índice. A operação de junção honra o objeto no qual é chamada. Então,a.join(b) não é igual a b.join(a).

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='inner')

Está output é o seguinte -

Name_x   id_x   subject_id   Name_y   id_y
0      Amy      2         sub2    Billy      1
1    Allen      3         sub4    Brian      2
2    Alice      4         sub6    Bryce      4
3   Ayoung      5         sub5    Betty      5

Pandas oferece várias facilidades para combinar facilmente Series, DataFrame, e Panel objetos.

pd.concat(objs,axis=0,join='outer',join_axes=None,
ignore_index=False)

• objs - Esta é uma sequência ou mapeamento de objetos Series, DataFrame ou Panel.

• axis - {0, 1, ...}, padrão 0. Este é o eixo ao longo do qual concatenar.

• join- {'interno', 'externo'}, padrão 'externo'. Como lidar com índices em outro (s) eixo (s). Externo para união e interno para interseção.

• ignore_index- booleano, padrão False. Se for True, não use os valores de índice no eixo de concatenação. O eixo resultante será rotulado 0, ..., n - 1.

• join_axes- Esta é a lista de objetos de índice. Índices específicos a serem usados ​​para os outros (n-1) eixos em vez de realizar a lógica de definição interna / externa.

Objetos de concatenação

o concatA função faz todo o trabalho pesado de realizar operações de concatenação ao longo de um eixo. Vamos criar objetos diferentes e fazer concatenação.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two])

Está output é o seguinte -

Marks_scored     Name   subject_id
1             98     Alex         sub1
2             90      Amy         sub2
3             87    Allen         sub4
4             69    Alice         sub6
5             78   Ayoung         sub5
1             89    Billy         sub2
2             80    Brian         sub4
3             79     Bran         sub3
4             97    Bryce         sub6
5             88    Betty         sub5

Suponha que desejamos associar chaves específicas a cada uma das partes do DataFrame fragmentado. Podemos fazer isso usando okeys argumento -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'])

Está output é o seguinte -

x  1  98    Alex    sub1
   2  90    Amy     sub2
   3  87    Allen   sub4
   4  69    Alice   sub6
   5  78    Ayoung  sub5
y  1  89    Billy   sub2
   2  80    Brian   sub4
   3  79    Bran    sub3
   4  97    Bryce   sub6
   5  88    Betty   sub5

O índice do resultante é duplicado; cada índice é repetido.

Se o objeto resultante tiver que seguir sua própria indexação, defina ignore_index para True.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'],ignore_index=True)

Está output é o seguinte -

Marks_scored     Name    subject_id
0             98     Alex          sub1
1             90      Amy          sub2
2             87    Allen          sub4
3             69    Alice          sub6
4             78   Ayoung          sub5
5             89    Billy          sub2
6             80    Brian          sub4
7             79     Bran          sub3
8             97    Bryce          sub6
9             88    Betty          sub5

Observe, o índice muda completamente e as Chaves também são substituídas.

Se dois objetos precisam ser adicionados junto axis=1, então as novas colunas serão anexadas.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],axis=1)

Está output é o seguinte -

Marks_scored    Name  subject_id   Marks_scored    Name   subject_id
1           98      Alex      sub1         89         Billy         sub2
2           90       Amy      sub2         80         Brian         sub4
3           87     Allen      sub4         79          Bran         sub3
4           69     Alice      sub6         97         Bryce         sub6
5           78    Ayoung      sub5         88         Betty         sub5

Concatenando usando append

Um atalho útil para concat são os métodos de instância anexar em Series e DataFrame. Na verdade, esses métodos são anteriores ao concat. Eles se concatenam juntoaxis=0, ou seja, o índice -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append(two)

Está output é o seguinte -

Marks_scored    Name  subject_id
1           98      Alex      sub1
2           90       Amy      sub2
3           87     Allen      sub4
4           69     Alice      sub6
5           78    Ayoung      sub5
1           89     Billy      sub2
2           80     Brian      sub4
3           79      Bran      sub3
4           97     Bryce      sub6
5           88     Betty      sub5

o append função pode levar vários objetos também -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append([two,one,two])

Está output é o seguinte -

Marks_scored   Name    subject_id
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5

Série Temporal

O Pandas fornece uma ferramenta robusta para o tempo de trabalho com dados de séries temporais, especialmente no setor financeiro. Ao trabalhar com dados de série temporal, frequentemente encontramos o seguinte:

• Gerando sequência de tempo
• Converta a série temporal em diferentes frequências

O Pandas fornece um conjunto de ferramentas relativamente compacto e independente para executar as tarefas acima.

Obtenha a hora atual

datetime.now() fornece a data e a hora atuais.

import pandas as pd

print pd.datetime.now()

Está output é o seguinte -

2017-05-11 06:10:13.393147

Crie um TimeStamp

Os dados com registro de data e hora são o tipo mais básico de dados de série temporal que associa valores a pontos no tempo. Para objetos pandas, significa usar os pontos no tempo. Vamos dar um exemplo -

import pandas as pd

print pd.Timestamp('2017-03-01')

Está output é o seguinte -

2017-03-01 00:00:00

Também é possível converter tempos inteiros ou períodos flutuantes. A unidade padrão para isso é nanossegundos (já que é assim que os timestamps são armazenados). No entanto, muitas vezes as épocas são armazenadas em outra unidade que pode ser especificada. Vamos dar outro exemplo

import pandas as pd

print pd.Timestamp(1587687255,unit='s')

Está output é o seguinte -

2020-04-24 00:14:15

Crie um intervalo de tempo

import pandas as pd

print pd.date_range("11:00", "13:30", freq="30min").time

Está output é o seguinte -

[datetime.time(11, 0) datetime.time(11, 30) datetime.time(12, 0)
datetime.time(12, 30) datetime.time(13, 0) datetime.time(13, 30)]

Mudar a frequência de tempo

import pandas as pd

print pd.date_range("11:00", "13:30", freq="H").time

Está output é o seguinte -

[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]

Convertendo em carimbos de data / hora

Para converter uma série ou um objeto semelhante a uma lista de objetos semelhantes a uma data, por exemplo, strings, épocas ou uma mistura, você pode usar o to_datetimefunção. Quando passado, retorna uma série (com o mesmo índice), enquanto umlist-like é convertido em um DatetimeIndex. Dê uma olhada no seguinte exemplo -

import pandas as pd

print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))

Está output é o seguinte -

0  2009-07-31
1  2010-01-10
2         NaT
dtype: datetime64[ns]

NaT significa Not a Time (equivalente a NaN)

Vamos dar outro exemplo.

import pandas as pd

print pd.to_datetime(['2005/11/23', '2010.12.31', None])

Está output é o seguinte -

DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)

Estendendo as séries temporais, as funcionalidades de data desempenham um papel importante na análise de dados financeiros. Ao trabalhar com dados de data, frequentemente encontramos o seguinte -

• Gerando sequência de datas
• Converta a série de datas para diferentes frequências

Crie um intervalo de datas

Usando o date.range()função especificando os períodos e a frequência, podemos criar a série de datas. Por padrão, a frequência do intervalo é Dias.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

Está output é o seguinte -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Mudar a frequência da data

import pandas as pd

print pd.date_range('1/1/2011', periods=5,freq='M')

Está output é o seguinte -

DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31', '2011-04-30', '2011-05-31'],
   dtype='datetime64[ns]', freq='M')

bdate_range

bdate_range () significa intervalos de datas comerciais. Ao contrário de date_range (), ele exclui sábado e domingo.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

Está output é o seguinte -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Observe, após 3 de março, a data salta para 6 de março excluindo 4 e 5 de março. Basta verificar os dias em seu calendário.

Funções de conveniência como date_range e bdate_rangeutilizar uma variedade de aliases de frequência. A frequência padrão para date_range é um dia de calendário, enquanto o padrão para bdate_range é um dia útil.

import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)

print pd.date_range(start, end)

Está output é o seguinte -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Offset Aliases

Vários apelidos de string são fornecidos para frequências de séries temporais comuns úteis. Vamos nos referir a esses aliases como aliases de deslocamento.

Pseudônimo	Descrição	Pseudônimo	Descrição
B	frequência do dia útil	BQS	frequência de início do trimestre comercial
D	frequência do dia do calendário	UMA	frequência final anual (ano)
W	frequência semanal	BA	frequência de fim de ano comercial
M	frequência de fim de mês	BAS	frequência de início do ano comercial
SM	frequência de fim de semestre	BH	frequência do horário comercial
BM	frequência de fim de mês útil	H	frequência horária
em	frequência de início do mês	T, min	frequência minuciosa
SMS	Frequência de início semestral de SMS	S	em segundo lugar, frequência
BMS	frequência de início do mês útil	L, ms	milissegundos
Q	frequência de final de trimestre	Vc, nos	microssegundos
BQ	frequência de fim de trimestre comercial	N	nanossegundos
QS	frequência de início do trimestre

Timedeltas são diferenças em tempos, expressos em unidades de diferença, por exemplo, dias, horas, minutos, segundos. Eles podem ser positivos e negativos.

Podemos criar objetos Timedelta usando vários argumentos, conforme mostrado abaixo -

Corda

Ao passar um literal de string, podemos criar um objeto timedelta.

import pandas as pd

print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')

Está output é o seguinte -

2 days 02:15:30

Inteiro

Ao passar um valor inteiro com a unidade, um argumento cria um objeto Timedelta.

import pandas as pd

print pd.Timedelta(6,unit='h')

Está output é o seguinte -

0 days 06:00:00

Deslocamentos de dados

Deslocamentos de dados como - semanas, dias, horas, minutos, segundos, milissegundos, microssegundos, nanossegundos também podem ser usados ​​na construção.

import pandas as pd

print pd.Timedelta(days=2)

Está output é o seguinte -

2 days 00:00:00

to_timedelta ()

Usando o nível superior pd.to_timedelta, você pode converter um escalar, matriz, lista ou série de um formato / valor timedelta reconhecido em um tipo Timedelta. Ele irá construir uma série se a entrada for uma série, um escalar se a entrada for semelhante a um escalar, caso contrário, irá produzir umTimedeltaIndex.

import pandas as pd

print pd.Timedelta(days=2)

Está output é o seguinte -

2 days 00:00:00

Operações

Você pode operar em Series / DataFrames e construir timedelta64[ns] Série por meio de operações de subtração em datetime64[ns] Série ou carimbos de data / hora.

Vamos agora criar um DataFrame com objetos Timedelta e datetime e realizar algumas operações aritméticas nele -

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))

print df

Está output é o seguinte -

A      B
0  2012-01-01 0 days
1  2012-01-02 1 days
2  2012-01-03 2 days

Operações de adição

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']

print df

Está output é o seguinte -

A      B          C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05

Operação de Subtração

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
df['D']=df['C']+df['B']

print df

Está output é o seguinte -

A      B          C          D
0 2012-01-01 0 days 2012-01-01 2012-01-01
1 2012-01-02 1 days 2012-01-03 2012-01-04
2 2012-01-03 2 days 2012-01-05 2012-01-07

Freqüentemente, em tempo real, os dados incluem as colunas de texto, que são repetitivas. Recursos como sexo, país e códigos são sempre repetitivos. Estes são os exemplos de dados categóricos.

Variáveis ​​categóricas podem assumir apenas um número limitado e geralmente fixo de valores possíveis. Além do comprimento fixo, os dados categóricos podem ter uma ordem, mas não podem realizar operações numéricas. Categóricos são um tipo de dados Pandas.

O tipo de dados categóricos é útil nos seguintes casos -

• Uma variável de string que consiste em apenas alguns valores diferentes. A conversão de tal variável de string em uma variável categórica economizará um pouco de memória.

• A ordem lexical de uma variável não é a mesma que a ordem lógica (“um”, “dois”, “três”). Ao converter para um categórico e especificar uma ordem nas categorias, a classificação e mín / máx usarão a ordem lógica em vez da ordem lexical.

• Como um sinal para outras bibliotecas Python de que esta coluna deve ser tratada como uma variável categórica (por exemplo, para usar métodos estatísticos adequados ou tipos de gráfico).

Criação de Objetos

Objetos categóricos podem ser criados de várias maneiras. As diferentes formas foram descritas abaixo -

categoria

Especificando o tipo de d como "categoria" na criação do objeto pandas.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print s

Está output é o seguinte -

0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

O número de elementos passados ​​para o objeto da série é quatro, mas as categorias são apenas três. Observe o mesmo nas categorias de saída.

pd.Categorical

Usando o construtor pandas Categorical padrão, podemos criar um objeto de categoria.

pandas.Categorical(values, categories, ordered)

Vamos dar um exemplo -

import pandas as pd

cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat

Está output é o seguinte -

[a, b, c, a, b, c]
Categories (3, object): [a, b, c]

Vamos dar outro exemplo -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat

Está output é o seguinte -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]

Aqui, o segundo argumento significa as categorias. Assim, qualquer valor que não esteja presente nas categorias será tratado comoNaN.

Agora, dê uma olhada no seguinte exemplo -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat

Está output é o seguinte -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]

Logicamente, o pedido significa que, a é melhor que b e b é melhor que c.

Descrição

Usando o .describe() comando nos dados categóricos, obtemos uma saída semelhante a um Series ou DataFrame do type corda.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})

print df.describe()
print df["cat"].describe()

Está output é o seguinte -

cat s
count    3 3
unique   2 2
top      c c
freq     2 2
count     3
unique    2
top       c
freq      2
Name: cat, dtype: object

Obtenha as propriedades da categoria

obj.cat.categories comando é usado para obter o categories of the object.

import pandas as pd
import numpy as np

s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories

Está output é o seguinte -

Index([u'b', u'a', u'c'], dtype='object')

obj.ordered comando é usado para obter a ordem do objeto.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered

Está output é o seguinte -

False

A função retornou false porque não especificamos nenhum pedido.

Renomeando categorias

A renomeação das categorias é feita atribuindo-se novos valores ao series.cat.categoriespropriedade series.cat.categories.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s.cat.categories = ["Group %s" % g for g in s.cat.categories]
print s.cat.categories

Está output é o seguinte -

Index([u'Group a', u'Group b', u'Group c'], dtype='object')

Categorias iniciais [a,b,c] são atualizados pelo s.cat.categories propriedade do objeto.

Anexando novas categorias

Usando o método Categorical.add.categories (), novas categorias podem ser anexadas.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories

Está output é o seguinte -

Index([u'a', u'b', u'c', 4], dtype='object')

Removendo categorias

Usando o Categorical.remove_categories() método, categorias indesejadas podem ser removidas.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print ("Original object:")
print s

print ("After removal:")
print s.cat.remove_categories("a")

Está output é o seguinte -

Original object:
0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

After removal:
0  NaN
1  b
2  c
3  NaN
dtype: category
Categories (2, object): [b, c]

Comparação de dados categóricos

Comparar dados categóricos com outros objetos é possível em três casos -

• comparar igualdade (== e! =) a um objeto semelhante a uma lista (lista, série, matriz, ...) do mesmo comprimento que os dados categóricos.

• todas as comparações (==,! =,>,> =, <e <=) de dados categóricos com outra série categórica, quando ordenadas == Verdadeiro e as categorias são as mesmas.

• todas as comparações de um dado categórico com um escalar.

Dê uma olhada no seguinte exemplo -

import pandas as pd

cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)

print cat>cat1

Está output é o seguinte -

0  False
1  False
2  True
dtype: bool

Plotagem básica: plotagem

Esta funcionalidade em Series e DataFrame é apenas um invólucro simples em torno do matplotlib libraries plot() método.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
   periods=10), columns=list('ABCD'))

df.plot()

Está output é o seguinte -

Se o índice consiste em datas, ele chama gct().autofmt_xdate() para formatar o eixo x conforme mostrado na ilustração acima.

Podemos traçar uma coluna contra outra usando o x e y palavras-chave.

Os métodos de plotagem permitem um punhado de estilos de plotagem além da plotagem de linha padrão. Esses métodos podem ser fornecidos como o argumento de palavra-chave kind paraplot(). Isso inclui -

• bar ou barh para gráficos de bar
• hist para histograma
• caixa para boxplot
• 'área' para parcelas de área
• 'scatter' para gráficos de dispersão

Bar Plot

Vamos agora ver o que é um gráfico de barras, criando um. Um gráfico de barra pode ser criado da seguinte maneira -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()

Está output é o seguinte -

Para produzir um gráfico de barras empilhadas, pass stacked=True -

import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)

Está output é o seguinte -

Para obter gráficos de barra horizontal, use o barh método -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')

df.plot.barh(stacked=True)

Está output é o seguinte -

Histogramas

Os histogramas podem ser traçados usando o plot.hist()método. Podemos especificar o número de caixas.

import pandas as pd
import numpy as np

df = pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.plot.hist(bins=20)

Está output é o seguinte -

Para traçar histogramas diferentes para cada coluna, use o seguinte código -

import pandas as pd
import numpy as np

df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.diff.hist(bins=20)

Está output é o seguinte -

Box Plots

Boxplot pode ser desenhado chamando Series.box.plot() e DataFrame.box.plot(), ou DataFrame.boxplot() para visualizar a distribuição de valores em cada coluna.

Por exemplo, aqui está um boxplot representando cinco tentativas de 10 observações de uma variável aleatória uniforme em [0,1).

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
df.plot.box()

Está output é o seguinte -

Terreno de área

O gráfico de área pode ser criado usando o Series.plot.area() ou o DataFrame.plot.area() métodos.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()

Está output é o seguinte -

Gráfico de dispersão

O gráfico de dispersão pode ser criado usando o DataFrame.plot.scatter() métodos.

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(50, 4), columns=['a', 'b', 'c', 'd'])
df.plot.scatter(x='a', y='b')

Está output é o seguinte -

Gráfico de pizza

O gráfico de pizza pode ser criado usando o DataFrame.plot.pie() método.

import pandas as pd
import numpy as np

df = pd.DataFrame(3 * np.random.rand(4), index=['a', 'b', 'c', 'd'], columns=['x'])
df.plot.pie(subplots=True)

Está output é o seguinte -

o Pandas I/O API é um conjunto de funções de leitor de nível superior acessadas como pd.read_csv() que geralmente retornam um objeto Pandas.

As duas funções burras para ler arquivos de texto (ou arquivos simples) são read_csv() e read_table(). Ambos usam o mesmo código de análise para converter dados tabulares em umDataFrame objeto -

pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

pandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

Aqui está como csv os dados do arquivo parecem -

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Salve esses dados como temp.csv e realizar operações nele.

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Salve esses dados como temp.csv e realizar operações nele.

read.csv

read.csv lê os dados dos arquivos csv e cria um objeto DataFrame.

import pandas as pd

df=pd.read_csv("temp.csv")
print df

Está output é o seguinte -

S.No     Name   Age       City   Salary
0     1      Tom    28    Toronto    20000
1     2      Lee    32   HongKong     3000
2     3   Steven    43   Bay Area     8300
3     4      Ram    38  Hyderabad     3900

índice personalizado

Isso especifica uma coluna no arquivo csv para personalizar o índice usando index_col.

import pandas as pd

df=pd.read_csv("temp.csv",index_col=['S.No'])
print df

Está output é o seguinte -

S.No   Name   Age       City   Salary
1       Tom    28    Toronto    20000
2       Lee    32   HongKong     3000
3    Steven    43   Bay Area     8300
4       Ram    38  Hyderabad     3900

Conversores

dtype das colunas pode ser passado como um dicionário.

import pandas as pd

df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes

Está output é o seguinte -

S.No       int64
Name      object
Age        int64
City      object
Salary   float64
dtype: object

Por padrão, o dtype da coluna Salário é int, mas o resultado mostra como float porque definimos explicitamente o tipo.

Assim, os dados parecem flutuantes -

S.No   Name   Age      City    Salary
0   1     Tom   28    Toronto   20000.0
1   2     Lee   32   HongKong    3000.0
2   3  Steven   43   Bay Area    8300.0
3   4     Ram   38  Hyderabad    3900.0

header_names

Especifique os nomes do cabeçalho usando o argumento names.

import pandas as pd
 
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df

Está output é o seguinte -

a        b    c           d        e
0   S.No     Name   Age       City   Salary
1      1      Tom   28     Toronto    20000
2      2      Lee   32    HongKong     3000
3      3   Steven   43    Bay Area     8300
4      4      Ram   38   Hyderabad     3900

Observe que os nomes dos cabeçalhos são anexados aos nomes personalizados, mas o cabeçalho do arquivo não foi eliminado. Agora, usamos o argumento do cabeçalho para removê-lo.

Se o cabeçalho estiver em uma linha diferente da primeira, passe o número da linha para o cabeçalho. Isso irá ignorar as linhas anteriores.

import pandas as pd 

df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df

Está output é o seguinte -

a        b    c           d        e
0  S.No     Name   Age       City   Salary
1     1      Tom   28     Toronto    20000
2     2      Lee   32    HongKong     3000
3     3   Steven   43    Bay Area     8300
4     4      Ram   38   Hyderabad     3900

skiprows

skiprows pula o número de linhas especificado.

import pandas as pd

df=pd.read_csv("temp.csv", skiprows=2)
print df

Está output é o seguinte -

2      Lee   32    HongKong   3000
0   3   Steven   43    Bay Area   8300
1   4      Ram   38   Hyderabad   3900

Objetos esparsos são “comprimidos” quando qualquer dado correspondente a um valor específico (NaN / valor ausente, embora qualquer valor possa ser escolhido) é omitido. Um objeto especial SparseIndex rastreia onde os dados foram “esparsos”. Isso fará muito mais sentido em um exemplo. Todas as estruturas de dados padrão do Pandas aplicam oto_sparse método -

import pandas as pd
import numpy as np

ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts

Está output é o seguinte -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64
BlockIndex
Block locations: array([0, 8], dtype=int32)
Block lengths: array([2, 2], dtype=int32)

Os objetos esparsos existem por motivos de eficiência de memória.

Vamos agora supor que você tenha um grande DataFrame de NA e execute o seguinte código -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10000, 4))
df.ix[:9998] = np.nan
sdf = df.to_sparse()

print sdf.density

Está output é o seguinte -

0.0001

Qualquer objeto esparso pode ser convertido de volta para a forma densa padrão chamando to_dense -

import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts.to_dense()

Está output é o seguinte -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64

Dtipos esparsos

Dados esparsos devem ter o mesmo tipo de d que sua representação densa. Atualmente,float64, int64 e booldtypessão suportados. Dependendo do originaldtype, fill_value default mudanças -

• float64 - np.nan

• int64 - 0

• bool - Falso

Vamos executar o seguinte código para entender o mesmo -

import pandas as pd
import numpy as np

s = pd.Series([1, np.nan, np.nan])
print s

s.to_sparse()
print s

Está output é o seguinte -

0   1.0
1   NaN
2   NaN
dtype: float64

0   1.0
1   NaN
2   NaN
dtype: float64

Advertências significa aviso e pegadinha significa um problema invisível.

Usando a declaração If / Truth com os Pandas

O Pandas segue a convenção entorpecida de gerar um erro quando você tenta converter algo em um bool. Isso acontece em umif ou when usando as operações booleanas, e, or, ou not. Não está claro qual deve ser o resultado. Deve ser verdadeiro porque não é comprimento zero? False porque existem valores False? Não está claro, então, em vez disso, o Pandas levanta umValueError -

import pandas as pd

if pd.Series([False, True, False]):
   print 'I am True'

Está output é o seguinte -

ValueError: The truth value of a Series is ambiguous. 
Use a.empty, a.bool() a.item(),a.any() or a.all().

Dentro ifcondição, não está claro o que fazer com ele. O erro sugere se deve ser usado umNone ou any of those.

import pandas as pd

if pd.Series([False, True, False]).any():
   print("I am any")

Está output é o seguinte -

I am any

Para avaliar objetos pandas de elemento único em um contexto booleano, use o método .bool() -

import pandas as pd

print pd.Series([True]).bool()

Está output é o seguinte -

True

Booleano bit a bit

Operadores booleanos bit a bit como == e != retornará uma série booleana, que quase sempre é o que é necessário de qualquer maneira.

import pandas as pd

s = pd.Series(range(5))
print s==4

Está output é o seguinte -

0 False
1 False
2 False
3 False
4 True
dtype: bool

está em operação

Isso retorna uma série booleana mostrando se cada elemento na série está contido exatamente na sequência de valores passada.

import pandas as pd

s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s

Está output é o seguinte -

0 True
1 False
2 True
dtype: bool

Reindexando vs ix Gotcha

Muitos usuários se verão usando o ix indexing capabilities como um meio conciso de selecionar dados de um objeto Pandas -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[['b', 'c', 'e']]

Está output é o seguinte -

one        two      three       four
a   -1.582025   1.335773   0.961417  -1.272084
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
d   -2.380648  -0.029981   0.196489   0.531714
e    1.846746   0.148149   0.275398  -0.244559
f   -1.842662  -0.933195   2.303949   0.677641

          one        two      three       four
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
e    1.846746   0.148149   0.275398  -0.244559

Isso é, obviamente, completamente equivalente, neste caso, a usar o reindex método -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.reindex(['b', 'c', 'e'])

Está output é o seguinte -

one        two      three       four
a    1.639081   1.369838   0.261287  -1.662003
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
d   -1.078791  -0.612607  -0.897289  -1.146893
e    0.465215   1.552873  -1.841959   0.329404
f    0.966022  -0.190077   1.324247   0.678064

          one        two      three       four
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
e    0.465215   1.552873  -1.841959   0.329404

Alguns podem concluir que ix e reindexsão 100% equivalentes com base nisso. Isso é verdade, exceto no caso de indexação de inteiros. Por exemplo, a operação acima pode alternativamente ser expressa como -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[[1, 2, 4]]
print df.reindex([1, 2, 4])

Está output é o seguinte -

one        two      three       four
a   -1.015695  -0.553847   1.106235  -0.784460
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
d   -1.238016  -0.749554  -0.547470  -0.029045
e   -0.056788   1.063999  -0.767220   0.212476
f    1.139714   0.036159   0.201912   0.710119

          one        two      three       four
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
e   -0.056788   1.063999  -0.767220   0.212476

    one  two  three  four
1   NaN  NaN    NaN   NaN
2   NaN  NaN    NaN   NaN
4   NaN  NaN    NaN   NaN

É importante lembrar que reindex is strict label indexing only. Isso pode levar a alguns resultados potencialmente surpreendentes em casos patológicos em que um índice contém, digamos, inteiros e strings.

Visto que muitos usuários potenciais do Pandas têm alguma familiaridade com SQL, esta página tem como objetivo fornecer alguns exemplos de como várias operações SQL podem ser realizadas usando o pandas.

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.head()

Está output é o seguinte -

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

SELECIONE

No SQL, a seleção é feita usando uma lista separada por vírgulas de colunas que você seleciona (ou um * para selecionar todas as colunas) -

SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;

Com o Pandas, a seleção de colunas é feita passando uma lista de nomes de colunas para seu DataFrame -

tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Vamos verificar o programa completo -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
 
tips=pd.read_csv(url)
print tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Está output é o seguinte -

total_bill   tip  smoker     time
0       16.99  1.01      No   Dinner
1       10.34  1.66      No   Dinner
2       21.01  3.50      No   Dinner
3       23.68  3.31      No   Dinner
4       24.59  3.61      No   Dinner

Chamar o DataFrame sem a lista de nomes de coluna exibirá todas as colunas (semelhante a * do SQL).

ONDE

A filtragem em SQL é feita por meio de uma cláusula WHERE.

SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;

Os DataFrames podem ser filtrados de várias maneiras; o mais intuitivo deles é usar a indexação booleana.

tips[tips['time'] == 'Dinner'].head(5)

Vamos verificar o programa completo -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips[tips['time'] == 'Dinner'].head(5)

Está output é o seguinte -

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

A instrução acima passa uma série de objetos True / False para o DataFrame, retornando todas as linhas com True.

GroupBy

Esta operação busca a contagem de registros em cada grupo em um conjunto de dados. Por exemplo, uma consulta que nos busca o número de dicas deixadas por sexo -

SELECT sex, count(*)
FROM tips
GROUP BY sex;

O equivalente Pandas seria -

tips.groupby('sex').size()

Vamos verificar o programa completo -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.groupby('sex').size()

Está output é o seguinte -

sex
Female   87
Male    157
dtype: int64

N principais linhas

SQL retorna o top n rows usando LIMIT -

SELECT * FROM tips
LIMIT 5 ;

O equivalente Pandas seria -

tips.head(5)

Vamos verificar o exemplo completo -

import pandas as pd

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

tips=pd.read_csv(url)
tips = tips[['smoker', 'day', 'time']].head(5)
print tips

Está output é o seguinte -

smoker   day     time
0      No   Sun   Dinner
1      No   Sun   Dinner
2      No   Sun   Dinner
3      No   Sun   Dinner
4      No   Sun   Dinner

Estas são as poucas operações básicas que comparamos e que aprendemos nos capítulos anteriores da Biblioteca Pandas.