Pandas

Carregando, aguarde alguns segundos.

1 - Introdução ao Pandas

Pandas é uma biblioteca Python usada para processamento de conjuntos de dados.

Possui funções para analisar, limpar, explorar e manipular dados.

O nome "Pandas" faz referência tanto a "Panel Data" quanto a "Python Data Analysis" e foi criado por Wes McKinney em 2008.

Pandas nos permite analisar big data e tirar conclusões com base em teorias estatísticas.

A relevância dos dados é muito importante na ciência de dados e o pandas realiza a limpeza de conjuntos de dados com problemas os tornado legíveis e relevantes.

A Ciência de Dados, do inglês Data Science, é um ramo da ciência da computação onde estudamos como armazenar, usar e analisar dados para derivação de informações.

O Pandas fornece respostas sobre os dados:

Existe uma correlação entre duas ou mais colunas?
O que é valor médio? Valor máximo? Valor mínimo?
Existem linhas não relevantes ou com valores errados, como valores vazios ou nulos, e necessidade de limpeza dos dados modificando ou excluindo estas linhas?

O código-fonte do Pandas está localizado no repositório do github https://github.com/pandas-dev/pandas.

Instalação do pandas

Se você já possui Python e Pip instalado em um sistema, instale o Pandas:

pip install pandas

Importação do Pandas

Após instalado importe o Pandas:

import pandas

Agora, o Pandas está importado e pronto para uso.

import pandas
#
meu_conjunto_dados = {
  'carros': ["BMW", "Volvo", "Ford"],
  'passagens': [3, 7, 2]
}
#
minha_variavel = pandas.DataFrame (meu_conjunto_dados)
#
print(minha_variavel)

  carros  passagens
0    BMW          3
1  Volvo          7
2   Ford          2

Versão

O texto da versão é armazenada no atributo __version__.

import pandas
print(pandas.__version__)

1.4.2

Importação como "pd"

Geralmente o Pandas é importando com a palavra-chave as declarando o alias pd para simplificar a referência ao pacote nas instruções.

O alias (ou pseudônimo), no Python, é um nome alternativo para referência a um mesmo objeto, a "uma mesma coisa".

import pandas as pd

Agora, o pacote Pandas pode ser referido como pd.

meu_conjunto_dados = {
  'carros': ["BMW", "Volvo", "Ford"],
  'passagens': [3, 7, 2]
}
df = pd.DataFrame(meu_conjunto_dados)
print(df)

  carros  passagens
0    BMW          3
1  Volvo          7
2   Ford          2

Autores

Roberto Teixeira

Betobyte

Cientista de Dados

CIEDA

cieda.com.br

roberto@cieda.com.br

Autor

Carlos Delfino

Arduino

Cientista de Dados

Basicão da Eletrônica

www.carlosdelfino.eti.br

consultoria@carlosdelfino.eti.br

Coautor

1.1 - Classe Series

Os objetos Pandas da classe Series são matrizes unidimensionais contendo dados de diferentes tipos, sendo correspondentes às colunas nas tabelas de linhas x colunas.

Crie uma série de Pandas simples a partir de uma lista com o método pd.Series(a):

import pandas as pd
a = [1, 7, 2]
serie = pd.Series(a)
print(serie)

0    1
1    7
2    2
dtype: int64

O objeto Series tem o tipo pandas.core.series.Series

print(type(serie))

<class 'pandas.core.series.Series'>

Para imprimir os valores dos elemento da série individualmente utilize o iterador for.

Usando índices:

for i in range(len(serie)):
    print(serie[i])

1
7
2

Iterando a série:

for item in serie:
    print(item)

1
7
2

A classe Series tem diversos atributos para manipução de dados:

