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()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S

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()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
6 7 0 1 McCarthy, Mr. Timothy J male 54.0 0 0 17463 51.8625 E46 S
10 11 1 3 Sandstrom, Miss. Marguerite Rut female 4.0 1 1 PP 9549 16.7000 G6 S
11 12 1 1 Bonnell, Miss. Elizabeth female 58.0 0 0 113783 26.5500 C103 S

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()
PassengerId Survived Pclass Name Sex SibSp Parch Ticket Fare
0 1 0 3 Braund, Mr. Owen Harris male 1 0 A/5 21171 7.2500
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 1 0 PC 17599 71.2833
2 3 1 3 Heikkinen, Miss. Laina female 0 0 STON/O2. 3101282 7.9250
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 1 0 113803 53.1000
4 5 0 3 Allen, Mr. William Henry male 0 0 373450 8.0500

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é.
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S

.fillna(value)

Attribuez une valeur spécifique à NaN.

df.fillna('THIS IS IT').head()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22 1 0 A/5 21171 7.2500 THIS IS IT S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26 0 0 STON/O2. 3101282 7.9250 THIS IS IT S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35 0 0 373450 8.0500 THIS IS IT S

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()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S
pd.isna(df).head()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 False False False False False False False False False False True False
1 False False False False False False False False False False False False
2 False False False False False False False False False False True False
3 False False False False False False False False False False False False
4 False False False False False False False False False False True False

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()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S

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()
PassengerId Survived Age SibSp Parch Fare
Pclass
1 461.597222 0.629630 38.233441 0.416667 0.356481 84.154687
2 445.956522 0.472826 29.877630 0.402174 0.380435 20.662183
3 439.154786 0.242363 25.140620 0.615071 0.393075 13.675550
df = df[df['Pclass']==1]
df.head()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
6 7 0 1 McCarthy, Mr. Timothy J male 54.0 0 0 17463 51.8625 E46 S
11 12 1 1 Bonnell, Miss. Elizabeth female 58.0 0 0 113783 26.5500 C103 S
23 24 1 1 Sloper, Mr. William Thompson male 28.0 0 0 113788 35.5000 A6 S

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

