数据分析与展示 pandas 入门

最新推荐文章于 2023-04-11 14:07:43 发布

Z_sam

最新推荐文章于 2023-04-11 14:07:43 发布

阅读量215

点赞数

分类专栏：数据分析

本文链接：https://blog.csdn.net/u010553139/article/details/107250049

版权

数据分析专栏收录该内容

5 篇文章 0 订阅

订阅专栏

pandas 入门

Pandas 库的介绍

Pandas 库的引用

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

Pandas 库小测

import pandas as pd
d = pd.Series(range(20))
print(d)
print(d.cumsum())

Pandas 库的理解

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

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

Pandas 库的Series类型

Series类型

Series类型由一组数据及与之相关的数据索引组成.
Series类型可以由如类型创建：python列表、标量值、python字典、ndarray、其他函数
	Series类型创建（从python列表创建）：
	a=pd.Series([1,2,3])
	说明：python列表，index与列表元素个数一致
	
	Series类型创建（从标量创建）：
	s = pd.Series(25,index=['a','b','c','d']) # 不能省略 index
	说明：标量值，index表达Series类型的尺寸
	
	Series类型创建（从字典类型创建）：
	d = pd.Series({'a':9,'b':8,'c':7})
	或
	d1 = pd.Series({'a':9,'b':8,'c':7},index=['c','a','b','d'])
	说明：Python字典，键值对中的“键”是索引，index从字典中进行选择操作
	
	Series类型创建（从Narray类型创建）：
	n = pd.Series(np.arange(5))
	或
	n1 = pd.Series(np.arange(5),index=np.arange(9,4,-1))
	说明：ndarray，索引和数据都可以通过ndarray类型创建
	
	Series类型创建（从其他函数创建）：
	例如：range()函数
	e = pd.Series(range(0,5))

Series类型的基本操作

Series类型包括index和values两部分

# 例1：
import pandas as pd
b = pd.Series([9,8,7,6],['a','b','c','d'])
b
Out[54]: 
a    9
b    8
c    7
d    6
dtype: int64
b.index  #.index 获取索引 
Out[55]: Index(['a', 'b', 'c', 'd'], dtype='object')
b.values #.values 获取数据
Out[56]: array([9, 8, 7, 6], dtype=int64)
b['a']  # 自定义索引
Out[57]: 9
b[0] # 自动索引 
Out[58]: 9
b[['a','b',3]] # 自定义索引和自动索引可以并存，但不能混用
KeyError             Traceback (most recent call last)

Series类型的操作类似ndarray类型

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

# 例：
import pandas as pd
b = pd.Series([9,8,7,6],['a','b','c','d'])
b[:3]
Out[67]: 
a    9
b    8
c    7
dtype: int64
b.median()
Out[68]: 7.5
b>b.median()
Out[72]: 
a     True
b     True
c    False
d    False
dtype: bool
b[b>b.median()]
Out[73]: 
a    9
b    8
dtype: int64

Series类型的操作类似Python字典类型
- 通过自定义索引访问
- 保留字in操作
- 使用.get()方法

 # 例
 import pandas as pd
 b = pd.Series([9,8,7,6],['a','b','c','d'])
 b['b']
Out[75]: 8
 'c' in b
 Out[76]: True
 'e' in b
 Out[77]: False
 0 in b
 Out[78]: False
 b.get('f',100)
 Out[81]: 100
 b.get('b')
 Out[83]: 8

Series类型对齐操作

Series + Series

import pandas as pd
a = pd.Series([1,2,3],['c','d','e'])
b = pd.Series([9,8,7,6],['a','b','c','d'])
a+b
Out[89]: 
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[98]: 
索引列
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.name = 'Series'

b
Out[106]: 
a    15
b     8
c     7
d     6
Name: Series, dtype: int64
b.name = 'New Series'

b['b','c'] = 20

b
Out[109]: 
a    15
b    20
c    20
d     6
Name: New Series, dtype: int64

Series类型（主要表达一维数据）

Series 是一维带 “标签” 数组

index_0 ----> data_a

Series 基本操作类似ndarray和字段，根据索引对齐。

Pandas 库的DataFrame类型

DataFrame类型（常用于表达二维数据，或多维数据）

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