values: Retorna os valores da serie
index: Retorna os rótulos dos elementos da série
len: Retorna o numero de elementos
shape: Retorna uma tupla com o número de linhas e colunas
head: Retorna as primeiras 5 linhas da serie
tail: Retorna as ultimas 5 linhas da serie
describe: Retorna informações estatísticas sobre a série
sort_index: Ordena os índices
sort_values: Ordena os valores
copy: Retorna uma cópia
to_list: Retorna uma lista
to_frame: Retorna um DataFrame
to_string: Retorna uma string
to_dict: Retorna um dicionário
to_numpy: Retorna um array NumPy
to_json: Retorna um objeto JSON
to_csv: Retorna um objeto CSV
to_excel: Retorna um objeto Excel
to_clipboard: Retorna um objeto Clipboard

O atributo values retorna os elementos da série.

print("Tipo:", type(serie.values))
print("Valores:")
print(serie.values)

Tipo: <class 'numpy.ndarray'>
Valores:
[1 7 2]

O atributo index retorna os rótulos dos elementos da série.

print(serie.index)

RangeIndex(start=0, stop=3, step=1)

O objeto RangeIndex(start=X, stop=Y, step=Z) é o objeto de índice padrão do Pandas, indicando a sequência de valores inicial (X), final (Y) e de incremento (Z).

O método len para retornar o número de elementos na série.

print(len(serie))

O atributo shape() retorna uma tupla com o número de linhas e colunas.

print(serie.shape)

(3,)

Os atributos head e tail retornam as primeiras e ultimas 5 linhas da serie.

print(serie.head())
print()
print(serie.tail())

0    1
1    7
2    2
dtype: int64

0    1
1    7
2    2
dtype: int64

O método describe retorna informações estatísticas sobre a série.

texto = serie.describe()
print("Tipo:", type(texto))
print(texto)

Tipo: <class 'pandas.core.series.Series'>
count    3.000000
mean     3.333333
std      3.214550
min      1.000000
25%      1.500000
50%      2.000000
75%      4.500000
max      7.000000
dtype: float64

O método sort_index ordena os índices.

val = serie.sort_index(ascending=False)
print("Tipo:", type(val))
print(val)

Tipo: <class 'pandas.core.series.Series'>
2    2
1    7
0    1
dtype: int64

O método sort_values ordena os valores.

val = serie.sort_values()
print("Tipo:", type(val))
print(val)

Tipo: <class 'pandas.core.series.Series'>
0    1
2    2
1    7
dtype: int64

O método copy retorna uma cópia.

copia = serie.copy()
print("Tipo:", type(copia))
print(copia)
print(serie == copia)
print(serie is copia)

Tipo: <class 'pandas.core.series.Series'>
0    1
1    7
2    2
dtype: int64
0    True
1    True
2    True
dtype: bool
False

O método to_list retorna uma lista.

lista = serie.to_list()
print("Tipo:", type(lista))
print(lista)

Tipo: <class 'list'>
[1, 7, 2]

O método to_frame retorna um DataFrame.

frame = serie.to_frame()
print("Tipo:", type(frame))
print(frame)

Tipo: <class 'pandas.core.frame.DataFrame'>
   0
0  1
1  7
2  2

O método to_string retorna uma string.

texto = serie.to_string()
print("Tipo:", type(texto))
print(texto)

Tipo: <class 'str'>
0    1
1    7
2    2

O método to_dict retorna um dicionário.

dic = serie.to_dict()
print("Tipo:", type(dic))
print(dic)

Tipo: <class 'dict'>
{0: 1, 1: 7, 2: 2}

O método to_numpy retorna um array NumPy.

npy = serie.to_numpy()
print("Tipo:", type(npy))
print(npy)

Tipo: <class 'numpy.ndarray'>
[1 7 2]

O método to_json retorna um objeto JSON.

json = serie.to_json()
print("Tipo:", type(json))
print(json)

Tipo: <class 'str'>
{"0":1,"1":7,"2":2}

O método to_csv retorna um objeto CSV.

csv = serie.to_csv()
print("Tipo:", type(csv))
print(csv)

Tipo: <class 'str'>
,0
0,1
1,7
2,2

O método to_excel retorna um objeto Excel.

nome_arquivo = "dados.xlsx"
print(serie.to_excel(nome_arquivo))

None

O método to_clipboard copia o conteúdo para o Clipboard em formato-texto, funcionando em conjunto com o sistema operacional, como Windows, Mac e Linux.

