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()

Anterior Próximo

Read More

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()

Anterior Próximo

Read More

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()

Anterior Próximo

Read More

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()

Anterior Próximo

Read More

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()

Anterior Próximo

Read More

Lendo tabelas HTML com pandas

Photo by Artem Sapegin on Unsplash

Um uso pouco conhecido da biblioteca pandas é a sua capacidade de ler tabelas de um site da web. Com pandas é fácil obter dados de uma tabela num site da web como a Wikipédia.
Nesse tutorial vamos obter dados de uma página na Wikipédia. Esses dados são das musicas de Avril Lavgine que foram utilizadas em séries.

Como ler dados de uma tabela HTML com pandas

Primeiro vamos chamar o método read_html(). Esse método carrega todas as tabelas de um arquivo html. Esse arquivo pode estar na internet ou no seu computador.

>>> import pandas as pd
>>> url = 'https://pt.wikipedia.org/wiki/Discografia_de_Avril_Lavigne'
>>> tabelas = pd.read_html(url)
>>> len(tabelas)
27

Com o código acima carregamos todas as tabelas no objeto tabelas. Com isso já podemos procurar pela tabela que queremos. Podemos acessar cada tabela com um índice do objeto tabela. A tabela que contem uma lista com as músicas que foram usados em séries é a 16.

>>> tabelas[16]
          Ano  ...   Ref.
0   2002/2004  ...  [108]
1   2002/2004  ...  [108]
2   2002/2004  ...  [108]
3        2003  ...  [108]
4        2003  ...  [108]
5        2003  ...  [108]
6        2003  ...  [108]
7        2003  ...  [108]
8        2004  ...  [108]
9        2004  ...  [108]
10       2005  ...  [108]
11       2005  ...  [108]
12  2007/2008  ...  [108]
13  2007/2008  ...  [108]
14  2007/2008  ...  [108]
15  2007/2008  ...  [108]
16  2007/2008  ...  [108]
17  2007/2008  ...  [108]
18  2007/2008  ...  [108]
19  2007/2008  ...  [108]
20       2008  ...  [108]
21       2008  ...  [108]
22       2008  ...  [108]
23       2008  ...  [108]
24  2008/2009  ...  [108]
25  2008/2009  ...  [108]
26       2009  ...  [108]
27       2009  ...  [108]

[28 rows x 5 columns]

Procurar por índice pode ser uma tarefa trabalhosa, especialmente se a pagina tiver muitas tabelas. Um jeito de encurtar a busca é carregar apenas a tabela que queremos. Podemos fazer isso identificando a tabela que nos interessa de algum modo. No exemplo abaixo vamos identificar a tabela pelo conteúdo da tag <caption>.

>>> url2 = 'https://en.wikipedia.org/wiki/The_Beatles_discography'
>>> beatles = pd.read_html(url2, match='List of studio albums', na_values='-')
>>> beatles
[                                                Title  ...                                     Certifications
                                                Title  ...                                     Certifications
0                                    Please Please Me  ...  BPI: Gold[10] ARIA: Gold[11] MC: Gold[12] RIAA...
1                                 With the Beatles[B]  ...  BPI: Gold[10] ARIA: Gold[11] BVMI: Gold[14] MC...
2                          Introducing... The Beatles  ...                                 RIAA: Platinum[13]
3                                   Meet the Beatles!  ...             MC: Platinum[12] RIAA: 5× Platinum[13]
4                                     Twist and Shout  ...                                MC: 3× Platinum[12]
5                           The Beatles' Second Album  ...             MC: Platinum[12] RIAA: 2× Platinum[13]
6                        The Beatles' Long Tall Sally  ...                                       MC: Gold[12]
7                                  A Hard Day's Night  ...             MC: Platinum[12] RIAA: 4× Platinum[13]
8                                  A Hard Day's Night  ...                   BPI: Platinum[10] ARIA: Gold[11]
9                                       Something New  ...                 MC: Gold[12] RIAA: 2× Platinum[13]
10                                   Beatles for Sale  ...  BPI: Gold[10] ARIA: Gold[11] MC: Gold[12] RIAA...
11                                        Beatles '65  ...             MC: Platinum[12] RIAA: 3× Platinum[13]
12                                         Beatles VI  ...                    MC: Gold[12] RIAA: Platinum[13]
13                                              Help!  ...                   BPI: Platinum[10] ARIA: Gold[11]
14                                              Help!  ...          MC: 2× Platinum[12] RIAA: 3× Platinum[13]
15                                        Rubber Soul  ...  BPI: Platinum[10] ARIA: Platinum[11] BVMI: Gol...
16                                        Rubber Soul  ...          MC: 2× Platinum[12] RIAA: 6× Platinum[13]
17                                Yesterday and Today  ...             MC: Platinum[12] RIAA: 2× Platinum[13]
18                                           Revolver  ...            BPI: 2× Platinum[10] ARIA: Platinum[11]
19                                           Revolver  ...          MC: 2× Platinum[12] RIAA: 5× Platinum[13]
20              Sgt. Pepper's Lonely Hearts Club Band  ...  BPI: 17× Platinum[10] ARIA: 4× Platinum[11] BV...
21                               Magical Mystery Tour  ...  BPI: Platinum[10] ARIA: Platinum[11] MC: 4× Pl...
22                    The Beatles ("The White Album")  ...  BPI: 2× Platinum[10] ARIA: 2× Platinum[11] MC:...
23                                Yellow Submarine[D]  ...      BPI: Gold[10] MC: Gold[12] RIAA: Platinum[13]
24                                         Abbey Road  ...  BPI: 3× Platinum[10] ARIA: 3× Platinum[11] BVM...
25                                          Let It Be  ...  BPI: Platinum[10] ARIA: Platinum[11] MC: 3× Pl...
26  "—" denotes that the recording did not chart o...  ...  "—" denotes that the recording did not chart o...

[27 rows x 10 columns]]

