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

字数统计: 2k字   |   阅读时长≈ 9分

pandas数据结构介绍

Series

  • Series最重要的一个功能：在算术运算中会自动对齐不同索引的数据（键相同）。
  • Series对象本身及其索引都有一个name属性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# 一组 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

DataFrame

DataFrame是一个表格型的数据结构，含有一组有序的列，每列可以是不同的值类型。既有行索引也有列索引。可看做由Series组成的字典。
以二维结构保存数据，可视为多维数据（层次化索引的表格型结构是pandas中许多高级数据处理功能的关键要素）。

  1. 构建DataFrame方式一

    方式一：直接传入一个由等长列表或NumPy数组组成的字典：

1
2
3
4
5
6
7
8
9
10
11
12
13
## 构建
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. 指定列序列

1
2
3
4
5
6
7
8
9
10
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 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

1
2
3
4
5
6
# print frame2.ix[1]
# out：
# year     2001
# state    Ohio
# pop       1.7
# Name: 1, dtype: object

1.4. 直接给列赋值，新建test列，赋值2.3

1
2
3
4
5
6
7
8
9
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。

  1. 构建DataFrame方式二

    方式二：嵌套字典，即字典的字典。

1
2
3
4
5
6
7
8
9
10
11
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属性

1
2
3
4
5
6
7
8
9
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中的数据

1
2
3
4
5
6
# print frame3.values
# out:
# [[ 2.3    nan]
#  [  nan  3.34]
#  [ 3.4    nan]
#  [  nan  5.2 ]]

索引对象

pandas索引对象负责管理轴标签和其他元数据（比如轴名称等）。

Index对象不可修改。此特性非常重要，使得Index对象在多个数据结构之间安全共享。

基本功能

重新索引reindex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

obj = 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
# 同样无效

丢弃指定轴上的项

1
2
3
4
5
6
7
8
9
10
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切片运算不同，末端是包含的，即封闭区间。如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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

算术运算和数据对齐

对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。

1
2
3
4
5
6
7
8
9
10
11
12
13
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对齐操作会同时发生在行和列上

排序和排名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 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()方法代替。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 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

排序

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

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

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true