O conteúdo da série é copiado para o clipboard e pode ser colado usando o atalho para colar usando o teclado, por exemplo, geralmente com as teclas Ctrl + V.

cb = serie.to_clipboard()
print("Tipo:", type(cb))
print(cb)

Tipo: <class 'NoneType'>
None

Rótulos

Nas séries são atribuidos valores aos elementos, chamados rótulos, usando o método index.

Se nada mais for especificado, os valores serão rotulados com seu número de índice.

O primeiro valor terá índice 0 no rótulo, o segundo valor terá índice 1 e assim por diante até o índice n-1, onde n é o número de itens na série.

print(serie.index)

RangeIndex(start=0, stop=3, step=1)

Com o argumento index, você pode nomear seus próprios rótulos.

serie = pd.Series([1, 7, 2], index = ["x", "y", "z"])
print(serie)

x    1
y    7
z    2
dtype: int64

O argumento index atribui a lista de textos com os rótulos da série.

print(serie.index)

Index(['x', 'y', 'z'], dtype='object')

Este rótulo pode ser usado para acessar um valor de específico do rótulo.

print(serie["y"])

O valor continua sendo acessado pelo índice.

print(serie[0])

Objetos de chave/valor como série

Você pode usar dicionários de itens chave:valor ao criar uma série.

Crie uma série de Pandas simples a partir de um dicionário:

calorias = {"dia1": 420, "dia2": 380, "dia3": 390}
serie = pd.Series(calorias)
print(serie)

dia1    420
dia2    380
dia3    390
dtype: int64

Nota: As chaves do dicionário tornam-se os rótulos.

Para selecionar apenas alguns dos itens do dicionário, use o argumento index e especifique apenas os itens que deseja incluir na série.

Crie uma série usando apenas dados de "dia1" e "dia2":

serie = pd.Series(calorias, index = ["dia1", "dia2"])
print(serie)

dia1    420
dia2    380
dtype: int64

1.2 - Classe DataFrame

Os conjuntos de dados em Pandas são tabelas multidimensionais contidas em objetos da classe DataFrame.

No texto da documentação, tanto o objeto quanto a classe DataFrame são referidos de forma genérica como dataframe nas explicações, e a variável do objeto instanciado como df.

Um dataframe é uma estrutura de dados bidimensional, como uma matriz bidimensional ou uma tabela com linhas e colunas.

O objeto da classe Series, com uma série de dados, é como uma coluna; o objeto da classe DataFrame é como uma tabela inteira, com várias séries compondo as colunas.

Criamos um dataframe simples do Pandas com duas séries, usando um dicionário:

dados_em_dicionario = {
  "calorias" : [420, 380, 390],
  "duracao"  : [50, 40, 45]
}
df = pd.DataFrame(dados_em_dicionario)
print(df)
print()
print(type(df))

   calorias  duracao
0       420       50
1       380       40
2       390       45

<class 'pandas.core.frame.DataFrame'>

1.2.1 - Localização de linhas

Dataframes definem tabelas com linhas e colunas.

O atributo loc[] retorna uma ou mais linhas especificadas do dataframe.

O exemplo abaixo retorna a linha, do tipo Series, do índice 0 do dataframe:

serie = df.loc[0]
print(serie)
print(type(serie))

calorias    420
duracao      50
Name: 0, dtype: int64
<class 'pandas.core.series.Series'>

O atributo loc[] com uma lista de indices retorna o objeto do Pandas do tipo DataFrame.

O exemplo abaixo retorna as linha dos índice 0 e 1 do dataframe:

df_indices = df.loc[[0, 1]]
print(df_indices)
print(type(df_indices))

   calorias  duracao
0       420       50
1       380       40
<class 'pandas.core.frame.DataFrame'>

1.2.2 - Índices nomeados

Com o argumento index, você pode nomear seus próprios índices.

Adicione uma lista de nomes para dar um nome a cada linha:

df = pd.DataFrame(dados_em_dicionario, index = ["dia1", "dia2", "dia3"])
print(df)

      calorias  duracao
