pandas库入门 北理工嵩天老师python数据分析与展示 单元7随堂笔记

pandas库入门 北理工嵩天老师python数据分析与展示 单元7随堂笔记

Pandas是Python第三方库，提供高性能易用数据类型和分析工具。

import pandas as pd

Pandas基于NumPy实现，常与Numpy和Matplotlib一同使用。

d = pd.Series(range(20))  
d  #第一列是索引，第二列是值

0      0
1      1
2      2
3      3
4      4
5      5
6      6
7      7
8      8
9      9
10    10
11    11
12    12
13    13
14    14
15    15
16    16
17    17
18    18
19    19
dtype: int64

d.cumsum() #计算前N项的累加和

0       0
1       1
2       3
3       6
4      10
5      15
6      21
7      28
8      36
9      45
10     55
11     66
12     78
13     91
14    105
15    120
16    136
17    153
18    171
19    190
dtype: int64

Pandas库的理解

两个数据类型：Series 、DataFrame
基于上述数据类型的各类操作：
基本操作，运算操作，特征类操作，关联类操作

       NumPy                              Pandas
      基础数据类型             基于np.array的扩展数据类型 Series 、DataFrame
关注数据的结构表达（即数据之间的维度表达）     关注数据的应用表达（如何提取、运算）
    维度：数据之间                       数据与索引间关系

Series类型

Series类型由一组数据及与之相关的数据索引组成
图四

a = pd.Series([9,8,7,6])  #自动索引
a

0    9
1    8
2    7
3    6
dtype: int64

b=pd.Series([9,8,7,6],index=['a','b','c','d']) #指定索引
b

a    9
b    8
c    7
d    6
dtype: int64

Series类型可以由如下类型创建

(1)标量值

s=pd.Series(25,index=['a','b','c'])  #通过标量值创建，不能省略index,index表达了Series类型的尺寸
s

a    25
b    25
c    25
dtype: int64

(2)python 字典

d=pd.Series({'a':9,'b':8,'c':7})# 用字典创建，键变为原来值的索引
d

a    9
b    8
c    7
dtype: int64

e=pd.Series({'a':9,'b':8,'c':7},index=['c','a','b','d'])#通过index指定Series结构
e

c    7.0
a    9.0
b    8.0
d    NaN
dtype: float64

(3)ndarray

import numpy as np
n=pd.Series(np.arange(5))
n

0    0
1    1
2    2
3    3
4    4
dtype: int32

m=pd.Series(np.arange(5),index=np.arange(9,4,-1))
m

9    0
8    1
7    2
6    3
5    4
dtype: int32

(4)其他函数

如range()

o=pd.Series(range(5),index=np.arange(9,4,-1))
o

9    0
8    1
7    2
6    3
5    4
dtype: int64

可以看到pandas与很多数据都具有兼容性

Series类型的基本操作

Series类型包括index和values两部分。
Series类型的操作类似ndarray类型。
Series类型的操作类似Python字典类型

b=pd.Series([9,8,7,6],['a','b','c','d'])
b

a    9
b    8
c    7
d    6
dtype: int64

b.index

Index(['a', 'b', 'c', 'd'], dtype='object')

b.values

array([9, 8, 7, 6], dtype=int64)

**Series类型实际上是将Numpy中的类型作为保留值的类型，索引是pandas内部新建立类型叫index
index类型和numpy中的array类型结合到一起就是Series类型 **

b['b']  # “b”为自定义索引

8

b[1]  # 1 为Series自动生成的索引

8

虽然用户自定义了索引，但它自动生成的索引也存在。
注意 ： 使用索引必须使用一致的索引方式，不能混用，同时使用时会被当作自定义索引。

Series类型的操作类似ndarray类型

如：
1.索引方法相同，采用[]；
2.NumPy中运算和操作可用于Series类型。
3.可以通过自定义索引的列表进行切片。
4.可以通过自动索引进行切片，如果存在自定义索引，则一同被切片。切片后仍然是Series类型

pd.Series([9,8,7,6],['a','b','c','d'])
b

a    9
b    8
c    7
d    6
dtype: int64

b[3]

6

b[:3]

a    9
b    8
c    7
dtype: int64

b[b>b.median()]    #中位数为7.5

a    9
b    8
dtype: int64

Series类型的操作与Python字典类型也有类似之处

如：
1.通过自定义索引访问
2.保留字in操作。不会判断自动索引，只会判断自定义索引
3.使用.get()方法

b['b']

8

'c' in b  #'c'是否是b中索引的一部分

True

0 in b # 判断 0  是否在用户自定义索引中

False

b.get('f',100) # 从b中提取索引‘f’ 对应的值，如果不存在就返回100

100

Series对象的对齐操作

Series+Series
Series类型在运算中会自动对齐不同索引的数据，这种运算更加精确，更不容易出错。

