本篇内容介绍了“Python Pandas的知识点有哪些”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
成都创新互联-专业网站定制、快速模板网站建设、高性价比东丰网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式东丰网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖东丰地区。费用合理售后完善，10多年实体公司更值得信赖。
为什么要学习Pandas?
那么问题来了：
numpy已经能够帮助我们处理数据，能够结合matplotlib解决我们数据分析的问题，那么pandas学习的目的在什么地方呢？
numpy能够帮我们处理处理数值型数据，但是这还不够， 很多时候，我们的数据除了数值之外，还有字符串，还有时间序列等
比如：我们通过爬虫获取到了存储在数据库中的数据
所以，pandas出现了。
什么是Pandas?
Pandas的名称来自于面板数据（panel data）
Pandas是一个强大的分析结构化数据的工具集，基于NumPy构建，提供了高级数据结构和数据操作工具，它是使Python成为强大而高效的数据分析环境的重要因素之一。
一个强大的分析和操作大型结构化数据集所需的工具集
基础是NumPy，提供了高性能矩阵的运算
提供了大量能够快速便捷地处理数据的函数和方法
应用于数据挖掘，数据分析
提供数据清洗功能
1. Pandas的索引操作
索引对象Index
1. Series和DataFrame中的索引都是Index对象
示例代码：
print(type(ser_obj.index))print(type(df_obj2.index))print(df_obj2.index)
运行结果：
Int64Index([0, 1, 2, 3], dtype='int64')
2. 索引对象不可变，保证了数据的安全
示例代码：
# 索引对象不可变df_obj2.index[0] = 2
运行结果：
---------------------------------------------------------------------------TypeError Traceback (most recent call last) in ()
1 # 索引对象不可变----> 2 df_obj2.index[0] = 2/Users/Power/anaconda/lib/python3.6/site-packages/pandas/indexes/base.py in __setitem__(self, key, value)
1402
1403 def __setitem__(self, key, value):-> 1404 raise TypeError("Index does not support mutable operations")
1405
1406 def __getitem__(self, key):TypeError: Index does not support mutable operations
3. 常见的Index种类
Index，索引
Int64Index，整数索引
MultiIndex，层级索引
DatetimeIndex，时间戳类型
3.1 Series索引
1. index 指定行索引名
示例代码：
ser_obj = pd.Series(range(5), index = ['a', 'b', 'c', 'd', 'e'])print(ser_obj.head())
运行结果：
a 0
b 1
c 2
d 3
e 4
dtype: int64
2. 行索引
ser_obj[‘label’], ser_obj[pos]
示例代码：
# 行索引print(ser_obj['b'])print(ser_obj[2])
运行结果：
1
2
3. 切片索引
ser_obj[2:4], ser_obj[‘label1’: ’label3’]
注意，按索引名切片操作时，是包含终止索引的。
示例代码：
# 切片索引print(ser_obj[1:3])print(ser_obj['b':'d'])
运行结果：
b 1
c 2
dtype: int64
b 1
c 2
d 3
dtype: int64
4. 不连续索引
ser_obj[[‘label1’, ’label2’, ‘label3’]]
示例代码：
# 不连续索引print(ser_obj[[0, 2, 4]])print(ser_obj[['a', 'e']])
运行结果：
a 0
c 2
e 4
dtype: int64
a 0
e 4
dtype: int64
5. 布尔索引
示例代码：
# 布尔索引ser_bool = ser_obj > 2print(ser_bool)print(ser_obj[ser_bool])print(ser_obj[ser_obj > 2])
运行结果：
a False
b False
c False
d True
e True
dtype: bool
d 3
e 4
dtype: int64
d 3
e 4
dtype: int64
3.2 DataFrame索引
1. columns 指定列索引名
示例代码：
import numpy as np
df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])print(df_obj.head())
运行结果：
a b c d
0 -0.241678 0.621589 0.843546 -0.383105
1 -0.526918 -0.485325 1.124420 -0.653144
2 -1.074163 0.939324 -0.309822 -0.209149
3 -0.716816 1.844654 -2.123637 -1.323484
4 0.368212 -0.910324 0.064703 0.486016
2. 列索引
df_obj[[‘label’]]
示例代码：
# 列索引print(df_obj['a']) # 返回Series类型
运行结果：
0 -0.241678
1 -0.526918
2 -1.074163
3 -0.716816
4 0.368212
Name: a, dtype: float64
3. 不连续索引
df_obj[[‘label1’, ‘label2’]]
示例代码：
# 不连续索引print(df_obj[['a','c']])
运行结果：
a c
0 -0.241678 0.843546
1 -0.526918 1.124420
2 -1.074163 -0.309822
3 -0.716816 -2.123637
4 0.368212 0.064703
4. 高级索引：标签、位置和混合
Pandas的高级索引有3种
1. loc 标签索引
DataFrame 不能直接切片，可以通过loc来做切片
loc是基于标签名的索引，也就是我们自定义的索引名
示例代码：
# 标签索引 loc# Seriesprint(ser_obj['b':'d'])print(ser_obj.loc['b':'d'])# DataFrameprint(df_obj['a'])# 第一个参数索引行，第二个参数是列print(df_obj.loc[0:2, 'a'])
运行结果：
b 1
c 2
d 3
dtype: int64
b 1
c 2
d 3
dtype: int64
0 -0.241678
1 -0.526918
2 -1.074163
3 -0.716816
4 0.368212
Name: a, dtype: float64
0 -0.241678
1 -0.526918
2 -1.074163
Name: a, dtype: float64
2. iloc 位置索引
作用和loc一样，不过是基于索引编号来索引
示例代码：
# 整型位置索引 iloc# Seriesprint(ser_obj[1:3])print(ser_obj.iloc[1:3])# DataFrameprint(df_obj.iloc[0:2, 0]) # 注意和df_obj.loc[0:2, 'a']的区别
运行结果：
b 1
c 2
dtype: int64
b 1
c 2
dtype: int64
0 -0.241678
1 -0.526918
Name: a, dtype: float64
3. ix 标签与位置混合索引
ix是以上二者的综合，既可以使用索引编号，又可以使用自定义索引，要视情况不同来使用，
如果索引既有数字又有英文，那么这种方式是不建议使用的，容易导致定位的混乱。
示例代码：
# 混合索引 ix# Seriesprint(ser_obj.ix[1:3])print(ser_obj.ix['b':'c'])# DataFrameprint(df_obj.loc[0:2, 'a'])print(df_obj.ix[0:2, 0])
运行结果：
b 1
c 2
dtype: int64
b 1
c 2
dtype: int64
0 -0.241678
1 -0.526918
2 -1.074163
Name: a, dtype: float64
注意
DataFrame索引操作，可将其看作ndarray的索引操作
标签的切片索引是包含末尾位置的
2. Pandas的对齐运算
Pandas的对齐运算是数据清洗的重要过程，可以按索引对齐进行运算，如果没对齐的位置则补NaN，最后也可以填充NaN
2.1 Series的对齐运算
1. Series 按行、索引对齐
示例代码：
s1 = pd.Series(range(10, 20), index = range(10))s2 = pd.Series(range(20, 25), index = range(5))print('s1: ' )print(s1)print('') print('s2: ')print(s2)运行结果：
s1:
0 10
1 11
2 12
3 13
4 14
5 15
6 16
7 17
8 18
9 19
dtype: int64
s2:
0 20
1 21
2 22
3 23
4 24
dtype: int64
2. Series的对齐运算
示例代码：
# Series 对齐运算s1 + s2
运行结果：
0 30.0
1 32.0
2 34.0
3 36.0
4 38.0
5 NaN
6 NaN
7 NaN
8 NaN
9 NaN
dtype: float64
2.2 DataFrame的对齐运算
1. DataFrame按行、列索引对齐
示例代码：
df1 = pd.DataFrame(np.ones((2,2)), columns = ['a', 'b'])df2 = pd.DataFrame(np.ones((3,3)), columns = ['a', 'b', 'c'])print('df1: ')print(df1)print('') print('df2: ')print(df2)运行结果：
df1:
a b
0 1.0 1.0
1 1.0 1.0
df2:
a b c
0 1.0 1.0 1.0
1 1.0 1.0 1.0
2 1.0 1.0 1.0
2. DataFrame的对齐运算
示例代码：
# DataFrame对齐操作df1 + df2
运行结果：
a b c0 2.0 2.0 NaN1 2.0 2.0 NaN2 NaN NaN NaN
2.3 填充未对齐的数据进行运算
fill_value
使用add,sub,p,mul的同时，
通过fill_value指定填充值，未对齐的数据将和填充值做运算
示例代码：
print(s1)print(s2)s1.add(s2, fill_value = -1)print(df1)print(df2)df1.sub(df2, fill_value = 2.)
运行结果：
# print(s1)0 101 112 123 134 145 156 167 178 189 19dtype: int64# print(s2)0 201 212 223 234 24dtype: int64# s1.add(s2, fill_value = -1)0 30.01 32.02 34.03 36.04 38.05 14.06 15.07 16.08 17.09 18.0dtype: float64# print(df1)
a b0 1.0 1.01 1.0 1.0# print(df2)
a b c0 1.0 1.0 1.01 1.0 1.0 1.02 1.0 1.0 1.0# df1.sub(df2, fill_value = 2.)
a b c0 0.0 0.0 1.01 0.0 0.0 1.02 1.0 1.0 1.0
算术方法表:
| 方法 | 描述 | | add，radd | 加法（+） |
| sub，rsub | 减法（-） |
| p，rp | 除法（/） |
| floorp，rfllorp | 整除（//） |
| mul，rmul | 乘法（*） |
| pow，rpow | 幂次方（**） |
3. Pandas的函数应用
3.1 apply 和 applymap
1. 可直接使用NumPy的函数
示例代码：
# Numpy ufunc 函数df = pd.DataFrame(np.random.randn(5,4) - 1)print(df)print(np.abs(df))
运行结果：
0 1 2 3
0 -0.062413 0.844813 -1.853721 -1.980717
1 -0.539628 -1.975173 -0.856597 -2.612406
2 -1.277081 -1.088457 -0.152189 0.530325
3 -1.356578 -1.996441 0.368822 -2.211478
4 -0.562777 0.518648 -2.007223 0.059411
0 1 2 3
0 0.062413 0.844813 1.853721 1.980717
1 0.539628 1.975173 0.856597 2.612406
2 1.277081 1.088457 0.152189 0.530325
3 1.356578 1.996441 0.368822 2.211478
4 0.562777 0.518648 2.007223 0.059411
2. 通过apply将函数应用到列或行上
示例代码：
# 使用apply应用行或列数据#f = lambda x : x.max()print(df.apply(lambda x : x.max()))
运行结果：
0 -0.062413
1 0.844813
2 0.368822
3 0.530325
dtype: float64
注意指定轴的方向，默认axis=0，方向是列
示例代码：
# 指定轴方向，axis=1，方向是行print(df.apply(lambda x : x.max(), axis=1))
运行结果：
0 0.844813
1 -0.539628
2 0.530325
3 0.368822
4 0.518648
dtype: float64
3. 通过applymap将函数应用到每个数据上
示例代码：
# 使用applymap应用到每个数据f2 = lambda x : '%.2f' % xprint(df.applymap(f2))
运行结果：
0 1 2 3
0 -0.06 0.84 -1.85 -1.98
1 -0.54 -1.98 -0.86 -2.61
2 -1.28 -1.09 -0.15 0.53
3 -1.36 -2.00 0.37 -2.21
4 -0.56 0.52 -2.01 0.06
3.2 排序
1. 索引排序
sort_index()
排序默认使用升序排序，ascending=False 为降序排序
示例代码：
# Seriess4 = pd.Series(range(10, 15), index = np.random.randint(5, size=5))print(s4)# 索引排序s4.sort_index() # 0 0 1 3 3
运行结果：
0 10
3 11
1 12
3 13
0 14
dtype: int64
0 10
0 14
1 12
3 11
3 13
dtype: int64
对DataFrame操作时注意轴方向
示例代码：
# DataFramedf4 = pd.DataFrame(np.random.randn(3, 5),
index=np.random.randint(3, size=3),
columns=np.random.randint(5, size=5))print(df4)df4_isort = df4.sort_index(axis=1, ascending=False)print(df4_isort) # 4 2 1 1 0
运行结果：
1 4 0 1 2
2 -0.416686 -0.161256 0.088802 -0.004294 1.164138
1 -0.671914 0.531256 0.303222 -0.509493 -0.342573
1 1.988321 -0.466987 2.787891 -1.105912 0.889082
4 2 1 1 0
2 -0.161256 1.164138 -0.416686 -0.004294 0.088802
1 0.531256 -0.342573 -0.671914 -0.509493 0.303222
1 -0.466987 0.889082 1.988321 -1.105912 2.787891
2. 按值排序
sort_values(by=‘column name’)
根据某个唯一的列名进行排序，如果有其他相同列名则报错。
示例代码：
# 按值排序df4_vsort = df4.sort_values(by=0, ascending=False)print(df4_vsort)
运行结果：
1 4 0 1 2
1 1.988321 -0.466987 2.787891 -1.105912 0.889082
1 -0.671914 0.531256 0.303222 -0.509493 -0.342573
2 -0.416686 -0.161256 0.088802 -0.004294 1.164138
3.3 处理缺失数据
示例代码：
df_data = pd.DataFrame([np.random.randn(3), [1., 2., np.nan],
[np.nan, 4., np.nan], [1., 2., 3.]])print(df_data.head())
运行结果：
0 1 2
0 -0.281885 -0.786572 0.487126
1 1.000000 2.000000 NaN
2 NaN 4.000000 NaN
3 1.000000 2.000000 3.000000
1. 判断是否存在缺失值：isnull()
示例代码：
# isnullprint(df_data.isnull())
运行结果：
0 1 2
0 False False False
1 False False True
2 True False True
3 False False False
2. 丢弃缺失数据：dropna()
根据axis轴方向，丢弃包含NaN的行或列。 示例代码：
# dropnaprint(df_data.dropna()) # 默认是按行print(df_data.dropna(axis=1)) # axis=1是按列
运行结果：
0 1 2
0 -0.281885 -0.786572 0.487126
3 1.000000 2.000000 3.000000
1
0 -0.786572
1 2.000000
2 4.000000
3 2.000000
3. 填充缺失数据：fillna()
示例代码：
# fillnaprint(df_data.fillna(-100.))
运行结果：
0 1 2
0 -0.281885 -0.786572 0.487126
1 1.000000 2.000000 -100.000000
2 -100.000000 4.000000 -100.000000
3 1.000000 2.000000 3.000000
4. 层级索引（hierarchical indexing）
下面创建一个Series， 在输入索引Index时，输入了由两个子list组成的list，第一个子list是外层索引，第二个list是内层索引。
示例代码：
import pandas as pdimport numpy as np
ser_obj = pd.Series(np.random.randn(12),index=[
['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
])print(ser_obj)
运行结果：
a 0 0.099174
1 -0.310414
2 -0.558047
b 0 1.742445
1 1.152924
2 -0.725332
c 0 -0.150638
1 0.251660
2 0.063387
d 0 1.080605
1 0.567547
2 -0.154148
dtype: float64
4.1 MultiIndex索引对象
打印这个Series的索引类型，显示是MultiIndex
直接将索引打印出来，可以看到有lavels,和labels两个信息。levels表示两个层级中分别有那些标签，labels是每个位置分别是什么标签。
示例代码：
print(type(ser_obj.index))print(ser_obj.index)
运行结果：
MultiIndex(levels=[['a', 'b', 'c', 'd'], [0, 1, 2]],
labels=[[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]])
4.2 选取子集
1. 外层选取：
ser_obj[‘outer_label’]
示例代码：
# 外层选取print(ser_obj['c'])
运行结果：
0 -1.362096
1 1.558091
2 -0.452313
dtype: float64
2. 内层选取：
ser_obj[:, ‘inner_label’]
示例代码：
# 内层选取print(ser_obj[:, 2])
运行结果：
a 0.826662
b 0.015426
c -0.452313
d -0.051063
dtype: float64
常用于分组操作、透视表的生成等
4.2 交换分层顺序
swaplevel()
.swaplevel( )交换内层与外层索引。
示例代码：
print(ser_obj.swaplevel())
运行结果：
0 a 0.099174
1 a -0.310414
2 a -0.558047
0 b 1.742445
1 b 1.152924
2 b -0.725332
0 c -0.150638
1 c 0.251660
2 c 0.063387
0 d 1.080605
1 d 0.567547
2 d -0.154148
dtype: float64
4.3 交换并排序分层
sortlevel()
.sortlevel( )先对外层索引进行排序，再对内层索引进行排序，默认是升序。
示例代码：
# 交换并排序分层print(ser_obj.swaplevel().sortlevel())
运行结果：
0 a 0.099174
b 1.742445
c -0.150638
d 1.080605
1 a -0.310414
b 1.152924
c 0.251660
d 0.567547
2 a -0.558047
b -0.725332
c 0.063387
d -0.154148
dtype: float64
5. Pandas统计计算和描述
示例代码：
arr1 = np.random.rand(4,3)pd1 = pd.DataFrame(arr1,columns=list('ABC'),index=list('abcd'))f = lambda x: '%.2f'% x
pd2 = pd1.applymap(f).astype(float)pd2运行结果：
A B C
a 0.87 0.26 0.67
b 0.69 0.89 0.17
c 0.94 0.33 0.04
d 0.35 0.46 0.29
5.1 常用的统计计算
sum, mean, max, min…
axis=0 按列统计，axis=1按行统计
skipna 排除缺失值， 默认为True
示例代码：
pd2.sum() #默认把这一列的Series计算,所有行求和pd2.sum(axis='columns') #指定求每一行的所有列的和pd2.idxmax()#查看每一列所有行的最大值所在的标签索引，同样我们也可以通过axis='columns'求每一行所有列的最大值的标签索引
运行结果：
A 2.85
B 1.94
C 1.17
dtype: float64
a 1.80
b 1.75
c 1.31
d 1.10
dtype: float64
A c
B b
C a
dtype: object
5.2 常用的统计描述
describe 产生多个统计数据
示例代码：
pd2.describe()#查看汇总
运行结果：
A B C
count 4.000000 4.00000 4.000000mean 0.712500 0.48500 0.292500std 0.263613 0.28243 0.271585min 0.350000 0.26000 0.04000025% 0.605000 0.31250 0.13750050% 0.780000 0.39500 0.23000075% 0.887500 0.56750 0.385000max 0.940000 0.89000 0.670000
#百分比:除以原来的量pd2.pct_change() #查看行的百分比变化，同样指定axis='columns'列与列的百分比变化
A B C
a NaN NaN NaN
b -0.206897 2.423077 -0.746269c 0.362319 -0.629213 -0.764706d -0.627660 0.393939 6.250000
5.3 常用的统计描述方法
6. 数据读取与存储
.jpg)
6.1 csv文件
读取csv文件read_csv(file_path or buf,usecols,encoding):file_path：文件路径,usecols:指定读取的列名，encoding:编码
data = pd.read_csv('d:/test_data/food_rank.csv',encoding='utf8')data.head()
name num0 酥油茶 219.01 青稞酒 95.02 酸奶 62.03 糌粑 16.04 琵琶肉 2.0#指定读取的列名data = pd.read_csv('d:/test_data/food_rank.csv',usecols=['name'])data.head()
name0 酥油茶1 青稞酒2 酸奶3 糌粑4 琵琶肉#如果文件路径有中文，则需要知道参数engine='python'data = pd.read_csv('d:/数据/food_rank.csv',engine='python',encoding='utf8')data.head()
name num0 酥油茶 219.01 青稞酒 95.02 酸奶 62.03 糌粑 16.04 琵琶肉 2.0#建议文件路径和文件名，不要出现中文写入csv文件
DataFrame:to_csv(file_path or buf,sep,columns,header,index,na_rep,mode)：file_path：保存文件路径,默认None,sep:分隔符,默认’,’ ,columns:是否保留某列数据,默认None,header：是否保留列名,默认True,index:是否保留行索引,默认True,na_rep:指定字符串来代替空值,默认是空字符,mode:默认’w’,追加’a’
**Series**:`Series.to_csv`\ (_path=None_,_index=True_,_sep='_,_'_,_na\_rep=''_,_header=False_,_mode='w'_,_encoding=None_\)
6.2 数据库交互
# 导入必要模块import pandas as pdfrom sqlalchemy import create_engine#初始化数据库连接#用户名root 密码 端口 3306 数据库 db2engine = create_engine('mysql+pymysql://root:@localhost:3306/db2')#查询语句sql = '''
select * from class;
'''#两个参数 sql语句 数据库连接df = pd.read_sql(sql,engine)df.jpg)
#新建df = pd.DataFrame({'id':[1,2,3,4],'num':[34,56,78,90]})df = pd.read_csv('ex1.csv')# #写入到数据库df.to_sql('df2',engine,index=False)print("ok")进入数据库查看
7. 数据清洗
7.1 数据清洗和准备
数据清洗是数据分析关键的一步，直接影响之后的处理工作
数据需要修改吗？有什么需要修改的吗？数据应该怎么调整才能适用于接下来的分析和挖掘？
是一个迭代的过程，实际项目中可能需要不止一次地执行这些清洗操作
1. 处理缺失数据
2. 数据转换
2.1 处理重复数据
2.2 duplicated()是否为重复行
duplicated\(\): 返回布尔型Series表示每行是否为重复行
示例代码：
import numpy as npimport pandas as pd
df_obj = pd.DataFrame({'data1' : ['a'] * 4 + ['b'] * 4,
'data2' : np.random.randint(0, 4, 8)})print(df_obj)print(df_obj.duplicated())运行结果：
# print(df_obj)
data1 data20 a 31 a 22 a 33 a 34 b 15 b 06 b 37 b 0# print(df_obj.duplicated())0 False1 False2 True3 True4 False5 False6 False7 Truedtype: bool
2.4 drop_duplicates()过滤重复行
示例代码：
print(df_obj.drop_duplicates())print(df_obj.drop_duplicates('data2'))运行结果：
# print(df_obj.drop_duplicates())
data1 data20 a 31 a 24 b 15 b 06 b 3# print(df_obj.drop_duplicates('data2'))
data1 data20 a 31 a 24 b 15 b 02.5 利用函数或映射进行数据转换
根据map传入的函数对每行或每列进行转换
示例代码：
ser_obj = pd.Series(np.random.randint(0,10,10))print(ser_obj)print(ser_obj.map(lambda x : x ** 2))
运行结果：
# print(ser_obj)0 11 42 83 64 85 66 67 48 79 3dtype: int64# print(ser_obj.map(lambda x : x ** 2))0 11 162 643 364 645 366 367 168 499 9dtype: int64
2.6 替换值
replace根据值的内容进行替换
示例代码：
# 单个值替换单个值print(ser_obj.replace(1, -100))# 多个值替换一个值print(ser_obj.replace([6, 8], -100))# 多个值替换多个值print(ser_obj.replace([4, 7], [-100, -200]))
运行结果：
# print(ser_obj.replace(1, -100))0 -1001 42 83 64 85 66 67 48 79 3dtype: int64# print(ser_obj.replace([6, 8], -100))0 11 42 -1003 -1004 -1005 -1006 -1007 48 79 3dtype: int64# print(ser_obj.replace([4, 7], [-100, -200]))0 11 -1002 83 64 85 66 67 -1008 -2009 3dtype: int64
3. 字符串操作
3.1 字符串方法
.jpg)
.jpg)
3.2 正则表达式方法
3.3 pandas字符串函数
7.2 数据合并
1. 数据合并(pd.merge)
根据单个或多个键将不同DataFrame的行连接起来
类似数据库的连接操作
pd.merge:(left, right, how=‘inner’,on=None,left_on=None, right_on=None )
left:合并时左边的DataFrame
right:合并时右边的DataFrame
how:合并的方式,默认’inner’, ‘outer’, ‘left’, ‘right’
on:需要合并的列名,必须两边都有的列名，并以 left 和 right 中的列名的交集作为连接键
left_on: left Dataframe中用作连接键的列
right_on: right Dataframe中用作连接键的列
内连接 inner:对两张表都有的键的交集进行联合
.jpg)
.jpg)
示例代码：
import pandas as pdimport numpy as np
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})pd.merge(left,right,on='key') #指定连接键key运行结果：
key A B C D0 K0 A0 B0 C0 D01 K1 A1 B1 C1 D12 K2 A2 B2 C2 D23 K3 A3 B3 C3 D3
示例代码：
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})pd.merge(left,right,on=['key1','key2']) #指定多个键，进行合并运行结果：
key1 key2 A B C D0 K0 K0 A0 B0 C0 D01 K1 K0 A2 B2 C1 D12 K1 K0 A2 B2 C2 D2
.jpg)
#指定左连接left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})pd.merge(left, right, how='left', on=['key1', 'key2'])
key1 key2 A B C D0 K0 K0 A0 B0 C0 D01 K0 K1 A1 B1 NaN NaN2 K1 K0 A2 B2 C1 D13 K1 K0 A2 B2 C2 D24 K2 K1 A3 B3 NaN NaN
#指定右连接left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})pd.merge(left, right, how='right', on=['key1', 'key2'])
key1 key2 A B C D0 K0 K0 A0 B0 C0 D01 K1 K0 A2 B2 C1 D12 K1 K0 A2 B2 C2 D23 K2 K0 NaN NaN C3 D3
默认是“内连接”(inner)，即结果中的键是交集
how: 指定连接方式
“外连接”(outer)，结果中的键是并集
示例代码：
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
pd.merge(left,right,how='outer',on=['key1','key2'])运行结果：
key1 key2 A B C D0 K0 K0 A0 B0 C0 D01 K0 K1 A1 B1 NaN NaN2 K1 K0 A2 B2 C1 D13 K1 K0 A2 B2 C2 D24 K2 K1 A3 B3 NaN NaN5 K2 K0 NaN NaN C3 D3
1. 处理重复列名
参数suffixes：默认为_x, _y
示例代码：
# 处理重复列名df_obj1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
'data' : np.random.randint(0,10,7)})df_obj2 = pd.DataFrame({'key': ['a', 'b', 'd'],
&nbs
当前名称：PythonPandas的知识点有哪些
标题路径：http://cdxtjz.cn/article/pppsoj.html