dia1       420       50
dia2       380       40
dia3       390       45

1.2.2.1 - Localização de índices nomeados

O atributo loc[] com o nome do índice localiza e retorna a(s) linha(s) especificada(s).

O exemplo abaixo localiza e retorna a linha com o índice nomeado "dia2":

calorias = {"dia1": 420, "dia2": 380, "dia3": 390}
serie = pd.Series(calorias)
print(serie)
print(serie.loc["dia2"]) # Consulte o índice nomeado "dia2"

dia1    420
dia2    380
dia3    390
dtype: int64
380

1.2.3 - Impressão de um dataframe

Imprimindo o dataframe, dependendo do tamanho, o Pandas mostrará apenas as 5 primeiras linhas e as últimas 5 linhas.

O atributo pd.options.display.max_rows determina o valor máximo para apresentação de todas as linhas do dataframe.

print(pd.options.display.max_rows)

O valor do atributo determina que se o dataframe contiver mais linhas que este valor, a instrução print(df) mostrará apenas os cabeçalhos, as primeiras 5 linhas e as últimas 5 linhas.

Você pode alterar o número máximo de linhas com a mesma instrução.

pd.options.display.max_rows = 20
print(df)

      calorias  duracao
dia1       420       50
dia2       380       40
dia3       390       45

O exemplo a seguir cria duas matrizes NumPy, uma para x e outra para y e, em seguida, cria um DataFrame usando o Pandas com essas matrizes.

O resultado será um DataFrame com duas colunas, x e y, onde x varia de 1 a 20 e y é o quadrado de x.

import pandas as pd
import numpy as np

# Criar uma matriz NumPy com valores de x de 1 a 20
x = np.arange(1, 21)

# Criar uma matriz NumPy com valores de y sendo o quadrado de x
y = x**2

# Criar o DataFrame com as colunas <i>x</i> e <i>y</i>
df = pd.DataFrame({'x': x, 'y': y})

# Imprimir o DataFrame
print(df)

     x    y
0    1    1
1    2    4
2    3    9
3    4   16
4    5   25
5    6   36
6    7   49
7    8   64
8    9   81
9   10  100
10  11  121
11  12  144
12  13  169
13  14  196
14  15  225
15  16  256
16  17  289
17  18  324
18  19  361
19  20  400

Os 20 valores foram impressos por que o atributo pd.options.display.max_rows foi anteriormente configurado para 20.

print(pd.options.display.max_rows)

Agora vamos criar o datafame com 30 elementos.

# Criar uma matriz NumPy com valores de x de 1 a 30
x = np.arange(1, 31)

# Criar uma matriz NumPy com valores de y sendo o quadrado de x
y = x**2

# Criar o DataFrame com as colunas <i>x</i> e <i>y</i>
df = pd.DataFrame({'x': x, 'y': y})

# Imprimir o DataFrame
print(df)

     x    y
0    1    1
1    2    4
2    3    9
3    4   16
4    5   25
..  ..  ...
25  26  676
26  27  729
27  28  784
28  29  841
29  30  900

[30 rows x 2 columns]

Foram impressos apenas as 5 primeiras e as 5 últimas pelo número de linhas ser maior que o valor do atributo pd.options.display.max_rows.

print(pd.options.display.max_rows)

O método to_string() imprime todos os dados do dataframe como texto.

df_str = df.to_string()
print(type(df_str))
print(df_str)

<class 'str'>
     x    y
0    1    1
1    2    4
2    3    9
3    4   16
4    5   25
5    6   36
6    7   49
7    8   64
8    9   81
9   10  100
10  11  121
11  12  144
12  13  169
13  14  196
14  15  225
15  16  256
16  17  289
17  18  324
18  19  361
19  20  400
20  21  441
21  22  484
22  23  529
23  24  576
24  25  625
25  26  676
26  27  729
27  28  784
28  29  841
29  30  900

Aumente o número máximo de linhas para exibir todo o DataFrame:

pd.options.display.max_rows = len(df)
print(df)

     x    y