index_0 --> data_a data_1 … data_w

index_1 --> data_b data_2 … data_x

index_2 --> data_c data_3 … data_y

index_3 --> data_d data_4 … data_z

索引 多列数据

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

DataFrame 类型创建:

二维Ndarray对象

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

由一维ndarray、列表、字典、元组或 Series 构成的字典

从一维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'])}
d1=pd.DataFrame(dt)
d1
Out[123]: 
   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[134]: 
   two three
b    8   NaN
c    7   NaN
d    6   NaN

从列表类型的字典创建

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

# 例1.1
import pandas as pb

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.0, 145.5, 101.6]}
d = pd.DataFrame(dl,index = ['c1','c2','c3','c4','c5'])
d
Out[144]: 
    城市     环比     同比     定基
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
Out[145]: Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')
d.columns
Out[146]: Index(['城市', '环比', '同比', '定基'], dtype='object')
d.values
Out[147]: 
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['同比'] # 列索引取值
Out[148]: 
c1    120.7
c2    127.3
c3    119.4
c4    140.9
c5    101.4
Name: 同比, dtype: float64
d.loc['c2'] # 行索引
Out[155]: 
城市       上海
环比    101.2
同比    127.3
定基    127.8
Name: c2, dtype: object
d['同比']['c2']
Out[159]: 127.3

Series 类型

DataFrame是二维带“标签”数组

column_0 column_1 column_i
index_0 data_a data_1 data_w
DataFrame基本操作类似Series，依据行列索引
其他的DataFrame类型

	column_0	column_1	column_i
index_0	data_a	data_1	data_w

Pandas 库的数据类型操作

数据类型操作

如何改变Series和DataFrame对象？

增加或重排：重新索引

**.reindex()**能够改变或重排 Series 和 DataFrame 索引
删除：drop

import pandas as pb

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.0, 145.5, 101.6]}
d = pd.DataFrame(dl,index = ['c1','c2','c3','c4','c5'])
d
Out[144]: 
    城市     环比     同比     定基
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 = d.reindex(index=['c5','c4','c3','c2','c1']) # 重排行索引
d
Out[162]: 
    城市     环比     同比     定基
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
d = d.reindex(columns=['城市','同比','环比','定基']) # 重排列索引
d
Out[164]: 
    城市     同比     环比     定基
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

重新索引

重新索引**.reindex(index=None, columns=None, …)**的参数

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

重新索引

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.0, 145.5, 101.6]}

d = pd.DataFrame(dl,index=['c1','c2','c3','c4','c5']) # 从字典创建
d
Out[172]: 
    城市     环比     同比     定基
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 = d.reindex(index=['c5','c4','c3','c2','c1']) # 重排索引
d
Out[174]: 
    城市     环比     同比     定基
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
new_c = d.columns.insert(4,'新增') # 新增列
new_c
Out[176]: Index(['城市', '环比', '同比', '定基', '新增'], dtype='object')
new_d = d.reindex(columns=new_c,fill_value=200) #重新索引，填充缺失位置的值
new_d
Out[178]: 
    城市     环比     同比     定基   新增
c5  沈阳  100.1  101.4  101.6  200
c4  深圳  102.0  140.9  145.5  200
c3  广州  101.3  119.4  120.0  200
c2  上海  101.2  127.3  127.8  200
c1  北京  101.5  120.7  121.4  200

索引类型

索引类型

d.index
Out[179]: Index(['c5', 'c4', 'c3', 'c2', 'c1'], dtype='object')
d.columns
Out[180]: Index(['城市', '环比', '同比', '定基'], dtype='object')
new_d.columns
Out[182]: Index(['城市', '环比', '同比', '定基', '新增'], dtype='object')

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[183]: 
    城市     环比     同比     定基
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
d.columns
Out[187]: Index(['城市', '环比', '同比', '定基'], dtype='object')
nc=d.columns.delete(2) # 删除列
nc
Out[185]: Index(['城市', '环比', '定基'], dtype='object')
ni = d.index.insert(5,'c0') # 插入行
ni
Out[189]: Index(['c5', 'c4', 'c3', 'c2', 'c1', 'c0'], dtype='object')
nd2 = d.reindex(index=ni,columns=nc).ffill() # 新数据，重新填充
nd2
Out[197]: 
    城市     环比     定基
