一、Numpy & Pandas 简介
- 主要应用领域：数据分析，机器学习，深度学习
- 运行速度快：两者都是基于C语言编写。Pandas 还是 Numpy 的升级版。
- 消耗资源少：采用矩阵运算，比 python 自带的字典或列表快。
二、Numpy 学习
1、Numpy 属性
- ndim：维度
- shape：行数和列数
- size：元素个数
2、Numpy 的创建 array
1、创建数组
a = np.array([1, 2, 3])
print(a)
2、指定数据类型 dtype
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)
# int 64
a = np.array([2,23,4],dtype=np.int32)
print(a.dtype)
# int32
a = np.array([2,23,4],dtype=np.float)
print(a.dtype)
# float64
a = np.array([2,23,4],dtype=np.float32)
print(a.dtype)
# float32
3、创建特定数据
a = np.array([[2,23,4],[2,32,4]]) # 2d 矩阵 2行3列
print(a)
"""
[[ 2 23 4]
[ 2 32 4]]
"""
创建全零数组
a = np.zeros((3,4)) # 数据全为0，3行4列
"""
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])
"""
创建全一数组, 同时也能指定这些特定数据的 dtype:
a = np.ones((3,4),dtype = np.int) # 数据为1，3行4列
"""
array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]])
"""
创建全空数组, 其实每个值都是接近于零的数:
a = np.empty((3,4)) # 数据为empty，3行4列
"""
array([[ 0.00000000e+000, 4.94065646e-324, 9.88131292e-324,
1.48219694e-323],
[ 1.97626258e-323, 2.47032823e-323, 2.96439388e-323,
3.45845952e-323],
[ 3.95252517e-323, 4.44659081e-323, 4.94065646e-323,
5.43472210e-323]])
"""
用 arange 创建连续数组:
a = np.arange(10,20,2) # 10-19 的数据，2步长
"""
array([10, 12, 14, 16, 18])
"""
使用 reshape 改变数据的形状
a = np.arange(12).reshape((3,4)) # 3行4列，0到11
"""
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
"""
用 linspace 创建线段型数据:
a = np.linspace(1,10,20) # 开始端1，结束端10，且分割成20个数据，生成线段
"""
array([ 1. , 1.47368421, 1.94736842, 2.42105263,
2.89473684, 3.36842105, 3.84210526, 4.31578947,
4.78947368, 5.26315789, 5.73684211, 6.21052632,
6.68421053, 7.15789474, 7.63157895, 8.10526316,
8.57894737, 9.05263158, 9.52631579, 10. ])
"""
同样也能进行 reshape 工作:
a = np.linspace(1,10,20).reshape((5,4)) # 更改shape
"""
array([[ 1. , 1.47368421, 1.94736842, 2.42105263],
[ 2.89473684, 3.36842105, 3.84210526, 4.31578947],
[ 4.78947368, 5.26315789, 5.73684211, 6.21052632],
[ 6.68421053, 7.15789474, 7.63157895, 8.10526316],
[ 8.57894737, 9.05263158, 9.52631579, 10. ]])
"""
3、Numpy 基础运算
1、一维矩阵的运算
import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arange(4)
c = a+b
print(c)
c = a-b
print(c)
c = a*b # 矩阵对应元素相乘
print(c)
c = b**2
print(c)
c = np.sin(a)
print(c)
print(b == 1)
print(b<2)
2、多维矩阵的运算
import numpy as np
a = np.array([[1, 1], [0, 1]])
b = np.arange(4).reshape(2, 2)
# 矩阵对应元素相乘
c = a*b
print(c)
# 矩阵乘法运算的 两种表示方法
c = np.dot(a, b)
d = a.dot(b)
print(c)
print(d)
3、sum(), min(), max()
import numpy as np
a = np.random.random((2, 4))
print("a : ", a)
print("sum : ", np.sum(a))
print("min : ", np.min(a))
print("max : ", np.max(a))
# 如果需要对行或者列进行查找运算，就需要在上述代码中为 axis 进行赋值。
# 当axis的值为0的时候，将会以列作为查找单元， 当axis的值为1的时候，将会以行作为查找单元。
print("sum of line : ", np.sum(a, axis = 1))
print("min of line : ", a.min(axis = 1))
print("max of column : ", a.max(axis = 0))
运行结果：
a : [[0.80427549 0.62523633 0.46176439 0.82552158]
[0.11904194 0.6907302 0.61703396 0.53077328]]
sum : 4.674377171487079
min : 0.11904194483055897
max : 0.8255215828012922
sum of line : [2.71679779 1.95757938]
min of line : [0.46176439 0.11904194]
max of column : [0.80427549 0.6907302 0.61703396 0.82552158]
4、其他一些运算
import numpy as np
a = np.arange(2, 14).reshape((3, 4))
print(a)
# 求矩阵中最大元素和最小元素的索引
print(a.argmax())
print(np.argmin(a))
# 求矩阵的均值
print(a.mean())
print(np.average(a))
# 求矩阵的中位数
print(np.median(a))
# 生成的每一项矩阵元素均是从原矩阵首项累加到对应项的元素之和/乘积
print(np.cumsum(a))
print(np.cumprod(a))
# 累差运算函数：每一行中后一项与前一项之差.故一个3行4列矩阵通过函数计算得到的矩阵便是3行3列的矩阵。
print(np.diff(a))
#将所有非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵
print(np.nonzero(a))
# 仅针对每一行从小到大排序操作
b = np.arange(14, 2, -1).reshape((3, 4))
print(np.sort(b))
# 矩阵的两种转置方法
print(np.transpose(a))
print(a.T)
# 判断矩阵中元素是否有比最小值小的或者比最大值大的元素，并将这些指定的元素转换为最小值或者最大值
print(np.clip(a, 5, 9))
实际上每一个Numpy中大多数函数均具有很多变量可以操作，你可以指定行、列甚至某一范围中的元素。更多具体的使用细节请记得查阅Numpy中文文档。
4、Numpy 索引
import numpy as np
# 一维二维的示例，注意是 0 base
a = np.arange(3, 15)
print(a)
print(a[3])
a = a.reshape(3, 4)
print(a)
print(a[2])
print(a[2][2])
# 类似于 python 中 list 的切片操作，注意是 左闭右开
print(a[1][1:3])
print(a[1, 1:3])
# 逐行逐列打印
for row in a:
print(row)
for column in a.T:
print(column)
# flatten是一个展开性质的函数，将多维的矩阵进行展开成1行的数列。
# 而flat是一个迭代器，本身是一个object属性。
print(a.flatten())
for item in a.flat:
print(item)
5、Numpy Array 合并
a = np.array([1, 1, 1])
b = np.array([2, 2, 2])
# vertical stack : 上下合并，即对括号中的两个整体进行对应操作
c = np.vstack((a, b))
print(c)
print(a.shape, c.shape)
# horizontal stack :
d = np.hstack((a, b))
print(d)
print(a.shape, d.shape)
说完array的合并，稍稍提及一下前一节中转置操作，如果面对如同前文所述的a序列， 转置操作便很有可能无法对其进行转置（因为a并不是矩阵的属性），此时就需要我们借助其他的函数操作进行转置：
print(a[np.newaxis,:])
# [[1 1 1]]
print(a[np.newaxis,:].shape)
# (1,3)
print(a[:,np.newaxis])
"""
[[1]
[1]
[1]]
"""
print(a[:,np.newaxis].shape)
# (3,1)
a = np.array([1, 1, 1])
b = np.array([2, 2, 2])
c = a[:, np.newaxis]
d = b[:, np.newaxis]
print(np.vstack((c, d)))
print(np.hstack((c, d)))
当合并操作需要针对多个矩阵或序列时，借助concatenate函数可能使用起来比前述的函数更加方便。axis参数很好的控制了矩阵的纵向或是横向打印，相比较vstack和hstack函数显得更加方便。
a = np.array([1, 2, 3])[np.newaxis, :]
b = np.array([4, 5, 6])[np.newaxis, :]
c = np.concatenate((a, b), axis = 0)
print(c)
d = np.concatenate((a, b), axis = 1)
print(d)
6、Numpy Array 分割
import numpy as np
a = np.arange(12).reshape((3, 4))
print(a)
# 纵向分割
print(np.split(a, 2, axis = 1))
# 横向分割
print(np.split(a, 3, axis = 0))
# 错误的分割，split 只能等量分割
# print(np.split(a, 2, axis = 0))
# 不等量的分割，机器学习中常用
print(np.array_split(a, 2, axis = 0))
# 其他的分割方式
print(np.vsplit(a, 3)) # 横切
print(np.hsplit(a, 2 )) # 竖切
7、Numpy copy & deep copy
import numpy as np
# 引用性的 copy，有关联性
a = np.arange(4)
b = a
c = a
d = b
a[0] = 11
print(a)
print(b is a)
print(c is a)
print(d is a)
# 拷贝性的 copy，没有关联性
b = a.copy()
print(b)
a[3] = 44
print(b)
print(b is a)
三、Pandas 学习
1、Pandas基本介绍
如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的，没有数值标签，而 Pandas 就是字典形式。Pandas是基于Numpy构建的，让Numpy为中心的应用变得更加简单。
Series
Series的字符串表现形式为：索引在左边，值在右边。由于我们没有为数据指定索引。于是会自动创建一个0到N-1（N为长度）的整数型索引。
# 用列表形式创建 Series
import pandas as pd
import numpy as np
s = pd.Series([1,3,6,np.nan,44,1])
print(s)
"""
0 1.0
1 3.0
2 6.0
3 NaN
4 44.0
5 1.0
dtype: float64
"""
DataFrame
DataFrame是一个表格型的数据结构，它包含有一组有序的列，每列可以是不同的值类型（数值，字符串，布尔值等）。DataFrame既有行索引也有列索引， 它可以被看做由Series组成的大字典。
import pandas as pd
import numpy as np
dates = pd.date_range('20160101', periods = 6)
df = pd.DataFrame(np.random.randn(6, 4), index = dates, columns=['a','b','c','d'])
print(df)
print(df['b'])
创建一组没有给定行标签和列标签的数据：
df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
print(df1)
"""
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
"""
用字典形式创建，这种方法能对每一列的数据进行特殊对待：
df2 = pd.DataFrame({'A' : 1.,
'B' : pd.Timestamp('20130102'),
'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
'D' : np.array([3] * 4,dtype='int32'),
'E' : pd.Categorical(["test","train","test","train"]),
'F' : 'foo'})
print(df2)
"""
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo
"""
# 如果想要查看数据中的类型
print(df2.dtypes)
"""
df2.dtypes
A float64
B datetime64[ns]
C float32
D int32
E category
F object
dtype: object
"""
# 如果想看对列的序号:
print(df2.index)
"""
Int64Index([0, 1, 2, 3], dtype='int64')
"""
# 每种数据的名称也能看到:
print(df2.columns)
"""
Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
"""
# 如果只想看所有df2的值:
print(df2.values)
"""
array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']], dtype=object)
"""
# 想知道数据的总结, 可以用 describe():
df2.describe()
"""
A C D
count 4.0 4.0 4.0
mean 1.0 1.0 3.0
std 0.0 0.0 0.0
min 1.0 1.0 3.0
25% 1.0 1.0 3.0
50% 1.0 1.0 3.0
75% 1.0 1.0 3.0
max 1.0 1.0 3.0
"""
# 如果想翻转数据, transpose:
print(df2.T)
"""
0 ... 3
A 1 ... 1
B 2013-01-02 00:00:00 ... 2013-01-02 00:00:00
C 1 ... 1
D 3 ... 3
E test ... train
F foo ... foo
[6 rows x 4 columns]
"""
# 如果想对数据的 index 进行排序并输出:
print(df2.sort_index(axis=1, ascending=False))
"""
F E D C B A
0 foo test 3 1.0 2013-01-02 1.0
1 foo train 3 1.0 2013-01-02 1.0
2 foo test 3 1.0 2013-01-02 1.0
3 foo train 3 1.0 2013-01-02 1.0
"""
# 如果是对数据 值 排序输出:
print(df2.sort_values(by='B'))
"""
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo
"""
2、Pandas 选择数据
dates = pd.date_range('20130101', periods = 6)
df = pd.DataFrame(np.arange(24).reshape((6, 4)), index = dates, columns = ['A', 'B', 'C', 'D'])
print(df)
# 单列
print(df['A'])
print(df.A)
# 多行或多列
print(df[:3])
print(df['20130102':'20130104'])
可以使用标签来选择数据 loc, 本例主要通过标签名字选择某一行数据， 或者通过选择某行或者所有行（:代表所有行）然后选其中某一列或几列数据。
print(df.loc['20130102'])
"""
A 4
B 5
C 6
D 7
Name: 2013-01-02 00:00:00, dtype: int64
"""
print(df.loc[:,['A','B']])
"""
A B
2013-01-01 0 1
2013-01-02 4 5
2013-01-03 8 9
2013-01-04 12 13
2013-01-05 16 17
2013-01-06 20 21
"""
print(df.loc['20130102',['A','B']])
"""
A 4
B 5
Name: 2013-01-02 00:00:00, dtype: int64
"""
另外可以采用位置进行选择 iloc, 在这里可以通过位置选择在不同情况下所需要的数据例如选某一个，连续选或者跨行选等操作。
print(df.iloc[3,1])
# 13
print(df.iloc[3:5,1:3])
"""
B C
2013-01-04 13 14
2013-01-05 17 18
"""
print(df.iloc[[1,3,5],1:3])
"""
B C
2013-01-02 5 6
2013-01-04 13 14
2013-01-06 21 22
"""
当然也可以采用混合选择 ix, 其中选择’A’和’C’的两列，并选择前三行的数据。
print(df.ix[:3,['A','C']])
"""
A C
2013-01-01 0 2
2013-01-02 4 6
2013-01-03 8 10
"""
最后可以采用判断指令 (Boolean indexing) 进行选择. 我们可以约束某项条件然后选择出当前所有数据.
print(df[df.A>8])
"""
A B C D
2013-01-04 12 13 14 15
2013-01-05 16 17 18 19
2013-01-06 20 21 22 23
"""
3、Pandas 设置值
import pandas as pd
import numpy as np
dates = pd.date_range('20130101', periods = 6)
df = pd.DataFrame(np.arange(24).reshape((6, 4)), index = dates, columns = ['A', 'B', 'C', 'D'])
df.iloc[2, 2] = 1111
df.loc['20130101', 'B'] = 2222
print(df)
df.B[df.A > 4] = 0
print(df)
df['F'] = np.nan
print(df)
df['E'] = pd.Series([1, 2, 3, 4, 5, 6],index = pd.date_range('20130101', periods=6))
print(df)
4、Pandas 处理丢失数据
import numpy as np
import pandas as pd
dates = pd.date_range('20130101', periods = 6)
df = pd.DataFrame(np.arange(24).reshape((6, 4)), index = dates, columns = ['A', 'B', 'C', 'D'])
df.iloc[0, 1] = np.nan
df.iloc[1, 2] = np.nan
print(df)
# 直接去掉有 NaN 的行或列
df.dropna(
axis=0, # 0: 对行进行操作; 1: 对列进行操作
how='any' # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop
)
"""
A B C D
2013-01-03 8 9.0 10.0 11
2013-01-04 12 13.0 14.0 15
2013-01-05 16 17.0 18.0 19
2013-01-06 20 21.0 22.0 23
"""
# 用其他值代替 NaN
df.fillna(value = 0)
"""
A B C D
2013-01-01 0 NaN 2.0 3
2013-01-02 4 5.0 NaN 7
2013-01-03 8 9.0 10.0 11
2013-01-04 12 13.0 14.0 15
2013-01-05 16 17.0 18.0 19
2013-01-06 20 21.0 22.0 23
"""
# 判断是否有缺失数据 NaN，返回一个矩阵
print(df.isnull())
print(df.isna())
# 检测在数据中是否存在 NaN
print(np.any(df.isna()) == True)
print(df.isna().any().any())
5、Pandas 导入导出
pandas可以读取与存取的资料格式有很多种，像csv、excel、json、html与pickle等…， 详细请看官方说明文件
import pandas as pd #加载模块
#读取csv
data = pd.read_csv('student.csv')
#打印出data
print(data)
## 将资料存取成pickle
data.to_pickle('student.pickle')
6、Pandas 合并 concat
pandas处理多组数据的时候往往会要用到数据的合并处理,使用 concat是一种基本的合并方式.而且concat中有很多参数可以调整,合并成你想要的数据形式.
axis 确定合并方向
# 0 跨行，1 跨列
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])
#concat纵向合并
res = pd.concat([df1, df2, df3], axis=0)
#打印结果
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 0 1.0 1.0 1.0 1.0
# 1 1.0 1.0 1.0 1.0
# 2 1.0 1.0 1.0 1.0
# 0 2.0 2.0 2.0 2.0
# 1 2.0 2.0 2.0 2.0
# 2 2.0 2.0 2.0 2.0
ignore_index 重置index
#承上一个例子，并将index_ignore设定为True
res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)
#打印结果
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 3 1.0 1.0 1.0 1.0
# 4 1.0 1.0 1.0 1.0
# 5 1.0 1.0 1.0 1.0
# 6 2.0 2.0 2.0 2.0
# 7 2.0 2.0 2.0 2.0
# 8 2.0 2.0 2.0 2.0
join 决定合并方式，交集or并集
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
#纵向"外"合并df1与df2
res = pd.concat([df1, df2], axis=0, join='outer')
print(res)
# a b c d e
# 1 0.0 0.0 0.0 0.0 NaN
# 2 0.0 0.0 0.0 0.0 NaN
# 3 0.0 0.0 0.0 0.0 NaN
# 2 NaN 1.0 1.0 1.0 1.0
# 3 NaN 1.0 1.0 1.0 1.0
# 4 NaN 1.0 1.0 1.0 1.0
#纵向"内"合并df1与df2
res = pd.concat([df1, df2], axis=0, join='inner')
#打印结果
print(res)
# b c d
# 1 0.0 0.0 0.0
# 2 0.0 0.0 0.0
# 3 0.0 0.0 0.0
# 2 1.0 1.0 1.0
# 3 1.0 1.0 1.0
# 4 1.0 1.0 1.0
join_axes 依照axes合并
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
#依照`df1.index`进行横向合并
res = pd.concat([df1, df2], axis=1, join_axes=[df1.index])
#移除join_axes，并打印结果
res = pd.concat([df1, df2], axis=1)
print(res)
#依照`df1.columns`进行纵向合并
res = pd.concat([df1, df2], axis=0, join_axes=[df1.columns])
#移除join_axes，并打印结果
res = pd.concat([df1, df2], axis=0)
print(res)
append 添加数据，只能纵向，不能横向
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])
#将df2合并到df1的下面，以及重置index，并打印出结果
res = df1.append(df2, ignore_index=True)
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 3 1.0 1.0 1.0 1.0
# 4 1.0 1.0 1.0 1.0
# 5 1.0 1.0 1.0 1.0
#合并多个df，将df2与df3合并至df1的下面，以及重置index，并打印出结果
res = df1.append([df2, df3], ignore_index=True)
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 3 1.0 1.0 1.0 1.0
# 4 1.0 1.0 1.0 1.0
# 5 1.0 1.0 1.0 1.0
# 6 1.0 1.0 1.0 1.0
# 7 1.0 1.0 1.0 1.0
# 8 1.0 1.0 1.0 1.0
#合并series，将s1合并至df1，以及重置index，并打印出结果
res = df1.append(s1, ignore_index=True)
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 3 1.0 2.0 3.0 4.0
7、Pandas 合并 merge
pandas中的merge和concat类似,但主要是用于两组有key column的数据,统一索引的数据. 通常也被用在Database的处理当中.
依据一组 key 合并
import pandas as pd
#定义资料集并打印出
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']})
print(left)
print(right)
#依据key column合并，并打印出
res = pd.merge(left, right, on='key')
print(res)
依据两组 key 合并
合并时有4种方法how = ['left', 'right', 'outer', 'inner']，预设值how='inner'
import pandas as pd
#定义资料集并打印出
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']})
print(left)
print(right)
#依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print(res)
res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
print(res)
res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print(res)
res = pd.merge(left, right, on=['key1', 'key2'], how='right')
print(res)
indicator 为True时会把合并的记录放在新的一列
import pandas as pd
#定义资料集并打印出
df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})
print(df1)
print(df2)
# 依据col1进行合并，并启用indicator=True，最后打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
print(res)
# 自定indicator column的名称，并打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
print(res)
依据 index 合并
import pandas as pd
#定义资料集并打印出
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
'D': ['D0', 'D2', 'D3']},
index=['K0', 'K2', 'K3'])
print(left)
print(right)
#依据左右资料集的index进行合并，how='outer',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)
#依据左右资料集的index进行合并，how='inner',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
print(res)
解决 overlapping
import pandas as pd
#定义资料集
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
#使用suffixes解决overlapping的问题
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
print(res)
网友评论