python pandas 0.19.1 Intro to Data Structures 数据结构介绍 文档翻译

1小时前来源:cnblogs

我们将以一个快速的、非全面的pandas的基础数据结构概述来开始。应用在所有对象的数据类型、索引和轴标签/对齐等的基础操作。首先我们需要向你的命名空间引入numpy和pandas。

In [1]: import numpy as np In [2]: import pandas as pd

有个宗旨需要牢记:数据对齐是内在的。标签和数据间的链接不会被轻易改变,除非你明确地做了相应的操作来让它改变。

我们将会对数据结构进行简要的介绍,然后会考虑到单独部分的功能和方法。

是一个一维的、可容纳任何数据类型(整型,字符串,浮点型数据,Python对象等)的标记数组。它的轴标签统称为索引。最基本的创建一个Series的方法是:

>>> s = pd.Series(data, index=index)

在这里,data可以是多种事物:

一个Python字典 一个多维数组 一个标量值(如5)

传入的index是一个轴标签列表。因此,根据data的不同,有如下几种情况:

基于多维数组

如果data是一个多维数组,index必须和data的长度相同。如果没有传入index,系统将会自动创建一个index,其值为[0, ..., len(data) - 1]In [3]: s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e']) In [4]: s Out[4]: a 0.2735 b 0.6052 c -0.1692 d 1.8298 e 0.5432 dtype: float64 In [5]: s.index Out[5]: Index([u'a', u'b', u'c', u'd', u'e'], dtype='object') In [6]: pd.Series(np.random.randn(5)) Out[6]: 0 0.3674 1 -0.8230 2 -1.0295 3 -1.0523 4 -0.8502 dtype: float64

注意

从v0.8.0版本开始,pandas开始支持非唯一索引值。如果尝试一个不支持重复索引值的操作,将会引发一个异常。懒惰的原因几乎都是源于性能(有许多计算中的实例,如GroupBy中的一部分就不需要用到index)

基于字典

如果data是一个字典,如果向index 中传入的值是data中的,那么index中对应于标签数据的值将会被移出。否则,如果可能的话,将会构成一个基于排序字典的index。

In [7]: d = {'a' : 0., 'b' : 1., 'c' : 2.} In [8]: pd.Series(d) Out[8]: a 0.0 b 1.0 c 2.0 dtype: float64 In [9]: pd.Series(d, index=['b', 'c', 'd', 'a']) Out[9]: b 1.0 c 2.0 d NaN a 0.0 dtype: float64

注意

NaN在pandas代表缺失值。

基于标量值

如果data是一个标量值,就必须传入一个index。因为这个标量值的数量取决于index的长度。

In [10]: pd.Series(5., index=['a', 'b', 'c', 'd', 'e']) Out[10]: a 5.0 b 5.0 c 5.0 d 5.0 e 5.0 dtype: float64 非常像一个多维数组,拥有着numpy的大部分功能。然而,切片操作也会对索引进行切片。In [11]: s[0] Out[11]: 0.27348116325673794 In [12]: s[:3] Out[12]: a 0.2735 b 0.6052 c -0.1692 dtype: float64 In [13]: s[s > s.median] Out[13]: b 0.6052 d 1.8298 dtype: float64 In [14]: s[[4, 3, 1]] Out[14]: e 0.5432 d 1.8298 b 0.6052 dtype: float64 In [15]: np.exp(s) Out[15]: a 1.3145 b 1.8317 c 0.8443 d 6.2327 e 1.7215 dtype: float64

我们将在一个单独的 section介绍基于数组的索引。

字典型Series

一个Series就像一个固定大小的字典,你可以通过索引标签来获取和设置Series的值:

In [16]: s['a'] Out[16]: 0.27348116325673794 In [17]: s['e'] = 12. In [18]: s Out[18]: a 0.2735 b 0.6052 c -0.1692 d 1.8298 e 12.0000 dtype: float64 In [19]: 'e' in s Out[19]: True In [20]: 'f' in s Out[20]: False >>> s['f'] KeyError: 'f'

使用get方法,缺失的标签将会返回None或者指定的缺省值:

In [21]: s.get('f') In [22]: s.get('f', np.nan) Out[22]: nan

参见属性访问部分 section on attribute access.

Series的量化操作和标签对齐

当进行数据分析时,通过Series的一个又一个值进行循环通常是没有必要的。Series能够使用大部分的numpy方法。

In [23]: s + s Out[23]: a 0.5470 b 1.2104 c -0.3385 d 3.6596 e 24.0000 dtype: float64 In [24]: s * 2 Out[24]: a 0.5470 b 1.2104 c -0.3385 d 3.6596 e 24.0000 dtype: float64 In [25]: np.exp(s) Out[25]: a 1.3145 b 1.8317 c 0.8443 d 6.2327 e 162754.7914 dtype: float64

Series和多维数组的关键区别在于Series的数据对齐是基于标签的。因此,不管你的Series是不是有相同的标签,你都可以无所顾忌地进行计算。

In [26]: s[1:] + s[:-1] Out[26]: a NaN b 1.2104 c -0.3385 d 3.6596 e NaN dtype: float64

在未对齐的Series进行操作将会涉及到索引的联合。如果一个标签在一个Series或其他中都不存在,在结果中将会被标记为缺失值。能够在未做任何明确的数据对齐的情况下编写代码,为交互式数据分析和研究提供了极大的自由和灵活性。

