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
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
"""
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
"""
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
"""
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
"""
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
"""
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
"""
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
"""
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
"""
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
"""
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
"""
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
"""
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
"""
(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
"""
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
"""
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
"""
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
"""
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