O parâmetro match especifica que queremos todas as tabelas que tenha a string que passamos para o parâmetro. Nessa pagina apenas uma tabela tinha a string, se tivesse mais elas seriam carregadas também. Outro jeito de especificar uma tabela é pelos atributos das tags HTML. Podemos procurar por atributo e valor do atributo. Por exemplo, se quiséssemos uma tabela cujo valor do atributo id seja tabela1, passaríamos o dicionario {'id':'tabela1'} para o parâmetro attrs. Podemos utilizar qualquer atributo e qualquer valor.

>>> tabela = pd.read_html(url, attrs={'class':'infobox_v2'})
>>> tabela
[   Discografia de Avril Lavigne Discografia de Avril Lavigne.1
0            Avril em Amsterdam             Avril em Amsterdam
1             Álbuns de estúdio                              6
2                Álbuns ao vivo                              4
3          Álbuns de compilação                              2
4               Álbuns de vídeo                              5
5           Extended plays (EP)                              4
6                       Singles                             25
7                       Lados B                             13
8               Vídeos musicais                             16
9             Álbuns de tributo                              1
10                 Vídeo single                              2
11                       Covers                             10
12            Álbuns de remixes                              2]

Nesse exemplo, carregamos todas as tabelas com o valor infobox_v2 atribuído ao atributo class. Nessa página, apenas uma tabela contem o valor infobox_v2 atribuído ao atributo class.

Como funciona o método read_html()

O método read_html() retorna uma lista com dataframes pandas. Para cada tabela encontrada na página um dataframe é criado.

Referência:
Método read_html()

Anterior Próximo

Read More

Lendo o formato de dados JSON

Photo by Hello I'm Nik 🎞 on Unsplash

Um dos formatos mais comum, para a transferência de dados pela internet, é o JavaScrip Object Notation - JSON. Você pode estar pensando que esse formato de transferência de dados só poderia ser utilizado na linguagem de JavaScript, muito provável mente pelo nome JavaScrip, mas isso não é verdade. Muitas outras linguagens de programação fazem uso desse formato de transferência de dados, entre elas o python. O python já vem com um módulo para decodificar e codificar dados no formato JSON.

>>> import pandas as pd
>>> import json
>>> dados =  '{"nome":["Diana", "Fabiana", "Eveline"], "aniversario":[1998, 1991, 1995]}'
>>> pessoas = json.loads(dados)
>>> encoded = json.dumps(pessoas)
>>> encoded
'{"nome": ["Diana", "Fabiana", "Eveline"], "aniversario": [1998, 1991, 1995]}'

Trabalhando com JSON e pandas

Para o nosso primeiro exemplo vamos ler os dados no formato JSON e criar um dataframe pandas com esses dados. Você pode notar muita semelhança com o tipo de dados dicionário do python.

>>> pessoas = pd.read_json(encoded)
>>> pessoas
      nome  aniversario
0    Diana         1998
1  Fabiana         1991
2  Eveline         1995

Quando trabalhamos com dados JSON precisamos ter a certeza que esses dados estão no formato certo para que a biblioteca pandas possa carregá-lo corretamente. A biblioteca pandas tem suporte aos dados JSON nas seguintes orientações:

• columns - (padrão) um mapeamento de nomes de colunas para uma lista de valores nas colunas.
• records - uma lista de linhas. Cada linha é um dicionário que mapeia uma coluna para um valor.
• split - Um mapeamento de columns para nomes de colunas, index para valores de índice e dados para uma lista de cada linha de dados (cada linha também é uma lista).
• index - Um mapeamento do valor do index para uma linha. Uma linha é um dicionário que mapeia uma coluna para um valor.
• values - uma lista de cada linha de dados (cada linha também é uma lista). Não inclui valores de coluna ou índice.
• table - Um mapeamento de schema para o esquema DataFrame e dados para uma lista de dicionários.

Veja exemplos com diferentes orientações:

>>> records = pessoas.to_json(orient='records')
>>> records
'[{"nome":"Diana","aniversario":1998},{"nome":"Fabiana","aniversario":1991},{"nome":"Eveline","aniversario":1995}]'
>>> pd.read_json(records, orient='records')
      nome  aniversario
0    Diana         1998
1  Fabiana         1991
2  Eveline         1995

>>> split = pessoas.to_json(orient='split')
>>> split
'{"columns":["nome","aniversario"],"index":[0,1,2],"data":[["Diana",1998],["Fabiana",1991],["Eveline",1995]]}'
>>> pd.read_json(split, orient='split')
      nome  aniversario
0    Diana         1998
1  Fabiana         1991
2  Eveline         1995

O método loads() retorna um dicionário, por isso podemos ler os dados de apenas uma colunas.

>>> pessoas = json.loads(dados)
>>> type(pessoas)
<class 'dict'>
>>> pessoas['nome']
['Diana', 'Fabiana', 'Eveline']

Em algumas situações, pode ser mais fácil trabalhar com dicionários do que com JSON.

Referência:
Módulo JSON
Método read_json()
Método to_json()

Anterior Próximo

Read More