注意

一般来说,为了避免信息错乱,我们选择在不同的索引对象间的操作的默认结果产生索引的联合。

In [27]: s = pd.Series(np.random.randn(5), name='something') In [28]: s Out[28]: 0 1.5140 1 -1.2345 2 0.5666 3 -1.0184 4 0.1081 Name: something, dtype: float64 In [29]: s.name Out[29]: 'something'

Series的name属性在很多情况下会被自动分配,特别是在你在下面看到的dataframe的一维切片中。

0.18.0.的新版本。

pandas.Series.rename 方法来对Series重命名。In [30]: s2 = s.rename("different") In [31]: s2.name Out[31]: 'different'

注意s和s2是不同的对象。

DataFrame

DataFrame 是一个拥有不同类型的列的二维的标记数据结构。你可以把它想成一个电子表格或数据库表,或者一个Seires对象的字典。它是pandas对象中最常用的一种。和Series一样,dataframe能够接受不同类型的输入:

对于dataframe中的data, 你可以选择传入index(行标签)和columns(列标签)。如果你传入了一个index和/或columns,你必须保证你传入的生成data frame的index和/或columns。因此,一个Series字典加上一个明确的索引将会丢弃所有不匹配索引的数据。

如果没有传入轴标签,系统将会基于常识规则根据输入的数据构造轴标签。

基于Series字典或字典的data frame

最终index是多种Series的index的联合。如果有任何嵌套字典,将会首先被转换成Series。如果没有传入列,列将会是字典的键的排序列表。

In [32]: d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']), ....: 'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])} ....: In [33]: df = pd.DataFrame(d) In [34]: df Out[34]: one two a 1.0 1.0 b 2.0 2.0 c 3.0 3.0 d NaN 4.0 In [35]: pd.DataFrame(d, index=['d', 'b', 'a']) Out[35]: one two d NaN 4.0 b 2.0 2.0 a 1.0 1.0 In [36]: pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three']) Out[36]: two three d 4.0 NaN b 2.0 NaN a 1.0 NaN

行和列标签能够分别通过访问index和columns属性进行访问。

注意

当一个特殊的列集合和字典同时被传入时,传入的列将会重写字典中的键。In [37]: df.index Out[37]: Index([u'a', u'b', u'c', u'd'], dtype='object') In [38]: df.columns Out[38]: Index([u'one', u'two'], dtype='object') 基于多维数组/列表的字典的data frame

多维数组必须都是相同长度的,如果传入了一个index,它必须和数组的长度相同。如果没有传入index,那么自动生成的index就是range(n),其中n是数组的长度。

In [39]: d = {'one' : [1., 2., 3., 4.], ....: 'two' : [4., 3., 2., 1.]} ....: In [40]: pd.DataFrame(d) Out[40]: one two 0 1.0 4.0 1 2.0 3.0 2 3.0 2.0 3 4.0 1.0 In [41]: pd.DataFrame(d, index=['a', 'b', 'c', 'd']) Out[41]: one two a 1.0 4.0 b 2.0 3.0 c 3.0 2.0 d 4.0 1.0 基于结构化或记录数组的data frame

这种情况和数组字典的情况相同。

In [42]: data = np.zeros((2,), dtype=[('A', 'i4'),('B', 'f4'),('C', 'a10')]) In [43]: data[:] = [(1,2.,'Hello'), (2,3.,"World")] In [44]: pd.DataFrame(data) Out[44]: A B C 0 1 2.0 Hello 1 2 3.0 World In [45]: pd.DataFrame(data, index=['first', 'second']) Out[45]: A B C first 1 2.0 Hello second 2 3.0 World In [46]: pd.DataFrame(data, columns=['C', 'A', 'B']) Out[46]: C A B 0 Hello 1 2.0 1 World 2 3.0

注意

DataFrame 并不打算向二维bumpy数组那样.

In [47]: data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}] In [48]: pd.DataFrame(data2) Out[48]: a b c 0 1 2 NaN 1 5 10 20.0 In [49]: pd.DataFrame(data2, index=['first', 'second']) Out[49]: a b c first 1 2 NaN second 5 10 20.0 In [50]: pd.DataFrame(data2, columns=['a', 'b']) Out[50]: a b 0 1 2 1 5 10 基于集合字典的data frame

你可以通过传入一个集合字典来自动创建一个多索引的frame。

