利用python进行数据分析 笔记_《利用Python进行数据分析》读书笔记-第五章-pandas入门...

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结束，时间节点设计有问题，现在需要手动敲的越来越多，所以速度跟不上，尤其是精力跟不上了。看书要分主次，重要的知识点要细看，必须手动敲出来；一些同类化的知识可以跳着看，以节省时间。

但是有一个原则不能改，一些重要的知识点不能跳过，需要真真的✋敲出来。不然那就是真正的浪费时间。