0    1    1
1    2    4
2    3    9
3    4   16
4    5   25
5    6   36
6    7   49
7    8   64
8    9   81
9   10  100
10  11  121
11  12  144
12  13  169
13  14  196
14  15  225
15  16  256
16  17  289
17  18  324
18  19  361
19  20  400
20  21  441
21  22  484
22  23  529
23  24  576
24  25  625
25  26  676
26  27  729
27  28  784
28  29  841
29  30  900

1.2.4 - Arquivos de dados

O conjunto de dados armazenado em um arquivo em uma unidade de armazenamento, com formato reconhecido pelo Pandas, pode ser carregado em um dataframe.

O arquivo é aberto e lido, e os dados são interpretados e carregados no dataframe.

Existem diversos formatos de dados de arquivos que podem ser lidos e gravados pelo Python, sendo os principais os formatos CSV e JSON.

CSV

Uma forma simples para armazenamento de grandes conjuntos de dados é usando arquivos CSV (arquivos separados por vírgula).

Os arquivos-texto no formato CSV são bem conhecidos e muito utilizados por serem fáceis de acessar e conterem texto simples de trabalhar.

Em nossos exemplos, usaremos um arquivo CSV chamado 'dados_alunos.csv', que pode ser baixado aqui.

Este arquivo está no formato CSV e contém 20 linhas com as notas de matemática, português, geografia e história dos alunos de A a T, das escolas U, V, X e Z.

Para ver o texto do arquivo-texto use a função nativa open() do Python, com os atributos de leitura e texto. Leia o conteúdo com o método read() e imprima o conteúdo do arquivo com print().

arq = open('dados_alunos.csv','rt')
dados = arq.read()
print(dados)
arq.close()

aluno, escola, mat, port, geo, hist
A, U, 9, 8, 7, 5
B, U, 8, 9, 6, 6 
C, U, 9, 9, 8, 7
D, U, 8, 9, 9, 8 
E, V, 9, 7, 8, 8 
F, V, 7, 9, 6, 8 
G, V, 8, 6, 7, 9 
H, V, 8, 7, 9, 8 
I, V, , 8, 8, 9 
J, V, 9, 8, 6, 8 
K, X, 6, 8, 7, 7 
L, X, 7, , 8, 8 
M, X, 6, 7, 8, 9
N, Z, 9, 9, 7, 7
O, Z, 7, 5, 9, 5
P, Z, 6, 7, 9, 7
Q, Z, , 8, 6, 6
R, Z, 8, 9, 8, 9
S, Z, 9, 6, 8, 8
T, Z, 7, 5, , 7

Carregue o arquivo "dados_alunos.csv" em um dataframe:

import pandas as pd
df = pd.read_csv('dados_alunos.csv')

Imprimindo o dataframe, o Pandas retornará apenas as 5 primeiras linhas e as últimas 5 linhas.

No exemplo abaixo o atributo pd.options.display.max_rows irá configurar o valor máximo para apresentação de todas as linhas do dataframe.

O arquivo tem 20 linhas, e max_rows será configurado com 19.

pd.options.display.max_rows = 19
print(type(df))
print(df)

<class 'pandas.core.frame.DataFrame'>
   aluno  escola  mat  port  geo   hist
0      A       U    9     8    7      5
1      B       U    8     9    6      6
2      C       U    9     9    8      7
3      D       U    8     9    9      8
4      E       V    9     7    8      8
..   ...     ...  ...   ...  ...    ...
15     P       Z    6     7    9      7
16     Q       Z          8    6      6
17     R       Z    8     9    8      9
18     S       Z    9     6    8      8
19     T       Z    7     5           7

[20 rows x 6 columns]

O método to_string() imprime todos os dados do dataframe como texto.

df_str = df.to_string()
print(type(df_str))
print(df_str)

<class 'str'>
   aluno  escola  mat  port  geo   hist