In [51]: pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2}, ....: ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4}, ....: ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6}, ....: ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8}, ....: ('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}}) ....: Out[51]: a b a b c a b A B 4.0 1.0 5.0 8.0 10.0 C 3.0 2.0 6.0 7.0 NaN D NaN NaN NaN NaN 9.0 基于一个Series

创建的结果是一个和输入的Series有着相同index的dataframe ,其中一列的名字是Series的原始名字(如果其他列的名字没有提供的话)

缺失数据

更多详见 Missing data 部分。使用np.nan能够构造一个包含缺失值的data frame。或者,你还可以传入一个numpy.MaskedArray,它的mask项目将被视为缺失值。

DataFrame.from_dict

接收一个字典或一个数组序列的字典,并返回一个data frame。 It operates like the DataFrame constructor except for the orient parameter which is 'columns' by default, but which can be set to 'index' in order to use the dict keys as row labels.

DataFrame.from_records

接收一个集合列表或结构化类型的多维数组。它与正常的dataframe构造器类似,不同的是它的index或许是一个特定的结构化类型。例如:In [52]: data Out[52]: array([(1, 2.0, 'Hello'), (2, 3.0, 'World')], dtype=[('A', '

DataFrame.from_items

DataFrame.from_items的形式也与dataframe构造器类似,它接收一个(键,值)序列,其中键是列名(或行名,如果零orient=“index”的话),值是列值(或行值)。这对于构造一个特定顺序列dataframe来说非常有用。

In [54]: pd.DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])]) Out[54]: A B 0 1 4 1 2 5 2 3 6 如果你传入 orient='index’关键字,值就会变成行标签。但是这种情况下你必须接着传入列名:In [55]: pd.DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])], ....: orient='index', columns=['one', 'two', 'three']) ....: Out[55]: one two three A 1 2 3 B 4 5 6 列的选取,增加和删除

你可以使用一个相同indexed的Series对象的字典的语法对dataframe进行操作。获取,设置和删除列的语法和字典操作类似:

In [56]: df['one'] Out[56]: a 1.0 b 2.0 c 3.0 d NaN Name: one, dtype: float64 In [57]: df['three'] = df['one'] * df['two'] In [58]: df['flag'] = df['one'] > 2 In [59]: df Out[59]: one two three flag a 1.0 1.0 1.0 False b 2.0 2.0 4.0 False c 3.0 3.0 9.0 True d NaN 4.0 NaN False

列可以向一个字典那样被删除或移除:

In [60]: del df['two'] In [61]: three = df.pop('three') In [62]: df Out[62]: one flag a 1.0 False b 2.0 False c 3.0 True d NaN False

当想要插入一个标量值时,它会自动填充整列:

In [63]: df['foo'] = 'bar' In [64]: df Out[64]: one flag foo a 1.0 False bar b 2.0 False bar c 3.0 True bar d NaN False bar

当插入一个与当前dataframe有着不同index的Series时,将会以dataframe的index为基准。

In [65]: df['one_trunc'] = df['one'][:2] In [66]: df Out[66]: one flag foo one_trunc a 1.0 False bar 1.0 b 2.0 False bar 2.0 c 3.0 True bar NaN d NaN False bar NaN

你可以插入原始多维数组,但是它们的长度必须和dataframe的index的长度相匹配。

默认情况下会在末尾插入列。inser功能允许在特定位置插入列:

In [67]: df.insert(1, 'bar', df['one']) In [68]: df Out[68]: one bar flag foo one_trunc a 1.0 1.0 False bar 1.0 b 2.0 2.0 False bar 2.0 c 3.0 3.0 True bar NaN d NaN NaN False bar NaN 受 dplyr’s 动词的变异, DataFrame 有一个 方法能够允许你轻易地创建一个从现有列派生出的新列。In [69]: iris = pd.read_csv('data/iris.data') In [70]: iris.head Out[70]: SepalLength SepalWidth PetalLength PetalWidth Name 0 5.1 3.5 1.4 0.2 Iris-setosa 1 4.9 3.0 1.4 0.2 Iris-setosa 2 4.7 3.2 1.3 0.2 Iris-setosa 3 4.6 3.1 1.5 0.2 Iris-setosa 4 5.0 3.6 1.4 0.2 Iris-setosa In [71]: (iris.assign(sepal_ratio = iris['SepalWidth'] / iris['SepalLength']) ....: .head) ....: Out[71]: SepalLength SepalWidth PetalLength PetalWidth Name sepal_ratio 0 5.1 3.5 1.4 0.2 Iris-setosa 0.6863 1 4.9 3.0 1.4 0.2 Iris-setosa 0.6122 2 4.7 3.2 1.3 0.2 Iris-setosa 0.6809 3 4.6 3.1 1.5 0.2 Iris-setosa 0.6739 4 5.0 3.6 1.4 0.2 Iris-setosa 0.7200

以上是插入一个预先计算好的值的例子。我们也可以传入一个单参数的函数.

In [72]: iris.assign(sepal_ratio = lambda x: (x['SepalWidth'] / ....: x['SepalLength'])).head ....: Out[72]: SepalLength SepalWidth PetalLength PetalWidth Name sepal_ratio 0 5.1 3.5 1.4 0.2 Iris-setosa 0.6863 1 4.9 3.0 1.4 0.2 Iris-setosa 0.6122 2 4.7 3.2 1.3 0.2 Iris-setosa 0.6809 3 4.6 3.1 1.5 0.2 Iris-setosa 0.6739 4 5.0 3.6 1.4 0.2 Iris-setosa 0.7200 assign 总是 returns返回一个数据的副本,而不会改变原data frame.

当你手边没有一个参考的dataframe时,相对于要插入的实际值来说,传入一个可变的值是非常有用的。在链式操作中使用assign是非常普遍的。例如,我们可以限制dataframe只选择那些长度大于5的SepalLength进行计算和作图:

In [73]: (iris.query('SepalLength > 5') ....: .assign(SepalRatio = lambda x: x.SepalWidth / x.SepalLength, ....: PetalRatio = lambda x: x.PetalWidth / x.PetalLength) ....: .plot(kind='scatter', x='SepalRatio', y='PetalRatio')) ....: Out[73]:

