pandas入门

pandas的两个最重要数据结构：Series和DataFrame

Series

Series是一个一维的类似的数组对象，包含一个数组的数据和一个与数组关联的数据标签，被叫做索引。

obj = Series([4, 7, -5, 3]);

输出obj会得到如下：

0 4
1 7
2 -5
3 3

索引在左边，值在右边。因为我们没有给数据指定索引，一个包含整数0到 N-1 （这里N是数据的长度）的默认索引被创建。 你可以分别的通过它的 values 和 index 属性来获取Series的数组表示和索引对象：

In [6]: obj.values
Out[6]: array([ 4, 7, -5, 3])
In [7]: obj.index
Out[7]: Int64Index([0, 1, 2, 3])

也可以创建一个自己设定的索引方便查找数组中的每一个值：

In [8]: obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
In [9]: obj2
Out[9]:
d 4
b 7
a -5
c 3
In [10]: obj2.index
Out[10]: Index([d, b, a, c], dtype=object)

利用索引访问数组中的元素：

In [11]: obj2['a']
Out[11]: -5
In [12]: obj2['d'] = 6
In [13]: obj2[['c', 'a', 'd']]
Out[13]:
c 3
a 5
d 6

和Numpy操作一样，Series也可以进行布尔数组过滤，纯量乘法，或使用数学函数，同时保持索引和值间的关联：

In [14]: obj2
Out[14]:
d 6
b 7
a -5
c 3
In [15]: obj2[obj2 > 0]   In [16]: obj2 * 2       In [17]: np.exp(obj2)
Out[15]:                         Out[16]:                Out[17]:
d 6                               d 12                    d 403.428793
b 7                               b 14                    b 1096.633158
c 3                               a -10                   a 0.006738
                                  c 6                     c 20.085537

从另一种角度看，可以把Series看成是一个定长，有序的字典，因为他把索引和值映射起来。
可以直接根据索引判断series是否函数其值：

In [18]: 'b' in obj2
Out[18]: True
In [19]: 'e' in obj2
Out[19]: False

所以也可以通过python中的字典创建一个Series：

In [20]: sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
In [21]: obj3 = Series(sdata)
In [22]: obj3
Out[22]:
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000

NaN在pandas中被用来标记数据缺失或 NA 值，用函数 isnull 和 notnull 来检测数据丢失：

pd.isnull(obj4)
pd.notnull(obj4)
#或用
obj4.isnull()

Series一个重要的功能是在算术用算中他会自动对齐不同索引的数据，例如obj3+obj4，他们会自动根据索引进行对应相加。

Series对象本身和它的索引都有一个 name 属性，它和pandas的其它一些关键功能整合在一起：

In [32]: obj4.name = 'population'
In [33]: obj4.index.name = 'state'
In [34]: obj4
Out[34]:
state
California NaN
Ohio 35000
Oregon 16000
Texas 71000
Name: population

Series的索引可以通过赋值就地更改：

In [35]: obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
In [36]: obj
Out[36]:
Bob 4
Steve 7
Jeff -5
Ryan 3

---

DataFrame

一个DataFrame表示一个表格，类似电子表格的数据结构。是一个二维结构。
通过一个等长列表的字典构建一个DataFrame：

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],

        'year': [2000, 2001, 2002, 2001, 2002],

        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = DataFrame(data)

由此产生的DataFrame和Series一样，它的索引会自动分配，并且对列进行了排序：

In [38]: frame
Out[38]:
  pop    state year
0 1.5     Ohio 2000
1 1.7     Ohio 2001
2 3.6     Ohio 2002
3 2.4   Nevada 2001
4 2.9   Nevada 2002

如果你设定了一个列的顺序，DataFrame的列将会精确的按照你所传递的顺序排列：

In [39]: DataFrame(data, columns=['year', 'state', 'pop'])
Out[39]:                                    
  year state pop
0 2000  Ohio 1.5
1 2001  Ohio 1.7
2 2002  Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9

和Series一样，在DataFrame中的一列可以通过字典记法或属性来检索

In [43]: frame2['state']     In [44]: frame2.year
Out[43]:                     Out[44]:
one   Ohio                   one   2000
two   Ohio                   two   2001
three Ohio                   three 2002
four  Nevada                 four  2001
five  Nevada                 five  2002
Name: state                  Name: year

注意，返回的Series包含和DataFrame相同的索引，并它们的 name 属性也被正确的设置了

行也可以使用一些方法通过位置或名字来检索，例如 ix 索引成员（field）：

In [45]: frame2.ix['three']
Out[45]:
year   2002
state  Ohio
pop    3.6
debt   NaN
Name: three

列可以通过赋值来修改。例如，空的 ‘debt’ 列可以通过一个纯量或一个数组来赋值：

In [46]: frame2['debt'] = 16.5
In [48]: frame2['debt'] = np.arange(5.)