0      A       U    9     8    7      5
1      B       U    8     9    6      6
2      C       U    9     9    8      7
3      D       U    8     9    9      8
4      E       V    9     7    8      8
5      F       V    7     9    6      8
6      G       V    8     6    7      9
7      H       V    8     7    9      8
8      I       V          8    8      9
9      J       V    9     8    6      8
10     K       X    6     8    7      7
11     L       X    7          8      8
12     M       X    6     7    8      9
13     N       Z    9     9    7      7
14     O       Z    7     5    9      5
15     P       Z    6     7    9      7
16     Q       Z          8    6      6
17     R       Z    8     9    8      9
18     S       Z    9     6    8      8
19     T       Z    7     5           7

JSON

Os conjuntos de fontes de dados big data na internet são comumente armazenados e extraídos como JSON.

JSON é um formato de texto simples, estruturado como objeto, bastante conhecido no mundo da programação, incluindo Pandas.

Ler arquivo JSON

Em nossos exemplos, usaremos um arquivo JSON chamado 'dados_alunos.json', que pode ser baixado aqui.

Para ver o texto do arquivo-texto use a função nativa open() do Python, com os atributos de leitura e texto.

Leia o conteúdo com o método read() e imprima o conteúdo do arquivo com print().

arq = open('dados_alunos.json','rt')
dados = arq.read()
print(dados)

{
    "aluno":{
        "0":"A","1":"B","2":"C","3":"D","4":"E",
        "5":"F","6":"G","7":"H","8":"I","9":"J",
        "10":"K","11":"L","12":"M","13":"N","14":"O",
        "15":"P","16":"Q","17":"R","18":"S","19":"T"
    },
    "escola":{
        "0":"U","1":"U","2":"U","3":"U","4":"V",
        "5":"V","6":"V","7":"V","8":"V","9":"V",
        "10":"X","11":"X","12":"X","13":"Z","14":"Z",
        "15":"Z","16":"Z","17":"Z","18":"Z","19":"Z",
    },
    "mat":{
        "0":9,"1":8,"2":9,"3":8,"4":9,
        "5":7,"6":8,"7":8,"8":8,"9":9,
        "10":6,"11":7,"12":6,"13":9,"14":7,
        "15":6,"16":8,"17":8,"18":9,"19":7
    },
    "port":{
        "0":8,"1":9,"2":9,"3":9,"4":7,
        "5":9,"6":6,"7":7,"8":8,"9":8,
        "10":8,"11":9,"12":7,"13":9,"14":5,
        "15":7,"16":8,"17":9,"18":6,"19":5
    },
    "geo":{
        "0":7,"1":6,"2":8,"3":9,"4":8,
        "5":6,"6":7,"7":9,"8":8,"9":6,
        "10":7,"11":8,"12":8,"13":7,"14":9,
        "15":9,"16":6,"17":8,"18":8,"19":8
    },
    "hist":{
        "0":5,"1":6,"2":7,"3":8,"4":8,
        "5":8,"6":9,"7":8,"8":9,"9":8,
        "10":7,"11":8,"12":9,"13":7,"14":5,
        "15":7,"16":6,"17":9,"18":8,"19":7
    }
}

Abra e carregue o arquivo JSON "dados_alunos.json" em um dataframe, e imprima as primeiras e últimas 5 linhas do dataframe:

pd.options.display.max_rows = 19
df = pd.read_json('dados_alunos.json')
print(df)

   aluno escola  mat  port  geo  hist
0      A      U    9     8    7     5
1      B      U    8     9    6     6
2      C      U    9     9    8     7
3      D      U    8     9    9     8
4      E      V    9     7    8     8
..   ...    ...  ...   ...  ...   ...
15     P      Z    6     7    9     7
16     Q      Z    8     8    6     6
17     R      Z    8     9    8     9
18     S      Z    9     6    8     8
19     T      Z    7     5    8     7

[20 rows x 6 columns]

Abra, carregue e imprima todas as linhas do dataframe com o método to_string().

df_str = df.to_string()
print(type(df_str)) 
print(df_str)

<class 'str'>
   aluno escola  mat  port  geo  hist
