[PYTHON] J'ai écrit le fonctionnement de base de Pandas dans Jupyter Lab (partie 2)

14e

À propos de NaN de DataFrame

import numpy as np
import pandas as pd

df = pd.read_csv('train.csv')
df.head()

Tous les enregistrements contenant NaN ont été supprimés. (l'index reste le même. Fondamentalement, l'index n'est pas réaffecté à moins que .reset_index ()

df.dropna().head()

Vous pouvez supprimer une colonne contenant NaN en prenant axis = 1 comme argument (la valeur par défaut est la ligne avec axis = 0).

n'utilisez pas beaucoup. Lors de la construction d'un modèle, il est utilisé dans la stratégie de réduction des variables (variables explicatives) qui expliquent les données sans réduire le nombre de données, mais il est peu probable que "réduise les variables explicatives car il n'y a même qu'un NaN". .. Quelles variables explicatives sont importantes pour la construction de modèles est une question très importante et prudente.

df.dropna(axis=1) .head()

En passant une liste de noms de colonnes à l'argument de sous-ensemble, seules les lignes contenant NaN dans cette colonne seront supprimées.

Il vous suffit de déposer la ligne NaN dans une colonne particulière. N'oubliez pas que c'est très pratique.

Bien sûr, .dropna () n'écrase pas le df d'origine. Si vous souhaitez mettre à jour le df d'origine, réaffectez-le avec le familier inplace = True ou df = df.dropna ().

df.dropna(subset=['Age']).head() ###index=888 est abandonné.

.fillna(value)

Attribuez une valeur spécifique à NaN.

df.fillna('THIS IS IT').head()

Remplacez la valeur moyenne de la colonne par NaN contenu dans une colonne spécifique

df['Age'].mean()

29.69911764705882

df['Age'].fillna(df['Age'].mean()).head()

0    22.0
1    38.0
2    26.0
3    35.0
4    35.0
Name: Age, dtype: float64

df['Age'] = df['Age'].fillna(df['Age'].mean())

df.head()

pd.isna(df).head()

Remplacez le résultat du jugement NaN de Cabin en utilisant la colonne Cabin_nan

df['Cabin_nan'] = pd.isna(df['Cabin']) df

15e

groupby avec la fonction .groupby () ()

df = pd.read_csv('train.csv')
df.head()

Regrouper par dans Pclass

Étant donné que df.groupby ('Pclass') seul ne sait pas quoi faire après le regroupement et le regroupement, appelez des fonctions telles que .mean () et .count ().

df.groupby('Pclass').mean()

df = df[df['Pclass']==1]
df.head()

Prenez des statistiques pour chaque colonne avec 'Pclass' == 1

df[df['Pclass']==1].describe()

Extraire seulement signifie

Il est difficile de les supprimer un par un, c'est donc une bonne idée d'utiliser .groupby () pour les voir tous ensemble.

df[df['Pclass']==1].describe().loc['mean']

PassengerId    461.597222
Survived         0.629630
Pclass           1.000000
Age             38.233441
SibSp            0.416667
Parch            0.356481
Fare            84.154687
Name: mean, dtype: float64

Après groupby, prenez la valeur spécifiée pour by, qui est le premier argument de groupby, dans index. Dans l'exemple ci-dessus, il s'agit de la valeur de Pclass (1, 2, 3). Bien sûr, le résultat de grouby est également un DataFrame, vous pouvez donc récupérer un groupe spécifique de Series avec .loc [].

df.groupby('Pclass').mean().loc[1]

PassengerId    461.597222
Survived         0.629630
Age             38.233441
SibSp            0.416667
Parch            0.356481
Fare            84.154687
Name: 1, dtype: float64

df.groupby('Pclass').count().loc[1] #count()Et somme()Etc. sont également possibles

PassengerId    216
Survived       216
Name           216
Sex            216
Age            186
SibSp          216
Parch          216
Ticket         216
Fare           216
Cabin          176
Embarked       214
Name: 1, dtype: int64

df.groupby('Pclass').describe()

df.groupby('Pclass').describe()['Age'] #J'ai sorti seulement Age

Dans Jupyter, si les colonnes et les lignes du DataFrame ne peuvent pas être affichées, elles seront omises.

Si vous souhaitez afficher toutes les colonnes (ou toutes les lignes) sans les omettre, vous pouvez empêcher leur omission en exécutant ce qui suit.

#Afficher sans omettre de colonnes
pd.set_option('display.max_columns', None)
#Afficher sans omettre de lignes
pd.set_option('display.max_rows', None)

Transformez le résultat de group by avec une instruction for

for i, group_df in df.groupby('Pclass'):
    print("{}: group_df's type is {} and has {}".format(i, type(group_df), len(group_df)))

1: group_df's type is <class 'pandas.core.frame.DataFrame'> and has 216
2: group_df's type is <class 'pandas.core.frame.DataFrame'> and has 184
3: group_df's type is <class 'pandas.core.frame.DataFrame'> and has 491

Numéroter le tarif le plus élevé pour chaque enregistrement dans chaque groupe Pclass

df = pd.read_csv('train.csv')
results = []
for i, group_df in df.groupby('Pclass'):
    sorted_group_df = group_df.sort_values('Fare')
    sorted_group_df['RankInClass'] = np.arange(len(sorted_group_df))
    results.append(sorted_group_df)

results_df = pd.concat(results)
results_df.head()

Joindre la table

Il existe deux principaux types de jointures de table.

Rejoindre en utilisant une colonne ou un index spécifique comme clé

Combinez simplement (ou verticalement) les DataFrames horizontalement (ou verticalement)

import pandas as pd

df1 = pd.DataFrame({'Key':['k0','k','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key':['k0','k1','k2'],
                   'C':['c0','c2','c3'],
                   'D':['d0','d1','d2']})

df1

df2

Les deux ont une colonne appelée «Clé» et leurs valeurs sont les mêmes.

Les autres colonnes ont des valeurs différentes. Cette colonne appelée "Key" est utilisée comme clé pour joindre deux DataFrames horizontalement. Utilisez .merge () pour la fusion.

df1.merge(df2)

Combinez simplement (ou verticalement) les DataFrames horizontalement (ou verticalement)

Utilisez pd.concat () concat = concatenate

#Vertical (souvent utilisé)
pd.concat([df1,df2], axis=0) #La valeur par défaut est axis=0

/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.

To accept the future behavior, pass 'sort=False'.

To retain the current behavior and silence the warning, pass 'sort=True'.

#côté
pd.concat([df1,df2], axis=1)

16e

Comment utiliser .merge ()

comment: comment combiner → {«gauche», «droite», «externe», «interne»}, la valeur par défaut est «interne»

Spécifiez la colonne sur laquelle se trouver: key (colonne qui existe dans les deux DataFrames). S'il n'est pas spécifié, ils seront joints dans une colonne commune.

left_on: Colonne pour être la clé du DataFrame gauche

right_on: Colonne pour être la clé du DataFrame droit

left_index: spécifiez True lors de la définition de la clé de gauche sur index

right_index: spécifiez True lors de la définition de la clé de droite à indexer

how

df1

df2

df1.merge(df2, how='left')

df1.merge(df2, how='outer')

df1.merge(df2, how='inner')

on

L'argument on spécifie quelle colonne doit être utilisée comme clé lors de la jonction. Vous ne pouvez spécifier que les colonnes qui se trouvent à la fois dans le tableau de gauche et dans le tableau de droite.

S'il y a une colonne commune, cette colonne sera la clé et sera combinée sans rien spécifier, mais spécifions les bases. C'est facile à comprendre et sûr. On dit souvent qu '«ils ont été réunis dans une colonne inattendue». S'il y a plusieurs colonnes communes, vous ne savez pas quelle colonne sera jointe, et même s'il n'y a qu'une seule colonne commune, il vaut mieux la spécifier. (Étant donné que les exemples jusqu'à présent étaient avant l'explication de on, je l'ai volontairement écrit sans spécifier l'argument on.)

Pour définir index sur Key, définissez right_index et left_index décrits plus loin sur True. Si les noms de colonne de chaque table (DataFrame) sont différents, spécifiez left_on et right_on décrits plus loin.

df1 = pd.DataFrame({'Key':['k0','k1','k2'],
                    'ID':['aa','bb','cc'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key':['k0','k1','k3'],
                    'ID':['aa','bb','cc'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})

df1.merge(df2, on='Key')

df1.merge(df2, on='ID')

Changer le suffixe

df1.merge(df2, on='ID', suffixes=('_left', '_right'))

left_on, right_on

Spécifiez cet argument lorsque le nom de la colonne que vous souhaitez utiliser comme clé est différent entre la gauche et la droite.

df1 = pd.DataFrame({'Key1':['k0','k1','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key2':['k0','k1','k3'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})

df1.merge(df2, left_on='Key1', right_on='Key2')

left_index, right_index

Si vous souhaitez spécifier Index comme clé au lieu de colonne, spécifiez True pour left_index et right_index.

df1.merge(df2, left_index=True, right_index=True)

join

Si vous utilisez la fonction de jointure, elle se joindra par index, mais vous n'avez pas besoin de vous en souvenir car vous pouvez faire presque la même chose avec la fusion.

df1 = pd.DataFrame({'Key1':['k0','k1','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key2':['k0','k1','k3'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})

df1.join(df2)

df1.merge(df2, left_index=True, right_index=True)

df1 = pd.DataFrame({'Key1':['k0','k1','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key2':['k0','k1','k3'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})
df3 = pd.DataFrame({'Key3':['k0','k1','k4'],
                   'E':['c0','c1','c3'],
                   'F':['d0','d1','d3']})
df1.join([df2, df3])

17e

.unique() .nunique()

import pandas as pd
df = pd.read_csv('train.csv')
df.head()

df['Pclass'].unique()

array([3, 1, 2])

df['Pclass'].nunique()

3

.value_counts()

df['Pclass'].value_counts()

3    491
1    216
2    184
Name: Pclass, dtype: int64

(Super important) .apply ()

Vous pouvez utiliser la fonction apply () pour traiter tous les enregistrements dans un DataFrame et stocker les résultats dans une colonne distincte. C'est une image qui applique un traitement à chaque ligne

def get_age_group(age):
    return str(age)[0] + '0s'

get_age_group(45)

'40s'

df = pd.DataFrame({'name':['John','Mike','Emily'],
                  'age':['23','36','42']})
df

df['age'].apply(get_age_group)

0    20s
1    30s
2    40s
Name: age, dtype: object

Comment utiliser .apply () avec la fonction lambda

#Affecter à la variable f dans la fonction lambda
f = lambda x: str(x)[0] + '0s'
#Mettez 43 à l'essai
f(43)

'40s'

df['age_group'] = df['age'].apply(lambda x: str(x)[0] + '0s')

df

Comment utiliser .apply () pour l'enregistrement entier

df = pd.DataFrame({'name':['John','Mike','Emily'],
                  'age':['23','36','42']})
df['description'] = df.apply(lambda row:'{} is {} years old'.format(row['name'], row['age']), axis=1)

df

18e

Enregistrez DataFrame au format csv avec .to_csv ()

df = pd.read_csv('train.csv')
df.head()

df['Adult'] = df['Age'].apply(lambda x: x>20)
df.tail()

df.to_csv('train_w_adult.csv')

df = pd.read_csv('train_w_adult.csv')
df.head(3)

En regardant le résultat de df.head (3), les informations d'index de la dernière fois sauvegardée sont enregistrées dans la colonne mystérieuse «Sans nom: 0».

Si vous spécifiez index = False dans .to_csv (), vous n'avez pas besoin d'enregistrer l'index. En gros, spécifiez toujours index = False et enregistrez-le au format csv.

Veuillez noter que si le même fichier existe déjà dans la destination de sauvegarde, il sera écrasé.

df = pd.read_csv('train.csv')
df['Adult'] = df['Age'].apply(lambda x: x>20)
df.to_csv('train_w_adult.csv', index=False)

df = pd.read_csv('train_w_adult.csv')
df.head(3)

df = pd.DataFrame({'A':[['a', 'b'], 2, 3], 'B':[['c', 'd'], 5, 6]})
df

#Assurez-vous que les valeurs stockées sont une liste.
type(df['A'].iloc[0])

list

#Économisez avec csv
df.to_csv('temp.csv', index=False)
#Chargez le csv enregistré
df = pd.read_csv('temp.csv')
df

type(df['A'].iloc[0])

str

Itérer DataFrame avec .iterrows ()

Il est utilisé lors de l'itération d'un DataFrame avec une instruction for. C'est difficile à retenir, mais comme "lignes" est une "itération", rappelons-nous iter + ligne + s. Puisqu'il peut être tourné avec for, pensons qu'il y a plusieurs s.

«Itération» signifie répéter le processus. C'est une boucle. Par exemple, s'il s'agissait d'une liste, elle pourrait être itérée avec for i in list: (voir Partie 4).

Dans DataFrame, vous ne pouvez pas dire directement pour i dans df: comme une liste. Écrivez comme suit en utilisant une fonction appelée .iterrows ().

df = pd.read_csv('train.csv')
for idx, row in df.iterrows():
    if row['Age'] > 40 and row['Pclass'] == 3 and row['Sex'] == 'male' and row['Survived'] == 1:
        print('{} is very lucky guy...!'.format(row['Name']))

Dahl, Mr. Karl Edwart is very lucky guy...!
Sundman, Mr. Johan Julian is very lucky guy...!

.apply () est souvent utilisé pour enregistrer les résultats traités de chaque enregistrement dans une colonne séparée, et cette fois .iterows () est souvent utilisé lorsque vous souhaitez simplement traiter plutôt que renvoyer une valeur.

Par exemple, le chemin du fichier est stocké dans DataFrame et .iterrows () est utilisé pour déplacer ou lire le fichier.

Trier par colonne spécifique avec .sort_values ()

#Trier par âge
df.sort_values('Age')
df.head()

Créez un tableau croisé dynamique avec .pivot_table ()

data = {'Data':['Jan-1','Jan-1','Jan-1','Jan-2','Jan-2','Jan-2'],
       'User':['Emily', 'John','Nick','Kevin','Emily','John'],
       'Method':['Card','Card','Cash','Card','Cash','Cash'],
       'Price':[100,250,200,460,200,130]}
df = pd.DataFrame(data)
df

Dans les valeurs, entrez la colonne que vous souhaitez agréger. Cette fois, c'est Price.

Tout d'abord, la valeur spécifiée par les valeurs (Prix dans ce cas) est entrée dans chaque cellule. Il s'agit de la colonne que vous souhaitez agréger.

D'autre part, passez simplement les colonnes pour lesquelles vous souhaitez spécifier l'index et les colonnes dans une liste.

df.pivot_table(values='Price', index=['Data', 'User'], columns=['Method'])

df.pivot_table(values='Price', index=['Data', 'Method'], columns=['User'])

Tout d'abord, clarifiez "quelle colonne vous souhaitez agréger" et mettez cette colonne dans les valeurs, puis mettez simplement les informations que vous voulez dans l'index et les colonnes.

Opération de coupe avec .xs ()

.xs () est une abréviation de section transversale. Je ne l'utilise pas beaucoup non plus, mais cela est pratique lorsque vous travaillez avec des DataFrames qui ont plusieurs index, tels que des pivots. C'est une bonne idée de s'en souvenir avec le pivot.

Ce que vous devez faire avec ce .xs () est de l'utiliser dans le tableau croisé dynamique ci-dessus, par exemple, lorsque vous souhaitez extraire uniquement la ligne "Carte". (Exactement en coupe)

#pivot.xs('Card', level = 'Method')