Zum Gedenken an die Veröffentlichung der japanischen Version von Python for Data Analysis Dinge, die wahrscheinlich häufig verwendet werden, oder Orte, die wahrscheinlich verstopfen
Es ist so lange her, also der Tisch
Verwenden Sie concat, um die Achse = 1 zu setzen
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
"""
Verschiedene sind vorbereitet und verwirrt Es ist ärgerlich, aber ich denke, die Referenz von ix ist am einfachsten zu verstehen
#Bereiten Sie DataFrame vor
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
"""
Geben Sie den Spaltennamen als Spaltenreferenz an Wenn Sie mehr als eine angeben, geben Sie diese im Listenformat an Wenn nur eine Spalte angegeben werden muss, wird die Instanzvariable anhand des Spaltennamens vorbereitet, sodass Sie sie angeben können.
#Geben Sie den Spaltennamen an
print df["a"]
"""
A 0
S 5
D 10
F 15
G 20
H 25
Name: a, dtype: int64
"""
#Geben Sie mehrere Spaltennamen an
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
"""
#Geben Sie die Instanzvariable des Spaltennamens an
print df.a
"""
A 0
S 5
D 10
F 15
G 20
H 25
"""
Bezeichnet durch Schneiden usw. Die Angabe des Namens (Indexetikett), der an die Zeile angehängt ist, wird später beschrieben.
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
"""
#Negative Indexspezifikation
print df[-2:]
"""
a b c d e
G 20 21 22 23 24
H 25 26 27 28 29
"""
Kann durch Schneiden des ix-Attributs referenziert werden Wenn Sie sich an so viel erinnern, können Sie es jederzeit im gleichen Format verwenden, und es ist praktisch Geben Sie durch [Zeile, Spalte] an, wie das Schneiden eines zweidimensionalen Arrays von NumPy Kann auch durch Indexbezeichnung angegeben werden Beachten Sie jedoch beim Schneiden nach Indexetikett, dass das dahinterliegende Indexetikett im Bereich enthalten ist.
#Bezeichnet durch Index
print df.ix[0, 3]
"""
3
"""
#Schneiden nach Index
print df.ix[0:3, 0:2]
"""
a b
A 0 1
S 5 6
D 10 11
"""
#Geben Sie separate Zeilen oder Spalten mit mehreren Indizes an
print df.ix[[0, 2, 4], [0, 2, 4]]
"""
a c e
A 0 2 4
D 10 12 14
G 20 22 24
"""
#Bezeichnet durch Indexetikett
print df.ix["D", "a"]
"""
10
"""
#Bereichsspezifikation nach Indexbezeichnung
print df.ix["A":"D", "a":"b"]
"""
a b
A 0 1
S 5 6
D 10 11
"""
#Geben Sie separate Zeilen oder Spalten mit mehreren Indexbezeichnungen an
print df.ix[["A", "H", "S"], ["c", "b", "a"]]
"""
c b a
A 2 1 0
H 27 26 25
S 7 6 5
"""
Seit ich DataFrame gemacht habe, habe ich auch Serien gemacht Im Gegensatz zu DataFrame können Sie von Anfang an auch nach Index angeben. Es ist möglich, durch Indexbezeichnung anzugeben, daher glaube ich nicht, dass es eine bestimmte Unordnung gibt. Schneiden ist auch möglich
#Serie vorbereiten
s1 = pd.Series(range(6), index=list("abcdef"))
print s1
"""
a 0
b 1
c 2
d 3
e 4
f 5
dtype: int64
"""
#Bezeichnet durch Index
print s1[0:3]
"""
a 0
b 1
c 2
dtype: int64
"""
#Bezeichnet durch Indexetikett
print ["b":"e"]
"""
b 1
c 2
d 3
e 4
dtype: int64
"""
Wenn Sie eine Serie oder einen DataFrame wie NumPys ndarray auswerten, wird die für jedes Element ausgewertete Bool-Serie oder der DataFrame zurückgegeben.
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
"""
Sie können die ursprüngliche Serie oder den DataFrame mit dem maskieren, was Sie zurückerhalten
#DataFrame-Maske
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
"""
#Serienmaske
print s1[s1 > 3]
"""
e 4
f 5
dtype: int64
"""
Berechnungen werden zwischen denselben Indexbezeichnungen durchgeführt Diejenigen ohne das gleiche Indexetikett sind NaN Wenn Sie es nicht auf NaN setzen möchten, können Sie es berechnen, indem Sie NaN mit fill_value 0 zuweisen.
#Serie vorbereiten
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 +kann s2 sein
print s1.add(s2)
"""
a 10
b NaN
c NaN
d 33
e NaN
f 45
g NaN
s NaN
dtype: float64
"""
#Berechnen Sie nach dem Ersetzen von NaN durch 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
"""
#Bereiten Sie DataFrame vor
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 +kann df2 sein
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
"""
#Berechnen Sie nach dem Ersetzen von NaN durch 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
"""
Wenn eine der Indexbezeichnungen der zu berechnenden Daten vollständig in der Indexbezeichnung der anderen Daten enthalten ist, kann fill_value vor der Berechnung mit reindex ausgeführt werden.
#Nehmen wir als Beispiel df1 und df2 oben
#Die Indexbezeichnung von df1 ist vollständig in df2 enthalten
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
"""
An eine Zeile oder Spalte können mehrere Indexbezeichnungen angehängt werden Verwenden Sie die Sortlevel-Methode, um nach hierarchischer Indexbezeichnung zu sortieren
# 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
"""
#Siehe äußeres Indexetikett
print s["a"]
"""
1 0
2 1
3 2
dtype: int64
"""
#Siehe inneres Indexetikett
print s[:, 1]
"""
a 0
b 4
c 6
d 8
dtype: int64
"""
#Ändern Sie die Indexbezeichnungshierarchie
#Tauschen Sie die Indexbezeichnung der 0. Ebene und die Indexbezeichnung der 1. Ebene aus
# s.swaplevel(1, 0)Vielleicht
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
"""
#Nach äußerer Indexbezeichnung sortieren
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 ist eine Pivot-Konvertierung von Spalte zu Zeile Unstack ist eine Pivot-Konvertierung von Zeile zu Spalte Da es sich um eine Konvertierung von Zeile zu Spalte handelt, kann sie nur mit einem DataFrame oder einer Serie mit einer hierarchischen Indexbezeichnung verwendet werden.
#Serienobjekt mit hierarchischer Indexbezeichnung
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
"""
#Konvertieren Sie Zeilen in Spalten
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
"""
#Spalte zu Zeile
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
"""
#Zeile zu Spalte
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
"""
Sie können den Namen ändern, indem Sie den Index für Zeilen und das Spaltenattribut für Spalten überschreiben. Alternativ können Sie die Umbenennungsmethode verwenden, um den Namen vor und nach der Änderung des Wörterbuchformats zu übergeben. Die Umbenennungsmethode gibt eine Kopie der Daten zurück und ändert die Originaldaten nicht
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
"""
#Zeile umbenennen
df.index = ["AAA", "SSS", "DDD", "FFF", "GGG", "HHH"]
#Spalte umbenennen
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
"""
#Verwenden Sie Umbenennen
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
"""
Sie können die Indexbezeichnung selbst benennen Der von Ihnen angegebene Name kann beim Konvertieren von Achsen wie Swaplevel und Unstack verwendet werden.
#Index umbenennen
df.index.names = ["UPPER"]
#Spalte umbenennen
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
"""
(Ein Bin ist eine Spalte eines Histogramms) Datenwerte können mit der Methode pd.cut in Bins aufgeteilt werden
#Alters- und Geschlechtsdaten
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
"""
#Wert beim Aufteilen in Behälter
bins = [18, 25, 35, 60, 100]
#Bin Name
group_names = ["Youth", "YoungAdult", "MiddleAged", "Senior"]
#Klasseneinteilung
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)
"""
#Fügen Sie df die Spalte bin hinzu
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
"""
Wenn Sie nur eine bestimmte Spalte in einen Index konvertieren möchten, verwenden Sie die Methode set_index von 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
"""
#Bin-Spalte in Index konvertieren
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
"""
#Geben Sie eine Liste als Argument an, um mehrere Spalten in einen hierarchischen Index zu konvertieren
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
"""
#Sortieren
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
"""
Mit DataFrame take können nur die erforderlichen Zeilen abgerufen werden Zufällige Stichproben können durch zufälliges Extrahieren von Spalten durchgeführt werden.
#Geben Sie die zu probierende Zeile an
print df.take([1, 3, 5])
"""
age sex bin
1 22 M Youth
3 27 M YoungAdult
5 23 M Youth
"""
#Zufallsstichprobe 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
"""
Mit der Methode get_dummies von pandas können Sie kategoriale Daten (qualitative Daten) in Dummy-Variablen konvertieren. Werden bei der Quantifizierung von Klasse I verwendet
#Die Spalte Geschlecht wird zu einer Dummy-Variablen
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
"""
#Zu df hinzufügen
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
"""
Die Gruppierung nach Wert kann mithilfe von groupby erfolgen Verwenden Sie die Apply-Methode des groupby-Objekts, um auf jede Gruppe dieselbe Verarbeitung anzuwenden
print df.groupby("bin")
"""
<pandas.core.groupby.DataFrameGroupBy object at 0x106af9a90>
"""
#Berechnen Sie den Mittelwert für jede Gruppe
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
"""
Beispiel: Behälteranalyse Gruppieren Sie den Wert von Behältern und erhalten Sie Statistiken für jeden Behälter
frame = DataFrame({"data1": np.random.randn(1000), "data2":np.random.randn(1000)})
factor = pd.cut(frame.data1, 4) #Teilen Sie den Wertebereich von data1 gleichmäßig in 4 Bins
#Definieren Sie eine anzuwendende Funktion
def get_stats(group):
return {"min": group.min(), "max": group.max(), "count": group.count(), "mean": group.mean()}
#Ausgabestatistik des Werts von data2 für jeden Datenbehälter1
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
"""
Dieselbe Funktion kann mit der agg-Methode auf jede Spalte des GroupBy-Objekts angewendet werden.
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