0      A      U    9     8    7     5
1      B      U    8     9    6     6
2      C      U    9     9    8     7
3      D      U    8     9    9     8
4      E      V    9     7    8     8
5      F      V    7     9    6     8
6      G      V    8     6    7     9
7      H      V    8     7    9     8
8      I      V    8     8    8     9
9      J      V    9     8    6     8
10     K      X    6     8    7     7
11     L      X    7     9    8     8
12     M      X    6     7    8     9
13     N      Z    9     9    7     7
14     O      Z    7     5    9     5
15     P      Z    6     7    9     7
16     Q      Z    8     8    6     6
17     R      Z    8     9    8     9
18     S      Z    9     6    8     8
19     T      Z    7     5    8     7

Dicionário como JSON

Os objetos JSON têm o mesmo formato dos dicionários Python, com uma cadeia aninhada de itens com pares de chave:valor.

Se o seu código JSON não estiver em um arquivo, mas em um Dicionário Python, você poderá carregá-lo diretamente em um DataFrame:

Carregue um dicionário Python em um dataframe:

import pandas as pd
#
data = {
  "Duracao":{
    "0":60,
    "1":60,
    "2":60,
    "3":45,
    "4":45,
    "5":60
  },
  "Pulso":{
    "0":110,
    "1":117,
    "2":103,
    "3":109,
    "4":117,
    "5":102
  },
  "Pulso_maximo":{
    "0":130,
    "1":145,
    "2":135,
    "3":175,
    "4":148,
    "5":127
  },
  "Calorias":{
    "0":409,
    "1":479,
    "2":340,
    "3":282,
    "4":406,
    "5":300
  }
}

df = pd.DataFrame(data)

print(df)

   Duracao  Pulso  Pulso_maximo  Calorias
0       60    110           130       409
1       60    117           145       479
2       60    103           135       340
3       45    109           175       282
4       45    117           148       406
5       60    102           127       300

1.2.5 - Consulta do dataframe

O método head() é usado para uma visão inicial do dataframe, retornando o cabeçalho e um número especificado de linhas, começando do topo.

Não sendo especificado o número de linhas, retorna as 5 primeiras linhas.

Imprima as primeiras 5 linhas do DataFrame:

print(df.head())

   Duracao  Pulso  Pulso_maximo  Calorias
0       60    110           130       409
1       60    117           145       479
2       60    103           135       340
3       45    109           175       282
4       45    117           148       406

Obtenha uma visão inicial imprimindo as primeiras 10 linhas do dataframe:

print(df.head(10))

   Duracao  Pulso  Pulso_maximo  Calorias
0       60    110           130       409
1       60    117           145       479
2       60    103           135       340
3       45    109           175       282
4       45    117           148       406
5       60    102           127       300

O método tail() retorna os cabeçalhos e um número especificado de linhas, em ordem inversa, da última para primeira, a partir da linha final do arquivo.

Imprima as últimas 5 linhas do DataFrame:

print(df.tail())

   Duracao  Pulso  Pulso_maximo  Calorias
1       60    117           145       479
2       60    103           135       340
3       45    109           175       282
4       45    117           148       406
5       60    102           127       300

1.2.6 - Informações sobre os dados

O objeto DataFrames possui um método chamado info(), que fornece informações sobre o conjunto de dados.

Observe as declarações no texto do arquivo "dados_alunos.json", com formato JSON, de itens com pares de chave contendo valores igual "null" .

arq = open('dados_alunos.json','rt')
dados = arq.read()
print(dados)

