quarta-feira, 12 de agosto de 2020

Como usar o método fillna() do pandas

Photo by Brett Jordan on Unsplash

A primeira linguagem de programação que vem a mente, quando o assunto é analise de dados, é a linguagem python. Isso por que python fornece um ecossistema de pacotes para a análise de dados. pandas é um desses pacotes. Com ele podemos importar dados de um dataset e realizar algumas analises facilmente.
Um problema comum, quando importamos dados de um dataset, é elementos com valores NaN (sem valor). Esse valor pode causar problemas e erros na analise de dados, por isso pode ser interessante colocar um valor para esses elementos.
Nesse tutorial, vamos aprender a substituir valores NaN dos dataframes pandas utilizando o método fillna(). O método fillna() pode preencher todos os elementos vazios com um valor definido.
Para começar, vamos precisar de um dataframe com elementos vazios.

>>> import pandas as pd
>>> import numpy as np
>>> dados = {
... 'A':[np.nan, 4, 8, np.nan],
... 'B':[9, np.nan, 6, np.nan],
... 'C':[np.nan, 1, np.nan, 9],
... 'D':[np.nan, np.nan, 8, 3]
... }
>>> df = pd.DataFrame(dados)
>>> df
     A    B    C    D
0  NaN  9.0  NaN  NaN
1  4.0  NaN  1.0  NaN
2  8.0  6.0  NaN  8.0
3  NaN  NaN  9.0  3.0

O funcionamento do método fillna() é bem simples, só precisamos passar para o método qual é o valor que vai substituir o valor NaN. Assim o método vai procurar por todo o dataframe, e onde encontrar um elemento vazio, ele vai preencher esse elemento com o valor que recebeu.

>>> df.fillna(2)
     A    B    C    D
0  2.0  9.0  2.0  2.0
1  4.0  2.0  1.0  2.0
2  8.0  6.0  2.0  8.0
3  2.0  2.0  9.0  3.0

Também podemos utilizar os valores do próprio dataframe para preencher os elementos vazios. Por exemplo, se quiséssemos preencher o elemento vazio com o último valor não vazio, passaríamos o valor 'ffill' (forward fill) para o parâmetro method. Outra meio de preencher é com o próximo valor não vazio da sequência, nesse caso passamos o valor 'bfill' (back fill) para o parâmetro method.

>>> dados = [
... [None, 2, 6],
... [1, None, None],
... [None, 3, None]
... ]
>>> df = pd.DataFrame(dados)
>>> df
     0    1    2
0  NaN  2.0  6.0
1  1.0  NaN  NaN
2  NaN  3.0  NaN

>>> df.fillna(method='ffill')
     0    1    2
0  NaN  2.0  6.0
1  1.0  2.0  6.0
2  1.0  3.0  6.0

>>> df.fillna(method='bfill')
     0    1    2
0  1.0  2.0  6.0
1  1.0  3.0  NaN
2  NaN  3.0  NaN

Também podemos definir o valor que será usado para preencher cada coluna. Por exemplo, você pode definir que os elementos vazios da coluna A serão preenchidos com o valor 'um' e da coluna D com o valor 'dois'.

>>> replace = {'A':'um', 'D':'dois'}
>>> df.fillna(value=replace)
    A    B    C     D
0   1  NaN  5.0  dois
1  um  2.0  NaN     6
2   3  NaN  8.0  dois
3  um  4.0  NaN     9

Um parâmetro, que pode ser útil, é o limit. Com ele podemos definir quantos elementos vazios serão substituídos. Por exemplo, se você quiser que apenas um elementos de cada coluna seja substituído passe o valor 1 para o parâmetro limit.

>>> df.fillna(value=replace, limit=1)
     A    B    C     D
0    1  NaN  5.0  dois
1   um  2.0  NaN     6
2    3  NaN  8.0   NaN
3  NaN  4.0  NaN     9

Repare que apenas um elemento vazio de cada coluna foi substituído.
Quer aprender mais sobre a biblioteca pandas? Comece com nossos tutoriais pandas.

Referência:
Função fillna()

terça-feira, 11 de agosto de 2020

Seleção de subconjuntos de dados

Photo by Thanos Pal on Unsplash

Introdução