由于传入了一个函数,该函数是在被分配到的dataframe上进行计算,重要的是,这个dataframe是那些长度大于5的行的dataframe.首先进行过滤,然后进行计算。在这个例子中,我们没有可过滤的dataframe。

assign的函数签名是简单的**kwargs。键是新字段的列名,值是用来插入的值(例如一个Series或者numpy数组),或者一个单参数的函数。将会返回一个插入了新值的dataframe的副本。

警告

由于assign的函数签名是**kwargs,是个字典,那么在生成的dataframe中插入的新列的顺序不能够保证和你传入的顺序一样。一般是在dataframe的最后按字母顺序插入。

所有的表达式会被首先计算,然后被分配。所以你不能在同一个assign中使用正在分配的列。

In [74]: # 不要这样做 df.assign(C = lambda x: x['A'] + x['B'], D = lambda x: x['A'] + x['C']) In [2]: # 而是需要把它分给两个assign (df.assign(C = lambda x: x['A'] + x['B']) .assign(D = lambda x: x['A'] + x['C']))

基本的索引如下所示:

操作 语法 结果 选取列 df[col] Series 通过标签选取行 df.loc[label] Series 通过整数位置选取行 df.iloc[loc] Series 行切片 df[5:10] DataFrame 通过布尔向量选取行 df[bool_vec] DataFrame

选取行,例如,返回一个Series,其index就是dataframe的列。

In [75]: df.loc['b'] Out[75]: one 2 bar 2 flag False foo bar one_trunc 2 Name: b, dtype: object In [76]: df.iloc[2] Out[76]: one 3 bar 3 flag True foo bar one_trunc NaN Name: c, dtype: object

对于更复杂的基于标签的索引和切片的更详尽的处理,参见 section on indexing.

数据对齐和算法

dataframe对象间的数据对齐会根据索引(行标签)和列自动对齐。同样,产生的结果将是行和列标签的联合。

In [77]: df = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D']) In [78]: df2 = pd.DataFrame(np.random.randn(7, 3), columns=['A', 'B', 'C']) In [79]: df + df2 Out[79]: A B C D 0 0.5222 0.3225 -0.7566 NaN 1 -0.8441 0.2334 0.8818 NaN 2 -2.2079 -0.1572 -0.3875 NaN 3 2.8080 -1.0927 1.0432 NaN 4 -1.7511 -2.0812 2.7477 NaN 5 -3.2473 -1.0850 0.7898 NaN 6 -1.7107 0.0661 0.1294 NaN 7 NaN NaN NaN NaN 8 NaN NaN NaN NaN 9 NaN NaN NaN NaN

当在dataframe和Series间进行操作时,默认操作是将Series的index和dataframe的列对齐,并broadcasting 行。例如:

In [80]: df - df.iloc[0] Out[80]: A B C D 0 0.0000 0.0000 0.0000 0.0000 1 -2.6396 -1.0702 1.7214 -0.7896 2 -2.7662 -1.6918 2.2776 -2.5401 3 0.8679 -3.5247 1.9365 -0.1331 4 -1.9883 -3.2162 2.0464 -1.0700 5 -3.3932 -4.0976 1.6366 -2.1635 6 -1.3668 -1.9572 1.6523 -0.7191 7 -0.7949 -2.1663 0.9706 -2.6297 8 -0.8383 -1.3630 1.6702 -2.0865 9 0.8588 0.0814 3.7305 -1.3737

在对时间序列数据进行操作的特殊情况中,DataFrame 的index包含了日期,因此broadcasting将会对列进行:

In [81]: index = pd.date_range('1/1/2000', periods=8) In [82]: df = pd.DataFrame(np.random.randn(8, 3), index=index, columns=list('ABC')) In [83]: df Out[83]: A B C 2000-01-01 0.2731 0.3604 -1.1515 2000-01-02 1.1577 1.4787 -0.6528 2000-01-03 -0.7712 0.2203 -0.5739 2000-01-04 -0.6356 -1.1703 -0.0789 2000-01-05 -1.4687 0.1705 -1.8796 2000-01-06 -1.2037 0.9568 -1.1383 2000-01-07 -0.6540 -0.2169 0.3843 2000-01-08 -2.1639 -0.8145 -1.2475 In [84]: type(df['A']) Out[84]: pandas.core.series.Series In [85]: df - df['A'] Out[85]: 2000-01-01 00:00:00 2000-01-02 00:00:00 2000-01-03 00:00:00 \ 2000-01-01 NaN NaN NaN 2000-01-02 NaN NaN NaN 2000-01-03 NaN NaN NaN 2000-01-04 NaN NaN NaN 2000-01-05 NaN NaN NaN 2000-01-06 NaN NaN NaN 2000-01-07 NaN NaN NaN 2000-01-08 NaN NaN NaN 2000-01-04 00:00:00 ... 2000-01-08 00:00:00 A B C 2000-01-01 NaN ... NaN NaN NaN NaN 2000-01-02 NaN ... NaN NaN NaN NaN 2000-01-03 NaN ... NaN NaN NaN NaN 2000-01-04 NaN ... NaN NaN NaN NaN 2000-01-05 NaN ... NaN NaN NaN NaN 2000-01-06 NaN ... NaN NaN NaN NaN 2000-01-07 NaN ... NaN NaN NaN NaN 2000-01-08 NaN ... NaN NaN NaN NaN [8 rows x 11 columns] df - df['A']