通过列表或数组给一列赋值时，所赋的值的长度必须和DataFrame的长度相匹配。如果你使用Series来赋值，它会代替在DataFrame中精确匹配的索引的值，并在说有的空洞插入丢失数据：

In [50]: val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
In [51]: frame2['debt'] = val
In [52]: frame2
Out[52]:
  year state  pop  debt
  one   2000 Ohio   1.5  NaN
  two   2001 Ohio   1.7  -1.2
  three 2002 Ohio   3.6  NaN
  four  2001 Nevada 2.4  -1.5
  five  2002 Nevada 2.9  -1.7

给一个不存在的列赋值，将会创建一个新的列。 像字典一样 del 关键字将会删除列：

In [53]: frame2['eastern'] = frame2.state == 'Ohio'
In [54]: frame2
Out[54]:
       year  state pop   debt eastern
 one   2000   Ohio 1.5    NaN    True
 two   2001   Ohio 1.7   -1.2    True
 three 2002   Ohio 3.6    NaN    True
 four  2001 Nevada 2.4   -1.5   False
 five  2002 Nevada 2.9   -1.7   False

In [55]: del frame2['eastern']
In [56]: frame2.columns
Out[56]: Index([year, state, pop, debt], dtype=object)

索引DataFrame时返回的列是底层数据的一个视窗，而不是一个拷贝。因此，任何在Series上的就地修改都会影响DataFrame。列可以使用Series的 copy 函数来显式的拷贝。

另一种通用的数据形式是一个嵌套的字典的字典格式：

In [57]: pop = {'Nevada': {2001: 2.4, 2002: 2.9},
                'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}

如果被传递到DataFrame，它的外部键会被解释为列索引，内部键会被解释为行索引：

In [58]: frame3 = DataFrame(pop)
In [59]: frame3
Out[59]:
       Nevada Ohio
2000    NaN  1.5
2001    2.4  1.7
2002    2.9  3.6

当然，你总是可以对结果转置：

In [60]: frame3.T
Out[60]:
        2000 2001 2002
Nevada   NaN 2.4 2.9
Ohio     1.5 1.7 3.6

内部字典的键被结合并排序来形成结果的索引。如果指定了一个特定的索引，就不是这样的了：

In [61]: DataFrame(pop, index=[2001, 2002, 2003])
Out[61]:
           Nevada Ohio
  2001     2.4  1.7
  2002     2.9  3.6
  2003     NaN  NaN

Series的字典也以相同的方式来处理：

In [62]: pdata = {'Ohio': frame3['Ohio'][:-1],
                  'Nevada': frame3['Nevada'][:2]}

In [63]: DataFrame(pdata)
Out[63]:
       Nevada Ohio
2000    NaN  1.5
2001    2.4  1.7

如果一个DataFrame的 index 和 columns 有它们的 name ，也会被显示出来：

In [64]: frame3.index.name = 'year'; frame3.columns.name = 'state'
In [65]: frame3
Out[65]:
   state Nevada Ohio
year
2000     NaN  1.5
2001     2.4  1.7
2002     2.9  3.6

像Series一样， values 属性返回一个包含在DataFrame中的数据的二维ndarray：

In [66]: frame3.values
Out[66]:
array([[ nan, 1.5],
   [ 2.4, 1.7],
   [ 2.9, 3.6]])

如果DataFrame的列有不同的dtypes，返回值数组将会给所有的列选择一个合适的dtyps：

In [67]: frame2.values
Out[67]:
array([[2000, Ohio, 1.5, nan],
       [2001, Ohio, 1.7, -1.2],
       [2002, Ohio, 3.6, nan],
       [2001, Nevada, 2.4, -1.5],
       [2002, Nevada, 2.9, -1.7]], dtype=object)

---

索引使用：

重建reindex函数，在Series上调用 reindex 重排数据，使得它符合新的索引，如果那个索引的值不存在就引入缺失数据值

In [81]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
In [82]: obj2
Out[82]:
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
In [83]: obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
Out[83]:
a -5.3
b 7.2
c 3.6   
d 4.5
e 0.0

reindex函数中的method选项可以选择作为填充：

obj3.reindex(range(6), method='ffill')

对于DataFrame， reindex 可以改变（行）索引，列或两者。当只传入一个序列时，结果中的行被重新索引了：

In [86]: frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'],
                                              columns=['Ohio', 'Texas', 'California'])
In [87]: frame
Out[87]:
    Ohio Texas California
a    0     1          2
c    3     4          5
d    6     7          8
In [88]: frame2 = frame.reindex(['a', 'b', 'c', 'd'])
In [89]: frame2
Out[89]:    
    Ohio Texas California
a    0     1          2
b  NaN   NaN        NaN
c    3     4          5
d    6     7          8

放弃写下去。。。直接去实战是最好的学习方法。之后或直接更新kaggle的实战