sábado, 3 de abril de 2021

Como leio e escrevo dados tabulares com pandas?

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.
  • Survived: Este recurso tem valores 0 e 1. 0 para não sobreviveu e 1 para sobreviveu.
  • Pclass: Existem 3 classes: Classe 1, Classe 2 e Classe 3.
  • Name: Nome do passageiro.
  • Sex: gênero do passageiro.
  • Age: Idade do passageiro.
  • SibSp: Indicação de que o passageiro tem irmãos e cônjuge.
  • Parch: se o passageiro está sozinho ou tem família.
  • Ticket: Número do bilhete do passageiro.
  • Fare: Indicando a tarifa.
  • Cabin: A cabine do passageiro.
  • Embarked: a categoria embarcada.

O arquivo csv pode ser baixado aqui.

  • Quero analisar os dados dos passageiros do Titanic, disponíveis como um arquivo CSV.

    In [2]: titanic = pd.read_csv("data/titanic.csv")
    

    O pandas fornece a função read_csv() que ler dados armazenados num arquivo csv e com os dados desse arquivo cria um DataFrame pandas. O pandas suporta muitos formatos de arquivo ou fontes de dados diferentes fora da caixa (csv, excel, sql, json, parquet, ...), cada um deles com o prefixo read_*.

Certifique-se de sempre verificar os dados após lê-los. Ao exibir um DataFrame, a primeira e as últimas 5 linhas serão mostradas por padrão:

In [3]: titanic
Out[3]: 
     PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
0              1         0       3  ...   7.2500   NaN         S
1              2         1       1  ...  71.2833   C85         C
2              3         1       3  ...   7.9250   NaN         S
3              4         1       1  ...  53.1000  C123         S
4              5         0       3  ...   8.0500   NaN         S
..           ...       ...     ...  ...      ...   ...       ...
886          887         0       2  ...  13.0000   NaN         S
887          888         1       1  ...  30.0000   B42         S
888          889         0       3  ...  23.4500   NaN         S
889          890         1       1  ...  30.0000  C148         C
890          891         0       3  ...   7.7500   NaN         Q

[891 rows x 12 columns]
  • Quero ver as primeiras 8 linhas de um DataFrame do pandas.

    In [4]: titanic.head(8)
    Out[4]: 
       PassengerId  Survived  Pclass                                               Name  ...            Ticket     Fare  Cabin  Embarked
    0            1         0       3                            Braund, Mr. Owen Harris  ...         A/5 21171   7.2500    NaN         S
    1            2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  ...          PC 17599  71.2833    C85         C
    2            3         1       3                             Heikkinen, Miss. Laina  ...  STON/O2. 3101282   7.9250    NaN         S
    3            4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  ...            113803  53.1000   C123         S
    4            5         0       3                           Allen, Mr. William Henry  ...            373450   8.0500    NaN         S
    5            6         0       3                                   Moran, Mr. James  ...            330877   8.4583    NaN         Q
    6            7         0       1                            McCarthy, Mr. Timothy J  ...             17463  51.8625    E46         S
    7            8         0       3                     Palsson, Master. Gosta Leonard  ...            349909  21.0750    NaN         S
    
    [8 rows x 12 columns]
    

    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.

Observação

Em vez disso, está interessado nas últimas N linhas? pandas também fornece o método tail(). Por exemplo, titanic.tail(10) retornará as últimas 10 linhas do DataFrame.

Uma verificação de como o pandas interpreta cada um dos tipos de dados da coluna pode ser feita solicitando o atributo dtypes do pandas:

In [5]: titanic.dtypes
Out[5]: 
PassengerId      int64
Survived         int64
Pclass           int64
Name            object
Sex             object
Age            float64
SibSp            int64
Parch            int64
Ticket          object
Fare           float64
Cabin           object
Embarked        object
dtype: object

Para cada uma das colunas, o tipo de dados usado é listado. Os tipos de dados DataFrame são integers (int64), floats (float64) e strings (object).

Observação

Ao solicitar o atributo dtypes, não são usados ​​colchetes! dtypes é um atributo do DataFrame e das Series. Os atributos do DataFrame ou Series não precisam de colchetes. Os atributos representam uma característica de um DataFrame / Series, 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 uma planilha.

    In [6]: titanic.to_excel("titanic.xlsx", sheet_name="passengers", index=False)
    

    Enquanto as funções com o prefixo read_* são usadas para ler dados e criar um DataFrame ou Series pandas, os métodos com o prefixo to_* são usados ​​para armazenar um DataFrame ou Series num arquivo (por exemplo, CSV ou xls). O método to_excel() armazena os dados como um arquivo Excel. No exemplo aqui, o sheet_name é nomeado passengers em vez do padrão Sheet1 . Ao definir o índice de linha como index=False, os rótulos não são salvos na planilha.

A função de leitura equivalente read_excel() recarregará os dados em um DataFrame:

In [7]: titanic = pd.read_excel("titanic.xlsx", sheet_name="passengers")
In [8]: titanic.head()
Out[8]: 
   PassengerId  Survived  Pclass                                               Name  ...            Ticket     Fare  Cabin  Embarked
0            1         0       3                            Braund, Mr. Owen Harris  ...         A/5 21171   7.2500    NaN         S
1            2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  ...          PC 17599  71.2833    C85         C
2            3         1       3                             Heikkinen, Miss. Laina  ...  STON/O2. 3101282   7.9250    NaN         S
3            4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  ...            113803  53.1000   C123         S
4            5         0       3                           Allen, Mr. William Henry  ...            373450   8.0500    NaN         S

[5 rows x 12 columns]
  • Estou interessado em um resumo técnico de um DataFrame.

    In [9]: titanic.info()
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 12 columns):
     #   Column       Non-Null Count  Dtype  
    ---  ------       --------------  -----  
     0   PassengerId  891 non-null    int64  
     1   Survived     891 non-null    int64  
     2   Pclass       891 non-null    int64  
     3   Name         891 non-null    object 
     4   Sex          891 non-null    object 
     5   Age          714 non-null    float64
     6   SibSp        891 non-null    int64  
     7   Parch        891 non-null    int64  
     8   Ticket       891 non-null    object 
     9   Fare         891 non-null    float64
     10  Cabin        204 non-null    object 
     11  Embarked     889 non-null    object 
    dtypes: float64(2), int64(5), object(5)
    memory usage: 83.7+ KB
    

    O método info() fornece informações técnicas sobre o DataFrame, então vamos explicar a saída com mais detalhes:

    • É realmente um DataFrame.

    • Existem 891 entradas, ou seja, 891 linhas.

    • Cada linha possui um rótulo de linha (também conhecido como index) com valores que variam de 0 a 890.

    • A tabela possui 12 colunas. A maioria das colunas tem um valor para cada uma das linhas (todos os 891 valores têm non-null). Algumas colunas têm valores ausentes e menos de 891 non-nullvalores.

    • As colunas Name, Sex, Cabine Embarkedconsiste de dados textuais (cordas, aka object). As outras colunas são dados numéricos com alguns deles números inteiros (aka integer) e outros são números reais (aka float)

    • O tipo de dados (caracteres, inteiros, ...) nas diferentes colunas são resumidos listando o dtypes.

    • A quantidade aproximada de RAM usada para armazenar o DataFrame também é fornecida.

LEMBRAR

  • A obtenção de dados para o pandas de muitos formatos de arquivo ou fontes de dados diferentes é suportada por funções read_*.

  • A exportação de dados de pandas é fornecida por diferentes métodos com prefixo to_*.

  • Os métodos head / tail / info e o atributo dtypes são convenientes para uma primeira verificação.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

Que tipo de dados podemos manipular com pandas?

  • Eu quero começar a usar pandas

    In [1]: import pandas as pd

    Para carregar o pacote pandas e começar a trabalhar com ele, importe o pacote. O apelido aceito pela comunidade para os pandas é pd, portanto, carregar o pandas com o apelido pd é uma prática padrão assumida para toda a documentação dos pandas.

representação da tabela de dados do pandas

  • Quero armazenar os dados dos passageiros do Titanic. Para vários passageiros, conheço os dados de nome (caracteres), idade (inteiros) e sexo (masculino / feminino).

    In [2]: df = pd.DataFrame(
       ...:     {
       ...:         "Name": [
       ...:             "Braund, Mr. Owen Harris",
       ...:             "Allen, Mr. William Henry",
       ...:             "Bonnell, Miss. Elizabeth",
       ...:         ],
       ...:         "Age": [22, 35, 58],
       ...:         "Sex": ["male", "male", "female"],
       ...:     }
       ...: )
       ...: 
    
    In [3]: df
    Out[3]: 
                           Name  Age     Sex
    0   Braund, Mr. Owen Harris   22    male
    1  Allen, Mr. William Henry   35    male
    2  Bonnell, Miss. Elizabeth   58  female

    Para armazenar dados manualmente em uma tabela, crie um DataFrame. Ao usar um dicionário de listas Python, as colchetes do dicionário serão usadas 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 mais) em colunas. É semelhante a uma planilha, uma tabela SQL ou o data.frame em R.

  • A tabela possui 3 colunas, cada uma delas com um rótulo de coluna. Os rótulos das colunas são Name, Age e Sex, respectivamente.

  • A coluna Name consiste em dados textuais com cada valor com uma string, a coluna Age são números e a coluna Sex são dados textuais.

No software de planilha, a representação da tabela de nossos dados seria muito semelhante:

Cada coluna no DataFrame é uma Series

  • Estou apenas interessado em trabalhar com os dados da coluna Age.

    In [4]: df["Age"]
    Out[4]: 
    0    22
    1    35
    2    58
    Name: Age, dtype: int64
    

    Ao selecionar uma única coluna do DataFrame pandas, o resultado são Series pandas. Para selecionar a coluna, use o rótulo da coluna entre colchetes [].

