pandas---数据结构介绍

基本原则:数据对齐是固有的。标签和数据之间的联系不会被打破，除非你明确地做了。

我们将简要介绍数据结构，然后在单独的部分中考虑所有功能和方法的广泛类别。

一 Series

Series是一个一维的标签数组，可以保存任何数据类型(整数、字符串、浮点数、Python对象等)。轴标签被统称为索引。创建一个Series的基本方法是调用:

import numpy as np
import pandas as pd

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

data可以是下面类型：

一个Python 字典

一个ndarray对象

一个标量值

index是一个轴标签的列表。这可以根据数据的不同而分成几个不同的情况:

（1）如果data是一个ndarray对象，index必须与data的长度相同。如果没有index传入，默认值为[0, 1, 2, ……, len(data)-1]

In [1]: import numpy as np

In [2]: import pandas as pd

In [3]: s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])

In [4]: s
Out[4]:
a    0.804583
b   -0.824178
c   -0.490994
d    0.641120
e   -1.064628
dtype: float64

In [5]: s.index
Out[5]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

In [6]: pd.Series(np.random.randn(5))
Out[6]:
0   -0.627069
1    0.217971
2    0.176098
3   -0.444478
4    0.449116
dtype: float64

注意：pandas支持非唯一的索引值。如果一个不支持重复索引值的操作被尝试，那么在那个时候将会抛出一个异常。

（2）如果data是一个dict，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(not a number)是pandas中使用的标准数据缺失的数据标记。

（3）如果data是一个标量值，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

Series与ndarray非常类似，对于大多数NumPy函数来说是一个有效的参数。但是，像切片这样的东西也可以分割索引。

In [11]: s[0]
Out[11]: 0.80458283501703032

In [12]: s[:3]
Out[12]:
a    0.804583
b   -0.824178
c   -0.490994
dtype: float64

In [13]: s[s > s.median()]
Out[13]:
a    0.804583
d    0.641120
dtype: float64

In [14]: s[[4, 3, 1]]
Out[14]:
e   -1.064628
d    0.641120
b   -0.824178
dtype: float64

In [15]: np.exp(s)
Out[15]:
a    2.235764
b    0.438595
c    0.612018
d    1.898605
e    0.344856
dtype: float64

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

4000
[code]In [16]: s['a']
Out[16]: 0.80458283501703032

In [17]: s['e']
Out[17]: -1.0646280407343107

In [18]: s
Out[18]:
a    0.804583
b   -0.824178
c   -0.490994
d    0.641120
e   -1.064628
dtype: float64

In [19]: 'e' is s
Out[19]: False

In [20]: 'e' in s
Out[20]: True

In [21]: 'f' in s
Out[21]: False

如果没有包含一个标签，则会出现一个异常;使用get方法，缺失的标签将返回None或指定的默认值:

In [22]: s['f']
KeyError: 'f'

In [23]: s.get('f')

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

1.Series矢量操作和标签对齐

In [25]: s + s
Out[25]:
a    1.609166
b   -1.648357
c   -0.981987
d    1.282239
e   -2.129256
dtype: float64

In [26]: s * 2
Out[26]:
a    1.609166
b   -1.648357
c   -0.981987
d    1.282239
e   -2.129256
dtype: float64

In [27]: np.exp(s)
Out[27]:
a    2.235764
b    0.438595
c    0.612018
d    1.898605
e    0.344856
dtype: float64

Series和ndarray之间的一个关键区别是，Series之间的操作会自动根据标签对齐数据。因此，您可以编写计算，而不必考虑所涉及的Series是否具有相同的标签。

In [28]: s[1:] + s[:-1]
Out[28]:
a         NaN
b   -1.648357
c   -0.981987
d    1.282239
e         NaN
dtype: float64

在未对齐的序列之间的操作的结果将会包含索引的联合。如果一个标签没有在一个系列或另一个中找到，那么结果将被标记为缺失的NaN。能够在不进行任何显式数据对齐的情况下编写代码，在交互数据分析和研究中提供了巨大的自由度和灵活性。pandas数据结构的综合数据排列特征使pandas有别于大多数用于标记数据的相关工具。

注意：一般来说，我们选择在不同的索引对象之间进行操作的默认结果是为了避免信息的丢失而产生索引的联合。有一个索引标签，虽然数据丢失了，但是作为计算的一部分，通常是重要的信息。当然，你可以选择通过dropna函数来删除缺失数据的标签。

