Pandas ist eine Bibliothek, die Funktionen zur Unterstützung der Datenanalyse in der Programmiersprache Python [^ wiki] bietet. Ich denke, "Pandas" ist selbst in der "Python" -Bibliothek [^ atm] kompliziert. Der Freiheitsgrad ist jedoch so hoch, dass es für Datenanalysten undenkbar ist, Daten ohne "Pandas" zu analysieren. Daher möchte ich bis zu dem Punkt erklären, dass "Wenn Sie so weit verstehen, können Sie alles tun (wenn Sie sich andere Websites ansehen)" [^ title].
[^ wiki]: Siehe https://ja.wikipedia.org/wiki/Pandas
[^ atm]: Aber es gibt eine Atmosphäre, von der man nicht sagen kann, dass sie schwierig ist.
[^ title]: Pandas ist keine Sprache, aber der Titel passt gut.
\ 1. Vorbereitung
Aktivieren Sie die Verwendung von "numpy" (eindimensionalen) Indexreferenzen, Slicing, Booleschen Indexreferenzen und ausgefallenen Indexreferenzen
Aktivieren Sie die Verwendung von "numpy" (zweidimensionalen) Indexreferenzen, Slicing- und Booleschen Indexreferenzen. Verstehen Sie das Verhalten der Funktion numpy.iloc_. (Ausgefallene Indexreferenzen sind in ndarray in 2D schwer zu verwenden, daher verwende ich sie selten persönlich.)
\ 2. Einführung in "Pandas"
Erstellen Sie "Series, DataFrame" und verwenden Sie die Indexreferenz ("Series" ist im Grunde eine Erweiterung von "numpy" (1 Dimension). "DataFrame" ist im Grunde "df.loc" (Priorität des Labelnamens). ) Oder dx.iloc (Zahlenpriorität) ist im Grunde eine Erweiterung von numpy (zweidimensional).)
Ermöglicht das Hinzufügen, Extrahieren, Löschen, Ändern usw. von Daten für "Serie, Datenrahmen"
(Wenn der Element- oder Indexname in "Series, DataFrame" eine Zeichenfolge ist, ist eine Stapeloperation zum Extrahieren und Ändern möglich. Dies ist praktisch. Verstehen Sie daher die Zeichenfolgenverarbeitung durch den "str" -Zugriff von "Pandas".)
Danach sollten Sie auf dem richtigen Weg sein und ein Level erreichen, in dem Sie verschiedene Dinge selbst untersuchen können (Sie sollten in der Lage sein, "Gruppieren nach" usw. reibungslos zu verstehen).
Zum Beispiel "Numpy"
arr = np.arange(12) #arr ist ein eindimensionales ndarray
arr = arr.reshape(3,4) #arr ist eine zweidimensionale ndarrary
# arr[i,j]Das erste Element ist die Zeile und das zweite Element ist die Spalte
arr[:2] #2D ndarray
arr[:2, 0] #1-dimensionales ndarray
arr[:, arr[0] > 2] #2D ndarray
Mit Pandas,
pop = {'Nevada' : {2001 : 2.4, 2002 : 2.9},
'Ohio' : {2000 : 1.5, 2001 : 1.7}}
df = DataFrame(pop) # DataFrame(2D)
df[df['Nevada'] > 2] # DataFrame(2D)
df.iloc[-1:]['Nevada'] # Series(1 Dimension)
Wie ist der Typ so? Wenn Sie sich dessen bewusst sind und es verstehen, scheint die Hälfte vorbei zu sein.
Fassen wir also das Verhalten der Indexreferenz von ndarray (2D) zusammen und fahren dann mit Pandas ~ fort
import
import numpy as np # ndarray
#Erforderlich, um Matplot im Jupiter anzuzeigen
%matplotlib inline
import matplotlib.pyplot as plt
from pandas import Series, DataFrame
import pandas as pd
Numpy
Nehmen wir ein zweidimensionales Ndarray. Pandas verstehen Hier gibt es zwei Dinge zu verstehen:
Haben Sie ein gutes Verständnis für "Numpy" -Indexreferenzen, Slicing, Boolesche Indexreferenzen und ausgefallene Indexreferenzen
Das zweidimensionale "Numpy" ist "arr [
arr = np.arange(12).reshape(3,4) #arr ist eine zweidimensionale ndarrary(3 Zeilen 4 Spalten)
#array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11]])
Wenn es nur ein + Indexer-Argument gibt, sieht es so aus:
#Holen Sie sich ein eindimensionales Ndarray
arr[1] #Elementreferenz nach Skalarwert
arr[0:2] #Schneiden Extrahieren Sie die Zeilen 0 und 1(Die zweite Zeile wird nicht extrahiert)
##Für jedes Element in der ersten Zeile(>2)Gibt den booleschen Wert von zurück
arr[1] > 2 # array([ True, True, True, True], dtype=bool)
#Holen Sie sich ein zweidimensionales Ndarray
arr>2 #Boolesche Indexreferenz
arr[np.array([True, False, True])] #Extrahieren Sie die Zeilen 0 und 2 mit der Booleschen Indexreferenz
# arr[[True, False, True]] # Warning
arr[[0,2,1]] #Siehe ausgefallener Index:Als Indexreferenz(ganze Zahl)Verwenden eines Arrays Extrahieren Sie die Zeilen 0, 2 und 1 nacheinander
Numpy Indexer (arr [･ (erstes Argument), ･ (zweites Argument)]für 2D). Das erste Argument ist die Zeile und das zweite Argument ist die Spalte.Es ist im Grunde dasselbe wie ein eindimensionales Ndarray, aber beachten Sie nur die Fallstricke, in die man leicht hineinfallen kann:
#Wenn Sie nur das zweite Argument angeben möchten. Das erste Argument kann nicht weggelassen werden. Zu dieser Zeit schneiden`:`Als erstes Argument
arr[:, 1]
#Wenn Sie für das erste und das zweite Argument einen ausgefallenen Index angeben, ist die Operation etwas unintuitiv.
## (Beachten Sie auch, dass es sich um ein eindimensionales Ndarray handelt!
## np.array([arr[i,j] for i,j in zip([1,2], [0,1])])Gleichwertig.# array([4, 9])
arr[[1,2], [0,1]]
## 1,2. Zeile und 0,Gehen Sie wie folgt vor, um ein zweidimensionales ndarray zu erhalten, das den Bereich der ersten Spalte extrahiert
arr[np.iloc_([1,2], [0,1])]
array([[4, 5],
[8, 9]])
#Linie
arr[:,1] > 2 # array([False, True, True], dtype=bool)
#Die erste Reihe ist(>2)Extrahieren Sie die folgenden Zeilen
arr[arr[:,1] > 2] # arr[np.array([False, True, True])]Gleich wie.(Ich habe es persönlich nicht viel benutzt)
# arr[arr[:, 1] > 2, :]Gleich wie.
arr[1] > 5
arr[:, arr[1] > 5] # array([False, False, True, True], dtype=bool)
#arr[:, np.array([False, False, True, True])] #Gleich wie
Zusammenfassend ist das Verhalten des Indexreferenztyps von ndarray (2D) wie folgt [^ summary]:
[^ Zusammenfassung]: Es ist ein wenig gewaltsam. Die Spalte "Keine" des zweiten Arguments zeigt auf "arr [･]". Die Klammern in (1d) bedeuten, dass Sie sie nicht zu oft verwenden. 1d steht für 1-dimensionales "ndarray" und 2d steht für 2-dimensionales "ndarray".
| Erstes Argument\Zweites Argument | Keiner | Skalar | Schneiden | Boolescher Index | Ausgefallener Index |
|---|---|---|---|---|---|
| Keiner | - | ❌ | ❌ | ❌ | ❌ |
| Skalar | 1d | 0d | 1d | 1d | 1d |
| Schneiden | 2d | 2d | 2d | 2d | 2d |
| Boolescher Index | 2d | 1d | 2d | (2d) | (1d) |
| Ausgefallener Index | 2d | 1d | 2d | (1d) | (1d) |
#Eine Falle, die mit etwas anderem verwechselt werden kann. Ich möchte das Element von arr verdreifachen
> arr = [0,1,2,3]
> arr*4
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
> np.arange(4)*4
[0,4,8,12]
#Wenn Sie dasselbe tun möchten, ohne in numpy zu konvertieren, verwenden Sie die Einschlussnotation.
> [i*4 for i in range(4)]
[0,4,8,12]
In Numpy sollte es als dasselbe ndarray behandelt worden sein, unabhängig davon, ob es 1D oder 2D ist, aber in Pandas wird es als 1D => Series, 2D => DataFrame unterteilt. Ich bin. Obwohl die Namen unterschiedlich sind, können "DataFrame" und "Series" nicht getrennt werden, da sie zwischen 2D <=> 1D hin und her gehen.
Wenn Sie beispielsweise eine einzelne Zeile / Spalte aus "DataFrame" angeben, können Sie die eindimensionale "Serie" extrahieren. Umgekehrt können Sie einen "DataFrame" erstellen, indem Sie die "Liste" oder das "Diktat" der "Serie" (1D) als Argument des "DataFrame" (2D) -Konstruktors angeben.
Daher ist es wichtig zu verstehen, ob die Dimensionen einer Variablen eindimensional oder zweidimensional sind, auch wenn sich der Name in "Serie, Datenrahmen" ändert.
Grundsätzlich setze ich oft "dict", "list" in den Konstruktor. Im Fall von "dict" ist es "Series" mit Index.
#Beispiel für ein Schubdiktat
dic = {'word' : 470, 'camera' : 78}
Series(dic)
#Oft wird eine Kombinationstechnik mit Reißverschluss und Diktat verwendet, um eine Serie zu generieren:
Series(dict(zip(words, frequency)))
Für Indexreferenzen ist es eine Erweiterung des eindimensionalen ndarray. Der Unterschied besteht darin, dass der Indexname auch als Indexargument enthalten sein kann.
ser = Series(np.random.randn(5), index = list('ABCDE'))
#A 1.700973
#B 1.061330
#C 0.695804
#D -0.435989
#E -0.332942
#dtype: float64
#Schneiden
ser[1] #Die erste Zeile also'A'Dimension 0 extrahieren(type =Typ float64)
ser['A'] # 'A'Zeilen extrahieren(type = float)
ser[1:3] #1,Extrahieren Sie die zweite Zeile(Series(Eindimensional)
ser[-1:] #Letzte Zeile extrahieren
ser[:-1] #Extrahieren Sie alle Zeilen mit Ausnahme der letzten Zeile
ser[[1,2]] # 1,Extrahieren Sie die zweite Zeile(Ausgefallener Index)
ser[['A', 'B']] # (Schick)Sie können den Index auch als Zeichenfolge angeben
ser > 0 #Die Art der Ser ist Serie(1 Dimension)Jedes Element ist ein boolescher Wert
ser[ser > 0] #Boolescher Index(ser > 0)Elementreferenz mit
# Read,Da beide geschrieben werden können, ist es auch möglich, den r-Wert nur in den entsprechenden zu schreiben, wie unten gezeigt..
#Die Technik, Bedingungen auf Werte zu bringen, wird häufig in DataFrames verwendet.
ser[ser > 0] = 0
#Wenn sowohl außen als auch innen diktiert werden
pop = {'Nevada' : {2001 : 2.4, 2002 : 2.9},
'Ohio' : {2000 : 1.5, 2001 : 1.7}}
df2 = DataFrame(pop)
# Nevada Ohio
#2000 NaN 1.5
#2001 2.4 1.7
#2002 2.9 NaN
#Das Äußere ist diktiert,Wenn das Innere Serie ist
# df1,df2 ist ein DataFrame-Typ(Also df1['name'], df2['address']Ist ein Serientyp)
##Spaltenname ist['typeA', 'typeB'],Indexname ist[0,1,2,3]
dfA = DataFrame({'typeA' : df1['name'], 'typeB' : df2['address']})
##Indexname ist[0,1,2,3],Spaltenname ist['name', 'address'](Attribut T ist Translokation)
dfB = DataFrame([df1['name'], df2['address']]).T
Wir verwenden oft die + eingebaute "zip" -Funktion, um einen "DataFrame" zu erstellen:
dict(zip([1,2,3], [4,5,6,7])) #{1: 4, 2: 5, 3: 6} =>Kann nicht in DataFrame konvertiert werden
list(zip([1,2,3], [4,5,6,7])) #[(1, 4), (2, 5), (3, 6)] =>Kann in DataFrame konvertiert werden(draußen:Liste, innen:Weil es ein Taple ist)
pd.DataFrame(list(zip([1,2,3], [4,5,6,7]))) # => OK!
df = DataFrame(np.arange(12).reshape(3,4), columns = list('ABCD'))
print(df)
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
DataFrame(Series({'word' : 470, 'camera' : 78}), columns = ['frequency'])
Das Erstellen eines "DataFrame" aus einer "Serie" wird im Abschnitt "Datenaddition" der Anfängerausgabe ausführlich erläutert.
In "Pandas", "df [･]" oder "df.loc [oder df.iloc [kann erstellt werden.df [･]` verhält sich ziemlich verwirrend wie folgt.
#Ich benutze oft
#dfA[1] # runtime error!!Die erste Spalte kann nicht als ganzzahliger Wert abgerufen werden
#dfA['typeA'] #'typeA'Serienspalten(1 Dimension)Extrahiert als
dfA[['typeB', 'typeA']] # typeB,DataFrame mit Spalten vom Typ A in der angegebenen Reihenfolge(2D)Extrahiert als
dfA['typeA'] > 3 #1-dimensionale Serie(Jedes Element ist ein boolescher Wert)
#Ein bisschen verwirrend(Ich benutze es oft persönlich)
dfA[dfA['typeA'] > 3] #dfA'typeA'Extrahieren Sie Zeilen mit 3 oder mehr Spalten.
# dfA.loc[dfA['typeA'] > 3] #Wenn Sie sich Sorgen machen, verwenden Sie diese
#Unten ist es ziemlich kompliziert, deshalb benutze ich es nicht viel.
dfA[1:] #Die erste Zeile~DataFrame(2D)Extrahiert als(Beachten Sie, dass es sich um eine Zeilenextraktion handelt)
#dfA[1:]Ich würde das eher schreiben als mich.
dfA.loc[1:] #Es wurde klargestellt, dass es sich um eine Linienspezifikation handelt. Oder dfA.loc[1:, :]
df.loc ist eine Version, in der Sie den Markennamen Numpy angeben können. Im Grunde sollten Sie es mit dem gleichen Kleber wie die Indexreferenz von "Numpy" schreiben.
df.locEs gibt jedoch zwei Dinge zu beachten, wenn es um df.loc geht (ziemlich wichtig und leicht festzuhalten).
Zum einen hat "df.loc" Vorrang vor dem Labelnamen. Selbst wenn für "index" ein ganzzahliger Wert angegeben wird, wird nicht auf die Indexnummer verwiesen, sondern die dem Labelnamen entsprechende Zeile wird extrahiert. ist. Wenn Sie beispielsweise die erste Zeile sortieren und extrahieren möchten, kann es leicht zu einem Unfall kommen:
dic = list(zip([0,3,5,6], list('ADCB')))
dfA = DataFrame(dic, columns = ['typeA', 'typeB'])
# typeA typeB
#0 0 A
#1 3 D
#2 5 C
#3 6 B
dfA = dfA.sort_values(by = 'typeB')
# typeA typeB
#0 0 A
#3 6 B
#2 5 C
#1 3 D
dfA.loc[1] #1(Mit anderen Worten, der zweite Platz)Ich möchte Zeilen extrahieren, aber wenn ich loc verwende, wird die Zeile mit dem Indexbezeichnungsnamen 1 extrahiert:
#typeA 3
#typeB D
#Name: 1, dtype: object
##Um eine solche Tragödie zu verhindern, df.Verwenden Sie iloc. Die Zeilennummer hat Priorität.
##(#3 6 B)Kann extrahiert werden
dfA.iloc[1]
"iloc" wird oft auch nach der Extraktion verwendet. (Wenn "index" nicht in numerischer Reihenfolge ist, kann es nicht durch "loc [number]" referenziert werden.)
df = df[df['A'] == name]
df.iloc[0]['B'] #Es fühlt sich ein wenig übersichtlich an...
Die andere ist eine Falle, in die man beim Umgang mit ganzzahligen Indizes leicht geraten kann. Wenn Sie jedoch die letzte Zeile extrahieren möchten, schlägt die Referenzierung eines negativen Werts in df.loc fehl. Da der Labelname Priorität hat, wird gesagt, dass es kein -1-Label gibt. Verwenden Sie erneut "df.iloc", um zu betonen, dass die Extraktion für Zeilennummern gilt.
# dfA.loc[-1] : NG
dfA.iloc[-1] # OK(Die letzte Zeile ist Serie(1 Dimension)Extrahiert als)
dfA.iloc[-1:] # OK(Die letzte Zeile ist DataFrame(2D)Extrahiert als)
Im Gegenteil, df.iloc kann nur Zahlen verwenden. Wenn Sie also Zeilen nach Zeilennummern und Spalten nach Beschriftungsnamen angeben möchten, schreiben Sie wie folgt.
df.iloc[i]['A'] #Es ist gut, so zu schreiben
#iloc kann nur Spalten mit Zahlen angeben
# Location based indexing can only have
# [integer, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean array] types
# res *= df.iloc[i, 'A'] #error
Um die Indexreferenz von "DataFrame" zusammenzufassen,
Wenn Sie sich nicht sicher sind, verwenden Sie "df.loc [
Wenn Sie jedoch die Extraktion von Zeilennummern hervorheben möchten, verwenden Sie "df.iloc [
Wenn Sie nur diese beiden Punkte berücksichtigen, können Sie Daten genauso angenehm extrahieren wie die Indexreferenz von "Numpy". Es ist wirklich einfach, wenn Sie sich nur an einen Typ von "df.loc" erinnern müssen, aber ganzzahlige Indizes sind in der Praxis so beliebt, dass Sie die Verwendung von "df.iloc" nicht vermeiden können: Schweiß. :: ::
loc und iloc können nicht in den l-Wert kopiert werden, wenn der Indexer zweimal verwendet wird (siehe unten). (Der Wert, den Sie im ursprünglichen DataFrame ändern möchten, wird nicht geändert.)
#A value is trying to be set on a copy of a slice from a DataFrame
df.loc[5]['colA'] #Kann kein Wert sein
#kein Problem!(Weil es eine Referenz ist)
df.loc[k, 'non_view_rate'] *= mult
Bisher haben wir uns die Indexreferenz "Pandas" angesehen. Vielleicht ist es über dem Berg, aber es gibt noch einige komplizierte Teile wie das Hinzufügen und Ändern von "DataFrame". Für die grundlegende Verwendung jeder Funktion [Einführung in die Datenanalyse durch Python --- Datenverarbeitung mit NumPy, Pandas](https://www.amazon.co.jp/ Einführung in die Datenanalyse durch Python --- NumPy, Pandas Datenverarbeitung mit Wes-McKinney / dp / 4873116554), und hier möchte ich es umgekehrt zusammenfassen.
ser = Series([1,2,3], index = list('ABC'))
#A 1
#B 2
#C 3
#dtype: int64
Wird als "Serie (3 * 1)" ausgedrückt. Die Indexnamen sind alle gleich. (['A', 'B', 'C']) Mal sehen, wie verschiedene Datenmuster verkettet werden.
(Series(31) <- Series(31)) -> DataFrame
DataFrame([s1, s2]) #Konstruktor verwenden
df = DataFrame([s1, s2], index = list('AB')).T
pd.concat([s1, s2], axis = 1) #Wenn Sie nach unten stapeln möchten, concat(.., axis = 1)Sollte benutzt werden
serA.append(serB)
#Oder
pd.concat([serA, serB])
#Wenn der Indexname eine Seriennummer von 0 sein soll..
s1.append(s2).reset_index(drop = True) #Sortieren Sie den Index neu
df1 = DataFrame(serA)
df2 = DataFrame(serB)
ndf = df1.join(df2, how = 'outer', lsuffix = 'A', rsuffix = 'B') #Ich wundere mich
#Hier können nur zwei angeschlossen werden.
ndf = pd.merge(df1, df2, left_index=True, right_index=True, how='outer')
0A 1A 2A 0B 1B 2B
0 1 2 3 4 5 6
(DataFrame(n3) <- Series(31)) => DataFrame
# Can only append a Series if ignore_index=True or if the Series has a index name
df.append(serA, ignore_index = True)
cols = ['colA', 'colB', 'colC']
res_df = DataFrame(columns = cols)
res_df = res_df.append(Series([1,2,3], cols).T, ignore_index = True)
...
(Series(3*1) + Series(3*1)) + Series(3*1) + Series(3*1)-> DataFrame(4*3)
df = DataFrame([serA, serB, serC, serD])
# DataFrame(3*4)Wenn du möchtest.Fügen Sie einfach T hinzu
df = DataFrame([serA, serB, serC, serD]).T
#Fügen Sie eine Zeile hinzu
df.loc['newrow'] = 0
df.append(serA, ignore_index = True)
#Fügen Sie mehrere Zeilen hinzu
df1.append(df2)
#Fügen Sie mehrere DataFrames hinzu(Stöbern Sie in der Liste)
df1.append([df2, df3, df4])
#Oder
pd.concat([df1, df2, df3, df4])
#1 Spalte hinzugefügt
df['newcol'] = 0
#Nicht zutreffender Index ist Outer Join(outer)Zu.(NAN値Zu.)
df1.join(df2, how = 'outer')
df1.join([df2, df3], how = 'outer')
#Das Zusammenführen kann detaillierter sein, beschränkt sich jedoch auf das Zusammenführen von zwei DataFrames:
df1.merge(df1, how = 'outer')
Weitere Informationen finden Sie auf der offiziellen Seite http://pandas.pydata.org/pandas-docs/version/0.19.1/generated/pandas.DataFrame.merge.html oder http://sinhrks.hatenablog.com/entry / 28.01.2015/073 Ich finde 327 gut.
Für letzteres,
+Einfache vertikale Verkettung DataFrame.append
+Flexible Verkettung pd.concat
+Join durch Spaltenwert pd.merge
+Join durch Index DataFrame.join (Machen Sie eine einfache Version der Zusammenführung)
Es ist leicht zu verstehen, da es mit Abbildungen und Beispielen geschrieben ist.
#Index umbenennen
df.index = ['one', 'two', 'three']
#Neuzuweisung der Indexnummer
df.reset_index(drop = True) #Sortieren Sie den Index neu(Ab Nummer 0~)
#Spalten umbenennen
##Tabellenerstellung=>Nach der Bearbeitung befindet sich die Spalte möglicherweise nicht in der erwarteten Reihenfolge
##Es ist sicherer, die Spaltenreihenfolge explizit anzugeben.
df = df[['old_a', 'old_b', 'old_c']]
df.columns = ['new_a', 'new_b', 'new_c']
#Oder df.Verwenden Sie Umbenennen
df = df[['old_a', 'old_b', 'old_c']] #So oder so, wenn Sie sich nicht für die Reihenfolge der Spalten interessieren.
#Da das Umbenennen keine destruktive Methode ist, muss es einem Wert zugewiesen werden. Geben Sie als Parameter Spalten an.(Beachten Sie, dass es sich nicht um einen Achsenparameter handelt)
df = df.rename(columns = {'old_a' : 'new_a', 'old_b' : 'new_b', 'old_c' : 'new_c'})
Hinweis 1) Sie können auch "df.rename" verwenden, wenn Sie einige Index- und Spaltennamen ändern möchten. (Geben Sie den Typ "dict" (als Entsprechungstabelle vor der Änderung) im Parameter "index" oder "columns" an. Beachten Sie, dass es keinen Parameter "axis" gibt. Der Rest ist "anstelle von" column ". Spalten(mits`))
Anmerkung 2) reindex ist ein Ersatz für die vorhandene Indexposition, keine Änderung des Indexnamens.
set_index erstellt ein neues Objekt unter Verwendung einer oder mehrerer spezifischer Spalten als Index, z. B. "df.set_index (['c1', 'c0'])". Beachten Sie, dass dies keine Methode zum Umbenennen des Index ist. reset_index konvertiert einen hierarchischen Index in eine Spalte. Nur die Beziehung von set_index <=> reset_index.
# 'A'Konzentrieren Sie sich auf die Spalten'wrong'Wählen Sie die Zeilen aus, die und von diesen Zeilen sind'B'Säule'sth'Ändern
df.loc[df['A'] == 'wrong', 'B'] = 'sth'
sort_index (zum Sortieren um den Index), sort_values (angegeben durch by) kann in aufsteigender oder absteigender Reihenfolge sortiert werden (bei absteigender Reihenfolge geben Sie ascending = False an )df [・] einfügen möchten.http://naotoogawa.hatenablog.jp/entry/2015/09/12/PandasのDataFrameの嵌りどころ
#Schließen Sie jeden Booleschen Index in Klammern ein
df = df[(df['A'] > 0) | (df['B'] > 0)]
df [･] in mehreren Kandidaten befindet#apply ist eine Funktion, die Series als Argument verwendet(Lambda-Stil)In das erste Argument
#map ist eine Funktion, die ein Element als Argument verwendet(Lambda-Stil)In das erste Argument
df = df[df['A'].map(lambda d : d in listA)]
Löschen Sie Zeilen und Spalten mit "df.drop" (nicht destruktiv). Wenn Sie eine Achse angeben, können Sie sowohl Zeilen als auch Spalten löschen.
df = df.drop("A", axis=1)
#Spalte ist'A', 'B', .. 'F'damit'C'Aus der Spalte'F'列まdamit削除したいときとかは、以下のようにする方が多い
df = df[['A', 'B']]
Siehe http://nekoyukimmm.hatenablog.com/entry/2015/02/25/222414.
#Gibt den DataFrame-Typ zurück
df.apply(lambda ser: ser % 2 == 0)
df.applymap(lambda x: x % 2 == 0)
df['goal'] == 0
df.isin([1,2])
df = df[~df.index.duplicated()] #Entfernen Sie den doppelten Index(Löschen Sie die Daten, die nach dem zweiten Mal angezeigt werden)
#Gibt den Serientyp zurück
df.apply(lambda ser : (ser > 0).any())
df['A'].map(lambda x : x > -1)
serA > serB #Serientyp
-bool_ser #Drehen Sie den Index eines Elements des Bool-Index um
#Das zweite Argument ist nur das Element, das im ersten Argument zu False wird
df['A'].where(df['A'] > 0, -df['A']) #Serienversion von abs(Wenn das erste Argument nicht zutrifft, fügen Sie ein negatives Vorzeichen hinzu(Mit anderen Worten, es wird positiv, weil es negativ ist.)
(df['goal'] == 0).all() #Richtig, wenn Sie von allen Bedingungen abhängig sind
df.apply(lambda ser: ser % 2 == 0)
(df['cdf(%)'] < 90).sum() #Zählen Sie die Zahl, die die Bedingungen erfüllt
df.where(df % 3 == 0, -df)
Es ist durchaus üblich, bei "NA" hängen zu bleiben. Notieren Sie sich daher, wo der "NA" -Wert generiert werden kann.
dic = dict(zip(list('ABCD'), [3,4,6,2])) #Dikt generieren
ser = Series(dic, index = list('ABCDE'))
#Spalte E, die nicht in dic enthalten ist, ist NAN
#A 3.0
#B 4.0
#C 6.0
#D 2.0
#E NaN
#dtype: float64
(Beispiel)
pop = {'Nevada' : {2001 : 2.4, 2002 : 2.9},
'Ohio' : {2000 : 1.5, 2001 : 1.7}}
df = DataFrame(pop)
Nevada Ohio
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 NaN
df.reindex einen Indexparameter enthält, der nicht im Index von df enthalten ist.Beispiel weggelassen
locdf.loc[[2002, 2001, 1999], ['Alaska', 'Nevada']]
Alaska Nevada
2002 NaN 2.9
2001 NaN 2.4
1999 NaN NaN
Hinweis) Fehler mit df ['non_exists'], df.loc [:, 'non_exists'] (Angabe eines Namens, der nicht in der Spalte enthalten ist).
Hinzufügen von Datenrahmen (das nicht entsprechende Element von "Index" oder "Spalte" wird zu NAN)
Wenn "how =" äußere "für" Zusammenführen, verbinden "angegeben ist
append, concat (wenn der Index dies nicht unterstützt)
df.dropna (Parameter ist wie oder Achse),df.fillna (0)(NA-Wert gleichmäßig auf 0 setzen
Geben Sie in df.reindex den Parameter fill_value oder method an
combin_first: Nur der NA-Wert von old_df wird durch das erste Argument ergänzt. (Beachten Sie, dass der Teil, in dem das Element in old_df 0 ist, nicht gepatcht werden muss!)
# df ..Indexsprünge(index.name : B_idx, columns = ['A'] =>Seriennummer des Index(0~89)Ich möchte den Interpolationswert auf 0 setzen
old_df = DataFrame(index = range(90), columns = 'A')
new_df = old_df.combine_first(df).fillna(0) # index.Name verschwindet
Vor allem, weil die Zeichenkettenoperation von Series oft nüchtern verwendet wird. Es kann nicht nur für Elemente verwendet werden, sondern auch für Indexnamen und Spaltennamen!
Weitere Informationen finden Sie unter http://pandas.pydata.org/pandas-docs/stable/text.html (insbesondere unten). Wenn Sie eine Zeichenfolge in einem DataFrame betreiben möchten, können Sie diese normalerweise hier lösen.
Zum Beispiel, wenn Sie nur die Zeilen extrahieren möchten, die einem bestimmten regulären Ausdruck entsprechen.
#df'A'Aktualisieren Sie df, indem Sie nur die Zeilen extrahieren, die mit Kleinbuchstaben in der Spalte beginnen
r = '^[a-z]'
df = df[df['A'].str.match(r)] # df['A'].str.match(r)Ist ein Boolescher Index
[1] [Einführung in die Datenanalyse mit Python --- Datenverarbeitung mit NumPy und Pandas](https://www.amazon.co.jp/ Einführung in die Datenanalyse mit Python --- Datenverarbeitung mit NumPy und Pandas-Wes -McKinney / dp / 4873116554)
[2] http://sinhrks.hatenablog.com/entry/2015/01/28/073327
[3] Documentation http://pandas.pydata.org/pandas-docs/stable/api.html
Recommended Posts