现在已不再使用,并将会在以后的版本中移除。该操作正确的方法是:

df.sub(df['A'], axis=0)

对匹配和广播行为的显式控制,参见 flexible binary operations.

你期待的对标量的操作:

In [86]: df * 5 + 2 Out[86]: A B C 2000-01-01 3.3655 3.8018 -3.7575 2000-01-02 7.7885 9.3936 -1.2641 2000-01-03 -1.8558 3.1017 -0.8696 2000-01-04 -1.1781 -3.8513 1.6056 2000-01-05 -5.3437 2.8523 -7.3982 2000-01-06 -4.0186 6.7842 -3.6915 2000-01-07 -1.2699 0.9157 3.9217 2000-01-08 -8.8194 -2.0724 -4.2375 In [87]: 1 / df Out[87]: A B C 2000-01-01 3.6616 2.7751 -0.8684 2000-01-02 0.8638 0.6763 -1.5318 2000-01-03 -1.2967 4.5383 -1.7424 2000-01-04 -1.5733 -0.8545 -12.6759 2000-01-05 -0.6809 5.8662 -0.5320 2000-01-06 -0.8308 1.0451 -0.8785 2000-01-07 -1.5291 -4.6113 2.6019 2000-01-08 -0.4621 -1.2278 -0.8016 In [88]: df ** 4 Out[88]: A B C 2000-01-01 0.0056 0.0169 1.7581e+00 2000-01-02 1.7964 4.7813 1.8162e-01 2000-01-03 0.3537 0.0024 1.0849e-01 2000-01-04 0.1632 1.8755 3.8733e-05 2000-01-05 4.6534 0.0008 1.2482e+01 2000-01-06 2.0995 0.8382 1.6789e+00 2000-01-07 0.1829 0.0022 2.1819e-02 2000-01-08 21.9244 0.4401 2.4219e+00

布尔操作也是如此:

In [89]: df1 = pd.DataFrame({'a' : [1, 0, 1], 'b' : [0, 1, 1] }, dtype=bool) In [90]: df2 = pd.DataFrame({'a' : [0, 1, 1], 'b' : [1, 1, 0] }, dtype=bool) In [91]: df1 & df2 Out[91]: a b 0 False False 1 False True 2 True False In [92]: df1 | df2 Out[92]: a b 0 True True 1 True True 2 True True In [93]: df1 ^ df2 Out[93]: a b 0 True True 1 True False 2 False True In [94]: -df1 Out[94]: a b 0 False True 1 True False 2 False False 转置 # 只显示前5行 In [95]: df[:5].T Out[95]: 2000-01-01 2000-01-02 2000-01-03 2000-01-04 2000-01-05 A 0.2731 1.1577 -0.7712 -0.6356 -1.4687 B 0.3604 1.4787 0.2203 -1.1703 0.1705 C -1.1515 -0.6528 -0.5739 -0.0789 -1.8796 DataFrame与 NumPy功能的交互

如果dataframe中的数据是数值型的话,Numpy的功能(如log, exp, sort等)和多种其他的numpy功能可以没有问题地使用在dataframe上。

In [96]: np.exp(df) Out[96]: A B C 2000-01-01 1.3140 1.4338 0.3162 2000-01-02 3.1826 4.3873 0.5206 2000-01-03 0.4625 1.2465 0.5633 2000-01-04 0.5296 0.3103 0.9241 2000-01-05 0.2302 1.1859 0.1526 2000-01-06 0.3001 2.6034 0.3204 2000-01-07 0.5200 0.8050 1.4686 2000-01-08 0.1149 0.4429 0.2872 In [97]: np.asarray(df) Out[97]: array([[ 0.2731, 0.3604, -1.1515], [ 1.1577, 1.4787, -0.6528], [-0.7712, 0.2203, -0.5739], [-0.6356, -1.1703, -0.0789], [-1.4687, 0.1705, -1.8796], [-1.2037, 0.9568, -1.1383], [-0.654 , -0.2169, 0.3843], [-2.1639, -0.8145, -1.2475]])

dataframe中的dot方法能够实现矩阵相乘。

In [98]: df.T.dot(df) Out[98]: A B C A 11.1298 2.8864 6.0015 B 2.8864 5.3895 -1.8913 C 6.0015 -1.8913 8.6204

相似地,Series的dot方法能够执行点积:

In [99]: s1 = pd.Series(np.arange(5,10)) In [100]: s1.dot(s1) Out[100]: 255

dataframe并不旨在做多维数组的替代,因为它的索引语法在矩阵方面和多维数组大不相同。

大规模的dataframe在控制台显示时将会被截断。你可以使用info来获取一个概括。(下面我读取一个csv试图的baseball数据集)