df[df['Pclass']==1].describe()
PassengerId Survived Pclass Age SibSp Parch Fare
count 216.000000 216.000000 216.0 186.000000 216.000000 216.000000 216.000000
mean 461.597222 0.629630 1.0 38.233441 0.416667 0.356481 84.154687
std 246.737616 0.484026 0.0 14.802856 0.611898 0.693997 78.380373
min 2.000000 0.000000 1.0 0.920000 0.000000 0.000000 0.000000
25% 270.750000 0.000000 1.0 27.000000 0.000000 0.000000 30.923950
50% 472.000000 1.000000 1.0 37.000000 0.000000 0.000000 60.287500
75% 670.500000 1.000000 1.0 49.000000 1.000000 0.000000 93.500000
max 890.000000 1.000000 1.0 80.000000 3.000000 4.000000 512.329200

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()
PassengerId Survived Age SibSp Parch Fare
count mean std min 25% 50% 75% max count mean std min 25% 50% 75% max count mean std min 25% 50% 75% max count mean std min 25% 50% 75% max count mean std min 25% 50% 75% max count mean std min 25% 50% 75% max
Pclass
1 216.0 461.597222 246.737616 2.0 270.75 472.0 670.5 890.0 216.0 0.629630 0.484026 0.0 0.0 1.0 1.0 1.0 186.0 38.233441 14.802856 0.92 27.0 37.0 49.0 80.0 216.0 0.416667 0.611898 0.0 0.0 0.0 1.0 3.0 216.0 0.356481 0.693997 0.0 0.0 0.0 0.0 4.0 216.0 84.154687 78.380373 0.0 30.92395 60.2875 93.5 512.3292
2 184.0 445.956522 250.852161 10.0 234.50 435.5 668.0 887.0 184.0 0.472826 0.500623 0.0 0.0 0.0 1.0 1.0 173.0 29.877630 14.001077 0.67 23.0 29.0 36.0 70.0 184.0 0.402174 0.601633 0.0 0.0 0.0 1.0 3.0 184.0 0.380435 0.690963 0.0 0.0 0.0 1.0 3.0 184.0 20.662183 13.417399 0.0 13.00000 14.2500 26.0 73.5000
3 491.0 439.154786 264.441453 1.0 200.00 432.0 666.5 891.0 491.0 0.242363 0.428949 0.0 0.0 0.0 0.0 1.0 355.0 25.140620 12.495398 0.42 18.0 24.0 32.0 74.0 491.0 0.615071 1.374883 0.0 0.0 0.0 1.0 8.0 491.0 0.393075 0.888861 0.0 0.0 0.0 0.0 6.0 491.0 13.675550 11.778142 0.0 7.75000 8.0500 15.5 69.5500
df.groupby('Pclass').describe()['Age'] #J'ai sorti seulement Age
count mean std min 25% 50% 75% max
Pclass
1 186.0 38.233441 14.802856 0.92 27.0 37.0 49.0 80.0
2 173.0 29.877630 14.001077 0.67 23.0 29.0 36.0 70.0
3 355.0 25.140620 12.495398 0.42 18.0 24.0 32.0 74.0

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()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked RankInClass
633 634 0 1 Parr, Mr. William Henry Marsh male NaN 0 0 112052 0.0 NaN S 0
822 823 0 1 Reuchlin, Jonkheer. John George male 38.0 0 0 19972 0.0 NaN S 1
815 816 0 1 Fry, Mr. Richard male NaN 0 0 112058 0.0 B102 S 2
806 807 0 1 Andrews, Mr. Thomas Jr male 39.0 0 0 112050 0.0 A36 S 3
263 264 0 1 Harrison, Mr. William male 40.0 0 0 112059 0.0 B94 S 4

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
Key A B
0 k0 a0 b0
1 k a1 b1
2 k2 a2 b2
df2
Key C D
0 k0 c0 d0
1 k1 c2 d1
2 k2 c3 d2

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)
Key A B C D
0 k0 a0 b0 c0 d0
1 k2 a2 b2 c3 d2

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'.
A B C D Key
0 a0 b0 NaN NaN k0
1 a1 b1 NaN NaN k
2 a2 b2 NaN NaN k2
0 NaN NaN c0 d0 k0
1 NaN NaN c2 d1 k1
2 NaN NaN c3 d2 k2
#côté
pd.concat([df1,df2], axis=1)
Key A B Key C D
0 k0 a0 b0 k0 c0 d0
1 k a1 b1 k1 c2 d1
2 k2 a2 b2 k2 c3 d2

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
Key A B
0 k0 a0 b0
1 k a1 b1
2 k2 a2 b2
df2
Key C D
0 k0 c0 d0
1 k1 c2 d1
2 k2 c3 d2
df1.merge(df2, how='left')
Key A B C D
0 k0 a0 b0 c0 d0
1 k a1 b1 NaN NaN
2 k2 a2 b2 c3 d2
df1.merge(df2, how='outer')
Key A B C D
0 k0 a0 b0 c0 d0
1 k a1 b1 NaN NaN
2 k2 a2 b2 c3 d2
3 k1 NaN NaN c2 d1
df1.merge(df2, how='inner')
Key A B C D
0 k0 a0 b0 c0 d0
1 k2 a2 b2 c3 d2

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')
Key ID_x A B ID_y C D
0 k0 aa a0 b0 aa c0 d0
1 k1 bb a1 b1 bb c1 d1
df1.merge(df2, on='ID')
Key_x ID A B Key_y C D
0 k0 aa a0 b0 k0 c0 d0
1 k1 bb a1 b1 k1 c1 d1
2 k2 cc a2 b2 k3 c3 d3

Changer le suffixe