2.name属性

在许多情况下，Series的name将自动分配，特别是在您将在下面看到的DataFrame的一维切片时。用pandas.series.rename()重命名。

In [31]: s.name
Out[31]: 'something'

In [32]: s2 = s.rename('different')

In [33]: s2.name
Out[33]: 'different'

In [34]: s.name
Out[34]: 'something'

二 DataFrame

DataFrame是一种二维标记的数据结构，具有不同类型的列。您可以将它想象成电子表格或SQL表，或者是一个Series对象的字典。它通常是最常用的pandas对象。DataFrame接受了许多不同类型的输入:

除了数据，您还可以选择通过index(行标签)和columns(列标签)参数。如果您传递了一个索引和/或列，那么您将确保得到结果的DataFrame的索引和/或列。因此，一个Series加上一个特定的索引的字典将会丢弃所有与传递的索引不匹配的数据。

如果不传递axis标签，将根据基于常识规则的输入数据构建它们。

（1）从Series字典或嵌套字典

结果索引将是各个Series的索引的联合。如果有任何嵌套的字典，这些将首先转换成Series。如果没有传递任何列，那么列将是已排序的字典键的列表。

通过访问index和columns属性，可以分别访问行和列标签。

In [35]: d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
...:      'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
...:

In [36]: df = pd.DataFrame(d)

In [37]: df
Out[37]:
one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0

In [38]: pd.DataFrame(d, index=['d', 'b', 'a'])
Out[38]:
one  two
d  NaN  4.0
b  2.0  2.0
a  1.0  1.0

In [39]: pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three'])
Out[39]:
two three
d  4.0   NaN
b  2.0   NaN
a  1.0   NaN

In [40]: df.index
Out[40]: Index(['a', 'b', 'c', 'd'], dtype='object')

In [41]: df.columns
Out[41]: Index(['one', 'two'], dtype='object')

注意：当一组特定的列与数据的一组数据一起传递时，被传递的列会覆盖在其中的键。

（2）从值为ndarray或列表的字典

ndarry一定都是一样的长度。如果一个索引被传递，它必须与数组的长度相同。如果没有通过索引，那么结果将是range(n)，其中n是数组长度。

In [43]: d = {'one': [1., 2., 3., 4.],
...:      'two': [4., 3., 2., 1.]}
...:

In [44]: pd.DataFrame(d)
Out[44]:
one  two
0  1.0  4.0
1  2.0  3.0
2  3.0  2.0
3  4.0  1.0

In [45]: pd.DataFrame(d, index=['a', 'b', 'c', 'd'])
Out[45]:
one  two
a  1.0  4.0
b  2.0  3.0
c  3.0  2.0
d  4.0  1.0

（3）从结构化或记录数组中

In [46]: data = np.zeros((2,), dtype=[('A', 'i4'), ('B', 'f4'), ('C', 'a10')])

In [47]: data[:] = [(1, 2., 'Hello'), (2, 3., "World")]

In [48]: pd.DataFrame(data)
Out[48]:
A    B         C
0  1  2.0  b'Hello'
1  2  3.0  b'World'

In [49]: pd.DataFrame(data, index=['first', 'second'])
Out[49]:
A    B         C
first   1  2.0  b'Hello'
second  2  3.0  b'World'

In [50]: pd.DataFrame(data, columns=['C', 'A', 'B'])
Out[50]:
C  A    B
0  b'Hello'  1  2.0
1  b'World'  2  3.0

（4）从字典的列表

In [51]: data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]

In [52]: pd.DataFrame(data2)
Out[52]:
a   b     c
0  1   2   NaN
1  5  10  20.0

In [53]: pd.DataFrame(data2, index=['first', 'second'])
Out[53]:
a   b     c
first   1   2   NaN
second  5  10  20.0

In [54]: pd.DataFrame(data2, columns=['a', 'b'])
Out[54]:
a   b
0  1   2
1  5  10

（5）从元组的字典

通过传递一个元组字典，可以自动创建一个多索引的框架.

In [55]: 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[55]:
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

（6）从一个Series

结果将是一个带有与输入Series相同的索引的DataFrame，以及一个列的名称是Series的原始名称(仅在没有提供其他列名的情况下)。