a=pd.Series([1,2,3],['c','d','e'])
b=pd.Series([9,8,7,6],['a','b','c','d'])
a+b

a    NaN
b    NaN
c    8.0
d    8.0
e    NaN
dtype: float64

Series类型的Name属性

Series对象和索引都可以有一个名字，存在属性.name中

b.name='Series对象'  #可以认为是对象的名字，也可认为是对象对应值的名字
b.index.name='索引列'
b

索引列
a    9
b    8
c    7
d    6
Name: Series对象, dtype: int64

Series对象可以随时修改并即刻生效

b['a']=15
b.name='Series'
b

索引列
a    15
b     8
c     7
d     6
Name: Series, dtype: int64

b.name='New series'
b['a','c']=20
b

索引列
a    20
b     8
c    20
d     6
Name: New series, dtype: int64

Pandas 库的DataFrame类型

Series是Pandas库中的一维数据类型
DataFrame是Pandas库中的二维数据类型，是由共用相同索引的一组列组成。即索引加多列数据构成。

DataFram类型的创建

从二维ndarray对象中创建

d = pd.DataFrame(np.arange(10).reshape(2,5))
d  #可以看出DataFrame是 原始数据增加横向和纵向的索引构成。

	0	1	2	3	4
0	0	1	2	3	4
1	5	6	7	8	9

从一维ndarray对象字典创建

dt={'one':pd.Series([1,2,3],index=['a','b','c']),
    'two':pd.Series([9,8,7,6],index=['a','b','c','d'])}
d=pd.DataFrame(dt)
d     #字典中的键自动成为了列索引
    

	one	two
a	1.0	9
b	2.0	8
c	3.0	7
d	NaN	6

pd.DataFrame(dt,index=['b','c','d'],columns=['two','three']) #three列不存在，自动补齐

	two	three
b	8	NaN
c	7	NaN
d	6	NaN

从列表类型的字典创建

d1={'one':[1,2,3,4],'two':[9,8,7,6]}
d=pd.DataFrame(d1,index = ['a','b','c','d'])
d

	one	two
a	1	9
b	2	8
c	3	7
d	4	6

d1={'城市':['北京','上海','广州','深圳','沈阳'],
    '环比':[101.5,101.2,101.3,102.0,100.1],
    '同比':[120.7,127.3,119.4,140.9,101.4],
    '定基':[121.4,127.8,120.0,145.5,101.6]}
d=pd.DataFrame(d1,index=['c1','c2','c3','c4','c5'])
d #字典是无序的，所以对象d中列之间的关系并不和字典给出的顺序相同

	城市	环比	同比	定基
c1	北京	101.5	120.7	121.4
c2	上海	101.2	127.3	127.8
c3	广州	101.3	119.4	120.0
c4	深圳	102.0	140.9	145.5
c5	沈阳	100.1	101.4	101.6

d.index

Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')

d.columns

Index(['城市', '环比', '同比', '定基'], dtype='object')

d.values

array([['北京', 101.5, 120.7, 121.4],
       ['上海', 101.2, 127.3, 127.8],
       ['广州', 101.3, 119.4, 120.0],
       ['深圳', 102.0, 140.9, 145.5],
       ['沈阳', 100.1, 101.4, 101.6]], dtype=object)

d['环比']  #每一列是Series对象

c1    101.5
c2    101.2
c3    101.3
c4    102.0
c5    100.1
Name: 环比, dtype: float64

d.ix['c2']   #生成对应行的Series对象

城市       上海
环比    101.2
同比    127.3
定基    127.8
Name: c2, dtype: object

d['同比']['c2']

127.3

Pandas库的数据类型操作

如何改变Series 和 DataFrame对象？

增加或重排：重新索引

方法： .reindex()能够改变或重排Series和DataFrame索引

c=d.reindex(index=['c5','c4','c3','c2','c1'])
c

	城市	环比	同比	定基
c5	沈阳	100.1	101.4	101.6
c4	深圳	102.0	140.9	145.5
c3	广州	101.3	119.4	120.0
c2	上海	101.2	127.3	127.8
c1	北京	101.5	120.7	121.4

c=c.reindex(columns=['城市','同比','环比','定基'])
c

	城市	同比	环比	定基
c5	沈阳	101.4	100.1	101.6
c4	深圳	140.9	102.0	145.5
c3	广州	119.4	101.3	120.0
c2	上海	127.3	101.2	127.8
c1	北京	120.7	101.5	121.4

删除：drop

.reindex(index=None，columns=None,…)的参数

newc = d.columns.insert(4,'新增')  #行索引加一个
newd = d.reindex(columns=newc,fill_value=200)
newd

	城市	环比	同比	定基	新增
c1	北京	101.5	120.7	121.4	200
c2	上海	101.2	127.3	127.8	200
c3	广州	101.3	119.4	120.0	200
c4	深圳	102.0	140.9	145.5	200
c5	沈阳	100.1	101.4	101.6	200