In [101]: baseball = pd.read_csv('data/baseball.csv') In [102]: print(baseball) id player year stint ... hbp sh sf gidp 0 88641 womacto01 2006 2 ... 0.0 3.0 0.0 0.0 1 88643 schilcu01 2006 1 ... 0.0 0.0 0.0 0.0 .. ... ... ... ... ... ... ... ... ... 98 89533 aloumo01 2007 1 ... 2.0 0.0 3.0 13.0 99 89534 alomasa02 2007 1 ... 0.0 0.0 0.0 0.0 [100 rows x 23 columns] In [103]: baseball.infoRangeIndex: 100 entries, 0 to 99 Data columns (total 23 columns): id 100 non-null int64 player 100 non-null object year 100 non-null int64 stint 100 non-null int64 team 100 non-null object lg 100 non-null object g 100 non-null int64 ab 100 non-null int64 r 100 non-null int64 h 100 non-null int64 X2b 100 non-null int64 X3b 100 non-null int64 hr 100 non-null int64 rbi 100 non-null float64 sb 100 non-null float64 cs 100 non-null float64 bb 100 non-null int64 so 100 non-null float64 ibb 100 non-null float64 hbp 100 non-null float64 sh 100 non-null float64 sf 100 non-null float64 gidp 100 non-null float64 dtypes: float64(9), int64(11), object(3) memory usage: 18.0+ KB

然而,使用to_string将会返回一个表格中的dataframe的字符串表示,虽然它不会总是符合控制台的宽度:

In [104]: print(baseball.iloc[-20:, :12].to_string) id player year stint team lg g ab r h X2b X3b 80 89474 finlest01 2007 1 COL NL 43 94 9 17 3 0 81 89480 embreal01 2007 1 OAK AL 4 0 0 0 0 0 82 89481 edmonji01 2007 1 SLN NL 117 365 39 92 15 2 83 89482 easleda01 2007 1 NYN NL 76 193 24 54 6 0 84 89489 delgaca01 2007 1 NYN NL 139 538 71 139 30 0 85 89493 cormirh01 2007 1 CIN NL 6 0 0 0 0 0 86 89494 coninje01 2007 2 NYN NL 21 41 2 8 2 0 87 89495 coninje01 2007 1 CIN NL 80 215 23 57 11 1 88 89497 clemero02 2007 1 NYA AL 2 2 0 1 0 0 89 89498 claytro01 2007 2 BOS AL 8 6 1 0 0 0 90 89499 claytro01 2007 1 TOR AL 69 189 23 48 14 0 91 89501 cirilje01 2007 2 ARI NL 28 40 6 8 4 0 92 89502 cirilje01 2007 1 MIN AL 50 153 18 40 9 2 93 89521 bondsba01 2007 1 SFN NL 126 340 75 94 14 0 94 89523 biggicr01 2007 1 HOU NL 141 517 68 130 31 3 95 89525 benitar01 2007 2 FLO NL 34 0 0 0 0 0 96 89526 benitar01 2007 1 SFN NL 19 0 0 0 0 0 97 89530 ausmubr01 2007 1 HOU NL 117 349 38 82 16 3 98 89533 aloumo01 2007 1 NYN NL 87 328 51 112 19 1 99 89534 alomasa02 2007 1 NYN NL 8 22 1 3 1 0

从0.10.0版本开始,列数过多的dataframes将默认多行显示:

In [105]: pd.DataFrame(np.random.randn(3, 12)) Out[105]: 0 1 2 3 4 5 6 \ 0 2.173014 1.273573 0.888325 0.631774 0.206584 -1.745845 -0.505310 1 -1.240418 2.177280 -0.082206 0.827373 -0.700792 0.524540 -1.101396 2 0.269598 -0.453050 -1.821539 -0.126332 -0.153257 0.405483 -0.504557 7 8 9 10 11 0 1.376623 0.741168 -0.509153 -2.012112 -1.204418 1 1.115750 0.294139 0.286939 1.709761 -0.212596 2 1.405148 0.778061 -0.799024 -0.670727 0.086877

你可以通过设置display.width选项来改变每一行显示的列数量:

In [106]: pd.set_option('display.width', 40) # 默认为80 In [107]: pd.DataFrame(np.random.randn(3, 12)) Out[107]: 0 1 2 \ 0 1.179465 0.777427 -1.923460 1 0.054928 0.776156 0.372060 2 -0.243404 -1.506557 -1.977226 3 4 5 \ 0 0.782432 0.203446 0.250652 1 0.710963 -0.784859 0.168405 2 -0.226582 -0.777971 0.231309 6 7 8 \ 0 -2.349580 -0.540814 -0.748939 1 0.159230 0.866492 1.266025 2 1.394479 0.723474 -0.097256 9 10 11 0 -0.994345 1.478624 -0.341991 1 0.555240 0.731803 0.219383 2 0.375274 -0.314401 -2.363136

你可以通过设置display.max_colwidth来调整每一列的最大宽度:

In [108]: datafile={'filename': ['filename_01','filename_02'], .....: 'path': ["media/user_name/storage/folder_01/filename_01", .....: "media/user_name/storage/folder_02/filename_02"]} .....: In [109]: pd.set_option('display.max_colwidth',30) In [110]: pd.DataFrame(datafile) Out[110]: filename \ 0 filename_01 1 filename_02 path 0 media/user_name/storage/fo... 1 media/user_name/storage/fo... In [111]: pd.set_option('display.max_colwidth',100) In [112]: pd.DataFrame(datafile) Out[112]: filename \ 0 filename_01 1 filename_02 path 0 media/user_name/storage/folder_01/filename_01 1 media/user_name/storage/folder_02/filename_02