As dimensões de uma série ou dataframe tem seu rotulo no objeto index. O objeto index é usado para separar as estruturas do pandas. São os indexs que rotulam cada linha e coluna, com isso podemos selecionar os dados do dataframe. A biblioteca pandas também permite selecionar dados de acordo com a posição das colunas e linhas. Podendo selecionar dados por nome ou números (posição), a biblioteca pandas fornece uma sintaxe poderosa. O que acaba torna a seleção de subconjuntos um pouco confusa.
Já vimos exemplos de seleção de dados por rótulo e posição. A lista e o dicionário do python fazem isso. Esse é um dos motivos da biblioteca pandas ser poderosa. Juntando a capacidade de acessar dados por rótulo (dicionário) e posição (lista) temos um tipo de dado muito versátil.

Seleção de dados da série com pandas

As séries e os dataframes pandas funcionam como contêiner de dados. Esses contêineres têm métodos e atributos que nos permitem selecionar os dados de várias maneiras. Os métodos e atributos fazer operações com índices para selecionar os dados. Também podemos usar os atributos iloc e loc.
Podemos selecionar dados informando a posição ou um rótulo. Usando o atributo iloc selecionamos os dados por posição, fazendo um objeto do pandas parecer com uma lista. Já usando o atributo loc, selecionamos os dados informando um rótulo, como um dicionário do python.
Esses dois atributos estão presentes nas séries e nos dataframes. Nesse tutorial vamos aprender a selecionar dados utilizando rótulos e posições. Os dois atributos aceitam valores escalares e listas.
Colocando colchetes depois de uma variável estamos fazendo uma operação de índice. Não faz diferença se é uma seleção com rótulo ou posição, tudo é operação de índice.
Você obter o dataset usado nesse tutorial aqui.

Selecionando dados utilizando rótulo e posição

Vamos carregar o dataset na memoria e selecionar uma coluna usando uma operação de index. Nesse primeiro exemplo vamos usar o rótulo da coluna.

>>> import pandas as pd
>>> animelist = pd.read_csv(‘animelist.csv’)
>>> animelist['title']
0                                Inu x Boku SS
1                             Seto no Hanayome
2                           Shugo Chara!! Doki
3                                Princess Tutu
4                          Bakuman. 3rd Season
                         ...                  
14473               Gutchonpa Omoshiro Hanashi
14474                     Geba Geba Shou Time!
14475              Godzilla: Hoshi wo Kuu Mono
14476    Nippon Mukashibanashi: Sannen Netarou
14477               Senjou no Valkyria Special
Name: title, Length: 14478, dtype: object

Podemos ter o mesmo resultado com o atributo loc.

>>> animelist.loc[:, 'title']
0                                Inu x Boku SS
1                             Seto no Hanayome
2                           Shugo Chara!! Doki
3                                Princess Tutu
4                          Bakuman. 3rd Season
                         ...                  
14473               Gutchonpa Omoshiro Hanashi
14474                     Geba Geba Shou Time!
14475              Godzilla: Hoshi wo Kuu Mono
14476    Nippon Mukashibanashi: Sannen Netarou
14477               Senjou no Valkyria Special
Name: title, Length: 14478, dtype: object

Com o atributo loc podemos selecionar linhas e colunas passando o rótulo do índice. Se apenas um valor for passado o atributo vai retornar uma linha com os dados de cada coluna. Se passamos dois valores podemos selecionar as linhas e as colunas, e ainda podemos definir o espaçamento.

