mémo pandas

Pour commémorer la sortie de la version japonaise de Python pour l'analyse des données Objets susceptibles d'être utilisés souvent ou endroits susceptibles de se boucher

Ça fait si longtemps, donc la table

Combinez plusieurs séries dans un DataFrame

Utilisez concat pour définir axis = 1

s1 = pd.Series([1,2,3,4,5], index=[0,1,2,3,4])
s2 = pd.Series([10,20,30,40,50], index=[10,11,12,13,14])
s3 = pd.Series([100,200,300,400,500], index=[0,2,4,6,8])
print pd.concat([s1, s2, s3], axis=1)
"""
     0   1    2
0    1 NaN  100
1    2 NaN  NaN
2    3 NaN  200
3    4 NaN  NaN
4    5 NaN  300
6  NaN NaN  400
8  NaN NaN  500
10 NaN  10  NaN
11 NaN  20  NaN
12 NaN  30  NaN
13 NaN  40  NaN
14 NaN  50  NaN
"""

Référence d'index DataFrame

Divers sont préparés et confus C'est ennuyeux, mais je pense que la référence par ix est la plus simple à comprendre

#Préparer DataFrame
df = DataFrame(arange(30).reshape((6, 5)), index=list("ASDFGH"), columns=list("abcde"))
print df
"""
    a   b   c   d   e
A   0   1   2   3   4
S   5   6   7   8   9
D  10  11  12  13  14
F  15  16  17  18  19
G  20  21  22  23  24
H  25  26  27  28  29
"""

Référence à la colonne

Spécifiez le nom de la colonne pour la référence de colonne Lorsque vous en spécifiez plusieurs, spécifiez au format liste S'il n'y a qu'une seule colonne à spécifier, la variable d'instance est préparée par le nom de la colonne, vous pouvez donc la spécifier.

#Spécifiez le nom de la colonne
print df["a"]
"""
A     0
S     5
D    10
F    15
G    20
H    25
Name: a, dtype: int64
"""

#Spécifiez plusieurs noms de colonne
print df[["a", "c", "e"]]
"""
    a   c   e
A   0   2   4
S   5   7   9
D  10  12  14
F  15  17  19
G  20  22  24
H  25  27  29
"""

#Spécifiez la variable d'instance du nom de la colonne
print df.a
"""
A     0
S     5
D    10
F    15
G    20
H    25
"""

Référence de ligne