你也可以通过expand_frame_repr 选项来禁用此功能。这将会在一个块中打印表格。

DataFrame 的列属性获取和IPython实现

如果一个dataframe列标签是一个有效的Python变量名,该列就能够通过属性的方式访问:

In [113]: df = pd.DataFrame({'foo1' : np.random.randn(5), .....: 'foo2' : np.random.randn(5)}) .....: In [114]: df Out[114]: foo1 foo2 0 -0.412237 0.213232 1 -0.237644 1.740139 2 1.272869 -0.241491 3 1.220450 -0.868514 4 1.315172 0.407544 In [115]: df.foo1 Out[115]: 0 -0.412237 1 -0.237644 2 1.272869 3 1.220450 4 1.315172 Name: foo1, dtype: float64

列还与 Python 实现机制相连,所以它们能够通过tab键实现自动完成。Panel

Panel是一个用处不多但仍旧很重要的三维数据容器。词条panel data 来自于计量经济学,并且是pandas这个名称的一部分来源( pan(el)-da(ta)-s)。panel的3个轴的名称旨在为包含panel数据的描述操作提供一些语义,尤其是panel数据的计量分析。然而,为了交叉分析dataframe对象集,你可能会发现panel的轴名称有点武断:

项: 0轴,每一项对应于一个包含于其中的dataframe 主轴: 1轴, 是每个data frame的index (行) 次轴: 2轴,是每个data frame的columns In [116]: wp = pd.Panel(np.random.randn(2, 5, 4), items=['Item1', 'Item2'], .....: major_axis=pd.date_range('1/1/2000', periods=5), .....: minor_axis=['A', 'B', 'C', 'D']) .....: In [117]: wp Out[117]:Dimensions: 2 (items) x 5 (major_axis) x 4 (minor_axis) Items axis: Item1 to Item2 Major_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00 Minor_axis axis: A to D In [118]: data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), .....: 'Item2' : pd.DataFrame(np.random.randn(4, 2))} .....: In [119]: pd.Panel(data) Out[119]:Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis) Items axis: Item1 to Item2 Major_axis axis: 0 to 3 Minor_axis axis: 0 to 2

注意,字典中的值只需要可转换为dataframe。因此,它们可以是dataframe中任何有效的输入。

一个有用的工厂方法是Panel.from_dict, 它能够接受一个dataframe字典和下列命名参数: 参数 默认 描述 intersect False 删除指数不对齐的元素 orient items 使dataframe的列作为panel的项

例如,与上面的结构相比:

In [120]: pd.Panel.from_dict(data, orient='minor') Out[120]:Orient 对于混合类型的dataframe特别有用。如果你传入了一个其列是混合类型dataframe对象,除非你传入orient=‘minor’,否则所有的数据类型都将会向上变为object类型。In [121]: df = pd.DataFrame({'a': ['foo', 'bar', 'baz'], .....: 'b': np.random.randn(3)}) .....: In [122]: df Out[122]: a b 0 foo -1.142863 1 bar -1.015321 2 baz 0.683625 In [123]: data = {'item1': df, 'item2': df} In [124]: panel = pd.Panel.from_dict(data, orient='minor') In [125]: panel['a'] Out[125]: item1 item2 0 foo foo 1 bar bar 2 baz baz In [126]: panel['b'] Out[126]: item1 item2 0 -1.142863 -1.142863 1 -1.015321 -1.015321 2 0.683625 0.683625 In [127]: panel['b'].dtypes Out[127]: item1 float64 item2 float64 dtype: object

注意

Panel由于不如Series和DataFrame常用,所以它也不像它们那样拥有那么多的好用的功能。dataframe中许多方法和选项在panel中都不能适用。我们将会继续努力。

基于使用to_panel方法的dataframe的panel

在v0.7中介绍了用来代替LongPanel的这个方法,它能够将一个两层索引的DataFrame转换为一个panel。

In [128]: midx = pd.MultiIndex(levels=[['one', 'two'], ['x','y']], labels=[[1,1,0,0],[1,0,1,0]]) In [129]: df = pd.DataFrame({'A' : [1, 2, 3, 4], 'B': [5, 6, 7, 8]}, index=midx) In [130]: df.to_panel Out[130]:Dimensions: 2 (items) x 2 (major_axis) x 2 (minor_axis) Items axis: A to B Major_axis axis: one to two Minor_axis axis: x to y 项的选取/增加/删除

和dataframe是多个Series组成的字典结构类似,panel就像是一个由多个dataframe组成的字典:

In [131]: wp['Item1'] Out[131]: A B C D 2000-01-01 -0.729430 0.427693 -0.121325 -0.736418 2000-01-02 0.739037 -0.648805 -0.383057 0.385027 2000-01-03 2.321064 -1.290881 0.105458 -1.097035 2000-01-04 0.158759 -1.261191 -0.081710 1.390506 2000-01-05 -1.962031 -0.505580 0.021253 -0.317071 In [132]: wp['Item3'] = wp['Item1'] / wp['Item2']

Panel的插入和删除的接口和dataframe一样。对于dataframe来说,如果项是一个有效的Python识别器,你可以适用Tab自动完成来像访问属性一样访问它。

