Python数据分析与展示_4_Pandas库入门

Pandas库入门

操作索引即操作数据，操作数据时度进行过多的考虑
Pandas库的引用

Pandas是Python第三方库，提供高性能易用数据类型和分析工具
import pandas as pd
Pandas基于NumPy实现，常与NumPy和Matplotlib一同使用

cumsum()
计算前n项的累加和

Pandas库的理解

Pandas主要提供两个数据类型：Series(表示一维数据),DataFrame(表示二维/多维数据)
基于上述数据类型的各类操作
基本操作、运算操作、特征类操作、关联类操作

Numpy与pandas的差异：
NumPy 
基础数据类型
关注数据的结构表达
维度：数据间关系
Pandas：
扩展数据类型
关注数据的应用表达
数据与索引间关系

Pandas库的Series类型

Series类型由一组数据及与之相关的数据索引组成
import pandas as pd
a=pd.Series([9,8,7,6])
a
输出：
0 9
1 8
2 7
3 6
dtype:int64
第一列是数据的索引
最后一行是NumPython中的数据类型

索引可以自行指定
import pandas as pd
b=pd.Series([9,8,7,6],index=['a','b','c','d'])
b
输出：
a 9
b 8
c 7
d 6
dtype:int64

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

• Python列表
• 标量值
• Python字典
• ndarray
• 其他函数

从标量值创建

import pandas as pd
s=pd.Series(25,index=['a','b','c'])
#index 不能省略
s
输出：
a 25
b 25
c 25
dtype:int64

从字典类型创建

import pandas as pd
d=pd.Series({'a':9,'b':8,'c':7})
d
输出：
a 9
b 8
c 7
dtype:int64

# 由index指定结构并从字典中取值
import pandas as pd
e=pd.Series({'a':9,'b':8,'c':7},index=['c','a','b','d'])
e
输出：
c    7.0
a    9.0
b    8.0
d    NaN #表示空
dtype: float64

从ndarray类型创建

import pandas as pd
import numpy as np
n=pd.Series(np.arange(5))
n
out:
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
Out: 
9    0
8    1
7    2
6    3
5    4
dtype: int32

Series类型的基本操作：

Series类型包括index和values两部分
Series类型的操作类似ndarray类型
Series类型的操作类似Python字典类型
import pandas as pd
b=pd.Series([9,8,7,6],['a','b','c','d'])

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

b.values
Out: array([9, 8, 7, 6], dtype=int64)

b['b']
out:8

#自动索引默认生成
b[1]
out:8

# 两套索引并存，但不能混用
b[['c','d',0]]
out:
c    7.0
d    6.0
0    NaN
dtype: float64

Series类型的操作类似ndarray类型：

• 索引方法相同，采用[]
• NumPy中运算和操作可用于Series类型
• 可以通过自定义索引的列表进行切片
• 可以通过自动索引进行切片，如果存在自定义索引，则一同被切片

import pandas as pd
b=pd.Series([9,8,7,6],['a','b','c','d'])
b[:3]
out:
a 9
b 8
c 7
dtype:int 64
#对Series类型切片等操作返回的仍是Series类型
#如果是对Series中的一个值操作则不会返回具有索引和值的Series类型

b[b>b.median()]
out:
a 9
b 8
dtype:int64

np.exp(b)
out:
a    8103.083928
b    2980.957987
c    1096.633158
d     403.428793
dtype: float64

Series类型的操作类似Python字典类型：

• 通过自定义索引访问
• 保留字in操作
• 使用.get()方法

import pandas as pd
b=pd.Series([9,8,7,6],['a','b','c','d'])
# 可以通过in判断索引是否在Seri中
'c' in b
out:True
# 不会判断保留字索引
0 in b
out:False
# 从Series中寻找索引f,找到对应的值，返回值，没找到返回给的值
b.get('f',100)
100

Seri类型对齐操作

import pandas as pd
a=pd.Series([1,2,3],['c','d','e','d'])
b=pd.Series([9,8,7,6],['a','b','c','d'])
a+b
out:
a    NaN
b    NaN
c    8.0
d    8.0
e    NaN
dtype: float64
# Series类型在运算中会自动对齐不同索引的数据

