pandas的数据结构

时间 2019-11-17

标签 pandas 数据结构繁體版

原文原文链接

要使用pandas，须要熟悉它的两个主要的数据结构，Series和DataFrame。python

Series

series是一种相似于觉得数组的对象，它由一组数据（各类numpy的数据类型）以及一组与之相关的数据标签（索引）组成。仅有一组数据便可产生简单的Series：数组

In [11]: from pandas import Series,DataFrame

In [12]: import pandas as pd

In [13]: obj=Series([4,-2,5,0])

In [14]: obj
Out[14]:
0    4
1   -2
2    5
3    0
dtype: int64

In [15]: type(obj)
Out[15]: pandas.core.series.Series

series的字符串表现形式为：索引在左边，值在右边。因为咱们没有为数据指定索引，因而自动建立一个0到N-1（N为数据的长度）的整数型索引。能够经过Series的values和index属性获取其数组表现形式和索引对象：安全

In [16]: obj.values
Out[16]: array([ 4, -2,  5,  0], dtype=int64)

In [17]: obj.index
Out[17]: RangeIndex(start=0, stop=4, step=1)

一般，咱们但愿所建立的Series带有一个能够对各个数据点进行标记的索引：数据结构

In [18]: obj2=Series([4,7,5,-3],index=['d','b','a','c'])

In [19]: obj2
Out[19]:
d    4
b    7
a    5
c   -3
dtype: int64

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

于普通numpy相比，你能够经过索引的方式选取Series的单个或一组值app

In [21]: obj2['a']
Out[21]: 5

In [22]: obj2['d']=6

