Python Pandas Tutorial

Crie uma série vazia

Uma série básica, que pode ser criada é uma Série Vazia.
Exemplos
Demonstração ao vivo

#import the pandas library and aliasing as pd

import pandas as pd
s = pd.Series()
print s

Sua saída é a seguinte −

Series([], dtype: float64)

#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

Sua saída é a seguinte −

0 a
1 b
2 c
3 d
dtype: object

Demonstração ao vivo

#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

Sua saída é a seguinte −

100 a
101 b
102 c
103 d
dtype: object
DataFrame
Exemplo
import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df

Sua saída é a seguinte −

0
0 1
1 2
2 3
3 4
4 5

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

Sua saída é a seguinte −

Name Age
0 Alex 10
1 Bob 12
2 Clarke 13

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

Sua saída é a seguinte −

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

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
Sua saída é a seguinte −
Age Name
rank1 28 Tom
rank2 34 Jack
rank3 29 Steve
rank4 42 Ricky

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

Sua saída é a seguinte −

a b c
0 1 2 NaN
1 5 10 20.0

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

Sua saída é a seguinte −

a b c
first 1 2 NaN
second 5 10 20.0

delete uma coluna

del df['one']
df.pop('two')

Seleção por Rótulo

df.loc['b']
Seleção por localização inteira
df.iloc[2]
Linhas de fatia
df[2:4]
impressão de dados gerais da tabela

print ("The first two rows of the data series:")

print s.head(2)

print ("The last two rows of the data series:")

print s.tail(2)

print ("Row axis labels and column axis labels are:")

print df.axes

print ("The data types of each column are:")

print df.dtypes

print ("The dimension of the object is:")

print df.ndim

print ("The shape of the object is:")

print df.shape

print ("The actual data in our data frame is:")

print df.values

soma()
Devolve a soma dos valores para o eixo solicitado. Por padrão, eixo é índice
(eixo=0).
print df.sum()

print df.sum(1) *soma os elementos de cada linha.

print df.mean()
print df.std()

Resumindo dados
A função describe() computa um resumo das estatísticas relativas às colunas
DataFrame.
print df.describe()
Ordem de Classificação
df = df.sort_index(ascending=False)

df = df.sort_values(by='col1')

loc

#select all rows for a specific column

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

iloc

# select few rows for columns

print df.iloc[:4] *linhas 0,1,2,3

Aplicar agregação em um dataframe

df['col'].aggregate(np.sum)
df[['A','B']].aggregate(np.sum)
df['A'].aggregate([np.sum,np.mean])
df[['A','B']].aggregate([np.sum,np.mean])
df.aggregate({'A' : np.sum,'B' : np.mean})

valores missing dados são perdidos?

df['col'].isnull()

Substitua a NaN por um valor escalar

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

Queda de valores faltantes

print df.dropna()

print df.dropna(axis=1)
Substituir valores genéricos ausentes
df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':
[1000,0,30,40,50,60]})

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

group by

#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

Sua saída é a 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

print df.groupby('Team').groups

Sua saída é a 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')}

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

Sua saída é a 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')}

grouped = df.groupby('Year')

for name,group in grouped:

print name
print group

Sua saída é a 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
grouped = df.groupby('Year')
print grouped.get_group(2014)
Sua saída é a 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
grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)

Sua saída é a seguinte −

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

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

Sua saída é a 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
grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)

Sua saída é a 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
print df.groupby('Team').filter(lambda x: len(x) >= 3)

Sua saída é a 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

Processamento de dados CSV

id,name,salary,start_date,dept
1,Rick,623.3,2012-01-01,IT
2,Dan,515.2,2013-09-23,Operations
3,Tusar,611,2014-11-15,IT
4,Ryan,729,2014-05-11,HR
5,Gary,843.25,2015-03-27,Finance
6,Rasmi,578,2013-05-21,IT
7,Pranab,632.8,2013-07-30,Operations
8,Guru,722.5,2014-06-17,Finance

import pandas as pd
data = pd.read_csv('path/input.csv')
print (data)

id name salary start_date dept