df1.merge(df2, on='ID', suffixes=('_left', '_right'))
Key_left ID A B Key_right C D
0 k0 aa a0 b0 k0 c0 d0
1 k1 bb a1 b1 k1 c1 d1
2 k2 cc a2 b2 k3 c3 d3

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')
Key1 A B Key2 C D
0 k0 a0 b0 k0 c0 d0
1 k1 a1 b1 k1 c1 d1

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)
Key1 A B Key2 C D
0 k0 a0 b0 k0 c0 d0
1 k1 a1 b1 k1 c1 d1
2 k2 a2 b2 k3 c3 d3

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)
Key1 A B Key2 C D
0 k0 a0 b0 k0 c0 d0
1 k1 a1 b1 k1 c1 d1
2 k2 a2 b2 k3 c3 d3
df1.merge(df2, left_index=True, right_index=True)
Key1 A B Key2 C D
0 k0 a0 b0 k0 c0 d0
1 k1 a1 b1 k1 c1 d1
2 k2 a2 b2 k3 c3 d3
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])
Key1 A B Key2 C D Key3 E F
0 k0 a0 b0 k0 c0 d0 k0 c0 d0
1 k1 a1 b1 k1 c1 d1 k1 c1 d1
2 k2 a2 b2 k3 c3 d3 k4 c3 d3

17e

.unique() .nunique()

import pandas as pd
df = pd.read_csv('train.csv')
df.head()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S
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
name age
0 John 23
1 Mike 36
2 Emily 42
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
name age age_group
0 John 23 20s
1 Mike 36 30s
2 Emily 42 40s

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
name age description
0 John 23 John is 23 years old
1 Mike 36 Mike is 36 years old
2 Emily 42 Emily is 42 years old

18e

Enregistrez DataFrame au format csv avec .to_csv ()

df = pd.read_csv('train.csv')
df.head()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S
df['Adult'] = df['Age'].apply(lambda x: x>20)
df.tail()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked Adult
886 887 0 2 Montvila, Rev. Juozas male 27.0 0 0 211536 13.00 NaN S True
887 888 1 1 Graham, Miss. Margaret Edith female 19.0 0 0 112053 30.00 B42 S False
888 889 0 3 Johnston, Miss. Catherine Helen "Carrie" female NaN 1 2 W./C. 6607 23.45 NaN S False
889 890 1 1 Behr, Mr. Karl Howell male 26.0 0 0 111369 30.00 C148 C True
890 891 0 3 Dooley, Mr. Patrick male 32.0 0 0 370376 7.75 NaN Q True
df.to_csv('train_w_adult.csv')
df = pd.read_csv('train_w_adult.csv')
df.head(3)
Unnamed: 0 PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked Adult
0 0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S True
1 1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C True
2 2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S True

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)
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked Adult
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S True
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C True
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S True
df = pd.DataFrame({'A':[['a', 'b'], 2, 3], 'B':[['c', 'd'], 5, 6]})
df
A B
0 [a, b] [c, d]
1 2 5
2 3 6
#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
A B
0 ['a', 'b'] ['c', 'd']
1 2 5
2 3 6
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()
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S

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
Data User Method Price
0 Jan-1 Emily Card 100
1 Jan-1 John Card 250
2 Jan-1 Nick Cash 200
3 Jan-2 Kevin Card 460
4 Jan-2 Emily Cash 200
5 Jan-2 John Cash 130

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'])
Method Card Cash
Data User
Jan-1 Emily 100.0 NaN
John 250.0 NaN
Nick NaN 200.0
Jan-2 Emily NaN 200.0
John NaN 130.0
Kevin 460.0 NaN
df.pivot_table(values='Price', index=['Data', 'Method'], columns=['User'])
User Emily John Kevin Nick
Data Method
Jan-1 Card 100.0 250.0 NaN NaN
Cash NaN NaN NaN 200.0
Jan-2 Card NaN NaN 460.0 NaN
Cash 200.0 130.0 NaN NaN

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

Recommended Posts

