Mês: agosto 2020

O Pandas é uma das melhores bibliotecas Python para análise de dados. Esta biblioteca open source oferece estrutura de dados de alto nível com um excelente desempenho para simplificar tarefas complicadas de manipulação de dados. Sua grande variedade de ferramentas possibilita traduzir operações complexas com dados em um ou dois comandos, além de possuir métodos internos para agrupar, filtrar e combinar dados.

 

Conheça agora, os seis truques mais úteis dos Pandas para acelerar sua análise de dados.

 

1. Selecionar colunas por tipo de dados;
2. Converter cadeias de caracteres em números;
3. Detectar e manipular valores ausentes;
4. Converter um recurso numérico contínuo em um recurso categórico;
5. Criar um DataFrame a partir da área de transferência;
6. Construir um DataFrame a partir de vários arquivos.

Confira aqui o repositório no Github para obter o código-fonte.

 

1. Selecione colunas por tipos de dados

Aqui estão os tipos de dados do DataFrame Titanic:

df.dtypes

 

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

 

Digamos que você precise selecionar as colunas numéricas.

df.select_dtypes(include='number').head()

 

Isso inclui as colunas int e float. Você também pode usar esse método para:

 

• selecionar apenas colunas de objeto;
• selecionar vários tipos de dados;
• excluir certos tipos de dados.

 

# select just object columns

df.select_dtypes(include='object')

 

# select multiple data types

df.select_dtypes(include=['int', 'datetime', 'object'])

 

# exclude certain data types

df.select_dtypes(exclude='int')

 

2. Converta sequências de caracteres em números

 

Existem dois métodos para converter uma string em números no Pandas:

• O método astype()
• O método to_numeric()

Vamos criar um exemplo de DataFrame para ver a diferença.

df = pd.DataFrame({ 'product': ['A','B','C','D'],

                 'price': ['10','20','30','40'], 

                'sales': ['20','-','60','-'] 

                })

 

 

As colunas de price e sales são armazenadas como uma cadeia de caracteres e, portanto, resultam em colunas de objeto:

df.dtypes

 

product    object

price      object

sales      object

dtype: object

 

Podemos usar o primeiro método astype()para realizar a conversão na coluna de price da seguinte maneira:

 

# Use Python type

df['price'] = df['price'].astype(int)

 

# alternatively, pass { col: dtype }

df = df.astype({'price': 'int'})

 

No entanto, isso resultaria em um erro se tentássemos usá-lo na coluna de sales. Para consertar isso, podemos usar to_numeric() com o argumento errors='coerce'.

 

df['sales'] = pd.to_numeric(df['sales'], errors='coerce')

 

Agora, valores inválidos – são convertidos para  NaN e o tipo de dado é float.

 

3. Detectar e manipular valores ausentes

Uma maneira de detectar valores ausentes é usar o método info(). Veja na coluna Non-Null Count.

df.info()

 

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

 

Quando o conjunto de dados é grande, podemos contar o número de valores ausentes. df.isnull().sum() retorna o número de valores ausentes para cada coluna.

 

df.isnull().sum()

 

PassengerId      0

Survived         0

Pclass           0

Name             0

Sex              0

Age            177

SibSp            0

Parch            0

Ticket           0

Fare             0

Cabin          687

Embarked         2

dtype: int64

 

df.isnull().sum().sum() retorna o número total de valores ausentes.

 

df.isnull().sum().sum()

 

886

 

Além disso, também podemos descobrir a porcentagem de valores que estão faltando, executando: df.isna().mean()

 

PassengerId    0.000000

Survived       0.000000

Pclass         0.000000

Name           0.000000

Sex            0.000000

Age            0.198653

SibSp          0.000000

Parch          0.000000

Ticket         0.000000

Fare           0.000000

Cabin          0.771044

Embarked       0.002245

dtype: float64

 

Eliminando valores ausentes

 

Para descartar linhas se houver algum valor NaN:

df.dropna(axis = 0)

Para descartar colunas se houver algum valor NaN:

df.dropna(axis = 1)

Para descartar colunas nas quais mais de 10% dos valores estão ausentes:

df.dropna(thresh=len(df)*0.9, axis=1)

 

Substituindo valores ausentes

 

Para substituir todos os valores de NaN por um escalar:

df.fillna(value=10)

Para substituir os valores de NaN pelos valores da linha anterior:

df.fillna(axis=0, method='ffill')

