Pandas-Grundlagen

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 &#39;pandas.core.series.Series&#39;>

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

DataFrame Die Neuindizierungsmethode eines Objekts ist:

. 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']

Elemente auf der angegebenen Achse löschen

bedeutet das Löschen eines Elements einer Serie oder einer Zeile (Spalte) eines DataFrame über die

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

Indizierung und Slicing

Genau wie Numpy unterstützt Pandas auch das Indizieren und Slicing durch

und das Filtern durch boolesche Arrays. obj[::]

Es sollte jedoch beachtet werden, dass der Index eines Pandas-Objekts bei Verwendung einer Nicht-Ganzzahl als Slice-Index terminal einbezogen wird, da er nicht auf Ganzzahlen beschränkt ist.

>>> 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: float64

DataFrame 的对齐操作会同时发生在行和列上。

当不希望在运算结果中出现 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!