Aprendizado de Máquina com Python e Scikit-learn
Pandas na prática
Link do meu Github com o script dessa aula:
Link da documentação oficial do Sklearn:
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook
Link do código fluente no Pinterest
Meus links de afiliados:
Na aula passada instalamos o Pandas e transformamos o iris dataset em um DataFrame Pandas.
Vamos conhecer melhor o que o Pandas oferece.
Pandas na prática
Objeto
Series do pandas
#importa a biblioteca pandas como pd
import pandas as pd
#importa o numpy como np
import numpy as np
#Cria um array numpy
data = np.array(['a','b','c','d'])
#Usa o array numpy criado acima para
#gerar um objeto Series do pandas
s1 = pd.Series(data)
s1
Saída:
s
0 a
1 b
2 c
3 d
dtype: object
Nós não passamos nenhum índice, então, por padrão, ele atribuiu os índices variando de 0 a len(data) -1, ou seja, 0 a 3.
Outro exemplo, agora
determinando os
índices:
#importa a biblioteca pandas como pd
import pandas as pd
#importa o numpy como np
import numpy as np
#Cria um array numpy
data2 = np.array(['a','b','c','d'])
s2 = pd.Series(data2, index = [70, 71, 72, 73])
print(s2)
Saída:
70 a
71 b
72 c
73 d
dtype: object
Crie uma Serie a partir de um
dicionário:
#importa a biblioteca pandas como pd
import pandas as pd
#importa o numpy como np
import numpy as np
data3 = {'a' : 0., 'b' : 1., 'c' : 2.}
s3 = pd.Series(data3)
s3
Saída:
a 0.0
b 1.0
c 2.0
dtype: float64
Outro exemplo de Series a partir de um dicionário:
#importa a biblioteca pandas como pd
import pandas as pd
#importa o numpy como np
import numpy as np
data4 = {'a' : 0., 'b' : 1., 'c' : 2.}
s4 = pd.Series(data4, index = ['b','c','d','a'])
print(s4)
Saída:
b 1.0
c 2.0
d NaN
a 0.0
dtype: float64
Veja que ordem do
índice é persistente e o
elemento ausente é preenchido com
NaN (
Not a Number).
Recuperar Dados Usando Rótulo (Índice):
Um objeto pandas
Serie é como um dicionário de tamanho fixo em que você pode obter e definir valores por rótulo de índice.
Exemplo 1
Recupera um único elemento usando o valor do rótulo de índice.
import pandas as pd
s = pd.Series([1, 2, 3, 4, 5], index = ['a','b','c','d','e'])
#recupera um único elemento
print(s['a'])
Saída:
1
Exemplo 2
Recupera 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'])
#recupera vários elementos
s[['a','c','d']]
Saída:
a 1
c 3
d 4
dtype: int64
Se tentar acessar uma
chave que
não existe, dá um
KeyError.
import pandas as pd
s = pd.Series([1, 2, 3, 4, 5],index = ['a','b','c','d','e'])
#recupera vários elementos
print(s['f'])
Saída:
...
...
...
File "pandas\_libs\index.pyx", line 132, in pandas._libs.index.IndexEngine.get_loc
File "pandas\_libs\hashtable_class_helper.pxi", line 1601, in pandas._libs.hashtable.PyObjectHashTable.get_item
File "pandas\_libs\hashtable_class_helper.pxi", line 1608, in pandas._libs.hashtable.PyObjectHashTable.get_item
KeyError: 'f'
DataFrame
DataFrame é uma estrutura de dados
bidimensional, ou seja, os dados são alinhados de maneira tabular em
linhas e
colunas.
Recursos do DataFrame:
- Colunas podem ser de diferentes tipos
- Tamanho - Mutável
- Eixos rotulados (linhas e colunas)
- Pode executar operações aritméticas em linhas e colunas
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.No |
ParametRo e Descrição |
| 1 |
data
dados assumem várias formas como: ndarray, series, maps, lists, dict, constants e também outros DataFrames. |
| 2 |
index
Para rotular linhas, o índice a ser usado para o DataFrame resultante é opcional. Default np.arrange(n) se nenhum índice for passado. |
| 3 |
columns
Para rotular colunas, a sintaxe padrão opcional é: np.arrange (n). Isso só é verdade se nenhum índice for passado. |
| 4 |
dtype
Tipo de dados de cada coluna. |
| 5 |
copy
Este comando (ou seja o que for) é usado para copiar dados, se o padrão for Falso. |
Criando um DataFrame
Um DataFrame pandas pode ser criado usando várias entradas como:
- Listas
- Dicionários
- Series
- Numpy Ndarrays
- Outros DataFrames
Vamos criar um DataFrame vazio
Exemplo
#importa a biblioteca pandas como pd
import pandas as pd
df = pd.DataFrame()
print(df)
Saída:
Empty DataFrame
Columns: []
Index: []
Agora vamos criar um DataFrame 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)
Saída:
0
0 1
1 2
2 3
3 4
4 5
Exemplo 2
import pandas as pd
data = [ ['Maria', 10], ['Carlos', 12], ['Paulo', 13] ]
df = pd.DataFrame(data, columns = ['Nome', 'Idade'])
print(df)
Saída:
Nome Idade
0 Maria 10
1 Carlos 12
2 Paulo 13
Exemplo 3
import pandas as pd
data = [ ['Maria', 10], ['Carlos', 12], ['Paulo', 13] ]
df = pd.DataFrame(data, columns = ['Nome', 'Idade'], dtype = float)
print(df)
Saída:
Nome Idade
0 Maria 10.0
1 Carlos 12.0
2 Paulo 13.0
Veja que o parâmetro
dtype altera o tipo de coluna
Idade para ponto flutuante.
Criando DataFrame a partir de um dicionário ndarrays / Lists
Todos os
ndarrays devem ter o mesmo comprimento.
Se o índice for passado, o comprimento do índice deve ser igual ao comprimento dos arrays.
Se nenhum índice for passado, por padrão, o índice será o intervalo (n), onde n é o comprimento da matriz.
exemplo 1
import pandas as pd
data = {'Nome':['Marcos', 'Paula', 'Lia', 'Carlos'], 'Idade':[28, 34, 29, 42]}
df = pd.DataFrame(data)
print(df)
Saída:
Idade Nome
0 28 Marcos
1 34 Paula
2 29 Lia
3 42 Carlos
Note 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).
Vamos agora criar um DataFrame indexado usando arrays.
Exemplo 2
import pandas as pd
data = {'Nome': ['Marcos', 'Paula', 'Lia', 'Carlos'], 'Pontuação': [7.5, 6.8, 5.9, 8.3]}
df = pd.DataFrame(data, index = ['rank1', 'rank2', 'rank3', 'rank4'])
print(df)
Saída:
Idade Nome
rank1 28 Marcos
rank2 34 Paula
rank3 29 Lia
rank4 42 Carlos
Criando um DataFrame da lista de dicionários
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 como os nomes de colunas.
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)
Saída:
a b c
0 1 2 NaN
1 5 10 20.0
Exemplo 2
O exemplo a seguir mostra como criar um
DataFrame passando uma lista de dicionários e os índices de linhas.
import pandas as pd
data = [ {'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20} ]
df = pd.DataFrame(data, index = ['primeiro', 'segundo'])
print(df)
Saída:
a b c
primeiro 1 2 NaN
segundo 5 10 20.0
Exemplo 3
O exemplo a seguir mostra como criar um
DataFrame com uma lista de dicionários, índices de linhas e índices de colunas.
import pandas as pd
data = [ {'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20} ]
#Com dois índices de colunas, os valores são iguais aos das chaves do dicionário
df1 = pd.DataFrame(data, index = ['primeiro', 'segundo'], columns = ['a', 'b'])
#Com dois índices de colunas com um índice com outro nome
df2 = pd.DataFrame(data, index = ['primeiro', 'segundo'], columns = ['a', 'b1'])
print(df1)
print(df2)
Saída:
#Saída do df1
a b
primeiro 1 2
segundo 5 10
#Saída do df2
a b
primeiro 1 NaN
segundo 5 NaN
Observe que o DataFrame
df2 é criado com um índice de coluna diferente da chave do dicionário.
Acrescentou o
NaN no lugar onde os índices de colunas não são iguais às chaves do dicionário.
Criando um DataFrame a partir do Dicionário de Series
Um Dicionário de série 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
dic = {'um' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
'dois' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}
df = pd.DataFrame(dic)
print(df)
Saída:
um dois
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
Veja que, para a série um, não há rótulo "
d" passado, mas no resultado, o rótulo
d é preenchido com
NaN.
Vamos agora entender a seleção da coluna, adição e exclusão através de exemplos.
Seleção de Coluna
Vamos entender isso selecionando uma coluna do DataFrame.
Exemplo:
import pandas as pd
dic = {'um' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
'dois' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}
df = pd.DataFrame(dic)
print(df ['um'])
Saída:
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
Dataframe existente.
import pandas as pd
dic = {'um' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
'dois' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}
df = pd.DataFrame(dic)
# Adicionando uma nova coluna a um objeto DataFrame existente
# com rótulo de coluna passando nova Series
print ("Adicionando uma nova coluna passando como Série:")
df['três'] = pd.Series([10, 20, 30], index = ['a','b','c'])
print(df)
print ("Adicionando uma nova coluna usando as colunas existentes no DataFrame")
df['quatro'] = df['um'] + df['três']
print(df)
Saída:
Adicionando uma nova coluna passando como série: um dois três
um dois três
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
Adicionando uma nova coluna usando as colunas existentes no DataFrame: um dois três quatro
um dois três quatro
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
Colunas podem ser excluídas, vamos a um exemplo para entender como.
# Usando o DataFrame anterior , vamos apagar uma coluna
# usando a função del
import pandas as pd
d = {'um' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
'dois' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd']),
'três' : pd.Series([10,20,30], index = ['a','b','c'])}
df = pd.DataFrame(d)
print ("Nosso dataframe é:")
print(df)
# usando a função del
print ("Excluindo a primeira coluna usando a função DEL:")
del df['um']
print(df)
# usando a função pop
print ("Excluindo outra coluna usando a função POP:")
df.pop('dois')
print(df)
Saída:
Nosso dataframe é:
um dois três
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
Deleting the first column using
DEL function:
um três
a 1 10.0
b 2 20.0
c 3 30.0
d 4 NaN
Excluindo outra coluna usando a função
POP:
três
a 10.0
b 20.0
c 30.0
d NaN
Seleção, adição e exclusão de linha
Vamos agora entender a seleção, adição e exclusão de linhas através de exemplos. Vamos começar com o conceito de seleção.
Seleção pelo rótulo(
label)
As linhas podem ser selecionadas passando o rótulo da linha para uma função
loc.
import pandas as pd
dic = {'um' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
'dois' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}
df = pd.DataFrame(dic)
print(df.loc['b'])
Saída:
um 2.0
dois 2.0
Name: b, dtype: float64
O resultado é uma série com rótulos como nomes de coluna do DataFrame e o nome da Serie é o rótulo com o qual é recuperado.
Seleção por localização numérica inteira
As linhas podem ser selecionadas passando a localização inteira para uma função
iloc.
import pandas as pd
dic = {'um' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
'dois' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}
df = pd.DataFrame(dic)
print(df.iloc[2])
Saída:
um 3.0
dois 3.0
Name: c, dtype: float64
Fatias de linhas(slice)
Várias linhas podem ser selecionadas usando o operador "
:".
import pandas as pd
d = {'um' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
'dois' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df[2:4])
Saída:
um dois
c 3.0 3
d NaN 4
Adição de linhas
Adicione novas linhas a um
DataFrame usando a função
append. 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)
Saída:
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 descartadas.
Se você observar, no exemplo acima, os rótulos são duplicados.
Vamos deletar um rótulo e ver quantas linhas serão descartadas.
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)
#Deleta as linhas com o rótulo 0
df = df.drop(0)
print(df)
Saída:
a b
1 3 4
1 7 8
No exemplo acima, duas linhas foram descartadas porque elas continham o mesmo rótulo zero(
0).
OBS: Eu havia feito uma aula, que seria a próxima, sobre a estrutura Panel do Pandas, mas, ao elaborar vi que o Panel está deprecated, isto é, ele foi descontinuado, ele ainda funciona, mas nas próximas versões do Pandas ele não existirá mais. Por isso abortei a ideia de fazer a aula sobre o Panel.
Link do meu Github com o script dessa aula:
Link do meu Github com o script dessa aula:
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook
Link do código fluente no Pinterest
Novamente deixo meus link de afiliados:
Obrigado, até a próxima e bons estudos. ;)