Series类型的name属性

Series对象和索引都可以有一个名字，存储在属性.name中
import pandas as pd
b=pd.Series([9,8,7,6],['a','b','c','d'])
b.name
b.name="Series对象"
b.index.name="索引列"
b
out:
索引列
a    9
b    8
c    7
d    6
Name: Series对象, dtype: int64

Series类型的修改

Series对象可以随时修改并即刻生效
import pandas as pd
b=pd.Series([9,8,7,6],['a','b','c','d'])
b['a']=15
b
out:
a    15
b     8
c     7
d     6
dtype: int64

Series类型

Series是一维带“标签”数组
data_a index_0
Series基本操作类似ndarray和字典，根据索引对齐

DataFrame类型

DataFrame类型由共用相同索引的一组列组成

DataFrame是一个表格型的数据类型，每列值类型可以不同
DataFrame既有行索引、也有列索引
DataFrame常用于表达二维数据，但可以表达多维数据

DataFrame类型可以由如下类型创建：
• 二维ndarray对象
• 由一维ndarray、列表、字典、元组或Series构成的字典
• Series类型
• 其他的DataFrame类型

从二维ndarray对象创建

import pandas as pd
import numpy as np
d=pd.DataFrame(np.arange(10).reshape(2,5))
d
Out: 
   0  1  2  3  4
0  0  1  2  3  4
1  5  6  7  8  9

从一维ndarray对象字典创建

import pandas as pd
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
Out: 
   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'])
Out: 
   two three
b    8   NaN
c    7   NaN
d    6   NaN

从列表类型的字典创建

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

import pandas as pd
dl={'城市':['北京','上海','广州','深圳','沈阳'],
    '环比':[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.2,145.5,101.6]
}
d=p.DataFrame(dl,index=['c1','c2','c2','c4','c5'])
d
out:
    同比  城市     定基     环比
c1  120.7  北京  121.4  101.5
c2  127.3  上海  127.8  101.2
c2  119.4  广州  120.2  101.3
c4  140.9  深圳  145.5  102.0
c5  101.4  沈阳  101.6  100.1

d.index
Out: Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')

d.columns
Out: Index(['同比', '城市', '定基', '环比'], dtype='object')

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

d['同比']
Out[52]: 
c1    120.7
c2    127.3
c3    119.4
c4    140.9
c5    101.4
Name: 同比, dtype: float64

d.ix['c2']
Out: 
同比    127.3
城市       上海
定基    127.8
环比    101.2
Name: c2, dtype: object  

d['同比']['c2']
Out[51]: 127.3     
       
DataFrame是二维带"标签"数组
DataFrame基本操作类似Series，依据行列索引

数据类型操作

• 如何改变Series和DataFrame对象？
  • 增加或重排：重新索引
  • 删除：drop

重新索引

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

d=d.reindex(index=['c5','c4','c3','c2','c1'])
d
out:
 同比  城市     定基     环比
c5  101.4  沈阳  101.6  100.1
c4  140.9  深圳  145.5  102.0
c3  119.4  广州  120.2  101.3
c2  127.3  上海  127.8  101.2
c1  120.7  北京  121.4  101.5

.reindex(index=None, columns=None, …)的参数:
参数 |说明
—|—
index, columns | 新的行列自定义索引
fill_value | 重新索引中，用于填充缺失位置的值
method |填充方法, ffill当前值向前填充，bfill向后填充
limit |最大填充量
copy |默认True，生成新的对象，False时，新旧相等不复制

d=d.reindex(columns=['城市','同比','环比','定基'])
d
out:
 城市     同比     环比     定基
c5  沈阳  101.4  100.1  101.6
c4  深圳  140.9  102.0  145.5
c3  广州  119.4  101.3  120.2
c2  上海  127.3  101.2  127.8
c1  北京  120.7  101.5  121.4

newc=d.columns.insert(4,'新增')
newd=d.reindex(columns=newc,fill_value=200)
newd
out:
    城市     同比     环比     定基   新增
c5  沈阳  101.4  100.1  101.6  200
c4  深圳  140.9  102.0  145.5  200
c3  广州  119.4  101.3  120.2  200
c2  上海  127.3  101.2  127.8  200
c1  北京  120.7  101.5  121.4  200