In [23: obj2[['c','a','d']]
Out[23:
c   -3
a    5
d    6
dtype: int64

numpy数组运算都会保留索引与值之间的连接：函数

In [26]: obj2[obj2>0]
Out[26]:
d    6
b    7
a    5
dtype: int64

In [27]: obj2*2
Out[27]:
d    12
b    14
a    10
c    -6
dtype: int64

In [28]: np.exp(obj2)
Out[28]:
d     403.428793
b    1096.633158
a     148.413159
c       0.049787
dtype: float64

还能够将Series当作一个定长的有序字典，由于它是索引值到数据值的一个映射。它能够在许多本来须要字典参数的函数中：spa

In [29]: 'b' in obj2
Out[29]: True

In [30]: 'e' in obj2
Out[30]: False

若是数据被存放在一个Python字典中，也能够直接经过这个字典来建立：code

In [32]: sdata={'a':1,'b':2,'c':3}

In [33]: obj3=Series(sdata)

In [34]: obj3
Out[34]:
a    1
b    2
c    3
dtype: int64

若是只传入一个字典，则结果series中的索引就是原字典的键（有序排列）对象

In [41]: states=['one','a','b']

In [42]: obj4=Series(sdata,index=states)

In [43]: obj4
Out[43]:
one    NaN
a      1.0
b      2.0
dtype: float64

例子中sdata中的states索引相匹配的那2个值会被找出来并放到相应的位置上。找不到的则用缺失值Na表示。blog

pandas中的isnull和notnull可用于检测缺失数据：

In [44]: pd.isnull(obj4)
Out[44]:
one     True
a      False
b      False
dtype: bool

In [45]: pd.notnull(obj4)
Out[45]:
one    False
a       True
b       True
dtype: bool

series中也有相似的实例方法：

In [46]: obj4.isnull()
Out[46]:
one     True
a      False
b      False
dtype: bool

Series中最重要的一个功能是：它在算术运算中会自动对齐不一样索引的数据。

In [47]: obj3
Out[47]:
a    1
b    2
c    3
dtype: int64

In [48]: obj4
Out[48]:
one    NaN
a      1.0
b      2.0
dtype: float64

In [49]: obj3+obj4
Out[49]:
a      2.0
b      4.0
c      NaN
one    NaN
dtype: float64

series对象自己及其索引都有一个name属性，该属性跟pandas其余关键功能关系很是密切：

In [50]: obj4.name='pop4'

In [51]: obj4.index.name='state4'

In [52]: obj4
Out[52]:
state4
one    NaN
a      1.0
b      2.0
Name: pop4, dtype: float64

series索引能够经过赋值的方式就地修改：

In [53]: obj
Out[53]:
0    4
1   -2
2    5
3    0
dtype: int64

In [54]: obj.index=['a','b','c','d']

In [55]: obj
Out[55]:
a    4
b   -2
c    5
d    0
dtype: int64

DataFrame

DataFrame是一个表格型数据结构。它含有一组有序的列，每列能够是不一样的值类型（数值、字符串、布尔值等）。DataFrame便可有行索引也能够有列索引，它能够被看作是由Series组成的字典（共同一个索引）跟其余的相似的数据结构相比，DataFrame中面向行和面向列的操做基本上是平衡的。其实，DataFrame中数据是以一个或多个二维块存放的。

构建DataFrame最多见的方法是直接传入一个等长列表或numpy数组组成的字典：

In [65]: data={'state':[True,True,False,True,False],'year':[2000,2001,2002,2003,2004]}

In [66]: data
Out[66]:
{'state': [True, True, False, True, False],
 'year': [2000, 2001, 2002, 2003, 2004]}

In [67]: frame=DataFrame(data)

In [68]: frame
Out[68]:
   state  year
0   True  2000
1   True  2001
2  False  2002
3   True  2003
4  False  2004

若是指定了列序列，则DataFrame的列就会按照指定顺序进行排列：

In [69]: DataFrame(data,columns=['year','state'])
Out[69]:
   year  state
0  2000   True
1  2001   True
2  2002  False
3  2003   True
4  2004  False

跟series同样，若是传入的列在数据中找不到就会产生NA值。

经过相似字典标记的方式或属性的方式，能够将DataFrame的列获取为一个Series：

In [70]: frame['state']
Out[70]:
0     True
1     True
2    False
3     True
4    False
Name: state, dtype: bool

In [71]: frame['year']
Out[71]:
0    2000
1    2001
2    2002
3    2003
4    2004
Name: year, dtype: int64

In [72]: type(frame['year'])
Out[72]: pandas.core.series.Series

返回的series拥有DataFrame相同的索引，且其name属性也已经被相应的设置好了。

列能够经过赋值的方式进行修改，如咱们增长一列‘debt’，赋上一个标量值或一组值：

In [77]: frame['debt']=16.25

In [78]: frame
Out[78]:
   state  year   debt
0   True  2000  16.25
1   True  2001  16.25
2  False  2002  16.25
3   True  2003  16.25
4  False  2004  16.25

In [79]: frame['debt']=np.arange(5)

In [80]: frame
Out[80]:
state year debt
0   True 2000     0
1   True 2001     1
2 False 2002     2
3   True 2003     3
4 False 2004     4

将列表或数组赋值给某一列时，长度必需要跟DataFrame的长度相匹配。若是赋值的是一个Series，就会精匹配DataFrame的索引，全部空位都会被填上缺省值：

In [85]: frame
Out[85]:
       state  year  debt  
one     True  2000     0   
two     True  2001     1    
three  False  2002     2   
four    True  2003     3    
five   False  2004     4    

In [86]: val=Series([-1.2,-1.5,-1.7],index=['one','two','three'])

In [87]: frame['debt2']=val

In [88]: frame
Out[88]:
       state  year  debt  debt2
one     True  2000     0   -1.2
two     True  2001     1   -1.5
three  False  2002     2   -1.7
four    True  2003     3    NaN
five   False  2004     4    NaN

为不存在的列赋值会创出一个心裂，关键字del用于删除列

In [92]: del frame['state1']

In [93]: frame
Out[93]:
       state  year  debt  debt2
one     True  2000     0   -1.2
two     True  2001     1   -1.5
three  False  2002     2   -1.7
four    True  2003     3    NaN
five   False  2004     4    NaN

另外一种常见的数据形式的嵌套字典：

In [94]: pop={'year':{2001:1.5,2002:1.6,2007:2},'prices':{2001:2.5,2002:3}}

若是将它传给DataFrame，它就会被解释为：外层的字典做为键的关键列，内层的则做为行索引：

In [95]: frame3=DataFrame(pop)

In [96]: frame3
Out[96]:
      year  prices
2001   1.5     2.5
2002   1.6     3.0
2007   2.0     NaN

能够对结果进行转置：

In [97]: frame3.T
Out[97]:
        2001  2002  2007
year     1.5   1.6   2.0
prices   2.5   3.0   NaN

内层的字典的键会被合并、排序以造成最终的索引。若是显式指定了索引：

In [109]: frame3.index=[2001,2002,2003]

In [111]: frame3
Out[111]:
      year  prices
2001   1.5     2.5
2002   1.6     3.0
2003   2.0     NaN

能够输入给DataFrame构造器的数据：

1.二维ndarry

2.由数组、列表或元祖组成的字典

3.numpy结构化

4.Series组成的字典

5.由字典组成的字典

6.字典或series的列表

7.由列表或元祖组成的列表

8.另外一个DataFrame

9.numpy的MaskedArray

若是设置了DataFrame的index和columns的name属性，则这些信息也会显示出来

In [113]: frame3.index.name='year';frame3.columns.name='state'

In [114]: frame3
Out[114]:
state  year  prices
year
2001    1.5     2.5
2002    1.6     3.0
2003    2.0     NaN

索引对象

pandas的索引对象负责管理轴标签和其余元数据（如轴名称）构建series或DataFrame时，所用到的任何数组或其余序列的标签都会被转换成一个index：

In [116]: obj=Series(range(3),index=['b','a','c'])

In [117]: index=obj.index

In [118]: index
Out[118]: Index(['b', 'a', 'c'], dtype='object')

In [121]: index[1:]
Out[121]: Index(['a', 'c'], dtype='object')

Index对象是不可修改的（immutable），所以用户不可对其进行修改

In [122]: index[1]='f'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-122-c2c86828e313> in <module>()
----> 1 index[1]='f'

d:\python\python36\lib\site-packages\pandas\core\indexes\base.py in __setitem__(self, key, value)
   2048
   2049     def __setitem__(self, key, value):
-> 2050         raise TypeError("Index does not support mutable operations")
   2051
   2052     def __getitem__(self, key):

TypeError: Index does not support mutable operations

不可修改属性很是重要，由于这样才能使Index对象在多个数据结构之间数据安全共享

In [123]: index=pd.Index(np.arange(3))

In [127]: obj2=Series([-1.5,2.6,0],index=index)

In [129]: obj2
Out[129]:
0   -1.5
1    2.6
2    0.0
dtype: float64

In [130]: obj2.index is index
Out[130]: True

pandas中主要的index对象：

index ：最泛化的index对象，将轴标签表示为一个由Python对象组成的numpy数组

int64index：针对整数的特殊index

Multiindex ：层次化索引对象，表示单个轴上的多层索引。能够当作由元组组成的数组

DatatimeIndex ：存储纳秒级时间戳

Periodindex：针对Period数据（时间间隔）的特殊index

除了长得像数组，index的功能相似一个固定大小的集合：

In [131]: frame3
Out[131]:
state  year  prices
year
2001    1.5     2.5
2002    1.6     3.0
2003    2.0     NaN

In [132]: 'year' in frame3.columns
Out[132]: True

In [133]: '2001'  in frame3.index
Out[133]: False

In [134]: 2001  in frame3.index
Out[134]: True

index的方法和属性：

append：链接另外一个index对象，产生一个新的index

diff：计算差集，并获得一个新的index

intersection：计算交集

union：计算并集

isin：计算一个指示各值是否都包含在参数集合中的布尔型数组

delete：删除索引i处的元素，并获得一个新的index

drop：删除传入的值，并获得一个新的index

insert：将元素插入到索引i处，并获得一个新的index

is_monotonic：当各元素大于等于前一个元素时，返回True

is_unique：当index没有重复值时，返回True

unique：计算index中惟一值得数组