J'ai écrit le fonctionnement de base de Pandas dans Jupyter Lab (partie 1)
J'ai écrit le fonctionnement de base de Pandas dans Jupyter Lab (partie 2)
J'ai écrit le fonctionnement de base de matplotlib dans Jupyter Lab
J'ai écrit la grammaire de base de Python dans Jupyter Lab
J'ai écrit le fonctionnement de base de Seaborn dans Jupyter Lab
Fonctionnement de base des pandas
Fonctionnement de base des Pandas
J'ai étudié avec Kaggle Start Book basé sur kaggle [Partie 1]
Créer un environnement d'exécution pour Jupyter Lab
J'ai fait une erreur en récupérant la hiérarchie avec MultiIndex of pandas
J'ai essayé la fonction de tableau croisé dynamique des pandas
Fonctionnement automatique de Chrome avec Python + Sélénium + pandas
J'ai vérifié la liste des touches de raccourci de Jupyter
Remplissez la largeur du bloc-notes Jupyter pour remplir le navigateur
Fonctionnement de base de Python Pandas Series et Dataframe (1)
J'ai comparé la moyenne mobile du type de filtre IIR avec les pandas et scipy
Calculer la somme des valeurs uniques par tabulation croisée des pandas
Je veux tracer les informations de localisation de GTFS Realtime sur Jupyter! (Avec ballon)
Prenez note de la liste des utilisations de base de Pandas
Dessinez sur Jupyter en utilisant la fonction de tracé des pandas
J'ai mesuré les performances d'un million de documents avec mongoDB
Résumé du flux de base de l'apprentissage automatique avec Python
J'ai essayé d'effacer la partie négative de Meros
Obtenez l'état de fonctionnement de JR West avec Python
J'ai essayé de comparer la vitesse de traitement avec dplyr de R et pandas de Python
Je t'ai écrit pour regarder le signal avec Go
J'ai écrit un doctest dans "J'ai essayé de simuler la probabilité d'un jeu de bingo avec Python"
J'ai essayé de trouver l'entropie de l'image avec python
J'ai essayé la "correction gamma" de l'image avec Python + OpenCV
J'ai écrit le code pour la génération de phrases japonaises avec DeZero
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
J'ai évalué la stratégie de négociation du système boursier avec Python.
Je veux obtenir des informations sur le fonctionnement de Yahoo Route
Reformatez l'axe des temps du graphique de la série chronologique des pandas avec matplotlib
J'ai essayé d'implémenter l'algorithme FloodFill avec TRON BATTLE de CodinGame
J'ai fait une image ponctuelle de l'image d'Irasutoya. (partie 1)
Essayez d'automatiser le fonctionnement des périphériques réseau avec Python
J'ai fait une image ponctuelle de l'image d'Irasutoya. (partie 2)
J'ai écrit GP avec numpy
Application Python: Pandas Partie 1: Basique
Changer le thème de Jupyter
Résumé de l'utilisation de base de Pandas
Le pouvoir des pandas: Python
Calcul de base des pandas pour profiter de Hakone Ekiden tout en rivalisant avec les meilleurs membres de tous les temps
Partie 1 J'ai écrit la réponse au problème de référence de l'écriture hors ligne en temps réel en Python
J'ai comparé la vitesse de Hash avec Topaz, Ruby et Python
J'ai essayé de gratter le classement du calendrier de l'avent Qiita avec Python
[AWS / Tello] J'ai essayé de faire fonctionner le drone avec ma voix Part2
J'ai essayé le déploiement autonome de play avec fabric [opération AWS avec boto] [déploiement de lecture]
Trouvez la valeur optimale de la fonction à l'aide d'un algorithme génétique (partie 2)
J'ai essayé d'automatiser l'arrosage du pot avec Raspberry Pi
[Python] J'ai écrit la route du typhon sur la carte en utilisant le folium
Je veux sortir le début du mois prochain avec Python
J'ai écrit le code pour écrire le code Brainf * ck en python
Compter la partie concaténée maximale d'un graphe aléatoire avec NetworkX
[AWS / Tello] J'ai essayé de faire fonctionner le drone avec ma voix Part1
J'ai essayé d'agrandir la taille du volume logique avec LVM
Je veux vérifier la position de mon visage avec OpenCV!
J'ai vérifié l'image de l'Université des sciences sur Twitter avec Word2Vec.
J'ai essayé d'améliorer l'efficacité du travail quotidien avec Python