0 1 Rick 623.30 2012-01-01 IT
1 2 Dan 515.20 2013-09-23 Operations
2 3 Tusar 611.00 2014-11-15 IT
3 4 Ryan 729.00 2014-05-11 HR
4 5 Gary 843.25 2015-03-27 Finance
5 6 Rasmi 578.00 2013-05-21 IT
6 7 Pranab 632.80 2013-07-30 Operations
7 8 Guru 722.50 2014-06-17 Finance

# Slice the result for first 5 rows

print (data[0:5]['salary'])
0 623.30
1 515.20
2 611.00
3 729.00
4 843.25
# Use the multi-axes indexing funtion
print (data.loc[:,['salary','name']])
salary name
0 623.30 Rick
1 515.20 Dan
2 611.00 Tusar
3 729.00 Ryan
4 843.25 Gary
5 578.00 Rasmi
6 632.80 Pranab
7 722.50 Guru

# Use the multi-axes indexing funtion

print (data.loc[[1,3,5],['salary','name']])
salary name
1 515.2 Dan
3 729.0 Ryan
5 578.0 Rasmi

Python - Distribuição Normal

A distribuição normal é uma forma que apresenta dados, organizando a distribuição de
probabilidades de cada valor nos dados. A maioria dos valores permanece em torno
do valor médio tornando o arranjo simétrico.

mu, sigma = 0.5, 0.1

s = np.random.normal(mu, sigma, 1000)

# Create the bins and histogram

count, bins, ignored = plt.hist(s, 20, normed=True)

# Plot the distribution curve

plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *
np.exp( - (bins - mu)**2 / (2 * sigma**2) ),
linewidth=3, color='y')
plt.show()
 Python - Distribuição Binomial
O modelo de distribuição binomial trata de encontrar a probabilidade de sucesso de
um evento que tem apenas dois resultados possíveis em uma série de experimentos.
Por exemplo, jogar uma moeda sempre dá uma cabeça ou uma cauda. A
probabilidade de encontrar exatamente 3 cabeças em jogar uma moeda repetidamente
por 10 vezes é estimada durante a distribuição binomial.

from scipy.stats import binom

import seaborn as sb

binom.rvs(size=10,n=20,p=0.8)

data_binom = binom.rvs(n=20,p=0.8,loc=0,size=1000)
ax = sb.distplot(data_binom,
kde=True,
color='blue',
hist_kws={"linewidth": 25,'alpha':1})
ax.set(xlabel='Binomial', ylabel='Frequency')
 Python - Distribuição Poisson
Uma distribuição Poisson é uma distribuição que mostra o número provável de vezes
que um evento ocorrerá dentro de um período de tempo pré-determinado. É usado
para eventos independentes que ocorrem a uma taxa constante dentro de um
determinado intervalo de tempo. A distribuição de Poisson é uma função discreta, o
que significa que o evento só pode ser medido como ocorrendo ou não como
ocorrendo, o que significa que a variável só pode ser medida em números inteiros.

from scipy.stats import poisson

import seaborn as sb

data_binom = poisson.rvs(mu=4, size=10000)

ax = sb.distplot(data_binom,
kde=True,
color='green',
hist_kws={"linewidth": 25,'alpha':1})
ax.set(xlabel='Poisson', ylabel='Frequency')
 Python - Distribuição Bernoulli
A distribuição de Bernoulli é um caso especial da distribuição binomial onde um único
experimento é realizado para que o número de observação seja 1. Assim, a
distribuição de Bernoulli descreve, portanto, eventos com exatamente dois resultados.

from scipy.stats import bernoulli

import seaborn as sb

data_bern = bernoulli.rvs(size=1000,p=0.6)
ax = sb.distplot(data_bern,
kde=True,
color='crimson',
hist_kws={"linewidth": 25,'alpha':1})
ax.set(xlabel='Bernouli', ylabel='Frequency')
 Python - Regressão Linear
Na Regressão Linear essas duas variáveis estão relacionadas através de uma
equação, onde expoente (poder) de ambas as variáveis é 1. Matematicamente uma
relação linear representa uma linha reta quando traçada como um gráfico. Uma
relação não linear onde o expoente de qualquer variável não é igual a 1 cria uma
curva.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.regplot(x = "total_bill", y = "tip", data = df)
plt.show()