Para substituir os valores de NaN pelos valores da coluna anterior:

df.fillna(axis=1, method='ffill')

Você também pode substituir os valores de NaN pelos valores da próxima linha ou coluna:

# Replace with the values in the next row

df.fillna(axis=0, method='bfill')

# Replace with the values in the next column

df.fillna(axis=1, method='bfill')

 

A outra substituição comum é trocar os valores de NaN pela média. Por exemplo, para substituir os valores de NaN na coluna Idade pela média.

 

df['Age'].fillna(value=df['Age'].mean(), inplace=True)

 

4. Converta um recurso numérico contínuo em um recurso categórico

 

Na etapa de preparação dos dados, é bastante comum combinar ou transformar recursos existentes para criar outro mais útil. Uma das maneiras mais populares é criar um recurso categórico a partir de um recurso numérico contínuo.

 

Observe a coluna Age do dataset do Titanic:

 

df['Age'].head(8)

 

0    22.0

1    38.0

2    26.0

3    35.0

4    35.0

5     NaN

6    54.0

7     2.0

Name: Age, dtype: float64

 

Age é um atributo numérico contínuo, mas se você desejar convertê-la em um atributo categórico, por exemplo, converta as idades em grupos de faixas etárias: ≤12, Teen (≤18), Adult (≤60) e Older (>60).

 

A melhor maneira de fazer isso é usando a função Pandas cut():

 

import sys

 

df['ageGroup']=pd.cut(

   df['Age'],

   bins=[0, 13, 19, 61, sys.maxsize],

   labels=['<12', 'Teen', 'Adult', 'Older']

)

 

Usar a função head(),na coluna age Group, deverá exibir as informações da coluna.

df['ageGroup'].head(8)

 

0    Adult

1    Adult

2    Adult

3    Adult

4    Adult

5      NaN

6    Adult

7      <12

Name: ageGroup, dtype: category

Categories (4, object): [<12 < Teen < Adult < Older]

 

5. Crie um DataFrame a partir da área de transferência

 

A função Pandas read_clipboard() é uma maneira muito útil de inserir dados em um DataFrame de forma rápida..

Suponha que tenhamos os seguintes dados e desejemos criar um DataFrame a partir dele:

 

    product   price

0    A         10

1    B         20

2    C         30

4    D         40

 

Só precisamos selecionar os dados e copiá-los para a área de transferência. Então, podemos usar a função para ler um DataFrame.

 

df = pd.read_clipboard ()

df

 

6. Crie um DataFrame a partir de vários arquivos

Seu dataset pode se espalhar por vários arquivos, mas você pode querer lê-lo em um único DataFrame.

Uma maneira de fazer isso é ler cada arquivo em seu próprio DataFrame, combiná-los e excluir o DataFrame original. Porém, isso seria ineficiente em memória.

Uma solução melhor é usar o módulo interno glob  (graças aos truques do Data School Pandas).

 

Neste caso, glob() estará procurando no diretório de dados, todos os arquivos CSV que começam com a palavra ” data_row_ “. O glob()recupera nomes de arquivos em uma ordem arbitrária, e é por isso que classificamos a lista usando a função sort().

 

Para dados em linha

Digamos que nosso dataset esteja distribuído por 2 arquivos em linhas: data_row_1.csv e data_row_2.csv.

 

Para criar um DataFrame a partir dos 2 arquivos:

 

files = sorted(glob('data/data_row_*.csv'))

pd.concat((pd.read_csv(file) for file in files), ignore_index=True)

 

sorted(glob('data/data_row_*.csv')) recupera nomes de arquivos. Depois disso, lemos cada um dos arquivos usando read_csv()e passamos os resultados para a função concat(), que conectará as linhas em um único DataFrame. Além disso, para evitar um valor duplicado no índice, dizemos ao concat()que ignore o index (ignore_index=True) e, em vez disso, use o índice inteiro padrão.

 

 

Para dados em colunas

Digamos que nosso dataset esteja distribuído em 2 arquivos em colunas: data_col_1.csv e data_col_2.csv.

 

Para criar um DataFrame a partir dos 2 arquivos:

files = sorted(glob('data/data_col_*.csv'))

pd.concat((pd.read_csv(file) for file in files), axis=1)

Desta vez, dizemos à função concat() para conectar ao longo do eixo das colunas.

————-

Isso é tudo!

Obrigada pela leitura e continue acompanhando nossos postagens em Data Science.

 

Texto original: B. Chen