Observação

Se você estiver familiarizado com os dicionários Python, a seleção de uma única coluna é muito semelhante à seleção dos valores do dicionário com base no colchete.

Você também pode criar uma Series do zero:

In [5]: ages = pd.Series([22, 35, 58], name="Age")

In [6]: ages
Out[6]: 
0    22
1    35
2    58
Name: Age, dtype: int64

Uma Series pandas não tem rótulos de coluna, pois é apenas uma coluna de um DataFrame. A Series tem rótulos de linha.

Faça algo com um DataFrame ou Série

  • Eu quero saber a idade máxima dos passageiros.

    Podemos fazer isso no DataFrame selecionando a coluna Age e aplicando max():

    In [7]: df["Age"].max()
    Out[7]: 58
    

    Ou para a Series:

    In [8]: ages.max()
    Out[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 Series. Como os métodos são funções, não se esqueça de usar parênteses ().

  • Estou interessado em algumas estatísticas básicas dos dados numéricos da minha tabela de dados.

    In [9]: df.describe()
    Out[9]: 
                 Age
    count   3.000000
    mean   38.333333
    std    18.230012
    min    22.000000
    25%    28.500000
    50%    35.000000
    75%    46.500000
    max    58.000000
    

    O método describe() fornece uma visão geral rápida dos dados numéricos em um DataFrame. Como as colunas Name e Sex são dados textuais, eles, por padrão, não são considerados pelo método describe().

Muitas operações do pandas retornam um DataFrame ou uma Series. O método describe() é um exemplo de uma operação de pandas retornando uma Series pandas.

Observação

Isto é só 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!

LEMBRAR

  • Importe o pacote, também conhecido como import pandas as pd.

  • Uma tabela de dados é armazenada como um pandas DataFrame.

  • Cada coluna em um DataFrame é uma Series.

  • Você pode fazer coisas aplicando um método a um DataFrame ou Series.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

Visão geral do pacote pandas

pandas é um pacote Python que fornece estruturas de dados rápidas, flexíveis e expressivas projetadas para tornar o trabalho com dados "relacionais" ou "rotulados" fácil e intuitivo. Ele tem como objetivo ser o bloco de construção fundamental de alto nível para fazer análises de dados práticas e do mundo real em Python. Além disso, tem o objetivo mais amplo de se tornar a ferramenta de análise / manipulação de dados de código aberto mais poderosa e flexível disponível em qualquer linguagem. Já está a caminho dessa meta.

O pandas é adequado para muitos tipos diferentes de dados:

  • Dados tabulares com colunas digitadas de forma heterogênea, como em uma tabela SQL ou planilha do Excel.

  • Dados de série temporal ordenados e não ordenados (não necessariamente de frequência fixa).

  • Dados de matriz arbitrária (homogeneamente tipados ou heterogêneos) 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 uma estrutura de dados do pandas.

As duas estruturas de dados primárias do pandas, Series (1-dimensional) e DataFrame (2-dimensional), lidam com a grande maioria dos casos de uso típicos em finanças, estatística, ciências sociais e muitas áreas da engenharia. Para usuários do R, DataFrame oferece tudo o que o R data.frame oferece e muito mais. O pandas é construído em cima do NumPy e se destina a se integrar 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 manuseio de dados ausentes (representados como NaN) em ponto flutuante, bem como dados de ponto não flutuante.

  • Mutabilidade de tamanho: as colunas podem ser inseridas e excluídas do DataFrame e objetos de dimensão superior.

  • Automática e explícita alinhamento de dados: objetos podem ser explicitamente alinhado a um conjunto de etiquetas, ou o usuário pode simplesmente ignorar os rótulos e deixe Series, DataFrame, etc. alinhar automaticamente os dados para você em cálculos.

  • Grupo poderoso e flexível por funcionalidades para executar operações dividir-aplicar-combinar em conjuntos de dados, para agregar e transformar dados.

  • Facilite a conversão de dados irregulares e indexados de forma diferente em outras estruturas de dados Python e NumPy em objetos DataFrame.

  • Inteligente, baseada em rótulo de corte, a indexação de fantasia, e subconjuntos de grandes conjuntos de dados.

  • Intuitiva fusão e concatenação de conjuntos de dados.

  • Remodelagem flexível e dinamização de conjuntos de dados.

  • Rotulagem hierárquica de eixos (possível ter vários rótulos por marca).

  • Ferramentas de IO robustas 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 de série temporal: 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 usando outras linguagens / ambientes de pesquisa científica. Para cientistas de dados, trabalhar com dados é normalmente dividido em vários estágios: munging e limpeza de dados, análise / modelagem e, em seguida, organização dos resultados da análise em uma forma adequada para plotagem ou exibição tabular. O 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 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.

  • O pandas é uma dependência de modelos de estatísticas, o que o torna uma parte importante do ecossistema de computação estatística em Python.

  • O pandas tem sido amplamente utilizado na produção em aplicações financeiras.

Estruturas de dados

Dimensões

Nome

Descrição

1

Series

Array de tipagem homogênea rotulada 1D

2

Quadro de dados

Estrutura tabular de tamanho mutável rotulado em 2D geral com coluna com tipagem potencialmente heterogênea.

Por que mais de uma estrutura de dados?

A melhor maneira de pensar sobre as estruturas de dados do pandas é como contêineres flexíveis para dados dimensionais 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 razoáveis ​​para as funções API comuns que levassem em consideração 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, o usuário tem que 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 têm como objetivo dar mais significado semântico aos dados; ou seja, para um determinado conjunto de dados, é provável que haja uma maneira “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 nas funções downstream.

Por exemplo, com dados tabulares (DataFrame) é mais semanticamente útil pensar no índice (as linhas) e nas colunas, em vez do eixo 0 e eixo 1. Iterando pelas colunas do DataFrame, portanto, resulta em um código mais legível:

for col in df.columns:
    series = df[col]
    # faça algo com series

Mutabilidade e cópia de dados

Todas as estruturas de dados do pandas são mutáveis ​​em valor (os valores que contêm podem ser alterados), mas nem sempre podem ser mutáveis ​​em tamanho. O comprimento de uma série não pode ser alterado, mas, por exemplo, as colunas podem ser inseridas em um DataFrame. No entanto, a grande maioria dos métodos produz novos objetos e não altera os dados de entrada. Em geral, gostamos de favorecer a imutabilidade onde for sensato.

Obtendo suporte

A primeira parada para questões e ideias sobre pandas é o Rastreador de Problemas do Github. Se você tiver uma pergunta 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 os pandas de código aberto possíveis. 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.

Governança do projeto

O processo de governança que o projeto pandas tem usado informalmente desde seu início em 2008 é formalizado nos documentos de governança do projeto. Os documentos esclarecem como as decisões são tomadas e como os vários elementos de 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 para a Vida (BDFL).

Equipe de desenvolvimento

A lista dos membros da Equipe Central e informações mais detalhadas podem ser encontradas na página de pessoas do repo de governança.

Parceiros institucionais

As informações sobre os atuais parceiros institucionais podem ser encontradas na página do site do pandas.

Licença

BSD 3-Clause License

Copyright (c) 2008-2011, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
All rights reserved.

Copyright (c) 2011-2020, Open source contributors.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

Instalação do pandas

A maneira mais fácil de instalar o pandas é instalá-lo como parte da distribuição Anaconda, uma distribuição de plataforma cruzada para análise de dados e computação científica. Este é o método de instalação recomendado para a maioria dos usuários.

Também são fornecidas instruções para instalar a partir do código-fonte, PyPI, ActivePython, várias distribuições Linux ou uma versão de desenvolvimento.

Suporte à versão Python

Oficialmente Python 3.7.1 e superior, 3.8 e 3.9.

Instalando pandas

Instalando com o Anaconda

Instalar o pandas e o resto da pilha do NumPy e do SciPy pode ser um pouco difícil para usuários inexperientes.

A maneira mais simples de instalar não apenas pandas, mas Python e os pacotes mais populares que compõem a pilha SciPy ( IPython, NumPy, Matplotlib, ...) é com Anaconda, uma distribuição Python de plataforma cruzada (Linux, macOS, Windows) para dados análise e computação científica.

Após executar o instalador, o usuário terá acesso ao pandas e ao resto da pilha do SciPy sem precisar instalar mais nada e sem precisar esperar que qualquer software seja compilado.

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 pessoal do usuário, o que torna trivial excluir o Anaconda se você decidir (apenas exclua essa pasta).

Instalando com Miniconda

A seção anterior descreveu como instalar o pandas como parte da distribuição do 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.

Se você deseja ter mais controle sobre quais pacotes, ou tem uma largura de banda limitada da Internet, instalar o pandas com o Miniconda pode ser uma solução melhor.

Conda é o gerenciador de pacotes sobre o qual a distribuição do Anaconda é construída. É um gerenciador de pacotes que é multiplataforma e agnóstico de linguagem (pode desempenhar uma função semelhante a uma combinação de pip e virtualenv).

O Miniconda permite que você crie uma instalação autônoma mínima do Python e, em seguida, use o comando Conda para instalar pacotes adicionais.

Primeiro, você precisa que o Conda esteja instalado e o download e a execução do Miniconda fará isso para 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 create -n name_of_my_env python

Isso criará um ambiente mínimo com apenas Python instalado. Para se colocar dentro desse ambiente, execute:

source activate name_of_my_env

No Windows, o comando é:

activate name_of_my_env

A etapa final necessária é instalar o pandas. Isso pode ser feito com o seguinte comando:

conda install pandas

Para instalar uma versão específica do pandas:

conda install pandas=0.20.3

Para instalar outros pacotes, IPython por exemplo:

conda install ipython

Para instalar a distribuição Anaconda completa:

conda install anaconda

Se você precisa de pacotes que estão disponíveis para o pip, mas não para o conda, instale o pip e use o pip para instalar esses pacotes:

conda install pip
pip install django

Instalando a partir do PyPI

pandas pode ser instalado via pip do PyPI.

pip install pandas

Instalando com ActivePython

As instruções de instalação para ActivePython podem ser encontradas aqui. As versões 2.7, 3.5 e 3.6 incluem pandas.

Instalando usando o gerenciador de pacotes de sua distribuição Linux

Os comandos nesta tabela irão instalar o pandas para Python 3 de sua distribuição.

Distribuição

Status

Link para download/repositório

Método de instalação

Debian

estável

repositório oficial do Debian

sudo apt-get install python3-pandas

Debian e Ubuntu

instável (pacotes mais recentes)

NeuroDebian

sudo apt-get install python3-pandas

Ubuntu

estável

repositório oficial do Ubuntu

sudo apt-get install python3-pandas

OpenSuse

estável

Repositório OpenSuse

zypper in python3-pandas

Fedora

estável

repositório oficial do Fedora

dnf install python3-pandas

Centos / RHEL

estável

Repositório EPEL

yum install python3-panda

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.

Manipulando ImportErrors

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 que procura, para encontrar pacotes. Você pode obter esses diretórios com:

import sys
sys.path

Uma maneira de encontrar esse erro é se você tiver várias instalações do Python em seu sistema e não tiver o pandas instalado na instalação do Python que está usando no momento. No Linux / Mac você pode rodar no seu terminal which python e ele vai te dizer 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 recomendável usar conda, para instalação rápida e para atualizações de pacotes e dependências. Você pode encontrar instruções de instalação simples para pandas neste documento: installation instructions </getting_started.html>

Instalando da fonte

Consulte o guia de contribuição para obter instruções completas sobre como compilar a partir da árvore de origem do git. Além disso, consulte a criação de um ambiente de desenvolvimento se desejar criar um ambiente de desenvolvimento do pandas.

Executando o conjunto de testes

O pandas está equipado com um conjunto exaustivo de testes de unidade, cobrindo cerca de 97% da base de código até o momento desta escrita. Para executá-lo em sua máquina para verificar se tudo está funcionando (e se você tem todas as dependências, soft e hard, instaladas), certifique-se de ter pytest > = 5.0.1 e Hypothesis > = 3.58, em seguida, execute:

>>> pd.test()
running: pytest --skip-slow --skip-network C:\Users\TP\Anaconda3\envs\py36\lib\site-packages\pandas
============================= test session starts =============================
platform 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
collected 12145 items / 3 skipped

..................................................................S......
........S................................................................
.........................................................................

==================== 12130 passed, 12 skipped in 368.339 seconds =====================

Dependências

Pacote

Versão mínima suportada

ferramentas de instalação

24.2.0

NumPy

1,16.5

python-dateutil

2.7.3

pytz

2017.3

Dependências recomendadas

  • numexpr: para acelerar certas operações numéricas. numexpr usa vários núcleos, bem como chunking e cache inteligentes para alcançar grandes acelerações. Se instalado, deve ser a versão 2.6.8 ou superior.

  • bottleneck:: para acelerar certos tipos de avaliações nan. bottleneck usa rotinas de cython especializadas para alcançar grandes acelerações. Se instalado, deve ser a versão 1.2.1 ou superior.

Observação

É altamente recomendável instalar essas bibliotecas, pois elas fornecem melhorias de velocidade, especialmente ao trabalhar com grandes conjuntos de dados.

Dependências opcionais

O 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 a dependência opcional não estiver instalada, o pandas lançará um ImportError quando o método que requer essa dependência for chamado.

Dependência

Versão Mínima

Notas

BeautifulSoup4

4.6.0

Analisador de HTML para read_html (ver nota )

Jinja2

2,10

Formatação condicional com DataFrame.style

PyQt4

E/S da área de transferência

PyQt5

E/S da área de transferência

PyTables

3.5.1

Leitura/gravação baseada em HDF5

SQLAlchemy

1.3.0

Suporte SQL para bancos de dados diferentes de sqlite

SciPy

1.12.0

Funções estatísticas diversas

xlsxwriter

1.0.2

Escrita em Excel

blosc

1.17.0

Compressão para HDF5

fsspec

0.7.4

Manipulação de arquivos além de local e HTTP

fastparquet

0.4.0

Leitura / escrita em parquet

gcsfs

0,6.0

Acesso ao Google Cloud Storage

html5lib

1.0.1

Analisador de HTML para read_html (ver nota )

lxml

4.3.0

Analisador de HTML para read_html (ver nota )

matplotlib

2.2.3

Visualização

numba

0,46,0

Mecanismo de execução alternativo para operações rotativas

openpyxl

2.6.0

Leitura / gravação de arquivos xlsx

pandas-gbq

0,12,0

Acesso ao Google Big Query

psycopg2

2,7

Motor PostgreSQL para sqlalchemy

pyarrow

0,15,0

Parquet, ORC e ​​leitura / escrita de penas

pymysql

0.8.1

Motor MySQL para sqlalchemy

pyreadstat

Leitura de arquivos SPSS (.sav)

pyxlsb

1.0.6

Leitura de arquivos xlsb

qtpy

E / S da área de transferência

s3fs

0.4.0

Acesso Amazon S3

tabular

0.8.3

Impressão em formato compatível com Markdown (consulte a tabela )

raio x

0.12.3

API pandas-like para dados N-dimensionais

xclip

E / S da área de transferência no Linux

xlrd

1.2.0

Leitura de Excel

xlwt

1.3.0

Escrita em Excel

xsel

E / S da área de transferência no Linux

zlib

Compressão para HDF5

Dependências opcionais para analisar HTML

Uma das seguintes combinações de bibliotecas é necessária para usar a função de nível superior read_html():

Aviso

Traduzido por Acervo Lima. O original pode ser acessado aqui.

sexta-feira, 2 de abril de 2021

Começando em pandas

Instalação

Trabalhando com conda?

O pandas faz parte da distribuição do Anaconda e pode ser instalado com o Anaconda ou Miniconda:

conda install pandas

Prefere pip?

pandas podem ser instalados via pip do PyPI.

pip install pandas

Instruções detalhadas?

Instalando uma versão específica? Instalando da fonte? Verifique a página de instalação avançada.

Introdução ao pandas

Que tipo de dados podemos manipular com pandas?

Ao trabalhar com dados tabulares, como dados armazenados em planilhas ou bancos de dados, o pandas é a ferramenta certa para você. O pandas irá ajudá-lo a explorar, limpar e processar seus dados. No pandas, uma tabela de dados é chamada de DataFrame.

Como leio e escrevo dados tabulares?

O pandas suporta a integração com muitos formatos de arquivo ou fontes de dados fora da caixa (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.

Leitura e escrita de dados com pandas

Como seleciono um subconjunto de uma tabela?

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 de que você precisa estão disponíveis no pandas.

Selecionando subconjuntos com pandas

Como criar um gráfico com pandas?

pandas fornece plotagem de seus dados fora da caixa, usando o poder do Matplotlib. Você pode escolher o tipo de gráfico (dispersão, barra, boxplot, ...) correspondente aos seus dados.

Criando um gráfico com pandas

Como criar novas colunas derivadas de colunas existentes?

Não há necessidade de percorrer todas as linhas de sua tabela de dados para fazer cálculos. As manipulações de dados em uma coluna funcionam de forma elementar. Adicionar uma coluna a um DataFrame com base nos dados existentes em outras colunas é simples.

Adicionando colunas a um dataframe

Como calcular estatísticas resumidas?

As estatísticas básicas (média, mediana, mínimo, máximo, contagens ...) são facilmente calculáveis. Essas agregações personalizadas podem ser aplicadas em todo o conjunto de dados, uma janela deslizante dos dados ou agrupados por categorias. A última também é conhecida como abordagem dividir-aplicar-combinar.

estatísticas resumidas com pandas

Como remodelar o layout das tabelas?

Altere a estrutura de sua tabela de dados de várias maneiras. Você pode fundir (melt()) sua tabela de dados de formato largo para longo / organizado ou girar (pivot()) de formato longo para largo. Com agregações integradas, uma tabela dinâmica é criada com um único comando.

remodelar o layout de tabelas pandas

Como combinar dados de várias tabelas?

Múltiplas tabelas podem ser concatenadas tanto em colunas quanto em linhas e operações de junção / mesclagem do tipo banco de dados são fornecidas para combinar várias tabelas de dados.

Combinar dados de várias tabelas

Como lidar com dados de série temporal?

O pandas tem ótimo suporte para séries temporais e um amplo conjunto de ferramentas para trabalhar com datas, horas e dados indexados por tempo.

Como manipular dados textuais?

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 informações úteis deles.

Vindo de...

Você está familiarizado com outro software para manipulação de dados tabulares? Aprenda as operações equivalentes do pandas em comparação com o software que você já conhece:

R

A linguagem de programação R fornece a estrutura de dados do dataframe e vários pacotes, como tidyverse e ampliar data.frames para funcionalidades de manipulação de dados convenientes semelhantes ao pandas.

SQL

Já familiarizado com SELECT, GROUP BY, JOIN, etc.? A maioria dessas manipulações SQL tem equivalentes nos pandas.

STATA

O dataset incluído no pacote de software estatístico STATA corresponde aos pandas dataframe. Muitas das operações conhecidas do STATA têm um equivalente em pandas.

SAS

O pacote de software estatístico SAS também fornece o dataset correspondente ao pandas dataframe. Além disso, as operações vetorizadas SAS, filtragem, operações de processamento de strings e muito mais têm funções semelhantes nos pandas.

Tutoriais

Para uma visão geral rápida da funcionalidade do pandas, consulte 10 Minutos para os pandas.

Você também pode consultar a folha de dicas do pandas para obter um guia sucinto sobre como manipular dados com os pandas.

A comunidade produz uma grande variedade de tutoriais disponíveis online. Parte do material é incluída nos tutoriais da comunidade contribuídos pela comunidade.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

quarta-feira, 31 de março de 2021

Um programa de exemplo usando structs em Rust

Para entender quando podemos usar structs, vamos escrever um programa que calcule a área de um retângulo. Começaremos com variáveis ​​únicas e, em seguida, refatoraremos o programa até usarmos structs.

Vamos fazer um novo projeto binário com Cargo chamado retângulos que pegará a largura e a altura de um retângulo especificado em pixels e calculará a área do retângulo. A Listagem 5-8 mostra um programa curto com uma maneira de fazer exatamente isso no src/main.rs do nosso projeto.

Nome do arquivo: src/main.rs

fn main() {
    let largura1 = 30;
    let altura1 = 50;

    println!(
        "A área do retângulo é de {} pixels quadrados.",
        area(largura1, altura1)
    );
}

fn area(largura: u32, altura: u32) -> u32 {
    largura * altura
}

Listagem 5-8: Calculando a área de um retângulo especificado por variáveis separadas de largura e altura

Agora, execute este programa usando cargo run:

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
    Finished dev [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/structs`
A área do retângulo é de 1500 pixels quadrados.

Embora a Listagem 5-8 funcione e descubra a área do retângulo chamando a função area com cada dimensão, podemos fazer melhor. A largura e a altura estão relacionadas entre si porque, juntas, elas descrevem um retângulo.

O problema com este código é evidente na assinatura de area:

fn main() {
    let largura1 = 30;
    let altura1 = 50;

    println!(
        "A área do retângulo é de {} pixels quadrados.",
        area(largura1, altura1)
    );
}

fn area(largura: u32, altura: u32) -> u32 {
    largura * altura
}

A função area deve calcular a área de um retângulo, mas a função que escrevemos tem dois parâmetros. Os parâmetros estão relacionados, mas não são expressos em nenhum lugar do nosso programa. Seria mais legível e gerenciável agrupar largura e altura. Já discutimos uma maneira de fazer isso na seção “O tipo tupla” do Capítulo 3: usando tuplas.

Refatorando com Tuplas

A Listagem 5-9 mostra outra versão de nosso programa que usa tuplas.

Nome do arquivo: src/main.rs

fn main() {
    let retangulo1 = (30, 50);

    println!(
        "A área do retângulo é de {} pixels quadrados.",
        area(retangulo1)
    );
}

fn area(dimensoes: (u32, u32)) -> u32 {
    dimensoes.0 * dimensoes.1
}

Listagem 5-9: Especificando a largura e altura do retângulo com uma tupla

Por um lado, este programa é melhor. As tuplas nos permitem adicionar um pouco de estrutura e agora estamos passando apenas um argumento. Mas, por outro lado, esta versão é menos clara: as tuplas não nomeiam seus elementos, então nosso cálculo se tornou mais confuso porque temos que indexar nas partes da tupla.

Não importa se misturamos largura e altura para o cálculo da área, mas se quisermos desenhar o retângulo na tela, isso faria diferença! Teríamos que ter em mente que largura é o índice da tupla 0 e altura é o índice da tupla 1. Se outra pessoa trabalhou neste código, ela teria que descobrir isso e mantê-lo em mente também. Seria fácil esquecer ou misturar esses valores e causar erros, porque não transmitimos o significado de nossos dados em nosso código.

Refatorando com Structs: Adicionando Mais Significado

Usamos estruturas para adicionar significado ao rotular os dados. Podemos transformar a tupla que estamos usando em um tipo de dados com um nome para o todo e também nomes para as partes, conforme mostrado na Listagem 5-10.

Nome do arquivo: src/main.rs

struct Retangulo {
    largura: u32,
    altura: u32,
}

fn main() {
    let retangulo1 = Retangulo {
        largura: 30,
        altura: 50,
    };

    println!(
        "A área do retângulo é de {} pixels quadrados.",
        area(&retangulo1)
    );
}

fn area(retangulo: &Retangulo) -> u32 {
    retangulo.largura * retangulo.altura
}

Listagem 5-10: Definindo uma estrutura Retangulo

Aqui, definimos uma estrutura e a nomeamos Retangulo. Dentro das chaves, definimos os campos como largura e altura, ambos com tipo u32. Em seguida em main, criamos uma instância específica de Retangulo que tem uma largura de 30 e uma altura de 50.

Nossa função area agora é definida com um parâmetro, que nomeamos retangulo, cujo tipo é um empréstimo imutável de uma instância da struct Retangulo. Conforme mencionado no Capítulo 4, queremos emprestar a estrutura em vez de assumir a propriedade dela. Dessa forma, main mantém sua propriedade e pode continuar usando retangulo1, razão pela qual usamos & na assinatura da função e onde chamamos a função.

A função area acessa os campos largura e altura da instância Retangulo. Nossa assinatura da função area agora diz exatamente o que queremos dizer: calcular a área de Retangulo, usando seus campos largura e altura. Isso indica que a largura e a altura estão relacionadas entre si e dá nomes descritivos aos valores em vez de usar os valores de índice de tupla de 0 e 1. Esta é uma vitória para maior clareza.

Adicionando Funcionalidade Útil com Características Derivadas

Seria bom poder imprimir uma instância de Retangulo enquanto estamos depurando nosso programa e ver os valores de todos os seus campos. A Listagem 5-11 tenta usar a macro println! como usamos nos capítulos anteriores. Isso não funcionará, no entanto.

Nome do arquivo: src/main.rs

Esse código não compila Esse código não compila.

struct Retangulo {
    largura: u32,
    altura: u32,
}

fn main() {
    let retangulo1 = Retangulo {
        largura: 30,
        altura: 50,
    };

    println!("retangulo1 is {}", retangulo1);
}

Listagem 5-11: Tentativa de imprimir uma Retangulo instância

Quando compilamos este código, obtemos um erro com esta mensagem principal:

error[E0277]: `Retangulo` doesn't implement `std::fmt::Display`

A macro println! pode fazer muitos tipos de formatação e, por padrão, as chaves indicam para println! usar a formatação conhecida como Display: saída destinada ao consumo direto do usuário final. Os tipos primitivos que vimos até agora implementam Display por padrão, porque há apenas uma maneira de mostrar um 1 ou qualquer outro tipo primitivo para um usuário. Mas com structs, a forma como a saída de println! deve ser formatada é menos clara porque há mais possibilidades de exibição: Você quer vírgulas ou não? Você quer imprimir as chaves? Todos os campos devem ser mostrados? Devido a essa ambiguidade, Rust não tenta adivinhar o que queremos e as estruturas não têm uma implementação fornecida de Display.

Se continuarmos lendo os erros, encontraremos esta nota útil:

   = help: the trait `std::fmt::Display` is not implemented for `Retangulo`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead

Vamos tentar! A chamada da macro println! agora será semelhante a println!("retangulo1 is {:?}", retangulo1);. Colocar o especificador :? dentro das chaves indica para a macro println! que queremos usar um formato de saída chamado Debug. A característica Debug nos permite imprimir nossa estrutura de uma forma que seja útil para desenvolvedores, para que possamos ver seu valor enquanto estamos depurando nosso código.

Compile o código com esta mudança. Droga! Ainda recebemos um erro:

error[E0277]: `Retangulo` doesn't implement `Debug`

Mas, novamente, o compilador nos dá uma nota útil:

   = help: the trait `Debug` is not implemented for `Retangulo`
   = note: add `#[derive(Debug)]` or manually implement `Debug`

Rust faz incluir a funcionalidade para imprimir informações de depuração, mas nós temos que explicitamente fazer essa funcionalidade disponível para a nossa struct. Para fazer isso, adicionamos a anotação #[derive(Debug)] logo antes da definição da estrutura, conforme mostrado na Listagem 5-12.

Nome do arquivo: src/main.rs

#[derive(Debug)]
struct Retangulo {
    largura: u32,
    altura: u32,
}

fn main() {
    let retangulo1 = Retangulo {
        largura: 30,
        altura: 50,
    };

    println!("retangulo1 é {:?}", retangulo1);
}

Listagem 5-12: Adicionar a anotação para derivar o traço Debug e imprimir a instância Retangulo usando formatação de depuração

Agora, quando executarmos o programa, não obteremos nenhum erro e veremos a seguinte saída:

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
    Finished dev [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/structs`
retangulo1 é Retangulo { largura: 30, altura: 50 }

Legal! Não é a saída mais bonita, mas mostra os valores de todos os campos dessa instância, o que definitivamente ajudaria durante a depuração. Quando temos estruturas maiores, é útil ter uma saída um pouco mais fácil de ler; nesses casos, podemos usar {:#?} em vez de {:?} na string println!. Quando usamos o estilo {:#?} no exemplo, a saída será semelhante a esta:

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
    Finished dev [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/structs`
retangulo1 é Retangulo {
    largura: 30,
    altura: 50,
}

Rust forneceu uma série de características para usarmos com a anotação derive que podem adicionar um comportamento útil aos nossos tipos personalizados. Essas características e seus comportamentos estão listados no Apêndice C. Cobriremos como implementar essas características com comportamento personalizado e também como criar suas próprias características no Capítulo 10.

Nossa função area é muito específica: ela apenas calcula a área dos retângulos. Seria útil vincular esse comportamento mais de perto à nossa estrutura Retangulo, porque ela não funcionará com nenhum outro tipo. Vamos ver como podemos continuar a refatorar esse código, transformando a função area em um método area definido em nosso tipo Retangulo.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

Licença