Heim >Backend-Entwicklung >Python-Tutorial >Pandas-Grundlagen
Pandas-Grundlagen
- 巴扎黑Original
- 2017-06-23 15:54:392439Durchsuche
Pandas ist ein auf Numpy basierendes Datenanalysepaket, das erweiterte Datenstrukturen und Tools enthält.
Ähnlich wie Numpy, dessen Kern ndarray ist, dreht sich auch bei Pandas die beiden Kerndatenstrukturen Series und DataFrame . Serien und DataFrame entsprechen einer eindimensionalen Sequenz bzw. einer zweidimensionalen Tabellenstruktur. Die herkömmliche Importmethode von Pandas lautet wie folgt:
from pandas import Series,DataFrame import pandas as pd
Serien
Serien können als geordnetes Wörterbuch fester Länge betrachtet werden. Grundsätzlich können alle eindimensionalen Daten zum Erstellen von Serienobjekten verwendet werden:
>>> s = Series([1,2,3.0,'abc']) >>> s 0 1 1 2 2 3 3 abc dtype: object
Obwohl dtype:object eine Vielzahl grundlegender Datentypen enthalten kann, scheint es immer Auswirkungen auf die Leistung zu haben, daher ist es am besten, es beizubehalten einfacher dtype.
Das Serienobjekt enthält zwei Hauptattribute: Index und Werte, die im obigen Beispiel die linke und rechte Spalte sind. Da es sich bei dem, was an den Konstruktor übergeben wird, um eine Liste handelt, ist der Wert des Index eine Ganzzahl, die von 0 ansteigt. Wenn eine wörterbuchähnliche Schlüssel-Wert-Paarstruktur übergeben wird, wird eine Reihe generiert, die dem Indexwert entspricht die Initialisierung Bei Verwendung von Schlüsselwortparametern zur expliziten Angabe eines Indexobjekts:
>>> s = Series(data=[1,3,5,7],index = ['a','b','x','y']) >>> s a 1 b 3 x 5 y 7 dtype: int64 >>> s.index Index(['a', 'b', 'x', 'y'], dtype='object') >>> s.values array([1, 3, 5, 7], dtype=int64)
Die Elemente des Series-Objekts werden streng nach dem angegebenen Index erstellt, was bedeutet: wenn der Datenparameter einen Schlüsselwert hat Paar, dann wird nur der im Index enthaltene Schlüssel verwendet. Wenn der entsprechende Schlüssel in den Daten fehlt, wird der Schlüssel hinzugefügt, auch wenn ein NaN-Wert angegeben ist.
Beachten Sie, dass es zwar eine Entsprechung zwischen dem Index der Reihe und den Elementen der Werte gibt, diese sich jedoch von der Zuordnung des Wörterbuchs unterscheidet. Index und Werte sind eigentlich immer noch unabhängige Ndarray-Arrays, daher ist die Leistung von Serienobjekten völlig in Ordnung. Der größte Vorteil von
Series, einer Datenstruktur, die Schlüssel-Wert-Paare verwendet, besteht darin, dass die Indizes automatisch ausgerichtet werden, wenn arithmetische Operationen zwischen Serien ausgeführt werden.
Darüber hinaus enthalten das Series-Objekt und sein Index beide ein name-Attribut:
>>> s.name = 'a_series' >>> s.index.name = 'the_index' >>> s the_index a 1 b 3 x 5 y 7 Name: a_series, dtype: int64
DataFrame
DataFrame is a Eine tabellarische Datenstruktur, die eine Reihe geordneter Spalten enthält (ähnlich einem Index), und jede Spalte kann einen anderen Werttyp haben (im Gegensatz zu ndarray, das nur einen D-Typ haben kann). Grundsätzlich können Sie sich einen DataFrame als eine Sammlung von Serien vorstellen, die denselben Index haben.
Die Konstruktionsmethode von DataFrame ähnelt der von Series, außer dass mehrere eindimensionale Datenquellen gleichzeitig akzeptiert werden können, von denen jede zu einer separaten Spalte wird:
>>> data = {'state':['Ohino','Ohino','Ohino','Nevada','Nevada'],
'year':[2000,2001,2002,2001,2002],
'pop':[1.5,1.7,3.6,2.4,2.9]}
>>> df = DataFrame(data)
>>> df
pop state year
0 1.5 Ohino 2000
1 1.7 Ohino 2001
2 3.6 Ohino 2002
3 2.4 Nevada 2001
4 2.9 Nevada 2002
[5 rows x 3 columns]Obwohl die Parameterdaten wie ein Wörterbuch aussehen, spielt der Schlüssel des Wörterbuchs nicht die Rolle des Index des DataFrame, sondern das „Name“-Attribut der Serie. Der hier generierte Index ist immer noch „01234“.
Die vollständigeren DataFrame-Konstruktorparameter sind: DataFrame(data=None,index=None,coloumns=None), Spalten sind „Name“:
>>> df = DataFrame(data,index=['one','two','three','four','five'],
columns=['year','state','pop','debt'])
>>> df
year state pop debt
one 2000 Ohino 1.5 NaN
two 2001 Ohino 1.7 NaN
three 2002 Ohino 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
[5 rows x 4 columns]In ähnlicher Weise werden fehlende Werte mit NaN aufgefüllt. Werfen Sie einen Blick auf Index, Spalten und Indextypen:
>>> df.index Index(['one', 'two', 'three', 'four', 'five'], dtype='object') >>> df.columns Index(['year', 'state', 'pop', 'debt'], dtype='object') >>> type(df['debt']) <class 'pandas.core.series.Series'>
Zeilenorientierte und spaltenorientierte DataFrame-Vorgänge sind grundsätzlich ausgeglichen, und jede extrahierte Spalte ist eine Serie.
Objekteigenschaften
Neuindizierung
Die Neuindizierung von Serienobjekten wird durch die Methode .reindex(index=None,**kwargs) implementiert. Es gibt zwei häufig verwendete Parameter in **kwargs: method=None,fill_value=np.NaN:
ser = Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c']) >>> a = ['a','b','c','d','e'] >>> ser.reindex(a) a -5.3 b 7.2 c 3.6 d 4.5 e NaN dtype: float64 >>> ser.reindex(a,fill_value=0) a -5.3 b 7.2 c 3.6 d 4.5 e 0.0 dtype: float64 >>> ser.reindex(a,method='ffill') a -5.3 b 7.2 c 3.6 d 4.5 e 4.5 dtype: float64 >>> ser.reindex(a,fill_value=0,method='ffill') a -5.3 b 7.2 c 3.6 d 4.5 e 4.5 dtype: float64
.reindex() Die Methode gibt ein neues Objekt zurück, dessen Index strikt den angegebenen Parametern folgt Geben Sie den Interpolationsmodus (Fill) an. Wenn nicht angegeben, wird er automatisch mit method:{'backfill', 'bfill', 'pad', 'ffill', None} gefüllt. Der Standardwert ist NaN (ffill = pad, bfill = back fill, bezieht sich jeweils auf den Vorwärts- oder Rückwärtswert während der Interpolation) fill_value
. Es gibt nur einen weiteren optionalen Spaltenparameter als „Series“, der zum Indizieren der Spalten verwendet wird. Die Verwendung ähnelt dem obigen Beispiel, mit der Ausnahme, dass der Parameter der Interpolationsmethode .reindex(index=None,columns=None,**kwargs) nur auf Zeilen, also Achse 0, angewendet werden kann. method
>>> state = ['Texas','Utha','California']
>>> df.reindex(columns=state,method='ffill')
Texas Utha California
a 1 NaN 2
c 4 NaN 5
d 7 NaN 8
[3 rows x 3 columns]
>>> df.reindex(index=['a','b','c','d'],columns=state,method='ffill')
Texas Utha California
a 1 NaN 2
b 1 NaN 2
c 4 NaN 5
d 7 NaN 8
[4 rows x 3 columns]Allerdings ist weiterhin gültig. Kluge Freunde haben vielleicht darüber nachgedacht, ob die Interpolation auf Spalten durch fill_value erreicht werden kann. Beachten Sie außerdem, dass bei Verwendung von df.T.reindex(index,method='**').T der Index monoton sein muss, da sonst ein reindex(index,method='**') ausgelöst wird. Der letzte Aufruf im obigen Beispiel funktioniert beispielsweise nicht, wenn ValueError: Must be monotonic for forward fill verwendet wird. index=['a','b','d','c']
-Methode des Objekts: .drop(labels, axis=0)
>>> ser d 4.5 b 7.2 a -5.3 c 3.6 dtype: float64 >>> df Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> ser.drop('c') d 4.5 b 7.2 a -5.3 dtype: float64 >>> df.drop('a') Ohio Texas California c 3 4 5 d 6 7 8 [2 rows x 3 columns] >>> df.drop(['Ohio','Texas'],axis=1) California a 2 c 5 d 8 [3 rows x 1 columns]
Was zurückgegeben wird, ist ein neues Objekt, und das Metaobjekt wird nicht geändert. .drop()
und das Filtern durch boolesche Arrays. obj[::]
>>> foo a 4.5 b 7.2 c -5.3 d 3.6 dtype: float64 >>> bar 0 4.5 1 7.2 2 -5.3 3 3.6 dtype: float64 >>> foo[:2] a 4.5 b 7.2 dtype: float64 >>> bar[:2] 0 4.5 1 7.2 dtype: float64 >>> foo[:'c'] a 4.5 b 7.2 c -5.3 dtype: float64
这里 foo 和 bar 只有 index 不同——bar 的 index 是整数序列。可见当使用整数索引切片时，结果与 Python 列表或 Numpy 的默认状况相同；换成 'c' 这样的字符串索引时，结果就包含了这个边界元素。
另外一个特别之处在于 DataFrame 对象的索引方式，因为他有两个轴向（双重索引）。
可以这么理解：DataFrame 对象的标准切片语法为：.ix[::,::]。ix 对象可以接受两套切片，分别为行（axis=0）和列（axis=1）的方向：
>>> df Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.ix[:2,:2] Ohio Texas a 0 1 c 3 4 [2 rows x 2 columns] >>> df.ix['a','Ohio'] 0
而不使用 ix ，直接切的情况就特殊了：
索引时，选取的是列
切片时，选取的是行
这看起来有点不合逻辑，但作者解释说 “这种语法设定来源于实践”，我们信他。
>>> df['Ohio'] a 0 c 3 d 6 Name: Ohio, dtype: int32 >>> df[:'c'] Ohio Texas California a 0 1 2 c 3 4 5 [2 rows x 3 columns] >>> df[:2] Ohio Texas California a 0 1 2 c 3 4 5 [2 rows x 3 columns]
使用布尔型数组的情况，注意行与列的不同切法（列切法的 : 不能省）：
>>> df['Texas']>=4 a False c True d True Name: Texas, dtype: bool >>> df[df['Texas']>=4] Ohio Texas California c 3 4 5 d 6 7 8 [2 rows x 3 columns] >>> df.ix[:,df.ix['c']>=4] Texas California a 1 2 c 4 5 d 7 8 [3 rows x 2 columns]
算术运算和数据对齐
pandas 最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，结果的索引取索引对的并集。自动的数据对齐在不重叠的索引处引入空值，默认为 NaN。
>>> foo = Series({'a':1,'b':2})
>>> foo
a 1
b 2
dtype: int64
>>> bar = Series({'b':3,'d':4})
>>> bar
b 3
d 4
dtype: int64
>>> foo + bar
a NaN
b 5
d NaN
dtype: float64DataFrame 的对齐操作会同时发生在行和列上。
当不希望在运算结果中出现 NA 值时，可以使用前面 reindex 中提到过 fill_value 参数，不过为了传递这个参数，就需要使用对象的方法，而不是操作符：df1.add(df2,fill_value=0)。其他算术方法还有：sub(), div(), mul()。
Series 和 DataFrame 之间的算术运算涉及广播，暂时先不讲。
函数应用和映射
Numpy 的 ufuncs（元素级数组方法）也可用于操作 pandas 对象。
当希望将函数应用到 DataFrame 对象的某一行或列时，可以使用 .apply(func, axis=0, args=(), **kwds) 方法。
f = lambda x:x.max()-x.min() >>> df Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.apply(f) Ohio 6 Texas 6 California 6 dtype: int64 >>> df.apply(f,axis=1) a 2 c 2 d 2 dtype: int64
排序和排名
Series 的 sort_index(ascending=True) 方法可以对 index 进行排序操作，ascending 参数用于控制升序或降序，默认为升序。
若要按值对 Series 进行排序，当使用 .order() 方法，任何缺失值默认都会被放到 Series 的末尾。
在 DataFrame 上，.sort_index(axis=0, by=None, ascending=True) 方法多了一个轴向的选择参数与一个 by 参数，by 参数的作用是针对某一（些）列进行排序（不能对行使用 by 参数）：
>>> df.sort_index(by='Ohio') Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.sort_index(by=['California','Texas']) Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.sort_index(axis=1) California Ohio Texas a 2 0 1 c 5 3 4 d 8 6 7 [3 rows x 3 columns]
排名（Series.rank(method='average', ascending=True)）的作用与排序的不同之处在于，他会把对象的 values 替换成名次（从 1 到 n）。这时唯一的问题在于如何处理平级项，方法里的 method 参数就是起这个作用的，他有四个值可选：average, min, max, first。
>>> ser=Series([3,2,0,3],index=list('abcd')) >>> ser a 3 b 2 c 0 d 3 dtype: int64 >>> ser.rank() a 3.5 b 2.0 c 1.0 d 3.5 dtype: float64 >>> ser.rank(method='min') a 3 b 2 c 1 d 3 dtype: float64 >>> ser.rank(method='max') a 4 b 2 c 1 d 4 dtype: float64 >>> ser.rank(method='first') a 3 b 2 c 1 d 4 dtype: float64
注意在 ser[0]=ser[3] 这对平级项上，不同 method 参数表现出的不同名次。
DataFrame 的 .rank(axis=0, method='average', ascending=True) 方法多了个 axis 参数，可选择按行或列分别进行排名，暂时好像没有针对全部元素的排名方法。
统计方法
pandas 对象有一些统计方法。它们大部分都属于约简和汇总统计，用于从 Series 中提取单个值，或从 DataFrame 的行或列中提取一个 Series。
比如 DataFrame.mean(axis=0,skipna=True) 方法，当数据集中存在 NA 值时，这些值会被简单跳过，除非整个切片（行或列）全是 NA，如果不想这样，则可以通过 skipna=False 来禁用此功能：
>>> df
one two
a 1.40 NaN
b 7.10 -4.5
c NaN NaN
d 0.75 -1.3
[4 rows x 2 columns]
>>> df.mean()
one 3.083333
two -2.900000
dtype: float64
>>> df.mean(axis=1)
a 1.400
b 1.300
c NaN
d -0.275
dtype: float64
>>> df.mean(axis=1,skipna=False)
a NaN
b 1.300
c NaN
d -0.275
dtype: float64其他常用的统计方法有：
| ######################## | ****************************************** |
| count | 非 NA 值的数量 |
| describe | 针对 Series 或 DF 的列计算汇总统计 |
| min , max | 最小值和最大值 |
| argmin , argmax | 最小值和最大值的索引位置（整数） |
| idxmin , idxmax | 最小值和最大值的索引值 |
| quantile | 样本分位数（0 到 1） |
| sum | 求和 |
| mean | 均值 |
| median | 中位数 |
| mad | 根据均值计算平均绝对离差 |
| var | 方差 |
| std | 标准差 |
| skew | 样本值的偏度（三阶矩） |
| kurt | 样本值的峰度（四阶矩） |
| cumsum | 样本值的累计和 |
| cummin , cummax | 样本值的累计最大值和累计最小值 |
| cumprod | 样本值的累计积 |
| diff | 计算一阶差分（对时间序列很有用） |
| pct_change | 计算百分数变化 |
Umgang mit fehlenden Daten
Der Hauptausdruck von NA in Pandas ist np.nan. Darüber hinaus wird Pythons integriertes None auch als NA behandelt .
Es gibt vier Möglichkeiten, mit NA umzugehen: dropna , fillna , isnull , notnull .
ist(nicht)null
Dieses Methodenpaar führt Anwendungen auf Elementebene für das Objekt aus und gibt dann ein boolesches Array zurück, das im Allgemeinen für die boolesche Indizierung verwendet werden kann.
dropna
Für eine Serie gibt dropna eine Serie zurück, die nur nicht leere Daten und Indexwerte enthält.
Das Problem liegt in der Art und Weise, wie DataFrame verarbeitet wird, denn sobald es gelöscht wird, muss mindestens eine Zeile (Spalte) verloren gehen. Die Lösung hier ähnelt der vorherigen, übergibt jedoch noch einen zusätzlichen Parameter: dropna(axis=0, how='any', thresh=None) Der optionale Wert des Parameters „how“ ist „any“ oder „all“. all verwirft die Zeile (Spalte) nur, wenn alle Slice-Elemente NA sind. Ein weiterer interessanter Parameter ist Thresh, der vom Typ Integer ist. Seine Funktion besteht darin, dass er beispielsweise beibehalten wird, wenn mindestens 3 Nicht-NA-Werte in einer Zeile vorhanden sind. Zusätzlich zum Basistyp kann der Wertparameter in
fillna
fillna(value=None, method=None, axis=0) auch ein Wörterbuch verwenden, sodass verschiedene Spalten mit unterschiedlichen Werten gefüllt werden können. Die Verwendung der Methode ist die gleiche wie bei der vorherigen .reindex()-Methode, daher werde ich hier nicht auf Details eingehen.
Inplace-Parameter
Es gibt einen Punkt, den ich vorher noch nicht erwähnt habe, aber nachdem ich das gesamte Beispiel geschrieben habe, habe ich festgestellt, dass er ziemlich wichtig ist. Unter den Methoden von Series- und DataFrame-Objekten verfügt jede Methode, die das Array ändert und ein neues Array zurückgibt, häufig über den optionalen Parameter replace=False. Wenn es manuell auf „True“ gesetzt wird, kann das ursprüngliche Array ersetzt werden.
Das obige ist der detaillierte Inhalt vonPandas-Grundlagen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!