Pandas对象介绍
在基础的层面上，Pandas对象可以被认为是NumPy结构化数组的增强版本，在Pandas中行和列是由标签标识的而不是简单的整型索引。如我们在本章的课程中所见，Pandas在基本的数据结构上提供了许多有用的工具，方法和功能，但是所有的这些方法工具要求我们理解这些结构是什么样的。因此，在我们继续前进之前，让我们介绍Pandas的基本数据结构：Series, DataFrame和Index。
使用标准的NumPy和Pandas导入来开始我们的代码阶段。
import numpy as np
import pandas as pd
Pandas Series 对象
Pandas Series 是带有索引数据的一维数组。它可以由列表或数组创建，例子如下：
data = pd.Series([0.25, 0.5, 0.75, 1.0])
data
0 0.25
1 0.50
2 0.75
3 1.00
dtype: float64
如我们在输出中所见，Series把一序列值和一序列索引结合在一起。值，索引分别可以通过values和index属性来访问。values的内容是熟悉的NumPy数组。
data.values
array([ 0.25, 0.5 , 0.75, 1. ])
index是一种类似数组的类型 pd.Index，随后会有详尽的讨论。
data.index
RangeIndex(start=0, stop=4, step=1)
就像NumPy数组一样，可以通过python方括号标记里面引用关联的索引来访问对应的数据值。
data[1]
0.5
data[1:3]
1 0.50
2 0.75
dtype: float64
然而，正如我们将看到的，Pandas的Series比它所模拟的一维NumPy更通用，更灵活。
Series作为广义的NumPy 数组
就我们目前所见而言，好像看起来，Series对象基本上可以和NumPy的一维数组可以互换。但关键的不同在于index的表达：NumPy数组使用隐含定义的整型索引来访问数据，而Pandas Series有明确定义的索引与数据像关联。
明确的索引定义给Series对象额外的能力。例如，索引可以不仅是整型，它可以由任何喜欢的类型组成。例如，如果愿意，我们可以使用字符作为索引：
data = pd.Series([0.25, 0.5, 0.75, 1.0],
index=['a', 'b', 'c', 'd'])
data
a 0.25
b 0.50
c 0.75
d 1.00
dtype: float64
内容的访问同我们期待的一样：
data['b']
0.5
我们甚至可以使用非连续索引：
data = pd.Series([0.25, 0.5, 0.75, 1.0],
index=[2, 5, 3, 7])
data
2 0.25
5 0.50
3 0.75
7 1.00
dtype: float64
data[5]
0.5
Series 作为特殊的字典
用这种方式，你可以认为Pandas Series有点像特殊化的字典。字典是可以映射任意键到任意值集合的结构，而Series是映射类型化的值到类型化值集合的结构。这种类型化是重要的：正如NumPy数组中特定类型的编译代码是它比Python列表的某些操作快一样，Pandas Series的类型信息使它比Python字典的某些操作更高效。
population_dict = {'California': 38332521,
'Texas': 26448193,
'New York': 19651127,
'Florida': 19552860,
'Illinois': 12882135}
population = pd.Series(population_dict)
population
California 38332521
Florida 19552860
Illinois 12882135
New York 19651127
Texas 26448193
dtype: int64
默认情况下，Series的索引由排序的键所创建。在这里，典型的字典风格操作也可以被执行：
population['California']
38332521
然而，与字典不同，Series也支持数组风格的操作，例如切片：
population['California':'Illinois']
California 38332521
Florida 19552860
Illinois 12882135
dtype: int64
我们会在Data Indexing and Selection.中讨论Pandas的索引和切片的一些技巧。
构建Series对象
我们已经看到了一些从头开始构建Pandas Series的方法；它们所有都是如下方法的不同版本：
>>> pd.Series(data, index=index)
这里index是可选参数，而data可以是各种不同的实体。
例如，data是列表或NumPy数组，默认情况下，index是整型序列：
pd.Series([2, 4, 6])
0 2
1 4
2 6
dtype: int64
data可以是标量，它被复制与索引的数量相对应：
pd.Series(5, index=[100, 200, 300])
100 5
200 5
300 5
dtype: int64
data可以是字典，默认的index是排序后的字典键值
pd.Series({2:'a', 1:'b', 3:'c'})
1 b
2 a
3 c
dtype: object
在每种情况下，如果期待不同的结果，都可以明确的设置索引：
pd.Series({2:'a', 1:'b', 3:'c'}, index=[3, 2])
3 c
2 a
dtype: object
注意在这个例子中，Series只是显示了明确定义了键值的内容。
Pandas 的DataFrame对象
Pandas中下一个基本结构是DataFrame。如同我们在前面章节讨论的Series对象一样，DataFrame可以被认为是通用化的NumPy数组或特殊化了的python字典。我们现在来看一下这些不同的观点。
DataFrame 作为广义的NumPy 数组
如果将Series类比于带有灵活索引的一维数组，那么DataFrame就类似于带有灵活行索引和列索引的二维数组。正如你可能认为二维数组是整齐排列的一维列序列一样，你可能认为DataFrame是整齐排列的Series对象序列。这里，‘整齐’的意思是指它们共享同样的索引。
作为说明，我们来构造一个新的Series列出前面例子中五个州的面积：
area_dict = {'California': 423967, 'Texas': 695662, 'New York': 141297,
'Florida': 170312, 'Illinois': 149995}
area = pd.Series(area_dict)
area
California 423967
Florida 170312
Illinois 149995
New York 141297
Texas 695662
dtype: int64
现在我们有area Series以及之前的population Series，我们可以使用字典来构造出一个单独的二维对象用以包那些信息
states = pd.DataFrame({'population': population,
'area': area})
states
area population
California 423967 38332521
Florida 170312 19552860
Illinois 149995 12882135
New York 141297 19651127
Texas 695662 26448193
与Series对象相似，DataFrame有index属性用来访问索引标识
states.index
Index(['California', 'Florida', 'Illinois', 'New York', 'Texas'], dtype='object')
另外，DataFrame有columns属性，它是一个保存列标识的index对象：
states.columns
Index(['area', 'population'], dtype='object')
因此DataFrame可以被认为是广义的二维NumPy数组，在这里可以使用广义的行索引和列索引来访问数据。
DataFrame作为特殊的字典
类似的，我们也可以认为DataFrame是一种特殊的字典。字典映射键到值，DataFrame映射一个列名字到一个Series类型的列数据。例如，请求‘area’属性返回包含面积信息的Series对象
states['area']
California 423967
Florida 170312
Illinois 149995
New York 141297
Texas 695662
Name: area, dtype: int64
注意这里潜在的困惑点：在一个二维NumPy数组中，data[0]返回的是第一行。对于一个DataFrame，data['col0']将会返回第一列。正因如此，可能认为DataFrame是广义的字典比认为是广义的数组会好些，尽管两种理解方式都是有用的。我们将会探索更多灵活的DataFrame索引方式在Data Indexing and Selection.
构建DataFrame对象
有好几种方式用来构建Pandas DataFrame。这里举几个例子：
通过单独的Series对象生成DataFrame
DateFrame是Series对象的集合，一个单列的DataFrame可以由一个独立的Series对象生成：
pd.DataFrame(population, columns=['population'])
population
California 38332521
Florida 19552860
Illinois 12882135
New York 19651127
Texas 26448193
通过字典列表生成DataFrame
任何字典列表都能制成DataFrame。我们使用列表解析来创建一些数据：
data = [{'a': i, 'b': 2 * i}
for i in range(3)]
pd.DataFrame(data)
a b
0 0 0
1 1 2
2 2 4
即使字典中的一些键值是缺失的，Pandas也能用NaN（不是数字）来填充
pd.DataFrame([{'a': 1, 'b': 2}, {'b': 3, 'c': 4}])
a b c
0 1.0 2 NaN
1 NaN 3 4.0
通过Serie对象字典生成DataFrame
如我们前面见到的，DataFrame也可以通过Series对象字典来构造：
pd.DataFrame({'population': population,
'area': area})
通过二维NumPy数组
通过一组二维数组数据，我们可以创建任何指定的列和索引名称的DataFrame。如果选择忽略,列和索引都将是整数:
pd.DataFrame(np.random.rand(3, 2),
columns=['foo', 'bar'],
index=['a', 'b', 'c'])
foo bar
a 0.865257 0.213169
b 0.442759 0.108267
c 0.047110 0.905718
通过NumPy结构化数组
我们在Structured Data: NumPy's Structured Arrays.会覆盖结构化数组内容。Pandas的DataFrame操作非常像结构数组，并且可以直接从结构数组来创建：
A = np.zeros(3, dtype=[('A', 'i8'), ('B', 'f8')])
A
array([(0, 0.0), (0, 0.0), (0, 0.0)],
dtype=[('A', '<i8'), ('B', '<f8')])
pd.DataFrame(A)
A B
0 0 0.0
1 0 0.0
2 0 0.0
Pandas Index对象
我们已经看到Series和DataFrame对象都包含一个显式索引，使您可以引用和修改数据。Index对象本身是一个有趣的数据结构，它可以被认为是一个不可变数组或一个有序集合（技术上讲是多集合，因为Index对象可以包含重复的值）。这些观点在Index对象可用的操作中有一些有趣的结果。作为一个简单的例子，让我们从整数列表来构建Index
ind = pd.Index([2, 3, 5, 7, 11])
ind
Int64Index([2, 3, 5, 7, 11], dtype='int64')
index 作为不可变数组
Index在很多方面就像一个数组。例如，我们能使用标准的python索引符号来获取值或切片：
ind[1]
3
ind[::2]
Int64Index([2, 5, 11], dtype='int64')
Index对象也由许多属性与NumPy数组相似：
print(ind.size, ind.shape, ind.ndim, ind.dtype)
5 (5,) 1 int64
Index对象和NumPy数组间的一个区别是索引是不可变的，它们不能通过正常的手段进行修改：
ind[1] = 0
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-34-40e631c82e8a> in <module>()
----> 1 ind[1] = 0
/Users/jakevdp/anaconda/lib/python3.5/site-packages/pandas/indexes/base.py in __setitem__(self, key, value)
1243
1244 def __setitem__(self, key, value):
-> 1245 raise TypeError("Index does not support mutable operations")
1246
1247 def __getitem__(self, key):
TypeError: Index does not support mutable operations
这种不可变性使在多个DataFrames和数组间共享索引更加安全，没有潜在的索引被不经意修改的副作用。
index作为有序集合
Pandas对象被设计为便于如跨数据集的连接那样的操作，这些操作依赖集合计算的许多方面。Index对象遵循许多python内置set数据结构的约定，因此交集，并集，差集和其他组合可以以相似的方法计算：
indA = pd.Index([1, 3, 5, 7, 9])
indB = pd.Index([2, 3, 5, 7, 11])
indA & indB # intersection 交集
Int64Index([3, 5, 7], dtype='int64')
indA | indB # union 合并
Int64Index([1, 2, 3, 5, 7, 9, 11], dtype='int64')
indA ^ indB # symmetric difference 差集
Int64Index([1, 2, 9, 11], dtype='int64')
这些操作也可以通过对象方法来实现，例如indA.intersection(indB).