c5  沈阳  100.1  101.6
c4  深圳  102.0  145.5
c3  广州  101.3  120.0
c2  上海  101.2  127.8
c1  北京  101.5  121.4
c0  北京  101.5  121.4

删除指定索引对象

删除：drop

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


import pandas as pd

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

a
Out[200]: 
a    9
b    8
c    7
d    6
dtype: int64

a.drop(['b','c'])
Out[201]: 
a    9
d    6
dtype: int64
    
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.0, 145.5, 101.6]}

d = pd.DataFrame(dl,index=['c5','c4','c3','c2','c1'])

d
Out[204]: 
    城市     环比     同比     定基
c5  北京  101.5  120.7  121.4
c4  上海  101.2  127.3  127.8
c3  广州  101.3  119.4  120.0
c2  深圳  102.0  140.9  145.5
c1  沈阳  100.1  101.4  101.6
d.drop('c5') # 删除行
Out[205]: 
    城市     环比     同比     定基
c4  上海  101.2  127.3  127.8
c3  广州  101.3  119.4  120.0
c2  深圳  102.0  140.9  145.5
c1  沈阳  100.1  101.4  101.6
d.drop('同比',axis=1) # 删除列
Out[207]: 
    城市     环比     定基
c5  北京  101.5  121.4
c4  上海  101.2  127.8
c3  广州  101.3  120.0
c2  深圳  102.0  145.5
c1  沈阳  100.1  101.6

Pandas 库的数据类型运算

算术运算法则

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

数据类型的算术运算

import pandas as pd
import numpy as np
a = pd.DataFrame(np.arange(12).reshape(3,4))

a
Out[214]: 
   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[216]: 
    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[217]: 
      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[218]: 
      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)	类型间除法运算，可选参数

import pandas as pd
import numpy as np
a = pd.DataFrame(np.arange(12).reshape(3,4))

a
Out[214]: 
   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[216]: 
    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
b.add(a,fill_value=100)
Out[220]: 
       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[222]: 
      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

fill_value参数代替NaN，代替后参与运算

b
Out[223]: 
    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[225]: 
0    0
1    1
2    2
3    3
dtype: int32
c-10
Out[226]: 
0   -10
1    -9
2    -8
3    -7
dtype: int32
c-b
Out[227]: 
      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
b-c
Out[228]: 
      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参与运算

b
Out[229]: 
    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
Out[230]: 
0    0
1    1
2    2
3    3
dtype: int32

b.sub(c,axis=0)
Out[231]: 
    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

b.add(c,axis=0)
Out[232]: 
    0   1   2   3   4
0   0   1   2   3   4
1   6   7   8   9  10
2  12  13  14  15  16
3  18  19  20  21  22

使用运算方法可以令一维Series参与轴0运算

比较运算法则

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

数据类型的比较运算

import pandas as pd
import numpy as np

a = pd.DataFrame(np.arange(12).reshape(3,4))
a
Out[239]: 
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
b = pd.DataFrame(np.arange(12,0,-1).reshape(3,4))
b
Out[242]: 
    0   1   2  3
0  12  11  10  9
1   8   7   6  5
2   4   3   2  1
a > b
Out[244]: 
       0      1      2      3
0  False  False  False  False
1  False  False  False   True
2   True   True   True   True
a == b
Out[258]: 
       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[261]: 
0    0
1    1
2    2
3    3
dtype: int32

a>c
Out[263]: 
       0      1      2      3
0  False  False  False  False
1   True   True   True   True
2   True   True   True   True

c>0
Out[264]: 
0    False
1     True
2     True
3     True
dtype: bool

Z_sam

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据分析与展示 pandas 入门

pandas 入门Pandas 库的介绍Pandas 库的引用pandas是python第三方库，提供高性能易用数据类型和分析工具import pandas as pdPandas基于NumPy实现，常与NumPy和Matplotlib一同使用Pandas 库小测import pandas as pdd = pd.Series(range(20))print(d)print(d.cumsum())Pandas 库的理解两个数据类型：Series， DataFrame基于上述数据
复制链接

扫一扫

专栏目录