{
    "aluno":{
        "0":"A","1":"B","2":"C","3":"D","4":"E",
        "5":"F","6":"G","7":"H","8":"I","9":"J",
        "10":"K","11":"L","12":"M","13":"N","14":"O",
        "15":"P","16":"Q","17":"R","18":"S","19":"T"
    },
    "escola":{
        "0":"U","1":"U","2":"U","3":"U","4":"V",
        "5":"V","6":"V","7":"V","8":"V","9":"V",
        "10":"X","11":"X","12":"X","13":"Z","14":"Z",
        "15":"Z","16":"Z","17":"Z","18":"Z","19":"Z",
    },
    "mat":{
        "0":9,"1":8,"2":9,"3":8,"4":9,
        "5":7,"6":8,"7":8,"8":8,"9":9,
        "10":6,"11":7,"12":6,"13":9,"14":7,
        "15":6,"16":8,"17":8,"18":9,"19":7
    },
    "port":{
        "0":8,"1":9,"2":9,"3":9,"4":7,
        "5":9,"6":6,"7":7,"8":8,"9":8,
        "10":8,"11":9,"12":7,"13":9,"14":5,
        "15":7,"16":8,"17":9,"18":6,"19":5
    },
    "geo":{
        "0":7,"1":6,"2":8,"3":9,"4":8,
        "5":6,"6":7,"7":9,"8":8,"9":6,
        "10":7,"11":8,"12":8,"13":7,"14":9,
        "15":9,"16":6,"17":8,"18":8,"19":8
    },
    "hist":{
        "0":5,"1":6,"2":7,"3":8,"4":8,
        "5":8,"6":9,"7":8,"8":9,"9":8,
        "10":7,"11":8,"12":9,"13":7,"14":5,
        "15":7,"16":6,"17":9,"18":8,"19":7
    }
}

Carregue o arquivo JSON no dataframe e observe os valores None nos campos do tipo texto e NaN nos campos do tipo numérico:

import pandas as pd
df = pd.read_json('dados_alunos.json')
df_str = df.to_string()
print(type(df_str)) 
print(df_str)

<class 'str'>
   aluno escola  mat  port  geo  hist
0      A      U    9     8    7     5
1      B      U    8     9    6     6
2      C      U    9     9    8     7
3      D      U    8     9    9     8
4      E      V    9     7    8     8
5      F      V    7     9    6     8
6      G      V    8     6    7     9
7      H      V    8     7    9     8
8      I      V    8     8    8     9
9      J      V    9     8    6     8
10     K      X    6     8    7     7
11     L      X    7     9    8     8
12     M      X    6     7    8     9
13     N      Z    9     9    7     7
14     O      Z    7     5    9     5
15     P      Z    6     7    9     7
16     Q      Z    8     8    6     6
17     R      Z    8     9    8     9
18     S      Z    9     6    8     8
19     T      Z    7     5    8     7

Finalmente imprima as informações sobre os dados:

print(df.info())

<class 'pandas.core.frame.DataFrame'>
Int64Index: 20 entries, 0 to 19
Data columns (total 6 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   aluno   20 non-null     object
 1   escola  20 non-null     object
 2   mat     20 non-null     int64 
 3   port    20 non-null     int64 
 4   geo     20 non-null     int64 
 5   hist    20 non-null     int64 
dtypes: int64(4), object(2)
memory usage: 1.1+ KB
None

1.2.6.1 - Resultado explicado

O resultado nos diz que existem 20 linhas e 6 colunas.

As colunas aluno e escola têm dados com conteúdo caracter, por isso são criadas com o tipo object.

As colunas mat, port, geo e hist têm dados com conteúdo inteiro de 8 bytes (64 bits) e por isso aa colunas são identificadas com o tipo int64.

Os dados estão integros e por isso a contagem de todos os objetos é igual a 20 e não existem objetos nulos.

1.2.6.2 - Valores Nulos

O método info() retorna a quantidade de valores não nulos presentes em cada coluna.

No conjunto de dados há 17 de 20 valores não nulos na coluna "mat".

Portanto existem 3 linhas com valor nulo (representando valor nenhum) nessa coluna.

Valores vazios, ou valores nulos, influenciam negativamente na análise de dados.

Você deve considerar limpar os dados removendo as linhas com valores vazios ou nulos.

Arduino

Coautor

Betobyte

Autor

Autores

||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Pandas || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (introdução) | Series (Series) | Dataframes (Dataframes) | Limpeza (limpeza) | Correlações (correlações) | Plotagem Pandas (plotagem pandas) | Seleções Pandas (Seleções pandas) | Pandas x SQL (Pandas x SQL) |