Pandas: Poderoso Kit de Ferramentas de Análise de Dados Python

Machine Translated by Google
pandas: poderoso kit de ferramentas de análise de

dados Python
Versão 1.4.4
Wes McKinney e a equipe de desenvolvimento do Pandas
31 de agosto de 2022
CONTEÚDO
1 Introdução 1.1 3
Instalação 1.2 . . . . . . . . .
. . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3
Introdução ao pandas . . . . . . .
. . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3
1.3 Vindo de. . . . . . . . .
. . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 5
1.4 Tutoriais . . . . . . . . . .
. . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 5
1.4.1 Instalação . . . .
. . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 6
1.4.2 Visão geral do pacote . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 12
1.4.3 Tutoriais de introdução 1.4.4 . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 15
Comparação com outras ferramentas ... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 61
1.4.5 Tutoriais da comunidade . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 147
2 Guia do 149
. . ...
usuário 2.1 10 minutos para pandas . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 149
2.1.1 Criação de objeto . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 149
2.1.2 Visualização de . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 151
dados 2.1.3 Seleção . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 153
2.1.4 Dados faltantes . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 158
2.1.5 Operações . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 159
2.1.6 Mesclar . . . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 161
2.1.7 Agrupamento . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 163
2.1.8 Remodelação . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 165
2.1.9 Séries . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 167
. . . ..
temporais 2.1.10 Categóricas . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 169
2.1.11 Plotagem . . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 171
2.1.12 Obtendo/retirando dados . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 173
2.1.13 Pegadinhas . . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 174
2.2 Introdução às estruturas de . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 174
dados 2.2.1 Série . . . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 175
2.2.2 DataFrame . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 180
2.3 Funcionalidades básicas essenciais . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 198
2.3.1 Cabeça e cauda . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 198
2.3.2 Atributos e dados subjacentes .. . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 199
2.3.3 Operações aceleradas . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 201
2.3.4 Operações binárias flexíveis . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 202
2.3.5 Estatísticas descritivas . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 211
2.3.6 Aplicação de funções . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 220
2.3.7 Reindexando e alterando rótulos . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 233
2.3.8 Iteração . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 243
2.3.9 Acessador .dt . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 247
2.3.10 Métodos de string vetorizados . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 251
eu
2.3.11 Classificação . . . . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 251
2.3.12 Cópia . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 259
2.3.13 dtipos . . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 259
2.3.14 Selecionando colunas com base em dtype . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 270
2.4 Ferramentas IO (texto, CSV, HDF5,...) . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 273
2.4.1 CSV e arquivos de texto . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 274
2.4.2 JSON . . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 313
2.4.3 HTML . . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 328
2.4.4 LaTeX . . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 337
2.4.5 XML . . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 338
2.4.6 Arquivos . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 350
Excel 2.4.7 Planilhas OpenDocument . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 357
2.4.8 Arquivos binários do Excel (.xlsb) ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 357
2.4.9 Área de transferência .. . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 358
2.4.10 Decapagem . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 359
2.4.11 pacote de mensagens . .. . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 362
2.4.12 HDF5 (PyTables) . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 362
2.4.13 Penas . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 390
2.4.14 Parquet . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 392
2.4.15 ORC . . . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 395
2.4.16 Consultas SQL . . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 395
2.4.17Google BigQuery . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 403
2.4.18 Formato Stata . . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 404
2.4.19 Formatos SAS . . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 406
2.4.20 Formatos SPSS . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 407
2.4.21 Outros formatos de arquivo . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 407
2.4.22 Considerações de desempenho. . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 407
2.5 Indexação e seleção de dados . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 411
2.5.1 Diferentes opções de indexação . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 412
2.5.2 Noções . . . . . . . . . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 412
básicas 2.5.3 Acesso a atributos . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 415
2.5.4 Segmentação de intervalos . . . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 417
2.5.5 Seleção por etiqueta . . . . . . . . . . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 418
2.5.6 Seleção por posição . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 423
2.5.7 Seleção por chamada . . ..... . . . .
. . . . . . . . . . ... . . . . . . . . . . . . . . 427
2.5.8 Combinando indexação posicional e baseada em rótulo .. . . . . . ... . . . . . . . . . . . . . . 428
2.5.9 A indexação com lista sem rótulos está obsoleta . . . . . ... . . . . . . . . . . . . . . 429
2.5.10 Seleção de amostras aleatórias . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 431
2.5.11 Configuração com ampliação . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 433
2.5.12 Obtenção e configuração rápida de valores escalares . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 435
2.5.13 Indexação booleana . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 435
2.5.14 Indexação com isin . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 438
2.5.15 O método where() e mascaramento . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 440
2.5.16 Configuração com ampliação condicionalmente usando numpy() . . . ... . . . . . . . . . . . . . . 444
2.5.17 O método query() 2.5.18 . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 445
Dados duplicados 2.5.19 . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 457
Método get() semelhante a um dicionário . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 460
2.5.20 Procurando valores por rótulos de índice/coluna . . . . . . . . . . ... . . . . . . . . . . . . . . 460
2.5.21 Objetos de índice . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 460
2.5.22 Definir/redefinir índice . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 464
2.5.23 Retornando uma visualização versus uma cópia . . . . . . . . . . . . .
. . . ... . . . . . . . . . . . . . . 466
2.6 MultiIndex/indexação avançada . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 470
2.6.1 Indexação hierárquica (MultiIndex) . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 470
2.6.2 Indexação avançada com índice hierárquico . . . . . . . . . . ... . . . . . . . . . . . . . . 477
eu
2.6.3 Classificando um MultiIndex . . . . . . . . . . . . . . . .

..... . . . . . . . . . . . . . . . . 489
2.6.4 Métodos 2.6.5 . . . . . . ..... . . . . . . . . . .
... . . . . . . . . . . . . . . . . . . 492
Tipos de índice . . . . . . . ..... . . . . . . . . . .
... . . . . . . . . . . . . . . . . . . 494
2.6.6 Perguntas freqüentes sobre indexação diversa . . . . . . . . . . . . .
... . . . . . . . . . . . . . . . . . . 503
2.7 Mesclar, juntar, concatenar e comparar . . . . . . . . . . . . .
... . . . . . . . . . . . . . . . . . . 508
2.7.1 Concatenando objetos . . ..... . . . . . . . . . .
... . . . . . . . . . . . . . . . . . . 508
2.7.2 DataFrame estilo banco de dados ou junção/mesclagem de séries nomeadas . . . . . . . . . . . . . . . . . 518
2.7.3 Fusão amigável de séries temporais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
2.7.4 Comparando objetos . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 541
2.8 Remodelando e tabelas . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 543
dinâmicas 2.8.1 Remodelando girando objetos DataFrame . .. . . . . . . . . . . . . . . . . . . . . . . . . 543
2.8.2 Remodelação empilhando e desempilhando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
2.8.3 Remodelando por . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 555
fusão 2.8.4 Combinando com stats e GroupBy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
2.8.5 Tabelas . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 558
dinâmicas 2.8.6 Tabulações . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 563
. . .. . . . . . . . . . . .
cruzadas 2.8.7 Ladrilhos . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 565
2.8.8 Calculando indicadores/variáveis dummies . . . . . . . . . . . ... . . . . . . . . . . . . . . 566
2.8.9 Fatoração de valores . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 569
2.8.10 Exemplos . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 571
2.8.11 Explodindo uma coluna semelhante a ... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 574
uma lista 2.9 Trabalhando com . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 576
dados de texto 2.9.1 Tipos de . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 576
dados de texto . 2.9.2 . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 579
Métodos de strings 2.9.3 Dividindo e substituindo strings. . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
2.9.4 Concatenação . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 585
2.9.5 Indexando com .str . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 591
2.9.6 Extraindo substrings . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 591
2.9.7 Testando strings que correspondem ou contêm um padrão . . . . . . . . . . . . . . . . . . . . . . . 595
2.9.8 Criação de variáveis indicadoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
2.9.9 Resumo do método . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 598
2.10 Trabalhando com dados . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 599
faltantes 2.10.1 Valores considerados “missos” .. .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
2.10.2 Inserindo dados faltantes . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 602
2.10.3 Cálculos com dados faltantes .. . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 603
2.10.4 Soma/produção de vazios/nans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
2.10.5 Valores NA em GroupBy . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 605
2.10.6 Preenchendo valores ausentes: ... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 606
fillna 2.10.7 Preenchendo com um PandasObject . . .. .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
2.10.8 Eliminando rótulos de eixos com dados ausentes: dropna . . . . . . . . . . . . . . . . . . . . . . . . 609
2.10.9 Interpolação . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 609
2.10.10 Substituindo valores genéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
2.10.11 Substituição de string/expressão regular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
2.10.12 Substituição numérica . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 622
2.10.13 Escalar NA experimental para denotar valores faltantes . . . . . . . . . . . . . . . . . . . . . . . . 625
2.11 Rótulos duplicados . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 629
2.11.1 Consequências de rótulos duplicados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630
2.11.2 Detecção de rótulos .... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 632
duplicados 2.11.3 Proibindo rótulos . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 633
duplicados 2.12 Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 637
categóricos 2.12.1 . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 638
. . .
Criação de objeto 2.12.2 CategoricalDtype . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 643
2.12.3 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 644
2.12.4 Trabalhando com categorias . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 645
iii
2.12.5 Classificação e . .
. . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 649
ordem 2.12.6 Comparações .. . .
. . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 652
2.12.7 Operações . . . . . .
. . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 655
2.12.8 Gerenciamento de dados . . . .
. . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 657
2.12.9 Obtendo/retirando dados . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 665
2.12.10 Dados . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 666
faltantes 2.12.11 Diferenças no fator . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 667
R 2.12.12 Pegadinhas. .. . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 667
2.13 Tipo de dados inteiro anulável . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 671
2.13.1 Construção . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 672
2.13.2 Operações . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 673
2.13.3 Valor Escalar NA . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 675
2.14 Tipo de dados booleano anulável . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 675
2.14.1 Indexação com valores NA . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 675
2.14.2 Operações lógicas de Kleene . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 676
2.15 Visualização de Gráfico . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 677
2.15.1 Plotagem básica: plotagem . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 678
2.15.2 Outras parcelas . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 680
2.15.3 Plotagem com dados faltantes 2.15.4 . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 714
Ferramentas de plotagem . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 715
2.15.5 Formatação de plotagem . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 723
2.15.6 Plotando diretamente com matplotlib . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 749
2.15.7 Plotando backends . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 750
2.16 Visualização de Tabela . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 751
2.16.1 Objeto Styler e HTML 2.16.2 . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 751
Formatando o Display . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 752
2.16.3 Métodos para adicionar estilos . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 753
2.16.4 Estilos de Tabela . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 754
2.16.5 Configurando Classes e Vinculando a CSS Externo . . . . . . . . ... . . . . . . . . . . . . . . 755
2.16.6 Funções do Styler . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 756
2.16.7 Dicas de ferramentas e legendas. . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 757
2.16.8 Controle mais preciso com fatiamento . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 758
2.16.9 Otimização . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 759
2.16.10 Estilos integrados . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 762
2.16.11 Compartilhando estilos . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 764
2.16.12 Limitações . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 765
2.16.13 Outras coisas úteis e divertidas . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 765
2.16.14 Exportar para . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 767
Excel 2.16.15 Exportar . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 768
para LaTeX 2.16.16 Mais sobre CSS e . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 768
HTML 2.16.17 Extensibilidade . . . .. . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 770
2.17 Ferramentas . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 772
. . . .....
computacionais 2.17.1 Funções estatísticas . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 772
2.18 Agrupar por: dividir-aplicar-combinar . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 777
2.18.1 Dividindo um objeto em grupos . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 778
2.18.2 Iterando através de grupos . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 787
2.18.3 Selecionando um grupo . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 788
2.18.4 Agregação . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 788
2.18.5 Transformação . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 796
2.18.6 Filtração . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 803
2.18.7 Despachando para métodos de . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 804
.
instância 2.18.8 Aplicação flexível . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 806
2.18.9 Rotinas aceleradas Numba ... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 808
2.18.10 Outros recursos úteis . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 808
4
2.18.11 Exemplos . . . . . . . . .....

. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 820
2.19 Operações de janelas . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 822
2.19.1 Visão Geral . . . . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 823
2.19.2 Janela rolante . . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 827
2.19.3 Janela ponderada . . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 835
2.19.4 Janela de expansão . . . .....
. . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 836
2.19.5 Janela ponderada exponencialmente . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 837
2.20 Funcionalidade de série temporal/data . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 839
2.20.1 Visão Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 841
2.20.2 Carimbos de data e hora versus intervalos de tempo . . . . .
. . . . . . . . . . . . . ... . . . . . . . . . . . . . . 842
2.20.3 Convertendo para carimbos de data e hora . . . . . .
. . . . . . . . . . . . . ... . . . . . . . . . . . . . . 844
2.20.4 Gerando intervalos de timestamps . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 848
2.20.5 Limitações de carimbo de data/ . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 851
hora 2.20.6 Indexação . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 852
2.20.7 Componentes de hora/data . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 861
2.20.8 Objetos DateOffset . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 862
2.20.9 Métodos de instância relacionados a séries . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 878
temporais 2.20.10 Reamostragem. . .. . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 880
2.20.11 Representação do intervalo de tempo . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 891
2.20.12 Conversão entre representações . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 898
2.20.13 Representando vãos fora dos limites . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 899
2.20.14 Tratamento de fuso horário . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 900
2.21 Deltas de tempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 909
2.21.1 Análise . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 909
2.21.2 Operações . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 911
2.21.3 Reduções . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 915
2.21.4 Conversão de frequência . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 916
2.21.5 Atributos . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 918
2.21.6 TimedeltaIndex . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 920
2.21.7 Reamostragem . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 924
2.22 Opções e configurações . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 924
2.22.1 Visão Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 924
2.22.2 Opções disponíveis . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 926
2.22.3 Obtendo e configurando opções . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 933
2.22.4 Configurando opções de inicialização em ambiente Python/IPython . . . ... . . . . . . . . . . . . . . 934
2.22.5 Opções usadas com frequência . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 934
2.22.6 Formatação de números . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 941
2.22.7 Formatação Unicode . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 942
2.22.8 Exibição do esquema da tabela . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 943
2.23 Melhorando o desempenho . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 943
2.23.1 Cython (escrevendo extensões C para pandas) . . . . . . . . . . ... . . . . . . . . . . . . . . 944
2.23.2 Numba (compilação JIT) . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 949
2.23.3 Avaliação de expressões via eval() . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 951
2.24 Escalando para grandes conjuntos . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 960
de dados 2.24.1 Carregar . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 960
. . .. . .
menos dados 2.24.2 Usar tipos de dados eficientes . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 962
2.24.3 Usar agrupamento . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 963
2.24.4 Use outras bibliotecas . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 965
2.25 Estruturas de dados . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 969
esparsas 2.25.1 SparseArray . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 971
2.25.2 SparseDtype . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 971
2.25.3 Acessador esparso . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 972
2.25.4 Cálculo esparso . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 972
2.25.5 Migrando . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 973
v
2.25.6 Interação com scipy.sparse . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 975

2.26 Perguntas Frequentes (FAQ) . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 978
2.26.1 Uso de memória DataFrame . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 978
2.26.2 Usando declarações if/truth com pandas . . . . . . . . . . . . ... . . . . . . . . . . . . . . 981
2.26.3 Mutação com métodos de Função Definida pelo Usuário . . . . ... . . . . . . . . . . . . . . 983
(UDF) 2.26.4 NaN, valores NA inteiros e promoções de tipo NA .. . . . . . ... . . . . . . . . . . . . . . 984
2.26.5 Diferenças com NumPy . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 987
2.26.6 Segurança de thread . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 987
2.26.7 Problemas de ordenação de . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 987
bytes 2.27 Livro de receitas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 987
2.27.1 Idiomas . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 988
2.27.2 Seleção . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 992
2.27.3 Multiindexação . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 996
2.27.4 Dados faltantes . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1000
2.27.5 Agrupamento . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1001
2.27.6 Séries . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1014
Temporais 2.27.7 Mesclar . . . .. . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1014
2.27.8 Plotagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1016
2.27.9 Entrada/saída de dados . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1017
2.27.10 Computação . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1023
2.27.11 Timedeltas . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1024
2.27.12 Criando dados de exemplo . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1026
3 Referência da 1027
API 3.1 Entrada/saída . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1027
3.1.1 Decapagem . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1027
3.1.2 Arquivo simples . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1030
3.1.3 Área de transferência . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1044
3.1.4 Excel . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1046
3.1.5 JSON . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1058
3.1.6 HTML . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1069
3.1.7 XML . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1074
3.1.8 Latex . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1081
3.1.9 HDFStore: PyTables (HDF5) . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1091
3.1.10 Penas . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1096
3.1.11 Parquet . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1097
3.1.12 ORC . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1099
3.1.13 SAS . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1100
3.1.14 SPSS . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1101
3.1.15 SQL . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1101
3.1.16 GoogleBigQuery . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1108
3.1.17 ESTADOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1110
3.2 Funções gerais 3.2.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1115
Manipulações de dados . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1115
3.2.2 Dados faltantes de nível superior . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1151
3.2.3 Tratamento de nível superior com dados numéricos . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1157
3.2.4 Tratamento de nível superior com dados semelhantes a . . . . . . . . . . . ... . . . . . . . . . . . . . . 1159
data e hora 3.2.5 Tratamento de nível superior com dados . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1172
. ..
de intervalo 3.2.6 Avaliação de nível superior ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1174
3.2.7 Hashing . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1176
3.2.8 Testes . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1177
3.3 Série . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1177
3.3.1 Construtor . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1177
3.3.2 Atributos . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1444
vi
3.3.3 Conversão . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1446

3.3.4 Indexação, iteração . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1447
3.3.5 Funções de operadores ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1449
binários 3.3.6 Aplicação de funções, GroupBy e janela .. . . . . . . . . ... . . . . . . . . . . . . . . 1450
3.3.7 Cálculos/estatísticas descritivas . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1450
3.3.8 Reindexação/seleção/manipulação de rótulos . . . . . . . . . . ... . . . . . . . . . . . . . . 1452
3.3.9 Tratamento de dados faltantes . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1453
3.3.10 Remodelação, classificação . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1453
3.3.11 Combinar/comparar/juntar/mesclar . . . . . . . . . ... . . . . . . . . . . . . . . 1453
3.3.12 Relacionado a séries temporais . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1454
3.3.13 Acessadores . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1454
3.3.14 Plotagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1572
3.3.15 Serialização/IO/conversão . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1621
3.4 DataFrame . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1621
3.4.1 Construtor . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1621
3.4.2 Atributos e dados subjacentes .. . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1964
3.4.3 Conversão . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1964
3.4.5 Funções de operadores ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1966
binários 3.4.6 Função aplicação, GroupBy & window . . . . . . . . . . ... . . . . . . . . . . . . . . 1967
3.4.8 Reindexação/seleção/manipulação de rótulos . . . . . . . . . . ... . . . . . . . . . . . . . . 1969
3.4.9 Tratamento de dados faltantes . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1970
3.4.10 Remodelar, classificar, transpor . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1970
3.4.11 Combinar/comparar/juntar/mesclar . . . . . . . . . ... . . . . . . . . . . . . . . 1971
3.4.12 Relacionado a séries temporais . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1971
3.4.13 Sinalizadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1971
3.4.14 Metadados . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1972
3.4.15 Plotagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1972
3.4.16 Acessador esparso . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2026
3.4.17 Serialização/E/S/conversão . . 3.5 . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2028
arrays, escalares e tipos de dados do pandas . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2028
3.5.1 pandas.array . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2029
3.5.2 Dados de data e . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2032
hora 3.5.3 Dados de . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2065
timedelta 3.5.4 Dados de . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2075
intervalo de . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2075
tempo 3.5.5 Período . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2093
. . . anulável
3.5.6 Dados de intervalo 3.5.7 Inteiro . . . . . .. . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2107
3.5.8 Dados categóricos . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2112
3.5.9 Dados esparsos . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2118
3.5.10 Dados de . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2120
texto 3.5.11 Dados booleanos com valores faltantes. .. . . . . . . . . . . . ... . . . . . . . . . . . . . . 2123
3.6 Indexar objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2125
3.6.1 Índice . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2125
3.6.2 Índice Numérico 3.6.3 . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2193
Índice Categórico . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2197
3.6.4 IntervalIndex . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2207
3.6.5 MultiIndex . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2219
3.6.6 DatetimeIndex . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2239
3.6.7 TimedeltaIndex . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2274
3.6.8 PeriodIndex . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2284
3.7 Deslocamentos de data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2292
3.7.1 Deslocamento de Data . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2292
vii
3.7.2 Dia Útil . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2298

3.7.3 BusinessHour . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2305
3.7.4 CustomBusinessDay . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2311
3.7.5 CustomBusinessHour . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2318
3.7.6 MonthEnd . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2324
3.7.7 MonthBegin . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2329
3.7.8 BusinessMonthEnd . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2334
3.7.9 BusinessMonthBegin . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2340
3.7.10 CustomBusinessMonthEnd . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2345
3.7.11 CustomBusinessMonthBegin . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2352
3.7.12 Fim do Semimês . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2359
3.7.13 SemiMonthBegin . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2364
3.7.14 Semana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2370
3.7.15 WeekOfMonth . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2375
3.7.16 LastWeekOfMonth . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2381
3.7.17 BQuarterEnd . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2387
3.7.18 BQuarterBegin . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2393
3.7.19 Fim do Trimestre . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2399
3.7.20 QuarterBegin . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2404
3.7.21 BYearEnd . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2410
3.7.22 BYearBegin . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2416
3.7.23 Fim de Ano . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2421
3.7.24 Início de Ano . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2426
3.7.25 EF5253 . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2431
3.7.26 Trimestre FY5253 . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2438
3.7.27 Páscoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2445
3.7.28 Assinale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2451
3.7.29 Dia . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2456
3.7.30 Hora . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2462
3.7.31 Minuto . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2467
3.7.32 Segundo . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2473
3.7.33 Mili . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2478
3.7.34 Micro . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2484
3.7.35 Nano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2489
3.8 Frequências . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2495
3.8.1 pandas.tseries.frequencies.to_offset . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2495
3.9 Janela . . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2496
3.9.1 Funções de janela rolante . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2496
3.9.2 Funções de janela ponderada . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2514
3.9.3 Funções de janela de expansão . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2516
3.9.4 Funções de janela com peso exponencial . . . . . . . . . . ... . . . . . . . . . . . . . . 2530
3.9.5 Indexador de . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2534
janela 3.10 GroupBy . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2537
3.10.2 Aplicação de função . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2542
3.11 Reamostragem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2610
3.11.2 Aplicação de função . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2613
3.11.3 Aumento da resolução . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2618
3.12 Estilo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2636
3.12.1 Construtor do Styler . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2636
3.12.2 Propriedades do Styler . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2679
viii
3.12.3 Aplicação de estilo . . . . ..... . .

. . . . . . . . . . . . ... . . . . . . . . . . . . . . 2680
3.12.4 Estilos integrados . . . . . . ..... . .
. . . . . . . . . . . . ... . . . . . . . . . . . . . . 2681
3.12.5 Exportação e importação de estilos . . . . . . . .
. . . . . . . . . . . . ... . . . . . . . . . . . . . . 2681
3.13 Plotagem . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . ... . . . . . . . . . . . . . . 2681
3.13.1 pandas.plotting.andrews_curves . . .
. . . . . . . . . . . . ... . . . . . . . . . . . . . . 2682
3.13.2 pandas.plotting.autocorrelation_plot . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2682
3.13.3 pandas.plotting.bootstrap_plot . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2684
3.13.4 pandas.plotting.boxplot . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2686
3.13.5 pandas.plotting.deregister_matplotlib_converters . . . . . . ... . . . . . . . . . . . . . . 2692
3.13.6 pandas.plotting.lag_plot . . . . . 3.13.7 . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2692
pandas.plotting.parallel_coordinates . 3.13.8 . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2695
pandas.plotting.plot_params . . . 3.13.9 . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2695
pandas.plotting.radviz . 3.13.10 . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2697
pandas.plotting.register_matplotlib_converters . 3.13.11 . . . . . . . ... . . . . . . . . . . . . . . 2698
pandas.plotting.scatter_matrix . . 3.13.12 . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2699
pandas.plotting.table . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2701
3.14 Funções utilitárias gerais . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2701
3.14.1 Trabalhando com opções . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2701
3.14.2 Testando funções . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2720
3.14.3 Exceções e avisos . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2725
3.14.4 Funcionalidade relacionada aos tipos de dados . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2730
3.14.5 Função de relatório de . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2758
bug 3.15 Extensões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2759
3.15.1 pandas.api.extensions.register_extension_dtype . . . . . . . ... . . . . . . . . . . . . . . 2759
3.15.2 pandas.api.extensions.register_dataframe_accessor . . . . . ... . . . . . . . . . . . . . . 2759
3.15.3 pandas.api.extensions.register_series_accessor . . . . . . . . ... . . . . . . . . . . . . . . 2761
3.15.4 pandas.api.extensions.register_index_accessor . . . . . . . . ... . . . . . . . . . . . . . . 2762
3.15.5 pandas.api.extensions.ExtensionDtype . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2763
3.15.6 pandas.api.extensions.ExtensionArray . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2767
3.15.7 pandas.arrays.PandasArray . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2781
3.15.8 pandas.api.indexers.check_array_indexer . . . . . . . . . . . ... . . . . . . . . . . . . . . 2781
4 Desenvolvimento 2785
4.1 Contribuindo para os pandas . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2785
4.1.1 Por onde começar? . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2786
4.1.2 Relatórios de bugs e solicitações de melhorias . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2786
4.1.3 Trabalhando com o código . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2787
4.1.4 Contribuindo com suas alterações no pandas . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2788
4.1.5 Dicas para uma solicitação pull bem-sucedida . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2791
4.2 Criando um ambiente de desenvolvimento . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2791
4.2.1 Criando um ambiente usando Docker 4.2.2 . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2791
Criando um ambiente sem Docker 4.3 Contribuindo . . . . . . . . . . . ... . . . . . . . . . . . . . . 2792
para a documentação ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2795
4.3.1 Sobre a documentação do pandas . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2796
4.3.2 Atualizando uma docstring do pandas . . . . . . .. . . . . . . . . . ... . . . . . . . . . . . . . . 2813
4.3.3 Como construir a documentação do pandas . . . . . . . . . . . ... . . . . . . . . . . . . . . 2813
4.3.4 Pré-visualizando alterações . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2814
4.4 Contribuindo para a base de código . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2815
4.4.1 Padrões de código . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2815
4.4.2 Pré-comprometimento . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2816
4.4.3 Dependências opcionais . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2816
4.4.4 Dicas de tipo . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2820
4.4.5 Teste com integração contínua . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2822
4.4.6 Desenvolvimento orientado a testes/escrita de código . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2823
ix
4.4.7 Executando o conjunto de . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2827

testes 4.4.8 Executando o conjunto de testes de . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2828
desempenho 4.4.9 Documentando seu código . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2829
Guia de estilo de código do pandas 4.5 . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2829
4.5.1 Padrões . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2830
4.5.2 Testes . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2830
4.5.3 Diversos 4.6 . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2830
Manutenção do pandas . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2831
4.6.1 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2831
4.6.2 Tarefas . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2831
4.6.3 Triagem de problemas . . .. . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2831
4.6.4 Encerramento de . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2832
questões 4.6.5 Revisando pull requests .. . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2833
4.6.6 Backport . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2833
4.6.7 Limpando problemas . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2833
antigos 4.6.8 Limpando solicitações pull antigas. . .. .. . . . . . . . . . . . ... . . . . . . . . . . . . . . 2833
4.6.9 Tornando-se um mantenedor do .. . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2834
pandas 4.6.10 Mesclando pull requests . . .. . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2834
4.7 Internos . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2834
4.7.1 Indexação . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2834
4.7.2 Subclassificando estruturas de dados do . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2836
pandas 4.8 Organização de testes. .. . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2836
4.9 Depurando extensões C . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2839
4.9.1 Usando um depurador . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2839
4.9.2 Verificando vazamentos de memória com valgrind . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2840
4.10 Estendendo pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2840
4.10.1 Registrando acessadores ... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2840
. . . . .. . . . .
customizados 4.10.2 Tipos de extensão . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2841
4.10.3 Subclassificando estruturas de dados do . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2844
pandas 4.10.4 Plotando back- . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2847
. .. . . . . . . . . . . . . . . .
ends 4.11 Desenvolvedor . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2848
4.11.1 Armazenando objetos DataFrame do pandas no formato Apache ... . . . . . . . . . . . . . . 2848
.. . . . . . . . . . . . . .....
Parquet 4.12 Políticas . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2851
4.12.1 Política de versão . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2851
4.12.2 Suporte Python . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2851
4.13 Roteiro . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2851
4.13.1 Extensibilidade . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2852
4.13.2 Tipo de dados String . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2852
4.13.3 Tratamento consistente de valores faltantes . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2852
4.13.4 Interoperabilidade do Apache Arrow . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2852
4.13.5 Reescrita do gerenciador de blocos . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2853
4.13.6 Desacoplação de indexação e internos . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2853
4.13.7 Operações aceleradas pelo Numba . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2853
4.13.8 Monitoramento de desempenho . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2853
4.13.9 Evolução do roteiro . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2854
4.13.10 Itens concluídos . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2854
4.14 Reuniões de desenvolvedores. .. . . . . . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2854
4.14.1 Minutos . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2855
4.14.2 Calendário . . . . . . . . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2855
5 Notas de versão 2857

5.1 Versão 1.4 . . . . . . . . . . . . ...... . . . . . . . . . . . . . ..... . . . . . . . . . . . . 2857
5.1.1 Novidades em 1.4.4 (31 de agosto de 2022) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2857
5.1.2 Novidades em 1.4.3 (23 de junho de 2022) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2859
x
5.1.3 Novidades em 1.4.2 (2 de abril de 2022) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2861

5.1.4 Novidades em 1.4.1 (12 de fevereiro de 2022) . . . . . . . . . . . ... . . . . . . . . . . . . . . 2862
5.1.5 Novidades na versão 1.4.0 (22 de janeiro de 2022) . . . . . . . . . . . ... . . . . . . . . . . . . . . 2864
5.2 Versão 1.3 . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2899
5.2.1 Novidades em 1.3.5 (12 de dezembro de 2021) . . . . . . . . . . ... . . . . . . . . . . . . . . 2899
5.2.2 Novidades em 1.3.4 (17 de outubro de 2021) . . . . . . . . . . . ... . . . . . . . . . . . . . . 2900
5.2.3 Novidades em 1.3.3 (12 de setembro de 2021) . . . . . . . . . . ... . . . . . . . . . . . . . . 2901
5.2.4 Novidades em 1.3.2 (15 de agosto de 2021) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2903
5.2.5 Novidades em 1.3.1 (25 de julho de 2021) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2904
5.2.6 Novidades da versão 1.3.0 (2 de julho de 2021) . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2906
5.3 Versão 1.2 . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2945
5.3.1 Novidades em 1.2.5 (22 de junho de 2021) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2945
5.3.2 Novidades em 1.2.4 (12 de abril de 2021) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2946
5.3.3 Novidades em 1.2.3 (02 de março de 2021) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2947
5.3.4 Novidades em 1.2.2 (09 de fevereiro de 2021) . . . . . . . . . . . ... . . . . . . . . . . . . . . 2948
5.3.5 Novidades em 1.2.1 (20 de janeiro de 2021) . . . . . . . . . . . ... . . . . . . . . . . . . . . 2950
5.3.6 Novidades na versão 1.2.0 (26 de dezembro de 2020) . . . . . . . . . . ... . . . . . . . . . . . . . . 2953
5.4 Versão 1.1 . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2982
5.4.1 Novidades em 1.1.5 (07 de dezembro de 2020) . . . . . . . . . . ... . . . . . . . . . . . . . . 2982
5.4.2 Novidades em 1.1.4 (30 de outubro de 2020) . . . . . . . . . . . ... . . . . . . . . . . . . . . 2984
5.4.3 Novidades na versão 1.1.3 (5 de outubro de 2020) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2986
5.4.4 Novidades na versão 1.1.2 (8 de setembro de 2020) . . . . . . . . . . ... . . . . . . . . . . . . . . 2988
5.4.5 Novidades em 1.1.1 (20 de agosto de 2020) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2990
5.4.6 Novidades na versão 1.1.0 (28 de julho de 2020) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2992
5.5 Versão 1.0 . . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 3034
5.5.1 Novidades da versão 1.0.5 (17 de junho de 2020) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3034
5.5.2 Novidades da versão 1.0.4 (28 de maio de 2020) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3035
5.5.3 Novidades na versão 1.0.3 (17 de março de 2020) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3036
5.5.4 Novidades na versão 1.0.2 (12 de março de 2020) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3037
5.5.5 Novidades na versão 1.0.1 (5 de fevereiro de 2020) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3040
5.5.6 Novidades da versão 1.0.0 (29 de janeiro de 2020) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3042
5.6 Versão 0.25 . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 3081
5.6.1 Novidades da versão 0.25.3 (31 de outubro de 2019) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3081
5.6.2 Novidades da versão 0.25.2 (15 de outubro de 2019) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3082
5.6.3 Novidades da versão 0.25.1 (21 de agosto de 2019) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3083
5.6.4 Novidades da versão 0.25.0 (18 de julho de 2019) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3086
5.7 Versão 0.24 . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 3124
5.7.1 Novidades da versão 0.24.2 (12 de março de 2019) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3124
5.7.2 Novidades da versão 0.24.1 (3 de fevereiro de 2019) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3127
5.7.3 Novidades da versão 0.24.0 (25 de janeiro de 2019) . . . . . . . . . . . ... . . . . . . . . . . . . . . 3128
5.8 Versão 0.23 . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 3185
5.8.1 Novidades da versão 0.23.4 (3 de agosto de 2018) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3185
5.8.4 Novidades da versão 0.23.1 (12 de junho de 2018) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3190
5.8.5 Novidades da versão 0.23.0 (15 de maio de 2018) . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3194
5.9 Versão 0.22 . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 3245
5.9.1 Versão 0.22.0 (29 de dezembro de 2017) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3245
5.10 Versão 0.21 . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 3249
5.10.1 Versão 0.21.1 (12 de dezembro de 2017) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3249
5.10.2 Versão 0.21.0 (27 de outubro de 2017) . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3254
5.11 Versão 0.20 . . . . . . . . . . . ..... . . . . . . . . . . . . . . ..... . . . . . . . . . . . . 3287
5.11.1 Versão 0.20.3 (7 de julho de 2017) . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3287
5.11.2 Versão 0.20.2 (4 de junho de 2017) . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 3290
XI
5.11.3 Versão 0.20.1 (5 de maio de 2017) . . . . . . . . . . . .

... .. . . . . . . . . . . . . . . . . . 3294
5.12 Versão 0.19 . . . . . . . . . . . ..... . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3343
5.12.1 Versão 0.19.2 (24 de dezembro de 2016) . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3343
5.12.2 Versão 0.19.1 (3 de novembro de 2016) . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3346
5.12.3 Versão 0.19.0 (2 de outubro de 2016) . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3349
5.13 Versão 0.18 . . . . . . . . . . . ..... . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3395
5.13.1 Versão 0.18.1 (3 de maio de 2016) . . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3395
5.13.2 Versão 0.18.0 (13 de março de 2016) . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3415
5.14 Versão 0.17 . . . . . . . . . . . ..... . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3451
5.14.1 Versão 0.17.1 (21 de novembro de 2015) . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3451
... .. . . . . . . . . . . . . . . . . . 3459
5.15 Versão 0.16 . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3489
5.15.1 Versão 0.16.2 (12 de junho de 2015) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3489
5.15.2 Versão 0.16.1 (11 de maio de 2015) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3495
5.15.3 Versão 0.16.0 (22 de março de 2015) . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3508
5.16 Versão 0.15 . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3526
... .. . . . . . . . . . . . . . . . . . 3526
... .. . . . . . . . . . . . . . . . . . 3533
5.16.3 Versão 0.15.0 (18 de outubro de 2014) . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3540
5.17 Versão 0.14 . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3573
5.17.1 Versão 0.14.1 (11 de julho de 2014) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3573
5.17.2 Versão 0.14.0 (31 de maio de 2014) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3580
5.18 Versão 0.13 . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3611
5.18.1 Versão 0.13.1 (3 de fevereiro de 2014) . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3611
5.18.2 Versão 0.13.0 (3 de janeiro de 2014) . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3623
5.19 Versão 0.12 . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3653
5.19.1 Versão 0.12.0 (24 de julho de 2013) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3653
5.20 Versão 0.11 . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3666
5.20.1 Versão 0.11.0 (22 de abril de 2013) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3666
5.21 Versão 0.10 . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3677
5.21.1 Versão 0.10.1 (22 de janeiro de 2013) . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3677
... .. . . . . . . . . . . . . . . . . . 3684
5.22 Versão 0.9 . . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3696
... .. . . . . . . . . . . . . . . . . . 3696
... .. . . . . . . . . . . . . . . . . . 3700
5.23 Versão 0.8 . . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3703
5.23.1 Versão 0.8.1 (22 de julho de 2012) . . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3703
5.23.2 Versão 0.8.0 (29 de junho de 2012) . . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3704
5.24 Versão 0.7 . . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3710
5.24.1 Versão 0.7.3 (12 de abril de 2012) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3710
5.24.2 Versão 0.7.2 (16 de março de 2012) . . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3713
5.24.3 Versão 0.7.1 (29 de fevereiro de 2012) . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3714
5.24.4 Versão 0.7.0 (9 de fevereiro de 2012) . . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3715
5.25 Versão 0.6 . . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3721
5.25.1 Versão 0.6.1 (13 de dezembro de 2011) . . . . . . . . .
... .. . . . . . . . . . . . . . . . . . 3721
... .. . . . . . . . . . . . . . . . . . 3722
5.26 Versão 0.5 . . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3724
... .. . . . . . . . . . . . . . . . . . 3724
5.27 Versão 0.4 . . . . . . . . . . . . ..... . . . . . . . . .
...... . . . . . . . . . . . . . . . . 3725
5.27.1 Versões 0.4.1 a 0.4.3 (25 de setembro a 9 de outubro de 2011) . . . . . . . . . . . . . . . . 3725
Bibliografia 3727
Índice do módulo Python 3729
xii
pandas: poderoso kit de ferramentas de análise de dados Python, versão 1.4.4
Data: 31 de agosto de 2022 Versão: 1.4.4
Baixe a documentação: Versão PDF | HTML compactado
Versões anteriores: a documentação das versões anteriores do pandas está disponível em pandas.pydata.org.
Links úteis: Instaladores binários | Repositório de Fontes | Questões e Idéias | Suporte para perguntas e respostas | Lista de discussão
pandas é uma biblioteca de código aberto licenciada por BSD que fornece estruturas de dados e ferramentas de análise de dados de alto desempenho e fáceis
de usar para a linguagem de programação Python .
Começando
Novo nos pandas? Confira os guias de primeiros passos. Eles contêm uma introdução aos principais conceitos do pandas e links para tutoriais adicionais.
Para os guias de primeiros passos
Guia de usuario
O guia do usuário fornece informações detalhadas sobre os principais conceitos dos pandas, com informações básicas e explicações úteis.
Para o guia do usuário
Referência da API
O guia de referência contém uma descrição detalhada da API do pandas. A referência descreve como os métodos funcionam e quais parâmetros podem ser
usados. Ele pressupõe que você tenha uma compreensão dos conceitos-chave.
Para o guia de referência
Guia do desenvolvedor
Viu um erro de digitação na documentação? Quer melhorar as funcionalidades existentes? As diretrizes de contribuição irão guiá-lo através do processo de
melhoria dos pandas.
Para o guia de desenvolvimento
CONTEÚDO 1
2 CONTEÚDO
CAPÍTULO
UM
COMEÇANDO
1.1 Instalação
Trabalhando com Conda?
pandas faz parte da distribuição Anaconda e pode ser instalado com Anaconda ou Miniconda:
conda instalar pandas
Prefere pip?
pandas pode ser instalado via pip do PyPI.
pip instalar pandas
Instruções detalhadas?
Instalando uma versão específica? Instalando a partir da fonte? Verifique a página de instalação avançada.
Saber mais
1.2 Introdução aos pandas
Direto para o tutorial. . .
Ao trabalhar com dados tabulares, como dados armazenados em planilhas ou bancos de dados, o pandas é a ferramenta certa para você.
pandas irá ajudá-lo a explorar, limpar e processar seus dados. No pandas, uma tabela de dados é chamada de DataFrame.
Para o tutorial de introdução
O pandas suporta a integração com muitos formatos de arquivo ou fontes de dados prontos para uso (csv, excel, sql, json, parquet,. . . ).
A importação de dados de cada uma dessas fontes de dados é fornecida pela função com o prefixo read_*. Da mesma forma, os métodos
to_* são usados para armazenar dados.
3
Selecionando ou filtrando linhas e/ou colunas específicas? Filtrando os dados em uma condição? Métodos para fatiar, selecionar e extrair os dados necessários
estão disponíveis no pandas.
O pandas fornece plotagem de seus dados prontos para uso, usando o poder do Matplotlib. Você pode escolher o tipo de gráfico (dispersão, barra, boxplot,...)
correspondente aos seus dados.
Não há necessidade de percorrer todas as linhas da sua tabela de dados para fazer cálculos. As manipulações de dados em uma coluna funcionam elemento
a elemento. Adicionar uma coluna a um DataFrame com base nos dados existentes em outras colunas é simples.
Estatísticas básicas (média, mediana, mínimo, máximo, contagens...) são facilmente calculáveis. Essas agregações ou agregações personalizadas podem ser
aplicadas em todo o conjunto de dados, em uma janela deslizante dos dados ou agrupadas por categorias. Esta última também é conhecida como abordagem
split-apply-combine.
Altere a estrutura da sua tabela de dados de várias maneiras. Você pode derreter() sua tabela de dados do formato largo para o formato longo/organizado ou
pivot() do formato longo para o formato largo. Com agregações integradas, uma tabela dinâmica é criada com um único comando.
Várias tabelas podem ser concatenadas tanto em colunas quanto em linhas, já que operações de junção/mesclagem semelhantes a bancos de dados são
fornecidas para combinar várias tabelas de dados.
pandas tem ótimo suporte para séries temporais e possui um extenso conjunto de ferramentas para trabalhar com datas, horas e dados indexados por tempo.
4 Capítulo 1. Primeiros passos

Os conjuntos de dados não contêm apenas dados numéricos. O pandas oferece uma ampla gama de funções para limpar dados textuais e extrair deles
informações úteis.
1.3 Vindo de. . .

Você está familiarizado com outros softwares para manipulação de dados tabulares? Aprenda as operações equivalentes ao pandas em comparação
com o software que você já conhece:
A linguagem de programação R fornece a estrutura de dados data.frame e vários pacotes, como tidyverse use e extend data.frame para funcionalidades
convenientes de manipulação de dados semelhantes às do pandas.
Saber mais
Já está familiarizado com SELECT, GROUP BY, JOIN, etc.? A maioria dessas manipulações SQL tem equivalentes em pandas.
Saber mais
O conjunto de dados incluído no pacote de software estatístico STATA corresponde ao DataFrame do pandas. Muitas das operações conhecidas do
STATA têm equivalente em pandas.
Saber mais
Os usuários do Excel ou de outros programas de planilha descobrirão que muitos dos conceitos podem ser transferidos para o pandas.
Saber mais
O conjunto de software estatístico SAS também fornece o conjunto de dados correspondente ao DataFrame do pandas. Além disso, operações
vetorizadas SAS, filtragem, operações de processamento de strings e muito mais têm funções semelhantes em pandas.
Saber mais
1.4 Tutoriais
Para uma rápida visão geral da funcionalidade do pandas, consulte 10 minutos para pandas.
Você também pode consultar a folha de dicas do pandas para obter um guia sucinto para manipular dados com pandas.
A comunidade produz uma grande variedade de tutoriais disponíveis online. Parte do material está listado nos tutoriais da comunidade contribuídos
pela comunidade.
1.3. Vindo de. . . 5

1.4.1 Instalação
A maneira mais fácil de instalar o pandas é instalá-lo como parte da distribuição Anaconda , uma distribuição multiplataforma para análise de
dados e computação científica. Este é o método de instalação recomendado para a maioria dos usuários.
Instruções para instalação a partir do código-fonte, PyPI, ActivePython, várias distribuições Linux ou uma versão de desenvolvimento também
são fornecidas.
Suporte à versão Python
Oficialmente Python 3.8, 3.9 e 3.10.
Instalando pandas
Instalando com Anaconda
Instalar o pandas e o resto da pilha NumPy e SciPy pode ser um pouco difícil para usuários inexperientes.
A maneira mais simples de instalar não apenas pandas, mas também Python e os pacotes mais populares que compõem a pilha SciPy (IPython,
NumPy, Matplotlib, . . . ) é com Anaconda, uma distribuição Python multiplataforma (Linux, macOS, Windows) para análise de dados e
computação científica.
Após executar o instalador, o usuário terá acesso ao pandas e ao restante da pilha do SciPy sem precisar instalar mais nada e sem precisar
esperar a compilação de nenhum software.
As instruções de instalação do Anaconda podem ser encontradas aqui.
Uma lista completa dos pacotes disponíveis como parte da distribuição Anaconda pode ser encontrada aqui.
Outra vantagem de instalar o Anaconda é que você não precisa de direitos de administrador para instalá-lo. O Anaconda pode ser instalado no
diretório inicial do usuário, o que torna trivial excluir o Anaconda se você decidir (basta excluir essa pasta).
Instalando com Miniconda
A seção anterior descreveu como instalar o pandas como parte da distribuição Anaconda . No entanto, esta abordagem significa que você
instalará bem mais de cem pacotes e envolve o download do instalador, que tem algumas centenas de megabytes de tamanho.
Se você deseja ter mais controle sobre quais pacotes ou tem largura de banda de internet limitada, instalar o pandas com Miniconda pode ser
uma solução melhor.
Conda é o gerenciador de pacotes sobre o qual a distribuição Anaconda é construída. É um gerenciador de pacotes que é independente de
plataforma cruzada e de linguagem (pode desempenhar uma função semelhante a uma combinação pip e virtualenv).
Miniconda permite que você crie uma instalação mínima independente do Python e, em seguida, use o comando Conda para instalar pacotes
adicionais.
Primeiro você precisará que o Conda esteja instalado e baixar e executar o Miniconda fará isso por você. O instalador pode ser encontrado aqui
A próxima etapa é criar um novo ambiente conda. Um ambiente conda é como um virtualenv que permite especificar uma versão específica do
Python e um conjunto de bibliotecas. Execute os seguintes comandos em uma janela de terminal:
conda criar -n nome_do_meu_env python
Isso criará um ambiente mínimo com apenas Python instalado. Para se colocar dentro deste ambiente execute:

fonte ativar nome_do_meu_env
No Windows o comando é:
ativar nome_do_meu_env
A etapa final necessária é instalar o pandas. Isso pode ser feito com o seguinte comando:
conda instalar pandas
Para instalar uma versão específica do pandas:
conda instalar pandas = 0.20.3
Para instalar outros pacotes, IPython por exemplo:
conda instalar ipython
Para instalar a distribuição completa do Anaconda :
conda instalar anaconda
Se você precisar de pacotes disponíveis para pip, mas não para conda, instale o pip e use o pip para instalar esses pacotes:
conda instalar pip pip

instalar django
Instalando a partir do PyPI
pandas pode ser instalado via pip do PyPI.
Nota: Você deve ter pip>=19.3 para instalar a partir do PyPI.
pip instalar pandas
Instalando com ActivePython
As instruções de instalação do ActivePython podem ser encontradas aqui. As versões 2.7, 3.5 e 3.6 incluem pandas.
Instalando usando o gerenciador de pacotes da sua distribuição Linux.
Os comandos nesta tabela instalarão o pandas para Python 3 da sua distribuição.
1.4. Tutoriais 7
Distribuição Status Link para download/ Método de instalação
repositório
Debian estábulo repositório oficial do Debian sudo apt-get install python3-pandas
Debian e instável NeuroDebian sudo apt-get install python3-pandas

Ubuntu (mais recente
pacotes)
Ubuntu estábulo repositório oficial do Ubuntu sudo apt-get install python3-pandas
Abrir- estábulo Repositório OpenSuse zypper em python3-pandas

Suse
Fedora estábulo repositório oficial do Fedora dnf instalar python3-pandas
estábulo Repositório EPEL yum instale python3-pandas

Centos/RHEL
No entanto, os pacotes nos gerenciadores de pacotes do Linux geralmente estão algumas versões atrás, portanto, para obter a versão mais recente do
pandas, é recomendado instalar usando os métodos pip ou conda descritos acima.
Tratamento de erros de importação
Se você encontrar um ImportError, geralmente significa que o Python não conseguiu encontrar o pandas na lista de bibliotecas disponíveis.
O Python possui internamente uma lista de diretórios nos quais ele pesquisa para encontrar pacotes. Você pode obter esses diretórios com:
sistema de importação
sys.caminho
Uma maneira de encontrar esse erro é se você tiver várias instalações do Python em seu sistema e não
tenha o pandas instalado na instalação do Python que você está usando atualmente. No Linux/Mac você pode executar which python em
seu terminal e ele lhe dirá qual instalação do Python você está usando. Se for algo como “/usr/bin/python”, você está
usando o Python do sistema, o que não é recomendado.
É altamente recomendado usar conda, para instalação rápida e para atualizações de pacotes e dependências. Você pode encontrar
instruções simples de instalação para pandas neste documento: instruções de instalação </getting_started.
html>.
Instalando a partir da fonte
Consulte o guia de contribuição para obter instruções completas sobre como construir a partir da árvore de origem do git. Além disso, consulte a criação de um
ambiente de desenvolvimento se você deseja criar um ambiente de desenvolvimento pandas.
Executando o conjunto de testes
O pandas está equipado com um conjunto exaustivo de testes unitários, cobrindo cerca de 97% da base de código no momento desta redação. Para
execute-o em sua máquina para verificar se tudo está funcionando (e se você tem todas as dependências, soft e hard,
instalado), certifique-se de ter pytest >= 6.0 e Hypothesis >= 3.58 e execute:
>>> pd.teste()
executando: pytest --skip-slow --skip-network C:\Users\TP\Anaconda3\envs\py36\lib\site-
ÿÿpacotes\pandas
(continua na próxima página)

(continuação da página anterior)
============================ início da sessão de teste ================== ===========

plataforma win32 – Python 3.6.2, pytest-3.6.0, py-1.4.34, pluggy-0.4.0
rootdir: C:\Users\TP\Documents\Python\pandasdev\pandas, inifile: setup.cfg
coletou 12.145 itens / 3 ignorados
.................................................. ................S......
........S................................................ .......................
.................................................. .......................
==================== 12130 aprovados, 12 ignorados em 368,339 segundos ======================
Dependências
Versão mínima suportada do pacote

NumPy 1.18.5
python-dateutil 2.8.1
pytz 2020.1
Dependências recomendadas
•
numexpr: para acelerar certas operações numéricas. numexpr usa vários núcleos, bem como fragmentação inteligente
e armazenamento em cache para obter grandes acelerações. Se instalado, deverá ser a versão 2.7.1 ou superior.
• gargalo: para acelerar certos tipos de avaliações nano. gargalo usa rotinas Cython especializadas para
alcançar grandes acelerações. Se instalado, deverá ser a versão 1.3.1 ou superior.
Nota: É altamente recomendável instalar essas bibliotecas, pois elas fornecem melhorias de velocidade, especialmente quando
trabalhando com grandes conjuntos de dados.
Dependências opcionais
pandas tem muitas dependências opcionais que são usadas apenas para métodos específicos. Por exemplo, pandas.read_hdf()
requer o pacote pytables, enquanto DataFrame.to_markdown() requer o pacote tabulate. Se o opcional
dependência não estiver instalada, o pandas gerará um ImportError quando o método que requer essa dependência for chamado.
Visualização
Notas de versão mínima de dependência

matplotlib 3.3.2 Biblioteca de plotagem
2.11 Jinja2 com DataFrame.style
Formatação condicional
0.8.7
tabular Impressão em formato compatível com Markdown (ver tabular)
1.4. Tutoriais 9
Computação
Versão Mínima Notas

Dependência
SciPy 1.4.1 Funções estatísticas diversas
numba 0,50,1 Mecanismo de execução alternativo para operações contínuas (consulte Melhorando o
desempenho)
matriz x 0.15.1 API semelhante ao pandas para dados N-dimensionais
Arquivos Excel

xlrd 2.0.1 Lendo Excel
xlwt 1.3.0 Escrevendo Excel
xlsxwriter 1.2.2 Escrevendo Excel
openpyxl 3.0.3 Leitura/escrita para arquivos xlsx
pyxlsb 1.0.6 Lendo arquivos xlsb
HTML

Analisador HTML BeautifulSoup4 4.8.2 para read_html
1.1para read_html
analisador HTML html5lib
4.5.0read_html
analisador HTML lxml para
Uma das seguintes combinações de bibliotecas é necessária para usar a função read_html() de nível superior :
• BeautifulSoup4 e html5lib
• BeautifulSoup4 e lxml
• BeautifulSoup4 e html5lib e lxml
• Somente lxml, embora consulte Análise de tabela HTML para saber por que você provavelmente não deveria adotar essa abordagem.
Aviso:
• se você instalar o BeautifulSoup4 você deverá instalar lxml ou html5lib ou ambos. read_html( ) não funcionará
com apenas BeautifulSoup4 instalado.
• Recomendamos vivamente que você leia dicas sobre análise de tabela HTML. Ele explica questões relacionadas à instalação
ção e uso das três bibliotecas acima.

XML

lxml4.5.0 Analisador XML para read_xml e construtor de árvore para to_xml
Bancos de dados SQL

SQLAlchemy 1.4.0 psycopg2 Suporte SQL para bancos de dados diferentes do sqlite
2.8.4 pymysql Mecanismo PostgreSQL para sqlalchemy
0.10.1 Mecanismo MySQL para sqlalchemy
Outras fontes de dados

Leitura/gravação baseada em PyTables 3.6.1 HDF5
bloco 1.20.1 Compressão para HDF5
zlib Compressão para HDF5
fast parquet 0.4.0 Leitura/escrita em parquet
Pyarrow 1.0.1 Leitura/escrita em parquet, ORC e penas
pyreadstat 1.1.0 Leitura de arquivos SPSS (.sav)
Aviso:
• Se você quiser usar read_orc(), é altamente recomendado instalar o pyarrow usando conda. A seguir
um resumo do ambiente em que read_orc() pode funcionar.
Falha no sistema Conda PyPI

Linux com sucesso (pyarrow == 3.0 com sucesso)
Falha no macOS com sucesso
Falha no Windows Fracassado
Acesse dados na nuvem

fsspec 0.7.4 Manipulando arquivos além de locais simples e HTTP
gcsfs 0.6.0 Acesso ao Google Cloud Storage
pandas-gbq 0.14.0 Acesso ao Google BigQuery
s3fs 0.4.0 Acesso ao Amazon S3
1.4. Tutoriais 11
Prancheta

PyQt4/PyQt5 E/S da área de transferência
qtpy E/S da área de transferência
xclip E/S da área de transferência no Linux

xsel E/S da área de transferência no Linux
Compressão

brotli 0.7.0 python-snappy 0.6.0 Compressão Brotli
0.15.2 Zstandard Compressão rápida
Compressão Zpadrão
1.4.2 Visão geral do pacote
pandas é um pacote Python que fornece estruturas de dados rápidas, flexíveis e expressivas, projetadas para facilitar o trabalho com
dados “relacionais” ou “rotulados” fáceis e intuitivos. Pretende ser o alicerce fundamental de alto nível para fazer
análise prática de dados do mundo real em Python. Além disso, tem o objetivo mais amplo de se tornar o mais poderoso
e ferramenta flexível de análise/manipulação de dados de código aberto, disponível em qualquer idioma. Já está bem encaminhado
em direção a esse objetivo.
pandas é adequado para muitos tipos diferentes de dados:
• Dados tabulares com colunas de tipo heterogêneo, como em uma tabela SQL ou planilha do Excel
• Dados de séries temporais ordenados e não ordenados (não necessariamente de frequência fixa).
• Dados de matriz arbitrária (digitados de forma homogênea ou heterogênea) com rótulos de linha e coluna
• Qualquer outra forma de conjuntos de dados observacionais/estatísticos. Os dados não precisam ser rotulados para serem colocados em um
estrutura de dados do pandas
As duas estruturas de dados primárias do pandas, Series (unidimensional) e DataFrame (bidimensional), lidam com o
grande maioria dos casos de uso típicos em finanças, estatística, ciências sociais e muitas áreas da engenharia. Para usuários R,
DataFrame fornece tudo o que o data.frame do R oferece e muito mais. pandas é construído em cima do NumPy e
destina-se a integrar-se bem em um ambiente de computação científica com muitas outras bibliotecas de terceiros.
Aqui estão apenas algumas das coisas que os pandas fazem bem:
• Fácil manipulação de dados ausentes (representados como NaN) em dados de ponto flutuante e também em dados de ponto não flutuante
• Mutabilidade de tamanho: colunas podem ser inseridas e excluídas do DataFrame e de objetos de dimensões superiores
• Alinhamento de dados automático e explícito : os objetos podem ser alinhados explicitamente a um conjunto de rótulos ou o usuário pode simplesmente
ignore os rótulos e deixe Series, DataFrame, etc. alinhar automaticamente os dados para você nos cálculos
• Funcionalidade de agrupamento poderosa e flexível para realizar operações de divisão, aplicação e combinação em conjuntos de dados, tanto para
agregando e transformando dados
• Facilite a conversão de dados irregulares e indexados de forma diferente em outras estruturas de dados Python e NumPy em
Objetos DataFrame
• Fatiamento inteligente baseado em rótulos , indexação sofisticada e subconjuntos de grandes conjuntos de dados

• Mesclagem e união intuitiva de conjuntos de dados
• Remodelagem e dinamização flexíveis de conjuntos de dados
• Rotulagem hierárquica de eixos (possível ter vários rótulos por tick)
• Ferramentas robustas de IO para carregar dados de arquivos simples (CSV e delimitados), arquivos Excel, bancos de dados e salvar/carregar
dados do formato HDF5 ultrarrápido
• Funcionalidade específica para séries temporais : geração de intervalo de datas e conversão de frequência, estatísticas de janela
móvel, mudança de data e atraso.
Muitos desses princípios estão aqui para resolver as deficiências frequentemente experimentadas no uso de outras linguagens/ambientes
de pesquisa científica. Para cientistas de dados, trabalhar com dados normalmente é dividido em vários estágios: limpar e limpar os dados,
analisá-los/modelá-los e, em seguida, organizar os resultados da análise em um formato adequado para plotagem ou exibição tabular.
pandas é a ferramenta ideal para todas essas tarefas.
Algumas outras notas
• pandas é rápido. Muitos dos bits algorítmicos de baixo nível foram amplamente ajustados no código Cython . No entanto, como
acontece com qualquer outra coisa, a generalização geralmente sacrifica o desempenho. Portanto, se você se concentrar em um
recurso para seu aplicativo, poderá criar uma ferramenta especializada mais rápida.
• pandas é uma dependência de modelos estatísticos, tornando-se uma parte importante do ecossistema de computação estatística em
Pitão.
• O pandas tem sido amplamente utilizado na produção de aplicações financeiras.
Estruturas de dados
Dimensões Nome Descrição

1 Series Matriz de tipo homogêneo rotulada 1D
2 Quadro de dados Estrutura tabular geral rotulada em 2D, de tamanho mutável, com coluna
potencialmente heterogênea
Por que mais de uma estrutura de dados?
A melhor maneira de pensar nas estruturas de dados do pandas é como contêineres flexíveis para dados de dimensões inferiores. Por
exemplo, DataFrame é um contêiner para Series e Series é um contêiner para escalares. Gostaríamos de poder inserir e remover objetos
desses contêineres como um dicionário.
Além disso, gostaríamos de comportamentos padrão sensatos para as funções comuns da API que levassem em conta a orientação típica
de séries temporais e conjuntos de dados transversais. Ao usar a matriz N-dimensional (ndarrays) para armazenar dados bidimensionais e
tridimensionais, é colocado sobre o usuário a responsabilidade de considerar a orientação do conjunto de dados ao escrever funções; os
eixos são considerados mais ou menos equivalentes (exceto quando a contiguidade C ou Fortran é importante para o desempenho). Nos
pandas, os eixos pretendem dar mais significado semântico aos dados; isto é, para um determinado conjunto de dados, é provável que
exista uma forma “certa” de orientar os dados. O objetivo, então, é reduzir a quantidade de esforço mental necessário para codificar as
transformações de dados em funções posteriores.
Por exemplo, com dados tabulares (DataFrame) é semanticamente mais útil pensar no índice (as linhas) e nas colunas em vez de no eixo
0 e no eixo 1. A iteração através das colunas do DataFrame resulta assim num código mais legível:
para col em df.columns:

series = df[col] # faça
algo com a série
1.4. Tutoriais 13
Mutabilidade e cópia de dados
Todas as estruturas de dados do pandas são de valor mutável (os valores que elas contêm podem ser alterados), mas nem sempre de tamanho
mutável. O comprimento de uma Série não pode ser alterado, mas, por exemplo, colunas podem ser inseridas em um DataFrame. No entanto, a
grande maioria dos métodos produz novos objetos e deixa os dados de entrada intactos. Em geral, gostamos de favorecer a imutabilidade sempre
que for sensato.
Obtendo suporte
A primeira parada para questões e ideias sobre pandas é o Github Issue Tracker. Se você tiver alguma dúvida geral, os especialistas da comunidade
pandas podem responder por meio do Stack Overflow.
Comunidade
O pandas é apoiado ativamente hoje por uma comunidade de indivíduos com ideias semelhantes em todo o mundo que contribuem com seu valioso
tempo e energia para ajudar a tornar possíveis os pandas de código aberto. Obrigado a todos os nossos colaboradores.
Se você estiver interessado em contribuir, visite o guia de contribuição.
pandas é um projeto patrocinado pela NumFOCUS . Isso ajudará a garantir o sucesso do desenvolvimento do pandas como um projeto de código
aberto de classe mundial e possibilitará doações para o projeto.
Projeto governamental
O processo de governação que o projecto pandas tem utilizado informalmente desde a sua criação em 2008 está formalizado em documentos de
Governação do Projecto. Os documentos esclarecem como as decisões são tomadas e como os vários elementos da nossa comunidade interagem,
incluindo a relação entre o desenvolvimento colaborativo de código aberto e o trabalho que pode ser financiado por entidades com ou sem fins
lucrativos.
Wes McKinney é o Ditador Benevolente Vitalício (BDFL).
Equipe de desenvolvimento
A lista dos membros do Core Team e informações mais detalhadas podem ser encontradas na página popular da governança
repositório.
Parceiros institucionais
As informações sobre os atuais parceiros institucionais podem ser encontradas na página do site do pandas.
Licença
Licença BSD de 3 cláusulas
Copyright (c) 2008-2011, AQR Capital Management, LLC, Lambda Foundry, Inc. e PyDataÿ ÿÿEquipe de Desenvolvimento Todos os direitos
reservados.
Copyright (c) 2011-2021, Colaboradores de código aberto.

A redistribuição e o uso em formato fonte e binário, com ou sem modificação, são

permitidos desde que as seguintes condições sejam atendidas:
* As redistribuições do código-fonte devem manter o aviso de direitos autorais acima, esta lista de
condições e a seguinte isenção de responsabilidade.
* As redistribuições em formato binário devem reproduzir o aviso de direitos autorais acima, esta
lista de condições e a seguinte isenção de responsabilidade na documentação e/ou outros
materiais fornecidos com a distribuição.
* Nem o nome do detentor dos direitos autorais nem os nomes de seus

colaboradores podem ser usados para endossar ou promover produtos derivados deste
software sem permissão prévia específica por escrito.
ESTE SOFTWARE É FORNECIDO PELOS DETENTORES DE DIREITOS AUTORAIS E COLABORADORES "COMO ESTÁ"
E QUAISQUER GARANTIAS EXPRESSAS OU IMPLÍCITAS, INCLUINDO, MAS NÃO SE LIMITANDO A, GARANTIAS
IMPLÍCITAS DE COMERCIALIZAÇÃO E ADEQUAÇÃO A UM DETERMINADO FIM SÃO REJEITADAS. EM HIPÓTESE ALGUMA
O DETENTOR DOS DIREITOS AUTORAIS OU COLABORADORES SERÃO RESPONSÁVEIS POR QUAISQUER DANOS
DIRETOS, INDIRETOS, INCIDENTAIS, ESPECIAIS, EXEMPLARES OU CONSEQUENCIAIS (INCLUINDO, MAS NÃO SE
LIMITANDO A, AQUISIÇÃO DE BENS OU SERVIÇOS SUBSTITUTOS; PERDA DE USO, DADOS OU LUCROS; OU
INTERRUPÇÃO DE NEGÓCIOS) QUALQUER CAUSA E SOBRE QUALQUER TEORIA DE RESPONSABILIDADE, SEJA
POR CONTRATO, RESPONSABILIDADE ESTRITA OU ATO ILÍCITO (INCLUINDO NEGLIGÊNCIA OU DE OUTRA FORMA)
DECORRENTE DE QUALQUER FORMA DO USO DESTE SOFTWARE, MESMO SE AVISADO DA POSSIBILIDADE DE TAIS
DANOS.
1.4.3 Tutoriais de introdução
Que tipo de dados os pandas tratam?
Quero começar a usar pandas
Em [1]: importar pandas como pd
Para carregar o pacote pandas e começar a trabalhar com ele, importe o pacote. O alias acordado pela comunidade para pandas
é pd, portanto, carregar pandas como pd é uma prática padrão para toda a documentação do pandas.
representação da tabela de dados do pandas
Quero armazenar dados de passageiros do Titanic. Para vários passageiros, conheço os dados de nome (personagens), idade (números
inteiros) e sexo (masculino/feminino).
Em [2]: df = pd.DataFrame( {
...:
...: "Nome":
...: [ "Braund, Sr. Owen Harris", "Allen,
...: Sr. William Henry", "Bonnell, Srta.
...: Elizabeth",
...: ],
1.4. Tutoriais 15

...: "Idade": [22, 35, 58],
...: "Sexo": ["masculino", "masculino", "feminino"],
...: }
... :)
...:
Em [3]: df
Fora[3]:
Nome Idade Sexo
0 Braund, Sr. Owen Harris 22 homens
1 Allen, Sr. William Henry 35 homem
2 Bonnell, Srta. Elizabeth 58 mulher
Para armazenar dados manualmente em uma tabela, crie um DataFrame. Ao usar um dicionário de listas Python, as chaves do dicionário
serão usados como cabeçalhos de coluna e os valores em cada lista como colunas do DataFrame.
Um DataFrame é uma estrutura de dados bidimensional que pode armazenar dados de diferentes tipos (incluindo caracteres, inteiros,
valores de ponto flutuante, dados categóricos e muito mais) em colunas. É semelhante a uma planilha, uma tabela SQL ou aos dados.
quadro em R.
• A tabela possui 3 colunas, cada uma delas com um rótulo de coluna. Os rótulos das colunas são respectivamente Nome, Idade e
Sexo.
• A coluna Nome consiste em dados textuais com cada valor uma string, a coluna Idade são números e a coluna
Sexo são dados textuais.
No software de planilha, a representação em tabela de nossos dados seria muito semelhante:

Cada coluna em um DataFrame é uma série
Estou apenas interessado em trabalhar com os dados da coluna Idade
Em [4]: df["Idade"]
Fora[4]: 0
22 1 35 2
58
Nome: Idade, dtype: int64
Ao selecionar uma única coluna de um DataFrame do pandas, o resultado é uma série do pandas. Para selecionar a coluna, use o
rótulo da coluna entre colchetes [].
Nota: Se você conhece os dicionários Python, a seleção de uma única coluna é muito semelhante à seleção de valores de dicionário
com base na chave.
Você também pode criar uma série do zero:
Em [5]: idades = pd.Series([22, 35, 58], nome="Idade")
Em [6]: idades
Fora[6]: 0
22 1 35 2
58
Nome: Idade, dtype: int64
Uma série pandas não possui rótulos de coluna, pois é apenas uma única coluna de um DataFrame. Uma série possui rótulos de linha.
Faça algo com um DataFrame ou Series
Quero saber a idade máxima dos passageiros
Podemos fazer isso no DataFrame selecionando a coluna Age e aplicando max():
Em [7]: df["Idade"].max()
Fora[7]: 58
Ou para a série:
Em [8]: idades.max()
Fora[8]: 58
Conforme ilustrado pelo método max(), você pode fazer coisas com um DataFrame ou Series. O pandas oferece muitas funcionalidades,
cada uma delas um método que você pode aplicar a um DataFrame ou Série. Como métodos são funções, não esqueça de usar
parênteses().
Estou interessado em algumas estatísticas básicas dos dados numéricos da minha tabela de dados
1.4. Tutoriais 17
Em [9]: df.describe()
Fora[9]:
Contagem de idade 3.000000

significa 38,333333
padrão 18.230012
mínimo 22.000000
25% 28,500000
50% 35,000000
75% 46,500000
máx. 58,000000
O método description() fornece uma visão geral rápida dos dados numéricos em um DataFrame. Como as colunas Nome e Sexo são dados textuais,
por padrão não são levados em consideração pelo método description() .
Muitas operações do pandas retornam um DataFrame ou uma Série. O método description() é um exemplo de operação do pandas que retorna uma
série do pandas ou um DataFrame do pandas.
Verifique mais opções de descrição na seção do guia do usuário sobre agregações com descrição
Nota: Este é apenas um ponto de partida. Semelhante ao software de planilha, o pandas representa os dados como uma tabela com colunas e linhas.
Além da representação, também as manipulações de dados e cálculos que você faria em um software de planilha são suportados pelo pandas.
Continue lendo os próximos tutoriais para começar!
• Importe o pacote, também conhecido como importar pandas como pd
• Uma tabela de dados é armazenada como um DataFrame do pandas
• Cada coluna em um DataFrame é uma série
• Você pode fazer coisas aplicando um método a um DataFrame ou Série
Uma explicação mais extensa sobre DataFrame e Series é fornecida na introdução às estruturas de dados.
Este tutorial usa o conjunto de dados do Titanic, armazenado como CSV. Os dados consistem nas seguintes colunas de dados:
• PassengerId: Id de cada passageiro.
• Sobreviveu: Este recurso tem valor 0 e 1. 0 para não sobreviveu e 1 para sobreviveu.
• Pclass: Existem 3 turmas: Turma 1, Turma 2 e Turma 3.
• Nome: Nome do passageiro.
• Sexo: Gênero do passageiro.
• Idade: Idade do passageiro.
• SibSp: Indicação de que o passageiro possui irmãos e cônjuge.
• Parch: Se o passageiro está sozinho ou tem família.
• Bilhete: Número do bilhete do passageiro.
• Tarifa: Indicação da tarifa.
• Cabine: A cabine do passageiro.
• Embarcado: A categoria embarcado.

Como leio e escrevo dados tabulares?
Quero analisar os dados dos passageiros do Titanic, disponíveis em arquivo CSV.
Em [2]: titanic = pd.read_csv("data/titanic.csv")
pandas fornece a função read_csv() para ler dados armazenados como um arquivo csv em um DataFrame do pandas. suportes de pandas
muitos formatos de arquivo ou fontes de dados diferentes prontos para uso (csv, excel, sql, json, parquet, . . . ), cada um deles com o
prefixo lido_*.
Certifique-se de sempre verificar os dados após lê-los. Ao exibir um DataFrame, o primeiro e

as últimas 5 linhas serão mostradas por padrão:
Em [3]: titânico
Fora[3]:
PassengerId sobreviveu à Pclass Nome ..
ÿÿ. Bilhete Tarifa Cabine Embarcada
0 1 0 3 Braund, Sr.
ÿÿ. A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Sra. John Bradley (Florence Briggs Th... ..
ÿÿ. PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Srta.
ÿÿ. ESTÃO/O2. 3101282 7.9250 3 NaN S
4 1 Futrelle, Sra.
ÿÿ. 1 113803 53.1000 C123 0 373450 S
4 5 3 Allen, Sr.
ÿÿ. 8.0500 NaN S
.. ... ... ... ... ..
ÿÿ. ... ... ... ...
886 887 0 211536 2 Montvila, Rev.
ÿÿ. 13,0000 888 1 112053 NaN S
887 30,0000 889 0 W./ 1 Graham, Srta.
ÿÿ. C. 6607 23.4500 890 1 B42 S
888 3 Johnston, Srta. Catherine Helen "Carrie" ..
ÿÿ. NaN S
889 1 Behr, Sr.
ÿÿ. 111369 30.0000 C148 C
890 891 0 3 Dooley, Sr.
ÿÿ. 370376 7.7500 NaN P
[891 linhas x 12 colunas]
Quero ver as primeiras 8 linhas de um DataFrame do pandas.
Em [4]: titanic.head(8)
Fora[4]:
PassengerId Sobreviveu Pclass ÿÿSexo ... Nome ÿ
Bilhete Parch 0 3 ÿÿmasculino ... 1 2 ÿÿfeminino ... 2 3 Tarifa Cabine Embarcada

ÿÿfeminino ... 1 0 Braund, Sr. ÿ
0 A/5 21171 7,2500 NaN 1 Cumings,

1 Sra. John Bradley (Florence Briggs Th... ÿ
0 PC 17599 71.2833 C85 C

1 3 Heikkinen, Srta. ÿ
0 PÓS/O2. 3101282 7,9250 NaN S (continua na próxima página)
1.4. Tutoriais 19

3 4 1 1 Futrelle, Sra. Jacques Heath (Lily May Peel) ÿ
ÿÿfeminino ... 0 113803 53.1000 C123 S
4 5 0 3 Allen , Sr.
ÿÿmasculino ... 0 373450 8,0500NaN S
5 6 0 3 Moran, Sr. ÿ
ÿÿmasculino ... 0 330877 8,4583 NaN P

6 7 0 1 McCarthy, Sr. ÿ
ÿÿmasculino ... 0 17463 51.8625 E46

7 8 0 3 Palsson, Mestre. Gosta Leonard ÿ
Para ver as primeiras N linhas de um DataFrame, use o método head() com o número necessário de linhas (neste caso 8) como
argumento.
Nota: Interessado nas últimas N linhas? pandas também fornece um método tail() . Por exemplo, titanic.tail(10)
retornará as últimas 10 linhas do DataFrame.
Uma verificação de como o pandas interpretou cada um dos tipos de dados da coluna pode ser feita solicitando os pandas dtypes
atributo:
Em [5]: titanic.dtypes
Fora[5]:
PassengerId int64
sobreviveu int64
à Pclass int64
Nome objeto
Sexo objeto
Idade float64
SibSp int64
Parch int64
Bilhete objeto
Tarifa float64
Cabine objeto
Tipo objeto
embarcado: objeto
Para cada uma das colunas, o tipo de dados usado é listado. Os tipos de dados neste DataFrame são inteiros (int64), flutuantes
(float64) e strings (objeto).
Nota: Ao solicitar os dtypes, nenhum colchete é usado! dtypes é um atributo de um DataFrame e Series. Atributos de DataFrame ou Series
não precisam de colchetes. Os atributos representam uma característica de um DataFrame/Série,
enquanto um método (que requer colchetes) faz algo com o DataFrame/Series conforme apresentado no primeiro tutorial.
Meu colega solicitou os dados do Titanic em forma de planilha.
Em [6]: titanic.to_excel("titanic.xlsx", sheet_name="passageiros", index=False)
Enquanto as funções read_* são usadas para ler dados para pandas, os métodos to_* são usados para armazenar dados. O to_excel()

O método armazena os dados como um arquivo Excel. No exemplo aqui, o nome_da_planilha é denominado passageiros em vez do padrão
Folha1. Ao definir index=False, os rótulos de índice de linha não são salvos na planilha.
A função de leitura equivalente read_excel() recarregará os dados em um DataFrame:
Em [7]: titanic = pd.read_excel("titanic.xlsx", sheet_name="passageiros")
Em [8]: titanic.head()
Fora[8]:
PassengerId sobreviveu Pclass ÿÿSex ... Nome ÿ
Bilhete Parch Tarifa Cabine Embarcada

0 1 0 3 Braund, Sr. ÿ
ÿÿmasculino ... 0 A/5 21171 7,2500 NaN 1 Cumings, S

1 2 ÿÿfeminino ... 2 3 1 Sra. John Bradley (Florence Briggs Th... ÿ
ÿÿfeminino ... 3 4 0 PC 17599 71.2833 C85 C

ÿÿfeminino ... 4 1 3 Heikkinen, Srta. ÿ
ÿÿmasculino ... 0 PÓS/O2. 3101282 7,9250 NaN S

1 Futrelle, Sra. Jacques Heath (Lily May Peel) ÿ
0 1 113803 53.1000 C123 3 S
5 0 Allen , Sr.
0 373450 8,0500NaN S
Estou interessado em um resumo técnico de um DataFrame
Em [9]: titanic.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entradas, 0 a 890
Colunas de dados (total de 12 colunas):
# Tipo de contagem não nula da coluna
--- ------ ------------------ -----
0 PassengerId 891 não nulo int64

1 Sobreviveu 891 não nulo 891 não nulo int64
2Pclass int64
3 Nome 891 não nulo objeto
4 sexo 891 não nulo objeto
5 idade 714 não nulo float64
6SibSp 891 não nulo int64
7 parca 891 não nulo 891 int64
8 Bilhete não nulo 891 não objeto
9 Tarifa nulo 204 não nulo float64
10 Objeto de cabine 889 não nulo
11 Objeto embarcado
dtypes: float64(2), int64(5), objeto(5)
uso de memória: 83,7+ KB
O método info() fornece informações técnicas sobre um DataFrame, então vamos explicar a saída com mais detalhes:
• Na verdade é um DataFrame.
• Existem 891 entradas, ou seja, 891 linhas.
• Cada linha possui um rótulo de linha (também conhecido como índice) com valores que variam de 0 a 890.
• A tabela possui 12 colunas. A maioria das colunas possui um valor para cada uma das linhas (todos os 891 valores não são nulos). Alguns
colunas têm valores ausentes e menos de 891 valores não nulos.
1.4. Tutoriais 21
• As colunas Nome, Sexo, Cabine e Embarcado consistem em dados textuais (strings, também conhecidos como objeto). As outras colunas
são dados numéricos com alguns deles números inteiros (também conhecidos como inteiros) e outros são números reais (também conhecidos como flutuantes).
• Os tipos de dados (caracteres, inteiros,...) nas diferentes colunas são resumidos pela listagem dos dtypes.
• A quantidade aproximada de RAM usada para armazenar o DataFrame também é fornecida.
• A obtenção de dados para o pandas a partir de vários formatos de arquivo ou fontes de dados diferentes é suportada pelas funções read_*.
• A exportação de dados do pandas é fornecida por diferentes métodos to_*.
• Os métodos head/tail/info e o atributo dtypes são convenientes para uma primeira verificação.
Para uma visão completa das possibilidades de entrada e saída de e para pandas, consulte a seção do guia do usuário sobre
funções de leitor e escritor.
Fora[3]:

ÿÿmasculino ... 0 A/5 21171 7,2500 NaN

1 2 1 1 Cumings, Sra. John Bradley (Florence Briggs ... ÿ
ÿÿfeminino ... 0 PC 17599 71.2833 C85 C

2 3 1 3 Heikkinen, Srta. ÿ
ÿÿfeminino ... 0 PÓS/O2. 3101282 7,9250 NaN S

ÿÿfeminino ... 0 113803 53.1000 C123 S
4 5 0 3 Allen , Sr.

Como seleciono um subconjunto de um DataFrame?
Como seleciono colunas específicas de um DataFrame?
Estou interessado na idade dos passageiros do Titanic.
Em [4]: idades = titânico["Idade"]
Em [5]: idades.head()
Fora[5]:
0 22,0
1 38,0
2 26,0
3 35,0
4 35,0
Nome: Idade, dtype: float64
Para selecionar uma única coluna, use colchetes [] com o nome da coluna de interesse.
Cada coluna em um DataFrame é uma série. Como uma única coluna é selecionada, o objeto retornado é uma série de pandas.
Podemos verificar isso verificando o tipo de saída:
Em [6]: type(titanic["Idade"])
Saída[6]: pandas.core.series.Series
E dê uma olhada no formato da saída:
Em [7]: titânico["Idade"].shape Out[7]:

(891,)
DataFrame.shape é um atributo (lembre-se do tutorial de leitura e escrita, não use parênteses para atributos) de uma série e DataFrame
do pandas contendo o número de linhas e colunas: (nrows, ncolumns). Uma série pandas é unidimensional e apenas o número de linhas
é retornado.
Estou interessado na idade e no sexo dos passageiros do Titanic.
Em [8]: idade_sexo = titânico[["Idade", "Sexo"]]
Em [9]: age_sex.head()
Fora[9]:
Sexo
Idade 0 22,0 macho
1 38,0 feminino 2 26,0
feminino 3 35,0
feminino masculino
4 35,0
Para selecionar várias colunas, use uma lista de nomes de colunas entre colchetes de seleção [].
Nota: Os colchetes internos definem uma lista Python com nomes de colunas, enquanto os colchetes externos são usados para
selecionar os dados de um DataFrame do pandas, como visto no exemplo anterior.
O tipo de dados retornado é um DataFrame do pandas:
1.4. Tutoriais 23
Em [10]: type(titanic[["Idade", "Sexo"]])

Saída[10]: pandas.core.frame.DataFrame
Em [11]: titânico[["Idade", "Sexo"]].forma

Fora[11]: (891, 2)
A seleção retornou um DataFrame com 891 linhas e 2 colunas. Lembre-se, um DataFrame é bidimensional com
uma dimensão de linha e coluna.
Para obter informações básicas sobre indexação, consulte a seção do guia do usuário sobre indexação e seleção de dados.
Como filtrar linhas específicas de um DataFrame?
Estou interessado nos passageiros com mais de 35 anos.
Em [12]: acima_35 = titânico[titânico["Idade"] > 35]
Em [13]: acima_35.head()
Fora[13]:
Bilhete Parch 1 1 ÿÿfeminino ... 6 Tarifa Cabine Embarcada

2
ÿÿmasculino ... 11 ÿÿfeminino ... 13 1 Cumings, Sra. John Bradley (Florence Briggs ... ÿ
ÿÿmasculino ... 15 0 PC 17599 71.2833 C85 0 1 17463 C

7 51.8625 E46 1 McCarthy, Sr. ÿ
0 S
12 Bonnell, Srta. ÿ
0 1 113783 26.5500 C103 0 S

14 Andersson, Sr. ÿ
5 3 347082 31,2750 NaN S

16 1 2 Hewlett, Sra .
ÿÿfeminino ... 0 248706 16,0000 NaN S
Para selecionar linhas com base em uma expressão condicional, use uma condição entre colchetes de seleção [].
A condição dentro dos colchetes de seleção titanic["Age"] > 35 verifica para quais linhas a coluna Age tem um valor
maior que 35:
Em [14]: titânico["Idade"] > 35

Fora[14]:
0 Falso
1 Verdadeiro
2 Falso
3 Falso
4 Falso
...
886 Falso
887 Falso
888 Falso
889 Falso


890 Falso
Nome: Idade, Comprimento: 891, dtype: bool
A saída da expressão condicional (>, mas também ==, !=, <, <=,. . . funcionaria) é na verdade uma série de pandas
valores booleanos (True ou False) com o mesmo número de linhas que o DataFrame original. Tal série de
valores booleanos podem ser usados para filtrar o DataFrame colocando-o entre os colchetes de seleção []. Apenas linhas para
cujo valor é True será selecionado.
Já sabemos que o DataFrame original do Titanic consiste em 891 linhas. Vamos dar uma olhada no número de
linhas que satisfazem a condição verificando o atributo shape do DataFrame resultante acima_35:
Em [15]: acima_35.shape
Fora[15]: (217, 12)
Estou interessado nos passageiros do Titanic das classes de cabine 2 e 3.
Em [16]: class_23 = titanic[titanic["Pclass"].isin([2, 3])]
Em [17]: class_23.head()
Fora[17]:
PassengerId sobreviveu ao bilhete Pclass 0 Nome Sexo Idade SibSp ÿ
ÿÿParque Tarifa Cabine Embarcada
1 Braund, Sr. masculino 22,0 1 ÿ
0 ÿÿ 0 3A/5 21171 7,2500 NaN3 3

2 1 Heikkinen, Srta. Laina feminino 26,0 0 ÿ
ÿÿ 0 PÓS/O2. 3101282 7,9250 NaN4 S

5 0 3 Allen, Sr. masculino 35,0 0 ÿ
ÿÿ 0 373450 8,0500NaN
5 6 0 3 Moran, Sr. masculino NaN 0 ÿ
ÿÿ 0 330877 8,4583 NaN P

7 8 0 3 Palsson, Mestre. Gosta Leonard masculino 2.0 3 ÿ
ÿÿ 1 349909 21,0750NaN S
Semelhante à expressão condicional, a função condicional isin() retorna um True para cada linha em que os valores estão
a lista fornecida. Para filtrar as linhas com base em tal função, use a função condicional dentro dos colchetes de seleção
[]. Neste caso, a condição dentro dos colchetes de seleção titanic["Pclass"].isin([2, 3]) verifica qual
linhas, a coluna Pclass é 2 ou 3.
O procedimento acima é equivalente a filtrar por linhas para as quais a classe é 2 ou 3 e combinar as duas instruções com
um | (ou) operador:
Em [18]: class_23 = titanic[(titanic["Pclass"] == 2) | (titânico["Pclass"] == 3)]
Em [19]: class_23.head()
Fora[19]:
PassengerId sobreviveu ao bilhete Pclass Nome Sexo Idade SibSp ÿ
ÿÿParque Tarifa Cabine Embarcada
0 1 0 3 Braund, Sr. masculino 22,0 1 ÿ
ÿÿ 0 A/5 21171 7,2500 NaN 3 3

2 1 Heikkinen, Srta. Laina feminino 26,0 0 ÿ
ÿÿ 0 PÓS/O2. 3101282 7,9250 NaN S

4 5 0 3 Allen, Sr. masculino 35,0 0 ÿ
ÿÿ 0 373450 8,0500NaN
5 6 0 3 Moran, Sr. masculino NaN 0 ÿ
ÿÿ 0 330877 8,4583 NaN P (continua na próxima página)
1.4. Tutoriais 25
7 8 0 3 Palsson, Mestre. Gosta Leonard masculino 2.0 3 ÿ
ÿÿ 1 349909 21,0750NaN S
Nota: Ao combinar múltiplas instruções condicionais, cada condição deve estar entre parênteses (). Além disso, você não pode usar ou/e, mas
precisa usar o operador or | e o operador and &.
Consulte a seção dedicada no guia do usuário sobre indexação booleana ou sobre a função isin.
Quero trabalhar com dados de passageiros cuja idade seja conhecida.
Em [20]: age_no_na = titanic[titanic["Idade"].notna()]
Em [21]: age_no_na.head()
Fora[21]:
PassengerId sobreviveu Pclass ÿÿSex ... Parch Nome ÿ
Ticket 0 3 Tarifa Cabine Embarcada

1 0 Braund, Sr. ÿ
ÿÿmasculino ... 0 A/5 21171 7,2500 NaN 1 Cumings,

1 2 1 Sra. John Bradley (Florence Briggs Th... ÿ
ÿÿfeminino ... 0 PC 17599 71.2833 C85 C

2 3 1 3 Heikkinen, Srta. ÿ
ÿÿfeminino ... 0 PÓS/O2. 3101282 7,9250 NaN S

ÿÿfeminino ... 0 113803 53.1000 C123 S
4 5 0 3 Allen , Sr.
A função condicional notna() retorna um True para cada linha em que os valores não são nulos. Como tal, isto pode ser
combinado com os colchetes de seleção [] para filtrar a tabela de dados.
Você pode estar se perguntando o que realmente mudou, já que as primeiras 5 linhas ainda têm os mesmos valores. Uma maneira de verificar é verificar se
a forma mudou:
Em [22]: age_no_na.shape
Fora[22]: (714, 12)
Para funções mais dedicadas sobre valores ausentes, consulte a seção do guia do usuário sobre como lidar com dados ausentes.
Como seleciono linhas e colunas específicas de um DataFrame?
Estou interessado nos nomes dos passageiros com mais de 35 anos.
Em [23]: adult_names = titanic.loc[titanic["Idade"] > 35, "Nome"]
Em [24]: adult_names.head()
Fora[24]:
1 Cumings, Sra. John Bradley (Florence Briggs ...

6 McCarthy, Sr.
11 Bonnell, Srta.
13 Andersson, Sr.
15 Hewlett, Sra.
Nome: Nome, dtype: objeto
Neste caso, um subconjunto de linhas e colunas é criado de uma só vez e apenas usar colchetes de seleção [] não é suficiente
não mais. Os operadores loc/iloc são necessários na frente dos colchetes de seleção []. Ao usar loc/iloc, a parte
antes da vírgula estão as linhas que você deseja e a parte depois da vírgula são as colunas que você deseja selecionar.
Ao usar nomes de colunas, rótulos de linhas ou uma expressão de condição, use o operador loc na frente da seleção
colchetes []. Tanto para a parte antes quanto depois da vírgula, você pode usar um único rótulo, uma lista de rótulos, uma fatia de rótulos,
uma expressão condicional ou dois pontos. Usar dois pontos especifica que você deseja selecionar todas as linhas ou colunas.
Estou interessado nas linhas 10 a 25 e nas colunas 3 a 5.
Em [25]: titanic.iloc[9:25, 2:5]

Fora[25]:
Pclass Nome Sexo
9 2 Nasser, Sra. Nicholas (Adele Achem) mulher
10 3 Sandstrom, Srta. Marguerite Rut fêmea
11 1 Bonnell, Srta. Elizabeth mulher
12 3 Saundercock, Sr. William Henry masculino
13 3Andersson, Sr. Anders Johan masculino
.. ... ... ...
20 2 Fynney, Sr. macho
21 2 Beesley, Sr. Lawrence masculino
22 3 McGowan, Srta. Anna "Annie" mulher
23 1 Sloper, Sr. William Thompson masculino
24 3 Palsson, Srta. Torborg Danira mulher
Novamente, um subconjunto de linhas e colunas é criado de uma só vez e apenas usar colchetes de seleção [] não é suficiente
não mais. Quando estiver especificamente interessado em determinadas linhas e/ou colunas com base em sua posição na tabela, use o iloc
operador na frente dos colchetes de seleção [].
Ao selecionar linhas e/ou colunas específicas com loc ou iloc, novos valores podem ser atribuídos aos dados selecionados. Para
por exemplo, para atribuir o nome anônimo aos 3 primeiros elementos da terceira coluna:
Em [26]: titanic.iloc[0:3, 3] = "anônimo"
Fora[27]:
PassengerId sobreviveu Pclass ÿÿ.. Parch Nome Sexo.
Ticket 0 0 Tarifa Cabine Embarcada
1 anônimo macho .
ÿÿ.. 0 3A/5 21171 7,2500 NaN1 S
1 2 1 mulher anônima.
ÿÿ.. 0 PC 17599 71.2833 C85 C
2 3 1 3 mulher anônima.
ÿÿ.. 0 PÓS/O2. 3101282 7,9250 NaN S
3 4 1 1 Futrelle, Sra. Jacques Heath (Lily May Peel) mulher.
ÿÿ.. 0 113803 53.1000 C123 S
1.4. Tutoriais 27

4 5 0 3 Allen, Sr. William Henry, homem.
ÿÿ.. 0 373450 8,0500NaN S
Consulte a seção do guia do usuário sobre diferentes opções de indexação para obter mais informações sobre o uso de loc e iloc.
• Ao selecionar subconjuntos de dados, são usados colchetes [].
• Dentro desses colchetes, você pode usar um único rótulo de coluna/linha, uma lista de rótulos de coluna/linha, uma fatia de rótulos, um
expressão condicional ou dois pontos.
• Selecione linhas e/ou colunas específicas usando loc ao usar os nomes de linhas e colunas
• Selecione linhas e/ou colunas específicas usando iloc ao usar as posições na tabela
• Você pode atribuir novos valores a uma seleção com base em loc/iloc.
Uma visão geral completa da indexação é fornecida nas páginas do guia do usuário sobre indexação e seleção de dados.
Em [2]: importe matplotlib.pyplot como plt
Para este tutorial, os dados de qualidade do 2 é utilizado, disponibilizado pelo openaq e utilizando o pacote py-openaq . O
ar sobre o conjunto de dados air_quality_no2.csv 2 valores para as estações de medição FR04014, BETR801 e Londres
fornecem Westminster em Paris, Antuérpia e Londres, respectivamente.
Em [3]: air_quality = pd.read_csv("data/air_quality_no2.csv", index_col=0, parse_

ÿÿdatas=Verdadeiro)
Em [4]: air_quality.head()
Fora[4]:
estação_antuérpia estação_paris estação_londres
data hora
07-05-2019 02:00:00 NaN NaN 23,0
07-05-2019 03:00:00 50,5 25,0 19,0
07-05-2019 04:00:00 45,0 27,7 19,0
07-05-2019 05:00:00 NaN 50,4 16,0
07-05-2019 06:00:00 NaN 61,9 NaN
Nota: O uso dos parâmetros index_col e parse_dates da função read_csv para definir o primeiro (0º)
coluna como índice do DataFrame resultante e converter as datas na coluna em objetos Timestamp , respectivamente.

Como criar tramas em pandas?
Quero uma verificação visual rápida dos dados.
Em [5]: air_quality.plot()
Saída[5]: <AxesSubplot:xlabel='datetime'>
Com um DataFrame, o pandas cria por padrão um gráfico de linha para cada uma das colunas com dados numéricos.
Quero plotar apenas as colunas da tabela de dados com os dados de Paris.
Em [6]: air_quality["station_paris"].plot()
1.4. Tutoriais 29
Para plotar uma coluna específica, use o método de seleção do tutorial de dados de subconjunto em combinação com o método plot() .
Conseqüentemente, o método plot() funciona tanto em Series quanto em DataFrame.
Quero comparar visualmente os 02 valores medidos em Londres versus Paris.
Em [7]: air_quality.plot.scatter(x="station_london", y="station_paris", alfa=0,5)

Saída[7]: <AxesSubplot:xlabel='station_london', ylabel='station_paris'>

Além do gráfico de linha padrão ao usar a função plot, diversas alternativas estão disponíveis para plotar dados.
Vamos usar Python padrão para obter uma visão geral dos métodos de plotagem disponíveis:
Em [8]: [
...: nome_método
...: para nome_método em dir(air_quality.plot) se não
...: nome_método.startswith("_")
...: ]
...:
Out[8]:
['área',
'bar',
'barh',
'caixa',
'densidade',
'hexbin',
'hist',
'kde',
'linha',
'torta',
'dispersão']
Nota: Em muitos ambientes de desenvolvimento, bem como IPython e Jupyter Notebook, use o botão TAB para obter uma
1.4. Tutoriais 31
visão geral dos métodos disponíveis, por exemplo air_quality.plot. + TAB.
Uma das opções é DataFrame.plot.box(), que se refere a um boxplot. O método da caixa é aplicável nos dados de exemplo de
qualidade do ar:
Em [9]: air_quality.plot.box()
Saída[9]: <AxesSubplot:>
Para obter uma introdução aos gráficos diferentes do gráfico de linha padrão, consulte a seção do guia do usuário sobre estilos de gráfico suportados.
Quero cada uma das colunas em uma subtrama separada.
Em [10]: axs = air_quality.plot.area(figsize=(12, 4), subplots=True)

Subtramas separadas para cada uma das colunas de dados são suportadas pelo argumento subtramas das funções de plotagem. Vale a
pena revisar as opções integradas disponíveis em cada uma das funções do gráfico do pandas.
Mais algumas opções de formatação são explicadas na seção do guia do usuário sobre formatação de plotagem.
Quero personalizar, estender ou salvar ainda mais o gráfico resultante.
Em [11]: fig, axs = plt.subplots(figsize=(12, 4))
Em [12]: air_quality.plot.area(ax=axs)
Em [13]: axs.set_ylabel("NO$_2$ concentração")

Out[13]: Text(0, 0.5, 'NO$_2$ concentração')
Em [14]: fig.savefig("no2_concentrations.png")
Cada um dos objetos de plotagem criados pelo pandas é um objeto matplotlib . Como o Matplotlib oferece muitas opções para
personalizar gráficos, tornar explícito o link entre pandas e Matplotlib permite todo o poder do matplotlib para o gráfico. Esta
estratégia é aplicada no exemplo anterior:
fig, eixos = plt.subplots(figsize=(12, 4)) # Crie uma figura matplotlib vazia eÿ

ÿÿEixos
air_quality.plot.area(ax=axs) ÿÿFigura/ # Use pandas para colocar o gráfico da área noÿ
Eixos preparados
axs.set_ylabel("NO$_2$ concentração") ÿÿcomo # Faça qualquer personalização do matplotlib que vocêÿ
1.4. Tutoriais 33
fig.savefig("no2_concentrations.png") ÿÿmétodo matplotlib # Salve a Figura/Eixos usando oÿ

existente.
• Os métodos .plot.* são aplicáveis em Series e DataFrames
• Por padrão, cada uma das colunas é plotada como um elemento diferente (linha, boxplot,. . . )
• Qualquer gráfico criado por pandas é um objeto Matplotlib.
Uma visão geral completa da plotagem em pandas é fornecida nas páginas de visualização.
Para este tutorial, os dados de qualidade do 2 é utilizado, disponibilizado pelo openaq e utilizando o pacote py-openaq . O
ar sobre o conjunto de dados air_quality_no2.csv 2 valores para as estações de medição FR04014, BETR801 e Londres
fornecem Westminster em Paris, Antuérpia e Londres, respectivamente.
Em [2]: qualidade do ar = pd.read_csv("data/air_quality_no2.csv", index_col=0, parse_

ÿÿdatas=Verdadeiro)
Fora[3]:
estação_antuérpia estação_paris estação_londres
data hora
07/05/2019 02:00:00 NaN NaN 23,0
07/05/2019 03:00:00 50,5 25,0 19,0
07/05/2019 04:00:00 45,0 27,7 19,0
07/05/2019 05:00:00 NaN 50,4 16,0
07/05/2019 06:00:00 NaN 61,9 NaN
Como criar novas colunas derivadas de colunas existentes?
Eu quero expressar o 2 concentração da estação em Londres em mg/m3
(Se assumirmos temperatura de 25 graus Celsius e pressão de 1013 hPa, o fator de conversão é 1,882)
Em [4]: qualidade do ar["london_mg_per_cubic"] = qualidade do ar["station_london"] * 1,882
Fora[5]:
estação_antuérpia estação_paris estação_londres londres_mg_per_cubic
data hora
07/05/2019 02:00:00 NaN NaN 23,0 43.286
07/05/2019 03:00:00 50,5 25,0 19,0 35.758
07/05/2019 04:00:00 45,0 27,7 19,0 35.758
07/05/2019 05:00:00 NaN 50,4 16,0 30.112
07/05/2019 06:00:00 NaN 61,9 NaN NaN
Para criar uma nova coluna, use os colchetes [] com o nome da nova coluna no lado esquerdo da tarefa.
Nota: O cálculo dos valores é feito element_wise. Isso significa que todos os valores na coluna fornecida são multiplicados

pelo valor 1,882 de uma só vez. Você não precisa usar um loop para iterar cada uma das linhas!
Quero verificar a relação dos valores em Paris versus Antuérpia e salvar o resultado em uma nova coluna
Em [6]: qualidade do ar["ratio_paris_antwerp"] = (

...: qualidade do ar["estação_paris"] / qualidade do ar["estação_antuérpia"]
... :)
...:
Fora[7]:
estação_antuérpia estação_paris estação_londres london_mg_per_cubicÿ
ÿÿ ratio_paris_antuérpia
data hora ÿ
ÿÿ
07/05/2019 02:00:00 NaN NaN NaN 23,0 43.286ÿ

ÿÿ
07/05/2019 03:00:00 0,495050 50,5 25,0 19,0 35.758ÿ

ÿÿ
07/05/2019 04:00:00 0,615556 45,0 27,7 19,0 35.758ÿ

ÿÿ
07/05/2019 05:00:00 NaN 50,4 16,0 30.112ÿ

ÿÿ NaN
07/05/2019 06:00:00 NaN 61,9 NaN NaNÿ
ÿÿ NaN
O cálculo é novamente elemento a elemento, portanto / é aplicado aos valores em cada linha.
Além disso, outros operadores matemáticos (+, -, \*, /) ou operadores lógicos (<, >, =,. . . ) funcionam em termos de elementos. Este último foi
já usado no tutorial de dados de subconjunto para filtrar linhas de uma tabela usando uma expressão condicional.
Se precisar de uma lógica mais avançada, você pode usar código Python arbitrário via apply().
Quero renomear as colunas de dados para os identificadores de estação correspondentes usados pelo openAQ
Em [8]: air_quality_renamed = air_quality.rename(

...: colunas={
...: "estação_antuérpia": "BETR801",
...: "estação_paris": "FR04014",
...: "station_london": "Londres Westminster",
...: }
... :)
...:
Em [9]: air_quality_renamed.head()
Fora[9]:
BETR801 FR04014 Londres Westminster london_mg_per_cubic ratio_
ÿÿparis_antuérpia
data hora ÿ
ÿÿ
07/05/2019 02:00:00 NaN NaN 23,0 43.286 ÿ
ÿÿ NaN
07/05/2019 03:00:00 50,5 25,0 19,0 35.758 ÿ
ÿÿ 0,495050 (continua na próxima página)
1.4. Tutoriais 35
07/05/2019 04:00:00 45,0 27,7 19,0 35.758 ÿ
ÿÿ 0,615556
07/05/2019 05:00:00 NaN 50,4 16,0 30.112 ÿ
ÿÿ NaN
07/05/2019 06:00:00 NaN 61,9 NaN NaN ÿ
ÿÿ NaN
A função rename() pode ser usada para rótulos de linha e rótulos de coluna. Forneça um dicionário com as chaves do
nomes atuais e os valores dos novos nomes para atualizar os nomes correspondentes.
O mapeamento não deve ser restrito apenas a nomes fixos, mas também pode ser uma função de mapeamento. Por exemplo,
a conversão dos nomes das colunas em letras minúsculas também pode ser feita usando uma função:
Em [10]: air_quality_renamed = air_quality_renamed.rename(columns=str.lower)
Em [11]: air_quality_renamed.head()
Fora[11]:
betr801 fr04014 Londres westminster london_mg_per_cubic ratio_
ÿÿparis_antuérpia
data hora ÿ
ÿÿ
07/05/2019 02:00:00 NaN NaN 23,0 43.286 ÿ
ÿÿ NaN
07/05/2019 03:00:00 50,5 25,0 19,0 35.758 ÿ
ÿÿ 0,495050
07/05/2019 04:00:00 45,0 27,7 19,0 35.758 ÿ
ÿÿ 0,615556
07/05/2019 05:00:00 NaN 50,4 16,0 30.112 ÿ
ÿÿ NaN
07/05/2019 06:00:00 NaN 61,9 NaN NaN ÿ
ÿÿ NaN
Detalhes sobre a renomeação de rótulos de colunas ou linhas são fornecidos na seção do guia do usuário sobre renomeação de rótulos.
• Crie uma nova coluna atribuindo a saída ao DataFrame com um novo nome de coluna entre [].
• As operações são realizadas elemento a elemento, sem necessidade de loop nas linhas.
• Use rename com um dicionário ou função para renomear rótulos de linhas ou nomes de colunas.
O guia do usuário contém uma seção separada sobre adição e exclusão de colunas.

Fora[3]:
Bilhete Parch 0 3 ÿÿmasculino ... 1 2 ÿÿfeminino ... 3 Tarifa Cabine Embarcada

ÿÿfeminino ... 3 1 0 Braund, Sr. ÿ
0 A/5 21171 7,2500 NaN 1 Cumings,

0 PC 17599 71.2833 C85 C

2 1 3 Heikkinen, Srta. ÿ
0 PÓS/O2. 3101282 7,9250 NaN S

4 1 1 Futrelle, Sra. Jacques Heath (Lily May Peel) ÿ
ÿÿfeminino ... 0 113803 53.1000 C123 S
4 5 0 3 Allen , Sr.
Como calcular estatísticas resumidas?
Agregando estatísticas
Qual é a idade média dos passageiros do Titanic?
Em [4]: titânico["Idade"].mean()
Saída[4]: 29.69911764705882
Diferentes estatísticas estão disponíveis e podem ser aplicadas a colunas com dados numéricos. As operações em geral excluem
dados ausentes e operam em linhas por padrão.
Qual é a idade média e o preço da passagem dos passageiros do Titanic?
Em [5]: titanic[["Idade", "Tarifa"]].median()

Fora[5]:
Tarifa 28.0000
por Idade 14.4542
tipo d: float64
A estatística aplicada a múltiplas colunas de um DataFrame (a seleção de duas colunas retorna um DataFrame, veja o
tutorial de dados de subconjunto) é calculado para cada coluna numérica.
1.4. Tutoriais 37
A estatística de agregação pode ser calculada para várias colunas ao mesmo tempo. Lembre-se da função de descrição
do primeiro tutorial?
Em [6]: titanic[["Idade", "Tarifa"]].describe()

Fora[6]:
Tarifa
Contagem de idade 714,000000 891,000000
significar 29.699118 32.204208
14.526497 49.693429
padrão 0,420000 0,000000
20.125000 7.910400
28.000000 14.454200
mínimo 25% 50%38,000000
75% 31,000000
máx. 80.000000 512.329200
Em vez das estatísticas predefinidas, podem ser definidas combinações específicas de estatísticas agregadas para determinadas colunas
usando o método DataFrame.agg() :
Em [7]: titanic.agg(
...: {
...: "Idade": ["min", "máx", "mediana", "inclinação"],
...: "Tarifa": ["min", "máx", "mediana", "média"],
...: }
... :)
...:
Fora[7]:
Tarifa
min Idade 0,420000 0,000000
máx. 80.000000 512.329200
mediana 28,000000 14,454200
inclinar 0,389108 NaN
significar NaN 32.204208
Detalhes sobre estatísticas descritivas são fornecidos na seção do guia do usuário sobre estatísticas descritivas.
Agregando estatísticas agrupadas por categoria
Qual é a idade média dos passageiros do sexo masculino e feminino do Titanic?
Em [8]: titânico[["Sexo", "Idade"]].groupby("Sexo").mean()

Fora[8]:
Idade
Sexo
feminino 27.915709
masculino 30.726645
Como nosso interesse é a idade média de cada gênero, primeiro é feita uma subseleção nessas duas colunas: titanic[["Sexo
", "Idade"]]. Em seguida, o método groupby() é aplicado na coluna Sexo para fazer um grupo por categoria. A média
a idade para cada sexo é calculada e retornada.
Calcular uma determinada estatística (por exemplo, idade média) para cada categoria em uma coluna (por exemplo, masculino/feminino na coluna Sexo) é uma tarefa
padrão comum. O método groupby é usado para suportar este tipo de operações. Mais geral, isso se enquadra no mais
padrão geral de divisão-aplicação-combinação:

• Divida os dados em grupos
• Aplicar uma função a cada grupo de forma independente
• Combine os resultados em uma estrutura de dados
As etapas de aplicar e combinar normalmente são feitas juntas no pandas.
No exemplo anterior, selecionamos explicitamente as 2 colunas primeiro. Caso contrário, o método da média é aplicado a cada coluna
contendo colunas numéricas:
Em [9]: titanic.groupby("Sexo").mean()
Fora[9]:
PassengerId sobreviveu Pclass Idade SibSp Parch Tarifa
Sexo
feminino 431,028662 0,742038 2,159236 27,915709 0,694268 0,649682 44,479818
masculino 454,147314 0,188908 2,389948 30,726645 0,429809 0,235702 25,523893
Não faz muito sentido obter o valor médio da Pclass. se estivermos interessados apenas na idade média
cada gênero, a seleção de colunas (colchetes retangulares [] como de costume) também é apoiada nos dados agrupados:
Em [10]: titanic.groupby("Sexo")["Idade"].mean()
Fora[10]:
Sexo
feminino 27.915709
masculino 30.726645
Nome: Idade, dtype: float64
Nota: A coluna Pclass contém dados numéricos, mas na verdade representa 3 categorias (ou fatores) com respectivamente
os rótulos '1', '2' e '3'. Calcular estatísticas sobre estes não faz muito sentido. Portanto, o pandas fornece uma
Tipo de dados categórico para lidar com esse tipo de dados. Mais informações são fornecidas no guia do usuário Dados categóricos
seção.
Qual é o preço médio da passagem para cada uma das combinações de sexo e classe de cabine?
Em [11]: titanic.groupby(["Sexo", "Pclass"])["Fare"].mean()

Fora[11]:
Sexo Pclass
feminino 1 106.125798
2 21.970121
3 16.118810
macho 1 67.226127
2 19.741782
3 12.661633
Nome: Tarifa, dtype: float64
O agrupamento pode ser feito por várias colunas ao mesmo tempo. Forneça os nomes das colunas como uma lista para groupby()
método.
Uma descrição completa da abordagem split-apply-combine é fornecida na seção do guia do usuário sobre operações groupby.
1.4. Tutoriais 39
Contar o número de registros por categoria
Qual é o número de passageiros em cada uma das classes de cabine?
Em [12]: titanic["Pclass"].value_counts()
Saída[12]:
3 491 1 216
2 184 Nome:
Pclass,
dtype: int64
O método value_counts() conta o número de registros para cada categoria em uma coluna.
A função é um atalho, pois na verdade é uma operação de agrupamento em combinação com a contagem do número de registros dentro de
cada grupo:
Em [13]: titanic.groupby("Pclass")["Pclass"].count()
Fora[13]:
Pclass
1 216
2 184
3 491
Nome: Pclass, dtype: int64
Nota: Tamanho e contagem podem ser usados em combinação com groupby. Enquanto size inclui valores NaN e fornece apenas o número
de linhas (tamanho da tabela), count exclui os valores ausentes. No método value_counts, use o argumento dropna para incluir ou excluir os
valores NaN.
O guia do usuário tem uma seção dedicada sobre value_counts , veja a página sobre discretização.
• As estatísticas de agregação podem ser calculadas em colunas ou linhas inteiras
• groupby fornece o poder do padrão split-apply-combine
• value_counts é um atalho conveniente para contar o número de entradas em cada categoria de uma variável
Uma descrição completa da abordagem split-apply-combine é fornecida nas páginas do guia do usuário sobre operações groupby.

Fora[3]:
Bilhete Parch 0 3 ÿÿmasculino ... 1 2 ÿÿfeminino ... 2 3 Tarifa Cabine Embarcada

ÿÿfeminino ... 3 1 0 Braund, Sr. ÿ
0 A/5 21171 7,2500 NaN 1 Cumings,

0 PC 17599 71.2833 C85 C

1 3 Heikkinen, Srta. ÿ
0 PÓS/O2. 3101282 7,9250 NaN S

4 1 1 Futrelle, Sra. Jacques Heath (Lily May Peel) ÿ
ÿÿfeminino ... 0 113803 53.1000 C123 S
4 5 0 3 Allen , Sr.
Este tutorial usa dados de qualidade do ar sobre 2 e Material particulado inferior a 2,5 micrômetros, disponibilizado por
o openaq e o pacote py-openaq . O conjunto de dados air_quality_long.csv fornece as estações de medição e valores para
2 25
FR04014, BETR801 e London Westminster em Paris, Antuérpia e Londres, respectivamente.
O conjunto de dados de qualidade do ar possui as seguintes colunas:
• cidade: cidade onde o sensor é usado, Paris, Antuérpia ou Londres
• país: país onde o sensor é usado, FR, BE ou GB
• localização: o ID do sensor, FR04014, BETR801 ou London Westminster
• parâmetro: o parâmetro medido pelo sensor, seja 2 ou material particulado
• valor: o valor medido
• unidade: a unidade do parâmetro medido, neste caso 'µg/m3 '
e o índice do DataFrame é datetime, a data e hora da medição.
Nota: Os dados sobre a qualidade do ar são fornecidos numa chamada representação de dados de formato longo , com cada observação num
linha separada e cada variável uma coluna separada da tabela de dados. O formato longo/estreito também é conhecido como arrumado
formato de dados.
Em [4]: qualidade do ar = pd.read_csv(

...: "dados/air_quality_long.csv", index_col="date.utc", parse_dates=True
... :)
...:
1.4. Tutoriais 41
Fora[5]:
unidade de valor do parâmetro de localização do país da cidade
data.utc
18/06/2019 06:00:00+00:00 Antuérpia SEJA BETR801 pm25 18,0 µg/m3
Como remodelar o layout das tabelas?
Classificar linhas da tabela
Quero classificar os dados do Titanic de acordo com a idade dos passageiros.
Em [6]: titanic.sort_values(by="Idade").head()
Fora[6]:
PassengerId sobreviveu Pclass ÿÿ Bilhete Parch Nome Idade do sexo SibSpÿ
803 804 Tarifa Cabine Embarcada
3Tomás, Mestre. Assad Alexandre masculino 0,42 0ÿ
ÿÿ 1 1 2625 8,5167 NaN 756 1 1 C
755 250649 14,5000 NaN 2 Hamalainen, Mestre. Viljo masculino 0,67 1ÿ
ÿÿ 645 1 2666 19,2583 NaN S
644 3 Baclini, Srta. Eugenie feminino 0,75 2ÿ
ÿÿ 1 C
469 470 1 3 Baclini, Srta. Helene Barbara feminino 0,75 2ÿ
ÿÿ 1 2666 19,2583 NaN C
78 79 1 2 Caldwell, Mestre. Alden Gates masculino 0,83 0ÿ
ÿÿ 2 248738 29,0000 NaN S
Quero classificar os dados do Titanic de acordo com a classe da cabine e a idade em ordem decrescente.
Em [7]: titanic.sort_values(by=['Pclass', 'Age'], ascendente=False).head()

Fora[7]:
PassengerId sobreviveu à cabine de tarifa Nome Sexo Idade SibSp ÿ
ÿÿBilhete de Parca 851 Pclass embarcada
852 0 ÿÿ0 347060 7,7750 NaN 116 0 ÿÿ0 Svensson, Sr. Johan masculino 74,0 0 ÿ
370369 7,7500 NaN 280 281 0 ÿÿ0 3S

117ÿÿ0 326
336439 7,7500 NaN 483 Connors, Sr. Patrick masculino 70,5 0 ÿ
3Q
Duane, Sr. Frank masculino 65,0 0 ÿ
3Q
484 1 Turkula, Sra. (Hedwig) feminino 63,0 0 ÿ
4134 9,5875 NaN 327 0 3S
3 Nysveen, Sr. Johan Hansen masculino 61,0 S 0 ÿ
ÿÿ0 345364 6,2375 NaN
Com Series.sort_values(), as linhas da tabela são classificadas de acordo com a(s) coluna(s) definida(s). O índice irá
siga a ordem das linhas.
Mais detalhes sobre a classificação de tabelas são fornecidos na seção do guia de uso sobre classificação de dados.

Formato de tabela longa a larga
Vamos usar um pequeno subconjunto do conjunto de dados de qualidade do ar. Nós 2 dados e usar apenas as duas primeiras medições de
nos concentramos em cada local (ou seja, o chefe de cada grupo). O subconjunto de dados será chamado no2_subset
#filtro apenas para dados no2

Em [8]: no2 = air_quality[air_quality["parâmetro"] == "no2"]
# use 2 medidas (cabeça) para cada local (groupby)

Em [9]: no2_subset = no2.sort_index().groupby(["local"]).head(2)
Em [10]: no2_subset
Fora[10]:
cidade país unidade de valor do parâmetro de localização
data.utc
09/04/2019 01:00:00+00:00 Antuérpia 09/04/2019 SER BETR801 no2 22,5 µg/m3
01:00:00+00:00 Paris França FR04014 no2 24,4 µg/m3
09-04-2019 02:00:00+00:00 Londres GB Londres Westminster no2 67,0 µg/m3
09/04/2019 02:00:00+00:00 Antuérpia 09/04/2019 SER BETR801 no2 53,5 µg/m3
02:00:00+00:00 Paris França FR04014 no2 27,4 µg/m3
09-04-2019 03:00:00+00:00 Londres GB Londres Westminster no2 67,0 µg/m3
Quero os valores das três estações como colunas separadas, uma ao lado da outra
Em [11]: no2_subset.pivot(columns="local", valores="valor")

Fora[11]:
data de BETR801 FR04014 Londres Westminster
localização.utc
09/04/2019 01:00:00+00:00 09/04/2019 22,5 24,4 NaN
02:00:00+00:00 09/04/2019 53,5 27,4 67,0
03:00:00+00:00 NaN NaN 67,0
A função pivot() é puramente uma remodelagem dos dados: é necessário um único valor para cada combinação de índice/coluna.
Como o pandas suporta a plotagem de múltiplas colunas (veja o tutorial de plotagem) pronto para uso, a conversão de longo para largo
O formato de tabela permite a plotagem das diferentes séries temporais ao mesmo tempo:
Em [12]: no2.head()
Fora[12]:
unidade de valor do parâmetro de localização do país da cidade
data.utc
21/06/2019 00:00:00+00:00 Paris 20/06/2019 FR FR04014 no2 20,0 µg/m3
23:00:00+00:00 Paris 20/06/2019 22:00+00:00 FR FR04014 no2 21,8 µg/m3
Paris 20/06/2019 21:00:00+00:00 Paris FR FR04014 no2 26,5 µg/m3
FR FR04014 no2 24,9 µg/m3
FR FR04014 no2 21,4 µg/m3
Em [13]: no2.pivot(columns="local", valores="valor").plot()

Saída[13]: <AxesSubplot:xlabel='date.utc'>
1.4. Tutoriais 43
Nota: Quando o parâmetro index não é definido, o índice existente (rótulos de linha) é usado.
Para obter mais informações sobre pivot(), consulte a seção do guia do usuário sobre dinamização de objetos DataFrame.
Tabela dinâmica
Quero as concentrações médias para 2 e 2,5 em cada uma das estações em forma de tabela
Em [14]: air_quality.pivot_table(
....: valores="valor", index="localização", colunas="parâmetro", aggfunc="média"
....: )
....:
Fora[14]:
localização nº2 pm25
do parâmetro
BETR801 26.950920 23.169492
FR04014 29.374284 NaN
Londres Westminster 29.740050 13.443568
No caso de pivot(), os dados são apenas reorganizados. Quando vários valores precisam ser agregados (neste caso específico,

os valores em diferentes intervalos de tempo) pivot_table() pode ser usado, fornecendo uma função de agregação (por exemplo, média) sobre como
para combinar esses valores.
A tabela dinâmica é um conceito bem conhecido em software de planilha. Quando estiver interessado em colunas de resumo para cada variável
separadamente também, coloque o parâmetro margin como True:
Em [15]: air_quality.pivot_table(
....: valores = "valor",
....: índice="localização",
....: colunas = "parâmetro",
....: aggfunc = "média",
....: margens = Verdadeiro,
....: )
....:
Fora[15]:
localização nº2 pm25 Todos
do parâmetro
BETR801 26.950920 23.169492 24.982353
FR04014 29,374284 NaN 29,374284
Londres Westminster 29.740050 13.443568 21.491708
Todos 29.430316 14.386849 24.222743
Para obter mais informações sobre pivot_table(), consulte a seção do guia do usuário sobre tabelas dinâmicas.
Nota: Caso você esteja se perguntando, pivot_table() está diretamente vinculado a groupby(). O mesmo resultado pode ser
derivado do agrupamento em parâmetro e localização:
air_quality.groupby(["parâmetro", "localização"]).mean()
Dê uma olhada em groupby() em combinação com unstack() na seção do guia do usuário sobre como combinar estatísticas e groupby.
Formato largo a longo
Começando novamente a partir da tabela de grande formato criada na seção anterior:
Em [16]: no2_pivoted = no2.pivot(columns="location", values="value").reset_index()
Em [17]: no2_pivoted.head()
Fora[17]:
localização date.utc BETR801 FR04014 Londres Westminster
0 09-04-2019 01:00:00+00:00 22,5 24,4 NaN
1 09-04-2019 02:00:00+00:00 53,5 27.4 67,0
2 09/04/2019 03:00:00+00:00 09/04/2019 54,5 34,2 67,0
3 04:00:00+00:00 09/04/2019 05:00:00+00:00 34,5 48,5 41,0
4 46,5 59,5 41,0
Quero coletar toda a qualidade do ar 2 medições em uma única coluna (formato longo)
Em [18]: no_2 = no2_pivoted.melt(id_vars="date.utc")
1.4. Tutoriais 45
Em [19]: no_2.head()
Fora[19]:
valor de localização date.utc
0 09/04/2019 01:00:00+00:00 BETR801 22,5
1 2019-04-09 02:00:00+00:00 BETR801 53,5
2 09/04/2019 03:00:00+00:00 BETR801 54,5
3 09/04/2019 04:00:00+00:00 BETR801 34,5
4 09/04/2019 05:00:00+00:00 BETR801 46,5
O método pandas.melt() em um DataFrame converte a tabela de dados de formato amplo para formato longo. Os cabeçalhos das
colunas tornam-se os nomes das variáveis em uma coluna recém-criada.
A solução é a versão resumida de como aplicar pandas.melt(). O método irá fundir todas as colunas NÃO mencionadas em id_vars
em duas colunas: Uma coluna com os nomes dos cabeçalhos das colunas e uma coluna com os próprios valores.
A última coluna obtém por padrão o valor do nome.
O método pandas.melt() pode ser definido com mais detalhes:
Em [20]: no_2 = no2_pivoted.melt(

....: id_vars="date.utc",
....: value_vars=["BETR801", "FR04014", "London Westminster"], value_name="NO_2",
....: var_name="id_location",
....:
....: )
....:
Fora[21]:
data.utc id_location NO_2 BETR801 22,5
0 2019-04-09 01:00:00+00:00 1 2019-04-09 BETR801 53,5
02:00:00+00:00 2 2019-04-09 03:00:00+00:00 BETR801 54,5
3 2019-04- 09 04:00:00+00:00 4 2019-04-09 BETR801 34,5
05:00:00+00:00 BETR801 46,5
O resultado é o mesmo, mas definido com mais detalhes:
• value_vars define explicitamente quais colunas devem ser fundidas
• value_name fornece um nome de coluna personalizado para a coluna de valores em vez do nome de coluna padrão value
• var_name fornece um nome de coluna personalizado para a coluna que coleta os nomes dos cabeçalhos das colunas. Caso contrário isto
leva o nome do índice ou uma variável padrão
Portanto, os argumentos nome_valor e nome_var são apenas nomes definidos pelo usuário para as duas colunas geradas. As
colunas a serem fundidas são definidas por id_vars e value_vars.
A conversão do formato largo para o formato longo com pandas.melt() é explicada na seção do guia do usuário sobre remodelagem por fusão.
• A classificação por uma ou mais colunas é suportada por sort_values
• A função pivot é puramente uma reestruturação dos dados, pivot_table suporta agregações
• O reverso do pivô (formato longo para largo) é fundido (formato largo para longo)
Uma visão geral completa está disponível no guia do usuário nas páginas sobre remodelagem e rotação.

Para este tutorial, os dados de qualidade do ar 2 é usado, disponibilizado pelo openaq e baixado usando o py-openaq
sobre package.
O conjunto de dados air_quality_no2_long.csv fornece 2 valores para as estações de medição FR04014, BETR801
Londres e Westminster em Paris, Antuérpia e Londres, respectivamente.
Em [2]: air_quality_no2 = pd.read_csv("data/air_quality_no2_long.csv",

...: parse_dates=Verdadeiro)
...:
Em [3]: air_quality_no2 = air_quality_no2[["date.utc", "location",

...: "parâmetro", "valor"]]
...:
Em [4]: air_quality_no2.head()
Fora[4]:
valor do parâmetro de localização date.utc
0 21/06/2019 00:00:00+00:00 FR04014 no2 20,0
1 20/06/2019 23:00:00+00:00 FR04014 nº 2 21,8
2 20/06/2019 22:00:00+00:00 FR04014 nº2 26,5
3 20/06/2019 21:00:00+00:00 FR04014 nº2 24,9
4 20/06/2019 20:00:00+00:00 FR04014 nº 2 21,4
Para este tutorial são utilizados dados de qualidade do ar sobre material particulado menor que 2,5 micrômetros, disponibilizados pela openaq
e baixado usando o pacote py-openaq .
O conjunto de dados air_quality_pm25_long.csv fornece 25 valores para as estações de medição FR04014, BETR801
Londres e Westminster em Paris, Antuérpia e Londres, respectivamente.
Em [5]: qualidade_do_ar_pm25 = pd.read_csv("dados/qualidade_do_ar_pm25_long.csv",

...: parse_dates=Verdadeiro)
...:
Em [6]: air_quality_pm25 = air_quality_pm25[["date.utc", "location",

...: "parâmetro", "valor"]]
...:
Em [7]: air_quality_pm25.head()
Fora[7]:
0 2019-06-18 06:00:00+00:00 BETR801 pm25 18.0
17/06/2019 08:00:00+00:00 BETR801 pm25 6,5
2 17/06/2019 07:00:00+00:00 BETR801 pm25 18,5
3 17/06/2019 06:00:00+00:00 BETR801 pm25 16,0
4 17/06/2019 05:00:00+00:00 BETR801 pm25 7,5
1.4. Tutoriais 47
Como combinar dados de várias tabelas?
Concatenando objetos
Quero combinar as medidas de 2 e 25, duas tabelas com estrutura semelhante, em uma única tabela
Em [8]: qualidade_do_ar = pd.concat([qualidade_do_ar_pm25, qualidade_do_no2], eixo=0)
Fora[9]:
0 2019-06-18 06:00:00+00:00 BETR801 pm25 18.0
17/06/2019 08:00:00+00:00 BETR801 pm25 6,5
2 17/06/2019 07:00:00+00:00 BETR801 pm25 18,5
3 17/06/2019 06:00:00+00:00 BETR801 pm25 16,0
4 17/06/2019 05:00:00+00:00 BETR801 pm25 7,5
A função concat() executa operações de concatenação de múltiplas tabelas ao longo de um dos eixos (linha ou linha).
coluna).
Por padrão, a concatenação ocorre ao longo do eixo 0, portanto a tabela resultante combina as linhas das tabelas de entrada. Vamos verificar o
formato do original e das tabelas concatenadas para verificar a operação:
Em [10]: print('Forma da tabela air_quality_pm25: ', air_quality_pm25.shape)

Formato da tabela air_quality_pm25: (1110, 4)
Em [11]: print('Forma da tabela air_quality_no2: ', air_quality_no2.shape)

Formato da tabela air_quality_no2: (2068, 4)
Em [12]: print('Forma da tabela air_quality resultante: ', air_quality.shape)

Formato da tabela air_quality resultante: (3178, 4)
Portanto, a tabela resultante tem 3.178 = 1.110 + 2.068 linhas.
Nota: O argumento axis retornará em vários métodos pandas que podem ser aplicados ao longo de um eixo. Um quadro de dados
tem dois eixos correspondentes: o primeiro correndo verticalmente para baixo nas linhas (eixo 0) e o segundo correndo
horizontalmente nas colunas (eixo 1). A maioria das operações como concatenação ou estatísticas resumidas são por padrão entre linhas
(eixo 0), mas também pode ser aplicado em colunas.
A classificação da tabela pelas informações de data e hora ilustra também a combinação de ambas as tabelas, com o parâmetro
coluna que define a origem da tabela (no2 da tabela air_quality_no2 ou pm25 da tabela
qualidade_do_ar_pm25):
Em [13]: qualidade_do_ar = qualidade_do_ar.sort_values("data.utc")
Fora[14]:
data.utc valor do parâmetro de localização
2067 2019-05-07 01:00:00+00:00 Londres Westminster nº2 23,0
1003 07-05-2019 01:00:00+00:00 FR04014 nº2 25,0
100 07-05-2019 01:00:00+00:00 BETR801 pm25 12,5


1098 07-05-2019 01:00:00+00:00 BETR801 nº2 50,5
1109 2019-05-07 01:00:00+00:00 Londres Westminster pm25 8,0
Neste exemplo específico, a coluna de parâmetros fornecida pelos dados garante que cada uma das tabelas originais possa ser
identificado. Isso não é sempre o caso. a função concat fornece uma solução conveniente com o argumento de chaves,
adicionando um índice de linha adicional (hierárquico). Por exemplo:
Em [15]: qualidade_do_ar = pd.concat([qualidade_do_ar_pm25, qualidade_do_no2], chaves=["PM25", "NO2

ÿÿ"])
Em [16]: air_quality_.head()
Fora[16]:
PM25 0 2019-06-18 06:00:00+00:00 BETR801 pm25 18.0
17/06/2019 08:00:00+00:00 BETR801 pm25 6,5
2 17/06/2019 07:00:00+00:00 BETR801 pm25 18,5
3 17/06/2019 06:00:00+00:00 BETR801 pm25 16,0
4 17/06/2019 05:00:00+00:00 BETR801 pm25 7,5
Nota: A existência de vários índices de linha/coluna ao mesmo tempo não foi mencionada nestes tutoriais.
A indexação hierárquica ou MultiIndex é um recurso avançado e poderoso do pandas para analisar dados de dimensões superiores.
A indexação múltipla está fora do escopo desta introdução do pandas. Por enquanto, lembre-se que a função reset_index
pode ser usado para converter qualquer nível de um índice em uma coluna, por exemplo, air_quality.reset_index(level=0)
Sinta-se à vontade para mergulhar no mundo da indexação múltipla na seção do guia do usuário sobre indexação avançada.
Mais opções sobre concatenação de tabelas (linha e coluna) e como concat pode ser usado para definir a lógica (união ou
interseção) dos índices nos outros eixos é fornecida na seção sobre concatenação de objetos.
Unir tabelas usando um identificador comum
Adicione as coordenadas da estação, fornecidas pela tabela de metadados das estações, às linhas correspondentes nas medições
mesa.
Atenção: As coordenadas da estação de medição da qualidade do ar são armazenadas em um arquivo de dados air_quality_stations.csv,
baixado usando o pacote py-openaq .
Em [17]: estações_coord = pd.read_csv("dados/air_quality_stations.csv")
Em [18]: estações_coord.head()
Fora[18]:
coordenadas de localização.coordenadas de latitude.longitude
0 BELAL01 51.23619 4.38522
1BELHB23 51.17030 4.34100
2BELLD01 51.10998 5.00486
3 BELLD02 51.12038 5.02155
4BELR833 51.32766 4.36226
1.4. Tutoriais 49
Nota: As estações usadas neste exemplo (FR04014, BETR801 e London Westminster) são apenas três entradas alistadas
na tabela de metadados. Queremos apenas adicionar as coordenadas destes três à tabela de medidas, cada uma no
linhas correspondentes da tabela air_quality.
Fora[19]:
data.utc valor do parâmetro de localização
2067 07-05-2019 01:00:00+00:00 Londres Westminster 1003 07-05-2019 nº2 23,0
01:00:00+00:00 FR04014 nº2 25,0
100 2019-05-07 01:00:00+00:00 BETR801 pm25 12,5
1098 07/05/2019 01:00:00+00:00 BETR801 nº2 50,5
1109 2019-05-07 01:00:00+00:00 Londres Westminster pm25 8,0
Em [20]: qualidade_do_ar = pd.merge(qualidade_do_ar, estações_coord, how="left", on="location")
Fora[21]:
data.utc valor do parâmetro de localização coordenadas.latitude ÿ
ÿÿcoordenadas.longitude
0 2019-05-07 01:00:00+00:00 Londres Westminster nº2 23,0 51.49467 ÿ
ÿÿ -0,13193
1 07/05/2019 01:00:00+00:00 2.39390 FR04014 nº2 25,0 48.83724 ÿ
ÿÿ
2 07/05/2019 01:00:00+00:00 2.39390 FR04014 nº2 25,0 48.83722 ÿ
ÿÿ
3 07/05/2019 01:00:00+00:00 4.43182 BETR801 pm25 12,5 51.20966 ÿ
ÿÿ
4 07/05/2019 01:00:00+00:00 4.43182 BETR801 nº2 50,5 51.20966 ÿ
ÿÿ
Usando a função merge() , para cada uma das linhas da tabela air_quality, as coordenadas correspondentes são adicionadas
da tabela air_quality_stations_coord. Ambas as tabelas têm em comum a localização da coluna que é usada como
uma chave para combinar as informações. Ao escolher a junção esquerda, apenas os locais disponíveis no air_quality (esquerda)
tabela, ou seja, FR04014, BETR801 e London Westminster, terminam na tabela resultante. A função de mesclagem suporta
múltiplas opções de junção semelhantes às operações de estilo de banco de dados.
Adicione a descrição completa e o nome do parâmetro, fornecidos pela tabela de metadados dos parâmetros, à tabela de medidas
Atenção: Os metadados dos parâmetros de qualidade do ar são armazenados em um arquivo de dados air_quality_parameters.csv,
baixado usando o pacote py-openaq .
Em [22]: air_quality_parameters = pd.read_csv("data/air_quality_parameters.csv")
Em [23]: air_quality_parameters.head()
Fora[23]:
id descrição nome
0 a.c. Carbono Negro AC
1 co Monóxido de carbono CO
2 não2 3 Dióxido de nitrogênio NO2
o3 Ozônio O3

16h10 Material particulado com menos de 10 micrômetros em... PM10
Em [24]: air_quality = pd.merge(air_quality, air_quality_parameters,

....: como='esquerda', left_on='parâmetro', right_on='id')
....:
Fora[25]:
parâmetro de localização date.utc ... descrição nome eu ia ÿ
ÿÿ
0 2019-05-07 01:00:00+00:00 Londres Westminster não2 ... não2 ÿ
ÿÿ Dióxido de nitrogênio 1 NO2

07/05/2019 01:00:00+00:00 FR04014 não2 ... não2 ÿ

2019-05-07 01:00:00+00:00 FR04014 não2 ... não2 ÿ

2019-05-07 01:00:00+00:00 BETR801 pm25 ... pm25 Partículasÿ
ÿÿmatéria menor que 2,5 micrômetros em... PM2,5
4 07/05/2019 01:00:00+00:00 BETR801 não2 ... não2 ÿ
ÿÿ Dióxido de nitrogênio NO2
Em comparação com o exemplo anterior, não existe um nome de coluna comum. No entanto, a coluna de parâmetro no
A tabela air_quality e a coluna id em air_quality_parameters_name fornecem a variável medida em um formato comum. Os argumentos left_on e
right_on são usados aqui (em vez de apenas on) para fazer o link
entre as duas tabelas.
pandas também suporta junções internas, externas e direitas. Mais informações sobre junção/mesclagem de tabelas são fornecidas no usuário
seção do guia sobre mesclagem de tabelas no estilo de banco de dados. Ou dê uma olhada na comparação com a página SQL .
• Várias tabelas podem ser concatenadas tanto em colunas quanto em linhas usando a função concat.
• Para mesclar/juntar tabelas semelhantes a bancos de dados, use a função de mesclagem.
Consulte o guia do usuário para obter uma descrição completa dos vários recursos para combinar tabelas de dados.
Para este tutorial, dados de qualidade do ar 2 e É utilizado material particulado inferior a 2,5 micrômetros, disponibilizado
obtidos por openaq e baixados usando o pacote py-openaq . O conjunto de dados air_quality_no2_long.csv" fornece valores para as 2
estações de medição FR04014, BETR801 e London Westminster em respectivamente Paris, Antuérpia e
Londres.
Em [3]: qualidade do ar = pd.read_csv("dados/qualidade_do_no2_long.csv")
Em [4]: air_quality = air_quality.rename(columns={"date.utc": "datetime"})
Fora[5]:
cidade país 0 Paris unidade de valor do parâmetro de localização de data e hora
FR 2019-06-21 00:00:00+00:00 FR04014 no2 20,0 µg/m3
1.4. Tutoriais 51
1Paris FR 2019-06-20 23:00:00+00:00 FR04014 no2 21,8 µg/m3

2Paris FR 2019-06-20 22:00:00+00:00 FR04014 no2 26,5 µg/m3
3Paris FR 2019-06-20 21:00:00+00:00 FR04014 no2 24,9 µg/m3
4Paris FR 2019-06-20 20:00:00+00:00 FR04014 no2 21,4 µg/m3
Em [6]: air_quality.city.unique()
Out[6]: array(['Paris', 'Antuérpia', 'Londres'], dtype=objeto)
Como lidar com dados de séries temporais com facilidade?
Usando propriedades de data e hora do pandas
Quero trabalhar com as datas na coluna datetime como objetos datetime em vez de texto simples
Em [7]: air_quality["datetime"] = pd.to_datetime(air_quality["datetime"])
Em [8]: qualidade_do_ar["datetime"]
Fora[8]:
0 21/06/2019 00:00:00+00:00
1 20/06/2019 23:00:00+00:00
2 20/06/2019 22:00:00+00:00
3 20/06/2019 21:00:00+00:00
4 20/06/2019 20:00:00+00:00
...
2063 2019-05-07 06:00:00+00:00
2064 2019-05-07 04:00:00+00:00
2065 2019-05-07 03:00:00+00:00
2066 2019-05-07 02:00:00+00:00
2067 2019-05-07 01:00:00+00:00
Nome: datetime, Duração: 2068, dtype: datetime64[ns, UTC]
Inicialmente, os valores em datetime são cadeias de caracteres e não fornecem nenhuma operação de data e hora (por exemplo, extrair o ano,
dia da semana,. . . ). Ao aplicar a função to_datetime, o pandas interpreta as strings e as converte em datetime
(ou seja, objetos datetime64[ns, UTC]). Nos pandas, chamamos esses objetos de data e hora semelhantes a datetime.datetime de
a biblioteca padrão como pandas.Timestamp.
Nota: Como muitos conjuntos de dados contêm informações de data e hora em uma das colunas, a função de entrada do pandas como
pandas.read_csv() e pandas.read_json() podem fazer a transformação em datas ao ler os dados usando
o parâmetro parse_dates com uma lista das colunas para ler como Timestamp:
pd.read_csv("../data/air_quality_no2_long.csv", parse_dates=["datahora"])
Por que esses objetos pandas.Timestamp são úteis? Vamos ilustrar o valor acrescentado com alguns exemplos de casos.
Qual é a data de início e término do conjunto de dados de série temporal com o qual estamos trabalhando?
Em [9]: air_quality["datetime"].min(), air_quality["datetime"].max()

Fora[9]:
(Carimbo de data/hora ('2019-05-07 01:00:00+0000', tz='UTC'),
Carimbo de data/hora ('21/06/2019 00:00:00+0000', tz='UTC'))

Usar pandas.Timestamp para data e hora nos permite calcular com informações de data e torná-las comparáveis.
Portanto, podemos usar isso para obter a duração de nossa série temporal:
Em [10]: air_quality["datetime"].max() - air_quality["datetime"].min()

Saída[10]: Timedelta('44 dias 23:00:00')
O resultado é um objeto pandas.Timedelta , semelhante a datetime.timedelta da biblioteca Python padrão e

definindo uma duração de tempo.
Os vários conceitos de tempo suportados pelo pandas são explicados na seção do guia do usuário sobre conceitos relacionados ao tempo.
Quero adicionar uma nova coluna ao DataFrame contendo apenas o mês da medição
Em [11]: qualidade_do_ar["mês"] = qualidade_do_ar["datahora"].dt.mês
Fora[12]:
cidade país 0 data e hora local parâmetro valor unidade mês
Paris FR 2019-06-21 00:00:00+00:00 FR04014 no2 20,0 µg/m3 6
1Paris FR 2019-06-20 23:00:00+00:00 FR04014 no2 21,8 µg/m3 no2 6
2Paris FR 2019-06-20 22:00:00+00:00 FR04014 26,5 µg/m3 no2 24,9 6
3Paris FR 2019-06-20 21:00:00+00:00 FR04014 µg/m3 no2 21,4 µg/m3 6
4Paris FR 2019-06-20 20:00:00+00:00 FR04014 6
Ao usar objetos Timestamp para datas, muitas propriedades relacionadas ao tempo são fornecidas pelos pandas. Por exemplo o mês,
mas também ano, semana do ano, trimestre. . . Todas essas propriedades são acessíveis pelo acessador dt.
Uma visão geral das propriedades de data existentes é fornecida na tabela de visão geral dos componentes de hora e data. Mais detalhes
sobre o acessador dt para retornar propriedades semelhantes a data e hora são explicadas em uma seção dedicada no acessador dt.
Qual é a média 2 concentração para cada dia da semana para cada um dos locais de medição?
Em [13]: air_quality.groupby(
....: [air_quality["datetime"].dt.weekday, "location"])["value"].mean()
....:
Fora[13]:
localização datahora
0 BETR801 27.875000
FR04014 24.856250
Londres Westminster 23.969697
1 BETR801 22.214286
FR04014 30.999359
...
5 FR04014 25.266154
6 BETR801 21.896552
FR04014 23.274306
Nome: valor, Comprimento: 21, dtype: float64
Lembra do padrão split-apply-combine fornecido por groupby no tutorial sobre cálculo estatístico? Aqui nós
deseja calcular uma determinada estatística (por exemplo, média 2) para cada dia da semana e para cada local de medição. Agrupar
nos dias de semana, usamos a propriedade datetime weekday (com segunda=0 e domingo=6) do pandas Timestamp, que é
também acessível pelo acessador dt. O agrupamento em locais e dias da semana pode ser feito para dividir o cálculo
da média em cada uma dessas combinações.
1.4. Tutoriais 53
Perigo: Como estamos trabalhando com uma série temporal muito curta nestes exemplos, a análise não fornece uma
resultado representativo a longo prazo!
Trace o padrão 2 típico durante o dia de nossa série temporal de todas as estações juntas. Em outras palavras, qual é o
valor médio para cada hora do dia?
Em [14]: fig, axs = plt.subplots(figsize=(12, 4))
Em [15]: air_quality.groupby(air_quality["datetime"].dt.hour)["value"].mean().plot(
....: kind='bar', rot=0, ax=axs
....: )
....:
Em [16]: plt.xlabel("Hora do dia"); # rótulo x personalizado usando matplotlib
Em [17]: plt.ylabel("$NO_2 (µg/m^3)$");
Semelhante ao caso anterior, queremos calcular uma determinada estatística (por exemplo, média 2) para cada hora do dia e podemos
use a abordagem dividir-aplicar-combinar novamente. Para este caso, usamos a propriedade datetime hora do pandas Timestamp,
que também é acessível pelo acessador dt.
Datahora como índice
No tutorial sobre remodelagem, pivot() foi introduzido para remodelar a tabela de dados com cada um dos locais de medição
como uma coluna separada:
Em [18]: no_2 = air_quality.pivot(index="datetime", colunas="local", valores="valor")
Fora[19]:
localização BETR801 FR04014 Londres Westminster
datahora
07-05-2019 01:00:00+00:00 07-05-2019 50,5 25,0 23,0
02:00:00+00:00 07-05-2019 45,0 27,7 19,0
03:00:00+00:00 07-05-2019 04:00 NaN 50,4 19,0
:00+00:00 07/05/2019 05:00:00+00:00 NaN 61,9 16,0
NaN 72,4 NaN

Nota: Ao dinamizar os dados, as informações de data e hora tornaram-se o índice da tabela. Em geral, definir uma coluna
como índice pode ser obtido pela função set_index.
Trabalhar com um índice de data e hora (ou seja, DatetimeIndex) fornece funcionalidades poderosas. Por exemplo, não precisamos do
acessador dt para obter as propriedades da série temporal, mas temos essas propriedades disponíveis diretamente no índice:
Em [20]: no_2.index.year, no_2.index.weekday Out[20]:
(Int64Index([2019, 2019, 2019, 2019, 2019, 2019, 2019, 2019, 2019, 2019,
...
2019, 2019, 2019, 2019, 2019, 2019, 2019, 2019, 2019, 2019],
dtype='int64', nome='datahora', comprimento=1033),
Int64Index([1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
...
3, 3, 3, 3, 3, 3, 3, 3, 3, 4], dtype='int64',
nome='datahora', comprimento=1033))
Algumas outras vantagens são a subconjunto conveniente do período de tempo ou a escala de tempo adaptada nas parcelas. Vamos aplicar isso em
nossos dados.
Crie um enredo do 2 valores nas diferentes estações de 20 de maio até final de 21 de maio
Em [21]: no_2["2019/05/20":"2019/05/21"].plot();
1.4. Tutoriais 55
Ao fornecer uma string que analisa uma data e hora, um subconjunto específico de dados pode ser selecionado em um DatetimeIndex.
Mais informações sobre o DatetimeIndex e o fatiamento usando strings são fornecidas na seção sobre séries temporais
indexação.
Reamostrar uma série temporal para outra frequência
Agregue os valores atuais da série temporal horária ao valor máximo mensal em cada uma das estações.
Em [22]: mensal_max = no_2.resample("M").max()
Em [23]: mensal_max
Fora[23]:
localização BETR801 FR04014 Londres Westminster
datahora
31/05/2019 00:00:00+00:00 30/06/2019 74,5 97,0 97,0
00:00:00+00:00 52,5 84,7 52,0
Um método muito poderoso em dados de série temporal com um índice de data e hora é a capacidade de reamostrar() série temporal para outra
frequência (por exemplo, conversão de dados secundários em dados de 5 minutos).
O método resample() é semelhante a uma operação groupby:
• fornece um agrupamento baseado no tempo, usando uma string (por exemplo, M, 5H,. . . ) que define a frequência alvo
• requer uma função de agregação como média, máximo. . .
Uma visão geral dos aliases usados para definir frequências de séries temporais é fornecida na tabela de visão geral dos aliases de deslocamento.
Quando definida, a frequência da série temporal é fornecida pelo atributo freq:
Em [24]: mensal_max.index.freq
Saída[24]: <FimMês>
Faça um gráfico do valor da média diária 2 em cada uma das estações.
Em [25]: no_2.resample("D").mean().plot(style="-o", figsize=(10, 5));

Mais detalhes sobre o poder da reamostragem de séries temporais são fornecidos na seção do guia do usuário sobre reamostragem.
• Strings de data válidas podem ser convertidas em objetos datetime usando a função to_datetime ou como parte de funções de leitura.
• Objetos de data e hora em pandas suportam cálculos, operações lógicas e propriedades convenientes relacionadas a datas usando
o acessador dt.
• Um DatetimeIndex contém essas propriedades relacionadas à data e oferece suporte ao fatiamento conveniente.
• A reamostragem é um método poderoso para alterar a frequência de uma série temporal.
Uma visão geral completa das séries temporais é fornecida nas páginas sobre séries temporais e funcionalidade de data.
1.4. Tutoriais 57
Fora[3]:

ÿÿmasculino ... 0 A/5 21171 7,2500 NaN 1 Cumings, S

1 2 ÿÿfeminino ... 2 3 1 Sra. John Bradley (Florence Briggs Th... ÿ
ÿÿfeminino ... 3 4 0 PC 17599 71.2833 C85 C

ÿÿfeminino ... 4 1 3 Heikkinen, Srta. ÿ
ÿÿmasculino ... 0 PÓS/O2. 3101282 7,9250 NaN S

1 Futrelle, Sra. Jacques Heath (Lily May Peel) ÿ
0 1 113803 53.1000 C123 3 S
5 0 Allen , Sr.
0 373450 8,0500NaN S
Como manipular dados textuais?
Deixe todos os caracteres do nome em letras minúsculas.
Em [4]: titanic["Nome"].str.lower()
Fora[4]:
0 braund, Sr. Owen Harris
1 cumings, Sra. john bradley (florence briggs...
2 Heikkinen, senhorita. Laina
3 Futrelle, Sra. Jacques Heath (lírio pode descascar)
4 Allen, Sr. William Henrique
...
886 montvila, rev. juozas
887 Graham, senhorita. Margaret Edith
888 Johnston, senhorita. Catarina Helena "Carrie"
889 behr, Sr. Karl Howell
890 dooley, Sr. Patrício
Nome: Nome, Comprimento: 891, dtype: objeto
Para deixar cada uma das strings na coluna Nome em minúsculas, selecione a coluna Nome (veja o tutorial sobre seleção de
data), adicione o acessador str e aplique o método inferior. Como tal, cada uma das strings é convertida elemento a elemento.
Semelhante aos objetos datetime no tutorial de série temporal com um acessador dt, vários métodos de string especializados são
disponível ao usar o acessador str. Esses métodos têm, em geral, nomes correspondentes com os equivalentes integrados
métodos de string para elementos únicos, mas são aplicados elemento a elemento (lembra dos cálculos elemento a elemento?) em cada um dos
os valores das colunas.
Crie uma nova coluna Sobrenome que contenha o sobrenome dos passageiros extraindo a parte antes da vírgula.
Em [5]: titanic["Nome"].str.split(",")
Fora[5]:
0 [Braund, Sr.
1 [Cumings, Sra. John Bradley (Florence Briggs ...
2 [Heikkinen, Srta. Laina]


3 [Futrelle, Sra. Jacques Heath (Lily May Peel)]
4 [Allen, Sr. William Henry]
...
886 [Montvila, Rev. Juozas]
887 [Graham, Srta. Margaret Edith]
888 [Johnston, Srta. Catherine Helen "Carrie"]
889 [Behr, Sr.
890 [Dooley, Sr.
Nome: Nome, Comprimento: 891, dtype: objeto
Usando o método Series.str.split() , cada um dos valores é retornado como uma lista de 2 elementos. O primeiro elemento é
a parte antes da vírgula e o segundo elemento é a parte depois da vírgula.
Em [6]: titanic["Sobrenome"] = titanic["Nome"].str.split(",").str.get(0)
Em [7]: titânico["Sobrenome"]
Fora[7]:
0 Braund
1 Cumings
2 Heikkinen
3 Futrelle
4 Allen
...
886 Montvila
887 Graham
888 Johnston
889 Behr
890 Dooley
Nome: Sobrenome, Comprimento: 891, dtype: objeto
Como estamos interessados apenas na primeira parte que representa o sobrenome (elemento 0), podemos novamente usar o acessador str e
aplique Series.str.get() para extrair a parte relevante. Na verdade, essas funções de string podem ser concatenadas para combinar
múltiplas funções ao mesmo tempo!
Mais informações sobre como extrair partes de strings estão disponíveis na seção do guia do usuário sobre divisão e substituição de strings.
Extraia os dados dos passageiros sobre as condessas a bordo do Titanic.
Em [8]: titanic["Nome"].str.contains("Condessa")
Fora[8]:
0 Falso
1 Falso
2 Falso
3 Falso
4 Falso
...
886 Falso
887 Falso
888 Falso
889 Falso
890 Falso
Nome: Nome, Comprimento: 891, dtype: bool
1.4. Tutoriais 59
Em [9]: titanic[titanic["Nome"].str.contains("Condessa")]
Fora[9]:
PassengerId Sobreviveu Pclass ÿÿ Sexo ... Nome ÿ
Bilhete Tarifa Cabine Sobrenome Embarcado

759 760 1 1 Rothes, a Condessa. de (Lucy Noel Martha Dye... ÿ
ÿÿfeminino ... 110152 86,5 B77 S Rothes
[1 linha x 13 colunas]
(Interessado na história dela? Veja a Wikipedia!)
O método de string Series.str.contains() verifica cada um dos valores na coluna Nome se a string contém
a palavra Condessa e retorna para cada um dos valores Verdadeiro (Condessa faz parte do nome) ou Falso (Condessa é
não faz parte do nome). Esta saída pode ser usada para subselecionar os dados usando a indexação condicional (booleana) introduzida em
o subconjunto do tutorial de dados. Como havia apenas uma condessa no Titanic, o resultado é uma linha.
Nota: Extrações mais poderosas em strings são suportadas, como Series.str.contains() e Series.str.
Os métodos extract() aceitam expressões regulares, mas estão fora do escopo deste tutorial.
Mais informações sobre como extrair partes de strings estão disponíveis na seção do guia do usuário sobre correspondência e extração de strings.
Qual passageiro do Titanic tem o nome mais longo?
Em [10]: titanic["Nome"].str.len()
Fora[10]:
0 23
1 51
2 22
3 44
4 24
..
886 21
887 28
888 40
889 21
890 19
Nome: Nome, Comprimento: 891, dtype: int64
Para obter o nome mais longo, primeiro precisamos obter o comprimento de cada um dos nomes na coluna Nome. Usando pandas
métodos de string, a função Series.str.len() é aplicada a cada um dos nomes individualmente (em termos de elemento).
Em [11]: titanic["Nome"].str.len().idxmax()
Fora[11]: 307
Em seguida, precisamos obter o local correspondente, de preferência o rótulo do índice, na tabela para a qual o comprimento do nome é
o maior. O método idxmax() faz exatamente isso. Não é um método de string e é aplicado a números inteiros, portanto, nenhum str é
usado.
Em [12]: titanic.loc[titanic["Nome"].str.len().idxmax(), "Nome"]

Fora[12]: 'Penasco y Castellana, Sra. Victor de Satode (Maria Josefa Perez de Soto yÿ
ÿÿValejo)'
Com base no nome do índice da linha (307) e da coluna (Nome), podemos fazer uma seleção utilizando o operador loc,
introduzido no tutorial sobre subconjuntos.

Na coluna “Sexo”, substitua os valores de “masculino” por “M” e os valores de “feminino” por “F”.
Em [13]: titânico["Sex_short"] = titânico["Sexo"].replace({"masculino": "M", "feminino": "F"})
Em [14]: titânico["Sex_short"]
Fora[14]:
0 M
1 F
2 F
3 F
4 M
..
886 M
887 F
888 F
889 M
890 M
Nome: Sex_short, Comprimento: 891, dtype: objeto
Embora replace() não seja um método de string, ele fornece uma maneira conveniente de usar mapeamentos ou vocabulários para traduzir
determinados valores. Requer um dicionário para definir o mapeamento {de: para}.
Aviso: também existe um método replace() disponível para substituir um conjunto específico de caracteres. No entanto, quando
tendo um mapeamento de vários valores, isso se tornaria:
titânico["Sexo_curto"] = titânico["Sexo"].str.replace("feminino", "F")

titanic["Sex_short"] = titanic["Sex_short"].str.replace("masculino", "M")
Isso se tornaria complicado e facilmente levaria a erros. Apenas pense (ou experimente você mesmo) o que aconteceria se
essas duas declarações são aplicadas na ordem oposta. . .
• Métodos string estão disponíveis usando o acessador str.
• Os métodos de string funcionam elemento a elemento e podem ser usados para indexação condicional.
• O método replace é um método conveniente para converter valores de acordo com um determinado dicionário.
Uma visão geral completa é fornecida nas páginas do guia do usuário sobre como trabalhar com dados de texto.
1.4.4 Comparação com outras ferramentas
Comparação com bibliotecas R/R
Como o pandas tem como objetivo fornecer muitas funcionalidades de manipulação e análise de dados para as quais as pessoas usam R , esta página
foi iniciado para fornecer uma visão mais detalhada da linguagem R e de suas muitas bibliotecas de terceiros relacionadas ao pandas.
Em comparações com as bibliotecas R e CRAN, nos preocupamos com o seguinte:
• Funcionalidade/flexibilidade: o que pode/não pode ser feito com cada ferramenta
• Desempenho: quão rápidas são as operações. Números/benchmarks concretos são preferíveis
• Facilidade de uso: uma ferramenta é mais fácil/mais difícil de usar (talvez você precise julgar isso, dado o código lado a lado
comparações)
Esta página também está aqui para oferecer um guia de tradução para usuários desses pacotes R.
1.4. Tutoriais 61
Para transferência de objetos DataFrame de pandas para R, uma opção é usar arquivos HDF5, consulte Compatibilidade externa para
um exemplo.
Referência rápida
Começaremos com um guia de referência rápida combinando algumas operações comuns do R usando dplyr com equivalentes do pandas.
Consulta, filtragem, amostragem
R pandas
dim(df) df.forma
head(df) df.head()
slice(df, 1:10) filter(df, df.iloc[:9]
col1 == 1, col2 == 1) df.query('col1 == 1 & col2 == 1')
df[df$col1 == 1 & df$col2 == 1,] df[(df.col1 == 1) & (df.col2 == 1)]
selecione(df, col1, col2) df[['col1', 'col2']]
selecione(df, col1:col3) df.loc[:, 'col1':'col3']
select(df, -(col1:col3)) df.drop(cols_to_drop, axis=1) mas veja1
distinto(select(df, col1)) df[['col1']].drop_duplicates()
distinto(select(df, col1, col2)) df[['col1', 'col2']].drop_duplicates()
amostra_n(df, 10) df.amostra(n=10)
amostra_frac(df, 0,01) df.amostra(frac=0,01)
Ordenação
Pandas R
organizar(df, col1, col2) df.sort_values(['col1', 'col2'])
organizar(df, desc(col1)) df.sort_values('col1', ascendente=Falso)
Transformando
R pandas
select(df, col_one = col1) df.rename(columns={'col1': 'col_one'})['col_one']
renomear(df, col_one = col1) df.rename(columns={'col1': 'col_one'})
mutar(df, c=ab) df.assign(c=df['a']-df['b'])
1 A abreviação de R para um subintervalo de colunas (select(df, col1:col3)) pode ser abordada de forma limpa em pandas, se você tiver a lista de colunas, por
exemplo df[cols[1:3]] ou df.drop(cols[1:3]), mas fazer isso pelo nome da coluna é um pouco confuso.

Agrupando e resumindo
pandas
Resumo R (df) df.describe() gdf =
gdf <- group_by (df, col1) resumo df.groupby('col1')
(gdf, avg = média (col1, na.rm = VERDADEIRO)) df.groupby ('col1').agg ({'col1': 'média' }) resumir(gdf, total=soma(col1))
df.groupby('col1').sum()
BaseR
Fatiando com R's c
R facilita o acesso às colunas data.frame por nome
df <- data.frame(a=rnorm(5), b=rnorm(5), c=rnorm(5), d=rnorm(5), e=rnorm(5)) df[, c("a" , "c", "e")]
ou por localização inteira
df <- data.frame(matriz(rnorm(1000), ncol=100)) df[, c(1:10, 25:30, 40,

50:100)]
Selecionar várias colunas por nome no pandas é simples
Em [1]: df = pd.DataFrame(np.random.randn(10, 3), colunas=lista("abc"))
Em [2]: df[["a", "c"]]

Fora[2]:
a c
0 0,469112 -1,509059
1 -1,135632 -0,173215
2 0,119209 -0,861849
3 -2,104569 1,071804
4 0,721555 -1,039575
5 0,271860 0,567020
6 0,276232 -0,673690
7 0,113648 0,524988
8 0,404705 -1,715002
9 -1,039268 -1,157892
Em [3]: df.loc[:, ["a", "c"]]

Fora[3]:
a c
0 0,469112 -1,509059 1
-1,135632 -0,173215 2 0,119209
-0,861849 3 -2,104569 1,071804
4 0,721555 -1,039575 5
0,271860 0,567020 6 0,276232
-0,673690 7 0,113648 0,524988
1.4. Tutoriais 63
8 0,404705 -1,715002
9 -1,039268 -1,157892
A seleção de múltiplas colunas não contíguas por localização inteira pode ser obtida com uma combinação do indexador iloc
atributo e numpy.r_.
Em [4]: nomeado = lista("abcdefg")
Em [5]: n = 30
Em [6]: colunas = nomeado + np.arange(len(nomeado), n).tolist()
Em [7]: df = pd.DataFrame(np.random.randn(n, n), colunas=colunas)
Em [8]: df.iloc[:, np.r_[:10, 24:30]]

Fora[8]:
a b c d e f... 24 25 ÿ
ÿÿ 26 27 28 29
0 -1,344312 0,844885 1,075770 -0,109050 1,643563 -1,469388 ... -1,170299 -0,226169 ÿ
ÿÿ0,410835 0,813850 0,132003 -0,827317

1 -0,076467 -1,187678 1,130127 -1,436737 -1,413681 1,607920 ... 0,959726 -1,110336 -
ÿÿ0,619976 0,149748 -0,732339 0,687738
2 0,176444 0,403310 -0,154951 0,301624 -2,179861 -1,369849 ... 0,084844 0,432390 ÿ
ÿÿ1,519970 -0,493662 0,600178 0,274230

3 0,132885 -0,023688 2,410179 1,450520 0,206053 -0,251905 ... -2,484478 -0,281461 ÿ
ÿÿ0,030711 0,109121 1,126203 -0,977349

4 1,474071 -0,064034 -1,282782 0,781836 -1,071357 0,441153 ... -1,197071 -1,066969 -
ÿÿ0,303421 -0,858447 0,306996 -0,028665
.. ... ... ... ... ... ... ... ... ... ÿ
ÿÿ ... ... ... ...

25 1,492125 -0,068190 0,681456 1,221829 -0,434352 1,204815 ... 1,944517 0,042344 -
ÿÿ0,307904 0,428572 0,880609 0,487645
26 0,725238 0,624607 -0,141185 -0,143948 -0,328162 2,095086 ... -0,846188 1,190624 ÿ
ÿÿ0,778507 1,008500 1,424017 0,717110

27 1,262419 1,950057 0,301038 -0,933858 0,814946 0,181439 ... -1,341814 0,334281 -
ÿÿ0,162227 1,007824 2,826008 1,458383
28 -1,585746 -0,899734 0,921494 -0,211762 -0,059182 0,058308 ... 0,403620 -0,026602 -
ÿÿ0,240481 0,577223 -1,088417 0,326687
29 -0,986248 0,169729 -1,158091 1,019673 0,646039 0,917399 ... -1,209247 -0,671466 ÿ
ÿÿ0,332872 -2,013086 -1,602549 0,333109

agregar
Em R, você pode querer dividir os dados em subconjuntos e calcular a média de cada um. Usando um data.frame chamado df e divisão
em grupos por1 e por2:
df <- dados.frame(
v1 = c(1,3,5,7,8,3,5,NA,4,5,7,9),
v2 = c(11,33,55,77,88,33,55,NA,44,55,77,99),
by1 = c("vermelho", "azul", 1, 2, NA, "grande", 1, 2, "vermelho", 1, NA, 12),
by2 = c("molhado", "seco", 99, 95, NA, "úmido", 95, 99, "vermelho", 99, NA, NA))
agregado(x=df[, c("v1", "v2")], por=lista(meudf2$by1, meudf2$by2), FUN = média)
O método groupby() é semelhante à função agregada base R.
Em [9]: df = pd.DataFrame(
...: {
...: "v1": [1, 3, 5, 7, 8, 3, 5, np.nan, 4, 5, 7, 9],
...: "v2": [11, 33, 55, 77, 88, 33, 55, np.nan, 44, 55, 77, 99],
...: "by1": ["vermelho", "azul", 1, 2, np.nan, "grande", 1, 2, "vermelho", 1, np.nan, 12],
...: "por2": [
...: "molhado",
...: "seco",
...: 99,
...: 95,
...: np.nan,
...: "úmido",
...: 95,
...: 99,
...: "vermelho",
...: 99,
...: np.nan,
...: np.nan,
...: ],
...: }
... :)
...:
Em [10]: g = df.groupby(["por1", "por2"])
Em [11]: g[["v1", "v2"]].mean()

Fora[11]:
v1 v2
por 1 por 2
1 95 5,0 55,0
99 5,0 55,0
2 95 7,0 77,0
99 NaN NaN
grande umidade 3,0 33,0
azul seco 3,0 33,0
vermelho vermelho 4,0 44,0
molhado 1,0 11,0
Para mais detalhes e exemplos consulte a documentação do groupby.
1.4. Tutoriais 65
correspondência / % em%
Uma maneira comum de selecionar dados em R é usando %in% que é definido usando a função match. O operador %in% é usado
para retornar um vetor lógico indicando se há correspondência ou não:
s <- 0:4
s % em% c(2,4)
O método isin() é semelhante ao operador R %in%:
Em [12]: s = pd.Series(np.arange(5), dtype=np.float32)
Em [13]: s.isin([2, 4])

Fora[13]:
0 Falso
1 Falso
Verdadeiro
2 3 Falso
4 Verdadeiro
tipo d: bool
A função match retorna um vetor das posições de correspondências do seu primeiro argumento no segundo:
s <- 0:4
correspondência(ões, c(2,4))
Para obter mais detalhes e exemplos, consulte a documentação de remodelagem.
tocar
tapply é semelhante ao agregado, mas os dados podem estar em uma matriz irregular, uma vez que os tamanhos das subclasses são possivelmente irregulares. Usando
um data.frame chamado baseball e recuperação de informações com base na equipe do array:
beisebol <-
data.frame(equipe = gl(5, 5,
rótulos = colar("Equipe", LETRAS[1:5])),
jogador = amostra(letras, 25),
rebatidas.média = runif(25, 0,200, 0,400))
tapply(beisebol$batting.average, baseball.example$time,
máximo)
Em pandas podemos usar o método pivot_table() para lidar com isso:
Em [14]: importação aleatória
Em [15]: string de importação
Em [16]: baseball = pd.DataFrame(

....: {
....: "team": ["team %d" % (x + 1) para x no intervalo(5)] * "player": 5,
....: random.sample(list(string.ascii_lowercase), 25),
....: "média de rebatidas": np.random.uniform (0,200, 0,400, 25),

....: }
....: )
....:
Em [17]: baseball.pivot_table(values="batting avg", columns="team", aggfunc=np.max)

Fora[17]:
equipe equipe 1 equipe 2 equipe 3 equipe 4 equipe 5
média de rebatidas 0,352134 0,295327 0,397191 0,394457 0,396194
subconjunto
O método query() é semelhante à função de subconjunto base R. Em R você pode querer obter as linhas de um data.frame onde
os valores de uma coluna são menores que os valores de outra coluna:
df <- data.frame(a=rnorm(10), b=rnorm(10)) subset(df, a <= b)

df[df$a <= df$b,] # observe
a vírgula
Nos pandas, existem algumas maneiras de realizar subconjuntos. Você pode usar query() ou passar uma expressão como se fosse
um índice/fatia, bem como indexação booleana padrão:
Em [18]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})
Em [19]: df.query("a <= b")

Fora[19]:
a
b 1 0,174950 0,552887 2
-0,023167 0,148084 3 -0,495291
-0,300218 4 -0,860736 0,197378
5 -1,134146 1,720780 7
-0,290098 0,083515 8 0,238636
0,946550
Em [20]: df[df["a"] <= df["b"]]

Fora[20]:
a b
1 0,174950 0,552887
2 -0,023167 0,148084
3 -0,495291 -0,300218
4 -0,860736 0,197378
5 -1,134146 1,720780
7 -0,290098 0,083515
8 0,238636 0,946550
Em [21]: df.loc[df["a"] <= df["b"]]

Fora[21]:
a
b1 0,174950 0,552887
1.4. Tutoriais 67
2 -0,023167 0,148084
3 -0,495291 -0,300218
4 -0,860736 0,197378
5 -1,134146 1,720780
7 -0,290098 0,083515
8 0,238636 0,946550
Para obter mais detalhes e exemplos, consulte a documentação da consulta.
com
Uma expressão usando um data.frame chamado df em R com as colunas aeb seria avaliada usando assim:
df <- data.frame(a=rnorm(10), b=rnorm(10)) with(df, a + b) df$a

+ df$b # igual à
expressão anterior
Nos pandas a expressão equivalente, usando o método eval() , seria:
Em [22]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})
Em [23]: df.eval("a + b")

OUT [23]:
0 -0.091430 1
-2.483890 2
-0.252728 3
-0.626444 4
-0.261740 5
2.149503 6
-0.332214 7 0,7931
8 -2.377245 9
2.10467
In [24]: df["a"] + df["b"] # igual à expressão anterior Out[24]: 0 -0.091430
1 -2,483890
2 -0,252728
3 -0,626444
4 -0,261740
5 2.149503
6-0,332214
7 0,799331
8 -2.377245 9
2.104677 tipo d:
float64
Em certos casos, eval() será muito mais rápido que a avaliação em Python puro. Para mais detalhes e exemplos, consulte a
documentação de avaliação.

plyr
plyr é uma biblioteca R para a estratégia split-apply-combine para análise de dados. As funções giram em torno de três dados
estruturas em R, a para matrizes, l para listas e d para data.frame. A tabela abaixo mostra como essas estruturas de dados
poderia ser mapeado em Python.
R Pitão
listas de lista
matrizes dicionário ou lista de objetos
data.frame quadro de dados
ddply
Uma expressão usando um data.frame chamado df em R onde você deseja resumir x por mês:
exigir (plyr)
df <- dados.frame(
x = runif(120, 1, 168),
y = runif(120, 7, 334),
z = runif(120, 1,7, 20,7),
mês = rep(c(5,6,7,8),30),
semana = amostra(1:4, 120, VERDADEIRO)
)
ddply(df, .(mês, semana), resumir,

média = rodada (média (x), 2),
sd = redondo (sd (x), 2))
Nos pandas a expressão equivalente, usando o método groupby() , seria:
....: {
....: "x": np.random.uniform(1,0, 168,0, 120),
....: "y": np.random.uniform(7,0, 334,0, 120),
....: "z": np.random.uniform(1,7, 20,7, 120),
....: "mês": [5, 6, 7, 8] * 30,
....: "semana": np.random.randint(1, 4, 120),
....: }
....: )
....:
Em [26]: agrupado = df.groupby(["mês", "semana"])
Em [27]: agrupado["x"].agg([np.mean, np.std])

Fora[27]:
significar padrão
mês semana
5 1 63.653367 40.601965
2 78.126605 53.342400
3 92.091886 57.630110
6 1 81.747070 54.339218
2 70.971205 54.687287
1.4. Tutoriais 69
3 100.968344 54.010081
7 1 61.576332 38.844274
2 61.733510 48.209013
3 71.688795 37.595638
8 1 62.741922 34.618153
2 91.774627 49.790202
3 73.936856 60.773900
Para mais detalhes e exemplos consulte a documentação do groupby.
remodelar / remodelar2
derretimento
Uma expressão usando uma matriz tridimensional chamada a em R onde você deseja fundi-la em um data.frame:
uma <- matriz(c(1:23, NA), c(2,3,4))

data.frame(derreter(a))
Em Python, como a é uma lista, você pode simplesmente usar a compreensão de lista.
Em [28]: a = np.array(list(range(1, 24)) + [np.NAN]).reshape(2, 3, 4)
Em [29]: pd.DataFrame([tuple(list(x) + [val]) para x, val in np.ndenumerate(a)])

Fora[29]:
0123
0 0 0 0 1,0
1 0 0 1 2,0
2 0 0 2 3,0
3 0 0 3 4,0
4 0 1 0 5,0
.. .. .. .. ...
19 1 1 3 20,0
20 1 2 0 21,0
21 1 2 1 22,0
22 1 2 2 23,0
23 1 2 3NaN
lista de fusão
Uma expressão usando uma lista chamada a em R onde você deseja fundi-la em um data.frame:
a <- as.list(c(1:4, NA))

data.frame(derreter(a))
Em Python, esta lista seria uma lista de tuplas, então o método DataFrame() a converteria em um dataframe conforme necessário.

Em [30]: a = lista(enumerar(lista(intervalo(1, 5)) + [np.NAN]))
Em [31]: pd.DataFrame(a)
Fora[31]:
0 1
0 0 1,0
1 1 2,0
2 2 3,0
3 3 4,0
4 4 NaN
Para obter mais detalhes e exemplos, consulte a documentação Into to Data Structures.
derreter
Uma expressão usando um data.frame chamado cheese em R onde você deseja remodelar o data.frame:
queijo <- data.frame(

primeiro = c('João', 'Maria'),
último = c('Doe', 'Bo'),
altura = c(5,5, 6,0),
peso = c(130, 150)
)
derreter(queijo, id=c("primeiro", "último"))
Em Python, o método melt() é o equivalente em R:
Em [32]: queijo = pd.DataFrame(

....: {
....: "primeiro": ["João", "Maria"],
....: "último": ["Doe", "Bo"],
....: "altura": [5,5, 6,0],
....: "peso": [130, 150],
....: }
....: )
....:
Em [33]: pd.melt(queijo, id_vars=["primeiro", "último"])

Fora[33]:
primeiro último valor da variável
0 altura de John Doe 1 altura 5.5
de Mary Bo 2 peso de John 6,0
Doe 130,0
3Mary Bo peso 150,0
Em [34]: cheese.set_index(["primeiro", "último"]).stack() # caminho alternativo

Fora[34]:
primeiro último
John Doe altura peso altura 5.5
peso 130,0
Maria Bo 6,0
150,0
1.4. Tutoriais 71
tipo d: float64
elenco
Em R acast é uma expressão que usa um data.frame chamado df em R para converter em uma matriz de dimensão superior:
df <- dados.frame(
x = runif(12, 1, 168),
y = runif(12, 7, 334),
z = runif(12, 1,7, 20,7),
mês = rep(c(5,6,7),4),
semana = rep(c(1,2), 6)
)
mdf <- melt(df, id=c("mês", "semana"))

acast(mdf, semana ~ mês ~ variável, média)
Em Python a melhor maneira é usar pivot_table():
....: {
....: "x": np.random.uniform(1,0, 168,0, 12),
....: "y": np.random.uniform(7,0, 334,0, 12),
....: "z": np.random.uniform(1,7, 20,7, 12),
....: "mês": [5, 6, 7] * "semana": 4,
....: [1, 2] * 6,
....: }
....: )
....:
Em [36]: mdf = pd.melt(df, id_vars=["mês", "semana"])
Em [37]: pd.pivot_table(
....: mdf,
....: valores = "valor",
....: index=["variável", "semana"],
....: colunas=["mês"],
....: aggfunc = np.mean,
....: )
....:
Fora[37]:
mês 5 6 7
variável semana
x 1 93.888747 98.762034 55.219673
2 94.391427 38.112932 83.942781
sim
1 94.306912 279.454811 227.840449
2 87.392662 193.028166 173.899260
z 1 11.016009 10.079307 16.170549
2 8.476111 17.638509 19.003494

Da mesma forma para dcast que usa um data.frame chamado df em R para agregar informações com base em Animal e FeedType:
df <- dados.frame(
Animal = c('Animal1', 'Animal2', 'Animal3', 'Animal2', 'Animal1',
'Animal2', 'Animal3'),
FeedType = c('A', 'B', 'A', 'A', 'B', 'B', 'A'),
Quantidade = c(10, 7, 4, 2, 5, 6, 2)
)
dcast(df, Animal ~ FeedType, soma, preenchimento=NaN)

# Método alternativo usando base R
com(df, tapply(Quantidade, lista(Animal, FeedType), soma))
Python pode abordar isso de duas maneiras diferentes. Em primeiro lugar, semelhante ao acima usando pivot_table():
....: {
....: "Animal": [
....: "Animal1",
....: "Animal2",
....: "Animal3",
....: "Animal2",
....: "Animal1",
....: "Animal2",
....: "Animal3",
....: ],
....: "FeedType": ["A", "B", "A", "A", "B", "B", "A"],
....: "Quantidade": [10, 7, 4, 2, 5, 6, 2],
....: }
....: )
....:
Em [39]: df.pivot_table(values="Amount", index="Animal", columns="FeedType", aggfunc="sum

ÿÿ")
Fora[39]:
Tipo de A B
alimentação Animal
Animal1 10,0 5,0

Animal2 2,0 13,0
Animal3 6,0 NaN
A segunda abordagem é usar o método groupby() :
Em [40]: df.groupby(["Animal", "FeedType"])["Quantidade"].sum()

Fora[40]:
Tipo de alimentação animal
Animal1 A 10
B 5
Animal2 A 2
B 13
Animal3 A 6
Nome: Quantidade, dtype: int64
Para obter mais detalhes e exemplos, consulte a documentação de remodelagem ou a documentação do groupby.
1.4. Tutoriais 73
fator
pandas possui um tipo de dados para dados categóricos.
cortar (c (1,2,3,4,5,6), 3)
fator(c(1,2,3,2,2,3))
Nos pandas isso é feito com pd.cut e astype("category"):
Em [41]: pd.cut(pd.Series([1, 2, 3, 4, 5, 6]), 3)

Fora[41]:
0 (0,995, 2,667]
1 (0,995, 2,667]
2 (2.667, 4.333]
3 (2.667, 4.333]
4 (4,333, 6,0]
5 (4,333, 6,0]
tipo: categoria
Categorias (3, intervalo [float64, direita]): [(0,995, 2,667] < (2,667, 4,333] < (4,333, 6.
ÿÿ0]]
Em [42]: pd.Series([1, 2, 3, 2, 2, 3]).astype("categoria")

Fora[42]:
01
12
23
32
42
53
tipo: categoria
Categorias (3, int64): [1, 2, 3]
Para obter mais detalhes e exemplos, consulte a introdução categórica e a documentação da API. Há também uma documentação
em relação às diferenças para o fator R.
Comparação com SQL
Como muitos usuários potenciais do pandas têm alguma familiaridade com SQL, esta página tem como objetivo fornecer alguns exemplos de
como várias operações SQL seriam executadas usando pandas.
Se você é novo no mundo dos pandas, talvez queira ler primeiro 10 minutos para pandas para se familiarizar com o
biblioteca.
Como de costume, importamos pandas e NumPy da seguinte forma:
Em [2]: importe numpy como np
A maioria dos exemplos utilizará o conjunto de dados de dicas encontrado nos testes do pandas. Leremos os dados em um DataFrame
chamado dicas e suponha que temos uma tabela de banco de dados com o mesmo nome e estrutura.
Em [3]: url = (
...: "https://raw.github.com/pandas-dev"

...: "/pandas/main/pandas/tests/io/data/csv/tips.csv"
... :)
...:
Em [4]: dicas = pd.read_csv(url)
Em [5]: dicas
Fora[5]:
dica total_bill tamanho do dia do fumante sexual
0 16,99 1,01 Feminino 10,34 Sem jantar ao sol 2
1 1,66 Masculino 21,01 3,50 Sem jantar ao sol 3
2 Masculino 23,68 3,31 Sem jantar ao sol 3
4 Feminino Sem jantar ao sol 4
.. ... ... ... ... ... ... ...
239 29,03 5,92 Masculino Não Sábado Jantar 27,18 2,00 3
240 Feminino Sim Sábado Jantar 22,67 2,00 Masculino Sim 2
241 Sábado Jantar 17,82 1,75 Masculino Não Sábado Jantar 2
242 18,78 3,00 Feminino Sem Qui Jantar 2
243 2
Cópias vs. operações no local
A maioria das operações do pandas retorna cópias do Series/DataFrame. Para fazer com que as alterações “permaneçam”, você precisará
atribuir a uma nova variável:
sort_df = df.sort_values("col1")
ou substitua o original:
df = df.sort_values("col1")
Nota: Você verá um argumento de palavra-chave inplace=True disponível para alguns métodos:
df.sort_values("col1", inplace=True)
Seu uso é desencorajado. Mais Informações.
1.4. Tutoriais 75
SELECIONAR
*
No SQL, a seleção é feita usando uma lista de colunas separadas por vírgula que você deseja selecionar (ou uma para selecionar todas as colunas):
SELECIONE total_bill, gorjeta, fumante, hora

COM dicas;
Com o pandas, a seleção de colunas é feita passando uma lista de nomes de colunas para o seu DataFrame:
Em [6]: dicas[["total_bill", "tip", "smoker", "time"]]

Fora[6]:
total_bill gorjeta tempo de fumante
0 16.99 1.01 Sem Jantar
1 10h34 1h66 Sem jantar
2 21h01 3h50 Sem jantar
3 23,68 3,31 Sem jantar
4 24,59 3,61 Sem jantar
.. ... ... ... ...
239 29,03 5,92 Sem jantar
240 27h18 2h00 Sim Jantar
241 22,67 2,00 Sim Jantar
242 17,82 1,75 Sem jantar
243 18,78 3,00 Sem jantar
Chamar o DataFrame sem a lista de nomes de colunas exibiria todas as colunas (semelhante ao * do SQL).
No SQL, você pode adicionar uma coluna calculada:
SELECIONE *, gorjeta/total_bill como tip_rate

COM dicas;
Com pandas, você pode usar o método DataFrame.assign() de um DataFrame para anexar uma nova coluna:
Em [7]: dicas.assign(tip_rate=tips["tip"] / dicas["total_bill"])

Fora[7]:
dica total_bill tamanho do horário do dia do fumante sexual tip_rate
0 16,99 1,01 Feminino 10,34 Sem Jantar ao Sol 2 0,059447
1 1,66 Masculino 21,01 3,50 Sem Jantar ao Sol Sem 3 0,160542
2 Masculino 23,68 3,31 Jantar ao Sol Sem 3 0,166587
3 Masculino 24,59 3,61 Jantar ao Sol Sem 20,139780
4 Feminino Jantar ao Sol 4 0,146808
.. ... ... ... ... ... ... ... ...
239 29,03 5,92 Masculino Não Sábado Jantar 27,18 2,00 3 0,203927
240 Feminino Sim Sábado Jantar 22,67 2,00 Masculino Sim 20,073584
241 Sábado Jantar 17,82 1,75 Masculino Não Sábado Jantar 2 0,088222
242 18,78 3,00 Feminino Sem Qui Jantar 2 0,098204
243 20,159744

ONDE
A filtragem em SQL é feita por meio de uma cláusula WHERE.
SELECIONE *
DE dicas
ONDE hora = 'Jantar';
DataFrames podem ser filtrados de várias maneiras; o mais intuitivo é usar a indexação booleana.
Em [8]: dicas[tips["total_bill"] > 10]

Fora[8]:
0 16,99 1,01 Feminino 10,34 Sem jantar ao sol 2
2 Masculino Sem jantar ao sol 3
3 23,68 3,31 Masculino Sem jantar ao sol 2
4 24,59 3,61 Feminino Sem jantar ao sol 4
.. ... ... ... ... ... ... ...
239 29,03 5,92 Macho Sem jantar de sábado 3
240 27,18 2,00 Feminino Sim Sábado Jantar 22,67 2,00 2
241 Masculino Sim Sábado Jantar Não Sábado Jantar Não Qui 2
242 17,82 1,75 Jantar 2
243 Masculino 18,78 3,00 Feminino 2
A instrução acima é simplesmente passar uma série de objetos True/False para o DataFrame, retornando todas as linhas com
Verdadeiro.
Em [9]: is_dinner = dicas["time"] == "Jantar"
Em [10]: é_jantar
Fora[10]:
0 Verdadeiro
1 Verdadeiro
2 Verdadeiro
3 Verdadeiro
4 Verdadeiro
...
239 Verdadeiro
240 Verdadeiro
241 Verdadeiro
242 Verdadeiro
243 Verdadeiro
Nome: hora, Comprimento: 244, dtype: bool
Em [11]: is_dinner.value_counts()
Fora[11]:
Verdadeiro 176
Falso 68
Nome: hora, dtype: int64
1.4. Tutoriais 77
Em [12]: dicas[é_jantar]
Fora[12]:
dica total_bill dia do fumante sexual tamanho do tempo
1 10,34 1,66 Masculino 21,01 Sem jantar ao sol 3
.. ... ... ... ... ... ... ...
239 29,03 5,92 Masculino Não Sábado Jantar 27,18 3
240 2,00 Feminino Sim Sábado Jantar 22,67 2,00 Masculino Sim 2
242 18,78 3,00 Feminino Não Qui Jantar 2
243 2
Assim como OR e AND do SQL, várias condições podem ser passadas para um DataFrame usando | (OU) e & (E).
Gorjetas de mais de US$ 5 nas refeições do Jantar:
SELECIONE *
DE dicas
WHERE horário = 'Jantar' AND gorjeta > 5,00;
Em [13]: dicas[(tips["time"] == "Jantar") & (tips["tip"] > 5.00)]

Fora[13]:
total_bill dica sexo fumante tamanho do dia
23 39,42 7,58 Masculino Sem Jantar de Sábado 4
44 30h40 5h60 Masculino Sem Jantar ao Sol 4
47 32h40 6h00 Masculino Sem Jantar ao Sol 4
52 34,81 5,20 Feminino Sem Jantar ao Sol 4
59 48,27 6,73 Masculino Sem Jantar de Sábado 4
116 29,93 5,07 Masculino Não Jantar ao Sol 29,85 5,14 Feminino 4
155 Não Jantar ao Sol 50,81 10,00 Sim Sábado Jantar 7,25 5,15 5
170 Macho 3
172 Macho Sim Jantar ao Sol 2
181 23,33 5,65 Macho Sim Jantar ao Sol 2
211 25,89 5,16 Macho Sim Sábado Jantar 4
214 28,17 6,50 Feminino Masculino Sim Sábado Jantar 3
239 29,03 5,92 Sem jantar de sábado 3
Gorjetas de grupos de pelo menos 5 clientes OU o total da conta foi superior a US$ 45:
SELECIONE *
DE dicas
WHERE tamanho >= 5 OU total_bill > 45;
Em [14]: dicas[(dicas["tamanho"] >= 5) | (dicas["total_bill"] > 45)]

Fora[14]:

conta_total dica dia do fumante sexual tamanho do tempo

125 29,80 4,20 Feminino Sem almoço na quinta 6
141 34h30 6h70 Macho Sem almoço na quinta 6
142 41,19 5,00 Sem almoço na quinta 5
143 Masculino 27,05 5,00 Feminino Sem almoço na quinta 6
155 29,85 5,14 Feminino Masculino Sem jantar ao sol 5
156 48,17 5,00 Sem jantar ao sol 6
170 50,81 10,00 Sim Sábado Jantar 3
182 45,35 3,50 Sim Jantar ao Sol 3
185 20,69 5,00 30,46 Sem jantar ao sol 5
187 2,00 48,33 9,00 Sim Jantar ao Sol 5
216 Sim Sábado
Masculino Masculino Jantar
Masculino 5
Masculino Masculino Masculino
A verificação de NULL é feita usando os métodos notna() e isna() .
Em [15]: frame = pd.DataFrame(

....: {"col1": ["A", "B", np.NaN, "C", "D"], "col2": ["F", np.NaN, "G", "H", "I "]}
....: )
....:
Em [16]: quadro
Fora[16]:
col1 col2
0 A F
1 B NaN
2 NaN 3 G
H
C4 D EU
Suponha que temos uma tabela com a mesma estrutura do nosso DataFrame acima. Podemos ver apenas os registros onde col2 ESTÁ
NULL com a seguinte consulta:
SELECIONE *
A PARTIR DE quadro
ONDE col2 É NULO;
Em [17]: frame[frame["col2"].isna()]
Fora[17]:
col1 col2
1 B NaN
Obter itens onde col1 IS NOT NULL pode ser feito com notna().
SELECIONE *
A PARTIR DE quadro
ONDE col1 NÃO É NULO;
Em [18]: frame[frame["col1"].notna()]
Fora[18]:
col1 col2
1.4. Tutoriais 79
0 A F
1 B NaN
3 C H
4 D EU
Agrupar por
No pandas, as operações GROUP BY do SQL são executadas usando o método groupby() de nome semelhante . agrupar por()
normalmente se refere a um processo em que gostaríamos de dividir um conjunto de dados em grupos, aplicar alguma função (normalmente agregação)
, e depois combine os grupos.
Uma operação SQL comum seria obter a contagem de registros em cada grupo em um conjunto de dados. Por exemplo, um
consulta nos dando o número de dicas deixadas por sexo:
SELECIONE sexo, conte(*)

DE dicas
GRUPO POR sexo;
/*
Fêmea 87
Macho 157
*/
O equivalente dos pandas seria:
Em [19]: dicas.groupby("sexo").size()
Fora[19]:
sexo
Feminino 87
Masculino 157
tipo d: int64
Observe que no código do pandas usamos size() e não count(). Isso ocorre porque count() aplica a função a
cada coluna, retornando o número de registros NOT NULL dentro de cada coluna.
Em [20]: dicas.groupby("sex").count()
Fora[20]:
total_bill gorjeta ao tamanho do dia do fumante
sexo
Fêmea 87 87 157 87 87 87 87
Macho 157 157 157 157 157
Alternativamente, poderíamos ter aplicado o método count() a uma coluna individual:
Em [21]: dicas.groupby("sex")["total_bill"].count()
Fora[21]:
sexo
Fêmea 87
Macho 157
Nome: total_bill, dtype: int64
Várias funções também podem ser aplicadas ao mesmo tempo. Por exemplo, digamos que gostaríamos de ver como o valor da gorjeta difere por dia
a semana - agg() permite que você passe um dicionário para seu DataFrame agrupado, indicando quais funções aplicar
colunas específicas.

SELECIONE dia, AVG(dica), COUNT(*)

DE dicas
GRUPO POR dia;
/*
Sex 2.734737 19
Sábado 2.993103 87
Dom 3.255132 76
Qui 2.771452 62
*/
Em [22]: dicas.groupby("dia").agg({"tip": np.mean, "dia": np.size})

Fora[22]:
dia de gorjeta
dia
Sex 2.734737 19
Sábado 2.993103 87
Dom 3.255132 76
Qui 2.771452 62
O agrupamento por mais de uma coluna é feito passando uma lista de colunas para o método groupby() .
SELECIONE fumante, dia, COUNT(*), AVG(dica)

DE dicas
GRUPO POR fumante, dia;
/*
dia do fumante
Não sex 4 2.812500
Sentado 45 3.102889
Sol 57 3.167895
qui 45 2.673778
Sim sex 15 2.714000
Sentado 42 2.875476
Sol 19 3.516842
qui 17 3,030000
*/
Em [23]: dicas.groupby(["fumante", "dia"]).agg({"tip": [np.size, np.mean]})

Fora[23]:
dica
tamanho significar
dia do fumante
Não Sex 4 2.812500
Sábado 45 3.102889
Dom 57 3.167895
Qui 45 2.673778
Sim Sex 15 2.714000
Sábado 42 2.875476
Dom 19 3.516842
Qui, 17 3.030000
1.4. Tutoriais 81
JUNTAR
JOINs podem ser realizados com join() ou merge(). Por padrão, join() juntará os DataFrames em seus índices. Cada método possui
parâmetros que permitem especificar o tipo de junção a ser realizada (LEFT, RIGHT, INNER, FULL) ou as colunas nas quais ingressar
(nomes de colunas ou índices).
Aviso: se ambas as colunas-chave contiverem linhas em que a chave for um valor nulo, essas linhas serão comparadas entre si. Isso
é diferente do comportamento normal de junção SQL e pode levar a resultados inesperados.
Em [24]: df1 = pd.DataFrame({"chave": ["A", "B", "C", "D"], "valor": np.random.randn(4)})
Em [25]: df2 = pd.DataFrame({"chave": ["B", "D", "D", "E"], "valor": np.random.randn(4)})
Suponha que temos duas tabelas de banco de dados com o mesmo nome e estrutura de nossos DataFrames.
Agora vamos examinar os vários tipos de JOINs.
JUNÇÃO INTERNA
SELECIONE *
FROM df1
INNER JOIN df2 ON
df1.key = df2.key;
# merge executa um INNER JOIN por padrão Em [26]:

pd.merge(df1, df2, on="key")
Saída [26]:
chave valor_x valor_y B -0,282863
0 1,212112 D -1,135632 -0,173215
1 D -1,135632 0,119209
2
merge() também oferece parâmetros para casos em que você deseja unir a coluna de um DataFrame com o índice de outro DataFrame.
Em [27]: indexed_df2 = df2.set_index("chave")
Em [28]: pd.merge(df1, indexed_df2, left_on="key", right_index=True)

Saída [28]:
chave valor_x valor_y B -0,282863
1 1,212112
3 D -1,135632 -0,173215 D
3 -1,135632 0,119209

JUNÇÃO EXTERIOR ESQUERDA
Mostrar todos os registros do df1.
SELECIONE *
DE df1
JUNÇÃO EXTERIOR ESQUERDA df2
ON df1.key = df2.key;
Em [29]: pd.merge(df1, df2, on="key", how="left")

Fora[29]:
valor-chave_x valor_y
0 A 0,469112 NaN
1 B -0,282863 1,212112
2 C -1,509059 D NaN
3 -1,135632 -0,173215
4 D -1,135632 0,119209
JUNTE-SE À DIREITA
Mostrar todos os registros do df2.
SELECIONE *
DE df1
JUNÇÃO EXTERIOR DIREITA df2
Em [30]: pd.merge(df1, df2, on="key", how="right")

Fora[30]:
0 B -0,282863 1,212112
1 D -1,135632 -0,173215
2 D -1,135632 0,119209
3 E NaN -1,044236
JUNTE-SE COMPLETO
O pandas também permite FULL JOINs, que exibem ambos os lados do conjunto de dados, independentemente de as colunas unidas encontrarem ou não um
corresponder. No momento da escrita, FULL JOINs não são suportados em todos os RDBMS (MySQL).
Mostre todos os registros de ambas as tabelas.
SELECIONE *
DE df1
JUNÇÃO EXTERIOR COMPLETA df2
Em [31]: pd.merge(df1, df2, on="key", how="outer")

Fora[31]:
1.4. Tutoriais 83
0 Um 0,469112 NaN
1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 E NaN -1,044236
UNIÃO
UNION ALL pode ser executado usando concat().
Em [32]: df1 = pd.DataFrame(

....: {"cidade": ["Chicago", "São Francisco", "Nova York"], "classificação": range(1, 4)}
....: )
....:

....: {"cidade": ["Chicago", "Boston", "Los Angeles"], "classificação": [1, 4, 5]}
....: )
....:
SELECIONE cidade, classificação

DE df1
UNIÃO TODOS
DE df2;
/*
classificação da cidade
Chicago 1
São Francisco 2
Cidade de Nova York 3
Chicago 1
Boston 4
Los Angeles*/ 5
Em [34]: pd.concat([df1, df2])

Fora[34]:
0 Chicago 1
1 São Francisco 2
2 Cidade de Nova York 3
0 Chicago 1
14 Boston
25 Los Angeles
O UNION do SQL é semelhante ao UNION ALL, porém UNION removerá linhas duplicadas.

DE df1

UNIÃO
DE df2;
- observe que há apenas um disco de Chicago desta vez
/*
Chicago 1
São Francisco 2
Cidade de Nova York 3
Boston 4
Los Angeles*/ 5
Nos pandas, você pode usar concat() em conjunto com drop_duplicates().
Em [35]: pd.concat([df1, df2]).drop_duplicates()

Fora[35]:
0 Chicago 1
1 São Francisco 2
2 Cidade de Nova York 1 3
Boston 4
2 Los Angeles 5
LIMITE
SELECIONE * NAS dicas

LIMITE 10;
Em [36]: dicas.head(10)
Fora[36]:
4 Masculino Masculino Masculino 24,59 Sem jantar ao sol 4
5 25,29 4,71 3,61 Sem jantar ao sol 4
7 26,88 3,12 15,04 Sem jantar ao sol 4
8 1,96 14,78 3,23 Sem jantar ao sol 2
9 Sem
Masculino Masculino jantarMasculino
Masculino ao sol Masculino 2
1.4. Tutoriais 85
equivalentes do pandas para algumas funções analíticas e agregadas SQL
N linhas principais com deslocamento
-- MySQL
SELECIONE * NAS dicas
ENCOMENDAR POR dica DESC
LIMITE 10 DESLOCAMENTO 5;
Em [37]: dicas.nlargest(10 + 5, columns="tip").tail(10)

Fora[37]:
dica total_bill sexo fumante dia 23,17 tamanho do tempo
183 6,50 Masculino Sim Jantar ao Dom 28,17 6,50 Feminino Sim 4
214 Sábado Jantar 32,40 6,00 Masculino Não Jantar ao Dom 3
47 29,03 5,92 Masculino Não Sábado Jantar 24,71 5,85 Masculino 4
239 Não Qui Almoço 23,33 5,65 Masculino Sim Dom Jantar 30,40 3
88 5,60 Masculino Não Jantar ao Sol 34,81 5,2 0 Feminino 2
181 2
44 4
52 Sem jantar ao sol 4
85 34,83 5,17 Feminino Sem almoço na quinta 4
211 25,89 5,16 Masculino Sim Sábado Jantar 4
N principais linhas por grupo
-- Função analítica ROW_NUMBER() da Oracle

SELECIONE * DE (
SELECIONAR
t.*,
ROW_NUMBER() OVER(PARTIÇÃO POR dia ORDER BY total_bill DESC) AS rn
A PARTIR DE dicas t
)
ONDE rn < 3
ORDENAR POR dia, RN;
Em [38]: (
....: dicas.assign(
....: rn=dicas.sort_values(["total_bill"], ascendente=Falso)
....: .groupby(["dia"])
....: .cumcount()
....: +1
....: )
....: .query("rn < 3")
....: .sort_values(["dia", "rn"])
....: )
....:
Fora[38]:
gorjeta total_bill 40,17 fumante sexual dia horário tamanho RN
95 4,73 28,97 3,00 Macho Sim, sexta-feira, jantar 4 1
90 Macho Sim, sexta-feira, jantar 2 2

170 50,81 10,00 Macho Sim Sábado Jantar 3 1

212 48,33 9,00 Macho Sem jantar de sábado 4 2
156 48,17 5,00 Macho Sem jantar ao sol 6 1
182 45,35 3,50 Macho Sim Jantar ao Sol 3 2
197 43,11 5,00 Feminino Masculino Sim, quinta-feira, almoço 4 1
142 41,19 5,00 Sem almoço na quinta 5 2
o mesmo usando a função rank(method='first')
Em [39]: (
....: dicas.assign(
....: rnk=tips.groupby(["dia"])["total_bill"].rank(
....: método="primeiro", ascendente=Falso
....: )
....: )
....: .query("rnk < 3")
....: .sort_values(["dia", "rnk"])
....: )
....:
Fora[39]:
conta_total dica dia do fumante sexual tamanho do tempo rnk
95 40,17 4,73 Macho Sim, sexta-feira, jantar 4 1,0
90 28,97 3,00 Sim, sexta-feira, jantar 2 2,0
170 50,81 10,00 Sim Sábado Jantar 3 1,0
212 48,33 9,00 Sem jantar de sábado 4 2,0
156 48,17 5,00 Sem jantar ao sol 6 1,0
182 45,35 3,50 Sim Jantar ao Sol 3 2,0
197 Masculino Masculino Masculino Sim, quinta-feira, almoço 4 1,0
142 Sem 5,00
Masculino Masculino 43,11 5,00 Feminino 41,19 almoço na quinta
Masculino 5 2,0
-- Função analítica RANK() da Oracle

SELECIONE * DE (
SELECIONAR
t.*,
RANK() OVER(PARTIÇÃO POR sexo ORDER POR dica) AS rnk
A PARTIR DE dicas t
ONDE dica < 2
)
ONDE classificação < 3
ORDEM POR sexo, rnk;
Vamos encontrar dicas com (classificação <3) por grupo de gênero para (dicas <2). Observe que ao usar a função rank(method='min')
rnk_min permanece o mesmo para a mesma dica (como a função RANK() da Oracle)
Em [40]: (
....: dicas[dicas["dica"] < 2]
....: .assign(rnk_min=dicas.groupby(["sexo"])["dica"].rank(método="min"))
....: .query("rnk_min < 3")
....: .sort_values(["sexo", "rnk_min"])
....: )
....:
Fora[40]:
1.4. Tutoriais 87
dica total_bill dia do fumante sexual tamanho do tempo rnk_min

67 3,07 1,00 Feminino Sim Sábado Jantar 1 1,0
92 5,75 1,00 Feminino Sim, sexta-feira, jantar 2 1,0
111 7,25 1,00 Feminino Sem jantar de sábado 1 1,0
236 12,60 1,00 Masculino Sim Sábado Jantar 32,83 1,17 2 1,0
237 Masculino Sim Sábado Jantar 2 2,0
ATUALIZAR
Dicas de ATUALIZAÇÃO
DEFINIR dica = dica*2

ONDE ponta < 2;
Em [41]: dicas.loc[tips["tip"] < 2, "tip"] *= 2
EXCLUIR
EXCLUIR DE dicas
ONDE ponta > 9;
No pandas selecionamos as linhas que devem permanecer em vez de excluí-las:
Em [42]: dicas = dicas.loc[tips["tip"] <= 9]
Comparação com planilhas
Como muitos usuários potenciais do pandas têm alguma familiaridade com programas de planilhas como o Excel, esta página destina-se a
forneça alguns exemplos de como várias operações de planilha seriam realizadas usando pandas. Esta página usará
terminologia e link para documentação do Excel, mas muitas coisas serão iguais/semelhantes no Planilhas Google, LibreOffice
Calc, Apple Numbers e outros softwares de planilhas compatíveis com Excel.
biblioteca.

Estruturas de dados
Tradução de terminologia geral
pandas Planilha
Quadro de dados Excel
Series coluna
Índice títulos de linha
linha linha
NaN célula vazia
Quadro de dados
Um DataFrame no pandas é análogo a uma planilha do Excel. Embora uma pasta de trabalho do Excel possa conter várias planilhas, os
DataFrames do pandas existem de forma independente.
Series
Uma série é a estrutura de dados que representa uma coluna de um DataFrame. Trabalhar com uma série é análogo a fazer referência a
uma coluna de uma planilha.
Índice
Cada DataFrame e Série possui um Índice, que são rótulos nas linhas dos dados. Nos pandas, se nenhum índice for especificado, um
RangeIndex é usado por padrão (primeira linha = 0, segunda linha = 1 e assim por diante), análogo aos títulos/números de linha em planilhas.
No pandas, os índices podem ser definidos como um (ou vários) valores exclusivos, o que é como ter uma coluna usada como identificador
de linha em uma planilha. Ao contrário da maioria das planilhas, esses valores de índice podem ser usados para fazer referência às linhas.
(Observe que isso pode ser feito no Excel com referências estruturadas.) Por exemplo, em planilhas, você referenciaria a primeira linha
como A1:Z1, enquanto em pandas você poderia usar populaciones.loc['Chicago'].
Os valores de índice também são persistentes, portanto, se você reordenar as linhas em um DataFrame, o rótulo de uma linha específica não muda.
Consulte a documentação de indexação para saber mais sobre como usar um índice de maneira eficaz.
A maioria das operações do pandas retorna cópias do Series/DataFrame. Para fazer as alterações “permanecerem”, você precisará atribuir
uma nova variável:
1.4. Tutoriais 89
Entrada/saída de dados
Construindo um DataFrame a partir de valores
Em uma planilha, os valores podem ser digitados diretamente nas células.
Um DataFrame do pandas pode ser construído de muitas maneiras diferentes, mas para um pequeno número de valores, geralmente é conveniente
para especificá-lo como um dicionário Python, onde as chaves são os nomes das colunas e os valores são os dados.
Em [3]: df = pd.DataFrame({"x": [1, 3, 5], "y": [2, 4, 6]})
Em [4]: df
Fora[4]:
xy
012
134
256
Lendo dados externos
Tanto o Excel quanto o pandas podem importar dados de várias fontes em vários formatos.
CSV
Vamos carregar e exibir o conjunto de dados de dicas dos testes do pandas, que é um arquivo CSV. No Excel, você baixaria e
em seguida, abra o CSV. No pandas, você passa a URL ou caminho local do arquivo CSV para read_csv():
Em [5]: url = (
...: "https://raw.github.com/pandas-dev"
...: "/pandas/main/pandas/tests/io/data/csv/tips.csv"
... :)
...:
Em [7]: dicas
Fora[7]:
0 16,99 1,01 Feminino 10,34 Sem Jantar ao Sol 2
1 1,66 Masculino 21,01 3,50 Sem Jantar ao Sol 3
2 Masculino 23,68 3,31 Sem Jantar ao Sol 3
.. ... ... ... ... ... ... ...


240 27,18 2,00 Feminino Sim Sábado Jantar 2
241 22h67 2h00 Masculino Sim Sábado Jantar 2
243 18,78 3,00 Feminino Sem jantar na quinta 2
Assim como o Assistente de Importação de Texto do Excel, read_csv pode usar vários parâmetros para especificar como os dados devem ser analisados.
Por exemplo, se os dados fossem delimitados por tabulações e não tivessem nomes de colunas, o comando pandas seria:
dicas = pd.read_csv("dicas.csv", sep="\t", header=Nenhum)
# alternativamente, read_table é um alias para read_csv com delimitador de tabulação

dicas = pd.read_table("tips.csv", header=None)
Arquivos Excel
O Excel abre vários formatos de arquivo Excel clicando duas vezes neles ou usando o menu Abrir. Nos pandas, você usa especial
métodos para ler e escrever de/ para arquivos Excel.
Vamos primeiro criar um novo arquivo Excel com base no dataframe de dicas do exemplo acima:
dicas.to_excel("./tips.xlsx")
Caso deseje acessar posteriormente os dados no arquivo dicas.xlsx, você pode lê-los em seu módulo usando
dicas_df = pd.read_excel("./tips.xlsx", index_col=0)
Você acabou de ler um arquivo Excel usando pandas!
Limitando a produção
Os programas de planilha mostrarão apenas uma tela cheia de dados por vez e depois permitirão que você role, então não há realmente
necessidade de limitar a produção. Nos pandas, você precisará pensar um pouco mais no controle de como seus DataFrames são
exibido.
Por padrão, o pandas truncará a saída de DataFrames grandes para mostrar a primeira e a última linha. Isso pode ser substituído por
alterando as opções do pandas ou usando DataFrame.head() ou DataFrame.tail().
Fora[8]:
3 Masculino 24,59 3,61 Feminino Sem jantar ao sol 2
1.4. Tutoriais 91
Exportando dados
Por padrão, o software de planilha para desktop salvará em seu respectivo formato de arquivo (.xlsx, .ods, etc.). Você pode, no entanto,
salve em outros formatos de arquivo.
O pandas pode criar arquivos Excel, CSV ou vários outros formatos.
Operações de dados
Operações em colunas
Nas planilhas, as fórmulas geralmente são criadas em células individuais e depois arrastadas para outras células para serem computadas.
outras colunas. Nos pandas, você pode realizar operações diretamente em colunas inteiras.
O pandas fornece operações vetorizadas especificando a série individual no DataFrame. Novas colunas podem ser
atribuído da mesma forma. O método DataFrame.drop() elimina uma coluna do DataFrame.
Em [9]: dicas["total_bill"] = dicas["total_bill"] - 2
Em [10]: dicas["new_bill"] = dicas["total_bill"] / 2
Em [11]: dicas
Fora[11]:
dica total_bill fumante sexual tamanho do dia new_bill
0 14,99 1,01 Feminino 8,34 Sem jantar ao sol 2 7.495
1 1,66 Masculino 19,01 3,50 Sem jantar ao sol 3 4.170
2 Masculino 21,68 3,31 Sem jantar ao sol 3 9.505
4 Feminino Sem jantar ao sol 4 11.295
.. ... ... ... ... ... ... ... ...
239 27,03 5,92 Masculino Não Sábado Jantar 25,18 2,00 3 13.515
240 Feminino Sim Sábado Jantar 20,67 2,00 Masculino Sim 2 12.590
241 Sábado Jantar 15,82 1,75 Masculino Não Sábado Jantar 2 10.335
242 16,78 3,00 Feminino Sem Qui Jantar 2 7.910
243 2 8.390
Em [12]: dicas = dicas.drop("new_bill", eixo=1)
Observe que não precisamos dizer para fazer essa subtração célula por célula - o pandas cuida disso para nós. Veja como criar
novas colunas derivadas de colunas existentes.

Filtragem
No Excel, a filtragem é feita através de um menu gráfico.

Fora[13]:
1.4. Tutoriais 93

.. ... ... ... ... ... ... ...
241 Sábado Jantar Não Sábado Jantar Não Qui Jantar 2
242 15,82 1,75 2
Verdadeiro.
Em [15]: é_jantar
Fora[15]:
0 Verdadeiro
1 Verdadeiro
2 Verdadeiro
3 Verdadeiro
4 Verdadeiro
...
239 Verdadeiro
240 Verdadeiro
241 Verdadeiro
242 Verdadeiro
243 Verdadeiro
Fora[16]:
Verdadeiro 176
Falso 68
Fora[17]:
.. ... ... ... ... ... ... ...
241 Sábado Jantar 2


Lógica se/então
Digamos que queremos fazer uma coluna de balde com valores baixos e altos, com base no fato de total_bill ser menor
ou mais de $ 10.
Nas planilhas, a comparação lógica pode ser feita com fórmulas condicionais. Usaríamos uma fórmula de =SE(A2 < 10,
"baixo", "alto"), arrastado para todas as células em uma nova coluna do bucket.
A mesma operação em pandas pode ser realizada usando o método where from numpy.
Em [18]: dicas["bucket"] = np.where(tips["total_bill"] < 10, "low", "high")
Em [19]: dicas
Fora[19]:
dica total_bill dia do fumante sexual balde de tamanho de tempo
0 14,99 1,01 Feminino Sem jantar ao sol 2 alto
1 8,34 1,66 Masculino Sem jantar ao sol 3 baixo
2 19,01 3,50 Masculino Sem jantar ao sol 3 alto

3 21,68 3,31 Masculino 22,59 Sem jantar ao sol 2 alto
4 3,61 Feminino Sem jantar ao sol 4 alto
.. ... ... ... ... ... ... ... ...
239 27,03 5,92 Masculino Não Sábado Jantar 25,18 3 alto
240 2,00 Feminino Sim Sábado Jantar 20,67 2,00 Masculino Sim 2 alto
241 Sábado Jantar 15,82 1,75 Masculino Não Sábado Jantar 2 alto
242 16,78 3,00 Feminino Não Qui Jantar 2 alto
243 2 alto
1.4. Tutoriais 95
Funcionalidade de data
Esta seção se referirá a “datas”, mas os carimbos de data e hora são tratados de forma semelhante.
Podemos pensar na funcionalidade de data em duas partes: análise e saída. Nas planilhas, os valores de data geralmente são analisados
automaticamente, embora exista uma função DATEVALUE se você precisar. Nos pandas, você precisa converter explicitamente
texto para objetos de data e hora, durante a leitura de um CSV ou uma vez em um DataFrame.
Depois de analisadas, as planilhas exibem as datas em um formato padrão, embora o formato possa ser alterado. Nos pandas, você
geralmente deseja manter as datas como objetos de data e hora enquanto você faz cálculos com elas. Produzindo partes de datas
(como o ano) é feito por meio de funções de data em planilhas e propriedades de data e hora em pandas.
Dadas a data1 e a data2 nas colunas A e B de uma planilha, você pode ter estas fórmulas:
coluna Fórmula
data1_ano =ANO(A2)
data2_mês =MÊS(B2)
data1_próximos =DATA(ANO(A2),MÊS(A2)+1,1)
meses_entre =DATEDIF(A2,B2,"M")
As operações equivalentes do pandas são mostradas abaixo.
Em [20]: dicas["data1"] = pd.Timestamp("2013-01-15")
Em [21]: dicas["date2"] = pd.Timestamp("2015-02-15")
Em [22]: dicas["data1_ano"] = dicas["data1"].dt.ano
Em [23]: dicas["data2_mês"] = dicas["data2"].dt.mês
Em [24]: dicas["date1_next"] = dicas["date1"] + pd.offsets.MonthBegin()
Em [25]: dicas["meses_entre"] = dicas["data2"].dt.to_period("M") - dicas[

....: "data1"
....: ].dt.to_period("M")
....:
Em [26]: dicas[
....: ["data1", "data2", "data1_ano", "data2_mês", "data1_próximo", "meses_
ÿÿentre"]
....: ]
....:
Fora[26]:
data1 data2 data1_ano data2_mês data1_próximos meses_entre
0 2013-01-15 2015-02-15 1 2013 2 01/02/2013 <25 * Fim do mês>
2013-01-15 2015-02-15 2 2013 2 01/02/2013 <25 * Fim do mês>
2013-01-15 2015-02-15 3 2013 2 01/02/2013 <25 * Fim do mês>
2013-01-15 2015-02-15 4 2013-01- 2013 2 01/02/2013 <25 * Fim do mês>
15 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
.. ... ... ... ... ... ...
239 15/01/2013 15/02/2015 240 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 241 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 242 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2015 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>

243 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
Consulte Funcionalidade de série temporal/ data para obter mais detalhes.
Seleção de colunas
Nas planilhas, você pode selecionar as colunas desejadas:
• Ocultar colunas
• Excluindo colunas
• Referenciar um intervalo de uma planilha para outra
Como as colunas da planilha normalmente são nomeadas em uma linha de cabeçalho, renomear uma coluna é simplesmente uma questão de alterar o
texto nessa primeira célula.
As mesmas operações são expressas nos pandas abaixo.
Mantenha certas colunas
Em [27]: dicas[["sexo", "total_bill", "dica"]]

Fora[27]:
dica de sexo total_bill
0 Feminino 14,99 1,01
1 Masculino 8,34 1,66
2 Masculino 19.01 3.50
4 Feminino 22,59 3,61
.. ... ... ...
239 Macho 27,03 5,92
240 Feminino 25h18 2h00
241 20,67 2,00
Masculino 242 Macho 15,82 1,75
243 Feminino 16,78 3,00
Soltar uma coluna
Em [28]: dicas.drop("sexo", eixo=1)

Fora[28]:
0 14.99 1.01 Sem Jantar ao Sol 2
1 8,34 1,66 Sem Jantar ao Sol 3
2 19h01 3h50 Sem Jantar ao Sol 3
1.4. Tutoriais 97
.. ... ... ... ... ... ...

240 25h18 2h00 Sim Sábado Jantar 2
243 16,78 3,00 Sem jantar na quinta 2
Renomear uma coluna
Em [29]: dicas.rename(columns={"total_bill": "total_bill_2"})

Fora[29]:
gorjeta total_bill_2 tamanho do dia do fumante sexual
1 8,34 1,66 Macho Sem jantar ao sol 3
2 19.01 3.50 Macho Sem jantar ao sol 3
.. ... ... ... ... ... ... ...
240 Masculino 25,18 2,00 Sim Sábado Jantar 2
243 Feminino Masculino Masculino 16,78 3,00
Sem Feminino
jantar na quinta 2
Classificando por valores
A classificação em planilhas é realizada por meio da caixa de diálogo de classificação.

pandas tem um método DataFrame.sort_values() , que usa uma lista de colunas para classificar.
Em [30]: dicas = dicas.sort_values(["sexo", "total_bill"])
Em [31]: dicas
Fora[31]:
conta_total tamanho do dia do fumante sexual
67 ponta 1,07 1,00 Feminino Sim Sábado Jantar 1
92 3,75 1,00 Feminino 5,25 Sim Sexta Jantar 2
111 1,00 Feminino 6,35 1,50 Sem jantar de sábado 1
145 Feminino 6,51 1,25 Feminino Sem almoço na quinta 2
135 Sem almoço na quinta 2
.. ... ... ... ... ... ... ...
182 43,35 3,50 46,17 Macho Sim Jantar ao Sol 3
156 5,00 46,27 6,73 Macho Sem jantar ao sol 6
59 46,33 9,00 48,81 Macho Sem jantar de sábado 4
212 10,00 Macho Sem jantar de sábado 4
170 Macho Sim Sábado Jantar 3
Processamento de strings
Encontrando o comprimento da string
Nas planilhas, a quantidade de caracteres do texto pode ser encontrada com a função LEN . Isso pode ser usado com o TRIM
função para remover espaços em branco extras.
=LEN(APARAR(A2))
Você pode encontrar o comprimento de uma string de caracteres com Series.str.len(). No Python 3, todas as strings são strings Unicode.
len inclui espaços em branco à direita. Use len e rstrip para excluir espaços em branco à direita.
1.4. Tutoriais 99
Em [32]: dicas["time"].str.len()
Fora[32]:
67 6
92 6
111 6
145 5
135 5
..
182 6
156 6
59 6
212 6
170 6
Nome: hora, Comprimento: 244, dtype: int64
Em [33]: dicas["tempo"].str.rstrip().str.len()
Fora[33]:
67 6
92 6
111 6
145 5
135 5
..
182 6
156 6
59 6
212 6
170 6
Observe que isso ainda incluirá vários espaços na string, portanto não é 100% equivalente.
Encontrando a posição da substring
A função de planilha FIND retorna a posição de uma substring, com o primeiro caractere sendo 1.

Você pode encontrar a posição de um caractere em uma coluna de strings com o método Series.str.find() . encontrar pesquisas
para a primeira posição da substring. Se a substring for encontrada, o método retornará sua posição. Se não for encontrado, ele retorna
-1. Tenha em mente que os índices Python são baseados em zero.
Em [34]: dicas["sexo"].str.find("ale")
Fora[34]:
67 3
92 3
111 3
145 3
135 3
..
182 1
156 1
59 1
212 1
170 1
Nome: sexo, Comprimento: 244, dtype: int64
Extraindo substring por posição
As planilhas possuem uma fórmula MID para extrair uma substring de uma determinada posição. Para obter o primeiro caractere:
=MÉDIO(A2,1,1)
Com pandas você pode usar a notação [] para extrair uma substring de uma string por localização de posição. Tenha em mente que
Os índices Python são baseados em zero.
Em [35]: dicas["sexo"].str[0:1]
Fora[35]:
67F
92 F
1.4. Tutoriais 101


111 F
145 F
135 F
..
182 M
156 M
59 M
212 M
170 M
Nome: sexo, Comprimento: 244, dtype: objeto
Extraindo a enésima palavra
No Excel, você pode usar o Assistente de Texto para Colunas para dividir texto e recuperar uma coluna específica. (Observe que é
possível fazer isso também por meio de uma fórmula.)
A maneira mais simples de extrair palavras em pandas é dividir as strings por espaços e depois referenciar a palavra por índice. Observação
existem abordagens mais poderosas, caso você precise delas.
Em [36]: firstlast = pd.DataFrame({"String": ["John Smith", "Jane Cook"]})
Em [37]: firstlast["First_Name"] = firstlast["String"].str.split(" ", expand=True)[0]
Em [38]: firstlast["Last_Name"] = firstlast["String"].str.rsplit(" ", expand=True)[1]
Em [39]: primeiroúltimo
Fora[39]:
String Nome_Sobrenome
0 John Smith John Smith
1Jane Cook Jane Cozinhar
Mudança de caso
As planilhas fornecem funções UPPER, LOWER e PROPER para converter texto em maiúsculas, minúsculas e títulos,
respectivamente.
Os métodos pandas equivalentes são Series.str.upper(), Series.str.lower() e Series.str.title().
Em [40]: firstlast = pd.DataFrame({"string": ["John Smith", "Jane Cook"]})
Em [41]: firstlast["upper"] = firstlast["string"].str.upper()
Em [42]: firstlast["lower"] = firstlast["string"].str.lower()
Em [43]: firstlast["title"] = firstlast["string"].str.title()
Fora[44]:
título inferior da string
superior
0 John Smith JOHN SMITH John Smith John Smith
1 Jane Cook JANE COOK Jane Cook Jane Cook

Mesclando
As tabelas a seguir serão usadas nos exemplos de mesclagem:
Em [46]: df1
Fora[46]:
valor chave
0 Um 0,469112
1 B -0,282863
2 C-1.509059
3 D-1.135632
Em [48]: df2
Fora[48]:
valor
0 chave B 1.212112
1 D-0,173215
2 D 0,119209
3 E-1.044236
No Excel, a mesclagem de tabelas pode ser feita por meio de um VLOOKUP.
Os DataFrames do pandas possuem um método merge() , que fornece funcionalidade semelhante. Os dados não precisam ser classificados
com antecedência, e diferentes tipos de junção são realizados por meio da palavra-chave how.
Em [49]: inner_join = df1.merge(df2, on=["key"], how="inner")
Em [50]: inner_join
Fora[50]:
0 B -0,282863 1,212112
1 D -1,135632 -0,173215
2 D -1,135632 0,119209
1.4. Tutoriais 103

Em [51]: left_join = df1.merge(df2, on=["key"], how="left")
Em [52]: left_join
Fora[52]:
0 Um 0,469112 NaN
1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
Em [53]: right_join = df1.merge(df2, on=["key"], how="right")
Em [54]: right_join
Fora[54]:
0 B -0,282863 1,212112
1 D -1,135632 -0,173215
2 D -1,135632 0,119209
3 ENaN -1,044236
Em [55]: outer_join = df1.merge(df2, on=["key"], how="outer")
Em [56]: junção_externa
Fora[56]:
0 Um 0,469112 NaN
1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 E NaN -1,044236
mesclar tem uma série de vantagens sobre VLOOKUP:
• O valor de pesquisa não precisa ser a primeira coluna da tabela de pesquisa
• Se houver correspondência de várias linhas, haverá uma linha para cada correspondência, em vez de apenas a primeira
• Incluirá todas as colunas da tabela de pesquisa, em vez de apenas uma única coluna especificada
• Suporta operações de junção mais complexas
Outras considerações
Alça de preenchimento
Crie uma série de números seguindo um padrão definido em um determinado conjunto de células. Em uma planilha, isso seria feito por
shift+arrastar depois de inserir o primeiro número ou inserindo os primeiros dois ou três valores e arrastando.
Isso pode ser conseguido criando uma série e atribuindo-a às células desejadas.

Em [57]: df = pd.DataFrame({"AAA": [1] * 8, "BBB": lista(intervalo(0, 8))})
Em [58]: df
Fora[58]:
AAABBB
0 1 0
1 1 1
2 1 2
3 1 3
4 1 4
5 1 5
6 1 6
7 1 7
Em [59]: série = lista(intervalo(1, 5))
Em [60]: série
Fora[60]: [1, 2, 3, 4]
Em [61]: df.loc[2:5, "AAA"] = série
Em [62]: df
Fora[62]:
AAABBB
0 1 0
1 1 1
2 1 2
3 2 3
4 3 4
5 4 5
6 6
7 11 7
Eliminar duplicatas
O Excel possui funcionalidade integrada para remover valores duplicados. Isso é suportado em pandas via drop_duplicates().
....: {
....: "classe": ["A", "A", "A", "B", "C", "D"],
....: "contagem_alunos": [42, 35, 42, 50, 47, 45],
....: "all_pass": ["Sim", "Sim", "Sim", "Não", "Não", "Sim"],
....: }
....: )
....:
Em [64]: df.drop_duplicates()
Fora[64]:
turma estudante_contar tudo_pass
0 A 42 Sim
1 A 35 Sim
1.4. Tutoriais 105

3 B 50 Não
4 C 47 Não
5 D 45 Sim
Em [65]: df.drop_duplicates(["class", "student_count"])

Fora[65]:
0 A 42 Sim
1 A 35 Sim
3 B 50 Não
4 C 47 Não
5 D 45 Sim
Tabelas dinâmicas
Tabelas dinâmicas de planilhas podem ser replicadas em pandas por meio de Reshaping e tabelas dinâmicas. Usando o conjunto de dados de dicas
novamente, vamos encontrar a gratificação média por tamanho do grupo e sexo do servidor.
No Excel, usamos a seguinte configuração para a Tabela Dinâmica:
O equivalente em pandas:
Em [66]: pd.pivot_table(
....: dicas, valores = "dica", índice = ["tamanho"], colunas = ["sexo"], aggfunc = np.average
....: )
....:
Fora[66]:
sexo Fêmea Macho
tamanho
1 1,276667 1,920000
2 2,528448 2,614184
3 3,250000 3,476667
4 4.021111 4.172143

5 5,140000 3,750000
6 4,600000 5,850000
Adicionando uma linha
Supondo que estamos usando um RangeIndex (numerado 0, 1, etc.), podemos usar concat() para adicionar uma linha ao final de um
Quadro de dados.
Em [67]: df
Fora[67]:
0 A 42 Sim
1 A 35 Sim
2 A 42 Sim
3 B 50 Não
4 C 47 Não
5 D 45 Sim
Em [68]: new_row = pd.DataFrame([["E", 51, True]],

....: colunas=["classe", "conta_alunos", "all_pass"])
....:
Em [69]: pd.concat([df, new_row])

Fora[69]:
0 A 42 Sim
1 A 35 Sim
2 A 42 Sim
3 B 50 Não
4 C 47 Não
D 45 Sim
50 E 51 Verdadeiro
Localizar e substituir
A caixa de diálogo Localizar do Excel leva você às células correspondentes, uma por uma. Nos pandas, esta operação geralmente é feita por um período inteiro
coluna ou DataFrame de uma só vez por meio de expressões condicionais.
Em [70]: dicas
Fora[70]:
92 3,75 1,00 Feminino 5,25 Sim, sexta-feira, jantar 2
.. ... ... ... ... ... ... ...
156 5,00 Macho Sem jantar ao sol 6
1.4. Tutoriais 107


Em [71]: dicas == "Sol"

Fora[71]:
total_bill dica sexo fumante tamanho do dia
67 Falso Falso Falso Falso Falso Falso Falso
.. ... ... ... ... ... ... ...
182 Falso Falso Falso Falso Verdadeiro Falso Falso
156 Falso Falso Falso Falso Verdadeiro Falso Falso
Em [72]: dicas["dia"].str.contains("S")
Fora[72]:
67 Verdadeiro
92 Falso
111 Verdadeiro
145 Falso
135 Falso
...
182 Verdadeiro
156 Verdadeiro
59 Verdadeiro
212 Verdadeiro
170 Verdadeiro
Nome: dia, Comprimento: 244, dtype: bool
O replace() do pandas é comparável ao Replace All do Excel.
Em [73]: dicas.replace("Qui", "Quinta")

Fora[73]:
92 3,75 1,00 Feminino Sim, sexta-feira, jantar 2
111 5,25 1,00 Feminino 6,35 Sem jantar de sábado 1
145 1,50 Feminino 6,51 1,25 Sem almoço na quinta 2
135 Feminino Sem almoço na quinta 2
.. ... ... ... ... ... ... ...


Comparação com SAS
Para usuários potenciais vindos do SAS, esta página tem como objetivo demonstrar como diferentes operações SAS seriam realizadas em pandas.
biblioteca.
Estruturas de dados
pandas SAS
Quadro de dados conjunto de dados
coluna variável
linha observação
agrupar por POR grupo
NaN .
Quadro de dados
Um DataFrame no pandas é análogo a um conjunto de dados SAS - uma fonte de dados bidimensional com colunas rotuladas que podem
ser de tipos diferentes. Como será mostrado neste documento, quase qualquer operação que possa ser aplicada a um conjunto de dados usando
A etapa DATA do SAS também pode ser realizada em pandas.
Series
Uma série é a estrutura de dados que representa uma coluna de um DataFrame. SAS não possui uma estrutura de dados separada
para uma única coluna, mas em geral, trabalhar com uma Série é análogo a fazer referência a uma coluna na etapa DATA.
1.4. Tutoriais 109

Índice
Cada DataFrame e Série possui um Índice - que são rótulos nas linhas dos dados. O SAS não possui um conceito exatamente análogo. As
linhas de um conjunto de dados são essencialmente não rotuladas, exceto um índice inteiro implícito que pode ser acessado durante a etapa
DATA (_N_).
Nos pandas, se nenhum índice for especificado, um índice inteiro também será usado por padrão (primeira linha = 0, segunda linha = 1 e assim por diante).
Embora o uso de um Índice ou MultiIndex rotulado possa permitir análises sofisticadas e, em última análise, seja uma parte importante de
compreensão do pandas, para esta comparação iremos essencialmente ignorar o Índice e apenas tratar o DataFrame como uma coleção de
colunas. Consulte a documentação de indexação para saber mais sobre como usar um índice de maneira eficaz.
uma nova variável:
Um conjunto de dados SAS pode ser construído a partir de valores especificados, colocando os dados após uma instrução datalines e especificando os
nomes das colunas.
dados df;
entrada xy ;
linhas de
dados; 1 2 3 4 5 6
;
correr;
Um DataFrame do pandas pode ser construído de muitas maneiras diferentes, mas para um pequeno número de valores, geralmente é
conveniente especificá-lo como um dicionário Python, onde as chaves são os nomes das colunas e os valores são os dados.
Em [2]: df

Fora[2]:
xy
012
134
256
Assim como o SAS, o pandas fornece utilitários para leitura de dados de vários formatos. O conjunto de dados de dicas, encontrado nos pandas
testes (csv) serão usados em muitos dos exemplos a seguir.
SAS fornece PROC IMPORT para ler dados CSV em um conjunto de dados.
proc import datafile='dicas.csv' dbms=csv out=dicas substituir;

getnomes=sim;
correr;
O método pandas é read_csv(), que funciona de forma semelhante.
Em [3]: url = (
...: "https://raw.github.com/pandas-dev/"
...: "pandas/main/pandas/tests/io/data/csv/tips.csv"
... :)
...:
Em [5]: dicas
Fora[5]:
.. ... ... ... ... ... ... ...
243 Masculino 18,78 3,00 Feminino Sem jantar na quinta 2
Assim como PROC IMPORT, read_csv pode receber vários parâmetros para especificar como os dados devem ser analisados. Por exemplo,
se os dados fossem delimitados por tabulações e não tivessem nomes de colunas, o comando pandas seria:

1.4. Tutoriais 111

Além de texto/csv, o pandas suporta uma variedade de outros formatos de dados, como Excel, HDF5 e bancos de dados SQL. Esses
são todos lidos por meio de uma função pd.read_*. Consulte a documentação do IO para obter mais detalhes.
Fora[1]:
3 Masculino 24,59 3,61 Feminino Sem Jantar ao Sol 2
4 Sem Jantar ao Sol 4
O equivalente em SAS seria:
proc imprimir dados=df(obs=5);

correr;
Exportando dados
O inverso de PROC IMPORT no SAS é PROC EXPORT
proc exportar dados=dicas outfile='tips2.csv' dbms=csv;

correr;
Da mesma forma, no pandas, o oposto de read_csv é to_csv(), e outros formatos de dados seguem uma API semelhante.
dicas.to_csv("dicas2.csv")
Na etapa DATA, expressões matemáticas arbitrárias podem ser usadas em colunas novas ou existentes.
dicas de dados ;
definir dicas;
total_bill = total_bill - 2;
nova_bill = total_bill / 2;
correr;

Em [3]: dicas
Fora[3]:
0 14,99 1,01 Feminino 8,34 Sem jantar ao sol 2 7.495
1 1,66 Masculino 19,01 3,50 Sem jantar ao sol 3 4.170
4 Feminino Sem jantar ao sol 4 11.295
.. ... ... ... ... ... ... ... ...
242 16,78 3,00 Feminino Sem Qui Jantar 2 7.910
243 2 8.390
Filtragem
A filtragem no SAS é feita com uma instrução if ou where, em uma ou mais colunas.
dicas de dados ;
definir dicas;
se total_bill > 10;
correr;
dicas de dados ;
definir dicas;
onde total_bill > 10;
/* equivalente neste caso - onde acontece antes do
A etapa DATA começa e também pode ser usada em instruções PROC */
correr;

Fora[1]:
.. ... ... ... ... ... ... ...
1.4. Tutoriais 113


Verdadeiro.
Em [2]: é_jantar
Fora[2]:
0 Verdadeiro
1 Verdadeiro
2 Verdadeiro
3 Verdadeiro
4 Verdadeiro
...
239 Verdadeiro
240 Verdadeiro
241 Verdadeiro
242 Verdadeiro
243 Verdadeiro
Fora[3]:
Verdadeiro 176
Falso 68
Fora[4]:
.. ... ... ... ... ... ... ...

Lógica se/então
No SAS, a lógica se/então pode ser usada para criar novas colunas.
dicas de dados ;
definir dicas;
balde de formato $ 4.;
se total_bill < 10 então bucket = 'low';

senão balde = 'alto';
correr;
Em [2]: dicas
Fora[2]:
dica total_bill dia do fumante sexual balde de tamanho de tempo
0 14,99 1,01 Feminino Sem jantar ao sol 2 alto
1 8,34 1,66 Masculino 19,01 Sem jantar ao sol 3 baixo
2 3,50 Masculino 21,68 3,31 Sem jantar ao sol 3 alto
3 Masculino 22,59 3,61 Sem jantar ao sol 2 alto
4 Feminino Sem jantar ao sol 4 alto
.. ... ... ... ... ... ... ... ...
239 27,03 5,92 Masculino Não Sábado Jantar 25,18 3 alto
240 2,00 Feminino Sim Sábado Jantar 20,67 2,00 Masculino Sim 2 alto
241 Sábado Jantar 15,82 1,75 Masculino Não Sábado Jantar 2 alto
242 16,78 3,00 Feminino Não Qui Jantar 2 alto
243 2 alto
O SAS fornece uma variedade de funções para realizar operações em colunas de data/datahora.
dicas de dados ;
definir dicas;
formato data1 data2 data1_maismês mmddyy10.;
data1 = mdia(1, 15, 2013);
data2 = mdia(2, 15, 2015);
data1_ano = ano(data1);
data2_mês = mês(data2);
* mudar a data para o início do próximo intervalo;
data1_próximo = intnx('MÊS', data1, 1);
*
contar intervalos entre datas;
meses_entre = intck('MÊS', data1, data2);
correr;
As operações equivalentes do pandas são mostradas abaixo. Além dessas funções, o pandas suporta outras séries temporais
recursos não disponíveis no Base SAS (como reamostragem e compensações personalizadas) - consulte a documentação da série temporal para obter mais informações
detalhes.
1.4. Tutoriais 115


...: "data1"
...: ].dt.to_period("M")
...:
Em [7]: dicas[
...: ["data1", "data2", "data1_ano", "data2_mês", "data1_próximo", "meses_entre
ÿÿ"]
...: ]
...:
Fora[7]:
0 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
2 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
3 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
4 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
.. ... ... ... ... ... ...
239 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
240 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
241 15/01/2013 15/02/2015 242 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 243 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
O SAS fornece palavras-chave na etapa DATA para selecionar, eliminar e renomear colunas.
dicas de dados ;
definir dicas;
mantenha a dica do sexo total_bill;
correr;
dicas de dados ;
definir dicas;
abandone o sexo;
correr;
dicas de dados ;

definir dicas;
renomear total_bill=total_bill_2;
correr;

Fora[1]:
0 Feminino 14,99 1,01
4 Feminino 22,59 3,61
.. ... ... ...
239 Macho 27,03 5,92
241 Macho 20,67 2,00
242 Macho 15,82 1,75
243 Feminino 16,78 3,00
Soltar uma coluna

Fora[2]:
0 14,99 1,01 8,34 Sem Jantar ao Sol Sem 2
1 1,66 19,01 3,50 Jantar ao Sol 3
.. ... ... ... ... ... ...
1.4. Tutoriais 117

Renomear uma coluna

Fora[1]:
4 Masculino 22,59 3,61 Feminino Sem jantar ao sol 4
.. ... ... ... ... ... ... ...
239 27,03 5,92 Masculino 25,18 Sem jantar de sábado 3
240 2,00 Feminino 20,67 2,00 Sim Sábado Jantar 2
241 Masculino 15,82 1,75 Sim Sábado Jantar 2
242 Masculino 16,78 3,00 Sem jantar de sábado 2
243 Feminino Sem jantar na quinta 2
A classificação no SAS é realizada via PROC SORT
proc sort data=dicas;

por sexo total_bill;
correr;
Em [2]: dicas
Fora[2]:
92 3,75 1,00 Feminino Sim, sexta-feira, jantar 2
111 5,25 1,00 Feminino 6,35 Sem jantar de sábado 1
145 1,50 Feminino 6,51 1,25 Sem almoço na quinta 2
135 Feminino Sem almoço na quinta 2
.. ... ... ... ... ... ... ...

SAS determina o comprimento de uma sequência de caracteres com as funções LENGTHN e LENGTHC . COMPRIMENTO exclui
espaços em branco à direita e LENGTHC inclui espaços em branco à direita.
dados _nulos_;
definir dicas;
colocar(COMPRIMENTO(tempo));
colocar(LENGTHC(hora));
correr;
Fora[1]:
67 6
92 6
111 6
145 5
135 5
..
182 6
156 6
59 6
212 6
170 6
Em [2]: dicas["time"].str.rstrip().str.len()
Fora[2]:
67 6
92 6
111 6
145 5
135 5
..
182 6
156 6
59 6
212 6
170 6
1.4. Tutoriais 119

O SAS determina a posição de um caractere em uma string com a função FINDW . FINDW pega a string definida pelo
primeiro argumento e procura a primeira posição da substring fornecida como segundo argumento.
dados _nulos_;
definir dicas;
put(FINDW(sexo,'ale'));
correr;
Fora[1]:
67 3
92 3
111 3
145 3
135 3
..
182 1
156 1
59 1
212 1
170 1
O SAS extrai uma substring de uma string com base em sua posição com a função SUBSTR .
dados _nulos_;
definir dicas;
colocar(substr(sexo,1,1));
correr;
Fora[1]:
67F
92°F
111F
145°F
135 F
..
182 M
156 M
59 M

212 M
170 M
A função SAS SCAN retorna a enésima palavra de uma string. O primeiro argumento é a string que você deseja analisar e o
segundo argumento especifica qual palavra você deseja extrair.
dados primeiro por

último; string de entrada
$ 60.; Primeiro_Nome = scan(string, 1);
Sobrenome = scan(string, -1); linhas de
dados2; João
Smith; Jane
Cook; ;;;
correr;
A maneira mais simples de extrair palavras em pandas é dividir as strings por espaços e depois referenciar a palavra por índice. Observe
que existem abordagens mais poderosas, caso você precise delas.
Fora[4]:
Mudança de caso
As funções SAS UPCASE LOWCASE e PROPCASE alteram a caixa do argumento.
dados primeiro por

último; string de entrada
$ 60.; string_up = UPCASE(string);
string_low = LOWCASE(string);
string_prop = PROPCASE(string); linhas de
dados2; João
Smith; Jane
Cook;
;;;
correr;
1.4. Tutoriais 121

Fora[5]:
superior
Mesclando
Em [2]: df1
Fora[2]:
valor chave
0 Um 0,469112
1 B -0,282863
2 C-1.509059
3 D-1.135632
Em [4]: df2
Fora[4]:
valor
0 chave B 1.212112
1 D-0,173215
2 D 0,119209
3 E-1.044236
No SAS, os dados devem ser classificados explicitamente antes da fusão. Diferentes tipos de junções são realizadas usando o in= dummy
variáveis para rastrear se uma correspondência foi encontrada em um ou ambos os quadros de entrada.
proc ordenar dados=df1;

por chave;
correr;
proc ordenar dados=df2;

por chave;
correr;
dados left_join inner_join right_join outer_join;

mesclar df1(in=a) df2(in=b);

se a e b então produza inner_join;

se for , então produza left_join;
se b então produza right_join;
se a ou b, então produza outer_join;
correr;
com antecedência, e diferentes tipos de junção são realizados por meio da palavra-chave how.
Em [2]: inner_join
Fora[2]:
0 B -0,282863 1,212112
1 D -1,135632 -0,173215
2 D -1,135632 0,119209
Em [4]: left_join
Fora[4]:
0 Um 0,469112 NaN
1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
Em [6]: right_join
Fora[6]:
0 B -0,282863 1,212112
1 D -1,135632 -0,173215
2 D -1,135632 0,119209
3 ENaN -1,044236
Fora[8]:
0 Um 0,469112 NaN
1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 E NaN -1,044236
1.4. Tutoriais 123

Dados ausentes
Tanto o pandas quanto o SAS possuem uma representação para dados ausentes.
pandas representa dados ausentes com o valor flutuante especial NaN (não um número). Muitas das semânticas são as mesmas;
por exemplo, dados ausentes se propagam por meio de operações numéricas e são ignorados por padrão para agregações.
Fora[1]:
0 A 0,469112 B NaN
1 -0,282863 1,212112
2 C -1,509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 ENaN -1,044236
Em [2]: outer_join["value_x"] + outer_join["value_y"]

Fora[2]:
0 NaN
1 0,929249
2 NaN
3-1.308847
4 -1,016424
5 NaN
tipo d: float64
Em [3]: outer_join["value_x"].sum()
Saída[3]: -3,5940742896293765
Uma diferença é que os dados faltantes não podem ser comparados ao seu valor sentinela. Por exemplo, no SAS você poderia fazer isso para
filtrar valores ausentes.
dados outer_join_nulls;
definir outer_join;
se valor_x = .;
correr;
dados outer_join_no_nulls;
definir outer_join;
se valor_x ^= .;
correr;
Nos pandas, Series.isna() e Series.notna() podem ser usados para filtrar as linhas.
Em [1]: outer_join[outer_join["value_x"].isna()]
Fora[1]:
5 E NaN -1,044236
Em [2]: outer_join[outer_join["value_x"].notna()]
Fora[2]:
0 Um 0,469112 NaN

1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
pandas fornece uma variedade de métodos para trabalhar com dados ausentes. aqui estão alguns exemplos:
Eliminar linhas com valores ausentes
Em [3]: outer_join.dropna()
Fora[3]:
1 B -0,282863 1,212112
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
Preenchimento direto das linhas anteriores
Em [4]: outer_join.fillna(method="ffill")
Fora[4]:
0 A 0,469112 B NaN
1 -0,282863 1,212112
2 C-1,509059 1,212112
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 E -1.135632 -1.044236
Substitua os valores ausentes por um valor especificado
Usando a média:
Em [1]: outer_join["value_x"].fillna(outer_join["value_x"].mean())
Fora[1]:
0 0,469112
1-0,282863
2 -1.509059
3-1.135632
4 -1.135632
5 -0,718815
Nome: valor_x, dtype: float64
1.4. Tutoriais 125

Agrupar por
Agregação
O PROC SUMMARY do SAS pode ser usado para agrupar por uma ou mais variáveis-chave e calcular agregações em colunas numéricas.
dados de resumo do proc = dicas nway;

fumante sexual de classe;
var dica total_bill; saída
out=tips_summed sum=;
correr;
O pandas fornece um mecanismo de agrupamento flexível que permite agregações semelhantes. Consulte a documentação do groupby para
obter mais detalhes e exemplos.
Em [1]: dicas_summed = dicas.groupby(["sexo", "fumante"])[["total_bill", "tip"]].sum()
Em [2]: dicas_summed
Fora[2]:
conta_total dica
sexo fumante
Feminino Não 869,68 149,77
Sim 527,27 96,74
Masculino Não 1725,75 302,00
Sim 1217,07 183,07
Transformação
No SAS, se as agregações de grupo precisarem ser usadas com o quadro original, elas deverão ser mescladas novamente. Por exemplo,
para subtrair a média de cada observação por grupo de fumantes.
dados de resumo do proc =dicas faltando nway;

fumante de classe;
var total_bill; saída
out=smoker_means significa(total_bill)=group_bill; correr;
proc sort data=dicas; por

fumante;
correr;
dicas de
dados ; mesclar dicas(in=a) smoker_means(in=b); por
fumante;
adj_total_bill = total_bill - grupo_bill; se a e b;
correr;
O pandas fornece um mecanismo de transformação que permite que esse tipo de operação seja expresso sucintamente em uma operação.

Em [1]: gb = dicas.groupby("fumante")["total_bill"]
Em [2]: dicas["adj_total_bill"] = dicas["total_bill"] - gb.transform("mean")
Em [3]: dicas
Fora[3]:
conta_total fumante sexual tamanho do dia adj_total_bill
67 ponta 1,07 1,00 Feminino Sim Sábado Jantar -17.686344 1
92 3,75 1,00 Feminino 5,25 Sim Sexta Jantar Não 2 -15.006344
111 1,00 Feminino 6,35 1,50 Sábado Jantar Não Qui 1 -11.938278
145 Feminino 6,51 1,25 Feminino Almoço Não Qui Almoço 2 -10.838278
135 2 -10.678278
.. ... ... ... ... ... ... ... ...
182 43,35 3,50 46,17 Macho Sim Jantar ao Sol 3 24.593656
156 5,00 46,27 6,73 Macho Sem jantar ao sol 6 28.981722
59 46,33 9,00 48,81 Macho Sem jantar de sábado 4 29.081722
212 10,00 Macho Sem jantar de sábado 4 29.141722
170 Macho Sim Sábado Jantar 3 30.053656
Por processamento de grupo
Além da agregação, o pandas groupby pode ser usado para replicar a maioria dos outros processamentos por grupo do SAS. Para
Por exemplo, esta etapa DATA lê os dados por sexo/grupo de fumantes e filtra a primeira entrada de cada um.
proc sort data=dicas;

por fumante sexual;
correr;
dicas de dados_first ;
definir dicas;
por fumante sexual;
se FIRST.sex ou FIRST.smoker então produza;
correr;
Em pandas isso seria escrito como:
Em [4]: dicas.groupby(["sexo", "fumante"]).first()

Fora[4]:
dia de gorjeta total_bill tamanho do tempo adj_total_bill
sexo fumante
Feminino Não 5,25 1,00 Sábado Jantar 1,07 1,00 1 -11.938278
Sim Sábado Jantar 5,51 2,00 Qui Almoço 1 -17.686344
Masculino Não 5,25 5,15 Domingo Jantar 2 -11.678278
Sim 2 -13.506344
1.4. Tutoriais 127

Disco vs memória
O pandas opera exclusivamente na memória, onde existe um conjunto de dados SAS no disco. Isso significa que o tamanho dos dados que podem
ser carregados no pandas é limitado pela memória da sua máquina, mas também que as operações nesses dados podem ser mais rápidas.
Se for necessário processamento fora do núcleo, uma possibilidade é a biblioteca dask.dataframe (atualmente em desenvolvimento), que
fornece um subconjunto de funcionalidades do pandas para um DataFrame em disco
Interoperabilidade de dados
pandas fornece um método read_sas() que pode ler dados SAS salvos no formato binário XPORT ou SAS7BDAT.
libname xportout xport 'arquivo-transporte.xpt'; dados xportout.tips;

definir
dicas(renome=(total_bill=tbill)); nomes de variáveis xport
*
limitados a 6 caracteres;
correr;
df = pd.read_sas("arquivo-transporte.xpt") df =
pd.read_sas("arquivo binário.sas7bdat")
Você também pode especificar o formato do arquivo diretamente. Por padrão, o pandas tentará inferir o formato do arquivo com base em sua extensão.
df = pd.read_sas("arquivo-transporte.xpt", format="xport") df = pd.read_sas("arquivo-

binário.sas7bdat", format="sas7bdat")
XPORT é um formato relativamente limitado e sua análise não é tão otimizada quanto alguns dos outros leitores do pandas. Uma forma
alternativa de interoperar dados entre SAS e pandas é serializar para csv.
# versão 0.17, 10 milhões de linhas
Em [8]: % tempo df = pd.read_sas('big.xpt')

Tempo de parede: 14,6 s
Em [9]: % tempo df = pd.read_csv('big.csv')

Tempo de parede: 4,86 s
Comparação com Stata
Para usuários potenciais vindos do Stata , esta página tem como objetivo demonstrar como diferentes operações do Stata seriam realizadas
em pandas.
Se você é novo no mundo dos pandas, talvez queira ler primeiro 10 minutos para pandas para se familiarizar com a biblioteca.

Estruturas de dados
pandas Conjunto de
Quadro de dados dados estatísticos
coluna variável
linha observação por
agrupar por classificação

NaN .
Quadro de dados
Um DataFrame em pandas é análogo a um conjunto de dados Stata – uma fonte de dados bidimensional com colunas rotuladas que podem
ser de diferentes tipos. Como será mostrado neste documento, quase qualquer operação que possa ser aplicada a um conjunto de dados no
Stata também pode ser realizada no pandas.
Series
Uma série é a estrutura de dados que representa uma coluna de um DataFrame. O Stata não possui uma estrutura de dados separada para
uma única coluna, mas em geral, trabalhar com uma série é análogo a fazer referência a uma coluna de um conjunto de dados no Stata.
Índice
Cada DataFrame e Série possui um Índice – rótulos nas linhas dos dados. Stata não possui um conceito exatamente análogo. No Stata, as
linhas de um conjunto de dados são essencialmente não rotuladas, exceto um índice inteiro implícito que pode ser acessado com _n.
Nos pandas, se nenhum índice for especificado, um índice inteiro também será usado por padrão (primeira linha = 0, segunda linha = 1 e assim por diante).
Embora o uso de um Índice ou MultiIndex rotulado possa permitir análises sofisticadas e, em última análise, seja uma parte importante de
compreensão do pandas, para esta comparação iremos essencialmente ignorar o Índice e apenas tratar o DataFrame como uma coleção de
colunas. Consulte a documentação de indexação para saber mais sobre como usar um índice de maneira eficaz.
uma nova variável:
1.4. Tutoriais 129

Um conjunto de dados Stata pode ser construído a partir de valores especificados, colocando os dados após uma instrução de entrada e especificando os
nomes das colunas.
entrada xy
12
34
56
fim
Um DataFrame do pandas pode ser construído de muitas maneiras diferentes, mas para um pequeno número de valores, geralmente é
conveniente especificá-lo como um dicionário Python, onde as chaves são os nomes das colunas e os valores são os dados.
Em [4]: df
Fora[4]:
xy 0 1
2
134
256
Assim como o Stata, o pandas fornece utilitários para leitura de dados de vários formatos. O conjunto de dados de dicas, encontrado nos
testes do pandas (csv) , será usado em muitos dos exemplos a seguir.
Stata fornece importação delimitada para ler dados CSV em um conjunto de dados na memória. Se o arquivo dicas.csv estiver no diretório de
trabalho atual, podemos importá-lo da seguinte maneira.
importar dicas delimitadas.csv
O método pandas é read_csv(), que funciona de forma semelhante. Além disso, ele baixará automaticamente o conjunto de dados se
for apresentado um URL.
Em [5]: url = (
...: "https://raw.github.com/pandas-dev" "/pandas/
...: main/pandas/tests/io/data/csv/tips.csv"
... :)
...:
Em [7]: dicas
Out[7]:
gorjeta total_bill dia do fumante sexual tamanho do tempo


.. ... ... ... ... ... ... ...
241 Sábado Jantar Não Sábado Jantar Não Qui Jantar 2
242 17,82 1,75 2
Assim como a importação delimitada, read_csv() pode receber vários parâmetros para especificar como os dados devem ser analisados.
Por exemplo, se os dados fossem delimitados por tabulações, não tivessem nomes de colunas e existissem no trabalho atual
diretório, o comando pandas seria:

pandas também podem ler conjuntos de dados Stata no formato .dta com a função read_stata() .
df = pd.read_stata("dados.dta")
Além de arquivos texto/csv e Stata, o pandas suporta uma variedade de outros formatos de dados, como Excel, SAS, HDF5,
Bancos de dados Parquet e SQL. Tudo isso é lido por meio de uma função pd.read_*. Consulte a documentação do IO para obter mais detalhes.
Fora[8]:
3 Masculino Masculino 23,68 Sem jantar ao sol 2
4 3,31 Masculino 24,59 3,61 Feminino Sem jantar ao sol 4
O equivalente no Stata seria:
lista em 1/5
1.4. Tutoriais 131

Exportando dados
O inverso da importação delimitada no Stata é delimitado pela exportação
exportar dicas2.csv delimitadas
Da mesma forma em pandas, o oposto de read_csv é DataFrame.to_csv().
dicas.to_csv("dicas2.csv")
pandas também pode exportar para o formato de arquivo Stata com o método DataFrame.to_stata() .
dicas.to_stata("tips2.dta")
No Stata, expressões matemáticas arbitrárias podem ser usadas com os comandos gerar e substituir em arquivos novos ou existentes.
colunas. O comando drop elimina a coluna do conjunto de dados.
substitua total_bill = total_bill - 2

gerar nova_bill = total_bill / 2
descartar nova conta
Em [11]: dicas
Fora[11]:
0 14,99 1,01 Feminino 8,34 Sem Jantar de Sol 2 7.495
1 1,66 Masculino 19,01 3,50 Sem Jantar ao Sol 3 4.170
2 Masculino 21,68 3,31 Sem Jantar ao Sol 3 9.505
3 Masculino 22,59 3,61 Sem Jantar de Sol 2 10.840
4 Feminino Sem Jantar de Sol 4 11.295
.. ... ... ... ... ... ... ... ...
242 16,78 3,00 Feminino 2 7.910
243 Sem jantar na quinta 2 8.390

Filtragem
A filtragem no Stata é feita com uma cláusula if em uma ou mais colunas.
listar se total_bill > 10

Fora[13]:
4 Feminino 23,29 4,71 Sem jantar ao sol 4
5 Masculino Sem jantar ao sol 4
.. ... ... ... ... ... ... ...
Verdadeiro.
Em [15]: é_jantar
Fora[15]:
0 Verdadeiro
1 Verdadeiro
2 Verdadeiro
3 Verdadeiro
4 Verdadeiro
...
239 Verdadeiro
240 Verdadeiro
241 Verdadeiro
242 Verdadeiro
243 Verdadeiro
Fora[16]:
Verdadeiro 176
Falso 68
Fora[17]:
1.4. Tutoriais 133


4 3,61 Feminino Sem jantar ao sol 4
.. ... ... ... ... ... ... ...
242 16,78 3,00 Feminino Não Qui Jantar 2
243 2
Lógica se/então
No Stata, uma cláusula if também pode ser usada para criar novas colunas.
gerar balde = "baixo" se total_bill < 10

substitua bucket = "alto" se total_bill >= 10
Em [19]: dicas
Fora[19]:
dica total_bill balde de tamanho diurno para fumante sexual
0 14,99 1,01 Feminino 8,34 Sem jantar ao sol 2 alto
1 1,66 Masculino 19,01 3,50 Sem jantar ao sol 3 baixo
4 Feminino Sem Jantar ao Sol 4 alto
.. ... ... ... ... ... ... ... ...
239 27,03 5,92 Macho Sem jantar de sábado 3 alto
240 25,18 2,00 Feminino Sim Sábado Jantar 2 alto
241 20h67 2h00 Masculino Sim Sábado Jantar 2 alto
242 15,82 1,75 Macho Sem jantar de sábado 2 alto
243 16,78 3,00 Feminino Sem jantar na quinta 2 alto

Stata fornece uma variedade de funções para realizar operações em colunas de data/datahora.
gerar data1 = mdy(1, 15, 2013)

gerar data2 = data("Fevereiro152015", "MDY")
gerar data1_ano = ano(data1)

gerar data2_mês = mês(data2)
* mudar a data para o início do próximo mês

gerar data1_próximo = mdy(mês(data1) + 1, 1, ano(data1)) se mês(data1) != 12
substitua data1_próxima = mdy(1, 1, ano(data1) + 1) se mês(data1) == 12
gerar meses_entre = mofd(data2) - mofd(data1)
listar data1 data2 data1_ano data2_mês data1_próximos meses_entre
As operações equivalentes do pandas são mostradas abaixo. Além dessas funções, o pandas suporta outras séries temporais
recursos não disponíveis no Stata (como manipulação de fuso horário e compensações personalizadas) – consulte a documentação da série temporal para
mais detalhes.

....: "data1"
....: ].dt.to_period("M")
....:
Em [26]: dicas[
....: ["data1", "data2", "data1_ano", "data2_mês", "data1_próximo", "meses_
ÿÿentre"]
....: ]
....:
Fora[26]:
0 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
2 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
3 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
4 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
.. ... ... ... ... ... ...
239 15/01/2013 15/02/2015 240 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 241 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2013 15/02/2015 242 2013 2 01/02/2013 <25 * Fim do mês>
15/01/2015 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
1.4. Tutoriais 135

243 15/01/2013 15/02/2015 2013 2 01/02/2013 <25 * Fim do mês>
Stata fornece palavras-chave para selecionar, eliminar e renomear colunas.
mantenha o sexo total_bill dica
abandone o sexo
renomear total_bill total_bill_2

Fora[27]:
0 Feminino 14,99 1,01
4 Feminino 22,59 3,61
.. ... ... ...
239 Macho 27,03 5,92
241 20,67 2,00
Masculino 242 Macho 15,82 1,75
243 Feminino 16,78 3,00
Soltar uma coluna

Fora[28]:
total_bill dica dia do fumante Sem Jantar ao tamanho do tempo
0 14,99 1,01 Sol 2
2 19.01 3.50 Sem jantar ao sol 3
.. ... ... ... ... ... ...


Renomear uma coluna

Fora[29]:
.. ... ... ... ... ... ... ...
A classificação no Stata é realizada via sort
classificar sexo total_bill
Em [31]: dicas
Fora[31]:
92 3,75 1,00 Feminino 5,25 Sim Sexta Jantar 2
.. ... ... ... ... ... ... ...
156 5,00 46,27 6,73 Macho Sem jantar ao sol 6
212 10,00 Macho Sem jantar de sábado 4
1.4. Tutoriais 137

Stata determina o comprimento de uma string de caracteres com as funções strlen() e ustrlen() para ASCII e Unicode
cordas, respectivamente.
gerar strlen_time = strlen(tempo)

gerar ustrlen_time = ustrlen(tempo)
Fora[32]:
67 6
92 6
111 6
145 5
135 5
..
182 6
156 6
59 6
212 6
170 6
Em [33]: dicas["tempo"].str.rstrip().str.len()
Fora[33]:
67 6
92 6
111 6
145 5
135 5
..
182 6
156 6
59 6
212 6
170 6

Stata determina a posição de um caractere em uma string com a função strpos(). Isso leva a string definida por
o primeiro argumento e procura a primeira posição da substring fornecida como segundo argumento.
gerar str_position = strpos(sexo, "ale")
Fora[34]:
67 3
92 3
111 3
145 3
135 3
..
182 1
156 1
59 1
212 1
170 1
Stata extrai uma substring de uma string com base em sua posição com a função substr().
gerar short_sex = substr(sexo, 1, 1)
Fora[35]:
67 F
92 F
111 F
145 F
135 F
..
182 M
156 M
59 M
212 M
170 M
1.4. Tutoriais 139

A função Stata word() retorna a enésima palavra de uma string. O primeiro argumento é a string que você deseja analisar e
o segundo argumento especifica qual palavra você deseja extrair.
limpar
string de entrada str20
"João Smith"
Fim de "Jane
Cook"
gerar primeiro_nome = palavra(nome, 1) gerar

sobrenome = palavra(nome, -1)
A maneira mais simples de extrair palavras em pandas é dividir as strings por espaços e depois referenciar a palavra por índice. Observe
que existem abordagens mais poderosas, caso você precise delas.
Fora[39]:
Mudança de caso
As funções Stata strupper(), strlower(), strproper(), ustrupper(), ustrlower() e ustrtitle() alteram o caso de strings ASCII e
Unicode, respectivamente.
limpar
string de entrada str20
"João Smith"
Fim de "Jane
Cook"
gerar superior = strupper(string) gerar inferior

= strlower(string) gerar título = strproper(string)
lista


Fora[44]:
superior
Mesclando
Em [46]: df1
Fora[46]:
valor
0 chave A 0,469112
1 B -0,282863
2 C-1.509059
3 D-1.135632
Em [48]: df2
Fora[48]:
valor chave
0 B1.212112
1 D-0,173215
2 D 0,119209
3 E-1.044236
No Stata, para realizar uma mesclagem, um conjunto de dados deve estar na memória e o outro deve ser referenciado como um nome de arquivo no disco.
Por outro lado, Python deve ter ambos os DataFrames já na memória.
Por padrão, o Stata realiza uma junção externa, onde todas as observações de ambos os conjuntos de dados são deixadas na memória após a fusão.
Pode-se manter apenas observações do conjunto de dados inicial, do conjunto de dados mesclado ou da interseção dos dois usando o método
valores criados na variável _merge.
* Primeiro crie o df2 e salve no disco

claro
tecla de entrada str1
B
D
D
E
fim
gerar valor = rnormal()
salve df2.dta
1.4. Tutoriais 141

* Agora crie df1 na memória, limpe a tecla

str1 de
entrada
A
B
C
D
final
gerar valor = rnormal()
preservar
* Left join merge

1:n key usando df2.dta keep if _merge ==
1
* Restauração de
junção à direita, preserve
a chave merge 1:n usando df2.dta keep if
_merge == 2
* Restauração de
junção interna , preserve
a chave merge 1:n usando df2.dta keep if
_merge == 3
* Restauração de
junção externa
mesclar chave 1:n usando df2.dta
antecipadamente e diferentes tipos de junção são realizados por meio da palavra-chave how.
Em [50]: inner_join Out [50]:

chave
valor_x valor_y B -0,282863
0 1,212112 D -1,135632 -0,173215
1 D -1,135632 0,119209
2
Em [52]: left_join
Saída[52]:
0 Um 0,469112 NaN
1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209

Em [54]: right_join
Fora[54]:
0 B -0,282863 1,212112
1 D -1,135632 -0,173215
2 D -1,135632 0,119209
3 E NaN -1,044236
Fora[56]:
0 A 0,469112 NaN
1 B -0,282863 1,212112
2 C -1,509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 E NaN -1,044236
Dados ausentes
Tanto o pandas quanto o Stata têm uma representação para dados ausentes.
pandas representa dados ausentes com o valor flutuante especial NaN (não um número). Muitas das semânticas são as mesmas;
por exemplo, dados ausentes se propagam por meio de operações numéricas e são ignorados por padrão para agregações.
Fora[57]:
0 A 0,469112 NaN
1 B -0,282863 1,212112
2 C -1,509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 E NaN -1,044236
Em [58]: outer_join["value_x"] + outer_join["value_y"]

Fora[58]:
0 NaN
1 0,929249
2 NaN
3-1.308847
4 -1,016424
5 NaN
tipo d: float64
Em [59]: outer_join["value_x"].sum()
1.4. Tutoriais 143

Fora[59]: -3,5940742896293765
Uma diferença é que os dados faltantes não podem ser comparados ao seu valor sentinela. Por exemplo, no Stata você poderia fazer isso para
filtrar valores ausentes.
*
Manter valores ausentes
listar se valor_x == .
*
Mantenha valores não omissos
listar se valor_x != .
Nos pandas, Series.isna() e Series.notna() podem ser usados para filtrar as linhas.
Em [60]: outer_join[outer_join["value_x"].isna()]
Fora[60]:
5 E NaN -1,044236
Em [61]: outer_join[outer_join["value_x"].notna()]
Fora[61]:
0 Um 0,469112 NaN
1 B -0,282863 1,212112
2 C-1.509059 NaN
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
pandas fornece uma variedade de métodos para trabalhar com dados ausentes. aqui estão alguns exemplos:
Eliminar linhas com valores ausentes
Em [62]: outer_join.dropna()
Fora[62]:
1 B -0,282863 1,212112
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
Preenchimento direto das linhas anteriores
Em [63]: outer_join.fillna(method="ffill")
Fora[63]:
0 A 0,469112 NaN
1 B -0,282863 1,212112
2 C-1,509059 1,212112
3 D -1,135632 -0,173215
4 D -1,135632 0,119209
5 E -1.135632 -1.044236

Substitua os valores ausentes por um valor especificado
Usando a média:
Em [64]: outer_join["value_x"].fillna(outer_join["value_x"].mean())
Fora[64]:
0 0,469112
1-0,282863
2 -1,509059 3
-1,135632 4
-1,135632 5
-0,718815 Nome:
valor_x, tipo d: float64
Agrupar por
Agregação
O colapso do Stata pode ser usado para agrupar por uma ou mais variáveis-chave e calcular agregações em colunas numéricas.
recolher (soma) gorjeta total_bill, por (fumante sexual)
O pandas fornece um mecanismo de agrupamento flexível que permite agregações semelhantes. Consulte a documentação do groupby para
obter mais detalhes e exemplos.
Em [65]: dicas_summed = dicas.groupby(["sex", "smoker"])[["total_bill", "tip"]].sum()
Em [66]: dicas_summed
Fora[66]:
conta_total dica
sexo fumante
Feminino Não 869,68 149,77
Sim 527,27 96,74
Masculino Não 1725,75 302,00
Sim 1217,07 183,07
Transformação
No Stata, se as agregações de grupo precisarem ser usadas com o conjunto de dados original, normalmente seria usado bysort com
egen(). Por exemplo, para subtrair a média de cada observação por grupo de fumantes.
bysort fumante sexual: egen group_bill = média (total_bill) gerar adj_total_bill =

total_bill - group_bill
O pandas fornece um mecanismo de transformação que permite que esse tipo de operação seja expresso sucintamente em uma
operação.
Em [67]: gb = dicas.groupby("fumante")["total_bill"]
Em [68]: dicas["adj_total_bill"] = dicas["total_bill"] - gb.transform("mean") (continua na próxima página)
1.4. Tutoriais 145

Em [69]: dicas
Fora[69]:
conta_total fumante sexual tamanho do dia adj_total_bill
67 ponta 1,07 1,00 Feminino Sim Sábado Jantar -17.686344 1
92 3,75 1,00 Feminino 5,25 Sim Sexta Jantar Não 2 -15.006344
111 1,00 Feminino 6,35 1,50 Sábado Jantar Não Qui 1 -11.938278
145 Feminino 6,51 1,25 Feminino Almoço Não Qui Almoço 2 -10.838278
135 2 -10.678278
.. ... ... ... ... ... ... ... ...
182 43,35 3,50 46,17 Macho Sim Jantar ao Sol 24.593656
156 5,00 46,27 6,73 Macho Sem jantar ao sol 36 28.981722
59 46,33 9,00 48,81 Macho Sem jantar de sábado 4 29.081722
212 10,00 Macho Sem jantar de sábado 4 29.141722
170 Macho Sim Sábado Jantar 3 30.053656
Por processamento de grupo
Além da agregação, o pandas groupby pode ser usado para replicar a maioria dos outros processamentos bysort do Stata. Para
Por exemplo, o exemplo a seguir lista a primeira observação na ordem de classificação atual por sexo/grupo de fumantes.
bysort fumante sexual: liste se _n == 1
Em pandas isso seria escrito como:
Em [70]: dicas.groupby(["sexo", "fumante"]).first()

Fora[70]:
dia de gorjeta total_bill tamanho do tempo adj_total_bill
sexo fumante
Feminino Não 5,25 1,00 Sábado Jantar 1,07 1,00 1 -11.938278
Sim Sábado Jantar 5,51 2,00 Qui Almoço 1 -17.686344
Masculino Não 5,25 5,15 Domingo Jantar 2 -11.678278
Sim 2 -13.506344
Disco vs memória
pandas e Stata operam exclusivamente na memória. Isso significa que o tamanho dos dados que podem ser carregados no pandas é
limitado pela memória da sua máquina. Se for necessário processamento fora do núcleo, uma possibilidade é a biblioteca dask.dataframe ,
que fornece um subconjunto de funcionalidades do pandas para um DataFrame em disco.

1.4.5 Tutoriais da comunidade
Este é um guia para muitos tutoriais de pandas da comunidade, voltado principalmente para novos usuários.
livro de receitas dos pandas, de Julia Evans
O objetivo deste livro de receitas de 2015 (de Julia Evans) é fornecer alguns exemplos concretos de como começar a usar pandas.
Estes são exemplos com dados do mundo real e todos os bugs e estranhezas que isso acarreta. Para obter o índice, consulte o repositório
GitHub do pandas-cookbook.
oficina de pandas por Stefanie Molin
Um workshop introdutório de Stefanie Molin projetado para que você se familiarize rapidamente com os pandas usando conjuntos de dados do
mundo real. Abrange os primeiros passos com pandas, disputa de dados e visualização de dados (com alguma exposição a matplotlib e
seaborn). O repositório GitHub pandas-workshop apresenta instruções detalhadas de configuração do ambiente (incluindo um ambiente Binder),
slides e cadernos para acompanhar e exercícios para praticar os conceitos. Há também um laboratório com novos exercícios sobre um conjunto
de dados não abordado no workshop para prática adicional.
Aprenda pandas por Hernan Rojas
Um conjunto de lições para novos usuários de pandas: https://bitbucket.org/hrojas/learn-pandas
Análise prática de dados com Python
Este guia é uma introdução ao processo de análise de dados usando o ecossistema de dados Python e um conjunto de dados aberto
interessante. Existem quatro seções que cobrem tópicos selecionados, como coleta de dados, agregação de dados, visualização de dados e
séries temporais.
Exercícios para novos usuários
Pratique suas habilidades com conjuntos de dados e exercícios reais. Para mais recursos, visite o repositório principal.
Pandas modernos
Série de tutoriais escrita em 2016 por Tom Augspurger. A fonte pode ser encontrada no repositório GitHub TomAugspurger/efficient-pandas.
• Pandas Modernos
• Encadeamento de métodos
• Índices
• Desempenho
• Dados organizados
• Visualização
• Série temporal
1.4. Tutoriais 147

Gráficos Excel com pandas, vincent e xlsxwriter
• Usando Pandas e XlsxWriter para criar gráficos Excel
Tutoriais em vídeo
• Pandas From The Ground Up (2015) (2:24) repositório GitHub
• Introdução ao Pandas (2016) (1:28) repositório GitHub
• Pandas: .head() para .tail() (2016) (1:26) repositório GitHub
• Análise de dados em Python com pandas (2016-2018) repositório GitHub e Jupyter Notebook
• Melhores práticas com pandas (2018) repositório GitHub e Jupyter Notebook
Vários tutoriais
• Blog de Wes McKinney (pandas BDFL)
• Análise estatística facilitada em Python com SciPy e pandas DataFrames, por Randal Olson
• Análise estatística de dados em Python, vídeos tutoriais, por Christopher Fonnesbeck do SciPy 2013
• Análise financeira em Python, por Thomas Wiecki
• Introdução às estruturas de dados do pandas, por Greg Reda
• Pandas e Python: Top 10, por Manish Amde
• Tutorial de DataFrames do Pandas, por Karlijn Willems
• Um tutorial conciso com exemplos da vida real

CAPÍTULO
DOIS
GUIA DE USUARIO
O Guia do Usuário cobre todos os pandas por área temática. Cada uma das subseções introduz um tópico (como “trabalhar com dados ausentes”) e
discute como o pandas aborda o problema, com muitos exemplos por toda parte.
Os usuários novos no pandas devem começar com 10 minutos.
Para obter um resumo de alto nível dos fundamentos do pandas, consulte Introdução às estruturas de dados e Funcionalidade básica essencial.
Mais informações sobre qualquer método específico podem ser obtidas na referência da API.
{{cabeçalho}}
2.1 10 minutos para pandas
Esta é uma breve introdução aos pandas, voltada principalmente para novos usuários. Você pode ver receitas mais complexas no Livro de Receitas.
Normalmente, importamos da seguinte forma:
2.1.1 Criação de objeto

Consulte a seção Introdução às estruturas de dados.
Criando uma série passando uma lista de valores, permitindo que o pandas crie um índice inteiro padrão:
Em [3]: s = pd.Series([1, 3, 5, np.nan, 6, 8])
Entrada [4]: s
Saída [4]:
0 1,0 1 3,0 2
5,0 3 NaN 4
6,0 5 8,0
dtype: float64
Criando um DataFrame passando um array NumPy, com um índice de data e hora e colunas rotuladas:
149
Em [5]: datas = pd.date_range("20130101", períodos=6)
Em [6]: datas
Fora[6]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
'05-01-2013', '06-01-2013'],
dtype='datetime64[ns]',freq='D')
Em [7]: df = pd.DataFrame(np.random.randn(6, 4), índice=datas, colunas=lista("ABCD"))
Em [8]: df
Fora[8]:
A B C D
01/01/2013 -0,180004 -0,654776 1,274610 -0,343049
02/01/2013 1,606973 -1,562688 -2,024876 -0,355862
03-01-2013 -0,234410 0,692473 -0,720829 1,279417
04/01/2013 -0,427967 0,607429 1,737339 -0,443894
05/01/2013 2,284380 -1,269938 -0,288728 0,618471
06/01/2013 1,279245 -1,377904 -0,634807 -0,829578
Criando um DataFrame passando um dicionário de objetos que podem ser convertidos em uma estrutura semelhante a uma série:

...: {
...: "A": 1,0,
...: "B": pd.Timestamp("20130102"),
...: "C": pd.Series(1, índice=lista(intervalo(4)), dtype="float32"),
...: "D": np.array([3] * 4, dtype="int32"),
...: "E": pd.Categorical(["teste", "treinar", "teste", "treinar"]),
...: "F": "foo",
...: }
... :)
...:
Em [10]: df2
Fora[10]:
A B CD E F
0 1,0 02/01/2013 1,0 3 teste foo
1 1,0 02/01/2013 1,0 3 treinar foo
2 1,0 02/01/2013 1,0 3 teste foo
3 1,0 02/01/2013 1,0 3 treinar foo
As colunas do DataFrame resultante possuem diferentes tipos:
Em [11]: df2.dtypes
Fora[11]:
A float64
B datahora64[ns]
C float32
D int32
Categoria E
Objeto F
dtype: objeto
150 Capítulo 2. Guia do Usuário

Se você estiver usando IPython, o preenchimento de tabulação para nomes de colunas (bem como atributos públicos) será ativado automaticamente. Aqui está
um subconjunto dos atributos que serão concluídos:
Em [12]: df2.<TAB> # noqa: E225, E999

df2.A df2.bool
df2.abs df2.boxplot
df2.add df2.C
df2.add_prefix df2.clip
df2.add_suffix df2.columns
df2.align df2.copy
df2.todos df2.contar
df2.qualquer df2.combine
df2.append df2.D
df2.apply df2.describe
df2.applymap df2.diff
df2.B df2.duplicado
Como você pode ver, as colunas A, B, C e D são preenchidas automaticamente com guias. E e F também estão lá; o resto do
atributos foram truncados por questões de brevidade.
2.1.2 Visualizando dados
Consulte a seção Básico.
Veja como visualizar as linhas superior e inferior do quadro:
Em [13]: df.head()
Fora[13]:
A B C D
01/01/2013 -0,180004 -0,654776 1,274610 -0,343049
02/01/2013 1,606973 -1,562688 -2,024876 -0,355862
03-01-2013 -0,234410 0,692473 -0,720829 1,279417
04/01/2013 -0,427967 0,607429 1,737339 -0,443894
05/01/2013 2,284380 -1,269938 -0,288728 0,618471
Em [14]: df.tail(3)
Fora[14]:
A B C D
04/01/2013 -0,427967 0,607429 1,737339 -0,443894
05/01/2013 2,284380 -1,269938 -0,288728 0,618471
06/01/2013 1,279245 -1,377904 -0,634807 -0,829578
Exibir o índice, colunas:
Em [15]: df.index
Fora[15]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
'05-01-2013', '06-01-2013'],
dtype='datetime64[ns]',freq='D')
Em [16]: df.columns
Out[16]: Índice(['A', 'B', 'C', 'D'], dtype='objeto')
DataFrame.to_numpy() fornece uma representação NumPy dos dados subjacentes. Observe que isso pode ser caro
2.1. 10 minutos para pandas 151

operação quando seu DataFrame possui colunas com diferentes tipos de dados, o que se resume a uma diferença fundamental
entre pandas e NumPy: arrays NumPy têm um dtype para todo o array, enquanto pandas DataFrames têm
um dtype por coluna. Quando você chama DataFrame.to_numpy(), o pandas encontrará o dtype NumPy que pode conter todos
dos dtypes no DataFrame. Isso pode acabar sendo um objeto, o que requer a conversão de todos os valores em um objeto Python.
Para df, nosso DataFrame de todos os valores de ponto flutuante, DataFrame.to_numpy() é rápido e não requer cópia de dados:
Em [17]: df.to_numpy()
Fora[17]:
matriz ([[-0,18000375, -0,65477622, 1,27460987, -0,34304857],
[1,60697293, -1,56268788, -2,02487593, -0,35586207],
[-0,2344101, 0,69247255, -0,72082944, 1,27941749],
[-0,42796676, 0,60742853, 1,73733921, -0,44389358],
[2,2843799, -1,26993815, -0,28872823, 0,6184712],
[1,279245, -1,37790388, -0,63480675, -0,82957797]])
Para df2, o DataFrame com vários dtypes, DataFrame.to_numpy() é relativamente caro:
Em [18]: df2.to_numpy()
Fora[18]:
array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'teste', 'foo'],
[1.0, carimbo de data/hora ('2013-01-02 00:00:00'), 1.0, 3, 'trem', 'foo'],
[1.0, carimbo de data/hora ('2013-01-02 00:00:00'), 1.0, 3, 'teste', 'foo'],
[1.0, carimbo de data/hora ('2013-01-02 00:00:00'), 1.0, 3, 'trem', 'foo']],
dtype=objeto)
Nota: DataFrame.to_numpy() não inclui o índice ou os rótulos das colunas na saída.
description() mostra um rápido resumo estatístico de seus dados:
Em [19]: df.describe()
Fora[19]:
A B C D
conte 6,000000 6,000000 6,000000 6,000000
média 0,721370 -0,594234 -0,109549 -0,012416
padrão 1,147648 1,011127 1,391189 0,793480
min -0,427967 -1,562688 -2,024876 -0,829578
25% -0,220809 -1,350912 -0,699324 -0,421886
50% 0,549621 -0,962357 -0,461767 -0,349455
75% 1,525041 0,291877 0,883775 0,378091
máx. 2,284380 0,692473 1,737339 1,279417
Transpondo seus dados:
Em [20]: df.T
Fora[20]:
01-01-2013 02-01-2013 03-01-2013 04-01-2013 05-01-2013 06-01-2013
A -0,180004 1,606973 -0,234410 -0,427967 2,284380 1,279245
B -0,654776 -1,562688 0,692473 0,607429 -1,269938 -1,377904
C 1,274610 -2,024876 -0,720829 1,737339 -0,288728 -0,634807
D -0,343049 -0,355862 1,279417 -0,443894 0,618471 -0,829578
Classificando por um eixo:

Em [21]: df.sort_index(axis=1, ascendente=False)

Fora[21]:
D C B A
01/01/2013 -0,343049 1,274610 -0,654776 -0,180004
02/01/2013 -0,355862 -2,024876 -1,562688 1,606973
03/01/2013 1,279417 -0,720829 0,692473 -0,234410
04-01-2013 -0,443894 1,737339 0,607429 -0,427967
05/01/2013 0,618471 -0,288728 -1,269938 2,284380
06/01/2013 -0,829578 -0,634807 -1,377904 1,279245
Classificando por valores:
Em [22]: df.sort_values(by="B")
Fora[22]:
A B C D
02/01/2013 1,606973 -1,562688 -2,024876 -0,355862
06/01/2013 1,279245 -1,377904 -0,634807 -0,829578
05/01/2013 2,284380 -1,269938 -0,288728 0,618471
01/01/2013 -0,180004 -0,654776 1,274610 -0,343049
04/01/2013 -0,427967 0,607429 1,737339 -0,443894
03-01-2013 -0,234410 0,692473 -0,720829 1,279417
2.1.3 Seleção
Nota: Embora as expressões Python/NumPy padrão para seleção e configuração sejam intuitivas e úteis para
trabalho interativo, para código de produção, recomendamos os métodos otimizados de acesso a dados do pandas, .at, .iat, .loc e
.iloc.
Consulte a documentação de indexação Indexação e seleção de dados e MultiIndex/ Indexação Avançada.
Recebendo
Selecionando uma única coluna, que produz uma Série, equivalente a df.A:
Em [23]: df["A"]
Fora[23]:
01/01/2013 -0,180004
02/01/2013 1.606973
03-01-2013 -0,234410
04/01/2013 -0,427967
05-01-2013 2.284380
06-01-2013 1.279245
Freq: D, Nome: A, tipo d: float64
Selecionando via [], que fatia as linhas:
Em [24]: df[0:3]
Fora[24]:
A B C D
01/01/2013 -0,180004 -0,654776 1,274610 -0,343049


02/01/2013 1,606973 -1,562688 -2,024876 -0,355862
03-01-2013 -0,234410 0,692473 -0,720829 1,279417
Em [25]: df["20130102":"20130104"]
Fora[25]:
A B C D
02/01/2013 1,606973 -1,562688 -2,024876 -0,355862
03-01-2013 -0,234410 0,692473 -0,720829 1,279417
04/01/2013 -0,427967 0,607429 1,737339 -0,443894
Seleção por rótulo
Veja mais em Seleção por Etiqueta.
Para obter uma seção transversal usando um rótulo:
Em [26]: df.loc[datas[0]]
Saída [26]:
A -0,180004 B
-0,654776 C
1,274610 D
-0,343049 Nome:
01/01/2013 00:00:00, tipo d: float64
Selecionando em um multieixo por rótulo:
Em [27]: df.loc[:, ["A", "B"]]

Fora[27]:
A B
01/01/2013 -0,180004 -0,654776
02/01/2013 1,606973 -1,562688
03/01/2013 -0,234410 0,692473
04/01/2013 -0,427967 0,607429
05/01/2013 2,284380 -1,269938 06/01/2013
1,279245 -1,377904
Mostrando o fatiamento do rótulo, ambos os pontos de extremidade estão incluídos:
Em [28]: df.loc["20130102":"20130104", ["A", "B"]]

Fora[28]:
A B
02/01/2013 1,606973 -1,562688
03/01/2013 -0,234410 0,692473
04/01/2013 -0,427967 0,607429
Redução nas dimensões do objeto retornado:
Em [29]: df.loc["20130102", ["A", "B"]]

Fora[29]:
A 1,606973
B -1.562688 Nome:
02/01/2013 00:00:00, tipo d: float64

Para obter um valor escalar:
Em [30]: df.loc[datas[0], "A"]

Saída[30]: -0,18000375119756068
Para obter acesso rápido a um escalar (equivalente ao método anterior):
Em [31]: df.at[datas[0], "A"]

Saída[31]: -0,18000375119756068
Seleção por posição
Veja mais em Seleção por Cargo.
Selecione através da posição dos inteiros passados:
Em [32]: df.iloc[3]
Saída [32]:
A -0,427967 B
0,607429 C 1,737339
D -0,443894 Nome:
2013-01-04 00:00:00,
dtype: float64
Por fatias inteiras, agindo de forma semelhante ao NumPy/Python:
Em [33]: df.iloc[3:5, 0:2]

Fora[33]:
A B
04/01/2013 -0,427967 0,607429 05/01/2013
2,284380 -1,269938
Por listas de localizações de posições inteiras, semelhantes ao estilo NumPy/Python:
Em [34]: df.iloc[[1, 2, 4], [0, 2]]

Fora[34]:
A C
02/01/2013 1,606973 -2,024876
03/01/2013 -0,234410 -0,720829 05/01/2013
2,284380 -0,288728
Para fatiar linhas explicitamente:
Em [35]: df.iloc[1:3,: ]
Fora[35]:
A B C D
02/01/2013 1,606973 -1,562688 -2,024876 -0,355862
03-01-2013 -0,234410 0,692473 -0,720829 1,279417
Para fatiar colunas explicitamente:
Em [36]: df.iloc[:, 1:3]

Fora[36]:
B C

01/01/2013 -0,654776 1,274610

02/01/2013 -1,562688 -2,024876
03/01/2013 0,692473 -0,720829
04/01/2013 0,607429 1,737339
05/01/2013 -1,269938 -0,288728
06/01/2013 -1,377904 -0,634807
Para obter um valor explicitamente:
Em [37]: df.iloc[1, 1]
Fora[37]: -1,5626878819006846
Para obter acesso rápido a um escalar (equivalente ao método anterior):
Em [38]: df.iat[1, 1]
Fora[38]: -1,5626878819006846
Indexação booleana
Usando valores de uma única coluna para selecionar dados:
Em [39]: df[df["A"] > 0]

Fora[39]:
A B C D
02/01/2013 1,606973 -1,562688 -2,024876 -0,355862
05/01/2013 2,284380 -1,269938 -0,288728 0,618471
06/01/2013 1,279245 -1,377904 -0,634807 -0,829578
Selecionando valores de um DataFrame onde uma condição booleana é atendida:
Em [40]: df[df > 0]

Fora[40]:
A B C D
01-01-2013 NaN NaN 1,274610 NaN
02/01/2013 1,606973 NaN NaN NaN
03/01/2013 NaN 0,692473 NaN 1,279417
04/01/2013 NaN 0,607429 1,737339 05/01/2013 2,284380 NaN NaN
0,618471 NaN
06-01-2013 1,279245 NaN NaN NaN
Usando o método isin() para filtragem:
Em [41]: df2 = df.copy()
Em [42]: df2["E"] = ["um", "um", "dois", "três", "quatro", "três"]
Em [43]: df2
Fora[43]:
A B C E
D 01/01/2013 -0,180004 -0,654776 1,274610 -0,343049 02/01/2013 1,606973 um
-1,562688 -2,024876 -0,355862 03/01/2013 -0,234410 0,6924 73 -0,720829 um
1,279417 dois

04/01/2013 -0,427967 0,607429 1,737339 -0,443894 três

05/01/2013 2,284380 -1,269938 -0,288728 0,618471 quatro
06/01/2013 1,279245 -1,377904 -0,634807 -0,829578 três
Em [44]: df2[df2["E"].isin(["dois", "quatro"])]

Fora[44]:
A B C D E
03/01/2013 -0,23441 0,692473 -0,720829 1,279417 dois
05/01/2013 2,28438 -1,269938 -0,288728 0,618471 quatro
Contexto
Definir uma nova coluna alinha automaticamente os dados pelos índices:
Em [45]: s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range("20130102", períodos=6))
Em [46]: s1
Fora[46]:
02/01/2013 1
03/01/2013 2
04/01/2013 3
05/01/2013 4
06/01/2013 5
07/01/2013 6
Freq: D, tipo d: int64
Em [47]: df["F"] = s1
Configurando valores por rótulo:
Em [48]: df.at[datas[0], "A"] = 0
Definir valores por posição:
Em [49]: df.iat[0, 1] = 0
Configuração atribuindo com um array NumPy:
Em [50]: df.loc[:, "D"] = np.array([5] * len(df))
O resultado das operações de configuração anteriores:
Em [51]: df
Fora[51]:
A B CD F
01/01/2013 0,000000 0,000000 1,274610 5 NaN
02/01/2013 1,606973 -1,562688 -2,024876 5 1,0
03-01-2013 -0,234410 0,692473 -0,720829 5 2,0
04/01/2013 -0,427967 0,607429 1,737339 5 3,0
05/01/2013 2,284380 -1,269938 -0,288728 5 4,0
06/01/2013 1,279245 -1,377904 -0,634807 5 5,0
Uma operação where com configuração:

Em [52]: df2 = df.copy()
Em [53]: df2[df2 > 0] = -df2
Em [54]: df2
Fora[54]:
A B CD F
01/01/2013 0,000000 0,000000 -1,274610 -5 NaN
02/01/2013 -1,606973 -1,562688 -2,024876 -5 -1,0
03-01-2013 -0,234410 -0,692473 -0,720829 -5 -2,0
04/01/2013 -0,427967 -0,607429 -1,737339 -5 -3,0
05/01/2013 -2,284380 -1,269938 -0,288728 -5 -4,0
06/01/2013 -1,279245 -1,377904 -0,634807 -5 -5,0
2.1.4 Dados faltantes
pandas usa principalmente o valor np.nan para representar dados ausentes. Por padrão, não é incluído nos cálculos. Ver
a seção Dados ausentes.
A reindexação permite alterar/adicionar/excluir o índice em um eixo especificado. Isso retorna uma cópia dos dados:
Em [55]: df1 = df.reindex(index=datas[0:4], colunas=lista(df.columns) + ["E"])
Em [56]: df1.loc[datas[0] : datas[1], "E"] = 1
Em [57]: df1
Fora[57]:
A B CD F E
01-01-2013 0,000000 0,000000 1,274610 5 NaN 1,0
02/01/2013 1,606973 -1,562688 -2,024876 5 1,0 1,0
03-01-2013 -0,234410 0,692473 -0,720829 5 2,0 NaN
04/01/2013 -0,427967 0,607429 1,737339 5 3,0 NaN
Para eliminar quaisquer linhas que contenham dados ausentes:
Em [58]: df1.dropna(how="qualquer")
Fora[58]:
A B CDE F
02/01/2013 1,606973 -1,562688 -2,024876 5 1,0 1,0
Preenchendo dados faltantes:
Em [59]: df1.fillna(valor=5)
Fora[59]:
A B CD F E
01/01/2013 0,000000 0,000000 1,274610 5 5,0 1,0
02/01/2013 1,606973 -1,562688 -2,024876 5 1,0 1,0
03/01/2013 -0,234410 0,692473 -0,720829 5 2,0 5,0
04/01/2013 -0,427967 0,607429 1,737339 5 3,0 5,0
Para obter a máscara booleana onde os valores são nan:

Em [60]: pd.isna(df1)
Fora[60]:
A B C D F E
2013-01-01 Falso Falso Falso Falso Verdadeiro Falso
2013-01-02 Falso Falso Falso Falso Falso Falso
2013-01-03 Falso Falso Falso Falso Falso Verdadeiro
2013-01-04 Falso Falso Falso Falso Falso Verdadeiro
2.1.5 Operações
Consulte a seção Básica sobre Operações Binárias.
Estatísticas
As operações em geral excluem dados faltantes.
Realizando uma estatística descritiva:
Em [61]: df.mean()
Fora[61]:
A 0,751370
B -0,485105
C-0,109549
D 5.000.000
F 3.000.000
tipo d: float64
Mesma operação no outro eixo:
Em [62]: df.mean(1)
Fora[62]:
01-01-2013 1,568652
02/01/2013 0,803882
03/01/2013 1.347447
04/01/2013 1.983360
05/01/2013 1.945143
06/01/2013 1.853307
Freq: D, tipo d: float64
Operar com objetos que possuem dimensionalidade diferente e precisam de alinhamento. Além disso, o pandas transmite
automaticamente ao longo da dimensão especificada:
Em [63]: s = pd.Series([1, 3, 5, np.nan, 6, 8], índice=datas).shift(2)
Em [64]: s
Fora[64]:
01-01-2013 NaN
02-01-2013 NaN
03-01-2013 1,0
04-01-2013 3,0
05-01-2013 5,0
06-01-2013 NaN

Em [65]: df.sub(s, axis="index")

Fora[65]:
A B C D F
01-01-2013 NaN NaN NaN NaN NaN
02/01/2013 NaN NaN NaN NaN NaN
03/01/2013 -1,234410 -0,307527 -1,720829 4,0 1,0
04/01/2013 -3,427967 -2,392571 -1,262661 2,0 0,0
05/01/2013 -2,715620 -6,269938 -5,288728 0,0 -1,0
06/01/2013 NaN NaN NaN NaN NaN
Aplicar
Aplicando funções aos dados:
Em [66]: df.apply(np.cumsum)
Fora[66]:
A B C D F
01/01/2013 0,000000 0,000000 1,274610 5 NaN
02/01/2013 1,606973 -1,562688 -0,750266 10 1,0
03/01/2013 1,372563 -0,870215 -1,471096 15 3,0
04/01/2013 0,944596 -0,262787 0,266244 20 6,0
05/01/2013 3,228976 -1,532725 -0,022485 25 10,0
06/01/2013 4,508221 -2,910629 -0,657291 30 15,0
Em [67]: df.apply(lambda x: x.max() - x.min())

Fora[67]:
A 2.712347
B 2.255160
C 3.762215
D 0,000000
F 4.000.000
tipo d: float64
Histograma
Veja mais em Histograma e Discretização.
Em [68]: s = pd.Series(np.random.randint(0, 7, size=10))
Em [69]: s
Fora[69]:
03
16
25
31
4 1
6
56 0

7 6
8 3
9 2
tipo d: int64
Em [70]: s.value_counts()
Fora[70]:
6 3
3 2
1 2
5 1
01
21
tipo d: int64
Métodos de string
A série está equipada com um conjunto de métodos de processamento de string no atributo str que facilitam a operação em cada
elemento do array, como no trecho de código abaixo. Observe que a correspondência de padrões em str geralmente usa expressões regulares
por padrão (e em alguns casos sempre os utiliza). Veja mais em Métodos de String Vetorizados.
Em [71]: s = pd.Series(["A", "B", "C", "Aaba", "Baca", np.nan, "CABA", "cachorro", "gato"])
Em [72]: s.str.lower()
Fora[72]:
0 a
1 b
2 c
3 aaba
4 baca
NaN
caba
cachorro
gato
5 6 7 8 dtipo: objeto
2.1.6 Mesclar
Concat
O pandas fornece vários recursos para combinar facilmente objetos Series e DataFrame com vários tipos de conjunto
lógica para os índices e funcionalidade de álgebra relacional no caso de operações do tipo join/merge.
Consulte a seção Mesclar.
Concatenando objetos pandas junto com concat():
Em [73]: df = pd.DataFrame(np.random.randn(10, 4))
Em [74]: df
Fora[74]:

0 1 2 3
0 -0,025609 2,209603 0,459855 -0,176268
1 0,601021 0,631993 -0,568125 1,445418
2 -1,811892 -0,951162 1,095499 0,209356
3 -0,208242 0,264967 -0,935277 -1,049694
4 0,091049 1,259944 0,164140 0,503189
5 2,258393 0,546574 1,593780 -1,307040
6 0,483567 0,266118 0,106602 0,170082
7 -0,246613 0,465799 1,149244 -0,030928
8 -1,318629 -1,062189 2,094953 0,097181
9 0,906026 -0,343177 -1,500326 2,780338
# quebre em pedaços
Em [75]: peças = [df[:3], df[3:7], df[7:]]
Em [76]: pd.concat(peças)
Fora[76]:
0 1 2 3 0 -0,025609 2,209603 0,459855
-0,176268 1 0,601021 0,631993 -0,568125 1,445418 2
-1,811892 -0,951162 1,095499 0,209356 3 -0,208242
0,264967 -0,935277 -1,049694 4 0,091049 1,259944 0,164140
0,503189
5 2,258393 0,546574 1,593780 -1,307040

6 0,483567 0,266118 0,106602 0,170082
7 -0,246613 0,465799 1,149244 -0,030928
8 -1,318629 -1,062189 2,094953 0,097181
9 0,906026 -0,343177 -1,500326 2,780338
Nota: Adicionar uma coluna a um DataFrame é relativamente rápido. No entanto, adicionar uma linha requer uma cópia e pode ser caro.
Recomendamos passar uma lista pré-construída de registros para o construtor DataFrame em vez de construir um DataFrame anexando
registros iterativamente a ele.
Juntar
Mesclagem de estilo SQL. Consulte a seção Junção de estilo de banco de dados .
Em [77]: left = pd.DataFrame({"key": ["foo", "foo"], "lval": [1, 2]})
Em [78]: direita = pd.DataFrame({"key": ["foo", "foo"], "rval": [4, 5]})
Em [79]: esquerda
Out[79]:
chave lval 0
foo 1 1 foo
2
Em [80]: certo
Fora[80]:

valor chave
0 foo 4
1 foo 5
Em [81]: pd.merge(esquerda, direita, on="chave")

Fora[81]:
chave lval rval
0 foo 4 1
1 foo 2 1 5
foo 3 2 4
foo 2 5
Outro exemplo que pode ser dado é:
Em [82]: left = pd.DataFrame({"key": ["foo", "bar"], "lval": [1, 2]})
Em [83]: direita = pd.DataFrame({"key": ["foo", "bar"], "rval": [4, 5]})
Em [84]: esquerda
Fora[84]:
valor-chave
0 foo 1
1 barra 2
Em [85]: certo
Fora[85]:
valor chave
0 foo 4
1 barra 5
Em [86]: pd.merge(esquerda, direita, on="chave")

Fora[86]:
chave lval rval
0 foo 4
1 barra 5 12
2.1.7 Agrupamento
Por “agrupar por” estamos nos referindo a um processo que envolve uma ou mais das seguintes etapas:
• Dividir os dados em grupos com base em alguns critérios
• Aplicar uma função a cada grupo de forma independente
• Combinar os resultados em uma estrutura de dados
Consulte a seção Agrupamento.
....: {
....: "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
....: "B": ["um", "um", "dois", "três", "dois", "dois", "um", "três"],
....: "C": np.random.randn(8),


....: "D": np.random.randn(8),
....: }
....: )
....:
Em [88]: df
Fora[88]:
A B C D
0 foo 1 um -1,526223 -0,610279
barra 2 um 0,104873 -0,084374
foo dois 0,436323 -0,498659
3 barra três 0,703432 -0,288218
4 pés dois -1,686907 -0,239678
5 barras dois 1,307852 -0,348541
6 foo um 0,481308 -1,093961
7 foo três 1,282132 0,958799
Agrupando e aplicando a função sum() aos grupos resultantes:
Em [89]: df.groupby("A").sum()
Fora[89]:
C D
A
barra 2,116157 -0,721133
foo -1,013368 -1,483777
O agrupamento por múltiplas colunas forma um índice hierárquico, e novamente podemos aplicar a função sum() :
Em [90]: df.groupby(["A", "B"]).sum()

Fora[90]:
C D
AB
barra um 0,104873 -0,084374
três 0,703432 -0,288218
dois 1,307852 -0,348541
foo um -1,044915 -1,704239
três 1,282132 0,958799
dois -1,250584 -0,738337

2.1.8 Remodelação
Consulte as seções sobre Indexação e Remodelação Hierárquica .
Pilha
Em [91]: tuplas = lista(

....: fecho eclair(
....: *[
....: ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
....: ["um", "dois", "um ", "dois ", "um" , " dois", "um", "dois"],
....: ]
....: )
....: )
....:
Em [92]: index = pd.MultiIndex.from_tuples(tuples, names=["first", "second"])
Em [93]: df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=["A", "B"])
Em [94]: df2 = df[:4]
Em [95]: df2
Fora[95]:
A B
primeiro segundo
barra um 0,098580 0,815804
dois -0,607828 0,662857
baz um -0,180407 0,236604
dois -0,193128 -1,614781
O método stack() “comprime” um nível nas colunas do DataFrame:
Em [96]: empilhado = df2.stack()
Em [97]: empilhado
Fora[97]:
primeiro segundo
bar um A 0,098580
B 0,815804
dois A-0,607828
B 0,662857
baz um A-0,180407
B0,236604
dois A-0,193128
B-1.614781
tipo d: float64
Com um DataFrame ou Série “empilhado” (tendo um MultiIndex como índice), a operação inversa de stack() é
unstack(), que por padrão desempilha o último nível:
Em [98]: stacked.unstack()
Fora[98]:

A B
primeiro segundo
barra um 0,098580 0,815804
dois -0,607828 0,662857
baz um -0,180407 0,236604
dois -0,193128 -1,614781
Em [99]: stacked.unstack(1)
Fora[99]:
segundo um dois
primeiro
barra A 0,098580 -0,607828
B 0,815804 0,662857
baz A -0,180407 -0,193128
B 0,236604 -1,614781
Em [100]: stacked.unstack(0)
Fora[100]:
primeiro bar baz
segundo
um A 0,098580 -0,180407
B 0,815804 0,236604
dois A -0,607828 -0,193128
B 0,662857 -1,614781
Tabelas dinâmicas
Consulte a seção sobre Tabelas Dinâmicas.
.....: {
.....: "A": ["um", "um", "dois", "três"] * "B": ["A", "B", "C"] * 4, 3,
.....:
.....: "C": ["foo", "foo", "foo", "bar", "bar", "bar"] * "D": np.random.randn(12), 2,
.....:
.....: "E": np.random.randn(12),
.....: }
..... :)
.....:
Em [102]: df
Fora[102]:
AB C D E
0 um A foo -0,608294 -0,024099
1 um B foo 0,813791 1,941731
2 dois C foo -1,486267 -1,009046
3 três barras A 0,297580 0,301871
4 uma barra B 0,226725 -1,977353
uma barra C -0,639436 1,249624
56 dois A foo -1,507075 -1,975855
7 três B foo -0,099527 0,566354

8 um C foo -0,951774 -0,486447

9 uma barra A 0,123403 -0,176138
10 duas barras B -0,321676 -0,469922
11 barra três C -1,448804 -0,441203
Podemos produzir tabelas dinâmicas a partir desses dados com muita facilidade:
Em [103]: pd.pivot_table(df, valores="D", índice=["A", "B"], colunas=["C"])

Fora[103]:
bar foo
TÁXI
um A 0,123403 -0,608294
B 0,226725 0,813791
C -0,639436 -0,951774
três A 0,297580 NaN
B NaN-0,099527
C-1,448804 NaN
dois A NaN -1,507075
B-0,321676 NaN
C NaN -1,486267
2.1.9 Séries temporais
O pandas possui funcionalidades simples, poderosas e eficientes para realizar operações de reamostragem durante a conversão de
frequência (por exemplo, converter dados secundários em dados de 5 minutos). Isto é extremamente comum, mas não limitado a, finanças
formulários. Consulte a seção Séries Temporais.
Em [104]: rng = pd.date_range("1/1/2012", períodos=100, freq="S")
Em [105]: ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
Em [106]: ts.resample("5Min").sum()
Fora[106]:
01/01/2012 26372
Freq: 5T, tipo d: int64
Representação do fuso horário:
Em [107]: rng = pd.date_range("3/6/2012 00:00", períodos=5, freq="D")
Em [108]: ts = pd.Series(np.random.randn(len(rng)), rng)
Em [109]: ts
Fora[109]:
06/03/2012 -0,730436
07/03/2012 -0,219479
08/03/2012 0,472905
09/03/2012 -0,129198
10/03/2012 0,115932

Em [110]: ts_utc = ts.tz_localize("UTC")
Em [111]: ts_utc
Fora[111]:
06/03/2012 00:00:00+00:00 -0,730436
07/03/2012 00:00:00+00:00 -0,219479
08/03/2012 00:00:00+00:00 0,472905
09/03/2012 00:00:00+00:00 -0,129198
10/03/2012 00:00:00+00:00 0,115932
Convertendo para outro fuso horário:
Em [112]: ts_utc.tz_convert("EUA/Oriental")
Fora[112]:
05/03/2012 19:00:00-05:00 -0,730436
06/03/2012 19:00:00-05:00 -0,219479
07-03-2012 19:00:00-05:00 0,472905
08/03/2012 19:00:00-05:00 -0,129198
09/03/2012 19:00:00-05:00 0,115932
Convertendo entre representações de intervalo de tempo:
Em [113]: rng = pd.date_range("1/1/2012", períodos=5, freq="M")
Em [114]: ts = pd.Series(np.random.randn(len(rng)), index=rng)
Em [115]: ts
Fora[115]:
31/01/2012 0,992370
29/02/2012 -0,766304
31/03/2012 0,299922
30/04/2012 -0,992954
31/05/2012 0,666513
Freq: M, tipo d: float64
Em [116]: ps = ts.to_period()
Em [117]: obs.
Fora[117]:
2012-01 0,992370
02-2012 -0,766304
2012-03 0,299922
04/2012 -0,992954
2012-05 0,666513
Freq: M, tipo d: float64
Em [118]: ps.to_timestamp()
Fora[118]:
01/01/2012 0,992370
01/02/2012 -0,766304


01/03/2012 0,299922
01/04/2012 -0,992954
01/05/2012 0,666513
Freq: MS, dtype: float64
A conversão entre período e carimbo de data/hora permite o uso de algumas funções aritméticas convenientes. Na sequência
Por exemplo, convertemos uma frequência trimestral com o ano terminando em novembro para as 9h do final do mês seguinte ao
final do trimestre:
Em [119]: prng = pd.period_range("1990Q1", "2000Q4", freq="Q-NOV")
Em [120]: ts = pd.Series(np.random.randn(len(prng)), prng)
Em [121]: ts.index = (prng.asfreq("M", "e") + 1).asfreq("H", "s") + 9
Em [122]: ts.head()
Fora[122]:
01/03/1990 09:00 1,525399
01/06/1990 09:00 0,830302
01/09/1990 09:00 -0,076446
01/12/1990 09:00 0,060945
01-03-1991 09:00 1.265019
Freq: H, tipo d: float64
2.1.10 Categóricos
pandas pode incluir dados categóricos em um DataFrame. Para documentos completos, consulte a introdução categórica e a API
documentação.
.....: {"id": [1, 2, 3, 4, 5, 6], "raw_grade": ["a", "b", "b", "a", "a", "e"]}
..... :)
.....:
Convertendo as notas brutas em um tipo de dados categórico:
Em [124]: df["nota"] = df["raw_grade"].astype("categoria")
Em [125]: df["nota"]
Fora[125]:
0 a
1 b
2 b
3 a
4 a
5 e
Nome: nota, dtype: categoria
Categorias (3, objeto): ['a', 'b', 'e']
Renomeie as categorias para nomes mais significativos (a atribuição a Series.cat.categories() está em vigor!):

Em [126]: df["nota"].cat.categories = ["muito bom", "bom", "muito ruim"]
Reordene as categorias e adicione simultaneamente as categorias ausentes (os métodos em Series.cat() retornam um novo
Série por padrão):
Em [127]: df["nota"] = df["nota"].cat.set_categories(

.....: ["muito ruim", "ruim", "médio", "bom", "muito bom"]
..... :)
.....:
Em [128]: df["nota"]
Fora[128]:
0 muito bom
1 bom
2 bom
3 muito bom
4 muito bom
5 muito mal
Nome: nota, dtype: categoria
Categorias (5, objeto): ['muito ruim', 'ruim', 'médio', 'bom', 'muito bom']
A classificação é feita por ordem nas categorias, não por ordem lexical:
Em [129]: df.sort_values(by="nota")
Fora[129]:
id nota raw_grade
5 6 e muito ruim
1 2 tá bom
2 3 tá bom
0 1 um muito bom
3 4 um muito bom
4 5 um muito bom
O agrupamento por uma coluna categórica também mostra categorias vazias:
Em [130]: df.groupby("nota").size()
Fora[130]:
nota
muito ruim 1
ruim 0
médio 0
bom 2
muito bom 3
dtype: int64

2.1.11 Plotagem
Consulte a documentação sobre plotagem .
Usamos a convenção padrão para referenciar a API matplotlib:
Em [132]: plt.close("todos")
O método close() é usado para fechar uma janela de figura:
Em [133]: ts = pd.Series(np.random.randn(1000), index=pd.date_range("1/1/2000",ÿ ÿÿperíodos=1000))
Em [134]: ts = ts.cumsum()
Em [135]: ts.plot();
Se estiver executando no Jupyter Notebook, o gráfico aparecerá em plot(). Caso contrário, use matplotlib.pyplot.show para mostrá-lo ou
matplotlib.pyplot.savefig para gravá-lo em um arquivo.
Em [136]: plt.show();
Em um DataFrame, o método plot() é uma conveniência para plotar todas as colunas com rótulos:

Em [137]: df =
.....: pd.DataFrame( np.random.randn(1000, 4), index=ts.index, columns=["A", "B", "C", "D"]
..... :)
.....:
Em [138]: df = df.cumsum()
Em [139]: plt.figure();
Em [140]: df.plot();
Em [141]: plt.legend(loc='best');

2.1.12 Obtendo/retirando dados
CSV
Escrevendo em um arquivo csv:
Em [142]: df.to_csv("foo.csv")
Lendo de um arquivo csv:
Em [143]: pd.read_csv("foo.csv")
Fora[143]:
Sem nome: 0 A B C D
0 01-01-2000 0,701649 0,019252 1,138484 -0,847174
1 02-01-2000 0,312098 0,627255 0,374972 -0,303597
2 03/01/2000 1,564243 1,078204 0,744295 0,282089
3 04/01/2000 1,818604 2,075496 -0,131436 2,361285
4 05-01-2000 0,510218 2,343267 -0,280249 1,526873
.. ... ... ... ... ...
995 22/09/2002 40.541199 25.569585 -86.693241 -10.208283
996 23/09/2002 40,602904 26,209052 -87,715568 -9,628036
997 2002-09-24 40.430498 26.010464 -84.914798 -10.379692
998 25/09/2002 40,729559 26,875505 -84,355929 -10,248975
999 26/09/2002 40,135475 26,174219 -83,565551 -9,617955
HDF5
Lendo e gravando em HDFStores.
Escrevendo para uma loja HDF5:
Em [144]: df.to_hdf("foo.h5", "df")
Lendo de uma loja HDF5:
Em [145]: pd.read_hdf("foo.h5", "df")

Fora[145]:
A B C D
01-01-2000 0,701649 0,019252 1,138484 -0,847174
02-01-2000 0,312098 0,627255 0,374972 -0,303597
03/01/2000 1,564243 1,078204 0,744295 0,282089
04/01/2000 1,818604 2,075496 -0,131436 2,361285
05-01-2000 0,510218 2,343267 -0,280249 1,526873
... ... ... ... ...
22/09/2002 40.541199 25.569585 -86.693241 -10.208283
23/09/2002 40.602904 26.209052 -87.715568 -9.628036
24/09/2002 40.430498 26.010464 -84.914798 -10.379692
25/09/2002 40,729559 26,875505 -84,355929 -10,248975
26/09/2002 40,135475 26,174219 -83,565551 -9,617955

Excel
Ler e escrever em MS Excel.
Escrevendo em um arquivo Excel:
Em [146]: df.to_excel("foo.xlsx", sheet_name="Sheet1")
Lendo de um arquivo Excel:
Em [147]: pd.read_excel("foo.xlsx", "Sheet1", index_col=None, na_values=["NA"])

Fora[147]:
Sem nome: 0 A B C D
0 01-01-2000 0,701649 0,019252 1,138484 -0,847174
1 02/01/2000 0,312098 0,627255 0,374972 -0,303597
2 03/01/2000 1,564243 1,078204 0,744295 0,282089
3 04/01/2000 1,818604 2,075496 -0,131436 2,361285
4 05-01-2000 0,510218 2,343267 -0,280249 1,526873
.. ... ... ... ... ...
995 22/09/2002 40.541199 25.569585 -86.693241 -10.208283
996 23/09/2002 40,602904 26,209052 -87,715568 -9,628036
997 2002-09-24 40.430498 26.010464 -84.914798 -10.379692
998 25/09/2002 40,729559 26,875505 -84,355929 -10,248975
999 26/09/2002 40,135475 26,174219 -83,565551 -9,617955
2.1.13 Pegadinhas
Se você estiver tentando executar uma operação, poderá ver uma exceção como:
>>> se pd.Series([Falso, Verdadeiro, Falso]):

... print("Eu era verdade")
Rastreamento
...
ValueError: O valor verdade de uma matriz é ambíguo. Use a.empty, a.any() ou a.all().
Consulte Comparações para obter uma explicação e o que fazer.
Veja pegadinhas também.
2.2 Introdução às estruturas de dados
Começaremos com uma visão geral rápida e não abrangente das estruturas de dados fundamentais no pandas para você começar.
O comportamento fundamental sobre tipos de dados, indexação e rotulagem/alinhamento de eixos se aplica a todos os objetos. Para
comece, importe o NumPy e carregue o pandas em seu namespace:
Aqui está um princípio básico a ter em mente: o alinhamento dos dados é intrínseco. A ligação entre rótulos e dados não será quebrada
a menos que seja feito explicitamente por você.

Faremos uma breve introdução às estruturas de dados e, em seguida, consideraremos todas as categorias amplas de funcionalidades e métodos
em seções separadas.
2.2.1 Série
Série é uma matriz rotulada unidimensional capaz de conter qualquer tipo de dados (inteiros, strings, números de ponto flutuante, objetos
Python, etc.). Os rótulos dos eixos são chamados coletivamente de índice. O método básico para criar uma série é chamar:
>>> s = pd.Series(dados, índice=índice)
Aqui, os dados podem ser muitas coisas diferentes:
• um ditado Python
• um ndarray
• um valor escalar (como 5)
O índice passado é uma lista de rótulos de eixo. Assim, isso se separa em alguns casos dependendo de quais dados são:
De ndarray
Se os dados forem um ndarray, o índice deverá ter o mesmo comprimento dos dados. Se nenhum índice for passado, será criado um com
valores [0, ..., len(dados) - 1].
Em [3]: s = pd.Series(np.random.randn(5), index=["a", "b", "c", "d", "e"])
Entrada [4]:
s Saída
a [4]: 0,469112
b -0,282863 c
-1,509059 d
-1,135632
e 1.212112
tipo d: float64
In [5]: s.index Out[5]:

Índice(['a', 'b', 'c', 'd', 'e'], dtype='objeto')
Em [6]: pd.Series(np.random.randn(5))
Fora[6]:
0 -0,173215
1 0,119209
2 -1,044236
3-0,861849
4 -2.104569
tipo d: float64
Nota: o pandas suporta valores de índice não exclusivos. Se for tentada uma operação que não suporta valores de índice duplicados,
uma exceção será gerada nesse momento. A razão para ser preguiçoso é quase toda baseada no desempenho (há muitos casos em
cálculos, como partes de GroupBy, onde o índice não é usado).
Do ditado
As séries podem ser instanciadas a partir de dictos:
2.2. Introdução às estruturas de dados 175

Em [7]: d = {"b": 1, "a": 0, "c": 2}
Em [8]: pd.Series(d)
Fora[8]:
b 1
a 0
c 2
tipo d: int64
Nota: Quando os dados são um dict e um índice não é passado, o índice da série será ordenado pela inserção do dict
ordem, se você estiver usando a versão Python >= 3.6 e a versão pandas >= 0.23.
Se você estiver usando Python <3.6 ou pandas <0.23, e um índice não for passado, o índice da série será o ordenado lexicamente
lista de chaves de ditado.
No exemplo acima, se você estivesse em uma versão Python inferior a 3.6 ou em uma versão pandas inferior a 0.23, a Série
seria ordenado pela ordem lexical das chaves de dict (ou seja, ['a', 'b', 'c'] em vez de ['b', 'a', 'c']).
Se um índice for passado, os valores dos dados correspondentes aos rótulos do índice serão extraídos.
Em [9]: d = {"a": 0,0, "b": 1,0, "c": 2,0}
Em [10]: pd.Series(d)
Fora[10]:
a 0,0
b 1,0
c 2,0
tipo d: float64
Em [11]: pd.Series(d, index=["b", "c", "d", "a"])

Fora[11]:
b 1,0
c 2,0
d NaN
a 0,0
tipo d: float64
Nota: NaN (não um número) é o marcador de dados ausentes padrão usado em pandas.
Do valor escalar
Se os dados forem um valor escalar, um índice deverá ser fornecido. O valor será repetido para corresponder ao comprimento do índice.
Em [12]: pd.Series(5.0, index=["a", "b", "c", "d", "e"])

Fora[12]:
a 5,0
b 5,0
c 5,0
d 5,0
e 5,0
tipo d: float64

A série é semelhante a ndarray
Series age de forma muito semelhante a um ndarray e é um argumento válido para a maioria das funções NumPy. No entanto,
operações como fatiar também fatiarão o índice.
Em [13]: s[0]
Fora[13]: 0,4691122999071863
Em [14]: s[:3]
Saída [14]:
a 0,469112 b
-0,282863 c
-1,509059 dtype:
float64
Em [15]: s[s > s.median()]

Fora[15]:
a 0,469112
e 1.212112
tipo d: float64
Em [16]: s[[4, 3, 1]]

Saída [16]:
e 1,212112 d
-1,135632 b
-0,282863 dtype:
float64
Em [17]: np.exp(s)
Saída [17]:
a 1,598575
b 0,753623
c 0,221118
d 0,321219
e 3,360575
dtype: float64
Nota: abordaremos a indexação baseada em array como s[[4, 3, 1]] na seção sobre indexação.
Como um array NumPy, uma série pandas tem um dtype.
In [18]: s.dtype Out[18]:

dtype('float64')
Geralmente é um dtype NumPy. No entanto, pandas e bibliotecas de terceiros estendem o sistema de tipos do NumPy em alguns
lugares, caso em que o dtype seria um ExtensionDtype. Alguns exemplos dentro do pandas são dados categóricos e tipo de dados
inteiro anulável. Veja dtypes para mais.
Se você precisar do array real que suporta uma série, use Series.array.
In [19]: s.array Out[19]:
<PandasArray>

[0,4691122999071863, -0,2828633443286633, -1,5090585031735124, -1,1356323710171934,

1,2121120250208506]
Comprimento: 5, tipo d: float64
Acessar o array pode ser útil quando você precisa fazer alguma operação sem o índice (para desabilitar o alinhamento automático, por
exemplo).
Series.array sempre será um ExtensionArray. Resumidamente, um ExtensionArray é um invólucro fino em torno de um ou mais arrays
concretos , como numpy.ndarray. O pandas sabe como pegar um ExtensionArray e armazená-lo em uma série ou coluna de um
DataFrame. Veja dtypes para mais.
Embora Series seja semelhante a ndarray, se você precisar de um ndarray real , use Series.to_numpy().
Em [20]: s.to_numpy()
Fora[20]: array([0,4691, -0,2829, -1,5091, -1,1356, 1,2121])
Mesmo que a série seja apoiada por um ExtensionArray, Series.to_numpy() retornará um ndarray NumPy.
A série é semelhante a um ditado
Uma série é como um ditado de tamanho fixo, pois você pode obter e definir valores por rótulo de índice:
Em [21]: s["a"]
Fora[21]: 0,4691122999071863
Em [22]: s["e"] = 12,0
Em [23]: s
Fora[23]:
a 0,469112
b -0,282863
c -1,509059
d -1,135632
e 12.000.000
tipo d: float64
Em [24]: "e" em s
Fora[24]: Verdadeiro
Em [25]: "f" em s
Fora[25]: Falso
Se um rótulo não estiver contido, uma exceção será gerada:
>>> s["f"]
KeyError: 'f'
Usando o método get, um rótulo ausente retornará None ou o padrão especificado:
Em [26]: s.get("f")
Em [27]: s.get("f", np.nan)

Fora[27]: nan

Veja também a seção sobre acesso a atributos.
Operações vetorizadas e alinhamento de rótulos com séries
Ao trabalhar com matrizes NumPy brutas, geralmente não é necessário fazer um loop valor por valor. O mesmo é verdade
ao trabalhar com séries em pandas. As séries também podem ser passadas para a maioria dos métodos NumPy esperando um ndarray.
Em [28]: s + s
Fora[28]:
a 0,938225
b -0,565727
c -3.018117
d -2,271265
e 24.000000
tipo d: float64
Entrada [29]: s * 2
Saída[29]:
a 0,938225
b -0,565727
c -3.018117
d -2,271265
e 24.000000
tipo d: float64
Em [30]: np.exp(s)
Fora[30]:
a 1,598575
b 0,753623
c 0,221118
d 0,321219
e 162754.791419
tipo d: float64
Uma diferença importante entre Series e ndarray é que as operações entre Series alinham automaticamente os dados com base em
rótulo. Assim, você pode escrever cálculos sem considerar se as séries envolvidas têm o mesmo
rótulos.
Em [31]: s[1:] + s[:-1]

Fora[31]:
a NaN
b-0,565727
c-3,018117
d-2,271265
e NaN
tipo d: float64
O resultado de uma operação entre Séries não alinhadas terá a união dos índices envolvidos. Se um rótulo não for encontrado
em uma série ou outra, o resultado será marcado como faltando NaN. Ser capaz de escrever código sem fazer nada explícito
o alinhamento de dados concede imensa liberdade e flexibilidade na análise e pesquisa interativa de dados. Os dados integrados
recursos de alinhamento das estruturas de dados do pandas diferenciam o pandas da maioria das ferramentas relacionadas para trabalhar com
dados rotulados.

Nota: Em geral, optamos por fazer com que o resultado padrão das operações entre objetos indexados de forma diferente produza a
união dos índices para evitar perda de informações. Ter um rótulo de índice, embora os dados estejam faltando, normalmente é uma
informação importante como parte de um cálculo. É claro que você tem a opção de descartar rótulos com dados ausentes por meio da
função dropna .
Atributo de nome
A série também pode ter um atributo de nome:
Em [32]: s = pd.Series(np.random.randn(5), name="alguma coisa")
Em [33]: s
Fora[33]:
0 -0,494929
1 1.071804
2 0,721555
3 -0.706771 4
-1.039575 Nome:
algo, dtype: float64
In [34]: s.name Out[34]:

'alguma coisa'
O nome da série será atribuído automaticamente em muitos casos, especialmente ao obter fatias 1D do DataFrame, como você verá
abaixo.
Você pode renomear uma série com o método pandas.Series.rename() .
Em [35]: s2 = s.rename("diferente")
In [36]: s2.name Out[36]:

'diferente'
Observe que s e s2 referem-se a objetos diferentes.
2.2.2 DataFrame
DataFrame é uma estrutura de dados rotulada bidimensional com colunas de tipos potencialmente diferentes. Você pode pensar nisso
como uma planilha ou tabela SQL, ou um ditado de objetos Series. Geralmente é o objeto pandas mais comumente usado. Assim como
o Series, o DataFrame aceita muitos tipos diferentes de entrada:
• Ditado de ndarrays 1D, listas, dictos ou séries
• numpy.ndarray 2D
• Ndarray estruturado ou de registro
• Uma série
• Outro DataFrame
Junto com os dados, você pode opcionalmente passar argumentos de índice (rótulos de linha) e colunas (rótulos de coluna). Se você
passar um índice e/ou colunas, você está garantindo o índice e/ou colunas do DataFrame resultante. Assim, um dict of Series mais um
índice específico descartará todos os dados que não correspondam ao índice passado.

Se os rótulos dos eixos não forem passados, eles serão construídos a partir dos dados de entrada com base em regras de bom senso.
Nota: Quando os dados são um dict e as colunas não são especificadas, as colunas do DataFrame serão ordenadas pela ordem
de inserção do dict, se você estiver usando a versão Python >= 3.6 e pandas >= 0.23.
Se você estiver usando Python <3.6 ou pandas <0.23, e as colunas não forem especificadas, as colunas do DataFrame serão a lista
ordenada lexicamente de chaves de dict.
Do dict of Series ou dicts
O índice resultante será a união dos índices das diversas Séries. Se houver algum dict aninhado, ele será primeiro
convertido em Série. Se nenhuma coluna for passada, as colunas serão a lista ordenada de chaves de dict.
Em [37]: d = { "um":
....: pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]), "dois": pd.Series([ 1,0, 2,0, 3,0, 4,0],
....: índice=["a", "b", "c", "d"]),
....: }
....:
Em [38]: df = pd.DataFrame(d)
Em [39]: df
Fora[39]:
um dois
a 1,0 1,0 b 2,0
2,0 c 3,0 3,0 d
NaN 4,0
Em [40]: pd.DataFrame(d, index=["d", "b", "a"])

Fora[40]:
um dois
dNaN 4,0
b 2,0 2,0
um 1,0 1,0
Em [41]: pd.DataFrame(d, index=["d", "b", "a"], colunas=["dois", "três"])

Fora[41]:
dois três d
4,0 NaN b 2,0
NaN a 1,0 NaN
Os rótulos de linha e coluna podem ser acessados respectivamente acessando os atributos de índice e colunas :
Nota: Quando um determinado conjunto de colunas é passado junto com um ditado de dados, as colunas passadas substituem as chaves
do ditado.
In [42]: df.index Out[42]:

Index(['a', 'b', 'c', 'd'], dtype='object')

Em [43]: df.columns Out[43]:

Index(['one', 'two'], dtype='object')
Do ditado de ndarrays/listas
Os ndarrays devem ter todos o mesmo comprimento. Se um índice for passado, ele também deve ter claramente o mesmo comprimento que os
arrays. Se nenhum índice for passado, o resultado será range(n), onde n é o comprimento do array.
Em [44]: d = {"um": [1,0, 2,0, 3,0, 4,0], "dois": [4,0, 3,0, 2,0, 1,0]}
Em [45]: pd.DataFrame(d)
Fora[45]:
um dois
0 1,0 4,0 1 2,0
3,0 2 3,0 2,0 3
4,0 1,0
Em [46]: pd.DataFrame(d, index=["a", "b", "c", "d"])

Fora[46]:
um dois
a 1,0 4,0 b 2,0
3,0 c 3,0 2,0
d 4,0 1,0
De matriz estruturada ou de registros
Este caso é tratado de forma idêntica a um ditado de arrays.
Em [47]: dados = np.zeros((2,), dtype=[("A", "i4"), ("B", "f4"), ("C", "a10")])
Em [48]: dados[:] = [(1, 2.0, "Olá"), (2, 3.0, "Mundo")]
Em [49]: pd.DataFrame(dados)
Fora[49]:
A B C
0 1 2,0 b'Olá' 1 2 3,0 b'Mundo'
Em [50]: pd.DataFrame(dados, índice=["primeiro", "segundo"])

Fora[50]: A
B
C primeiro 1 2,0 b'Olá' segundo 2 3,0
b'Mundo'
Em [51]: pd.DataFrame(dados, colunas=["C", "A", "B"])

Fora[51]:
CA B


0 b'Olá' 1 2.0
1 b'Mundo' 2 3,0
Nota: DataFrame não se destina a funcionar exatamente como um ndarray NumPy bidimensional.
De uma lista de dictos
Em [52]: dados2 = [{"a": 1, "b": 2}, {"a": 5, "b": 10, "c": 20}]
Em [53]: pd.DataFrame(dados2)
Fora[53]:
ab c
01 2NaN
1 5 10 20,0
Em [54]: pd.DataFrame(data2, index=["primeiro", "segundo"])

Fora[54]:
ab c
primeiros 1 2 NaN
segundo 5 10 20,0
Em [55]: pd.DataFrame(data2, colunas=["a", "b"])

Fora[55]:
ab
01 2
1 5 10
De um ditado de tuplas
Você pode criar automaticamente um quadro MultiIndexado passando um dicionário de tuplas.
Em [56]: pd.DataFrame(
....: {
....: ("a", "b"): {("A", "B"): 1, ("A", "C"): 2},
....: ("a", "a"): {("A", "C"): 3, ("A", "B"): 4},
....: ("a", "c"): {("A", "B"): 5, ("A", "C"): 6},
....: ("b", "a"): {("A", "C"): 7, ("A", "B"): 8},
....: ("b", "b"): {("A", "D"): 9, ("A", "B"): 10},
....: }
....: )
....:
Fora[56]:
a b
bb a c a
AB 1,0 4,0 5,0 8,0 10,0
C 2,0 3,0 6,0 7,0 NaN
D NaN NaN NaN NaN 9,0

De uma série
O resultado será um DataFrame com o mesmo índice da Série de entrada e com uma coluna cujo nome é o nome original da
Série (somente se nenhum outro nome de coluna for fornecido).
De uma lista de instâncias nomeadas
Os nomes dos campos do primeiro nomeado na lista determinam as colunas do DataFrame. As tuplas nomeadas restantes (ou
tuplas) são simplesmente descompactadas e seus valores são inseridos nas linhas do DataFrame. Se alguma dessas tuplas for
menor que a primeira tupla nomeada, as colunas posteriores na linha correspondente serão marcadas como valores ausentes.
Se algum for maior que a primeira tupla nomeada, um ValueError será gerado.
Em [57]: de coleções importar nomeadotuple
Em [58]: Ponto = nomeadotuple("Ponto", "x y")
Em [59]: pd.DataFrame([Ponto(0, 0), Ponto(0, 3), (2, 3)])

Fora[59]:
xy 0 0
0
103
22 3
Em [60]: Ponto3D = nomeadotuple("Ponto3D", "xy z")
Em [61]: pd.DataFrame([Point3D(0, 0, 0), Point3D(0, 3, 5), Point(2, 3)])

Fora[61]:
xy 0 0 z
0 0,0 1 0 3 5,0 2 2
3 NaN
De uma lista de classes de dados
Novo na versão 1.1.0.
As classes de dados introduzidas no PEP557 podem ser passadas para o construtor DataFrame. Passar uma lista de classes de
dados equivale a passar uma lista de dicionários.
Esteja ciente de que todos os valores na lista devem ser classes de dados; misturar tipos na lista resultaria em um TypeError.
Em [62]: de dataclasses importar make_dataclass
Em [63]: Ponto = make_dataclass("Ponto", [("x", int), ("y", int)])
Em [64]: pd.DataFrame([Ponto(0, 0), Ponto(0, 3), Ponto(2, 3)])

Fora[64]:
xy 0 0
0
103
22 3
Dados ausentes

Muito mais será dito sobre este tópico na seção Dados ausentes . Para construir um DataFrame com dados faltantes, usamos
np.nan para representar valores ausentes. Alternativamente, você pode passar um numpy.MaskedArray como argumento de dados para o
Construtor DataFrame e suas entradas mascaradas serão consideradas ausentes.
Construtores alternativos
DataFrame.from_dict
DataFrame.from_dict pega um ditado de dictos ou um ditado de sequências semelhantes a array e retorna um DataFrame. Funciona como
o construtor DataFrame, exceto para o parâmetro orient que é 'colunas' por padrão, mas que pode ser definido como
'index' para usar as chaves dict como rótulos de linha.
Em [65]: pd.DataFrame.from_dict(dict([("A", [1, 2, 3]), ("B", [4, 5, 6])]))

Fora[65]:
AB
014
12 5
236
Se você passar orient='index', as chaves serão os rótulos das linhas. Neste caso, você também pode passar os nomes das colunas desejadas:
Em [66]: pd.DataFrame.from_dict(
....: ditado([("A", [1, 2, 3]), ("B", [4, 5, 6])]),
....: orientar = "índice",
....: colunas=["um", "dois", "três"],
....: )
....:
Fora[66]:
um dois três
A 1 2 3
B 4 5 6
DataFrame.from_records
DataFrame.from_records pega uma lista de tuplas ou um ndarray com dtype estruturado. Funciona de forma análoga ao
construtor DataFrame normal, exceto que o índice DataFrame resultante pode ser um campo específico do estruturado
tipo. Por exemplo:
Em [67]: dados
Fora[67]:
array([(1, 2., b'Olá'), (2, 3., b'Mundo')],
dtype=[('A', '<i4'), ('B', '<f4'), ('C', 'S10')])
Em [68]: pd.DataFrame.from_records(data, index="C")

Fora[68]:
A B
C
b'Olá' 1 2.0
b'Mundo' 2 3.0

Seleção, adição, exclusão de coluna
Você pode tratar um DataFrame semanticamente como um ditado de objetos Series indexados da mesma forma. Obter, definir e excluir
colunas funciona com a mesma sintaxe das operações análogas de dict:
Em [69]: df["um"]
Fora[69]:
a 1,0
b 2,0
c 3,0
d NaN
Nome: um, dtype: float64
Em [70]: df["três"] = df["um"] * df["dois"]
Em [71]: df["flag"] = df["one"] > 2
In [72]: df Out
[72]: um
dois três sinalizadores a 1,0 1,0
1,0 Falso b 2,0 2,0 4,0 Falso c 3,0 3,0
9,0 Verdadeiro d NaN 4,0 NaN Falso
As colunas podem ser excluídas ou exibidas como um dict:
Em [73]: del df["dois"]
Em [74]: três = df.pop("três")
In [75]: df
Out[75]: um
sinalizador a
1,0 Falso b 2,0
Falso c 3,0
Verdadeiro d NaN
Falso
Ao inserir um valor escalar, ele será naturalmente propagado para preencher a coluna:
Em [76]: df["foo"] = "barra"
In [77]: df
Out[77]: um
flag foo a 1.0 False bar
b 2.0 Barra falsa

c 3.0 Barra verdadeira
d NaN Barra falsa
Ao inserir uma Série que não possui o mesmo índice do DataFrame, ela ficará conforme o índice do DataFrame:

Em [78]: df["one_trunc"] = df["one"][:2]
Em [79]: df
Fora[79]:
uma bandeira foo one_trunc
uma barra falsa de 1,0 1,0
b 2,0 Barra falsa c 3,0 2,0
Barra verdadeira d NaN NaN
Barra falsa NaN
Você pode inserir ndarrays brutos, mas seu comprimento deve corresponder ao comprimento do índice do DataFrame.
Por padrão, as colunas são inseridas no final. A função de inserção está disponível para inserção em um local específico no
colunas:
Em [80]: df.insert(1, "bar", df["um"])
Em [81]: df
Fora[81]:
sinalizador de uma barra foo one_trunc
a 1,0 1,0 Barra falsa 1,0
b 2,0 2,0 Barra falsa c 3,0 3,0 2,0
Barra verdadeira d NaN NaN Barra NaN
falsa NaN
Atribuindo novas colunas em cadeias de métodos
Inspirado no verbo mutate do dplyr , o DataFrame possui um método assign() que permite criar facilmente novas colunas
que são potencialmente derivados de colunas existentes.
Em [82]: iris = pd.read_csv("data/iris.data")
Em [83]: iris.head()
Fora[83]:
SépalaComprimento SépalaLargura PétalaComprimento PétalaLargura Nome
0 5,1 3,5 1,4 0,2 Íris-setosa
1 4,9 3,0 1,4 0,2 Íris-setosa
2 4,7 3,2 1,3 0,2 Íris-setosa
3 4,6 3,1 1,5 0,2 Íris-setosa
4 5,0 3,6 1,4 0,2 Íris-setosa
Em [84]: iris.assign(sepal_ratio=iris["SepalWidth"] / iris["SepalLength"]).head()

Fora[84]:
SépalaComprimento SépalaLargura PétalaComprimento PétalaLargura Nome sepal_ratio
0 5.1 3.5 1,4 0,2 Íris-setosa 0,686275
1 4.9 3,0 1.4 0,2 Íris-setosa 0,612245
2 4.7 3.2 1.3 0,2 Íris-setosa 0,680851
3 4.6 3.1 1,5 0,2 Íris-setosa 0,2 Íris-setosa 0,673913
4 5,0 3.6 1.4 0,720000
No exemplo acima, inserimos um valor pré-computado. Também podemos passar uma função de um argumento a ser avaliado
no DataFrame que está sendo atribuído.

Em [85]: iris.assign(sepal_ratio=lambda x: (x["SepalWidth"] / x["SepalLength"])).head()

Fora[85]:
SépalaComprimento SépalaLargura PétalaComprimento PétalaLargura Nome sepal_ratio
0 5.1 3.5 1,4 0,2 Íris-setosa 0,686275
1 4.9 3,0 1.4 0,2 Íris-setosa 0,2 Íris-setosa 0,612245
2 4.7 3.2 1.3 0,2 Íris-setosa 0,2 Íris-setosa 0,680851
3 4.6 3.1 1,5 0,673913
4 5,0 3.6 1.4 0,720000
atribuir sempre retorna uma cópia dos dados, deixando o DataFrame original intacto.
Passar um valor que pode ser chamado, em vez de um valor real a ser inserido, é útil quando você não tem uma referência ao
DataFrame em mãos. Isso é comum ao usar atribuir em uma cadeia de operações. Por exemplo, podemos limitar o
DataFrame apenas para aquelas observações com comprimento de sépala maior que 5, calcule a proporção e represente graficamente:
Em [86]: (
....: iris.query("Comprimento Sépala > 5")
....: .atribuir(
....: SepalRatio=lambda x: x.SepalWidth / x.SepalLength,
....: PetalRatio = lambda x: x.PetalWidth / x.PetalLength,
....: )
....: .plot(kind="dispersão", x="SepalRatio", y="PetalRatio")
....: )
....:
Fora[86]: <AxesSubplot:xlabel='SepalRatio', ylabel='PetalRatio'>

Como uma função é passada, a função é calculada no DataFrame ao qual está sendo atribuído. É importante ressaltar que este é o
DataFrame que foi filtrado para as linhas com comprimento de sépala maior que 5. A filtragem acontece primeiro e depois o
cálculos de proporção. Este é um exemplo em que não tínhamos referência ao DataFrame filtrado disponível.
A assinatura da função para atribuir é simplesmente **kwargs. As chaves são os nomes das colunas dos novos campos e os
valores são um valor a ser inserido (por exemplo, uma matriz Series ou NumPy) ou uma função de um argumento a ser
chamado no DataFrame. Uma cópia do DataFrame original é retornada, com os novos valores inseridos.
A partir do Python 3.6, a ordem dos **kwargs é preservada. Isso permite a atribuição dependente , onde uma expressão
posterior em **kwargs pode se referir a uma coluna criada anteriormente na mesma atribuição().
Em [87]: dfa = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
Em [88]: dfa.assign(C=lambda x: x["A"] + x["B"], D=lambda x: x["A"] + x["C"])

Fora[88]:
ABCD
01456
12579
2 3 6 9 12
Na segunda expressão, x['C'] se referirá à coluna recém-criada, que é igual a dfa['A'] + dfa['B'].

Indexação/seleção
Os princípios básicos da indexação são os seguintes:
Operação Sintaxe Resultado
Selecionar coluna df[col] Series

Selecione linha por rótulo df.loc[rótulo] Series
Selecione linha por localização inteira df.iloc[loc] df[5:10] Series
Fatiar linhas df[bool_vec] Quadro de dados
Selecione linhas por vetor booleano Quadro de dados
A seleção de linhas, por exemplo, retorna uma Série cujo índice são as colunas do DataFrame:
Em [89]: df.loc["b"]
Fora[89]:
um 2,0
bar 2,0
Falso
bandeira foo bar
one_trunc 2,0
Nome: b, dtype: objeto
Em [90]: df.iloc[2]
Fora[90]:
um 3,0
3,0
bandeira Verdadeiro
de bar foo bar

one_trunc NaN
Nome: c, dtype: objeto
Para um tratamento mais exaustivo da indexação e divisão sofisticada baseada em rótulos, consulte a seção sobre indexação. Vamos
abordar os fundamentos da reindexação/conformidade com novos conjuntos de rótulos na seção sobre reindexação.
Alinhamento de dados e aritmética
O alinhamento de dados entre objetos DataFrame alinha automaticamente nas colunas e no índice (rótulos de linha).
Novamente, o objeto resultante terá a união dos rótulos de coluna e linha.
Em [91]: df = pd.DataFrame(np.random.randn(10, 4), colunas=["A", "B", "C", "D"])
Em [92]: df2 = pd.DataFrame(np.random.randn(7, 3), colunas=["A", "B", "C"])
Em [93]: df + df2
Fora[93]:
A B CD
0 0,045691 -0,014138 1,380871 NaN
1 -0,955398 -1,501007 0,037181 NaN
2 -0,662690 1,534833 -0,859691 NaN
3 -2,452949 1,237274 -0,133712 NaN
4 1,414490 1,951676 -2,320422 NaN
5 -0,494922 -1,649727 -1,084601 NaN

6 -1,047551 -0,748572 -0,805479 NaN

7 NaN NaN NaN NaN
8 NaN NaN NaN NaN
9 NaN NaN NaN NaN
Ao fazer uma operação entre DataFrame e Series, o comportamento padrão é alinhar o índice Series no
Colunas do DataFrame , transmitindo assim por linha. Por exemplo:
Em [94]: df - df.iloc[0]
Fora[94]:
A B C D
0 0,000000 0,000000 0,000000 0,000000
1 -1,359261 -0,248717 -0,453372 -1,754659
2 0,253128 0,829678 0,010026 -1,991234
3 -1,311128 0,054325 -1,724913 -1,620544
4 0,573025 1,500742 -0,676070 1,367331
5 -1,741248 0,781993 -1,241620 -2,053136
6 -1,240774 -0,869551 -0,153282 0,000430
7 -0,743894 0,411013 -0,929563 -0,282386
8 -1,194921 1,320690 0,238224 -1,482644
9 2,293786 1,856228 0,773289 -1,446531
Para controle explícito sobre o comportamento de correspondência e transmissão, consulte a seção sobre operações binárias flexíveis.
As operações com escalares são exatamente como você esperaria:
Em [95]: df * 5 + 2
Fora[95]:
A B D
C0 3,359299 -0,124862 4,835102 3,381160
1 -3,437003 -1,368449 2,568242 -5,392133
2 4,624938 4,023526 4,885230 -6,575010
3 -3,196342 0,146766 -3,789461 -4,721559
4 6,224426 7,378849 1,454750 10,217815
5 -5,346940 3,785103 -1,373001 -6,884519
6 -2,844569 -4,472618 4,068691 3,383309
7 -0,360173 1,930201 0,187285 1,969232
8 -2,615303 6,478587 6,026220 -4,032059
9 14.828230 9.156280 8.701544 -3.851494
Em [96]: 1 / df
Fora[96]:
A B D
C0 3,678365 -2,353094 1,763605 3,620145
1 -0,919624 -1,484363 8,799067 -0,676395
2 1,904807 2,470934 1,732964 -0,583090
3 -0,962215 -2,697986 -0,863638 -0,743875
4 1,183593 0,929567 -9,170108 0,608434
5 -0,680555 2,800959 -1,482360 -0,562777
6 -1,032084 -0,772485 2,416988 3,614523
7 -2,118489 -71,634509 -2,758294 -162,507295
8 -1,083352 1,116424 1,241860 -0,828904
9 0,389765 0,698687 0,746097 -0,854483

Em [97]: df ** 4
Fora[97]:
A B C D
0 0,005462 3,261689e-02 0,103370 5,822320e-03
1 1,398165 2,059869e-01 0,000167 4,777482e+00
2 0,075962 2,682596e-02 0,110877 8,650845e+00
3 1.166571 1.887302e-02 1.797515 3.265879e+00
4 0,509555 1,339298e+00 0,000141 7,297019e+00
5 4,661717 1,624699e-02 0,207103 9,969092e+00
6 0,881334 2,808277e+00 0,029302 5,858632e-03 7 0,049647 3,797614e-08
0,017276 1,433866e-09 8 0,725974 6,437005e-01 0,420 446 2.118275e+00
9 43.329821 4.196326e+00 3.227153 1.875802e+00
Os operadores booleanos também funcionam:
Em [98]: df1 = pd.DataFrame({"a": [1, 0, 1], "b": [0, 1, 1]}, dtype=bool)
Em [99]: df2 = pd.DataFrame({"a": [0, 1, 1], "b": [1, 1, 0]}, dtype=bool)
Em [100]: df1 e df2

Fora[100]:
a b
0 Falso Falso
1 Falso Verdadeiro
2 Verdadeiro Falso
Em [101]: df1 | df2

Fora[101]:
a b
0 Verdadeiro Verdadeiro
Em [102]: df1 ^ df2

Fora[102]:
a b
1 Verdadeiro Falso
2 Falso Verdadeiro
Em [103]: -df1
Fora[103]:
a b
0 Falso Verdadeiro
1 Verdadeiro Falso
2 Falso Falso

Transposição
Para transpor, acesse o atributo T (também a função de transposição), semelhante a um ndarray:
# mostra apenas as 5 primeiras linhas

Em [104]: df[:5].T
Fora[104]:
0 1 2 3 4
A 0,271860 -1,087401 0,524988 -1,039268 0,844885
B -0,424972 -0,673690 0,404705 -0,370647 1,075770
C 0,567020 0,113648 0,577046 -1,157892 -0,109050
D 0,276232 -1,478427 -1,715002 -1,344312 1,643563
Interoperabilidade do DataFrame com funções NumPy
Elementwise NumPy ufuncs (log, exp, sqrt, . . . ) e várias outras funções NumPy podem ser usadas sem problemas em
Series e DataFrame, assumindo que os dados contidos nele são numéricos:
Em [105]: np.exp(df)
Fora[105]:
A B D
C0 1,312403 0,653788 1,763006 1,318154
1 0,337092 0,509824 1,120358 0,227996
2 1,690438 1,498861 1,780770 0,179963
3 0,353713 0,690288 0,314148 0,260719
4 2,327710 2,932249 0,896686 5,173571
5 0,230066 1,429065 0,509360 0,169161
6 0,379495 0,274028 1,512461 1,318720
7 0,623732 0,986137 0,695904 0,993865
8 0,397301 2,449092 2,237242 0,299269
9 13,009059 4,183951 3,820223 0,310274
Em [106]: np.asarray(df)
Fora[106]:
matriz([[ 0,2719, -0,425, 0,2762], , 0,567
[-1,0874, -0,6737, 0,1136, -1,4784],
[0,525 -1,715],
, 0,4047, 0,577 ,
[-1,0393, -0,3706, -1,1579, -1,3443],
[0,8449, 1,0758, -0,109, 1,6436],
[-1,4694, 0,357, -0,6746, -1,7769],
[-0,9689, -1,2945, 0,4137, 0,2767],
, -0,014
[-0,472, -0,3625, -0,0062],
[-0,9231, 0,8957, 0,8052, -1,2064],
[2,5656, 1,4313, 1,3403, -1,1703]])
O DataFrame não se destina a ser um substituto imediato para o ndarray, pois sua semântica de indexação e modelo de dados são bastante
diferente em alguns lugares de uma matriz n-dimensional.
Series implementa __array_ufunc__, o que permite trabalhar com funções universais do NumPy.
O ufunc é aplicado ao array subjacente em uma série.
Em [107]: ser = pd.Series([1, 2, 3, 4])

Em [108]: np.exp(ser)
Fora[108]:
0 2.718282
1 7.389056
2 20.085537
3 54.598150
tipo d: float64
Alterado na versão 0.25.0: Quando múltiplas séries são passadas para um ufunc, elas são alinhadas antes de executar o
Operação.
Como outras partes da biblioteca, o pandas alinhará automaticamente as entradas rotuladas como parte de um ufunc com múltiplas entradas. Para
por exemplo, usar numpy.remainder() em duas séries com rótulos ordenados de forma diferente será alinhado antes da operação.
Em [109]: ser1 = pd.Series([1, 2, 3], índice=["a", "b", "c"])
Em [110]: ser2 = pd.Series([1, 3, 5], índice=["b", "a", "c"])
Em [111]: ser1
Fora[111]:
a 1
b 2
c 3
tipo d: int64
Em [112]: ser2
Fora[112]:
b 1
a 3
c 5
tipo d: int64
Em [113]: np.remainder(ser1, ser2)

Fora[113]:
a 1
b 0
c 3
tipo d: int64
Como de costume, a união dos dois índices é feita e os valores não sobrepostos são preenchidos com os valores faltantes.
Em [114]: ser3 = pd.Series([2, 4, 6], índice=["b", "c", "d"])
Em [115]: ser3
Fora[115]:
b2
c 4
d6
tipo d: int64
Em [116]: np.remainder(ser1, ser3)

Fora[116]:
a NaN

b 0,0
c 3,0
d NaN
tipo d: float64
Quando um ufunc binário é aplicado a uma Série e Índice, a implementação da Série tem precedência e uma Série é
devolvida.
Em [117]: ser = pd.Series([1, 2, 3])
Em [118]: idx = pd.Index([4, 5, 6])
Em [119]: np.maximum(ser, idx)

Fora[119]:
04
15
26
tipo d: int64
Ufuncs NumPy são seguros para aplicação em séries apoiadas por matrizes não ndarray, por exemplo arrays.SparseArray (consulte
Cálculo esparso). Se possível, o ufunc é aplicado sem converter os dados subjacentes em um ndarray.
Exibição do console
DataFrames muito grandes serão truncados para exibi-los no console. Você também pode obter um resumo usando info().
(Aqui estou lendo uma versão CSV do conjunto de dados de beisebol do pacote plyr R):
Em [120]: beisebol = pd.read_csv("data/baseball.csv")
Em [121]: imprimir(beisebol)
id jogador ano período equipe lg g ab r h X2b X3b hr rbi sb ÿ
ÿÿcs bb então ibb hbp sh sf gidp

0 88641 womacto01 2006 2 CHN NL 19 50 6 14 ÿÿ0 4 4,0 0,0 0,0 3,0 0,0 0,0 1 0 1 2,0 1,0 1.
1 88643 schilcu01 2006 1 BOS AL 31 ÿÿ0 0 1,0 0,0 0,0 0,0 0,0 0,0 20 1 0 0 0 0,0 0,0 0.
.. ... ... ... ... ... .. .. ... .. ... ... ... .. ... ... ..
ÿÿ. .. ... ... ... ... ... ...
98 89533 aloumo01 2007 ÿÿ0 27 30,0 5,0 1 NYN NL 87 328 51 112 19 1 13 49,0 3,0 0.
2,0 0,0 3,0 13,0
99 89534 alomasa02 2007 1 NYN NL 8 22 1 3 1 0 0 0,0 0,0 0.
ÿÿ0 0 3,0 0,0 0,0 0,0 0,0 0,0
Em [122]: baseball.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100 entradas, 0 a 99
Colunas de dados (total de 23 colunas):
# Tipo de contagem não nula da coluna
--- ------ -------------- -----
0 identificação 100 não nulo int64


1 jogador 100 não nulos 2 anos objeto

100 não nulos 3 períodos 100 int64
não nulos int64
4 equipe 100 não nulo objeto
5lg 6g 100 não-nulo objeto
7ab 100 não-nulo int64
100 não-nulo int64
8 R 100 não-nulo int64
9h 100 não-nulo int64
10X2b 100 não-nulo int64
11 X3b 100 não-nulo int64
12 100 não-nulo int64
horas 13 100 não-nulo float64
rbi 14 100 não-nulo float64
sb 15 100 não-nulo float64
cs 16 100 não-nulo int64
bb 17 100 não -nulo float64
então 18 100 não nulo float64
ibb 19 100 não nulo float64
hbp 20 100 não nulo float64
sh 21 sf 100 não nulo float64
22 gidp 100 não nulo float64
dtypes: float64(9), int64(11), objeto(3)
uso de memória: 18,1+ KB
No entanto, usar to_string retornará uma representação de string do DataFrame em formato tabular, embora nem sempre
ajuste a largura do console:
Em [123]: print(baseball.iloc[-20:, :12].to_string())

eu ia jogador ano período equipe lg g ab rh X2b X3b
80 89474 finlest01 2007 81 89480 1 COL NL 43 94 9 17 3 0
embreal01 2007 82 89481 1 CARVALHO AL 0 0 0 4 0 0
edmonji01 2007 83 89482 1 SLN NL 117 365 39 92 15 2
easleda01 2007 84 89489 1 NYN NL 76 193 24 54 6 0
delgaca01 2007 85 89493 1 NYN NL 139 538 71 139 30 0
cormirh01 2007 86 89 494 1 CIN NL 0 0 0 6 0 0
coninje01 2007 87 89495 coninje01 2 NYN NL 21 41 2 2 0 8
2007 88 89497 clemero02 2007 89 1 CIN NL 80 215 23 57 11 1

89498 claytro01 2007 90 89499 1NYA AL 2 2 0 1 00
claytro01 2007 91 89501 cirilje01 2 BOS AL 0 0 8 6 1 0

2007 92 89502 cirilje01 2007 93 1TOR AL 69 189 23 48 14 0
89521 bondsba01 2007 2 ARI NL 28 40 6 8 4 0
1MIN AL 50 153 18 40 9 2
1 SFN NL 126 340 75 94 14 0
94 89523 biggicr01 2007 95 89525 1 HOU NL 141 517 68 130 31 3
benitar01 2007 96 89526 benitar01 2FLO NL 34 0 0 0 0 0
2007 97 89530 ausmubr01 2007 1 SFNNL 19 0 0 0 0 0
98 89533 aloumo01 2007 99 89534 1 HOU NL 117 349 38 82 16 3
alomasa02 2007 1 NYN NL 87 328 51 112 19 1
1 NYN NL 8 22 1 3 1 0
Wide DataFrames serão impressos em várias linhas por padrão:

Em [124]: pd.DataFrame(np.random.randn(3, 12))

Fora[124]:
0 1 2 3 4 5 6 7 ÿ
ÿÿ8 9 10 11
0 -1,226825 0,769804 -1,281247 -0,727707 -0,121306 -0,097883 0,695775 0,341734 0.
ÿÿ959726 -1,110336 -0,619976 0,149748
1 -0,732339 0,687738 0,176444 0,403310 -0,154951 0,301624 -2,179861 -1,369849 -0.
ÿÿ954208 1,462696 -1,743161 -0,826591
2 -0,345352 1,314232 0,690579 0,995761 2,396780 0,014871 3,357427 -0,317441 -1.
ÿÿ236269 0,896171 -0,487602 -0,082240
Você pode alterar quanto imprimir em uma única linha definindo a opção display.width:
Em [125]: pd.set_option("display.width", 40) # o padrão é 80
Em [126]: pd.DataFrame(np.random.randn(3, 12))

Fora[126]:
0 1 2 3 4 5 6 7 ÿ
ÿÿ8 9 10 11
0 -2,182937 0,380396 0,084844 0,432390 1,519970 -0,493662 0,600178 0,274230 0.
ÿÿ132885 -0,023688 2,410179 1,450520
1 0,206053 -0,251905 -2,213588 1,063327 1,266143 0,299368 -0,863838 0,408204 -1.
ÿÿ048089 -0,025747 -0,988387 0,094055
2 1,262731 1,289997 0,082423 -0,055758 0,536580 -0,489682 0,369374 -0,034571 -2.
ÿÿ484478 -0,281461 0,030711 0,109121
Você pode ajustar a largura máxima das colunas individuais definindo display.max_colwidth
Em [127]: arquivo de dados = {

.....: "nome do arquivo": ["nome do arquivo_01", "nome do arquivo_02"],
.....: "caminho": [
.....: "mídia/nome_usuário/armazenamento/pasta_01/nome_arquivo_01",
.....: "mídia/nome_usuário/armazenamento/pasta_02/nome_arquivo_02",
.....: ],
.....: }
.....:
Em [128]: pd.set_option("display.max_colwidth", 30)
Em [129]: pd.DataFrame(arquivo de dados)

Fora[129]:
nome do arquivo caminho
0 nome_do_arquivo_01 mídia/nome_do_usuário/armazenamento/fo...
1 nome_do_arquivo_02 mídia/nome_do_usuário/armazenamento/fo...
Em [130]: pd.set_option("display.max_colwidth", 100)
Em [131]: pd.DataFrame(arquivo de dados)

Fora[131]:
nome do arquivo caminho
0 nome_arquivo_01 mídia/nome_usuário/armazenamento/pasta_01/nome_arquivo_01
1 nome_arquivo_02 mídia/nome_usuário/armazenamento/pasta_02/nome_arquivo_02
Você também pode desativar esse recurso por meio da opção expand_frame_repr. Isso imprimirá a tabela em um bloco.

Acesso ao atributo da coluna DataFrame e conclusão do IPython
Se um rótulo de coluna DataFrame for um nome de variável Python válido, a coluna poderá ser acessada como um atributo:
Em [132]: df = pd.DataFrame({"foo1": np.random.randn(5), "foo2": np.random.randn(5)})
Em [133]: df
Fora[133]:
foo1 foo2
0 1,126203 0,781836
1 -0,977349 -1,071357
2 1,474071 0,441153
3 -0,064034 2,353925
4 -1,282782 0,583787
Entrada [134]: df.foo1

Saída[134]:
0 1.126203
1 -0,977349 2
1,474071 3
-0,064034 4
-1,282782 Nome:
foo1, dtype: float64
As colunas também estão conectadas ao mecanismo de conclusão do IPython para que possam ser preenchidas com guias:
Em [5]: df.foo<TAB> # noqa: E225, E999 df.foo1 df.foo2
2.3 Funcionalidades básicas essenciais
Aqui discutimos muitas das funcionalidades essenciais comuns às estruturas de dados do pandas. Para começar, vamos criar
alguns objetos de exemplo como fizemos na seção 10 minutos para pandas :
Em [1]: índice = pd.date_range("1/1/2000", períodos=8)
Em [3]: df = pd.DataFrame(np.random.randn(8, 3), index=index, columns=["A", "B", "C"])
2.3.1 Cabeça e cauda
Para visualizar uma pequena amostra de um objeto Series ou DataFrame, use os métodos head() e tail() . O número padrão de elementos
a serem exibidos é cinco, mas você pode passar um número personalizado.
Em [4]: long_series = pd.Series(np.random.randn(1000))
Em [5]: long_series.head()
Saída[5]:
0 -1,157892


1 -1,344312
2 0,844885
3 1,075770
4 -0,109050
tipo d: float64
Em [6]: long_series.tail(3)
Fora[6]:
997 -0,289388
998 -1.020544
999 0,589993
tipo de d: float64
2.3.2 Atributos e dados subjacentes
objetos pandas têm vários atributos que permitem acessar os metadados
• shape: fornece as dimensões do eixo do objeto, consistente com ndarray
• Rótulos de eixo
– Série: índice (apenas eixo)
– DataFrame: índice (linhas) e colunas
Observe que esses atributos podem ser atribuídos com segurança!
Em [7]: df[:2]
Fora[7]:
A B C
01-01-2000 -0,173215 0,119209 -1,044236
02/01/2000 -0,861849 -2,104569 -0,494929
Em [8]: df.columns = [x.lower() para x em df.columns]
Em [9]: df
Fora[9]:
a b c
01-01-2000 -0,173215 0,119209 -1,044236
2000-01-02 -0,861849 -2,104569 -0,494929 2000-01-03
1,071804 0,721555 -0,706771 2000-01-04 -1,039575 0,271860
-0,424972 2000-01 -05 0,567020 0,276232 -1,087401
2000-01-06 -0,673690 0,113648 -1,478427 2000 -01-07
0,524988 0,404705 0,577046 2000-01-08 -1,715002 -1,039268
-0,370647
objetos pandas (Índice, Série, DataFrame) podem ser considerados contêineres para matrizes, que armazenam os dados reais e fazem o
cálculo real. Para muitos tipos, a matriz subjacente é numpy.ndarray. No entanto, pandas e bibliotecas de terceiros podem estender o sistema
de tipos do NumPy para adicionar suporte para arrays personalizados (consulte dtypes).
Para obter os dados reais dentro de um índice ou série, use a propriedade .array
2.3. Funcionalidade básica essencial 199

In [10]: s.array Out[10]:
<PandasArray>
[0,4691122999071863, -0,2828633443286633, -1,5090585031735124, -1,1356323710171934,
1,21211202502085 06]
Comprimento: 5, tipo d: float64
In [11]: s.index.array Out[11]:
<PandasArray>
['a', 'b', 'c', 'd', 'e']
Comprimento: 5, dtype: objeto
array sempre será um ExtensionArray. Os detalhes exatos do que é um ExtensionArray e por que o pandas os utiliza estão um
pouco além do escopo desta introdução. Veja dtypes para mais.
Se você sabe que precisa de um array NumPy, use to_numpy() ou numpy.asarray().
Em [12]: s.to_numpy()
Fora[12]: array([0,4691, -0,2829, -1,5091, -1,1356, 1,2121])
Em [13]: np.asarray(s)
Fora[13]: array([0,4691, -0,2829, -1,5091, -1,1356, 1,2121])
Quando a série ou índice é apoiado por um ExtensionArray, to_numpy() pode envolver a cópia de dados e a coerção de valores.
Veja dtypes para mais.
to_numpy() dá algum controle sobre o dtype do numpy.ndarray resultante. Por exemplo, considere datas e horas com fusos
horários. NumPy não possui um dtype para representar datas com reconhecimento de fuso horário, portanto, há duas
representações possivelmente úteis:
1. Um object-dtype numpy.ndarray com objetos Timestamp , cada um com o tz correto
2. Um datetime64[ns] -dtype numpy.ndarray, onde os valores foram convertidos para UTC e o fuso horário
descartado
Os fusos horários podem ser preservados com dtype=object
Em [14]: ser = pd.Series(pd.date_range("2000", períodos=2, tz="CET"))
Em [15]: ser.to_numpy(dtype=objeto)
Saída[15]:
array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'), Timestamp('2000-01-02
00:00:00+0100', tz ='CET')], dtype=objeto)
Ou jogado fora com dtype='datetime64[ns]'
Em [16]: ser.to_numpy(dtype="datetime64[ns]")
Saída[16]:
array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00.000000000'], dtype='datetime64[ns]')
Obter os “dados brutos” dentro de um DataFrame é possivelmente um pouco mais complexo. Quando o seu DataFrame tiver apenas
um único tipo de dados para todas as colunas, DataFrame.to_numpy() retornará os dados subjacentes:

Em [17]: df.to_numpy()
Fora[17]:
matriz([[-0,1732, 0,1192, -1,0442],
[-0,8618, -2,1046, -0,4949],
[1,0718, 0,7216, -0,7068],
[-1,0396, 0,2719, -0,425],
[0,567, 0,2762, -1,0874],
[-0,6737, 0,1136, -1,4784],
[0,525, 0,4047, 0,577],
[-1,715, -1,0393, -0,3706]])
Se um DataFrame contém dados de tipo homogêneo, o ndarray pode realmente ser modificado no local e as alterações
será refletido na estrutura de dados. Para dados heterogêneos (por exemplo, algumas colunas do DataFrame não são todas
mesmo dtype), este não será o caso. O próprio atributo de valores, ao contrário dos rótulos dos eixos, não pode ser atribuído.
Nota: Ao trabalhar com dados heterogêneos, o dtype do ndarray resultante será escolhido para acomodar todos
dos dados envolvidos. Por exemplo, se strings estiverem envolvidas, o resultado será do tipo de objeto. Se houver apenas carros alegóricos e
inteiros, a matriz resultante será do tipo float.
No passado, os pandas recomendavam Series.values ou DataFrame.values para extrair os dados de uma série ou
Quadro de dados. Você ainda encontrará referências a eles em bases de código antigas e online. No futuro, recomendamos evitar
.values e usando .array ou .to_numpy(). .values tem as seguintes desvantagens:
1. Quando sua série contém um tipo de extensão, não está claro se Series.values retorna uma matriz NumPy ou o
matriz de extensão. Series.array sempre retornará um ExtensionArray e nunca copiará dados. Series.
to_numpy() sempre retornará um array NumPy, potencialmente ao custo de copiar/coagir valores.
2. Quando o seu DataFrame contém uma mistura de tipos de dados, DataFrame.values pode envolver a cópia de dados e
forçar valores para um tipo comum, uma operação relativamente cara. DataFrame.to_numpy(), sendo um método,
deixa mais claro que o array NumPy retornado pode não ser uma visualização dos mesmos dados no DataFrame.
2.3.3 Operações aceleradas
pandas tem suporte para acelerar certos tipos de operações binárias numéricas e booleanas usando a biblioteca numexpr
e as bibliotecas gargalo.
Essas bibliotecas são especialmente úteis ao lidar com grandes conjuntos de dados e fornecem grandes acelerações. numexpr usa
chunking inteligente, cache e múltiplos núcleos. gargalo é um conjunto de rotinas Cython especializadas que são especialmente
rápido ao lidar com arrays que possuem nans.
Aqui está um exemplo (usando DataFrames de 100 colunas x 100.000 linhas):
Operação 0,11,0 (ms) Versão Anterior (ms) Proporção para Anterior
df1 > df2 df1 13,32 125,35 0,1063

* df2 df1 + df2 21,71 36,63 0,5928
22.04 36,50 0,6039
Você é altamente encorajado a instalar ambas as bibliotecas. Consulte a seção Dependências Recomendadas para mais instalações
informações.
Ambos estão habilitados para uso por padrão, você pode controlar isso definindo as opções:

pd.set_option("compute.use_bottleneck", Falso)
pd.set_option("compute.use_numexpr", Falso)
2.3.4 Operações binárias flexíveis
Com operações binárias entre estruturas de dados pandas, existem dois pontos principais de interesse:
• Comportamento de transmissão entre objetos de dimensões superiores (por exemplo, DataFrame) e de dimensões inferiores (por exemplo, Séries).
• Dados faltantes nos cálculos.
Demonstraremos como gerenciar essas questões de forma independente, embora elas possam ser tratadas simultaneamente.
Comportamento de correspondência/transmissão
DataFrame possui os métodos add(), sub(), mul(), div() e funções relacionadas radd(), rsub(), . . . para realizar
operações binárias. Para o comportamento de transmissão, a entrada em série é de interesse primário. Usando essas funções, você pode usar para
corresponda ao índice ou às colunas por meio da palavra-chave axis :
....: {
....: "um": pd.Series(np.random.randn(3), índice=["a", "b", "c"]),
....: "dois": pd.Series(np.random.randn(4), index=["a", "b", "c", "d"]),
....: "três": pd.Series(np.random.randn(3), index=["b", "c", "d"]),
....: }
....: )
....:
Em [19]: df
Fora[19]:
um dois três
a 1,394981 1,772517 NaN
b 0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435
d NaN 0,279344 -0,613172
Em [20]: linha = df.iloc[1]
Em [21]: coluna = df["dois"]
Em [22]: df.sub(linha, eixo="colunas")

Fora[22]:
um dois três
a 1,051928 -0,139606 NaN
b 0,000000 0,000000 0,000000
c 0,352192 -0,433754 1,277825
dNaN -1,632779 -0,562782
Em [23]: df.sub(linha, eixo=1)

Fora[23]:
um dois três
a 1,051928 -0,139606 NaN

b 0,000000 0,000000 0,000000

c 0,352192 -0,433754 1,277825
d NaN -1,632779 -0,562782
Em [24]: df.sub(coluna, eixo="índice")

Fora[24]:
um dois três
a -0,377535 0,0 NaN
b -1,569069 0,0 -1,962513
c -0,783123 0,0 -0,250933
d NaN 0,0 -0,892516
Em [25]: df.sub(coluna, eixo=0)

Fora[25]:
um dois três
a -0,377535 0,0 NaN
b -1,569069 0,0 -1,962513
c -0,783123 0,0 -0,250933
dNaN 0,0 -0,892516
Além disso, você pode alinhar um nível de um DataFrame MultiIndexado com uma Série.
Em [26]: dfmi = df.copy()
Em [27]: dfmi.index = pd.MultiIndex.from_tuples(

....: [(1, "a"), (1, "b"), (1, "c"), (2, "a")], nomes=["primeiro", "segundo"]
....: )
....:
Em [28]: dfmi.sub(coluna, eixo=0, nível="segundo")

Fora[28]:
um dois três
primeiro segundo
1 a -0,377535 0,000000NaN
b -1,569069 0,000000 -1,962513
c -0,783123 0,000000 -0,250933
2 a NaN -1,493173 -2,385688
Séries e índices também suportam o divmod() integrado. Esta função assume a divisão do piso e a operação do módulo no
ao mesmo tempo, retornando duas tuplas do mesmo tipo que o lado esquerdo. Por exemplo:
Em [29]: s = pd.Series(np.arange(10))
Em [30]: s
Fora[30]:
0 0
1 1
2 2
3 3
4 4
5
56 6

7 7
8 8
9 9
tipo d: int64
Em [31]: div, rem = divmod(s, 3)
Em [32]: div
Fora[32]:
0 0
1 0
2 0
3 1
4 1
51
62
72
82
93
tipo d: int64
Em [33]: rem
Fora[33]:
00
1 1
2 2
3 0
4 1
5 2
6 0
7 1
8 2
9 0
tipo d: int64
Em [34]: idx = pd.Index(np.arange(10))
Em [35]: idx
Fora[35]: Int64Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype='int64')
Em [36]: div, rem = divmod(idx, 3)
Em [37]: div
Em [38]: rem
Também podemos fazer divmod() elemento a elemento:
Em [39]: div, rem = divmod(s, [2, 2, 3, 3, 4, 4, 5, 5, 6, 6])

Em [40]: div
Fora[40]:
00
1 0
2 0
3 1
4 1
5 1
6 1
7 1
81
91
tipo d: int64
Em [41]: rem
Fora[41]:
00
11
22
30
4 0
1
56 1
7 2
8 2
9 3
tipo d: int64
Dados/operações ausentes com valores de preenchimento
Em Series e DataFrame, as funções aritméticas têm a opção de inserir um fill_value, ou seja, um valor para substituir
quando no máximo um dos valores em um local está faltando. Por exemplo, ao adicionar dois objetos DataFrame, você pode
deseja tratar NaN como 0, a menos que ambos os DataFrames estejam faltando esse valor, caso em que o resultado será NaN (você pode
mais tarde substitua NaN por algum outro valor usando fillna se desejar).
Em [42]: df
Fora[42]:
um dois três
a 1,394981 1,772517 b 0,343054 NaN
1,912123 -0,050390
c 0,695246 1,478369 1,227435
dNaN 0,279344 -0,613172
Em [43]: df2
Fora[43]:
um dois três
um 1,394981 1,772517 1,000000
b 0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435
d NaN 0,279344 -0,613172

Em [44]: df + df2
Fora[44]:
um dois três
um 2,789963 3,545034 NaN
b 0,686107 3,824246 -0,100780
c 1,390491 2,956737 2,454870
d NaN 0,558688 -1,226343
Em [45]: df.add(df2, fill_value=0)

Fora[45]:
um dois três
um 2,789963 3,545034 1,000000
b 0,686107 3,824246 -0,100780
c 1,390491 2,956737 2,454870
dNaN 0,558688 -1,226343
Comparações flexíveis
Series e DataFrame possuem os métodos de comparação binária eq, ne, lt, gt, le e ge cujo comportamento é análogo a
as operações aritméticas binárias descritas acima:
Em [46]: df.gt(df2)
Fora[46]:
um dois três
um falso falso falso
b Falso Falso Falso
c Falso Falso Falso
d Falso Falso Falso
Em [47]: df2.ne(df)
Fora[47]:
um dois três
um falso falso verdadeiro
b Falso Falso Falso
c Falso Falso Falso
d Verdadeiro Falso Falso
Essas operações produzem um objeto pandas do mesmo tipo que a entrada do lado esquerdo que é do tipo dtype bool. Esses
objetos booleanos podem ser usados em operações de indexação, consulte a seção sobre indexação booleana.
Reduções booleanas
Você pode aplicar as reduções: vazio, any(), all() e bool() para fornecer uma maneira de resumir um resultado booleano.
Em [48]: (df > 0).all()

Fora[48]:
um Falso
dois Verdadeiro
três Falso
dtype: bool

Em [49]: (df > 0).any()

Fora[49]:
um Verdadeiro
dois Verdadeiro
três Verdadeiro
dtype: bool
Você pode reduzir para um valor booleano final.
Em [50]: (df > 0).any().any()

Você pode testar se um objeto pandas está vazio, através da propriedade vazia .
In [51]: df.empty Out[51]:

Falso
Em [52]: pd.DataFrame(columns=list("ABC")).empty Out[52]: Verdadeiro
Para avaliar objetos pandas de elemento único em um contexto booleano, use o método bool():
Em [53]: pd.Series([True]).bool()
Em [54]: pd.Series([False]).bool()
Fora[54]: Falso
Em [55]: pd.DataFrame([[True]]).bool()
Em [56]: pd.DataFrame([[False]]).bool()
Fora[56]: Falso
Aviso: você pode ficar tentado a fazer o seguinte:
>>> se df:
... passar
Ou
>>> df e df2
Ambos gerarão erros, pois você está tentando comparar vários valores.:
ValueError: O valor verdade de uma matriz é ambíguo. Use a.empty, a.any() ou a.all().
Veja pegadinhas para uma discussão mais detalhada.

Comparando se os objetos são equivalentes
Muitas vezes você pode descobrir que há mais de uma maneira de calcular o mesmo resultado. Como um exemplo simples, considere df
+ df e df * 2. Para testar se esses dois cálculos produzem o mesmo resultado, dadas as ferramentas mostradas acima, você pode imaginar
usar (df + df == df * 2).all(). Mas, na verdade, esta expressão é falsa:
Em [57]: df + df == df * 2
Fora[57]:
um dois três
um Verdadeiro Verdadeiro Falso
b Verdadeiro Verdadeiro Verdadeiro
c Verdadeiro Verdadeiro Verdadeiro
d Falso Verdadeiro Verdadeiro
Em [58]: (df + df == df * 2).all()

Fora[58]:
um Falso
dois Verdadeiro
três Falso
dtype: bool
Observe que o DataFrame booleano df + df == df * 2 contém alguns valores False! Isso ocorre porque os NaNs não são comparados como
iguais:
In [59]: np.nan == np.nan Out[59]:

Falso
Portanto, NDFrames (como Series e DataFrames) possuem um método equals() para testar a igualdade, com NaNs em locais
correspondentes tratados como iguais.
Em [60]: (df + df).equals(df * 2)

Observe que o índice Series ou DataFrame precisa estar na mesma ordem para que a igualdade seja True:
Em [61]: df1 = pd.DataFrame({"col": ["foo", 0, np.nan]})
Em [62]: df2 = pd.DataFrame({"col": [np.nan, 0, "foo"]}, index=[2, 1, 0])
Em [63]: df1.equals(df2)
Fora[63]: Falso
Em [64]: df1.equals(df2.sort_index())

Comparando objetos semelhantes a array
Você pode realizar comparações elemento a elemento de maneira conveniente ao comparar uma estrutura de dados do pandas com um valor escalar:
Em [65]: pd.Series(["foo", "bar", "baz"]) == "foo"

Fora[65]:
0 Verdadeiro
1 Falso
2 Falso
tipo d: bool
Em [66]: pd.Index(["foo", "bar", "baz"]) == "foo"

Out[66]: array([Verdadeiro, Falso, Falso])
O pandas também lida com comparações elemento a elemento entre diferentes objetos semelhantes a arrays do mesmo comprimento:
Em [67]: pd.Series(["foo", "bar", "baz"]) == pd.Index(["foo", "bar", "qux"])

Fora[67]:
Verdadeiro
Verdadeiro
Falso
0 1 2 dtype: bool
Em [68]: pd.Series(["foo", "bar", "baz"]) == np.array(["foo", "bar", "qux"])

Fora[68]:
0 Verdadeiro
1 Verdadeiro
2 Falso
tipo d: bool
Tentar comparar objetos Index ou Series de comprimentos diferentes gerará um ValueError:
Em [55]: pd.Series(['foo', 'bar', 'baz']) == pd.Series(['foo', 'bar'])

ValueError: os comprimentos das séries devem corresponder para comparação
Em [56]: pd.Series(['foo', 'bar', 'baz']) == pd.Series(['foo'])

ValueError: os comprimentos das séries devem corresponder para comparação
Observe que isso é diferente do comportamento do NumPy, onde uma comparação pode ser transmitida:
Em [69]: np.array([1, 2, 3]) == np.array([2])

Out[69]: array([Falso, Verdadeiro, Falso])
ou pode retornar False se a transmissão não puder ser feita:
Em [70]: np.array([1, 2, 3]) == np.array([1, 2])

Fora[70]: Falso

Combinando conjuntos de dados sobrepostos
Um problema que surge ocasionalmente é a combinação de dois conjuntos de dados semelhantes, onde os valores de um são
preferidos em relação ao outro. Um exemplo seriam duas séries de dados que representam um indicador económico específico,
sendo uma delas considerada de “qualidade superior”. No entanto, as séries de qualidade inferior podem ser mais antigas na história
ou ter uma cobertura de dados mais completa. Como tal, gostaríamos de combinar dois objetos DataFrame onde os valores ausentes
em um DataFrame são preenchidos condicionalmente com valores com rótulos semelhantes do outro DataFrame. A função que
implementa esta operação é combine_first(), que ilustramos:
Em [71]: df1 = pd.DataFrame( {"A": [1.0,

....: np.nan, 3.0, 5.0, np.nan], "B": [np.nan, 2.0, 3.0, np.nan, 6.0 ]}
....: )
....:
Em [72]: df2 = pd.DataFrame( {

....:
....: "A": [5,0, 2,0, 4,0, np.nan, 3,0, 7,0], "B": [np.nan, np.nan,
....: 3,0, 4,0, 6,0, 8,0],
....: }
....: )
....:
Entrada [73]: df1

Saída [73]:
AB 0 1,0
NaN 1 NaN 2,0
2 3,0 3,0 3 5,0
NaN 4 NaN 6,0
Em [74]: df2
Fora[74]:
A B
0 5,0 NaN
1 2,0 NaN
2 4,0 3,0
3NaN 4,0
4 3,0 6,0
5 7,0 8,0
Em [75]: df1.combine_first(df2)
Fora[75]:
A B
0 1,0 NaN 1 2,0
2,0 2 3,0 3,0 3
5,0 4,0 4 3,0 6,0
5 7,0 8,0

Combinação geral de DataFrame
O método combine_first() acima chama o DataFrame.combine() mais geral . Este método leva outro
DataFrame e uma função combinadora, alinha o DataFrame de entrada e, em seguida, passa os pares de funções combinadoras da Série
(ou seja, colunas cujos nomes são iguais).
Então, por exemplo, para reproduzir combine_first() como acima:
Em [76]: def combinador(x, y):

....: retorne np.where(pd.isna(x), y, x)
....:
Em [77]: df1.combine(df2, combinador)

Fora[77]:
A B
0 1,0 NaN
1 2,0 2,0
2 3,0 3,0
3 5,0 4,0
4 3,0 6,0
5 7,0 8,0
2.3.5 Estatísticas descritivas
Existe um grande número de métodos para calcular estatísticas descritivas e outras operações relacionadas em séries,
Quadro de dados. A maioria delas são agregações (produzindo, portanto, um resultado de dimensão inferior) como sum(), média() e
quantile(), mas alguns deles, como cumsum() e cumprod(), produzem um objeto do mesmo tamanho. De modo geral, esses
métodos aceitam um argumento de eixo , assim como ndarray.{sum, std, . . . }, mas o eixo pode ser especificado por nome ou
inteiro:
• Série: nenhum argumento de eixo é necessário
• DataFrame: “índice” (eixo=0, padrão), “colunas” (eixo=1)
Por exemplo:
Em [78]: df
Fora[78]:
um dois três
um 1,394981 1,772517 NaN
b 0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435
d NaN 0,279344 -0,613172
Em [79]: df.mean(0)
Fora[79]:
um 0,811094
dois 1.360588
três 0,187958
dtype: float64
Em [80]: df.mean(1)
Fora[80]:
a 1.583749

b 0,734929
c 1.133683
d-0,166914
tipo d: float64
Todos esses métodos têm uma opção skipna sinalizando se os dados ausentes devem ser excluídos (True por padrão):
Em [81]: df.sum(0, skipna=False)

Fora[81]:
um NaN
dois 5.442353
três NaN
tipo d: float64
Em [82]: df.sum(axis=1, skipna=True)

Fora[82]:
a 3.167498
b 2.204786
c 3.401050
d-0,333828
tipo d: float64
Combinado com o comportamento de transmissão / aritmética, pode-se descrever vários procedimentos estatísticos, como a
padronização (renderizando os dados com média zero e desvio padrão de 1), de forma muito concisa:
Em [83]: ts_stand = (df - df.mean()) / df.std()
Em [84]: ts_stand.std()
Fora[84]:
um 1,0
dois 1,0
três 1,0
tipo d: float64
Em [85]: xs_stand = df.sub(df.mean(1), axis=0).div(df.std(1), axis=0)
Em [86]: xs_stand.std(1)
Fora[86]:
a 1,0
b 1,0
c 1,0
1,0
d tipo: float64
Observe que métodos como cumsum() e cumprod() preservam a localização dos valores NaN. Isso é um pouco diferente
de expandindo() e rolando() uma vez que o comportamento NaN é, além disso, ditado por um parâmetro min_periods.
Em [87]: df.cumsum()
Fora[87]:
um dois três
a 1,394981 1,772517 NaN
b 1,738035 3,684640 -0,050390


c 2,433281 5,163008 1,177045
d NaN 5,442353 0,563873
Aqui está uma tabela de resumo de referência rápida de funções comuns. Cada um também recebe um parâmetro de nível opcional que
aplica-se somente se o objeto tiver um índice hierárquico.
Função Descrição
contar Número de observações não-NA
soma Soma dos valores
significar Média de valores
louco Desvio médio absoluto
mediana Mediana aritmética de valores
min Mínimo
máx. Máximo
modo Modo
Valor absoluto
Produto de valores
abdômen prod std Desvio padrão da amostra corrigido por Bessel
var Variância imparcial
sem Erro padrão da média
Assimetria da amostra (3º momento)
Amostra de curtose (4º momento)
distorcer o quantil de Kurt Quantil da amostra (valor em %)
cumsum Soma cumulativa
produto cumulado Produto cumulativo
gozada Máximo cumulativo
cominho Mínimo cumulativo
Observe que, por acaso, alguns métodos NumPy, como média, padrão e soma, excluirão NAs na entrada da série por padrão:
Em [88]: np.mean(df["um"])
Fora[88]: 0,8110935116651192
Em [89]: np.mean(df["one"].to_numpy())
Fora[89]: nan
Series.nunique() retornará o número de valores exclusivos não-NA em uma série:
Em [90]: série = pd.Series(np.random.randn(500))
Em [91]: série[20:500] = np.nan
Em [92]: série[10:20] = 5
Em [93]: series.nunique()
Fora[93]: 11

Resumindo dados: descrever
Existe uma função descreva() conveniente que calcula uma variedade de estatísticas resumidas sobre uma série ou o
colunas de um DataFrame (excluindo NAs, é claro):
Em [94]: série = pd.Series(np.random.randn(1000))
Em [95]: série[::2] = np.nan
Em [96]: series.describe()
Fora[96]:
contar 500.000000
significar -0,021292
padrão 1.015906
mínimo -2,683763
25% -0,699070
50% -0,069718
75% 0,714483
máx. 3.160915
tipo d: float64
Em [97]: frame = pd.DataFrame(np.random.randn(1000, 5), columns=["a", "b", "c", "d", "e

ÿÿ"])
Em [98]: frame.iloc[::2] = np.nan
Em [99]: frame.describe()
Fora[99]:
a b c d e
contar 500,000000 500,000000 500,000000 500,000000 500,000000
significar 0,033387 0,030045 -0,043719 -0,051686 0,005979
padrão 1.017152 0,978743 1,025270 1.015988 1,006695
min -3,000951 -2,637901 -3,303099 -3,159200 -3,188821
25% -0,647623 -0,576449 -0,712369 -0,691338 -0,691115
50% 0,047578 -0,021499 -0,023888 -0,032652 -0,025363
75% 0,729907 0,775880 0,618896 0,670047 0,649748
máx. 2.740139 2.752332 3.004229 2.728702 3.240991
Você pode selecionar percentis específicos para incluir na saída:
Em [100]: series.describe(percentis=[0,05, 0,25, 0,75, 0,95])

Fora[100]:
contar 500.000000
significar -0,021292
padrão 1.015906
mínimo -2,683763
5% -1,645423
25% -0,699070
50% -0,069718
75% 0,714483
95% 1.711409
máx. 3.160915
tipo d: float64

Por padrão, a mediana é sempre incluída.
Para um objeto Series não numérico, scribe() fornecerá um resumo simples do número de valores únicos e da maioria
valores que ocorrem com frequência:
Em [101]: s = pd.Series(["a", "a", "b", "b", "a", "a", np.nan, "c", "d", "a "])
Em [102]: s.describe()
Fora[102]:
contar 9
tipo de 4
a
5
frequência superior exclusivo: objeto
Observe que em um objeto DataFrame de tipo misto, scribe() restringirá o resumo para incluir apenas colunas numéricas
ou, se não houver, apenas colunas categóricas:
Em [103]: frame = pd.DataFrame({"a": ["Sim", "Sim", "Não", "Não"], "b": range(4)})
Em [104]: frame.describe()
Fora[104]:
b
conte 4.000000
significa 1,500000
1.290994
padrão 0,000000
0,750000
1,500000
2,250000
mínimo 25% 50% 75%
máx. 3.000.000
Esse comportamento pode ser controlado fornecendo uma lista de tipos como argumentos de inclusão/exclusão. O valor especial todo
também pode ser usado:
Em [105]: frame.describe(include=["objeto"])
Fora[105]:
a
contar 4
frequência 2
Sim
superior única 2
Em [106]: frame.describe(include=["número"])
Fora[106]:
b
conte 4.000000
significa 1,500000
padrão 1.290994
mínimo 0,000000
25% 0,750000
50% 1,500000
75% 2,250000
máx. 3.000.000

Em [107]: frame.describe(include="all")
Fora[107]:
a b
contar 4 4,000000
frequência 2 NaN
Sim NaN
superior única 2 NaN
significar NaN 1,500000
NaN 1,290994
padrão NaN 0,000000
NaN 0,750000
NaN 1,500000
mínimo 25% 50%NaN
75% 2,250000
máx. NaN 3,000000
Esse recurso depende de select_dtypes. Consulte-o para obter detalhes sobre as entradas aceitas.
Índice de valores mínimo/máximo
As funções idxmin() e idxmax() em Series e DataFrame calculam os rótulos de índice com os valores mínimo e
valores máximos correspondentes:
Em [108]: s1 = pd.Series(np.random.randn(5))
Em [109]: s1
Fora[109]:
0 1.118076
1 -0,352051
2-1.242883
3 -1,277155
4 -0,641184
tipo d: float64
Em [110]: s1.idxmin(), s1.idxmax()

Fora[110]: (3, 0)
Em [111]: df1 = pd.DataFrame(np.random.randn(5, 3), colunas=["A", "B", "C"])
Em [112]: df1
Fora[112]:
A B C
0 -0,327863 -0,946180 -0,137570
1 -0,186235 -0,257213 -0,486567
2 -0,507027 -0,871259 -0,111110
3 2,000339 -2,430505 0,089759
4 -0,321434 -0,033695 0,096271
Em [113]: df1.idxmin(eixo=0)
Fora[113]:
A 2

B 3
C 1
tipo d: int64
Em [114]: df1.idxmax(eixo=1)
Fora[114]:
0 C
1 A
2 C
3 A
4 C
dtype: objeto
Quando há múltiplas linhas (ou colunas) correspondentes ao valor mínimo ou máximo, idxmin() e idxmax() retornam o primeiro índice
correspondente:
Em [115]: df3 = pd.DataFrame([2, 1, 1, 3, np.nan], colunas=["A"], índice=lista("edcba"))
Em [116]: df3
Fora[116]:
A
e 2,0 d
1,0
c 1,0
b 3,0
um NaN
Em [117]: df3["A"].idxmin()
Fora[117]: 'd'
Nota: idxmin e idxmax são chamados de argmin e argmax em NumPy.
Contagens de valores (histograma) / modo
O método da série value_counts() e a função de nível superior calculam um histograma de uma matriz 1D de valores. Também pode ser
usado como uma função em arrays regulares:
Em [118]: dados = np.random.randint(0, 7, tamanho=50)
Em [119]: dados
Fora[119]:
matriz([6, 6, 2, 3, 5, 3, 2, 5, 4, 5, 4, 3, 4, 5, 0, 2, 0, 4, 2, 0, 3, 2, 2, 5, 6, 5, 3, 4, 6, 4, 3, 5, 6, 4, 3, 6, 2, 6, 6, 2,
3, 4, 2, 1, 6, 2, 6, 1, 5, 4])
Em [120]: s = pd.Series(dados)
Em [121]: s.value_counts()
Fora[121]: 6
10

2 10
4 9
3 8
5 8
0 3
1 2
tipo d: int64
Em [122]: pd.value_counts(dados)
Fora[122]:
6 10
2 10
4 9
38
58
03
12
tipo d: int64
O método value_counts() pode ser usado para contar combinações em múltiplas colunas. Por padrão, todas as colunas
são usados, mas um subconjunto pode ser selecionado usando o argumento subset.
Em [123]: dados = {"a": [1, 2, 3, 4], "b": ["x", "x", "y", "y"]}
Em [124]: quadro = pd.DataFrame(dados)
Em [125]: frame.value_counts()
Fora[125]:
ab
1x 1
2x 1
3 1
anos 1
4 anos dtype: int64
Da mesma forma, você pode obter os valores que ocorrem com mais frequência, ou seja, a moda, dos valores em uma série ou DataFrame:
Em [126]: s5 = pd.Series([1, 1, 3, 3, 3, 5, 5, 7, 7, 7])
Em [127]: s5.mode()
Fora[127]:
03
17
tipo d: int64

.....: {
.....: "A": np.random.randint(0, 7, tamanho=50),
.....: "B": np.random.randint(-10, 15, tamanho=50),
.....: }
..... :)

.....:
Em [129]: df5.mode()
Fora[129]:
AB
0 1,0 -9
1 NaN 10
2 NaN 13
Discretização e quantização
Valores contínuos podem ser discretizados usando as funções cut() (compartimentos baseados em valores) e qcut() (compartimentos baseados
em quantis de amostra):
Em [130]: arr = np.random.randn(20)
Em [131]: fator = pd.cut(arr, 4)
Em [132]: fator Out[132]:

[(-0,251,
0,464], (-0,968, -0,251], (0,464, 1,179], (-0,251, 0,464], (-0,968, -0,251], .. ÿÿ., (-0,251, 0,464], (-0,968, -0,251], (-0,968, -0,251], (-0,968,
-0,251], (-0,968, -0. ÿÿ251] ]
Comprimento:
20 categorias (4, intervalo [float64, direita]): [(-0,968, -0,251] < (-0,251, 0,464] < (0,464,ÿ ÿÿ1,179 ] <
(1.179, 1.893]]
Em [133]: fator = pd.cut(arr, [-5, -1, 0, 1, 5])
In [134]: fator Out[134]:

[(0, 1], (-1,
0], (0, 1], (0, 1), (-1, 0], ..., (- 1, 0], (-1, 0], (-1, 0], (-1, 0], (-1,ÿ ÿÿ0]]
Comprimento:
20 categorias (4, intervalo [int64, direita]): [(-5, -1] < (-1, 0] < (0, 1] < (1, 5]]
qcut() calcula quantis de amostra. Por exemplo, poderíamos dividir alguns dados normalmente distribuídos em quartis de
tamanhos iguais, assim:
Em [136]: fator = pd.qcut(arr, [0, 0,25, 0,5, 0,75, 1])
Em [137]: fator Out[137]:

[(0,569,
1,184], (-2,278, -0,301], (-2,278, -0,301], (0,569, 1,184], (0,569, 1,184], ..., ÿÿ (-0,301, 0,569], (1,184, 2,346], (1,184, 2,346], (-0,301,
0,569], (-2,278, -0,301]]
Comprimento:
30 categorias (4, intervalo [float64, direita]): [(-2,278, -0,301] < (-0,301, 0,569] < (0,569,ÿ ÿÿ 1,184] <

(1.184, 2.346]]
Em [138]: pd.value_counts(fator)
Fora [138]:
(-2,278, -0,301] 8
(1,184, 2,346] 8
(-0,301, 0,569] 7
(0,569, 1,184] 7
dtype: int64
Também podemos passar valores infinitos para definir os compartimentos:
Em [140]: fator = pd.cut(arr, [-np.inf, 0, np.inf])
In [141]: fator Out[141]:

[(-inf, 0,0],
(0,0, inf], (0,0, inf], (-inf, 0,0], (-inf, 0,0], ..., ( -inf, 0,0], (-inf,ÿ ÿÿ0,0], (-inf, 0,0], (0,0, inf], (0,0, inf]]
Comprimento:
20 categorias (2, intervalo [float64, direita]): [(-inf, 0,0] < (0,0, inf]]
2.3.6 Aplicação da função
Para aplicar funções próprias ou de outra biblioteca a objetos pandas, você deve estar ciente dos três métodos
abaixo. O método apropriado a ser usado depende se sua função espera operar em um DataFrame ou Série inteiro,
em linhas ou colunas, ou em elementos.
1. Aplicação da função tablewise: pipe()
2. Aplicação de função em linha ou coluna: apply()
3. API de agregação: agg() e transform()
4. Aplicando funções elementares: applymap()
Aplicação de função tablewise
DataFrames e Series podem ser passados para funções. No entanto, se a função precisar ser chamada em cadeia,
considere usar o método pipe() .
Primeiro algumas configurações:
Em [142]: def extract_city_name(df):

"""
.....:
.....: Chicago, IL -> Chicago para coluna city_name
"""
.....:
.....: df["nome_cidade"] = df["cidade_e_código"].str.split(",").str.get(0) retornar df
.....:
.....:
Em [143]: def add_country_name(df, country_name=None):



"""
.....:
.....: Chicago -> Chicago-EUA para coluna city_name
"""
.....:
.....: col = "nome_cidade"
.....: df["cidade_e_país"] = df[col] + nome_país
.....: retornar df
.....:
Em [144]: df_p = pd.DataFrame({"city_and_code": ["Chicago, IL"]})
extract_city_name e add_country_name são funções que pegam e retornam DataFrames.

Agora compare o seguinte:
Em [145]: add_country_name(extract_city_name(df_p), country_name="US")

Fora[145]:
cidade_e_código cidade_nome cidade_e_país
0 Chicago, IL Chicago ChicagoEUA
É equivalente a:
Em [146]: df_p.pipe(extract_city_name).pipe(add_country_name, country_name="US")

Fora[146]:
cidade_e_código cidade_nome cidade_e_país
0 Chicago, IL Chicago ChicagoEUA
pandas incentiva o segundo estilo, conhecido como encadeamento de métodos. tubo facilita o uso do seu próprio ou de outro
funções da biblioteca em cadeias de métodos, juntamente com os métodos do pandas.
No exemplo acima, as funções extract_city_name e add_country_name esperavam, cada uma, um DataFrame como
o primeiro argumento posicional. E se a função que você deseja aplicar considerar seus dados como, digamos, o segundo argumento? Nisso
caso, forneça ao pipe uma tupla de (callable, data_keyword). .pipe irá encaminhar o DataFrame para o argumento
especificado na tupla.
Por exemplo, podemos ajustar uma regressão usando modelos estatísticos. A API deles espera primeiro uma fórmula e um DataFrame como
segundo argumento, dados. Passamos a função, par de palavras-chave (sm.ols, 'data') para canalizar:
Em [147]: importar statsmodels.formula.api como sm
Em [148]: bb = pd.read_csv("data/baseball.csv", index_col="id")
Em [149]: (
.....: bb.query("h > 0")
.....: .assign(ln_h=lambda df: np.log(df.h))
.....: .pipe((sm.ols, "dados"), "hr ~ ln_h + ano + g + C(lg)")
.....: .ajustar()
.....: .resumo()
..... :)
.....:
Fora[149]:
<class 'statsmodels.iolib.summary.Summary'>
"""
Resultados da regressão OLS

================================================= ============================

Dep. Variável: Modelo: hr R-quadrado: OLS 0,685

Adj. R ao quadrado: Estatística F 0,665
Método: de mínimos quadrados: Quarta, 31 de agosto 34,28
Data: de 2022 Prob (estatística F): 09:57:41 Log-Probabilidade: 68 3.48e-15
Tempo: AIC: -205,92
Não. Observações: 421,8
Resíduos Df: Modelo 63 BIC: 432,9
Df: Tipo de 4
covariância: não robusto
================================================= =============================
coef std err t P>|t| [0,025 0,975]

-------------------------------------------------- -----------------------------
Interceptar -8484,7720 4664,146 C (lg) [T.NL] -2,2736 -1,819 0,074 -1,78e+04 0,091 835.780
1,325 ln_h -1,3542 0,875 4,2277 2,324 0,1841 0,029 -1,716 -4,922 0,127 -3,103 0,074 0,375
-1,547 -0,417 0,000 0,125 0,395
ano 1,819 8.872
g 6,258 0,243
================================================= ============================
Ônibus: 10.875 Durbin-Watson: 1.999

Problema (ônibus): 0,004 Jarque-Bera (JB): 0,537 Prob(JB): 17.298
Inclinação: 5,225 Cond. Não. 0,000175
Curtose: 1.49e+07
================================================= ============================
Notas:
[1] Erros padrão assumem que a matriz de covariância dos erros está corretaÿ
ÿÿespecificado.
[2] O número da condição é grande, 1,49e+07. Isto pode indicar que existem
forte multicolinearidade ou outros problemas numéricos.
"""
O método pipe é inspirado em pipes unix e mais recentemente em dplyr e magrittr, que introduziram o popular
Operador (%>%) (read pipe) para R. A implementação de pipe aqui é bastante limpa e se sente em casa no Python.
Nós encorajamos você a visualizar o código fonte de pipe().
Aplicação de função em linha ou coluna
Funções arbitrárias podem ser aplicadas ao longo dos eixos de um DataFrame usando o método apply() , que, como o descritivo
métodos estatísticos, recebe um argumento de eixo opcional:
Em [150]: df.apply(np.mean)
Fora[150]:
um 0,811094
dois 1.360588
três 0,187958
dtype: float64
Em [151]: df.apply(np.mean, eixo=1)

Fora[151]:
a 1.583749
b 0,734929


c 1.133683
d-0,166914
tipo d: float64
Em [152]: df.apply(lambda x: x.max() - x.min())

Fora[152]:
um 1.051928
dois 1.632779
três 1.840607
dtype: float64
Em [153]: df.apply(np.cumsum)
Fora[153]:
um dois três
a 1,394981 1,772517 b 1,738035 NaN
3,684640 -0,050390
c 2,433281 5,163008 1,177045
dNaN 5,442353 0,563873
Em [154]: df.apply(np.exp)
Fora[154]:
um dois três
um 4,034899 5,885648 NaN
b 1,409244 6,767440 0,950858
c 2,004201 4,385785 3,412466
d NaN 1,322262 0,541630
O método apply() também será despachado em um nome de método string.
Em [155]: df.apply("mean")
Fora[155]:
um 0,811094
dois 1.360588
três 0,187958
dtype: float64
Em [156]: df.apply("média", eixo=1)

Fora[156]:
a 1.583749
b 0,734929
c 1.133683
d-0,166914
tipo d: float64
O tipo de retorno da função passada para apply() afeta o tipo da saída final de DataFrame.apply para o
comportamento padrão:
• Se a função aplicada retornar uma Série, a saída final será um DataFrame. As colunas correspondem ao índice do
Série retornada pela função aplicada.
• Se a função aplicada retornar qualquer outro tipo, a saída final será uma Série.
Este comportamento padrão pode ser substituído usando o result_type, que aceita três opções: reduzir, transmitir,
e expandir. Isso determinará como os valores de retorno de listas se expandem (ou não) para um DataFrame.

apply() combinado com alguma inteligência pode ser usado para responder muitas perguntas sobre um conjunto de dados. Por exemplo, suponha
queríamos extrair a data onde ocorreu o valor máximo para cada coluna:
Em [157]: tsdf = pd.DataFrame(

.....: np.random.randn(1000, 3),
.....: colunas=["A", "B", "C"],
.....: índice=pd.date_range("1/1/2000", períodos=1000),
..... :)
.....:
Em [158]: tsdf.apply(lambda x: x.idxmax())

Fora[158]:
06/08/2000
B 18/01/2001
C 2001-07-18
tipo d: datahora64[ns]
Você também pode passar argumentos adicionais e argumentos de palavras-chave para o método apply() . Por exemplo, considere o
seguinte função que você gostaria de aplicar:
def subtrair_e_dividir(x, sub, dividir=1):

retornar (x - sub) / dividir
Você pode então aplicar esta função da seguinte maneira:
df.apply(subtrair_e_divide, args=(5,), dividir=3)
Outro recurso útil é a capacidade de passar métodos Series para realizar alguma operação Series em cada coluna ou linha:
Em [159]: tsdf
Fora[159]:
A B C
01/01/2000 -0,158131 -0,232466 0,321604
02/01/2000 -1,810340 -3,105758 0,433834
03/01/2000 -1,209847 -1,156793 -0,136794
04-01-2000 NaN NaN NaN
05/01/2000 NaN NaN NaN
08-01-2000 -0,653602 0,178875 1,008298
09/01/2000 1,007996 0,462824 0,254472
10/01/2000 0,307473 0,600337 1,643950
Em [160]: tsdf.apply(pd.Series.interpolate)
Fora[160]:
abc
01/01/2000 -0,158131 -0,232466 0,321604
02/01/2000 -1,810340 -3,105758 0,433834
03/01/2000 -1,209847 -1,156793 -0,136794
04/01/2000 -1,098598 -0,889659 0,092225
05-01-2000 -0,987349 -0,622526 0,321243
06-01-2000 -0,876100 -0,355392 0,550262
07-01-2000 -0,764851 -0,088259 0,779280
08-01-2000 -0,653602 0,178875 1,008298

09/01/2000 1,007996 0,462824 0,254472

10/01/2000 0,307473 0,600337 1,643950
Finalmente, apply() recebe um argumento bruto que é False por padrão, que converte cada linha ou coluna em uma Série
antes de aplicar a função. Quando definido como True, a função passada receberá um objeto ndarray, que possui
implicações positivas no desempenho se você não precisar da funcionalidade de indexação.
API de agregação
A API de agregação permite expressar possivelmente múltiplas operações de agregação de uma forma única e concisa. Esse
A API é semelhante em objetos pandas, consulte API groupby, API de janela e API de resample. O ponto de entrada para
agregação é DataFrame.gregate() ou o alias DataFrame.agg().
Usaremos um quadro inicial semelhante acima:

.....: colunas=["A", "B", "C"],
..... :)
.....:
Em [162]: tsdf.iloc[3:7] = np.nan
Em [163]: tsdf
Fora[163]:
A B C
01/01/2000 1,257606 1,004194 0,167574
02-01-2000 -0,749892 0,288112 -0,757304
03-01-2000 -0,207550 -0,298599 0,116018
08/01/2000 0,814347 -0,257623 0,869226
09-01-2000 -0,250663 -1,206601 0,896839
10/01/2000 2,169758 -1,333363 0,283157
Usar uma única função é equivalente a apply(). Você também pode passar métodos nomeados como strings. Estes retornarão um
Série da produção agregada:
Em [164]: tsdf.agg(np.sum)
Fora[164]:
Um 3.033606
B-1.803879
C1.575510
tipo d: float64
Em [165]: tsdf.agg("soma")
Fora[165]:
A 3.033606
B-1.803879


C 1.575510
tipo d: float64
# estes são equivalentes a .sum() porque estamos agregando

# em uma única função
Em [166]: tsdf.sum()
Fora[166]:
A 3.033606
B-1.803879
C 1.575510
tipo d: float64
Agregações únicas em uma série retornarão um valor escalar:
Em [167]: tsdf["A"].agg("soma")
Fora[167]: 3,033606102414146
Agregando com múltiplas funções
Você pode passar vários argumentos de agregação como uma lista. Os resultados de cada uma das funções passadas serão uma linha no
DataFrame resultante. Eles são naturalmente nomeados a partir da função de agregação.
Em [168]: tsdf.agg(["soma"])
Fora[168]:
A B C
soma 3,033606 -1,803879 1,57551
Várias funções geram várias linhas:
Em [169]: tsdf.agg(["soma", "média"])

Fora[169]:
A B C
soma 3,033606 -1,803879 1,575510
média 0,505601 -0,300647 0,262585
Em uma Série, múltiplas funções retornam uma Série, indexada pelos nomes das funções:
Em [170]: tsdf["A"].agg(["soma", "média"])

Fora[170]:
soma 3.033606
significar 0,505601
Nome: A, tipo d: float64
Passar uma função lambda produzirá uma linha chamada <lambda>:
Em [171]: tsdf["A"].agg(["sum", lambda x: x.mean()])

Fora[171]:
soma 3.033606
<lambda> 0,505601
Passar uma função nomeada produzirá esse nome para a linha:

Em [172]: def minhamédia(x):

.....: retornar x.mean()
.....:
Em [173]: tsdf["A"].agg(["soma", minha média])

Fora[173]:
soma 3.033606
minha média 0,505601
Agregando com um ditado
Passar um dicionário de nomes de colunas para um escalar ou uma lista de escalares para DataFrame.agg permite que você personalize
quais funções são aplicadas a quais colunas. Observe que os resultados não estão em nenhuma ordem específica, você pode usar um
OrderedDict em vez disso, para garantir o pedido.
Em [174]: tsdf.agg({"A": "média", "B": "soma"})

Fora[174]:
A 0,505601
B-1.803879
tipo d: float64
Passar uma lista irá gerar uma saída DataFrame. Você obterá uma saída semelhante a uma matriz de todos os agregadores. O
a saída consistirá em todas as funções exclusivas. Aqueles que não forem anotados para uma coluna específica serão NaN:
Em [175]: tsdf.agg({"A": ["média", "min"], "B": "soma"})

Fora[175]:
A B
média 0,505601 min NaN
-0,749892 NaN NaN
soma -1,803879
Tipos mistos
Obsoleto desde a versão 1.4.0: tentativa de determinar quais colunas não podem ser agregadas e eliminação silenciosa
dos resultados está obsoleto e será removido em uma versão futura. Se alguma parte das colunas ou operações
se falhar, a chamada para .agg aumentará.
Quando apresentados com dtypes mistos que não podem agregar, .agg aceitará apenas as agregações válidas. Isto é semelhante
sobre como .groupby.agg funciona.
Em [176]: mdf = pd.DataFrame(

.....: {
.....: "A": [1, 2, 3],
.....: "B": [1,0, 2,0, 3,0],
.....: "C": ["foo", "bar", "baz"],
.....: "D": pd.date_range("20130101", períodos=3),
.....: }
..... :)
.....:

Em [177]: mdf.dtypes
Fora[177]:
A int64
B float64
C objeto
D datahora64[ns]
dtype: objeto
Em [178]: mdf.agg(["min", "soma"])

Fora[178]:
A B C D
mínimo 1 1,0 barra 01/01/2013
soma 6 6,0 foobarbaz NaT
Descrição personalizada
Com .agg() é possível criar facilmente uma função de descrição personalizada, semelhante à função de descrição integrada.
Em [179]: de functools importa parcial
Em [180]: q_25 = parcial(pd.Series.quantile, q=0,25)
Em [181]: q_25.__name__ = "25%"
Em [182]: q_75 = parcial(pd.Series.quantile, q=0,75)
Em [183]: q_75.__name__ = "75%"
Em [184]: tsdf.agg(["contagem", "média", "padrão", "min", q_25, "mediana", q_75, "máx"])

Fora[184]:
A B C
conte 6,000000 6,000000 6,000000
significar 0,505601 -0,300647 0,262585
padrão 1,103362 0,887508 0,606860
min -0,749892 -1,333363 -0,757304
25% -0,239885 -0,979600 0,128907
mediana 0,303398 -0,278111 0,225365
75% 1,146791 0,151678 0,722709
máx. 2,169758 1,004194 0,896839
API de transformação
O método transform() retorna um objeto que é indexado do mesmo (mesmo tamanho) que o original. Esta API permite que você
para fornecer várias operações ao mesmo tempo, em vez de uma por uma. Sua API é bastante semelhante à API .agg.
Criamos um quadro semelhante ao usado nas seções acima.

.....: colunas=["A", "B", "C"],


..... :)
.....:
Em [186]: tsdf.iloc[3:7] = np.nan
Em [187]: tsdf
Fora[187]:
A B C
01/01/2000 -0,428759 -0,864890 -0,675341
02/01/2000 -0,168731 1,338144 -1,279321
03/01/2000 -1,621034 0,438107 0,903794
08-01-2000 0,254374 -1,240447 -0,201052
09-01-2000 -0,157795 0,791197 -1,144209
10/01/2000 -0,030876 0,371900 0,061932
Transforme todo o quadro. .transform() permite funções de entrada como: uma função NumPy, um nome de função de string ou um
função definida pelo usuário.
Em [188]: tsdf.transform(np.abs)
Fora[188]:
A B C
01-01-2000 0,428759 0,864890 0,675341
02-01-2000 0,168731 1,338144 1,279321
03/01/2000 1,621034 0,438107 0,903794
08-01-2000 0,254374 1,240447 0,201052
09/01/2000 0,157795 0,791197 1,144209
10/01/2000 0,030876 0,371900 0,061932
Em [189]: tsdf.transform("abs")
Fora[189]:
A B C
01-01-2000 0,428759 0,864890 0,675341
02-01-2000 0,168731 1,338144 1,279321
03/01/2000 1,621034 0,438107 0,903794
08-01-2000 0,254374 1,240447 0,201052
09/01/2000 0,157795 0,791197 1,144209
10/01/2000 0,030876 0,371900 0,061932
Em [190]: tsdf.transform(lambda x: x.abs())


Fora[190]:
A B C
01-01-2000 0,428759 0,864890 0,675341
02-01-2000 0,168731 1,338144 1,279321
03/01/2000 1,621034 0,438107 0,903794
08-01-2000 0,254374 1,240447 0,201052
09/01/2000 0,157795 0,791197 1,144209
10/01/2000 0,030876 0,371900 0,061932
Aqui transform() recebeu uma única função; isso é equivalente a um aplicativo ufunc .
Em [191]: np.abs(tsdf)
Fora[191]:
A B C
01-01-2000 0,428759 0,864890 0,675341
02-01-2000 0,168731 1,338144 1,279321
03/01/2000 1,621034 0,438107 0,903794
08-01-2000 0,254374 1,240447 0,201052
09/01/2000 0,157795 0,791197 1,144209
10/01/2000 0,030876 0,371900 0,061932
Passar uma única função para .transform() com uma Série produzirá uma única Série em troca.
Em [192]: tsdf["A"].transform(np.abs)
Fora[192]:
01/01/2000 0,428759
02/01/2000 0,168731
03/01/2000 1.621034
04/01/2000 NaN
05/01/2000 NaN
06/01/2000 NaN
07/01/2000 NaN
08/01/2000 0,254374
09/01/2000 0,157795
10/01/2000 0,030876
Freq: D, Nome: A, tipo d: float64

Transforme com múltiplas funções
Passar múltiplas funções produzirá uma coluna MultiIndexed DataFrame. O primeiro nível será o quadro original
nomes de colunas; o segundo nível serão os nomes das funções transformadoras.
Em [193]: tsdf.transform([np.abs, lambda x: x + 1])

Fora[193]:
A B C
absoluto <lambda> absoluto <lambda> absoluto <lambda>
01-01-2000 0,428759 0,571241 0,864890 0,135110 0,675341 0,324659
02-01-2000 0,168731 0,831269 1,338144 2,338144 1,279321 -0,279321
03/01/2000 1,621034 -0,621034 0,438107 1,438107 0,903794 1,903794
2000-01-04 NaN NaN NaN NaN NaN NaN
08-01-2000 0,254374 1,254374 1,240447 -0,240447 0,201052 0,798948
09-01-2000 0,157795 0,842205 0,791197 1,791197 1,144209 -0,144209
10/01/2000 0,030876 0,969124 0,371900 1,371900 0,061932 1,061932
Passar múltiplas funções para uma Série produzirá um DataFrame. Os nomes das colunas resultantes serão os transformadores
funções.
Em [194]: tsdf["A"].transform([np.abs, lambda x: x + 1])

Fora[194]:
absoluto <lambda>
01-01-2000 0,428759 0,571241
02-01-2000 0,168731 0,831269
03/01/2000 1,621034 -0,621034
04-01-2000 NaN NaN
05-01-2000 NaN NaN
06-01-2000 NaN NaN
07-01-2000 NaN NaN
08-01-2000 0,254374 1,254374
09/01/2000 0,157795 0,842205
10/01/2000 0,030876 0,969124
Transformando com um ditado
Passar um ditado de funções permitirá a transformação seletiva por coluna.
Em [195]: tsdf.transform({"A": np.abs, "B": lambda x: x + 1})

Fora[195]:
A B
01/01/2000 0,428759 0,135110
02/01/2000 0,168731 2,338144
03-01-2000 1.621034 1.438107
04-01-2000 NaN NaN
05-01-2000 NaN NaN
06-01-2000 NaN NaN
07-01-2000 NaN NaN
08/01/2000 0,254374 -0,240447

09/01/2000 0,157795 1,791197

10/01/2000 0,030876 1,371900
Passar um ditado de listas irá gerar um DataFrame MultiIndexed com essas transformações seletivas.
Em [196]: tsdf.transform({"A": np.abs, "B": [lambda x: x + 1, "sqrt"]})

Fora[196]:
A B
absoluto <lambda> quadrado
01/01/2000 0,428759 0,135110 02/01/2000 NaN

0,168731 2,338144 1,156782
03/01/2000 1,621034 1,438107 0,661897
08/01/2000 0,254374 -0,240447 NaN
09/01/2000 0,157795 1,791197 0,889493
10/01/2000 0,030876 1,371900 0,609836
Aplicando funções elemento a elemento
Como nem todas as funções podem ser vetorizadas (aceitar arrays NumPy e retornar outro array ou valor), os métodos
applymap() no DataFrame e analogamente map() na Series aceitam qualquer função Python assumindo um único valor e
retornando um único valor. Por exemplo:
Em [197]: df4
Fora[197]:
um dois três
um 1,394981 1,772517 NaN
b 0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435
d NaN 0,279344 -0,613172
Em [198]: def f(x):

.....: retornar len(str(x))
.....:
Em [199]: df4["um"].map(f)
Fora[199]:
a 18
b 19
c 18
d 3
Nome: um, dtype: int64
Em [200]: df4.applymap(f)
Fora[200]:
um dois três
um 18 17 3
b 19 18 20

c 18 18 16
d 3 19 19
Series.map() possui um recurso adicional; ele pode ser usado para “vincular” ou “mapear” facilmente valores definidos por uma série secundária.
Isso está intimamente relacionado à funcionalidade de fusão/ junção:
Em [201]: s = pd.Series(
.....: ["seis", "sete", "seis", "sete", "seis"], índice=["a", "b", "c", "d", "e"]
..... :)
.....:
Em [202]: t = pd.Series({"seis": 6,0, "sete": 7,0})
Em [203]: s
Fora[203]:
a seis
b Sete
c seis
d Sete
e seis
dtype: objeto
Em [204]: s.map(t)
Fora[204]:
a 6,0
b 7,0
c 6,0
d 7,0
e 6,0
tipo d: float64
2.3.7 Reindexando e alterando rótulos

reindex() é o método fundamental de alinhamento de dados em pandas. É usado para implementar quase todos os outros recursos
contando com a funcionalidade de alinhamento de rótulos. Reindexar significa conformar os dados para corresponderem a um determinado conjunto de rótulos ao longo de um
eixo específico. Isso realiza várias coisas:
• Reordena os dados existentes para corresponder a um novo conjunto de rótulos
• Insere marcadores de valor ausente (NA) em locais de etiqueta onde não existiam dados para essa etiqueta
• Se especificado, preencha os dados para rótulos ausentes usando lógica (altamente relevante para trabalhar com dados de série temporal)
Aqui está um exemplo simples:
Em [206]: s
Fora[206]:
a 1.695148
b 1.328614
c 1.234686
d-0,385845

e-1,326508
tipo d: float64
Em [207]: s.reindex(["e", "b", "f", "d"])

Fora[207]:
e-1,326508
1.328614
NaN
bfd -0,385845
tipo d: float64
Aqui, o rótulo f não estava contido na série e, portanto, aparece como NaN no resultado.
Com um DataFrame, você pode reindexar simultaneamente o índice e as colunas:
Em [208]: df
Fora[208]:
um dois três
um 1,394981 1,772517 NaN
b 0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435
d NaN 0,279344 -0,613172
Em [209]: df.reindex(index=["c", "f", "b"], colunas=["três", "dois", "um"])

Fora[209]:
três dois um
c 1,227435 1,478369 0,695246
NaN NaN NaN
fb -0,050390 1,912123 0,343054
Você também pode usar reindex com uma palavra-chave axis:
Em [210]: df.reindex(["c", "f", "b"], axis="index")

Fora[210]:
um dois três
c 0,695246 1,478369 1,227435
f NaN NaN NaN
b 0,343054 1,912123 -0,050390
Observe que os objetos de índice que contêm os rótulos dos eixos reais podem ser compartilhados entre objetos. Então, se tivermos uma série
e um DataFrame, o seguinte pode ser feito:
Em [211]: rs = s.reindex(df.index)
Em [212]: rs
Fora[212]:
a 1.695148
b 1.328614
c 1.234686
d-0,385845
tipo d: float64
Em [213]: rs.index é df.index


Isso significa que o índice da série reindexada é o mesmo objeto Python que o índice do DataFrame.
DataFrame.reindex() também suporta uma convenção de chamada “estilo eixo”, onde você especifica um único argumento de rótulos
e o eixo ao qual ele se aplica.
Em [214]: df.reindex(["c", "f", "b"], axis="index")

Fora[214]:
um dois três
c 0,695246 1,478369 1,227435
fNaNNaN NaN
b 0,343054 1,912123 -0,050390
Em [215]: df.reindex(["três", "dois", "um"], eixo="colunas")

Fora[215]:
três dois um
a NaN 1,772517 1,394981
b -0,050390 1,912123 0,343054
c 1,227435 1,478369 0,695246
d -0,613172 0,279344 NaN
Veja também:
MultiIndex/ Advanced Indexing é uma forma ainda mais concisa de fazer reindexação.
Nota: Ao escrever código sensível ao desempenho, há um bom motivo para gastar algum tempo tornando-se um agente de reindexação.
ninja: muitas operações são mais rápidas em dados pré-alinhados. Adicionar dois DataFrames desalinhados internamente aciona um
etapa de reindexação. Para análise exploratória você dificilmente notará a diferença (porque a reindexação tem sido fortemente
otimizado), mas quando os ciclos de CPU são importantes, espalhar algumas chamadas de reindexação explícitas aqui e ali pode ter um impacto.
Reindexando para alinhar com outro objeto
Você pode querer pegar um objeto e reindexar seus eixos para ser rotulado da mesma forma que outro objeto. Embora a sintaxe para isso
é simples, embora detalhado, é uma operação bastante comum que o método reindex_like() esteja disponível para
torne isso mais simples:
Em [216]: df2
Fora[216]:
um dois
um 1,394981 1,772517
b 0,343054 1,912123
c 0,695246 1,478369
Em [217]: df3
Fora[217]:
um dois
0,583888 0,051514
b -0,468040 0,191120
c -0,115848 -0,242634

Em [218]: df.reindex_like(df2)
Fora[218]:
um dois
um 1,394981 1,772517
b 0,343054 1,912123
c 0,695246 1,478369
Alinhando objetos entre si com alinhamento
O método align() é a maneira mais rápida de alinhar dois objetos simultaneamente. Ele suporta um argumento join
(relacionado à junção e fusão):
• join='outer': pega a união dos índices (padrão)
• join='left': usa o índice do objeto chamador
• join='right': usa o índice do objeto passado
• join='inner': cruza os índices
Ele retorna uma tupla com ambas as séries reindexadas:
Em [220]: s1 = s[:4]
Em [221]: s2 = s[1:]
Em [222]: s1.align(s2)
Fora[222]: (a
-0,186646 b -1,692424
c-0,303893
d-1,425662
e NaN
tipo d: float64,
a NaN
b-1,692424
c-0,303893
d -1,425662
e 1,114285
dtipo: float64)
Em [223]: s1.align(s2, join="inner")

Fora [223]:
(b -1,692424 c
-0,303893 d
-1,425662 dtipo:
float64, b -1,692424 c
-0,303893 d
-1,425662 dtipo:
float64)

Em [224]: s1.align(s2, join="left")

Fora[224]:
(a -0,186646
b-1,692424
c-0,303893
d-1,425662
tipo d: float64,
a NaN
b-1,692424
c-0,303893
d-1,425662
tipo d: float64)
Para DataFrames, o método join será aplicado ao índice e às colunas por padrão:
Em [225]: df.align(df2, join="inner")

Fora[225]:
um dois
(um 1,394981 1,772517
b 0,343054 1,912123
c 0,695246 1,478369,
um dois
um 1,394981 1,772517
b 0,343054 1,912123
c 0,695246 1,478369)
Você também pode passar uma opção de eixo para alinhar apenas no eixo especificado:
Em [226]: df.align(df2, join="inner", axis=0)

Fora[226]:
( três um dois
a 1,394981 1,772517 NaN
b 0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435,
um dois
um 1,394981 1,772517
b 0,343054 1,912123
c 0,695246 1,478369)
Se você passar uma série para DataFrame.align(), poderá optar por alinhar ambos os objetos no índice do DataFrame ou
colunas usando o argumento do eixo:
Em [227]: df.align(df2.iloc[0], eixo=1)

Fora[227]:
um NaN 1,772517
(três a 1,394981 dois
b 0,343054 -0,050390 1,912123

c 0,695246 1,227435 1,478369
dNaN -0,613172 0,279344,
um 1.394981
três NaN

dois 1.772517
Nome: a, dtype: float64)
Preenchendo durante a reindexação
reindex() usa um método de parâmetro opcional que é um método de preenchimento escolhido na tabela a seguir:
Método Ação
pad / Preencha os valores adiante
preenchimento bfill / backfill Preencher valores para trás

mais próximo Preencha a partir do valor do índice mais próximo
Ilustramos esses métodos de preenchimento em uma série simples:
Em [228]: rng = pd.date_range("3/1/2000", períodos=8)
Em [229]: ts = pd.Series(np.random.randn(8), index=rng)
Em [230]: ts2 = ts[[0, 3, 6]]
Em [231]: ts
Fora[231]:
03/01/2000 0,183051
04-01-2000 0,400528
05/01/2000 -0,015083
06/01/2000 2.395489
07/01/2000 1.414806
08/01/2000 0,118428
09/01/2000 0,733639
10/01/2000 -0,936077
Em [232]: ts2
Fora[232]:
03/01/2000 0,183051
06-01-2000 2.395489
09/01/2000 0,733639
Freq: 3D, tipo d: float64
Em [233]: ts2.reindex(ts.index)
Fora[233]:
03/01/2000 0,183051
04-01-2000 NaN
05/01/2000 NaN
06/01/2000 2.395489
07/01/2000 NaN
08/01/2000 NaN
09/01/2000 0,733639
10/01/2000 NaN

Em [234]: ts2.reindex(ts.index, method="ffill")

Fora[234]:
03/01/2000 0,183051
04-01-2000 0,183051
05/01/2000 0,183051
06/01/2000 2.395489
07/01/2000 2.395489
08/01/2000 2.395489
09/01/2000 0,733639
10/01/2000 0,733639
Em [235]: ts2.reindex(ts.index, method="bfill")

Fora[235]:
2000-01-03 0,183051
2000-01-04 2.395489
2000-01-05 2.395489
2000-01-06 2.395489
2000-01-07 0,733639
2000-01-08 0,733639
2000-01-09 0,733639
2000-01-10 NaN
Freq: D, dtype: float64
Em [236]: ts2.reindex(ts.index, método="mais próximo")

Fora[236]:
03/01/2000 0,183051
04-01-2000 0,183051
05/01/2000 2.395489
06/01/2000 2.395489
07/01/2000 2.395489
08/01/2000 0,733639
09/01/2000 0,733639
10/01/2000 0,733639
Esses métodos exigem que os índices sejam ordenados crescente ou decrescente.
Observe que o mesmo resultado poderia ter sido alcançado usando fillna (exceto para method='nearest') ou interpolar:
Em [237]: ts2.reindex(ts.index).fillna(method="ffill")
Fora[237]:
03/01/2000 0,183051
04-01-2000 0,183051
05/01/2000 0,183051
06/01/2000 2.395489
07/01/2000 2.395489
08/01/2000 2.395489
09/01/2000 0,733639
10/01/2000 0,733639

reindex() gerará um ValueError se o índice não estiver aumentando ou diminuindo monotonicamente. preencher() e
interpolate() não realizará nenhuma verificação na ordem do índice.
Limites de preenchimento durante a reindexação
Os argumentos limite e tolerância fornecem controle adicional sobre o preenchimento durante a reindexação. Limite especifica o
contagem máxima de partidas consecutivas:
Em [238]: ts2.reindex(ts.index, método="ffill", limite=1)

Fora[238]:
03/01/2000 0,183051
04-01-2000 0,183051
05/01/2000 NaN
06/01/2000 2.395489
07/01/2000 2.395489
08/01/2000 NaN
09/01/2000 0,733639
10/01/2000 0,733639
Por outro lado, a tolerância especifica a distância máxima entre os valores do índice e do indexador:
Em [239]: ts2.reindex(ts.index, método="ffill", tolerância="1 dia")

Fora[239]:
03/01/2000 0,183051
04/01/2000 0,183051
05/01/2000 NaN
06/01/2000 2.395489
07/01/2000 2.395489
08/01/2000 NaN
09/01/2000 0,733639
10/01/2000 0,733639
Observe que quando usado em um DatetimeIndex, TimedeltaIndex ou PeriodIndex, a tolerância será forçada a um
Timedelta, se possível. Isso permite especificar a tolerância com strings apropriadas.
Soltando rótulos de um eixo
Um método intimamente relacionado à reindexação é a função drop() . Remove um conjunto de rótulos de um eixo:
Em [240]: df
Fora[240]:
um dois três
a 1,394981 1,772517 b 0,343054 NaN
1,912123 -0,050390
c 0,695246 1,478369 1,227435
dNaN 0,279344 -0,613172
Em [241]: df.drop(["a", "d"], eixo=0)

Fora[241]:
um dois três

b 0,343054 1,912123 -0,050390

c 0,695246 1,478369 1,227435
Em [242]: df.drop(["um"], eixo=1)

Fora[242]:
dois três
um 1,772517 NaN
b 1,912123 -0,050390
c 1,478369 1,227435
d 0,279344 -0,613172
Observe que o seguinte também funciona, mas é um pouco menos óbvio/limpo:
Em [243]: df.reindex(df.index.difference(["a", "d"]))

Fora[243]:
um dois três b
0,343054 1,912123 -0,050390 c 0,695246
1,478369 1,227435
Renomear/mapear rótulos
O método rename() permite renomear um eixo com base em algum mapeamento (um dict ou Series) ou uma função arbitrária.
Entrada [244]: s
Saída [244]:
a -0,186646
b-1,692424
c-0,303893
d-1,425662
e 1.114285
tipo d: float64
Em [245]: s.rename(str.upper)
Saída [245]:
A -0,186646 B
-1,692424 C
-0,303893 D
-1,425662 E
1,114285 dtype:
float64
Se você passar uma função, ela deverá retornar um valor quando chamada com qualquer um dos rótulos (e deverá produzir um conjunto de valores
exclusivos). Um dict ou Series também pode ser usado:
Em [246]:
.....: df.rename( columns={"one": "foo", "two": "bar"}, index={"a": "apple",
.....: "b": "banana", "d ": "durian"},
..... :)
.....:
Fora[246]:
foo bar três

maçã 1,394981 1,772517 banana NaN

0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435
durião NaN 0,279344 -0,613172
Se o mapeamento não incluir um rótulo de coluna/índice, ele não será renomeado. Observe que rótulos extras no mapeamento não geram
um erro.
DataFrame.rename() também suporta uma convenção de chamada “estilo eixo”, onde você especifica um único mapeador e o
eixo ao qual aplicar esse mapeamento.
Em [247]: df.rename({"one": "foo", "two": "bar"}, axis="columns")

Fora[247]:
barra foo a 1,394981 três
1,772517 b 0,343054 1,912123 NaN
-0,050390
c 0,695246 1,478369 1,227435
dNaN 0,279344 -0,613172
Em [248]: df.rename({"a": "apple", "b": "banana", "d": "durian"}, axis="index")

Fora[248]:
um dois três
maçã 1,394981 1,772517 banana NaN
0,343054 1,912123 -0,050390
c 0,695246 1,478369 1,227435
durião NaN 0,279344 -0,613172
O método rename() também fornece um parâmetro nomeado inplace que é por padrão False e copia o parâmetro subjacente
dados. Passe inplace=True para renomear os dados no local.
Finalmente, rename() também aceita um escalar ou semelhante a uma lista para alterar o atributo Series.name.
Em [249]: s.rename("nome escalar")

Fora[249]:
-0,186646
b-1,692424
c-0,303893
d-1,425662
e 1.114285
Nome: nome escalar, dtype: float64
Os métodos DataFrame.rename_axis() e Series.rename_axis() permitem que nomes específicos de um MultiIndex sejam

ser alterado (em oposição aos rótulos).
.....: {"x": [1, 2, 3, 4, 5, 6], "y": [10, 20, 30, 40, 50, 60]},
.....: índice=pd.MultiIndex.from_product(
.....: [["a", "b", "c"], [1, 2]], nomes=["let", "num"]
.....: ),
..... :)
.....:
Em [251]: df
Fora[251]:

x sim
deixe num
um 1 1 10
2 2 20
b 1 3 30
2 4 40
c 1 5 50
2 6 60
Em [252]: df.rename_axis(index={"let": "abc"})

Fora[252]:
x sim
número abc
um 1 2 1 10
2 20
b 3 30
4 40
c 5 50
1212 6 60
Em [253]: df.rename_axis(index=str.upper)
Fora[253]:
x sim
DEIXE NUM
um 1 1 10
2 2 20
b 1 3 30
2 4 40
c 1 5 50
2 6 60
2.3.8 Iteração
O comportamento da iteração básica sobre objetos pandas depende do tipo. Ao iterar sobre uma série, considera-se
como semelhante a um array, e a iteração básica produz os valores. DataFrames seguem a convenção semelhante a um ditado de iterar sobre o
“chaves” dos objetos.
Resumindo, a iteração básica (para i no objeto) produz:

• Série: valores
• DataFrame: rótulos de colunas
Assim, por exemplo, iterar sobre um DataFrame fornece os nomes das colunas:
.....: {"col1": np.random.randn(3), "col2": np.random.randn(3)}, índice=["a", "b",
ÿÿ"c"]
..... :)
.....:
Em [255]: para col em df:

.....: imprimir (coluna)


.....:
col1
col2
Os objetos pandas também têm o método items() do tipo dict para iterar sobre os pares (chave, valor).
Para iterar nas linhas de um DataFrame, você pode usar os seguintes métodos:
• iterrows(): Itera sobre as linhas de um DataFrame como pares (índice, série). Isso converte as linhas em séries
objetos, que podem alterar os dtypes e ter algumas implicações de desempenho.
• itertuples(): Itera sobre as linhas de um DataFrame como nomeadastuplas dos valores. Isso é muito mais rápido do que
iterrows() e, na maioria dos casos, é preferível usar para iterar sobre os valores de um DataFrame.
Aviso: a iteração através de objetos pandas geralmente é lenta. Em muitos casos, a iteração manual nas linhas não é
necessária e pode ser evitada com uma das seguintes abordagens:
• Procure uma solução vetorizada : muitas operações podem ser realizadas usando métodos integrados ou funções NumPy
ções, indexação (booleana), . . .
• Quando você tem uma função que não pode funcionar no DataFrame/Series completo de uma só vez, é melhor usar apply()
em vez de iterar sobre os valores. Consulte a documentação sobre aplicação de função.
• Se você precisar fazer manipulações iterativas nos valores, mas o desempenho for importante, considere escrever o loop
interno com cython ou numba. Consulte a seção de melhoria de desempenho para obter alguns exemplos dessa abordagem.
Aviso: você nunca deve modificar algo sobre o qual está iterando. Não é garantido que isso funcione em todos os casos.
Dependendo dos tipos de dados, o iterador retorna uma cópia e não uma visualização, e escrever nele não terá efeito!
Por exemplo, no seguinte caso, definir o valor não tem efeito:
Em [256]: df = pd.DataFrame({"a": [1, 2, 3], "b": ["a", "b", "c"]})
Em [257]: para índice, linha em df.iterrows(): row["a"] = 10

.....:
.....:
Em [258]: df
Fora[258]:
ab 0
1a12b
23c

Unid
Consistente com a interface semelhante a dict, items() itera através de pares de valores-chave:
• Série: pares (índice, valor escalar)
• DataFrame: pares (coluna, série)
Por exemplo:
Em [259]: para rótulo, ser em df.items():

.....: Etiqueta de impressão)
.....: imprimir (ser)
.....:
a
0 1
1 2
2 3
Nome: a, dtype: int64
b
0 a
1 b
2 c
Nome: b, dtype: objeto
iterrows
iterrows() permite iterar pelas linhas de um DataFrame como objetos Series. Ele retorna um iterador produzindo
cada valor de índice junto com uma série contendo os dados em cada linha:
Em [260]: para row_index, linha em df.iterrows():

.....: print(row_index, linha, set="\n")
.....:
0
a 1
b a
Nome: 0, dtype: objeto
1
a 2
b b
2
a 3
b c
Nota: Como iterrows() retorna uma série para cada linha, ele não preserva os dtypes nas linhas (dtypes são
preservados em colunas para DataFrames). Por exemplo,
Em [261]: df_orig = pd.DataFrame([[1, 1.5]], colunas=["int", "float"])
Em [262]: df_orig.dtypes
Fora[262]:


interno int64
flutuador float64
dtype: objeto
Em [263]: linha = next(df_orig.iterrows())[1]
Em [264]: linha
Fora[264]:
int 1,0
float 1,5
Nome: 0, dtype: float64
Todos os valores na linha, retornados como uma série, agora são convertidos em flutuantes, também o valor inteiro original na coluna x:
Em [265]: linha["int"].dtype Fora[265]:

dtype('float64')
Em [266]: df_orig["int"].dtype Fora[266]:

dtype('int64')
Para preservar os dtypes durante a iteração nas linhas, é melhor usar itertuples() que retorna tuplas nomeadas dos valores e que
geralmente é muito mais rápido que iterrows().
Por exemplo, uma forma inventada de transpor o DataFrame seria:
Em [267]: df2 = pd.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
Em [268]: imprimir(df2)
xy 0 1
412523
6
Em [269]: imprimir(df2.T)
0123e
x12
456
Em [270]: df2_t = pd.DataFrame({idx: valores para idx, valores em df2.iterrows()})
Em [271]: imprimir(df2_t)
012
x12 3
e456

itértulos
O método itertuples() retornará um iterador produzindo um nomeadotuple para cada linha no DataFrame. O primeiro
elemento da tupla será o valor do índice correspondente da linha, enquanto os valores restantes são os valores da linha.
Por exemplo:
Em [272]: para linha em df.itertuples(): print(row)

.....:
.....:
Pandas(Índice=0, a=1, b='a')
Pandas(Índice=1, a=2, b='b')
Pandas(Índice=2, a=3, b='c')
Este método não converte a linha em um objeto Series; ele apenas retorna os valores dentro de uma tupla nomeada.
Portanto, itertuples() preserva o tipo de dados dos valores e geralmente é mais rápido que iterrows().
Nota: Os nomes das colunas serão renomeados para nomes posicionais se forem identificadores Python inválidos, repetidos ou
começarem com um sublinhado. Com um grande número de colunas (>255), são retornadas tuplas regulares.
2.3.9 Acessador .dt
Series tem um acessador para retornar sucintamente propriedades semelhantes a data e hora para os valores da Série, se for uma data e
hora/período como Series. Isto retornará uma Série, indexada como a Série existente.
# datetime
Em [273]: s = pd.Series(pd.date_range("20130101 09:10:12", períodos=4))
Em [274]: s
Fora[274]:
0 01/01/2013 09:10:12
12/01/2013 09:10:12
2013-01-03 09:10:12
3 04/01/2013 09:10:12
tipo d: datahora64[ns]
Entrada [275]: sdt.hora

Saída [275]:
0919
2939
dtype:
int64
Entrada [276]: sdt.segundo

Saída [276]:
0 12 1 12
2 12
12
3dtipo: int64

Entrada [277]: dia s.dt.

Saída [277]:
0 1
1 2
2 3
3 4
tipo d: int64
Isso permite expressões legais como esta:
Em [278]: s[s.dt.day == 2]
Saída[278]:
1 02/01/2013 09:10:12 dtype:
datetime64[ns]
Você pode facilmente produzir transformações conscientes de tz:
Em [279]: stz = s.dt.tz_localize("EUA/Oriental")
Em [280]: stz
Fora [280]:
0 01/01/2013 09:10:12-05:00 1 02/01/2013
09:10:12-05:00 2 03/01/2013
09:10:12-05:00 3 04/01/2013
09:10:12-05:00 dtype: datetime64[ns,
EUA/Leste]
Entrada [281]: stz.dt.tz

Saída [281]: <DstTzInfo 'EUA/Leste' LMT-1 dia, 19:04:00 STD>
Você também pode encadear estes tipos de operações:
Em [282]: s.dt.tz_localize("UTC").dt.tz_convert("EUA/Leste")
Fora[282]:
01/01/2013 04:10:12-05:00
102/01/2013 04:10:12-05:00
2013-01-03 04:10:12-05:00
3 04/01/2013 04:10:12-05:00
dtype: datetime64[ns, EUA/Leste]
Você também pode formatar valores de data e hora como strings com Series.dt.strftime() que suporta o mesmo formato que o
strftime() padrão.
# DatetimeIndex In
[283]: s = pd.Series(pd.date_range("20130101", períodos=4))
Em [284]: s
Saída [284]:
0 01/01/2013 1
02/01/2013 2
03/01/2013 3
04/01/2013 dtype:
datetime64[ns]

Em [285]: s.dt.strftime("%Y/%m/%d")
Fora[285]:
0 01/01/2013
1 2013/01/02
2 03/01/2013
3 04/01/2013
dtype: objeto
#PeríodoIndex
Em [286]: s = pd.Series(pd.period_range("20130101", períodos=4))
Em [287]: s
Fora[287]:
0 01/01/2013
12013-01-02
2013-01-03
3 04/01/2013
dtipo: período[D]
Em [288]: s.dt.strftime("%Y/%m/%d")
Fora[288]:
0 01/01/2013
1 2013/01/02
2 03/01/2013
3 2013/01/04
dtype: objeto
O acessador .dt funciona para tipos de período e timedelta.
# período
Em [289]: s = pd.Series(pd.period_range("20130101", períodos=4, freq="D"))
Em [290]: s
Fora[290]:
0 01-01-2013
1 02/01/2013
2 03/01/2013
3 04/01/2013
dtipo: período[D]
Em [291]: ano sdt

Fora[291]:
0 2013
1 2013
2 2013
3 2013
tipo d: int64
Em [292]: dia sdt

Fora[292]:
0 1


1 2
2 3
3 4
tipo d: int64
#timedelta
Em [293]: s = pd.Series(pd.timedelta_range("1 dia 00:00:05", períodos=4, freq="s"))
Em [294]: s
Fora[294]:
0 1 dias 00:00:05
1 1 dias 00:00:06
2 1 dias 00:00:07
3 1 dias 00:00:08
tipo d: timedelta64[ns]
Em [295]: s.dt.days
Fora[295]:
0 1
1 1
2 1
3 1
tipo d: int64
Em [296]: s.dt.seconds
Fora[296]:
0 5
1 6
2 7
38
tipo d: int64
Em [297]: s.dt.components
Fora[297]:
dias horas minutos segundos milissegundos microssegundos nanossegundos
0 0 0 0 0 0
1 11 0 0 56 0 0 0
2 1 0 0 7 0 0 0
3 1 0 0 8 0 0 0
Nota: Series.dt gerará um TypeError se você acessar com valores diferentes de data e hora.

2.3.10 Métodos de strings vetorizadas
A série está equipada com um conjunto de métodos de processamento de strings que facilitam a operação em cada elemento do array.
Talvez o mais importante seja que esses métodos excluem valores ausentes/NA automaticamente. Eles são acessados através do Series's
str e geralmente têm nomes que correspondem aos métodos de string integrados equivalentes (escalares). Por exemplo:
Em [298]: s = pd.Series(
.....: ["A", "B", "C", "Aaba", "Baca", np.nan, "CABA", "cachorro", "gato"],ÿ
ÿÿdtype="string"
..... :)
.....:
Em [299]: s.str.lower()
Fora[299]:
0 a
1 b
2 c
3 aaba
4 baca
5 <NA>
6 caba
7 cachorro
gato
8 dtype: string
Métodos poderosos de correspondência de padrões também são fornecidos, mas observe que a correspondência de padrões geralmente usa
expressões regulares por padrão (e em alguns casos sempre as utiliza).
Nota: Antes do pandas 1.0, os métodos de string estavam disponíveis apenas no object -dtype Series. pandas 1.0 adicionou o
StringDtype que é dedicado a strings. Consulte Tipos de dados de texto para obter mais informações.
Consulte Métodos de String Vetorizada para obter uma descrição completa.
2.3.11 Classificação
O pandas suporta três tipos de classificação: classificação por rótulos de índice, classificação por valores de coluna e classificação por combinação
de ambos.
Por índice
Os métodos Series.sort_index() e DataFrame.sort_index() são usados para classificar um objeto pandas por seu índice
níveis.
.....: {
.....: "um": pd.Series(np.random.randn(3), índice=["a", "b", "c"]),
.....: "dois": pd.Series(np.random.randn(4), index=["a", "b", "c", "d"]),
.....: "três": pd.Series(np.random.randn(3), index=["b", "c", "d"]),
.....: }
..... :)
.....:

Em [301]: unsorted_df = df.reindex(

.....: índice=["a", "d", "c", "b"], colunas=["três", "dois", "um"]
..... :)
.....:
Em [302]: não classificado_df

Fora[302]:
três dois um
a NaN -1,152244 0,562973
d -0,252916 -0,109597 c NaN
1,273388 -0,167123 0,640382
b -0,098217 0,009797 -1,299504
# Quadro de dados
Em [303]: unsorted_df.sort_index()
Fora[303]:
três dois um
a NaN -1,152244 0,562973
b -0,098217 0,009797 -1,299504
c 1,273388 -0,167123 0,640382
d -0,252916 -0,109597 NaN
Em [304]: unsorted_df.sort_index(ascendente=Falso)
Fora[304]:
três dois um
d -0,252916 -0,109597 NaN
c 1,273388 -0,167123 0,640382
b -0,098217 0,009797 -1,299504
a NaN -1,152244 0,562973
Em [305]: unsorted_df.sort_index(axis=1)
Fora[305]:
um três a dois
0,562973 NaN -1,152244
dNaN -0,252916 -0,109597
c 0,640382 1,273388 -0,167123
b -1,299504 -0,098217 0,009797
# Series
Em [306]: unsorted_df["três"].sort_index()
Fora[306]:
a NaN
b -0,098217
c 1.273388
d-0,252916
Nome: três, dtype: float64
A classificação por índice também oferece suporte a um parâmetro chave que usa uma função que pode ser chamada para ser aplicada ao índice que está sendo classificado. Para
Objetos MultiIndex, a chave é aplicada por nível aos níveis especificados por nível.

Em [307]: s1 = pd.DataFrame({"a": ["B", "a", "C"], "b": [1, 2, 3], "c": [2, 3 , 4]}).set_
ÿÿíndice(
.....: lista("ab")
..... :)
.....:
Em [308]: s1
Fora[308]:
c
ab
B12
um 2 3
C34
Em [309]: s1.sort_index(level="a")
Fora[309]:
c
ab
B12
C34
um 2 3
Em [310]: s1.sort_index(level="a", key=lambda idx: idx.str.lower())

Fora[310]:
c
ab
um 2 3
B12
C34
Para obter informações sobre classificação de chaves por valor, consulte classificação de valores.
Por valores
O método Series.sort_values() é usado para classificar uma série por seus valores. O DataFrame.sort_values()
O método é usado para classificar um DataFrame por seus valores de coluna ou linha. O parâmetro by opcional para DataFrame.
sort_values() pode ser usado para especificar uma ou mais colunas a serem usadas para determinar a ordem de classificação.

.....: {"um": [2, 1, 1, 1], "dois": [1, 3, 2, 4], "três": [5, 4, 3, 2]}
..... :)
.....:
Em [312]: df1.sort_values(by="dois")
Fora[312]:
um dois três
0 2 1 5
2 1 2 3
1 1 3 4
3 1 4 2
O parâmetro by pode receber uma lista de nomes de colunas, por exemplo:

Em [313]: df1[["um", "dois", "três"]].sort_values(by=["um", "dois"])

Fora[313]:
um dois três
2 1 2 3
1 1 3 4
3 1 4 2
0 2 1 5
Esses métodos têm tratamento especial para valores NA por meio do argumento na_position:
Em [314]: s[2] = np.nan
Em [315]: s.sort_values()
Fora[315]:
0A
3 Aaba
1 B
4 Baca
6 CABÁ
8 gato
7 cachorro
2 <NA>
5 <NA>
dtype: string
Em [316]: s.sort_values(na_position="first")
Fora[316]:
2 <NA>
5 <NA>
0 A
3 Aaba
1 B
4 Baca
6 CABÁ
8 gato
7 cachorro
dtype: string
A classificação também oferece suporte a um parâmetro chave que usa uma função que pode ser chamada para ser aplicada aos valores que estão sendo classificados.
Em [317]: s1 = pd.Series(["B", "a", "C"])
Em [318]: s1.sort_values()
Fora[318]:
0B
2C
a
1 dtipo: objeto
Em [319]: s1.sort_values(key=lambda x: x.str.lower())

Fora[319]:


1 a
0 B
2 C
dtype: objeto
key receberá a série de valores e deverá retornar uma série ou array do mesmo formato com o transformado
valores. Para objetos DataFrame, a chave é aplicada por coluna, portanto a chave ainda deve esperar uma Série e retornar um
Série, por exemplo
Em [320]: df = pd.DataFrame({"a": ["B", "a", "C"], "b": [1, 2, 3]})
Em [321]: df.sort_values(by="a")
Fora[321]:
ab
0B1
2C3
1a2
Em [322]: df.sort_values(by="a", key=lambda col: col.str.lower())

Fora[322]:
ab
1a2
0B1
2C3
O nome ou tipo de cada coluna pode ser usado para aplicar funções diferentes a colunas diferentes.
Por índices e valores
Strings passadas como parâmetro by para DataFrame.sort_values() podem se referir a colunas ou nomes de nível de índice.
# Construir MultiIndex
Em [323]: idx = pd.MultiIndex.from_tuples(
.....: [("a", 1), ("a", 2), ("a", 2), ("b", 2), ("b", 1), ("b", 1)]
..... :)
.....:
Em [324]: idx.names = ["primeiro", "segundo"]
#Construir DataFrame
Em [325]: df_multi = pd.DataFrame({"A": np.arange(6, 0, -1)}, index=idx)
Em [326]: df_multi
Fora[326]:
A
primeiro segundo
a 1 6
2 5
2 4
b 2 3
1 2
1 1

Classificar por 'segundo' (índice) e 'A' (coluna)
Em [327]: df_multi.sort_values(by=["second", "A"])

Fora[327]:
A
primeiro segundo
b111222 1
2
a 6
b 3
a 4
5
Nota: Se uma string corresponder ao nome de uma coluna e a um nome de nível de índice, um aviso será emitido e a coluna receberá
precedência. Isso resultará em um erro de ambiguidade em uma versão futura.
pesquisa ordenada
A série possui o método searchsorted() , que funciona de forma semelhante a numpy.ndarray.searchsorted().
Em [328]: ser = pd.Series([1, 2, 3])
Em [329]: ser.searchsorted([0, 3])

Fora[329]: array([0, 2])
Em [330]: ser.searchsorted([0, 4])

Fora[330]: array([0, 3])
Em [331]: ser.searchsorted([1, 3], side="right")

Fora[331]: array([1, 3])
Em [332]: ser.searchsorted([1, 3], side="left")

Fora[332]: array([0, 2])
Em [333]: ser = pd.Series([3, 1, 2])
Em [334]: ser.searchsorted([0, 3], classificador=np.argsort(ser))

Fora[334]: array([0, 2])
menores/maiores valores
Series possui os métodos nsmallest() e nlargest() que retornam os menores ou maiores valores. Para um grande
Série isso pode ser muito mais rápido do que classificar a série inteira e chamar head(n) no resultado.
Em [335]: s = pd.Series(np.random.permutation(10))
Em [336]: s
Fora[336]:
0 2
1 0

2 3
3 7
4 1
5 5
6 9
7 6
8 8
9 4
tipo d: int64
Em [337]: s.sort_values()
Fora[337]:
10
4 1
02
23
94
55
76
37
88
69
tipo d: int64
Em [338]: s.nsmallest(3)
Fora[338]:
1 0
4 1
0 2
tipo d: int64
Em [339]: s.nmaior(3)
Fora[339]:
69
88
7
3dtipo: int64
DataFrame também possui os métodos nlargest e nsmallest.
.....: {
.....: "a": [-2, -1, 1, 10, 8, 11, -1],
.....: "b": lista("abdceff"),
.....: "c": [1,0, 2,0, 4,0, 3,2, np.nan, 3,0, 4,0],
.....: }
..... :)
.....:
Em [341]: df.nlargest(3, "a")

Fora[341]:
ab c


5 11 f 3,0
3 10 c 3,2
4 8 e NaN
Em [342]: df.nlargest(5, ["a", "c"])

Fora[342]:
ab 5 c
11 f 3,0
3 10 c 3,2
4 8 e NaN
2 1 d 4,0
6 -1f 4,0
Em [343]: df.nsmallest(3, "a")

Fora[343]:
ab 0 c
-2 a 1,0
1 -1 b 2,0
6 -1f 4,0
Em [344]: df.nsmallest(5, ["a", "c"])

Fora[344]:
ab c
0 -2 a 1,0
1 -1 b 2,0
6 -1f 4,0
2 1 d 4,0
4 8 e NaN
Classificando por uma coluna MultiIndex
Você deve ser explícito sobre a classificação quando a coluna for um MultiIndex e especificar totalmente todos os níveis a serem seguidos.
Em [345]: df1.columns = pd.MultiIndex.from_tuples(

.....: [("a", "um"), ("a", "dois"), ("b", "três")]
..... :)
.....:
Em [346]: df1.sort_values(by=("a", "dois"))

Fora[346]:
a b
um dois três
0 215
2 123
1 134
3 142

2.3.12 Copiando
O método copy() em objetos pandas copia os dados subjacentes (embora não os índices dos eixos, uma vez que são imutáveis) e retorna
um novo objeto. Observe que raramente é necessário copiar objetos. Por exemplo, há apenas um
algumas maneiras de alterar um DataFrame no local:
• Inserir, excluir ou modificar uma coluna.
• Atribuir atributos ao índice ou às colunas.
• Para dados homogêneos, modificação direta dos valores através do atributo valores ou indexação avançada.
Para ser claro, nenhum método pandas tem o efeito colateral de modificar seus dados; quase todo método retorna um novo objeto,
deixando o objeto original intocado. Se os dados forem modificados, é porque você o fez explicitamente.
2.3.13 dtipos
Na maior parte, o pandas usa matrizes NumPy e dtypes para séries ou colunas individuais de um DataFrame. NumPy
fornece suporte para float, int, bool, timedelta64[ns] e datetime64[ns] (observe que NumPy não suporta
datas com reconhecimento de fuso horário).
pandas e bibliotecas de terceiros estendem o sistema de tipos do NumPy em alguns lugares. Esta seção descreve as extensões
pandas fez internamente. Consulte Tipos de extensão para saber como escrever sua própria extensão que funcione com pandas. Ver
ecosystem.extensions para obter uma lista de bibliotecas de terceiros que implementaram uma extensão.
A tabela a seguir lista todos os tipos de extensão do pandas. Para métodos que requerem argumentos dtype, strings podem ser especificadas
como indicado. Consulte as respectivas seções de documentação para obter mais informações sobre cada tipo.
Tipo Tipo de dados escalar Variedade Aliases de string

de
Dados
tz- Matrizes de carimbo
data/hora
de DatetimeTZDtype. 'datahora64[ns, <tz>]'
consciente MatrizDataHora
data
hora
CategóricoDtype (nenhum) Categórico 'categoria'
Categórico
período PeríodoDtypePeriod matrizes. 'período[<freq>]',
(tempo PeríodoArray
vãos) 'Período[<freq>]'
esparso SparseDtype(nenhum) matrizes. 'Esparso', 'Esparso[int]', 'Esparso[float]'
MatrizEsparada
entre Matrizes IntervalDtypeInterval. 'intervalo', 'Intervalo',
vals IntervalArray 'Intervalo[<numpy_dtype>]',
'Intervalo[datetime64[ns, <tz>]]',
'Intervalo[timedelta64[<freq>]]'
Tipo Int64D, (nenhum) matrizes. 'Int8', 'Int16', 'Int32', 'Int64', 'UInt8',
etiqueta nula ... MatrizInteira 'UInt16', 'UInt32', 'UInt64'
inteiro
StringsStringDtypestr _ matrizes. 'corda'
StringArray
boleano BooleanDtypebool matrizes. 'boleano'
(com BooleanArray
N / D)

pandas tem duas maneiras de armazenar strings.
1. object dtype, que pode conter qualquer objeto Python, incluindo strings.
2. StringDtype, que é dedicado a strings.
Geralmente, recomendamos o uso de StringDtype. Consulte Tipos de dados de texto para obter mais informações.
Finalmente, objetos arbitrários podem ser armazenados usando o tipo de objeto, mas devem ser evitados na medida do possível (por
desempenho e interoperabilidade com outras bibliotecas e métodos. Veja conversão de objeto).
Um atributo dtypes conveniente para DataFrame retorna uma série com o tipo de dados de cada coluna.
Em [347]: dft = pd.DataFrame(

.....: {
.....: "A": np.random.rand(3),
.....: "B": 1,
.....: "C": "foo",
.....: "D": pd.Timestamp("20010102"),
.....: "E": pd.Series([1.0] * 3).astype("float32"),
.....: "F": Falso,
.....: "G": pd.Series([1] * 3, dtype="int8"),
.....: }
..... :)
.....:
Em [348]: dft
Fora[348]:
AB C D E FG
0 0,035962 1 foo 02/01/2001 1,0 Falso 1
1 0,701379 1 foo 02/01/2001 1,0 Falso 1
2 0,281885 1 foo 02/01/2001 1,0 Falso 1
Em [349]: dft.dtypes
Fora[349]:
A float64
B int64
C objeto
D datahora64[ns]
E float32
F bool
int8
Tipo G: objeto
Em um objeto Series, use o atributo dtype .
Em [350]: dft["A"].dtype
Fora[350]: dtype('float64')
Se um objeto pandas contiver dados com vários dtypes em uma única coluna, o dtype da coluna será escolhido para
acomodar todos os tipos de dados (objeto é o mais geral).
# esses ints são coagidos a floats

Em [351]: pd.Series([1, 2, 3, 4, 5, 6.0])
Fora[351]:
0 1,0

1 2,0
2 3,0
3 4,0
4 5,0
5 6,0
tipo d: float64
# string data força um tipo de objeto

Em [352]: pd.Series([1, 2, 3, 6.0, "foo"])
Fora[352]:
01
12
23
3 6,0
4 foo
dtype: objeto
O número de colunas de cada tipo em um DataFrame pode ser encontrado chamando DataFrame.dtypes.value_counts().
Em [353]: dft.dtypes.value_counts()
Fora[353]:
float64 1
int64 1
objeto 1
datetime64[ns] 1
float32 1
bool 1
int8 1
dtype: int64
Os dtypes numéricos serão propagados e podem coexistir em DataFrames. Se um dtype for passado (diretamente através do dtype
palavra-chave, um ndarray passado ou uma série passada), então ele será preservado nas operações do DataFrame. Além disso,
diferentes tipos numéricos NÃO serão combinados. O exemplo a seguir lhe dará uma ideia.
Em [354]: df1 = pd.DataFrame(np.random.randn(8, 1), colunas=["A"], dtype="float32")
Em [355]: df1
Fora[355]:
A
0 0,224364
1 1.890546
20,182879
3 0,787847
4 -0,188449
5 0,667715
6 -0,011736
7 -0,399073
Em [356]: df1.dtypes
Fora[356]:
A float32
dtype: objeto


.....: {
.....: "A": pd.Series(np.random.randn(8), dtype="float16"),
.....: "B": pd.Series(np.random.randn(8)),
.....: "C": pd.Series(np.array(np.random.randn(8), dtype="uint8")),
.....: }
..... :)
.....:
Em [358]: df2
Fora[358]:
A B C
0 0,823242 0,256090 0
1 1,607422 1,426469 0
2 -0,333740 -0,416203 255
3 -0,063477 1,139976 0
4 -1,014648 -1,193477 0
5 0,678711 0,096706 0
6 -0,040863 -1,956850 1
7 -0,357422 -0,714337 0
Fora[359]:
Um carro alegórico16
B float64
C uint8
dtype: objeto
padrões
Por padrão, os tipos inteiros são int64 e os tipos float são float64, independentemente da plataforma (32 ou 64 bits). A seguir
tudo resultará em dtypes int64.
Em [360]: pd.DataFrame([1, 2], colunas=["a"]).dtypes

Fora[360]:
a int64
dtype: objeto
Em [361]: pd.DataFrame({"a": [1, 2]}).dtypes

Fora[361]:
a int64
dtype: objeto
Em [362]: pd.DataFrame({"a": 1}, index=list(range(2))).dtypes

Fora[362]:
a int64
dtype: objeto
Observe que Numpy escolherá tipos dependentes de plataforma ao criar arrays. O seguinte resultará em int32
na plataforma de 32 bits.

Em [363]: frame = pd.DataFrame(np.array([1, 2]))
upcasting
Os tipos podem potencialmente sofrer upcast quando combinados com outros tipos, o que significa que são promovidos a partir do tipo atual
(por exemplo, int para flutuar).
Em [364]: df3 = df1.reindex_like(df2).fillna(valor=0,0) + df2
Em [365]: df3
Fora[365]:
A B C
0 1,047606 0,256090 0,0
1 3,497968 1,426469 0,0
2 -0,150862 -0,416203 255,0
3 0,724370 1,139976 0,0
4 -1,203098 -1,193477 0,0
5 1,346426 0,096706 0,0
6 -0,052599 -1,956850 1,0
7 -0,756495 -0,714337 0,0
Fora[366]:
B float64
C float64
dtype: objeto
DataFrame.to_numpy() retornará o denominador comum inferior dos dtypes, ou seja, o dtype que pode acomodar TODOS os tipos na
matriz NumPy dtyped homogênea resultante. Isso pode forçar algum upcasting.
Em [367]: df3.to_numpy().dtype
Fora[367]: dtype('float64')
tipo
Você pode usar o método astype() para converter dtypes explicitamente de um para outro. Por padrão, eles retornarão uma cópia,
mesmo que o dtype tenha permanecido inalterado (passe copy=False para alterar esse comportamento). Além disso, eles abrirão uma exceção
se a operação astype for inválida.
O upcasting está sempre de acordo com as regras do NumPy . Se dois dtypes diferentes estiverem envolvidos em uma operação, então quanto mais
geral será usado como resultado da operação.
Em [368]: df3
Fora[368]:
A B C
0 1,047606 0,256090 1 0,0
3,497968 1,426469 0,0
2 -0,150862 -0,416203 255,0
3 0,724370 1,139976 0,0
4 -1,203098 -1,193477 0,0

5 1,346426 0,096706 0,0

6 -0,052599 -1,956850 1,0
7 -0,756495 -0,714337 0,0
Fora[369]:
A float32
B float64
C float64
dtype: objeto
# conversão de dtypes
Em [370]: df3.astype("float32").dtypes
Fora[370]:
A float32
B float32
float32
Tipo de C: objeto
Converta um subconjunto de colunas para um tipo especificado usando astype().
Em [371]: dft = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
Em [372]: dft[["a", "b"]] = dft[["a", "b"]].astype(np.uint8)
Em [373]: dft
Fora[373]:
abc
0147
1258
2369
Fora[374]:
a uint8
b uint8
c int64
dtype: objeto
Converta certas colunas em um dtype específico passando um dict para astype().
Em [375]: dft1 = pd.DataFrame({"a": [1, 0, 1], "b": [4, 5, 6], "c": [7, 8, 9]})
Em [376]: dft1 = dft1.astype({"a": np.bool_, "c": np.float64})
Em [377]: dft1
Fora[377]:
ab 0 c
Verdadeiro 4 7,0
1 Falso 5 8,0
2 Verdadeiro 6 9,0

Em [378]: dft1.dtypes
Fora[378]:
a bool
b int64
c float64
dtype: objeto
Nota: Ao tentar converter um subconjunto de colunas para um tipo especificado usando astype() e loc(), ocorre upcasting.
loc() tenta ajustar o que estamos atribuindo aos dtypes atuais, enquanto [] irá sobrescrevê-los pegando o dtype de
o lado direito. Portanto, o trecho de código a seguir produz o resultado não intencional.
Em [379]: dft = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
Em [380]: dft.loc[:, ["a", "b"]].astype(np.uint8).dtypes

Fora[380]:
a uint8
b uint8
dtype: objeto
Em [381]: dft.loc[:, ["a", "b"]] = dft.loc[:, ["a", "b"]].astype(np.uint8)
Fora[382]:
a int64
b int64
c int64
dtype: objeto
conversão de objeto
O pandas oferece várias funções para tentar forçar a conversão de tipos do objeto dtype para outros tipos. Em casos
onde os dados já são do tipo correto, mas armazenados em uma matriz de objetos, o DataFrame.infer_objects() e
Os métodos Series.infer_objects() podem ser usados para conversão suave para o tipo correto.
Em [383]: importar data e hora
.....: [
.....: [1, 2],
.....: ["a", "b"],
.....: [datetime.datetime(2016, 3, 2), datetime.datetime(2016, 3,ÿ
ÿÿ2)],
.....: ]
..... :)
.....:
Em [385]: df = df.T
Em [386]: df

Fora[386]:
01 2
0 1 em 02/03/2016
1 2 b 02/03/2016
Em [387]: df.dtypes
Fora[387]:
0 objeto
1 objeto
2 datetime64[ns]
dtype: objeto
Como os dados foram transpostos, a inferência original armazenou todas as colunas como objeto, que infer_objects corrigirá.
Em [388]: df.infer_objects().dtypes Fora[388]: 0
objeto
1 int64
2 datetime64[ns]
dtype: objeto
As seguintes funções estão disponíveis para matrizes de objetos unidimensionais ou escalares para realizar a conversão rígida de objetos
para um tipo especificado:
• to_numeric() (conversão para tipos numéricos)
Em [389]: m = ["1,1", 2, 3]
Em [390]: pd.to_numeric(m)
Fora[390]: array([1.1, 2. , 3.])
• to_datetime() (conversão para objetos datetime)
Em [392]: m = ["09/07/2016", datetime.datetime(2016, 3, 2)]
Em [393]: pd.to_datetime(m)
Out[393]: DatetimeIndex(['2016-07-09', '2016-03-02'], dtype='datetime64[ns]',ÿ ÿÿfreq=None)
• to_timedelta() (conversão para objetos timedelta)
Em [394]: m = ["5us", pd.Timedelta("1dia")]
Em [395]: pd.to_timedelta(m)
Out[395]: TimedeltaIndex(['0 dias 00:00:00.000005', '1 dia 00:00:00'], dtype= ÿÿ'timedelta64[ns]', freq=Nenhum)
Para forçar uma conversão, podemos passar um argumento de erros, que especifica como os pandas devem lidar com
elementos que não podem ser convertidos no tipo ou objeto desejado. Por padrão, erros='raise', o que significa que quaisquer
erros encontrados serão gerados durante o processo de conversão. No entanto, se erros = 'coercer', esses erros serão
ignorados e os pandas converterão elementos problemáticos em pd.NaT (para data e hora e timedelta) ou np.nan (para numérico). Isso pode ser

útil se você estiver lendo dados que são principalmente do tipo desejado (por exemplo, numérico, data e hora), mas ocasionalmente
possuem elementos não conformes misturados que você deseja representar como ausentes:
Em [397]: m = ["maçã", datetime.datetime(2016, 3, 2)]
Em [398]: pd.to_datetime(m, erros = "coercer")

Out[398]: DatetimeIndex(['NaT', '2016-03-02'], dtype='datetime64[ns]', freq=None)
Em [399]: m = ["maçã", 2, 3]
Em [400]: pd.to_numeric(m, erros = "coercer")

Fora[400]: array([nan, 2., 3.])
Em [401]: m = ["maçã", pd.Timedelta("1dia")]
Em [402]: pd.to_timedelta(m, erros = "coercer")

Out[402]: TimedeltaIndex([NaT, '1 dias'], dtype='timedelta64[ns]', freq=None)
O parâmetro erros tem uma terceira opção de erros='ignore', que simplesmente retornará os dados passados se encontrar algum erro na
conversão para um tipo de dados desejado:
Em [404]: m = ["maçã", datetime.datetime(2016, 3, 2)]
Em [405]: pd.to_datetime(m, erros = "ignorar")

Out[405]: Índice(['apple', 02/03/2016 00:00:00], dtype='objeto')
Em [406]: m = ["maçã", 2, 3]
Em [407]: pd.to_numeric(m, erros = "ignorar")

Out[407]: array(['maçã', 2, 3], dtype=objeto)
Em [408]: m = ["maçã", pd.Timedelta("1dia")]
Em [409]: pd.to_timedelta(m, erros = "ignorar")

Out[409]: array(['apple', Timedelta('1 dias 00:00:00')], dtype=object)
Além da conversão de objetos, to_numeric() fornece outro argumento downcast, que dá a opção de fazer downcast dos dados numéricos
recentes (ou já) para um dtype menor, que pode conservar memória:
Em [410]: m = ["1", 2, 3]
In [411]: pd.to_numeric(m, downcast="integer") # menor int assinado dtype Out[411]: array([1, 2, 3], dtype=int8)
Em [412]: pd.to_numeric(m, downcast="signed") # igual a 'integer'

Fora[412]: array([1, 2, 3], dtype=int8)
In [413]: pd.to_numeric(m, downcast="unsigned") # menor unsigned int dtype Out[413]: array([1, 2, 3], dtype=uint8)

In [414]: pd.to_numeric(m, downcast="float") # menor float dtype Out[414]: array([1., 2., 3.],
dtype=float32)
Como esses métodos se aplicam apenas a arrays, listas ou escalares unidimensionais; eles não podem ser usados diretamente
em objetos multidimensionais, como DataFrames. No entanto, com apply(), podemos “aplicar” a função em cada coluna de
forma eficiente:
Em [416]: df = pd.DataFrame([["2016-07-09", datetime.datetime(2016, 3, 2)]] * 2, dtype="O ÿÿ")
Em [417]: df
Fora[417]:
0
1 0 2016-07-09 2016-03-02 00:00:00 1
2016-07-09 2016-03-02 00:00:00
Em [418]: df.apply(pd.to_datetime)
Fora[418]:
0 1
0 09/07/2016 02/03/2016
1 09/07/2016 02/03/2016
Em [419]: df = pd.DataFrame([["1.1", 2, 3]] * 2, dtype="O")
Entrada [420]:
df Saída
[420]: 0
1 2 0 1,1 2 3 1
1,1 2 3
Em [421]: df.apply(pd.to_numeric)
Fora[421]:
0120
1,1 2 3 1 1,1 2 3
Em [422]: df = pd.DataFrame([["5us", pd.Timedelta("1day")]] * 2, dtype="O")
Em [423]: df
Fora[423]:
0 1
0 5us 1 dia 00:00:00 1 5us 1
dia 00:00:00
Em [424]: df.apply(pd.to_timedelta)
Fora[424]:
0 1
0 0 dias 00:00:00.000005 1 dia 1 0 dias
00:00:00.000005 1 dia

Pegadinhas
A execução de operações de seleção em dados do tipo inteiro pode facilmente transformar os dados em flutuantes. O dtype da entrada
os dados serão preservados nos casos em que não sejam introduzidos nans. Consulte também Suporte para número inteiro NA.
Em [425]: dfi = df3.astype("int32")
Em [426]: dfi["E"] = 1
Em [427]: dfi
Fora[427]:
AB CE
010 01
131 01
2 0 0 255 1
301 01
4 -1 -1 01
510 01
6 0 -1 7 0 1
0 101
Em [428]: dfi.dtypes
Fora[428]:
Um int32
B int32
C int32
E int64
dtype: objeto
Em [429]: lançado = dfi[dfi > 0]
Em [430]: lançado
Fora[430]:
A B CE
0 1,0 NaN NaN 1
1 3,0 1,0 NaN 1
2 NaN NaN 255,0 1
3NaN 1,0 NaN 1
4 NaN NaN NaN 1
5 1,0 NaN NaN 1
6 NaN NaN 1,0 1
7 NaN NaN NaN 1
Em [431]: casted.dtypes
Fora[431]:
B float64
C float64
E int64
dtype: objeto
Embora os dtypes float permaneçam inalterados.

Em [432]: dfa = df3.copy()
Em [433]: dfa["A"] = dfa["A"].astype("float32")
Em [434]: dfa.dtypes
Fora[434]:
A float32
B float64
C float64
dtype: objeto
Em [435]: convertido = dfa[df2 > 0]
Em [436]: lançado
Fora[436]:
AB 0 1,047606 C
0,256090 1 3,497968 1,426469 NaN
NaN
2 NaN NaN 255,0
3 NaN 1,139976 NaN
4 NaN NaN NaN
5 1,346426 0,096706 NaN
6 NaN NaN 1,0
7 NaN NaN NaN
Em [437]: casted.dtypes
Fora[437]:
A float32
B float64
C float64
dtype: objeto
2.3.14 Selecionando colunas com base no dtype
O método select_dtypes() implementa subconjuntos de colunas com base em seu dtype.
Primeiro, vamos criar um DataFrame com vários dtypes diferentes:
.....: {
.....: "string": lista("abc"),
.....: "int64": lista(intervalo(1, 4)),
.....: "uint8": np.arange(3, 6).astype("u1"),
.....: "float64": np.arange(4.0, 7.0),
.....: "bool1": [Verdadeiro, Falso, Verdadeiro],
.....: "bool2": [Falso, Verdadeiro, Falso],
.....: "datas": pd.date_range("agora", períodos=3),
.....: "categoria": pd.Series(list("ABC")).astype("categoria"),
.....: }
..... :)
.....:

Em [439]: df["tdeltas"] = df.dates.diff()
Em [440]: df["uint64"] = np.arange(3, 6).astype("u8")
Em [441]: df["outras_datas"] = pd.date_range("20130101", períodos=3)
Em [442]: df["tz_aware_dates"] = pd.date_range("20130101", períodos=3, tz="US/Eastern")
Em [443]: df
Fora[443]:
string int64 uint8 float64 bool1 bool2 tz_aware_dates categoria de datasÿ
ÿÿtdeltas uint64 other_dates 0 1 3 3
2013-01-01a2013-01-01 4.0 Verdadeiro Falso 31/08/2022 09:57:43.930396 A ÿ
ÿÿNaT 00:00:00-05:00
b 2 4 5.0 Falso Verdadeiro 2022-09-01 09:57:43.930396 B 1ÿ
1ÿ ÿdias 4 02/01/2013 02/01/2013 00:00:00-05:00
c 3 5 6.0 Verdadeiro Falso 02/09/2022 09:57:43.930396 C 1ÿ
2ÿ ÿdias 5 03/01/2013 03/01/2013 00:00:00-05:00
E os tipos:
Em [444]: df.dtypes
Fora[444]:
string objeto
int64 int64
uint8 uint8
float64 float64
bool1 bool
bool2 bool
datas datahora64[ns]
categoria categoria
tdeltas timedelta64[ns]
uint64 uint64
other_dates datahora64[ns]
tz_aware_dates dtype: datetime64[ns, EUA/Leste]
objeto
select_dtypes() tem dois parâmetros include e exclude que permitem que você diga “dê-me as colunas com estes
dtypes” (incluir) e/ou “forneça as colunas sem esses dtypes” (excluir).
Por exemplo, para selecionar colunas bool:
Em [445]: df.select_dtypes(include=[bool])
Fora[445]:
bool1 bool2
0 Verdadeiro Falso
1 Falso Verdadeiro
2 Verdadeiro Falso
Você também pode passar o nome de um dtype na hierarquia de dtype NumPy:
Em [446]: df.select_dtypes(include=["bool"])
Fora[446]:

bool1 bool2
0 Verdadeiro Falso
1 Falso Verdadeiro
2 Verdadeiro Falso
select_dtypes() também funciona com dtypes genéricos.
Por exemplo, para selecionar todas as colunas numéricas e booleanas, excluindo números inteiros sem sinal:
Em [447]: df.select_dtypes(include=["number", "bool"], exclude=["unsignedinteger"])

Fora[447]:
int64 float64 bool1 bool2 tdeltas
0 1 4.0 Verdadeiro Falso NaT
1 2 5,0 Falso Verdadeiro 1 dia
2 3 6,0 Verdadeiro Falso 1 dia
Para selecionar colunas de string você deve usar o objeto dtype:
Em [448]: df.select_dtypes(include=["objeto"])
Fora[448]:
corda
0 a
1 b
2 c
Para ver todos os tipos filhos de um tipo genérico como numpy.number você pode definir uma função que retorna uma árvore de filhos
tipos:
Em [449]: def subdtypes(dtype):

.....: subs = dtype.__subclasses__()
.....: se não for substituto:
.....: retornar tipo de d
.....: retornar [dtype, [subdtypes(dt) para dt em subs]]
.....:
Todos os dtypes NumPy são subclasses de numpy.generic:
Em [450]: subdtypes(np.generic)
Fora[450]:
[numpy.genérico,
[[numpy.número,
[[numpy.inteiro,
[[numpy.signedinteiro,
[numpy.int8,
numpy.int16,
numpy.int32,
numpy.int64,
numpy.longlong,
numpy.timedelta64]],
[numpy.unsignedinteger,
[numpy.uint8,
numpy.uint16,
numpy.uint32,

numpy.uint64,
numpy.ulonglong]]]],
[numpy.inexato,
[[numpy.flutuante,
[numpy.float16, numpy.float32, numpy.float64, numpy.float128]],
[numpy.complexfloating,
[numpy.complex64, numpy.complex128, numpy.complex256]]]]]],
[numpy.flexível,
[[numpy.caractere, [numpy.bytes_, numpy.str_]],
[numpy.void, [numpy.record]]]],
numpy.bool_,
numpy.datetime64,
numpy.object_]]
Nota: pandas também define a categoria de tipos e datetime64[ns, tz], que não estão integrados no normal
Hierarquia NumPy e não aparecerá com a função acima.
2.4 Ferramentas IO (texto, CSV, HDF5,...)
A API de E/S do pandas é um conjunto de funções de leitura de nível superior acessadas como pandas.read_csv() que geralmente retornam um
objeto panda. As funções de gravação correspondentes são métodos de objeto que são acessados como DataFrame.to_csv().
Abaixo está uma tabela contendo leitores e escritores disponíveis.
Formatar descrição de dados Leitor Escritor

Tipo
texto CSV read_csv para_csv
texto Arquivo de texto de largura fixa read_fwf
texto JSON read_json para_json
texto HTML read_html para_html
texto Látex Estilizador.to_latex
texto XML read_xml para_xml
texto Área de transferência local read_clipboard para_área de transferência
binário Excel read_excel para se destacar
binário OpenDocument read_excel

binário Formato HDF5 read_hdf para_hdf
binário Formato Pena read_feather para_pena
binário Formato Parquet read_parquet para_parquet
binário Formato ORC read_orc
binário Estatística read_stata para_stata
binário SAS read_sas
binário SPSS leitura_spss
binário Formato Pickle Python read_pickle para_pickle
SQL SQL read_sql to_sql
SQL GoogleBigQuery read_gbq para_gbq
Aqui está uma comparação informal de desempenho para alguns desses métodos de IO.
Nota: Para exemplos que usam a classe StringIO, certifique-se de importá-la com from io import StringIO for
2.4. Ferramentas IO (texto, CSV, HDF5,...) 273

Pitão 3.
2.4.1 CSV e arquivos de texto
A função robusta para ler arquivos de texto (também conhecidos como arquivos simples) é read_csv(). Consulte o livro de receitas para algumas estratégias
avançadas.
Opções de análise
read_csv() aceita os seguintes argumentos comuns:
Básico
filepath_or_buffer [vários] Um caminho para um arquivo (um str, pathlib.Path ou py:py._path.local.LocalPath), URL (incluindo locais http, ftp e
S3) ou qualquer objeto com read() método (como um arquivo aberto ou StringIO).
sep [str, o padrão é ',' para read_csv(), \t para read_table()] Delimitador a ser usado. Se sep for None, o mecanismo C não poderá detectar
automaticamente o separador, mas o mecanismo de análise Python poderá, o que significa que o último será usado e detectará
automaticamente o separador pela ferramenta sniffer integrada do Python, csv.Sniffer . Além disso, separadores com mais de 1 caractere
e diferentes de '\s+' serão interpretados como expressões regulares e também forçarão o uso do mecanismo de análise Python. Observe
que os delimitadores regex tendem a ignorar os dados citados. Exemplo de regex: '\\r\\t'.
delimitador [str, padrão Nenhum] Nome de argumento alternativo para setembro.

'
delim_whitespace [boolean, default False] Especifica se há ou não espaços em branco (por exemplo, ' ou '\t') será usado como
delimitador. Equivalente à configuração sep='\s+'. Se esta opção estiver definida como True, nada deverá ser passado para o parâmetro
delimitador.
Locais e nomes de colunas e índices
cabeçalho [int ou lista de inteiros, padrão 'inferir'] Número(s) de linhas a serem usados como nomes de colunas e o início dos dados.
O comportamento padrão é inferir os nomes das colunas: se nenhum nome for passado, o comportamento será idêntico ao header=0 e
os nomes das colunas serão inferidos a partir da primeira linha do arquivo, se os nomes das colunas forem passados explicitamente, o
comportamento será idêntico ao header=None . Passe explicitamente header=0 para poder substituir nomes existentes.
O cabeçalho pode ser uma lista de inteiros que especificam locais de linha para um MultiIndex nas colunas, por exemplo, [0,1,3].
As linhas intermediárias que não forem especificadas serão ignoradas (por exemplo, 2 neste exemplo são ignoradas). Observe que este
parâmetro ignora linhas comentadas e linhas vazias se skip_blank_lines=True, então header=0 denota a primeira linha de dados em vez
da primeira linha do arquivo.
nomes [tipo array, padrão Nenhum] Lista de nomes de colunas a serem usados. Se o arquivo não contiver nenhuma linha de cabeçalho, você deverá explicitamente
passar cabeçalho=Nenhum. Duplicatas nesta lista não são permitidas.
index_col [int, str, sequência de int / str, ou False, opcional, padrão Nenhum] Coluna(s) para usar como rótulos de linha do DataFrame, fornecidos
como nome de string ou índice de coluna. Se uma sequência de int/str for fornecida, um MultiIndex será usado.
Nota: index_col=False pode ser usado para forçar o pandas a não usar a primeira coluna como índice, por exemplo, quando você tem um
arquivo malformado com delimitadores no final de cada linha.
O valor padrão None instrui os pandas a adivinhar. Se o número de campos na linha do cabeçalho da coluna for igual ao número de
campos no corpo do arquivo de dados, um índice padrão será usado. Se for maior, então as primeiras colunas

são usados como índice para que o número restante de campos no corpo seja igual ao número de campos no
cabeçalho.
A primeira linha após o cabeçalho é usada para determinar o número de colunas que irão para o índice. Se o
as linhas subsequentes contêm menos colunas do que a primeira linha e são preenchidas com NaN.
Isso pode ser evitado através de usecols. Isso garante que as colunas sejam consideradas como estão e os dados finais sejam
ignorado.
usecols [tipo lista ou chamável, padrão Nenhum] Retorna um subconjunto de colunas. Se for semelhante a uma lista, todos os elementos devem ser
posicionais (ou seja, índices inteiros nas colunas do documento) ou strings que correspondem aos nomes das colunas fornecidos
pelo usuário em nomes ou inferido da(s) linha(s) do cabeçalho do documento. Se forem fornecidos nomes, o documento
linha(s) de cabeçalho não são levadas em consideração. Por exemplo, um parâmetro usecols semelhante a uma lista válido seria [0, 1,
2] ou ['foo', 'bar', 'baz'].
A ordem dos elementos é ignorada, então usecols=[0, 1] é igual a [1, 0]. Para instanciar um DataFrame a partir de dados
com a ordem dos elementos preservada, use pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]
para colunas na ordem ['foo', 'bar'] ou pd.read_csv(data, usecols=['foo', 'bar'])[['bar',
'foo']] para ordem ['bar', 'foo'].
Se puder ser chamada, a função que pode ser chamada será avaliada em relação aos nomes das colunas, retornando nomes onde a função que pode ser chamada
função é avaliada como True:
Em [2]: de io import StringIO
Em [3]: dados = "col1,col2,col3\na,b,1\na,b,2\nc,d,3"
Em [4]: pd.read_csv(StringIO(dados))
Fora[4]:
col1 col2 col3
0 a 1
a 2
12 c bbd 3
Em [5]: pd.read_csv(StringIO(data), usecols=lambda x: x.upper() in ["COL1", "COL3"])

Fora[5]:
col1 col3
0 a 1
1 a 2
2 c 3
Usar esse parâmetro resulta em um tempo de análise muito mais rápido e menor uso de memória ao usar o mecanismo c. O
O mecanismo Python carrega os dados primeiro, antes de decidir quais colunas serão eliminadas.
squeeze [boolean, padrão False] Se os dados analisados contiverem apenas uma coluna, retorne uma série.
Obsoleto desde a versão 1.4.0: anexe .squeeze("columns") à chamada para {func_name} para espremer o
dados.
prefixo [str, padrão Nenhum] Prefixo para adicionar aos números das colunas quando não há cabeçalho, por exemplo, 'X' para X0, X1, . . .
Obsoleto desde a versão 1.4.0: Use uma compreensão de lista nas colunas do DataFrame após chamar read_csv.
Em [6]: dados = "col1,col2,col3\na,b,1"
Em [7]: df = pd.read_csv(StringIO(dados))

Em [8]: df.columns = [f"pre_{col}" para col em df.columns]
Em [9]: df
Fora[9]:
pré_col1 pré_col2 pré_col3
0 a b 1
mangle_dupe_cols [boolean, padrão True] Colunas duplicadas serão especificadas como 'X', 'X.1'. . . 'X.N', em vez de
'X'. . . 'X'. Passar False fará com que os dados sejam sobrescritos se houver nomes duplicados nas colunas.
Configuração de análise geral
dtype [Nome do tipo ou ditado da coluna -> tipo, padrão Nenhum] Tipo de dados para dados ou colunas. Por exemplo, {'a': np.
float64, 'b': np.int32} (não suportado com engine='python'). Use str ou object junto com configurações na_values adequadas para
preservar e não interpretar dtype.
motor [{'c', 'python', 'pyarrow'}] Mecanismo de análise a ser usado. Os motores C e pyarrow são mais rápidos, enquanto o python
o motor está atualmente mais completo em recursos. Atualmente, multithreading é suportado apenas pelo mecanismo pyarrow.
Novidade na versão 1.4.0: O mecanismo “pyarrow” foi adicionado como mecanismo experimental e alguns recursos não são suportados
ou podem não funcionar corretamente com este mecanismo.
conversores [dict, padrão None] Dict de funções para conversão de valores em determinadas colunas. As chaves podem ser números inteiros
ou rótulos de coluna.
true_values [lista, padrão Nenhum] Valores a serem considerados como Verdadeiros.
false_values [lista, padrão Nenhum] Valores a serem considerados como falsos.
skipinitialspace [boolean, default False] Ignora espaços após o delimitador.
skiprows [list-like ou inteiro, padrão Nenhum] Números de linhas a serem ignoradas (indexadas em 0) ou número de linhas a serem ignoradas (int) no
início do arquivo.
Se puder ser chamada, a função que pode ser chamada será avaliada em relação aos índices de linha, retornando True se a linha for
ignorado e False caso contrário:
Fora[11]:
col1 col2 col3
0 a b 1
1 a b 2
2 c d 3
Em [12]: pd.read_csv(StringIO(dados), skiprows=lambda x: x % 2 != 0)

Fora[12]:
col1 col2 col3
0 a b 2
skipfooter [int, padrão 0] Número de linhas na parte inferior do arquivo a serem ignoradas (não suportado com engine='c').
nrows [int, padrão Nenhum] Número de linhas do arquivo a serem lidas. Útil para ler pedaços de arquivos grandes.

low_memory [boolean, padrão True] Processa internamente o arquivo em partes, resultando em menor uso de memória durante a análise, mas
possivelmente em inferência de tipo misto. Para garantir que não haja tipos mistos, defina False ou especifique o tipo com o parâmetro
dtype. Observe que o arquivo inteiro é lido em um único DataFrame, independentemente, use o parâmetro chunksize ou iterator para
retornar os dados em pedaços. (Válido apenas com analisador C)
memory_map [boolean, default False] Se um caminho de arquivo for fornecido para filepath_or_buffer, mapeie o objeto de arquivo diretamente na
memória e acesse os dados diretamente de lá. Usar esta opção pode melhorar o desempenho porque não há mais sobrecarga de E/S.
NA e tratamento de dados ausentes
na_values [scalar, str, list-like ou dict, padrão None] Strings adicionais a serem reconhecidas como NA/NaN. Se o dict for aprovado, valores NA
específicos por coluna. Consulte os valores na const abaixo para obter uma lista dos valores interpretados como NaN por padrão.
keep_default_na [boolean, default True] Se deve ou não incluir os valores NaN padrão ao analisar os dados.
Dependendo se na_values for passado, o comportamento será o seguinte:
• Se keep_default_na for True e na_values forem especificados, na_values será anexado aos valores NaN padrão usados para análise.
• Se keep_default_na for True e na_values não forem especificados, apenas os valores NaN padrão serão usados para
análise.
• Se keep_default_na for False e na_values forem especificados, apenas os valores NaN especificados na_values
são usados para análise.
• Se keep_default_na for False e na_values não forem especificados, nenhuma string será analisada como NaN.
Observe que se na_filter for passado como False, os parâmetros keep_default_na e na_values serão ignorados.
na_filter [boolean, padrão True] Detecta marcadores de valor ausentes (strings vazias e o valor de na_values). Em dados sem NAs, passar
na_filter=False pode melhorar o desempenho da leitura de um arquivo grande.
verbose [boolean, default False] Indica o número de valores NA colocados em colunas não numéricas.
skip_blank_lines [boolean, padrão True] Se True, pule as linhas em branco em vez de interpretar como valores NaN.
Tratamento de data e hora
parse_dates [booleano ou lista de inteiros ou nomes ou lista de listas ou dict, padrão False.]
• Se True -> tente analisar o índice.
• Se [1, 2, 3] -> tente analisar as colunas 1, 2, 3 cada uma como uma coluna de data separada.
• If [[1, 3]] -> combine as colunas 1 e 3 e analise como uma única coluna de data.
• If {'foo': [1, 3]} -> analisa as colunas 1, 3 como data e chama o resultado 'foo'. Existe um caminho rápido para iso8601-
datas formatadas.
infer_datetime_format [boolean, padrão False] Se True e parse_dates estiverem ativados para uma coluna, tente inferir o formato de data e hora
para acelerar o processamento.
keep_date_col [boolean, padrão False] Se True e parse_dates especificam a combinação de múltiplas colunas, então mantenha o
colunas originais.
date_parser [função, padrão Nenhum] Função a ser usada para converter uma sequência de colunas de string em uma matriz de instâncias de
data e hora. O padrão usa dateutil.parser.parser para fazer a conversão. O pandas tentará chamar date_parser de três maneiras diferentes,
avançando para a próxima se ocorrer uma exceção: 1) Passe um ou mais arrays (como

definido por parse_dates) como argumentos; 2) concatenar (linha) os valores da string das colunas definidas por parse_dates em um
único array e passá-lo; e 3) chamar date_parser uma vez para cada linha usando uma ou mais strings (correspondentes às colunas
definidas por parse_dates) como argumentos.
dayfirst [boolean, default False] Datas em formato DD/MM, formato internacional e europeu.
cache_dates [boolean, padrão True] Se True, use um cache de datas convertidas exclusivas para aplicar a conversão de data e hora.
Pode produzir uma aceleração significativa ao analisar sequências de datas duplicadas, especialmente aquelas com diferenças de fuso horário.
Iteração
iterador [booleano, padrão False] Retorna o objeto TextFileReader para iteração ou obtenção de pedaços com get_chunk().
chunksize [int, padrão Nenhum] Retorna o objeto TextFileReader para iteração. Veja iteração e fragmentação abaixo.
Citação, compactação e formato de arquivo
compressão [{'infer', 'gzip', 'bz2', 'zip', 'xz', 'zstd', None, dict}, default 'infer'] Para descompactação instantânea de dados em disco. Se 'inferir',
use gzip, bz2, zip, xz ou zstandard se filepath_or_buffer for semelhante a um caminho terminando em '.gz', '.bz2', '.zip', '.xz', '.zst',
respectivamente, e nenhuma descompressão caso contrário. Se estiver usando 'zip', o arquivo ZIP deverá conter apenas um arquivo de
dados para ser lido. Defina como Nenhum para não descompactar. Também pode ser um ditado com a chave 'método' definida como
{'zip', 'gzip', 'bz2', 'zstd'} e outros pares de valores-chave são encaminhados para zipfile.ZipFile, gzip.GzipFile, bz2. BZ2File ou
zstandard.ZstdDecompressor. Como exemplo, o seguinte poderia ser passado para compactação mais rápida e para criar um arquivo
gzip reproduzível: compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}.
Alterado na versão 1.1.0: opção dict estendida para suportar gzip e bz2.
Alterado na versão 1.2.0: versões anteriores encaminhavam entradas de dict para 'gzip' para gzip.open.
milhares [str, padrão Nenhum] Separador de milhares.
decimal [str, padrão '.'] Caractere a ser reconhecido como ponto decimal. Por exemplo, use ',' para dados europeus.
float_precision [string, padrão None] Especifica qual conversor o mecanismo C deve usar para valores de ponto flutuante.
As opções são None para o conversor comum, high para o conversor de alta precisão e round_trip para o conversor de ida e volta.
lineterminator [str (comprimento 1), padrão Nenhum] Caractere para dividir o arquivo em linhas. Válido apenas com analisador C.
quotechar [str (comprimento 1)] O caractere usado para indicar o início e o fim de um item entre aspas. Os itens cotados podem incluir
o delimitador e ele será ignorado.
citando [instância int ou csv.QUOTE_*, padrão 0] Campo de controle citando comportamento por constantes csv.QUOTE_*. Use um entre
QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) ou QUOTE_NONE (3).
doublequote [boolean, padrão True] Quando quotechar for especificado e a cotação não for QUOTE_NONE, indique se dois elementos
quotechar consecutivos devem ou não ser interpretados dentro de um campo como um único elemento quotechar.
escapechar [str (comprimento 1), padrão Nenhum] A sequência de um caractere usada para escapar do delimitador ao citar é QUOTE_NONE.
comment [str, padrão None] Indica que o restante da linha não deve ser analisado. Se for encontrado no início de uma linha, a linha será
totalmente ignorada. Este parâmetro deve ser um único caractere. Assim como as linhas vazias (desde que skip_blank_lines=True), as
linhas totalmente comentadas são ignoradas pelo cabeçalho do parâmetro, mas não pelos skiprows.
Por exemplo, se comment='#', analisar '#empty\na,b,c\n1,2,3' com header=0 resultará em 'a,b,c' sendo tratado como o cabeçalho.

codificação [str, padrão Nenhum] Codificação a ser usada para UTF ao ler/escrever (por exemplo, 'utf-8'). Lista de padrão Python
codificações.
dialect [str ou csv.Dialect instance, default None] Se fornecido, este parâmetro substituirá os valores (padrão ou não) para os seguintes
parâmetros: delimitador, aspas duplas, escapechar, skipinitialspace, quotechar e aspas. Caso seja necessário substituir valores, será
emitido um ParserWarning. Consulte a documentação do csv.Dialect para obter mais detalhes.
Manipulação de erros
error_bad_lines [boolean, opcional, padrão None] Linhas com muitos campos (por exemplo, uma linha csv com muitas vírgulas) por padrão
causarão o lançamento de uma exceção e nenhum DataFrame será retornado. Se for falso, essas “linhas incorretas” serão eliminadas
do DataFrame retornado. Veja linhas ruins abaixo.
Obsoleto desde a versão 1.3.0: O parâmetro on_bad_lines deve ser usado para especificar o comportamento ao encontrar uma linha
incorreta.
warning_bad_lines [boolean, opcional, padrão None] Se error_bad_lines for False e warning_bad_lines for True, um aviso
ing para cada “linha ruim” será gerado.
Obsoleto desde a versão 1.3.0: O parâmetro on_bad_lines deve ser usado para especificar o comportamento ao encontrar uma linha
incorreta.
on_bad_lines [('error', 'warn', 'skip'), default 'error'] Especifica o que fazer ao encontrar uma linha incorreta (uma linha com
muitos campos). Os valores permitidos são:
• 'error', gera um ParserError quando uma linha incorreta é encontrada.
• 'warn', imprime um aviso quando uma linha incorreta é encontrada e pula essa linha.
• 'skip', pula linhas ruins sem aumentar ou avisar quando elas são encontradas.
Especificando tipos de dados de coluna
Você pode indicar o tipo de dados para todo o DataFrame ou colunas individuais:
Em [14]: dados = "a,b,c,d\n1,2,3,4\n5,6,7,8\n9,10,11"
Em [15]: imprimir(dados) a,b,c,d

1,2,3,4
5,6,7,8
9,10,11
Em [16]: df = pd.read_csv(StringIO(dados), dtype=objeto)
Em [17]: df
Fora[17]:
abc 0 1 3 1 5 d
8 2 4
6 7
2 9 10 11 NaN

Em [18]: df["a"][0]
Fora[18]: '1'
Em [19]: df = pd.read_csv(StringIO(data), dtype={"b": object, "c": np.float64, "d": ÿÿ"Int64"})
In [20]: df.dtypes Out[20]:

objeto int64
a float64
b d Int64
c dtype:
objeto
Felizmente, o pandas oferece mais de uma maneira de garantir que suas colunas contenham apenas um dtype. Se você não está
familiarizado com esses conceitos, você pode ver aqui para aprender mais sobre dtypes, e aqui para aprender mais sobre conversão de
objetos em pandas.
Por exemplo, você pode usar o argumento conversores de read_csv():
Em [21]: dados = "col_1\n1\n2\n'A'\n4.22"
Em [22]: df = pd.read_csv(StringIO(dados), conversores={"col_1": str})
Em [23]: df
Saída[23]:
col_1
0 1
1 2
2 'A'
3 4,22
Em [24]: df["col_1"].apply(type).value_counts()
Out[24]:
<class 'str'> Nome: 4
col_1, dtype: int64
Ou você pode usar a função to_numeric() para coagir os dtypes após a leitura dos dados,
Em [25]: df2 = pd.read_csv(StringIO(dados))
Em [26]: df2["col_1"] = pd.to_numeric(df2["col_1"], erros = "coercer")
Entrada [27]: df2

Saída [27]:
col_1
0 1,00 1
2,00 2 NaN
3 4,22
Em [28]: df2["col_1"].apply(type).value_counts()

Fora[28]:
<classe 'float'> 4
Nome: col_1, dtype: int64
que converterá todas as análises válidas em flutuantes, deixando a análise inválida como NaN.
Em última análise, como você lida com a leitura em colunas contendo tipos mistos depende de suas necessidades específicas. Dentro do estojo
acima, se você quiser eliminar as anomalias de dados, então to_numeric() é provavelmente sua melhor opção. No entanto, se você
queria que todos os dados fossem coagidos, não importa o tipo, então usar o argumento dos conversores de read_csv() seria
certamente vale a pena tentar.
Nota: Em alguns casos, a leitura de dados anormais com colunas contendo tipos mistos resultará em um resultado inconsistente.
conjunto de dados. Se você confiar no pandas para inferir os dtypes de suas colunas, o mecanismo de análise irá inferir os dtypes para
diferentes partes dos dados, em vez de todo o conjunto de dados de uma só vez. Conseqüentemente, você pode acabar com colunas com
tipos mistos. Por exemplo,
Em [29]: col_1 = lista(intervalo(500000)) + ["a", "b"] + lista(intervalo(500000))
Em [30]: df = pd.DataFrame({"col_1": col_1})
Em [31]: df.to_csv("foo.csv")
Em [32]: mixed_df = pd.read_csv("foo.csv")
Em [33]: mixed_df["col_1"].apply(type).value_counts()
Fora[33]:
<classe 'int'> 737858
<class 'str'> 262144
Nome: col_1, dtype: int64
Em [34]: mixed_df["col_1"].dtype
Fora[34]: dtype('O')
resultará com mixed_df contendo um int dtype para certos pedaços da coluna e str para outros devido ao
dtypes mistos dos dados que foram lidos. É importante observar que a coluna geral será marcada com um dtype
do objeto, que é usado para colunas com tipos mistos.
Especificando dtype categórico
Colunas categóricas podem ser analisadas diretamente especificando dtype='category' ou

dtype=CategoricalDtype(categorias, ordenadas).
Fora[36]:
col1 col2 col3
0 a 1
a 2
12 c bbd 3

Em [37]: pd.read_csv(StringIO(dados)).dtypes
Fora[37]:
objeto col1
col2 objeto
col3 int64
dtype: objeto
Em [38]: pd.read_csv(StringIO(data), dtype="category").dtypes

Fora[38]:
categoria col1
categoria col2
categoria col3
dtype: objeto
Colunas individuais podem ser analisadas como categóricas usando uma especificação de ditado:
Em [39]: pd.read_csv(StringIO(data), dtype={"col1": "category"}).dtypes

Fora[39]:
col1 categoria
col2 objeto
col3 int64
dtype: objeto
Especificar dtype='category' resultará em um Categorical não ordenado cujas categorias são os valores únicos
observado nos dados. Para obter mais controle sobre as categorias e a ordem, crie um CategoricalDtype com antecedência e
passe isso para o dtype dessa coluna.
Em [40]: de pandas.api.types import CategoricalDtype
Em [41]: dtype = CategoricalDtype(["d", "c", "b", "a"], ordenado=True)
Em [42]: pd.read_csv(StringIO(data), dtype={"col1": dtype}).dtypes

Fora[42]:
col1 categoria
col2 objeto
col3 int64
dtype: objeto
Ao usar dtype=CategoricalDtype, valores “inesperados” fora de dtype.categories são tratados como ausentes
valores.
Em [43]: dtype = CategoricalDtype(["a", "b", "d"]) # Não 'c'
Em [44]: pd.read_csv(StringIO(data), dtype={"col1": dtype}).col1

Fora[44]:
0 a
a
1 2 NaN
Nome: col1, dtype: categoria

Categorias (3, objeto): ['a', 'b', 'd']
Isso corresponde ao comportamento de Categorical.set_categories().

Nota: Com dtype='category', as categorias resultantes sempre serão analisadas como strings (objeto dtype). Se o
as categorias são numéricas e podem ser convertidas usando a função to_numeric() ou, conforme apropriado, outro conversor
como to_datetime().
Quando dtype é um CategoricalDtype com categorias homogêneas (todas numéricas, todas datahoras, etc.), a conversão é feita
automaticamente.
Em [45]: df = pd.read_csv(StringIO(dados), dtype="categoria")
Em [46]: df.dtypes
Fora[46]:
categoria col1
categoria col2
categoria col3
dtype: objeto
Em [47]: df["col3"]
Fora[47]:
01
12
23

Categorias (3, objeto): ['1', '2', '3']
Em [48]: df["col3"].cat.categories = pd.to_numeric(df["col3"].cat.categories)
Em [49]: df["col3"]
Fora[49]:
0 1
1 2
2 3
Categorias (3, int64): [1, 2, 3]
Nomeando e usando colunas
Tratamento de nomes de colunas
Um arquivo pode ou não ter uma linha de cabeçalho. pandas assume que a primeira linha deve ser usada como nome das colunas:
Em [50]: dados = "a,b,c\n1,2,3\n4,5,6\n7,8,9"
Em [51]: imprimir(dados)
abc
1,2,3
4,5,6
7,8,9
Fora[52]:
abc

012 3
1456
2789
Ao especificar o argumento de nomes em conjunto com o cabeçalho, você pode indicar outros nomes a serem usados e se
não jogar fora a linha do cabeçalho (se houver):
abc
1,2,3
4,5,6
7,8,9
Em [54]: pd.read_csv(StringIO(data), nomes=["foo", "bar", "baz"], cabeçalho=0)

Fora[54]:
foo bar baz
0 1 2 3
1 4 6
2 7 58 9
Em [55]: pd.read_csv(StringIO(dados), nomes=["foo", "bar", "baz"], cabeçalho=Nenhum)

Fora[55]:
foo bar baz
0 abc
1 1 2 3
2 4 5 6
3 7 8 9
Se o cabeçalho estiver em uma linha diferente da primeira, passe o número da linha para o cabeçalho. Isso irá pular as linhas anteriores:
Em [56]: data = "pular isso pular\na,b,c\n1,2,3\n4,5,6\n7,8,9"
Em [57]: pd.read_csv(StringIO(dados), cabeçalho=1)

Fora[57]:
abc
0123
1456
2789
Nota: O comportamento padrão é inferir os nomes das colunas: se nenhum nome for passado, o comportamento é idêntico ao header=0
e os nomes das colunas são inferidos a partir da primeira linha não vazia do arquivo, se os nomes das colunas forem passados explicitamente, então o
o comportamento é idêntico ao header=None.

Análise de nomes duplicados
Se o arquivo ou cabeçalho contiver nomes duplicados, o pandas irá, por padrão, distinguir entre eles para evitar a
substituição de dados:
Em [58]: dados = "a,b,a\n0,1,2\n3,4,5"
Fora[59]:
ab a.1
001 2
134 5
Não há mais dados duplicados porque mangle_dupe_cols=True por padrão, que modifica uma série de colunas
duplicadas 'X', . . . , 'X' para se tornar 'X', 'X.1', . . . , 'XN'. Se mangle_dupe_cols=False, podem surgir dados duplicados:
Em [2]: dados = 'a,b,a\n0,1,2\n3,4,5'

Em [3]: pd.read_csv(StringIO(dados), mangle_dupe_cols=False)
Fora[3]:
aba 0 2
121545
Para evitar que os usuários encontrem esse problema com dados duplicados, uma exceção ValueError será gerada
se mangle_dupe_cols != True:
Em [2]: dados = 'a,b,a\n0,1,2\n3,4,5'

Em [3]: pd.read_csv(StringIO(dados), mangle_dupe_cols=False)
...
ValueError: A configuração mangle_dupe_cols=False ainda não é suportada
Filtrando colunas (usecols)
O argumento usecols permite selecionar qualquer subconjunto de colunas em um arquivo, usando os nomes das colunas, números de
posição ou uma chamada:
Em [60]: dados = "a,b,c,d\n1,2,3,foo\n4,5,6,bar\n7,8,9,baz"
Fora[61]:
abc d
012 3 foo
1 4 5 6 barras
2 7 8 9 baz
Em [62]: pd.read_csv(StringIO(dados), usecols=["b", "d"])

Saída[62]:
bd 0 2
foo 1 5
compasso
2 8 baz

Em [63]: pd.read_csv(StringIO(dados), usecols=[0, 2, 3])

Fora[63]:
ac d
0 1 3 foo 1 4 6
barra 2 7 9 baz
Em [64]: pd.read_csv(StringIO(data), usecols=lambda x: x.upper() in ["A", "C"])

Fora[64]:
ac
01314
6279
O argumento usecols também pode ser usado para especificar quais colunas não usar no resultado final:
Em [65]: pd.read_csv(StringIO(data), usecols=lambda x: x não está em ["a", "c"])

Fora[65]:
b d
0 2 foo
1 5 barras
2 8 baz
Nesse caso, o callable especifica que excluímos as colunas “a” e “c” da saída.
Comentários e linhas vazias
Ignorando comentários de linha e linhas vazias
Se o parâmetro comment for especificado, as linhas completamente comentadas serão ignoradas. Por padrão, as linhas completamente
em branco também serão ignoradas.
Em [66]: data = "\na,b,c\n \n# linha comentada\n1,2,3\n\n4,5,6"
abc
# linha comentada
1,2,3
4,5,6
Em [68]: pd.read_csv(StringIO(dados), comentário="#")

Fora[68]:
abc
012 3
1456
Se skip_blank_lines=False, então read_csv não irá ignorar linhas em branco:

Pandas: Poderoso Kit de Ferramentas de Análise de Dados Python

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Pandas: Poderoso Kit de Ferramentas de Análise de Dados Python

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

pandas: poderoso kit de ferramentas de análise de

Wes McKinney e a equipe de desenvolvimento do Pandas

2.6.3 Classificando um MultiIndex . . . . . . . . . . . . . . . .

2.18.11 Exemplos . . . . . . . . .....

2.25.6 Interação com scipy.sparse . . . . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 975

3.3.3 Conversão . . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 1446

3.7.2 Dia Útil . . . . . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2298

3.12.3 Aplicação de estilo . . . . ..... . .

4.4.7 Executando o conjunto de . . ..... . . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2827

5 Notas de versão 2857

5.1.3 Novidades em 1.4.2 (2 de abril de 2022) . . . . . . . . . . . . . ... . . . . . . . . . . . . . . 2861

5.11.3 Versão 0.20.1 (5 de maio de 2017) . . . . . . . . . . . .

Índice do módulo Python 3729

pandas: poderoso kit de ferramentas de análise de dados Python, versão 1.4.4

Data: 31 de agosto de 2022 Versão: 1.4.4

Baixe a documentação: Versão PDF | HTML compactado

Para os guias de primeiros passos

Para o guia do usuário

Para o guia de referência

Para o guia de desenvolvimento

pandas: poderoso kit de ferramentas de análise de dados Python, versão 1.4.4

Trabalhando com Conda?

conda instalar pandas

pandas pode ser instalado via pip do PyPI.

pip instalar pandas

1.2 Introdução aos pandas

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

pandas: poderoso kit de ferramentas de análise de dados Python, versão 1.4.4

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

4 Capítulo 1. Primeiros passos

pandas: poderoso kit de ferramentas de análise de dados Python, versão 1.4.4

Para o tutorial de introdução

Para o guia do usuário

Direto para o tutorial. . .

Para o tutorial de introdução

Para o guia do usuário

1.3 Vindo de. . .

1.3. Vindo de. . . 5

pandas: poderoso kit de ferramentas de análise de dados Python, versão 1.4.4