pandas
安装方法：pip3 install pandas
pandas是一个强大的Python数据分析的工具包,它是基于NumPy构建的模块。
pandas的主要功能：
具备对其功能的数据结构DataFrame、Series
集成时间序列功能
提供丰富的数学运算和操作（实质是NumPy提供的）
灵活处理缺失数据(NaN)
引用方法：import pandas as pd
Series
Series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签（索引）组成。索引可以自定义如果不谢的话默认是从0开始的数据
1.1、创建方式：
pd.Series([4,7,-5,3])
pd.Series([4,7,-5,3],index=['a','b','c','d'])
pd.Series({'a':1, 'b':2})
pd.Series(0, index=['a','b','c','d'])
1.2、Series比较像列表（数组）和字典的结合体，取Series中某值的话，通过索引可以取值也可以通过位置取值。
In [1]: import pandas as pd
#创建Series
In [2]: a = pd.Series([11,12,13,14,15],index=list("abcde"))
In [3]: a
Out[3]:
a 11
b 12
c 13
d 14
e 15
dtype: int64
#取值，通过索引(标签)获取
In [4]: a["a"]
Out[4]: 11
#通过位置获取
In [5]: a[0]
Out[5]: 11
1.3、获取值数组和索引数组：values属性和index属性
In [6]: a Out[6]: a 11 b 12 c 13 d 14 e 15 dtype: int64 #获取左侧索引(标签) In [8]: a.index Out[8]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object') #获取右侧值 In [9]: a.values Out[9]: array([11, 12, 13, 14, 15], dtype=int64)
1.4、Series特性 (完全继承数组NumPy的特性，唯一不同的是：Series是一维数组)
Series支持NumPy模块的特性（下标）
从ndarray创建Series：Series(arr)
与标量运算：sr*2
两个Series运算：sr1+sr2
索引：sr[0], sr[[1,2,4]]（花式索引）布尔索引
布尔值过滤：sr[sr>0]
切片：sr[0:2]
也可以通过标签改值：sr[0] = 11
注意：普通的切片也是一个视图，与NumPy中切片的属性完全一致。
通用函数：np.abs(sr)
示例代码：
In [11]: import numpy as np
In [12]: import pandas as pd
In [13]: a = pd.Series(np.arange(6),index=list("abcdef"))
In [14]: a
Out[14]:
a 0
b 1
c 2
d 3
e 4
f 5
dtype: int32
#标量运算测试
In [15]: a+1
Out[15]:
a 1
b 2
c 3
d 4
e 5
f 6
dtype: int32
In [16]: a**2
Out[16]:
a 0
b 1
c 4
d 9
e 16
f 25
dtype: int32
In [17]: a+a
Out[17]:
a 0
b 2
c 4
d 6
e 8
f 10
dtype: int32
#索引取值
In [18]: a[0]
Out[18]: 0
In [19]: a[-1]
Out[19]: 5
#花式索引取值
In [20]: a[[1,2,4]]
Out[20]:
b 1
c 2
e 4
dtype: int32
#布尔索引判断
In [21]: a>3
Out[21]:
a False
b False
c False
d False
e True
f True
dtype: bool
#布尔索引取值
In [22]: a[a>3]
Out[22]:
e 4
f 5
dtype: int32
#切片
In [23]: b = a[:3]
In [24]: b
Out[24]:
a 0
b 1
c 2
dtype: int32
#切片视图测试
In [25]: b[0]=10
In [26]: b
Out[26]:
a 10
b 1
c 2
dtype: int32
In [27]: a
Out[27]:
a 10
b 1
c 2
d 3
e 4
f 5
dtype: int32
#切片拷贝测试
In [28]: c = a[3:].copy()
In [29]: c
Out[29]:
d 3
e 4
f 5
dtype: int32
In [30]: c[-1]=15
In [31]: c
Out[31]:
d 3
e 4
f 15
dtype: int32
In [32]: a
Out[32]:
a 10
b 1
c 2
d 3
e 4
f 5
dtype: int32
#通用函数测试
In [34]: a[0] = -10
In [35]: a
Out[35]:
a -10
b 1
c 2
d 3
e 4
f 5
dtype: int32
In [36]: np.abs(a)
Out[36]:
a 10
b 1
c 2
d 3
e 4
f 5
dtype: int32
1.5、Series支持字典的特性（标签）：
可以通过字典创建Series：
dic = {"a":1,"b":2,"c":3}
pd.Series(dic),
in运算,判断键在不在Series中，返回布尔值。get也可以判断，但不会报错！
’a’ in sr
键索引：sr['a'], sr[['a', 'b', 'd']]，也支持切片
当用标签去切片的时候，是可以取到结果的！原因：数组是有序的！并且切片得到的结果不同于数组的切片是顾头顾尾！
不同点：for 循环得到的是values值而不是索引！可以理解为数组的权重高！
示例代码：
In [37]: dic = {"a":1,"b":2,"c":3}
#通过字典创建Series数据
In [38]: a = pd.Series(dic)
In [39]: a
Out[39]:
a 1
b 2
c 3
dtype: int64
#in判断
In [40]: "a" in a
Out[40]: True
In [41]: "d" in a
Out[41]: False
#切片
#通过标签切片
In [42]: a["a":"b"]
Out[42]:
a 1
b 2
dtype: int64
In [43]: a["b":]
Out[43]:
b 2
c 3
dtype: int64
#通过索引切片
In [44]: a[:2]
Out[44]:
a 1
b 2
dtype: int64
#索引与花式索引
In [45]: a["a"]
Out[45]: 1
In [46]: a[["a","c"]]
Out[46]:
a 1
c 3
dtype: int64
#for循环取值
In [47]: for i in a:
...: print(i)
...:
1
2
3
1.6、整数索引：
大家都知道，切片的时候中括号中可以放标签也可以放下标；如果标签是整数，通过切片方式获取值的话，当数值既可以解释成标签也可以解释成下标的时候，他会解释成标签所以最好避免这种以数字作为索引(标签)的方式！要不然会产生各种误会！
可以通过两个属性来解决这个问题：
loc 默认通过标签形式解释
iloc 默认是以下标形式解释
注意：loc or iloc 可以传一个值，也可以切片
示例代码：
#生成Series数组对象 In [48]: b = pd.Series(np.arange(10,20),index=np.arange(10,20)) In [49]: b Out[49]: 10 10 11 11 12 12 13 13 14 14 15 15 16 16 17 17 18 18 19 19 dtype: int32 #通过下标获取 In [50]: b[0] ------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-50-422167f1cdee> in <module>() ----> 1 b[0] c:program filespython36libsite-packagespandascoreseries.py in __getitem__(self, key ) 599 key = com._apply_if_callable(key, self) 600 try: --> 601 result = self.index.get_value(self, key) 602 603 if not is_scalar(result): c:program filespython36libsite-packagespandascoreindexesase.py in get_value(self, series, key) 2475 try: 2476 return self._engine.get_value(s, k, -> 2477 tz=getattr(series.dtype, 'tz', None)) 2478 except KeyError as e1: 2479 if len(self) > 0 and self.inferred_type in ['integer', 'boolean']: pandas\_libsindex.pyx in pandas._libs.index.IndexEngine.get_value (pandas\_libsindex.c:4 404)() pandas\_libsindex.pyx in pandas._libs.index.IndexEngine.get_value (pandas\_libsindex.c:4 087)() pandas\_libsindex.pyx in pandas._libs.index.IndexEngine.get_loc (pandas\_libsindex.c:512 6)() pandas\_libshashtable_class_helper.pxi in pandas._libs.hashtable.Int64HashTable.get_item (pandas\_libshashtable.c:14031)() pandas\_libshashtable_class_helper.pxi in pandas._libs.hashtable.Int64HashTable.get_item (pandas\_libshashtable.c:13975)() KeyError: 0 #通过下标切片获取 In [51]: b[-2:] Out[51]: 18 18 19 19 dtype: int32 #通过标签上的数字 In [52]: b[10] Out[52]: 10 In [53]: b[19] Out[53]: 19 #但无法完成切片 In [54]: b[10:15] Out[54]: Series([], dtype: int32) In [60]: b Out[60]: 10 10 11 11 12 12 13 13 14 14 15 15 16 16 17 17 18 18 19 19 dtype: int32 #同过loc和iloc获取 In [61]: b.loc[10] Out[61]: 10 In [63]: b.loc[19] Out[63]: 19 In [64]: b.iloc[0] Out[64]: 10 In [65]: b.iloc[-1] Out[65]: 19
1.7、Series数据对齐 (常用运算)
【Series在计算时，会先按照标签对齐，然后才会计算】
pandas在运算时，会按索引进行对齐然后计算。如果存在不同的索引，则结果的索引是两个操作数索引的并集。
sr1 = pd.Series([12,23,34], index=['c','a','d']) sr2 = pd.Series([11,20,10], index=['d','c','a',]) sr1+sr2 sr3 = pd.Series([11,20,10,14], index=['d','c','a','b']) sr1+sr3
所以当两个Series的标签不同时，第一步会先合并标签，然后在计算时会把不同标签的值写成NaN(缺失值)，原标签对应的值就不存在。这是因为在进行计算的时候，不同的标签只有一个值，当他与一个缺失标签进行计算的话就会变成缺失值。
那如何在两个Series对象相加时将缺失值设为0呢？在做不同运算的时候，添加相关参数：fill_value=0；定义默认缺失标签值为0
sr1.add(sr2, fill_value=0)
灵活的算术方法：add, sub, div, mul
示例代码：
#定义两个Series数组对象 In [68]: sr1 = pd.Series([12,23,34], index=['c','a','d']); In [69]: sr2 = pd.Series([11,20,10], index=['d','c','a',]) #查看数据 In [70]: sr1 Out[70]: c 12 a 23 d 34 dtype: int64 In [71]: sr2 Out[71]: d 11 c 20 a 10 dtype: int64 #数据对齐加法计算 In [72]: sr1+sr2 Out[72]: a 33 c 32 d 45 dtype: int64 #在定义另一个Series对象 In [73]: sr3 = pd.Series([11,20,10,14], index=['d','c','a','b']) #查看 In [74]: sr3 Out[74]: d 11 c 20 a 10 b 14 dtype: int64 ##数据对齐加法计算(标签并集，缺失值) In [75]: sr1+sr3 Out[75]: a 33.0 b NaN c 32.0 d 45.0 dtype: float64 #解决标签对应缺失值问题 In [76]: sr1.add(sr3,fill_value=0) Out[76]: a 33.0 b 14.0 c 32.0 d 45.0 dtype: float64
1.8、Series关于缺失数据
【注意pandas是不会在原来的数据上修改，需要接收修改覆盖掉，或是重新接收】
缺失数据：使用NaN（Not a Number）来表示缺失数据。其值等于np.nan。内置的None值也会被当做NaN处理。
缺失值表示方式：na nan NaN null
处理缺失数据的相关方法：
dropna() 过滤掉值为NaN的行
fillna() 填充缺失数据
isnull() 返回布尔数组，缺失值对应为True
notnull() 返回布尔数组，缺失值对应为False
过滤缺失数据：sr.dropna() 或 sr[sr.notnull()]
填充缺失数据：sr.fillna(0)
判断是缺失值的方法：sr.isnull() 返回是布尔值的数组,缺失值对应为True
判断不是缺失值的方法：sr.notnull() 返回是布尔值的数组,缺失值对应为False
处理缺失数据有两种办法：
一种是去除不再需要：sr = sr.dropna();
另一种是填上默认值: sr.fillna(1) 用某值把NaN填上参数
示例代码：
In [78]: d Out[78]: a 33.0 b NaN c 32.0 d 45.0 dtype: float64 #去除缺失值 In [79]: d.dropna() Out[79]: a 33.0 c 32.0 d 45.0 dtype: float64 #缺失值判断 In [80]: d.isnull() Out[80]: a False b True c False d False dtype: bool #非缺失值判断 In [81]: d.notnull() Out[81]: a True b False c True d True dtype: bool #缺失值填充 In [82]: d.fillna(111) Out[82]: a 33.0 b 111.0 c 32.0 d 45.0 dtype: float64
NumPy中的通用函数，Series全部支持！
DataFrame
DataFrame是一个表格型的数据结构，含有一组有序的列，要求每一列的数据类型必须相同。DataFrame可以被看做是由Series组成的字典，并且共用一个Series的索引。
2.1、创建方式(很多种，以字典类型举例)：
pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
……
列索引就是创建时字典的键，行索引就是Series的标签；创建的时候还是需要数据对齐的问题！！！
2.2、csv文件读取与写入：
pd.read_csv('filename.csv') #读取 传值可以是文件对象，可以是文件名；
pd.to_csv() #写入 存储文件的时候，会默认把标签列存入，所以存储的时候需要处理下，指定不存储索引。
csv格式存储数据，所有的数据都是以逗号隔开；python内置有处理csv文件的库
2.3、DataFrame查看数据
查看数据常用属性及方法：
index 获取行索引 T 转置 【行列互换】 columns 获取列索引 values 获取值 【二维数组，一行代表一条】 describe() 快速统计 【按列打印的统计描述信息】
name属性：（df 是 DataFrame 对象简写。）
DataFrame 对象每一列都会有一个name属性,就是每列的id名。
1、索引(标签)列的id名：
df.index.name # 查看id df.index.name = "###" #给索引列添加或是改名
2、DataFrame各列name属性：
对列改名：df.rename(columns={"原列名":"新列名",.....})
2.4、DataFrame索引和切片
DataFrame是结合了NumPy和series的所有方法，所以他具有各种各样的花式索引。不同的是：DataFrame有行索引和列索引。
注意：
1、df[] 只能选列，不能选行（直接索引，花式索引都可以，切片不行）;如果选择的仅一列可以看作是Series去操作
2、df[]通过索引得到的数据还是DataFrame对象。
3、df[0:10]如果直接切片操作，DataFrame对象会解释为行,这之后也可以使用列的花式索引！
4、不建议使用上述方法去切片，如果要取一个值的话，可以使用！
获取数据正确的打开方式是：loc[[行,列]]【标签索引】和iloc[[行下标,列下标]]【下标索引】
df.loc[[:10,["close","open"]]] #获取前10行 close和open列的数据
df.iloc[[:10,:2]]
1.1、通过标签获取： df['A'] #只取单列 df[['A', 'B']] #取a,b两列 df['A'][0] #取A列上第一个值 df[0:10][['A', 'C']] #取前10行A、C两列的值 #通过loc属性进行切片操作获取需要的数据 df.loc[:,['A','B']] #获取A、B两列 df.loc[:,'A':'C'] #切片获取 A、B、C三列 df.loc[0,'A'] #获取单个数据 df.loc[0:10,['A','C']] ##取前10行A、C两列的值 1.2、通过位置获取：(记住是通过下标去获取的！) df.iloc[3] df.iloc[3,3] df.iloc[0:3,4:6] df.iloc[1:5,:] df.iloc[[1,2,4],[0,3]] 1.3、通过布尔值过滤： df[df['A']>0] # 通过某一列过滤的数据 df[df<0] #把获取所有为负数的数据 会把所有False对应的值改成NaN,而不是舍去；因为DataFrame是二维数组，无法删除某一行或是某一列。 df[df<0].fillna(0) #给所有NaN的位置赋值为0 df[df['id'].isin([1,3,5])] #isin是在集合中查询，查找某一列中有没有对应值的数据，返回布尔值，然后通过这些值过滤出行。 #同一类型的数据下，可以通过布尔索引过滤，对是NaN的值赋值 df[df["C"]<20] = 0
注意：df[df<20]
代码如上：dataframe 直接做布尔值索引，是直接对整个dataframe数据做的判断，把小于20的False全部改成NaN。
给NaN赋值：df[df<20].fillna(0) 全部赋值为0。
2.5、DataFrame数据对齐与缺失数据
数据对齐：
DataFrame对象在运算时，同样会进行数据对齐，结果的行索引与列索引分别为两个操作数的行索引与列索引的并集。（数据对齐不仅是列对齐，行也必须对齐！）
DataFrame处理缺失数据的方法【与Series的方法一致】。
dropna(axis=0,where='any',…) #默认是判断一行中有没有NaN，有的话会把这一行删除。默认对行操作，默认是any #参数解释： # where="any"/"all" any指：这一行中有一个NaN就删除；all指：这一行中全部都是NaN才删除； # axis 指对行还是对列执行删除操作：0代表行，1代表列 fillna() isnull() notnull()
2.6、其他常用方法 （注意数据的类型）
pandas常用方法（适用Series和DataFrame）：
mean(axis=0,skipna=False) #平均值
sum(axis=1) #求和
sort_index(axis, …, ascending) 按行或列索引排序
#参数：
# ascending升序降序，默认为True,改为False为降序
# axis 指行或列，默认为行
sort_values('列名', axis, ascending) 按值排序/按列排序
#注意点：排序可以传入一个列表，表示按照关键字排序，优先按照第一个元素排序，一样的话再按照第二个排序，依次类推！
sort_values(["close","id"])
NumPy的通用函数同样适用于pandas
#参数为函数的方法，把所有的元素都执行一遍这个函数 apply(func, axis=0) 将自定义函数应用在各行或者各列上，func可返回标量或者Series，func可返回标量或者Series applymap(func) 将函数应用在DataFrame各个元素上 map(func) 将函数应用在Series各个元素上 df.applymap(lambda x:x+1) #操作对象是元素 df["close"].map(lambda x:x+1) df.apply(lambda x:x.sum) #默认操作对象为一列数据
2.7、层次化：
就是有多层索引！通过索引一层一层的去获取数据！
层次化索引是Pandas的一项重要功能，它使我们能够在一个轴上拥有多个索引级别。
例：data=pd.Series(np.random.rand(9), index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'], [1,2,3,1,2,3,1,2,3]])
2.8、从文件读取
1、读取文件：从文件名、URL、文件对象中加载数据
read_csv 默认分隔符为,[逗号] read_table 默认分隔符为
2、读取文件函数主要参数：
sep 指定分隔符，也可以用正则表达式，如：'s+' header=None 指定文件无列名 (会改成编号0，1，2，3) 不写默认把第一行转换成列名 names 指定列名 names=["列名1","列名2",....]可以指定列名 index_col 指定某列作为索引（行索引） [比其他列名低一格] na_values 指定某些字符串表示缺失值 na_values=["none","None","na","nan","NaN","null"] 把列表内的数据解析成 parse_dates 指定某些列是否被解析为日期，传值是布尔值或列表 转化成时间对象，默认为True skiprows 跳过某几行不读 skiprows=["行索引",...]
3、写入到文件：
写入到文件的方法：to_csv
写入文件函数的主要参数：
sep 指定分隔符， na_rep 指定缺失值转换的字符串，默认为空字符串 header=False 不输出列名一行 index=False 不输出行索引一列 保存文件的时候不保存索引列 cols 指定输出的列，参数传入为列表，元素为列名 其他文件类型：json, XML, HTML, 数据库 pandas转换为二进制文件格式（pickle）: save load
2.8、时间对象处理
1、时间序列类型：
时间戳：特定时刻
固定时期：如2017年7月
时间间隔：起始时间-结束时间
Python标准库：datetime 需要指定时间格式
date time datetime timedelta strftime() #对象转成字符串 strptime() #字符串转换成对象
第三方包：dateutil
import dateutil dateutil.parser.parse() #不用指定格式，直接对时间字符串类型转换成时间对象。
成组处理日期：pandas
pd.to_datetime(['2001-01-01', '2002-02-02'])
2、产生时间对象数组：date_range
start 开始时间 end 结束时间 periods 时间长度 给定起始时间(字符串类型)，指定时间长度，生成多少天 freq 时间频率，默认为'D'，可选H(our),W(eek),B(usiness),S(emi-)M(onth)【半个月】,M(onth),(min)T(es), S(econd), A(year),… W-MON 每周一...可以看文档查找
2.9、时间索引
时间序列就是以时间对象为索引的Series或DataFrame。
datetime对象作为索引时是存储在DatetimeIndex对象中的。
1、时间索引特殊功能：
1）传入“年”或“年月”作为切片方式
df["2017"] #会把2017年的数据全部算出来； df["2017-02"] #会把2017年2月的所有数据取出来
2）传入日期范围作为切片方式
df["2017-01-01":"2017-05-08"] #按照时间切片获取，后包括切片时间内容。
补充：
1、补充 array or Series中的两个方法：
shift(n) 移动 操作一维数组，向右移动n个位置 【若n为负数，那向右移动为负，所以为向左移动】空出的位置是缺失值为NaN
rolling(n) 滚动，向前滚动n行(每次带n行迭代)，默认最后一行为中心带着前边n-1行,作为窗口向前滚动。实质就是内部实现遍历切片功能！
2、注意在向二维数组写值的时候，不要用连续的中括号！！！否则会有warning警告！
df["ma5"] = np.nan #正确示范
3、DataFrame数据类型与数据库结构很像，但不会存放在数据库中而是存放在内存，大数据分析要的是速度。当数据量过于庞大时，从内存中获取数据的速度远比在硬盘中获取的快。
DataFrame数据类型与数据库结构很像，所以说数据库的相关操作，DataFrame数据也有：
例如：
分组：df.groupby("A")
.sum() 组内求和
.size() 分组的个数；.
.get_group('foo') 查看复组
组合分组，返回的是层级索引
df.groupby("A","B")
连表操作：
np.merge(数组1,数组2) 参数on="列名" 以某列做join ；how="方法" 连表方法 inner ,left,right
创建数据：
#创建数据：
import pandas as pd
import numpy as np
df = pd.DataFrame(
{"A":["foo","bar","foo","bar","foo","bar","foo","bar",],
"B":["one","one","two","three","two","two","one","three"],
"C":np.random.randn(8),
"D":np.random.randn(8),
})
#执行方法测试
#单分组
s = df.groupby("A")
s.sum()
s.size()
s.get_group("foo") #根据列获取分组该名下对应的数据
#组合分组
ss = df.groupby(["A","B"])
#连表操作：
#创建数据
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",],
})
#连表方法
result = pd.merge(left,right,)
result = pd.merge(left,right,on="key")
result = pd.merge(left,right,on="key",how="inner")
代码执行结果：
In [28]: import pandas as pd
...: import numpy as np
...:
...: df = pd.DataFrame(
...: {"A":["foo","bar","foo","bar","foo","bar","foo","bar",],
...: "B":["one","one","two","three","two","two","one","three"],
...: "C":np.random.randn(8),
...: "D":np.random.randn(8),
...: })
...:
In [29]: df
Out[29]:
A B C D
0 foo one -0.475396 -0.395205
1 bar one 0.197466 -0.371583
2 foo two 0.696546 0.818669
3 bar three -0.205806 0.368646
4 foo two -0.293573 1.889839
5 bar two 0.433100 -0.668867
6 foo one 1.099607 1.725991
7 bar three -0.760478 0.576407
In [30]: s = df.groupby("A")
In [31]: s
Out[31]: <pandas.core.groupby.DataFrameGroupBy object at 0x00000000070F3AC8>
In [32]: s.sum()
Out[32]:
C D
A
bar -0.335718 -0.095396
foo 1.027184 4.039294
In [33]: s.size()
Out[33]:
A
bar 4
foo 4
dtype: int64
In [34]: s.get_group("foo")
Out[34]:
B C D
0 one -0.475396 -0.395205
2 two 0.696546 0.818669
4 two -0.293573 1.889839
6 one 1.099607 1.725991
In [36]: ss = df.groupby(["A","B"])
In [40]: ss.sum()
Out[40]:
C D
A B
bar one 0.197466 -0.371583
three -0.966284 0.945053
two 0.433100 -0.668867
foo one 0.624211 1.330786
two 0.402973 2.708508
#执行效果
In [20]: left = pd.DataFrame({
...: "key":["K0","K1","K2","K3",],
...: "A":["A0","A1","A2","A3",],
...: "B":["B0","B1","B2","B3",],
...: })
In [21]: right = pd.DataFrame({
...: "key":["K0","K1","K2","K3",],
...: "C":["C0","C1","C2","C3",],
...: "D":["D0","D1","D2","D3",],
...: })
#单纯连表
In [22]: result = pd.merge(left,right,)
In [23]: result
Out[23]:
A B key C D
0 A0 B0 K0 C0 D0
1 A1 B1 K1 C1 D1
2 A2 B2 K2 C2 D2
3 A3 B3 K3 C3 D3
#指定连表列
In [24]: result = pd.merge(left,right,on="key")
In [25]: result
Out[25]:
A B key C D
0 A0 B0 K0 C0 D0
1 A1 B1 K1 C1 D1
2 A2 B2 K2 C2 D2
3 A3 B3 K3 C3 D3
#指定连表列和连表类型
In [26]: result = pd.merge(left,right,on="key",how="inner")
In [27]: result
Out[27]:
A B key C D
0 A0 B0 K0 C0 D0
1 A1 B1 K1 C1 D1
2 A2 B2 K2 C2 D2
3 A3 B3 K3 C3 D3