pandas数据结构介绍
SeriesSeries最重要的一个功能:在算术运算中会自动对齐不同索引的数据(键相同)。
Series对象本身及其索引都有一个name属性。
# 一组 key: value
# obj = Series([4,5,7,-3])
# print obj
# out:
# 0 4
# 1 5
# 2 7
# 3 -3
# dtype: int64
# print obj.values
# out:[ 4 5 7 -3]
# print obj.index
# out:RangeIndex(start=0, stop=4, step=1)
obj2 = Series([3, 5, -7, 9], index=['a', 'd', 'b', 'c'])
# print obj2
# out:
# a 3
# d 5
# b 7
# c 9
# dtype: int64
# print obj2['d']
# out: 5
# print obj2[['d','c','b']]
# out:
# d 5
# c 9
# b 7
# dtype: int64
# print obj2[obj2>0]
# out:
# a 3
# d 5
# c 9
# dtype: int64
# print 'b' in obj2
# out: True
# 通过字典创建Series
sdata = {'aaa': 41, 'bbb': 51, 'ccc': 61, 'ddd': 71}
obj3 = Series(sdata)
# print obj3
# out:
# aaa 41
# bbb 51
# ccc 61
# ddd 71
# dtype: int64
# 传入一个值,作为键
states = ['aaa', 'bbb', 'ddd', 'eee']
obj4 = Series(sdata, index=states)
# print obj4
# out:
# aaa 41
# bbb 51
# ddd 71
# eee NaN
# dtype: int64
# 第四个值eee找不到键
# isnull,notnull检测缺失数据
# print pd.isnull(obj4)
# out:
# aaa False
# bbb False
# ddd False
# eee True
# dtype: bool
# 算术运算,自动对齐键
# print obj3+obj4
# our:
# aaa 82.0
# bbb 102.0
# ccc NaN
# ddd 142.0
# eee NaN
# dtype: float64
obj4.name = 'population'
obj4.index.name = 'state'
# print obj4
# out:
# state
# aaa 41.0
# bbb 51.0
# ddd 71.0
# eee NaN
# Name: population, dtype: float64
# 索引改变:
obj4.index = ['bob', 'fds', 'a33', '8uk']
# print obj4
DataFrameDataFrame是一个表格型的数据结构,含有一组有序的列,每列可以是不同的值类型。既有行索引也有列索引。可看做由Series组成的字典。
以二维结构保存数据,可视为多维数据(层次化索引的表格型结构是pandas中许多高级数据处理功能的关键要素)。
构建DataFrame方式一方式一:直接传入一个由等长列表或NumPy数组组成的字典:
## 构建
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2003, 2004],
'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame1 = DataFrame(data)
# print frame1
# out:
# pop state year
# 0 1.5 Ohio 2000
# 1 1.7 Ohio 2001
# 2 3.6 Ohio 2002
# 3 2.4 Nevada 2003
# 4 2.9 Nevada 2004
1.1. 指定列序列
frame2 = DataFrame(data, columns=['year', 'state', 'pop'])
# print frame2
# out:
# year state pop
# 0 2000 Ohio 1.5
# 1 2001 Ohio 1.7
# 2 2002 Ohio 3.6
# 3 2003 Nevada 2.4
# 4 2004 Nevada 2.9
# 若找不到列,就会显示NaN
1.2. 通过字典标记方式或属性方式,获取一个Series
# print frame2['state']
# out:
# 0 Ohio
# 1 Ohio
# 2 Ohio
# 3 Nevada
# 4 Nevada
# Name: state, dtype: object
# print frame2.year
# out:
# 0 2000
# 1 2001
# 2 2002
# 3 2003
# 4 2004
# Name: year, dtype: int64
1.3. 行,通过名称或位置获取,如用索引字段ix
# print frame2.ix[1]
# out:
# year 2001
# state Ohio
# pop 1.7
# Name: 1, dtype: object
1.4. 直接给列赋值,新建test列,赋值2.3
frame2['test'] = 2.3
# print frame2
# out:
# year state pop test
# 0 2000 Ohio 1.5 2.3
# 1 2001 Ohio 1.7 2.3
# 2 2002 Ohio 3.6 2.3
# 3 2003 Nevada 2.4 2.3
# 4 2004 Nevada 2.9 2.3将列表或数组赋值给某个列时,长度必须和DataFrame相匹配;空位都将填上缺失值NaN。
构建DataFrame方式二方式二:嵌套字典,即字典的字典。
pop = {'Nevada': {2001:2.3, 2004:3.4},
'Ohio': {2003:3.34, 2005:5.2}}
# 转化为DataFrame,解释原则:外层字典的键作为列,内层键作为行索引。
frame3 = DataFrame(pop)
# print frame3
# out:
# Nevada Ohio
# 2001 2.3 NaN
# 2003 NaN 3.34
# 2004 3.4 NaN
# 2005 NaN 5.20
2.1 设置index和columns的name属性
frame3.index.name = 'year';frame3.columns.name = 'state'
# print frame3
# out:
# state Nevada Ohio
# year
# 2001 2.3 NaN
# 2003 NaN 3.34
# 2004 3.4 NaN
# 2005 NaN 5.20
2.2 value属性会以二维ndarray形式返回DataFrame中的数据
# print frame3.values
# out:
# [[ 2.3 nan]
# [ nan 3.34]
# [ 3.4 nan]
# [ nan 5.2 ]]
索引对象pandas索引对象负责管理轴标签和其他元数据(比如轴名称等)。
Index对象不可修改。此特性非常重要,使得Index对象在多个数据结构之间安全共享。
基本功能
重新索引reindexobj = Series([4.5, 2.3, -2.4, 3.5], index=['d', 'c', 'a', 'b'])
# obj.reindex(['a','b', 'c', 'd', 'e', 'f'])
# print obj
# out:
# d 4.5
# c 2.3
# a -2.4
# b 3.5
# dtype: float64
# 这里没有像书上说的一样,没有索引值用缺失值NaN;待查
# obj.reindex(['a','b', 'c', 'd', 'e', 'f'], fill_value=0)
# 这一句会用0来填充缺失值
# print obj
# out:
# d 4.5
# c 2.3
# a -2.4
# b 3.5
# dtype: float64
# 同样无效
丢弃指定轴上的项obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
new_obj = obj.drop('c')
# print new_obj
# out:
# a 0.0
# b 1.0
# d 3.0
# e 4.0
# dtype: float64
# drop放回一个在指定轴上删除了指定值的新对象
索引、选取和过滤
利用标签的切片与普通Python切片运算不同,末端是包含的,即封闭区间。如
obj = Series(np.arange(4.), index=['a','b','c','d'])
# print obj
# out:
# a 0.0
# b 1.0
# c 2.0
# d 3.0
# dtype: float64
# print obj['b':'c']
# out:
# b 1.0
# c 2.0
# dtype: float64
# 如果是普通切片方式,b-c就只有1.0
# 赋值方式如下:
obj['b','c'] = 5
# print obj
# out:
# a 0.0
# b 5.0
# c 5.0
# d 3.0
# dtype: float64
算术运算和数据对齐对象相加时,如果存在不同的索引对,则结果的索引就是该索引对的并集。
s1 = Series([7.3, 4.5, 67.1, 2.3], index=['a', 'b', 'd', 'f'])
s2 = Series([3, 5, 6, 7, 3], ['a', 'd', 'f', 'g', 'h'])
# print s1 + s2
# out:
# a 10.3
# b NaN
# d 72.1
# f 8.3
# g NaN
# h NaN
# dtype: float64
# 相加就是并集,若索引不重叠,则NaN;自动数据对齐操作。
# 而DataFrame对齐操作会同时发生在行和列上
排序和排名# obj = Series(range(4), index=['d','c','b','a'])
# print obj
# d 0
# c 1
# b 2
# a 3
# dtype: int64
# print obj.sort_index()
# a 3
# b 2
# c 1
# d 0
# dtype: int64
frame = DataFrame(np.arange(8).reshape((2,4)), index=['three', 'one'], columns=['d','a','b','c'])
# print frame.sort_index()
# d a b c
# one 4 5 6 7
# three 0 1 2 3
# print frame.sort_index(axis=1)
# a b c d
# three 1 2 3 0
# one 5 6 7 4按值对Series排序,用其order方法;
排序时缺失值会被放到Series末尾。
sort_index()方法已过时,用sort_value()方法代替。
# DataFrame根据列值排序,传列名给by选项
frame = DataFrame({'b': [4, 8, 5, 3], 'a': [-2, 1, 9, 6]})
# print frame
# a b
# 0 -2 4
# 1 1 8
# 2 9 5
# 3 6 3
# print frame.sort_values(by='b')
# a b
# 3 6 3
# 0 -2 4
# 2 9 5
# 1 1 8
排序
obj = Series([7, 3, 5, 7, 9, 3, 1])
# print obj.rank()
# 0 5.5
# 1 2.5
# 2 4.0
# 3 5.5
# 4 7.0
# 5 2.5
# 6 1.0
# dtype: float64
# 暂时没看懂什么意思啊
汇总和计算描述统计axis(约简的 轴)选项标明是按行还是按列;如axis=0按列,axis=1按行。
skipna 排除缺失值,默认值True
level 轴是层次化索引的,则根据level分组约简
第五章于20170319结束,时间节点设计有问题,现在需要手动敲的越来越多,所以速度跟不上,尤其是精力跟不上了。看书要分主次,重要的知识点要细看,必须手动敲出来;一些同类化的知识可以跳着看,以节省时间。
但是有一个原则不能改,一些重要的知识点不能跳过,需要真真的✋敲出来。不然那就是真正的浪费时间。