Désigné par tranchage, etc. La spécification par le nom (étiquette d'index) attaché à la ligne sera décrite plus loin.

print df[0:3]
"""
    a   b   c   d   e
A   0   1   2   3   4
S   5   6   7   8   9
D  10  11  12  13  14
"""

#Spécification d'indice négatif
print df[-2:]
"""
    a   b   c   d   e
G  20  21  22  23  24
H  25  26  27  28  29
"""

Référence en spécifiant la plage de lignes et de colonnes en même temps (référence par ix)

Peut être référencé en découpant l'attribut ix En fait, si vous vous en souvenez beaucoup, vous pouvez l'utiliser à tout moment dans le même format et c'est pratique Spécifiez par [ligne, colonne] comme découper un tableau à deux dimensions de NumPy Peut également être spécifié par l'étiquette d'index Cependant, dans le cas du découpage par étiquette d'index, notez que l'étiquette d'index derrière est incluse dans la plage.

#Désigné par index
print df.ix[0, 3]
"""
3
"""

#Tranchage par index
print df.ix[0:3, 0:2]
"""
    a   b
A   0   1
S   5   6
D  10  11
"""

#Spécifiez des lignes ou des colonnes séparées avec plusieurs index
print df.ix[[0, 2, 4], [0, 2, 4]]
"""
    a   c   e
A   0   2   4
D  10  12  14
G  20  22  24
"""

#Désigné par étiquette d'index
print df.ix["D", "a"]
"""
10
"""

#Spécification de plage par étiquette d'index
print df.ix["A":"D", "a":"b"]
"""
    a   b
A   0   1
S   5   6
D  10  11
"""

#Spécifiez des lignes ou des colonnes séparées avec plusieurs étiquettes d'index
print df.ix[["A", "H", "S"], ["c", "b", "a"]]
"""
    c   b   a
A   2   1   0
H  27  26  25
S   7   6   5
"""

Référence d'index de série

Depuis que j'ai fait DataFrame, j'ai aussi fait Series Contrairement à DataFrame, vous pouvez également spécifier par index depuis le début. Il est possible de spécifier par étiquette d'index, donc je ne pense pas qu'il y ait de désordre particulier. Le tranchage est également possible

#Préparer la série
s1 = pd.Series(range(6), index=list("abcdef"))
print s1
"""
a    0
b    1
c    2
d    3
e    4
f    5
dtype: int64
"""

#Désigné par index
print s1[0:3]
"""
a    0
b    1
c    2
dtype: int64
"""

#Désigné par étiquette d'index
print ["b":"e"]
"""
b    1
c    2
d    3
e    4
dtype: int64
"""

Masquage par valeur booléenne

Si vous évaluez une Series ou DataFrame comme le ndarray de NumPy, la série booléenne ou DataFrame qui a été évaluée pour chaque élément sera renvoyée.

print df > 5
"""
       a      b      c      d      e
A  False  False  False  False  False
S  False   True   True   True   True
D   True   True   True   True   True
F   True   True   True   True   True
G   True   True   True   True   True
H   True   True   True   True   True
"""

print s1 > 3
"""
a    False
b    False
c    False
d    False
e     True
f     True
dtype: bool
"""

Vous pouvez masquer la série ou le DataFrame d'origine avec ce que vous récupérez

#Masque DataFrame
print df[df > 5]
"""
    a   b   c   d   e
A NaN NaN NaN NaN NaN
S NaN   6   7   8   9
D  10  11  12  13  14
F  15  16  17  18  19
G  20  21  22  23  24
H  25  26  27  28  29
"""

#Masque de série
print s1[s1 > 3]
"""
e    4
f    5
dtype: int64
"""

Opérations entre Series et DataFrame

Les calculs sont effectués entre les mêmes étiquettes d'index Ceux qui n'ont pas la même étiquette d'index seront NaN Si vous ne souhaitez pas le définir sur NaN, vous pouvez calculer en attribuant 0 à NaN avec fill_value.

#Préparer la série
s1 = pd.Series(range(6), index=list("abcdef"))
s2 = pd.Series([10,20,30,40,50], index=list("asdfg"))

print s1
"""
a    0
b    1
c    2
d    3
e    4
f    5
dtype: int64
"""

print s2
"""
a    10
s    20
d    30
f    40
g    50
dtype: int64
"""

# s1 +peut être s2
print s1.add(s2)
"""
a    10
b   NaN
c   NaN
d    33
e   NaN
f    45
g   NaN
s   NaN
dtype: float64
"""

#Calculer après avoir remplacé NaN par 0
print s1.add(s2, fill_value=0)
"""
a    10
b     1
c     2
d    33
e     4
f    45
g    50
s    20
dtype: float64
"""

#Préparer DataFrame
df1 = DataFrame(arange(30).reshape((6,5)), index=list("ASDFGH"), columns=list("abcde"))
df2 = DataFrame(arange(42).reshape((7,6)), index=list("ASDFGHJ"), columns=list("abcdef"))

print df1
"""
    a   b   c   d   e
A   0   1   2   3   4
S   5   6   7   8   9
D  10  11  12  13  14
F  15  16  17  18  19
G  20  21  22  23  24
H  25  26  27  28  29
"""

print df2
"""
    a   b   c   d   e   f
A   0   1   2   3   4   5
S   6   7   8   9  10  11
D  12  13  14  15  16  17
F  18  19  20  21  22  23
G  24  25  26  27  28  29
H  30  31  32  33  34  35
J  36  37  38  39  40  41
"""

# df1 +peut être df2
print df1.add(df2)
"""
    a   b   c   d   e   f
A   0   2   4   6   8 NaN
D  22  24  26  28  30 NaN
F  33  35  37  39  41 NaN
G  44  46  48  50  52 NaN
H  55  57  59  61  63 NaN
J NaN NaN NaN NaN NaN NaN
S  11  13  15  17  19 NaN
"""

#Calculer après avoir remplacé NaN par 0
print df1.add(df2, fill_value=0)
"""
    a   b   c   d   e   f
A   0   2   4   6   8   5
D  22  24  26  28  30  17
F  33  35  37  39  41  23
G  44  46  48  50  52  29
H  55  57  59  61  63  35
J  36  37  38  39  40  41
S  11  13  15  17  19  11
"""

Si l'une des étiquettes d'index des données à calculer est complètement incluse dans l'étiquette d'index des autres données, fill_value peut être effectuée avec réindexation avant le calcul.

#Prenant df1 et df2 ci-dessus comme exemple
#L'étiquette d'index de df1 est entièrement incluse dans df2
print df1.index.isin(df2.index).all(), df1.columns.isin(df2.columns).all()
"""
True True
"""

print df1.reindex(index=df2.index, columns=df2.columns, fill_value=0) + df2
"""
    a   b   c   d   e   f
A   0   2   4   6   8   5
S  11  13  15  17  19  11
D  22  24  26  28  30  17
F  33  35  37  39  41  23
G  44  46  48  50  52  29
H  55  57  59  61  63  35
J  36  37  38  39  40  41
"""

Index hiérarchique

Plusieurs étiquettes d'index peuvent être attachées à une ligne ou une colonne Utilisez la méthode sortlevel pour trier par étiquette d'index hiérarchique

# Series
s = Series(range(10), index=[list("aaabbbccdd"),[1,2,3,2,1,3,1,2,1,2]])
print s
"""
a  1    0
   2    1
   3    2
b  2    3
   1    4
   3    5
c  1    6
   2    7
d  1    8
   2    9
dtype: int64
"""

#Voir l'étiquette d'index externe
print s["a"]
"""
1    0
2    1
3    2
dtype: int64
"""

#Voir l'étiquette d'index intérieure
print s[:, 1]
"""
a    0
b    4
c    6
d    8
dtype: int64
"""

#Modifier la hiérarchie des étiquettes d'index
#Permutez l'étiquette d'index de la 0ème couche et l'étiquette d'index de la 1ère couche
# s.swaplevel(1, 0)Peut être
print s.swaplevel(0, 1)
"""
1  a    0
2  a    1
3  a    2
2  b    3
1  b    4
3  b    5
1  c    6
2  c    7
1  d    8
2  d    9
dtype: int64
"""

#Trier par étiquette d'index externe
print s.swaplevel(0,1).sortlevel(0)
"""
1  a    0
   b    4
   c    6
   d    8
2  a    1
   b    3
   c    7
   d    9
3  a    2
   b    5
dtype: int64
"""

méthode stack et méthode unstack

stack est une conversion pivot de colonne en ligne unstack est une conversion pivot de ligne à colonne Puisqu'il s'agit d'une conversion de ligne à colonne, il ne peut être utilisé qu'avec un DataFrame ou une Series avec une étiquette d'index hiérarchique.

#Objet de série avec étiquette d'index hiérarchique
print s
"""
a  1    0
   2    1
   3    2
b  2    3
   1    4
   3    5
c  1    6
   2    7
d  1    8
   2    9
dtype: int64
"""

#Convertir des lignes en colonnes
print s.unstack()
"""
   1  2   3
a  0  1   2
b  4  3   5
c  6  7 NaN
d  8  9 NaN
"""

print df
"""
    a   b   c   d   e
A   0   1   2   3   4
S   5   6   7   8   9
D  10  11  12  13  14
F  15  16  17  18  19
G  20  21  22  23  24
H  25  26  27  28  29
"""

#Colonne à ligne
print df.stack()
"""
A  a     0
   b     1
   c     2
   d     3
   e     4
S  a     5
   b     6
   c     7
   d     8
   e     9
D  a    10
   b    11
   c    12
   d    13
   e    14
F  a    15
   b    16
   c    17
   d    18
   e    19
G  a    20
   b    21
   c    22
   d    23
   e    24
H  a    25
   b    26
   c    27
   d    28
   e    29
dtype: int64
"""

#Ligne à colonne
print df.unstack()
"""
a  A     0
   S     5
   D    10
   F    15
   G    20
   H    25
b  A     1
   S     6
   D    11
   F    16
   G    21
   H    26
c  A     2
   S     7
   D    12
   F    17
   G    22
   H    27
d  A     3
   S     8
   D    13
   F    18
   G    23
   H    28
e  A     4
   S     9
   D    14
   F    19
   G    24
   H    29
dtype: int64
"""

Appellation

Dénomination des lignes ou des colonnes

Vous pouvez modifier le nom en remplaçant l'attribut index pour les lignes et l'attribut colonnes pour les colonnes. Vous pouvez également utiliser la méthode renommer pour transmettre le nom avant et après la modification du format du dictionnaire. La méthode rename renvoie une copie des données et ne modifie pas les données d'origine

print df
"""
    a   b   c   d   e
A   0   1   2   3   4
S   5   6   7   8   9
D  10  11  12  13  14
F  15  16  17  18  19
G  20  21  22  23  24
H  25  26  27  28  29
"""

#Renommer la ligne
df.index = ["AAA", "SSS", "DDD", "FFF", "GGG", "HHH"]
#Renommer la colonne
df.columns=["one", "two", "three", "four", "five"]

print df
"""
     one  two  three  four  five
AAA    0    1      2     3     4
SSS    5    6      7     8     9
DDD   10   11     12    13    14
FFF   15   16     17    18    19
GGG   20   21     22    23    24
HHH   25   26     27    28    29
"""

#Utiliser renommer
print df.rename(index={"AAA":"a", "SSS":"s", "DDD":"d", "FFF":"f", "GGG":"g", "HHH":"h"},
columns={"one":1, "two":2, "three":3, "four":4, "five":5})
"""
    1   2   3   4   5
a   0   1   2   3   4
s   5   6   7   8   9
d  10  11  12  13  14
f  15  16  17  18  19
g  20  21  22  23  24
h  25  26  27  28  29
"""

Nommer l'étiquette d'index elle-même

Vous pouvez nommer l'étiquette d'index elle-même Le nom que vous donnez peut être utilisé lors de la conversion d'axes tels que swaplevel et unstack.

#Renommer l'index
df.index.names = ["UPPER"]
#Renommer la colonne
df.columns.names = ["lower"]

print df
"""
lower  one  two  three  four  five
UPPER                             
AAA      0    1      2     3     4
SSS      5    6      7     8     9
DDD     10   11     12    13    14
FFF     15   16     17    18    19
GGG     20   21     22    23    24
HHH     25   26     27    28    29
"""

Binning

(Un bac est une colonne d'un histogramme) Les valeurs de données peuvent être divisées en groupes à l'aide de la méthode pd.cut

#Données d'âge et de sexe
df = DataFrame([[20,"F"],[22,"M"],[25,"M"],[27,"M"],[21,"F"],[23,"M"],[37,"F"],[31,"M"],[61,"F"],[45,"M"],[41,"F"],[32,"M"]], columns=["age", "sex"])
print df
"""
   age sex
0   20   F
1   22   M
2   25   M
3   27   M
4   21   F
5   23   M
6   37   F
7   31   M
8   61   F
9   45   M
10  41   F
11  32   M
"""

#Valeur lors du fractionnement en bacs
bins = [18, 25, 35, 60, 100]
#Nom du bac
group_names = ["Youth", "YoungAdult", "MiddleAged", "Senior"]
#Binning
print pd.cut(df.age, bins, labels=group_names)
"""
Categorical: 
[Youth, Youth, Youth, YoungAdult, Youth, Youth, nan, YoungAdult, nan, nan, nan, YoungAdult]
Levels (4): Index(['Youth', 'YoungAdult', 'MiddleAged', 'Senior'], dtype=object)
"""

#Ajouter une colonne bin à df
df["bin"] = pd.cut(df.age, bins, labels=group_names)
print df
"""
    age sex         bin
0    20   F       Youth
1    22   M       Youth
2    25   M       Youth
3    27   M  YoungAdult
4    21   F       Youth
5    23   M       Youth
6    37   F  MiddleAged
7    31   M  YoungAdult
8    61   F      Senior
9    45   M  MiddleAged
10   41   F  MiddleAged
11   32   M  YoungAdult
"""

Conversion de colonnes et d'index

Si vous souhaitez convertir uniquement une colonne spécifique en index, utilisez la méthode set_index de DataFrame.

print df
"""
    age sex         bin
0    20   F       Youth
1    22   M       Youth
2    25   M       Youth
3    27   M  YoungAdult
4    21   F       Youth
5    23   M       Youth
6    37   F  MiddleAged
7    31   M  YoungAdult
8    61   F      Senior
9    45   M  MiddleAged
10   41   F  MiddleAged
11   32   M  YoungAdult
"""

#Convertir la colonne bin en index
print df.set_index("bin")
"""
            age sex
bin                
Youth        20   F
Youth        22   M
Youth        25   M
YoungAdult   27   M
Youth        21   F
Youth        23   M
MiddleAged   37   F
YoungAdult   31   M
Senior       61   F
MiddleAged   45   M
MiddleAged   41   F
YoungAdult   32   M
"""

#Donner une liste comme argument pour convertir plusieurs colonnes en un index hiérarchique
print df.set_index(["bin", "sex"])
"""
                age
bin        sex     
Youth      F     20
           M     22
           M     25
YoungAdult M     27
Youth      F     21
           M     23
MiddleAged F     37
YoungAdult M     31
Senior     F     61
MiddleAged M     45
           F     41
YoungAdult M     32
"""

#Trier
print df.set_index(["bin", "sex"]).sortlevel("bin")
"""
                age
bin        sex     
MiddleAged F     37
           F     41
           M     45
Senior     F     61
YoungAdult M     27
           M     31
           M     32
Youth      F     20
           F     21
           M     22
           M     25
           M     23
"""

Échantillonnage aléatoire

DataFrame take peut être utilisé pour récupérer uniquement les lignes requises Un échantillonnage aléatoire peut être effectué en extrayant aléatoirement des colonnes en utilisant ceci.

#Spécifiez la ligne à échantillonner
print df.take([1, 3, 5])
"""
   age sex         bin
1   22   M       Youth
3   27   M  YoungAdult
5   23   M       Youth
"""

#Échantillon aléatoire 5
sampler = np.random.permutation(len(df))
print df.take(sampler[:5])
"""
   age sex         bin
8   61   F      Senior
2   25   M       Youth
7   31   M  YoungAdult
1   22   M       Youth
0   20   F       Youth
"""

Faire des données catégorielles une variable factice

Vous pouvez utiliser la méthode get_dummies de pandas pour convertir des données catégorielles (données qualitatives) en variables factices. Sont utilisés pour quantifier la classe I

#La colonne de genre est transformée en une variable fictive
dum = pd.get_dummies(df["sex"])
print dum
"""
    F  M
0   1  0
1   0  1
2   0  1
3   0  1
4   1  0
5   0  1
6   1  0
7   0  1
8   1  0
9   0  1
10  1  0
11  0  1
"""

#Ajouter à df
df = pd.concat((df, dum), axis=1)
df = df.drop("sex", axis=1)
print df
"""
    age         bin  F  M
0    20       Youth  1  0
1    22       Youth  0  1
2    25       Youth  0  1
3    27  YoungAdult  0  1
4    21       Youth  1  0
5    23       Youth  0  1
6    37  MiddleAged  1  0
7    31  YoungAdult  0  1
8    61      Senior  1  0
9    45  MiddleAged  0  1
10   41  MiddleAged  1  0
11   32  YoungAdult  0  1
"""

regroupement

Le regroupement par valeur peut être effectué en utilisant groupby Utilisez la méthode apply de l'objet groupby pour appliquer le même traitement à chaque groupe

print df.groupby("bin")
"""
<pandas.core.groupby.DataFrameGroupBy object at 0x106af9a90>
"""

#Calculer la moyenne pour chaque groupe
f = lambda x: x.mean()
print df.groupby("bin").apply(f)
"""
             age         F         M
bin                                 
MiddleAged  41.0  0.666667  0.333333
Senior      61.0  1.000000  0.000000
YoungAdult  30.0  0.000000  1.000000
Youth       22.2  0.400000  0.600000
"""

Exemple: analyse de casier Regroupez la valeur des bacs et obtenez des statistiques pour chaque bac

frame = DataFrame({"data1": np.random.randn(1000), "data2":np.random.randn(1000)})
factor = pd.cut(frame.data1, 4)  #Divisez la plage de valeurs de data1 uniformément en 4 bacs

#Définir une fonction à appliquer
def get_stats(group):
    return {"min": group.min(), "max": group.max(), "count": group.count(), "mean": group.mean()}

#Statistiques de sortie de la valeur de data2 pour chaque bin de data1
grouped = frame.data2.groupby(factor)
print grouped.apply(get_stats).unstack()
"""
                  count       max      mean       min
data1                                                
(-3.205, -1.673]     44  2.544910 -0.108558 -1.984124
(-1.673, -0.147]    414  3.420818  0.003078 -3.168528
(-0.147, 1.379]     447  2.563359 -0.018062 -3.175148
(1.379, 2.905]       95  2.498611  0.140166 -2.439985
"""

La même fonction peut être appliquée à chaque colonne de l'objet GroupBy à l'aide de la méthode agg.

df["random"] = [random.choice((0,1)) for i in range(len(df))]
print df
"""
    age sex  random
0    20   F       1
1    22   M       1
2    25   M       1
3    27   M       0
4    21   F       1
5    23   M       1
6    37   F       1
7    31   M       0
8    61   F       1
9    45   M       1
10   41   F       0
11   32   M       0
"""

print df.groupby("sex").agg([np.max, np.min, np.mean])
"""
      age                   random                
     amax  amin       mean    amax  amin      mean
sex                                               
F      61    20  36.000000       1     0  0.800000
M      45    22  29.285714       1     0  0.571429
"""

Recommended Posts

Mémo Pandas
mémo pandas
Mémo inversé Pandas
Pandas
mémo gzip
Mémo Raspberry-pi
[Python] Mémo d'opération de pandas DataFrame
Mémo HackerRank
Mémo Python
mémo python
mémo graphène
Mémo du flacon
mémo pyenv
Mémo Matplotlib
Mémo Pandas ~ Aucun, np.nan, sur les caractères vides ~
mémo pytest
Mémo Python
Installer Memo
Notions de base sur les pandas
Mémo BeautifulSoup4
Notes de pandas
mémo networkx
mémo python
mémo Tomcat
[Mémo] Petite histoire de pandas, stupide
mémo de commande
Mémo du générateur.
Mémorandum de Pandas
mémo psycopg2
Mémo Python
Mémo SSH
Notions de base sur les pandas
mémorandum pandas
Mémo Shell
pandas SettingWithCopyWarning
Mémo Python
Mémo Pycharm
mémo d'auto-apprentissage pandas
Mémo de dévotion AtCoder (11/12)
[OpenCV] Mémo personnel
[Python] Mémo sur le dictionnaire
Mémo push PyPI
mémo d'introduction tensorflow-gpu
Note d'étude LPIC201
Mémo Jupyter Notebook
Mémo de virtualisation LPIC304
Mémo d'exécution ALDA
Mes pandas (Python)
youtube télécharger un mémo
ARC # 016 Mémo de participation
Belle note de soupe
Note d'étude LPIC101
mémo débutant python (9.1)
Exercice Pandas (édition)
mémo Linux (ubuntu)
Mémo Primer Flask
mémo céleri / kombu
[pandas] Conseils GroupBy
lecture de données pandas