# selecionando uma linha
# passamos um número inteiro porque o índice é de inteiros e não strings
>>> animelist.loc[12]
anime_id                                                      11123
title                                          Sekaiichi Hatsukoi 2
title_english     Sekai Ichi Hatsukoi - World's Greatest Fi...
title_japanese                                              世界一初恋 2
title_synonyms    Sekai-ichi Hatsukoi 2, Sekai'ichi Hatsukoi 2
image_url         https://myanimelist.cdn-dena.com/images/anime/...
type                                                             TV
source                                                        Manga
episodes                                                         12
status                                              Finished Airing
airing                                                        False
aired_string                            Oct 8, 2011 to Dec 24, 2011
aired                    {'from': '2011-10-08', 'to': '2011-12-24'}
duration                                            24 min. per ep.
rating                                    PG-13 - Teens 13 or older
score                                                          8.23
scored_by                                                     53285
rank                                                            288
popularity                                                      945
members                                                       89543
favorites                                                       726
background        An event to show ep.1 of season 2 (along with ...
premiered                                                 Fall 2011
broadcast                                                   Unknown
related           {'Adaptation': [{'mal_id': 10309, 'type': 'man...
producer                   Lantis, Kadokawa Shoten, AT-X, KlockWorx
licensor                                                 Funimation
studio                                                  Studio Deen
genre                            Comedy, Drama, Romance, Shounen Ai
opening_theme     ['"Sekai no Hate ni Kimi ga Itemo" (世界の果てに君がいて...
ending_theme             ['"Aikotoba" (アイコトバ) by Sakura Merry-Men']
Name: 12, dtype: object

>>> animelist.loc[12:32, 'title':'rank']
                     title  ...    rank
12    Sekaiichi Hatsukoi 2  ...   288.0
13  Tonari no Kaibutsu-kun  ...  1093.0
14                  Bleach  ...   693.0
15                 Chobits  ...  1546.0
16          Kimi ni Todoke  ...   400.0
17      Naruto: Shippuuden  ...   337.0
18                 Ranma ½  ...   802.0
19               Toradora!  ...   174.0
20     Bakuman. 2nd Season  ...   108.0
21            Gakuen Alice  ...   941.0
22              Skip Beat!  ...   282.0
23           Chihayafuru 2  ...   116.0
24        Shounen Onmyouji  ...  1158.0
25             Chihayafuru  ...   246.0
26         Itazura na Kiss  ...  1108.0
27               Beelzebub  ...   528.0
28   Hanasakeru Seishounen  ...   753.0
29              SKET Dance  ...   213.0
30            B-gata H-kei  ...  3193.0
31        Crayon Shin-chan  ...  1032.0
32           Fruits Basket  ...   939.0

[21 rows x 17 columns]

No ultimo exemplo selecionamos linhas e colunas. Selecionamos os dados da linha numero doze até a linha trinta e dois. As colunas, selecionamos da coluna title até a coluna rank. O atributo iloc funciona do mesmo modo, a diferença é que esse atributo não aceita rótulos. O atributo iloc só aceita posições.

>>> animelist.iloc[12:32, 1:17]
                     title  ... scored_by
12    Sekaiichi Hatsukoi 2  ...     53285
13  Tonari no Kaibutsu-kun  ...    281448
14                  Bleach  ...    433097
15                 Chobits  ...    175388
16          Kimi ni Todoke  ...    212710
17      Naruto: Shippuuden  ...    385179
18                 Ranma ½  ...     59911
19               Toradora!  ...    557898
20     Bakuman. 2nd Season  ...    122090
21            Gakuen Alice  ...     33244
22              Skip Beat!  ...     90699
23           Chihayafuru 2  ...     62720
24        Shounen Onmyouji  ...     14619
25             Chihayafuru  ...     89081
26         Itazura na Kiss  ...     91187
27               Beelzebub  ...    136105
28   Hanasakeru Seishounen  ...     16772
29              SKET Dance  ...     44132
30            B-gata H-kei  ...    142827
31        Crayon Shin-chan  ...     17683

[20 rows x 16 columns]

Para selecionar, do primeiro elemento até um determinado, é só omitir a posição ou rótulo de inicio. Por exemplo: animelist.iloc[:32, 1:17]. Se você quiser definir o inicio e selecionar até o ultimo elemento é só omitir a posição ou rotulo do último elemento: animelist.loc[12:, ‘rank’:].

Referência:
Atributo loc
Atributo iloc

Agrupando e ordenando com pandas

Photo by UX Indonesia on Unsplash

O agrupamento e a classificação de dados é uma das tarefas mais básicas durante a análise de dados. É comum selecionar linhas que tenham o maior valor dentro de uma coluna e classificar esses valores em grupos. Por exemplo, se você precisar saber qual foi o filme de 2016 com maior audiência ou qual é a classificação de filme que arrecada mais com bilheteria, isso seria feito classificando os grupos. Primeiro é preciso separar os filmes por ano e depois selecionar os filmes com maior bilheteria.
Nesse tutorial, vamos descobrir qual é o anime com o maior rank entre os animes com os scores mais altos.

Como agrupar e ordenar com pandas

Primeiro vamos carregar o dataset e selecionar as colunas que nos interessa: title, rank e score. O dataset que vamos utilizar pode ser baixado aqui.

>>> import pandas as pd
>>> animelist = pd.read_csv('animelist.csv')
>>> animelist = animelist[['title', 'score', 'rank']]
>>> animelist
                                       title  score     rank
0                              Inu x Boku SS   7.63   1274.0
1                           Seto no Hanayome   7.89    727.0
2                         Shugo Chara!! Doki   7.55   1508.0
3                              Princess Tutu   8.21    307.0
4                        Bakuman. 3rd Season   8.67     50.0
...                                      ...    ...      ...
14473             Gutchonpa Omoshiro Hanashi   5.50  10337.0
14474                   Geba Geba Shou Time!   4.60  10236.0
14475            Godzilla: Hoshi wo Kuu Mono   0.00      NaN
14476  Nippon Mukashibanashi: Sannen Netarou   6.00  11557.0
14477             Senjou no Valkyria Special   5.15  12056.0

[14478 rows x 3 columns]

Vamos utilizar o método sort_values() para ordenar o dataframe por score. Esse método vai ordenar todo o dataframe começando do menor para o maior. Assim as primeiras linhas serão os animes com os menores score. Para inverter isso passamos o valor False para o parâmetro ascending.

>>> animelist.sort_values(by='score', ascending=False)
                                                   title  score     rank
14407                                         Ittekimasu  10.00  10657.0
14317  Kuunyan no Koutsuu Anzen: Tadashii Jitensha no...  10.00  11071.0
548    Manichi ga Tsurai Kimochi Wakarimasu ka: Yurus...  10.00  11178.0
14467               Kyouiku Eiga-sai Jushou Anime Series  10.00  11091.0
14403                            Dokidoki Little Ooyasan   9.52      NaN
...                                                  ...    ...      ...
6557                                 Asagao to Kase-san.   0.00      NaN
6614                              Boogiepop wa Warawanai   0.00      NaN
14067                             BanG Dream! 2nd Season   0.00      0.0
12964                       Katsugeki/Touken Ranbu Movie   0.00      NaN
12039                           Moshimoshi, Terumi Desu.   0.00      NaN

[14478 rows x 3 columns]

No exemplo acima, os dados foram ordenados de acordo com o score, do maior para o menor. Para ordenar várias colunas, vamos usar uma lista com os nomes das colunas que queremos ordenar.

>>> animelist.sort_values(by=['score', 'rank'], ascending=False)
    title  score     rank
548    Manichi ga Tsurai Kimochi Wakarimasu ka: Yurus...  10.00  11178.0
14467               Kyouiku Eiga-sai Jushou Anime Series  10.00  11091.0
14317  Kuunyan no Koutsuu Anzen: Tadashii Jitensha no...  10.00  11071.0
14407                                         Ittekimasu  10.00  10657.0
14403                            Dokidoki Little Ooyasan   9.52      NaN
...                                                  ...    ...      ...
14414                             Shinya! Tensai Bakabon   0.00      NaN
14416                          Chikyuugai Shounen Shoujo   0.00      NaN
14417                           Uchuu no Hou: Reimei-hen   0.00      NaN
14463                                          Space Bug   0.00      NaN
14475                        Godzilla: Hoshi wo Kuu Mono   0.00      NaN

[14478 rows x 3 columns]

Note que as duas colunas foram ordenadas do maior para o menor. A biblioteca pandas seleciona o score mais alto e depois seleciona os ranks mais altos com o mesmo score. Desse modo, agrupamos os animes de acordo com o score e o rank. Assim obtemos a informação de que o anime com maior rank, entre os animes que tem o maior score, é o Manichi ga Tsurai. Podemos obter um par score/rank dos maiores valores de cada score diferente chamando o método drop_duplicates().

>>> (
... animelist.sort_values(by=['score', 'rank'], ascending=False)
... .drop_duplicates(subset='score')
... )
                                                   title  score     rank
548    Manichi ga Tsurai Kimochi Wakarimasu ka: Yurus...  10.00  11178.0
14403                            Dokidoki Little Ooyasan   9.52      NaN
14454           Tat-chan - Momo-chan no Fushigina Taiken   9.50  12430.0
2555                    Fullmetal Alchemist: Brotherhood   9.25      1.0
3129                                   Okaachan Gomen ne   9.20  11595.0
...                                                  ...    ...      ...
12844                                         Dragon Egg   1.50  10028.0
14420      Cofun Gal no Coffy (TV): Christmas Daisakusen   1.33   9959.0
14393                          Atashi Tenshi Anata Akuma   1.25   9712.0
13955                                         Woo to Wah   1.00  12678.0
14425                        Wo Shi Jiang Xiaobai (2018)   0.00  12719.0

[630 rows x 3 columns]

Por padrão, o método drop_duplicates() pega o primeiro valor. Podemos mudar esse comportamento passando o valor 'last' para o parâmetro keep.

>>> (
... animelist.sort_values(by=['score', 'rank'], ascending=False)
... .drop_duplicates(subset='score', keep='last')
... )
                                               title  score     rank
14407                                     Ittekimasu  10.00  10657.0
14403                        Dokidoki Little Ooyasan   9.52      NaN
14208                                   Hashire John   9.50  10357.0
2555                Fullmetal Alchemist: Brotherhood   9.25      1.0
3129                               Okaachan Gomen ne   9.20  11595.0
...                                              ...    ...      ...
12844                                     Dragon Egg   1.50  10028.0
14420  Cofun Gal no Coffy (TV): Christmas Daisakusen   1.33   9959.0
14393                      Atashi Tenshi Anata Akuma   1.25   9712.0
14187                               Gomen ne Chitchi   1.00  10256.0
14475                    Godzilla: Hoshi wo Kuu Mono   0.00      NaN

[630 rows x 3 columns]

Referência:
Método sort_values()

segunda-feira, 10 de agosto de 2020

Selecionando o menor dos maiores

Photo by Jon Tang on Unsplash

O que vamos fazer nesse tutorial é parecido com as manchetes de noticias cativantes, como das cem melhores universidades, estas cinco tem a menor nota de corte ou dos cinquenta melhores países para morar, estes três são os mais fáceis de conseguir visto.
Uma coisa comum na analise de dados é agrupar dados e depois fazer uma busca nesse grupo. Imagine que você precisar dos n-maiores valores de uma colunas e depois selecionar os n-menores valores desse grupo que você acabou de selecionar.
Nesse tutorial vamos selecionar um grupo de dados e depois selecionar outro grupo de dados a partir dos dados selecionados na primeira seleção. Esse tipo de seleção é utilizado para refinar os resultados. Como analisar gigabytes de dados não é uma tarefa fácil devemos diminuir as variáveis no processo de analise de dados.

Como selecionar o menor dos maiores com pandas

Nesse exemplo vamos obter os cinco animes com o menor rank entre os cem animes com os maiores score. O dataset que vamos usar pode ser obtido aqui.

>>> import pandas as pd
>>> anime = pd.read_csv('animelist.csv')
>>> anime = anime[['title', 'score', 'rank']]
>>> anime.nlargest(100, 'score').nsmallest(5, 'rank')
                                 title  score  rank
2555  Fullmetal Alchemist: Brotherhood   9.25   1.0
1028                    Kimi no Na wa.   9.19   2.0
1252                          Gintama°   9.15   3.0
6177                     Steins;Gate 0   9.15   4.0
2999                       Steins;Gate   9.14   5.0

Como funciona...

Primeiro selecionamos as colunas que nos interessa: title, score e rank. Depois selecionamos as cem linhas com o score mais alto, em seguida selecionamos as cinco linhas com o rank mais baixo. Desse jeito selecionamos os cinco animes com menor rank entre os cem animes com o maior score.

Referência:
Método nlargest()
Método nnsmallest()

Reduzindo memoria utilizada pelo pandas

Photo by Cristina Gottardi on Unsplash

Quando criamos um dataframe com a biblioteca pandas esse dataframe tem os seus tipos de dados muito bem definidos. Isso não acontece quando importamos dados de um arquivo CSV. Nesse caso a biblioteca pandas precisar deduzir qual é o tipo de dados. E isso pode causar um aumento no consumo de memoria, já que a biblioteca pode ocupar espaço de armazenar um numero de ponto flutuante quando só precisa ocupar espaço para um inteiro.
Nesse tutorial vamos aprender a definir o tipo de dados de uma coluna. Fazendo isso vamos reduzir a quantidade de memoria utilizada pelo dataframe.

Como reduzir a memoria utilizada mudando o tipo de dado

Vamos utilizar o método info() para saber o tipo de dado de cada coluna. Com esse método temos um resultado total de quanta memoria o dataframe esta usando.

>>> filmes = pd.read_csv('filmes.csv')
>>> filmes.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 9262 entries, 0 to 9261
Data columns (total 9 columns):
 #   Column                   Non-Null Count  Dtype
---  ------                   --------------  -----
 0   indice                   9262 non-null   int64
 1   codigo_obra              9262 non-null   int64
 2   titulo_original          9262 non-null   object
 3   titulo_brasil            9262 non-null   object
 4   ano_producao             9259 non-null   float64
 5   diretor                  9262 non-null   object
 6   razao_social_requerente  9262 non-null   object
 7   cnpj_requerente          9262 non-null   object
 8   data_exibicao            9262 non-null   object
dtypes: float64(1), int64(2), object(6)
memory usage: 434.2+ KB

Para saber a quantidade individual que cada coluna esta usando chamamos o método memory_usage(). O método memory_usage() retorna uma série com os nomes de cada coluna e a quantidade de memoria utilizada em bytes.

>>> filmes.memory_usage(deep=True)
Index                          64
indice                      74096
codigo_obra                 74096
titulo_original            441609
titulo_brasil              474434
ano_producao                74096
diretor                    434254
razao_social_requerente    615172
cnpj_requerente            435066
data_exibicao              357076
dtype: int64

No dataframe filmes, a coluna ano_producao esta ocupando espaço para armazenar números de ponto flutuante, quando na realidade só precisaria ocupar espaço para armazenar inteiros. Por isso esse dataframe esta utilizando mais memoria do que deveria. Podemos resolver isso convertendo os valores da coluna para inteiros.

>>> filmes.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 9262 entries, 0 to 9261
Data columns (total 9 columns):
 #   Column                   Non-Null Count  Dtype
---  ------                   --------------  -----
 0   indice                   9262 non-null   int64
 1   codigo_obra              9262 non-null   int64
 2   titulo_original          9262 non-null   object
 3   titulo_brasil            9262 non-null   object
 4   ano_producao             9259 non-null   float64
 5   diretor                  9262 non-null   object
 6   razao_social_requerente  9262 non-null   object
 7   cnpj_requerente          9262 non-null   object
 8   data_exibicao            9262 non-null   object
dtypes: float64(1), int64(2), object(6)
memory usage: 434.2+ KB

>>> filmes.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 9262 entries, 0 to 9261
Data columns (total 9 columns):
 #   Column                   Non-Null Count  Dtype
---  ------                   --------------  -----
 0   indice                   9262 non-null   int64
 1   codigo_obra              9262 non-null   int64
 2   titulo_original          9262 non-null   object
 3   titulo_brasil            9262 non-null   object
 4   ano_producao             9262 non-null   int32
 5   diretor                  9262 non-null   object
 6   razao_social_requerente  9262 non-null   object
 7   cnpj_requerente          9262 non-null   object
 8   data_exibicao            9262 non-null   object
dtypes: int32(1), int64(2), object(6)
memory usage: 398.0+ KB

Com isso reduzimos o uso de memoria usado pelo dataframe. Nesse dataframe reduzimos pouco, mas imagine um dataframe com gigabytes de dados do tipo float que podem ser convertidos para int.
Reduzir a memoria utilizada por um dataframe pode não ser possível em algumas situações. A situação onde a redução é mais comum é quando importamos dados de um dataset. Por isso é bom analisar os dados e verificar se a conversão é possível.

Referência:
Método read_csv()
Método info()
Método memory_usage()

Dicionário de dados na analise de dados

Photo by Edho Pratama on Unsplash

A criação e manutenção de um dicionário de dados é uma tarefa muito importante na analise de dados. Mais o que é um dicionário de dados? Um dicionário de dados é uma tabela com informações sobre os dados, como por exemplo, o significado das abreviações usadas no banco de dados, uma explicação de como esses dados foram obtidos, entre outras coisas. Um dos principais objetivos de um dicionário é explicar qual é o significado de cada coluna. O dicionário é importante quando o trabalho é em grupo, ou pra você mesmo quando passar muito tempo sem olhar os dados. Com um dicionário fica fácil, para uma pessoa que acabou de pegar esses dados, saber do que se trata e como utiliza-lo da melhor forma.
Um exemplo parecido é um dicionário de termos urbanos. Esse dataset contem expressões e os seus significados. Um dicionário de dados tem a mesma função: explicar termos ou dados que podem confundir o analista.

>>> import pandas as pd
>>> urban_dictionary = pd.read_csv('urban_dictionary.csv')
>>> urban_dictionary
                                             definition  ...               date
0     When a city or town specifically zones an area...  ...     April 05, 2013
1                                        A toilet bowl.  ...     March 23, 2017
2     Excellent health care reserved exclusively for...  ...       May 16, 2008
3     A dick thing you say to a tall person to piss ...  ...     March 20, 2017
4     The insane, narcissistic, outrageous asshat wh...  ...     March 18, 2017
...                                                 ...  ...                ...
4267  Verb. Etymology: coming from the modern car tu...  ...     March 26, 2003
4268  (adjective, adverb, interjection) awesome; coi...  ...  February 17, 2003
4269  Something socially unacceptable done in a soci...  ...      June 28, 2004
4270  A night when groups of adults get drunk and us...  ...   January 07, 2004
4271  A year whose number is divisible by four in wh...  ...   January 03, 2004

[4272 rows x 7 columns]

Um dicionário de dados é útil para informar o significado de abreviações. Mas é possível notar que um dataframe não é o melhor lugar para guardar um dicionário de dados. Uma escolha melhor pode ser uma planilha do Excel ou uma do Google. Pra min a melhor alternativa é uma célula Markdown no jupyter.
É comum que você tenha que entrar em contato com quem criou o banco de dados com o qual você está trabalhando, para obter algumas informações. Uma complicação que pode ser evitada com um dicionário de dados. Por isso sempre crie um dicionário de dados do seu banco de dados.

Referência:
Método read_csv()

Analise de dados com pandas

Photo by Isaac Smith on Unsplash

Introdução

Como analista de dados, você precisar analisar os passos que você executa quando encontra um conjunto de dados pela primeira vez. Essa analise deve ser feita logo após ser criado o dataframe. O que você deve se perguntar é: existe alguma rotina que você segue quando encontra um dataset novo? Você sabe quais são os tipos de dados presentes no dataframe? Esse post da inicio a uma série de tutoriais do que fazer quando encontrar um dataset novo. Nessa série vamos responder perguntas comuns sobre coisas que não são simples de fazer com pandas.

Rotina de analise de dados

Não existe um padrão estabelecido do que deve ser feito quando encontramos um dataset pela primeira vez. Uma boa ideia é desenvolver a sua própria rotina do que fazer com um dataset na primeira vez. Assim como temos uma rotina para outras tarefas na nossa vida, como fazer uma lista de compras antes de ir ao supermercado, devemos ter uma rotina para quando obtemos um dataset novo. Essa rotina vai te ajudar nos passos seguintes. Essa rotina pode ser uma lista que coisas que você acha útil fazer com um dataset novo. A lista pode se expandir ou diminuir com o tempo, o que vai definir isso é o beneficio que você vai obter com cada tarefa.
Análise exploratória de dados (AED) é muito utilizada para descrever o processo de analise de conjuntos de dados (datasets). Esse processo não engloba a criação de modelos, mas sim a analise a fim de descobrir as principais características e a melhor forma de visualizar esses dados.
Os processos utilizados na analise exploratória de dados são uteis para entender um conjunto de dados. Esses processos são muito utilizados para descobrir qual é a melhor maneira de criar e treinar modelos de aprendizagem de máquina.
Nesse tutorial vamos aprender uma pequena, mas fundamental, parte da Análise exploratória de dados: A coleta de dados e estatísticas do dataset. Aqui vamos descrever uma lista de tarefas que podem ser uteis quando importamos um dataset pela primeira vez. Você pode adicionar os métodos, que vamos mostrar, na sua própria rotina de analise de dados.
Os métodos, utilizados nesse tutorial, descrevem os dados sobre os dados. Vamos aprender a obter algumas informações básicas, como a quantidade de colunas e seus nomes, tipo de dados da coluna entre outros.

Como começar a analise de dados

Primeiro precisamos de um dataset. Os dataset que vamos utilizar podem ser encontrados aqui. Depois vamos pegar algumas amostras do dataframe com o método sample(). Para essas amostras serem mais realistas vamos pegar oito amostras de forma aleatória. Utilizando o parâmetro n para informar a quantidade de amostras e o parâmetro random_state para informar o número que deve ser utilizado na geração de números aleatórios (pseudoaleatórios).

>>> import pandas as pd
>>> animelist = pd.read_csv('animelist.csv')
>>> animelist.sample(n=8, random_state=42)
       anime_id  ...                     ending_theme
12334     12133  ...                               []
8366       8619  ...                               []
1795      18967  ...                               []
7100      36121  ...                               []
6050       8157  ...                               []
14198     35104  ...                               []
8028      33201  ...                               []
1730       1005  ...  ['"Hearts" by Saori Nishihata']

[8 rows x 31 columns]

Para saber a forma do dataframe vamos chamar o atributo shape. Esse atributo retorna uma tupla com a forma do dataframe. O primeiro elemento da tupla é o número de linhas e o segundo o número de colunas.

>>> animelist.shape
(14478, 31)

Chamando o método info() conseguimos algumas informações. Esse método nos mostra o nome de cada coluna, a quantidade de elementos não vazios e o tipo de dado de cada coluna. E ainda nos informa a quantidade de memoria que o dataframe está utilizando.

>>> animelist.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 14478 entries, 0 to 14477
Data columns (total 31 columns):
 #   Column          Non-Null Count  Dtype
---  ------          --------------  -----
 0   anime_id        14478 non-null  int64
 1   title           14478 non-null  object
 2   title_english   5724 non-null   object
 3   title_japanese  14443 non-null  object
 4   title_synonyms  8937 non-null   object
 5   image_url       14382 non-null  object
 6   type            14478 non-null  object
 7   source          14478 non-null  object
 8   episodes        14478 non-null  int64
 9   status          14478 non-null  object
 10  airing          14478 non-null  bool
 11  aired_string    14478 non-null  object
 12  aired           14478 non-null  object
 13  duration        14478 non-null  object
 14  rating          14478 non-null  object
 15  score           14478 non-null  float64
 16  scored_by       14478 non-null  int64
 17  rank            12904 non-null  float64
 18  popularity      14478 non-null  int64
 19  members         14478 non-null  int64
 20  favorites       14478 non-null  int64
 21  background      1057 non-null   object
 22  premiered       4096 non-null   object
 23  broadcast       4271 non-null   object
 24  related         14478 non-null  object
 25  producer        8288 non-null   object
 26  licensor        3373 non-null   object
 27  studio          8544 non-null   object
 28  genre           14414 non-null  object
 29  opening_theme   14478 non-null  object
 30  ending_theme    14478 non-null  object
dtypes: bool(1), float64(2), int64(6), object(22)
memory usage: 2.1+ MB

Se você estiver precisando saber as estatísticas básicas do dataframe é só chamar o método describe(). Esse método nos fornece as estatísticas básicas de cada coluna. Com o parâmetro include especificamos de quais colunas queremos as estatísticas.

>>> import numpy as np
>>> animelist.describe(include=np.number)
           anime_id      episodes  ...       members      favorites
count  14478.000000  14478.000000  ...  1.447800e+04   14478.000000
mean   17377.229866     11.308399  ...  2.296640e+04     311.649606
std    13165.315011     43.443451  ...  7.498136e+04    2615.554211
min        1.000000      0.000000  ...  0.000000e+00       0.000000
25%     4389.250000      1.000000  ...  2.450000e+02       0.000000
50%    15135.000000      1.000000  ...  1.679500e+03       2.000000
75%    31146.500000     12.000000  ...  1.037900e+04      23.000000
max    37916.000000   1818.000000  ...  1.456378e+06  106895.000000

[8 rows x 8 columns]
>>> animelist.describe(include='O')
              title title_english  ... opening_theme ending_theme
count         14478          5724  ...         14478        14478
unique        14477          5606  ...          4328         5458
top     Hinamatsuri    Cyborg 009  ...            []           []
freq              2             4  ...          9784         8807

[4 rows x 22 columns]

Esses são alguns métodos que você pode adicionar a lista do que fazer quando tiver um dataset novo. Aumente a lista com os métodos que você achar necessário ou remova algum que não faz diferença pra você, mas sempre crie uma rotina dos primeiros passos com um dataset novo.

Referência:
Método read_csv()
Método sample()
Atributo shape
Método info()
Método describe()