转置

可以适用转置方法改变一个panel(该方法默认不是生成一个副本,除非数据是异构的)

Dimensions: 4 (items) x 3 (major_axis) x 5 (minor_axis) Items axis: A to D Major_axis axis: Item1 to Item3 Minor_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00 操作 语法 结果 选取项 wp[item] DataFrame 在主轴标签上切片 wp.major_xs(val) DataFrame 在次轴标签上切片 wp.minor_xs(val) DataFrame

例如,使用之前的示例数据,我们可以:

In [134]: wp['Item1'] Out[134]: A B C D 2000-01-01 -0.729430 0.427693 -0.121325 -0.736418 2000-01-02 0.739037 -0.648805 -0.383057 0.385027 2000-01-03 2.321064 -1.290881 0.105458 -1.097035 2000-01-04 0.158759 -1.261191 -0.081710 1.390506 2000-01-05 -1.962031 -0.505580 0.021253 -0.317071 In [135]: wp.major_xs(wp.major_axis[2]) Out[135]: Item1 Item2 Item3 A 2.321064 -0.538606 -4.309389 B -1.290881 0.791512 -1.630905 C 0.105458 -0.020302 -5.194337 D -1.097035 0.184430 -5.948253 In [136]: wp.minor_axis Out[136]: Index([u'A', u'B', u'C', u'D'], dtype='object') In [137]: wp.minor_xs('C') Out[137]: Item1 Item2 Item3 2000-01-01 -0.121325 1.413524 -0.085832 2000-01-02 -0.383057 1.243178 -0.308127 2000-01-03 0.105458 -0.020302 -5.194337 2000-01-04 -0.081710 -1.811565 0.045105 2000-01-05 0.021253 -1.040542 -0.020425 In [138]: wp.reindex(items=['Item1']).squeeze Out[138]: A B C D 2000-01-01 -0.729430 0.427693 -0.121325 -0.736418 2000-01-02 0.739037 -0.648805 -0.383057 0.385027 2000-01-03 2.321064 -1.290881 0.105458 -1.097035 2000-01-04 0.158759 -1.261191 -0.081710 1.390506 2000-01-05 -1.962031 -0.505580 0.021253 -0.317071 In [139]: wp.reindex(items=['Item1'], minor=['B']).squeeze Out[139]: 2000-01-01 0.427693 2000-01-02 -0.648805 2000-01-03 -1.290881 2000-01-04 -1.261191 2000-01-05 -0.505580 Freq: D, Name: B, dtype: float64 一个panel能够被一个分层索引的dataframe二维表格替代。详见hierarchical indexing。使用to_frame方法将一个panel转换为一个dataframe。In [140]: panel = pd.Panel(np.random.randn(3, 5, 4), items=['one', 'two', 'three'], .....: major_axis=pd.date_range('1/1/2000', periods=5), .....: minor_axis=['a', 'b', 'c', 'd']) .....: In [141]: panel.to_frame Out[141]: one two three major minor 2000-01-01 a -1.876826 -0.383171 -0.117339 b -1.873827 -0.172217 0.780048 c -0.251457 -1.674685 2.162047 d 0.027599 0.762474 0.874233 2000-01-02 a 1.235291 0.481666 -0.764147 b 0.850574 1.217546 -0.484495 c -1.140302 0.577103 0.298570 d 2.149143 -0.076021 0.825136 2000-01-03 a 0.504452 0.720235 -0.388020 b 0.678026 0.202660 -0.339279 c -0.628443 -0.314950 0.141164 d 1.191156 -0.410852 0.565930 2000-01-04 a -1.145363 0.542758 -1.749969 b -0.523153 1.955407 -1.402941 c -1.299878 -0.940645 0.623222 d -0.110240 0.076257 0.020129 2000-01-05 a -0.333712 -0.897159 -2.858463 b 0.416876 -1.265679 0.885765 c -0.436400 -0.528311 0.158014 d 0.999768 -0.660014 -1.981797 四维Panel 和多维Panel (不推荐使用)

警告

在0.19.0版本中不推荐使用四维Panel和多维panel,它们将会在以后的版本中被逐渐移除。推荐的使用方式是使用 xarray package来代替这种多维数据。Pandas提供了一个to_xarray方法来自动完成此转换。

详见 docs of a previous version 。

本文开发(python)相关术语:python基础教程 python多线程 web开发工程师 软件开发工程师 软件开发流程

分页:12
转载请注明
本文标题:Python pandas 0.19.1 Intro to Data Structures 数据结构介绍 文档翻译
本站链接:http://www.codesec.net/view/522711.html
分享请点击:


1.凡CodeSecTeam转载的文章,均出自其它媒体或其他官网介绍,目的在于传递更多的信息,并不代表本站赞同其观点和其真实性负责;
2.转载的文章仅代表原创作者观点,与本站无关。其原创性以及文中陈述文字和内容未经本站证实,本站对该文以及其中全部或者部分内容、文字的真实性、完整性、及时性,不作出任何保证或承若;
3.如本站转载稿涉及版权等问题,请作者及时联系本站,我们会及时处理。
登录后可拥有收藏文章、关注作者等权限...
技术大类 技术大类 | 开发(python) | 评论(0) | 阅读(55)