索引类型

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

索引类型的常用方法

方法	说明
.append(idx)	连接另一个Index对象，产生新的Index对象
.diff(idx)	计算差集，产生新的Index对象
.intersection(idx)	计算交集
.union(idx)	计算并集
.delete(loc)	删除loc位置处的元素
.insert(loc,e)	在loc位置增加一个元素e

索引类型的使用

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

nc=d.columns.delete(2)
ni=d.index.insert(5,'c0')
# 按照教程中的写法此句会报错：ValueError: index must be monotonic increasing or decreasing
# 错误原因：pandas版本问题,这种写法不可以同时对行和列进行重新索引
# 解决办法：nd=d.reindex(index=ni,columnc=nc).ffill()
nd=d.reindex(index=ni,columnc=nc,method='ffill')
nd

删除指定索引对象

.drop()能够删除Series和DataFrame指定行或列索引
a=pd.Series([9,8,7,6],index=['a','b','c','d'])
a
out:
a    9
b    8
c    7
d    6
dtype: int64

a.drop(['b','c'])
Out: 
a    9
d    6
dtype: int64

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

d.drop('c5')
out:
    城市     同比     环比     定基
c4  深圳  140.9  102.0  145.5
c3  广州  119.4  101.3  120.2
c2  上海  127.3  101.2  127.8
c1  北京  120.7  101.5  121.4

d.drop('同比',axis=1)
# 意思是删除第2列的索引叫同比的列，必须用axis指明列位置，axis默认=0
d.drop('同比',axis=1)
Out: 
    城市     环比     定基
c5  沈阳  100.1  101.6
c4  深圳  102.0  145.5
c3  广州  101.3  120.2
c2  上海  101.2  127.8
c1  北京  101.5  121.4

算术运算法则

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

数据类型的算术运算

import pandas as pd
import numpy as np
a=pd.DataFrame(np.arange(12).reshape(3,4))
a
Out: 
   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
Out: 
    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
Out: 
      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

a*b
Out: 
      0     1      2      3   4
0   0.0   1.0    4.0    9.0 NaN
1  20.0  30.0   42.0   56.0 NaN
2  80.0  99.0  120.0  143.0 NaN
3   NaN   NaN    NaN    NaN NaN

方法形式的运算
方法 |说明
—|—
.add(d, *argws)| 类型间加法运算，可选参数
.sub(d, *argws)| 类型间减法运算，可选参数
.mul(d, *argws)| 类型间乘法运算，可选参数
.div(d, *argws)| 类型间除法运算，可选参数

b.add(a,fill_value=100)
Out: 
       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)
Out: 
      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
Out: 
    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
Out[85]: 
0    0
1    1
2    2
3    3
dtype: int32
# 每一个c中的数组-10
c-10
Out[86]: 
0   -10
1    -9
2    -8
3    -7
dtype: int32

b-c
Out[87]: 
      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参与运算

可以使用运算方法令一维Series参与轴0运算
b.sub(c,axis=0)
Out: 
    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

比较运算法则

• 比较运算只能比较相同索引的元素，不进行补齐
• 二维和一维、一维和零维间为广播运算
• 采用> < >= <= == !=等符号进行的二元运算产生布尔对象

  a
  Out: 
     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
  Out: 
      0   1   2  3
  0  12  11  10  9
  1   8   7   6  5
  2   4   3   2  1
  
  a>d
  Out: 
         0      1      2      3
  0  False  False  False  False
  1  False  False  False   True
  2   True   True   True   True
  
  a==d
  Out: 
         0      1      2      3
  0  False  False  False  False
  1  False  False   True  False
  2  False  False  False  False
  
   c=pd.Series(np.arange(4))
  
  c
  Out: 
  0    0
  1    1
  2    2
  3    3
  dtype: int32
  
  #不同维度，广播运算，默认在1轴
  a>c
  Out: 
         0      1      2      3
  0  False  False  False  False
  1   True   True   True   True
  2   True   True   True   True
  
  c>0
  Out[97]: 
  0    False
  1     True
  2     True
  3     True
  dtype: bool