d.index

Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')

d.columns

Index(['城市', '环比', '同比', '定基'], dtype='object')

Series和DataFrame的索引是index类型
Index对象是不可修改的类型

索引类型的常用方法

c

	城市	同比	环比	定基
c5	沈阳	101.4	100.1	101.6
c4	深圳	140.9	102.0	145.5
c3	广州	119.4	101.3	120.0
c2	上海	127.3	101.2	127.8
c1	北京	120.7	101.5	121.4

删除指定索引对象

.drop()能够删除Series和DataFrame指定行或列索引

a = pd.Series([9,8,7,6],index=['a','b','c','d'])
a

a    9
b    8
c    7
d    6
dtype: int64

a.drop(['b','c'])

a    9
d    6
dtype: int64

d

	城市	环比	同比	定基
c1	北京	101.5	120.7	121.4
c2	上海	101.2	127.3	127.8
c3	广州	101.3	119.4	120.0
c4	深圳	102.0	140.9	145.5
c5	沈阳	100.1	101.4	101.6

d.drop('c5')

	城市	环比	同比	定基
c1	北京	101.5	120.7	121.4
c2	上海	101.2	127.3	127.8
c3	广州	101.3	119.4	120.0
c4	深圳	102.0	140.9	145.5

d.drop('同比',axis=1)  #如果没有axis=1，则默认操作0轴上的元素

	城市	环比	定基
c1	北京	101.5	121.4
c2	上海	101.2	127.8
c3	广州	101.3	120.0
c4	深圳	102.0	145.5
c5	沈阳	100.1	101.6

Pandas库的数据类型运算

算术运算法则

算术运算根据行列索引，补齐后运算，运算默认产生浮点数。
补齐时缺项填充NaN（空值）
二维和一维、一维和零维间为广播运算
采用+ - * / 符号进行的二元运算产生新的对象

a = pd.DataFrame(np.arange(12).reshape(3,4))
a

	0	1	2	3
0	0	1	2	3
1	4	5	6	7
2	8	9	10	11

b=pd.DataFrame(np.arange(20).reshape(4,5))
b

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

a+b   #一个矩阵缺项就补为NaN

	0	1	2	3	4
0	0.0	2.0	4.0	6.0	NaN
1	9.0	11.0	13.0	15.0	NaN
2	18.0	20.0	22.0	24.0	NaN
3	NaN	NaN	NaN	NaN	NaN

数据类型的算术运算的方法

b.add(a,fill_value=100)  # 缺值用100补

	0	1	2	3	4
0	0.0	2.0	4.0	6.0	104.0
1	9.0	11.0	13.0	15.0	109.0
2	18.0	20.0	22.0	24.0	114.0
3	115.0	116.0	117.0	118.0	119.0

a.mul(b,fill_value=0)  #相乘

	0	1	2	3	4
0	0.0	1.0	4.0	9.0	0.0
1	20.0	30.0	42.0	56.0	0.0
2	80.0	99.0	120.0	143.0	0.0
3	0.0	0.0	0.0	0.0	0.0

b= pd.DataFrame(np.arange(20).reshape(4,5))
b

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

c = pd.Series(np.arange(4))
c

0    0
1    1
2    2
3    3
dtype: int32

c- 10  #广播，不同维度间的运算会作用到高维的每一个元素上

0   -10
1    -9
2    -8
3    -7
dtype: int32

b-c   #同理，也是广播    b中每一行和c相减

	0	1	2	3	4
0	0.0	0.0	0.0	0.0	NaN
1	5.0	5.0	5.0	5.0	NaN
2	10.0	10.0	10.0	10.0	NaN
3	15.0	15.0	15.0	15.0	NaN

**不同维度间为广播运算，一维Series默认在轴1参与运算
要在零轴参与运算，需指定axis=0 **

b.sub(c,axis=0)

	0	1	2	3	4
0	0	1	2	3	4
1	4	5	6	7	8
2	8	9	10	11	12
3	12	13	14	15	16

比较运算法则

比较运算只能比较相同索引的元素，不进行补齐。 (只能同维度运算，尺寸一致)
二维和一维、一维和零维间为广播运算。默认在1轴。
采用> < >= <= == != 等符号进行的二元运算产生布尔对象。

a = pd.DataFrame(np.arange(12).reshape(3,4)) 
a

	0	1	2	3
0	0	1	2	3
1	4	5	6	7
2	8	9	10	11

d=pd.DataFrame(np.arange(12,0,-1).reshape(3,4))
d

	0	1	2	3
0	12	11	10	9
1	8	7	6	5
2	4	3	2	1

a>d  #必须同维度，不进行填充

	0	1	2	3
0	False	False	False	False
1	False	False	False	True
2	True	True	True	True

a==d

	0	1	2	3
0	False	False	False	False
1	False	False	True	False
2	False	False	False	False