人工智能学习

预备知识

人工智能：- 机器学习、深度学习、有监督学习、无监督学习、半监督学习（有交互的无监督学习）、强化学习

回归任务的本质是拟合；

分类任务的本质是找到分界；

聚类任务的本质是分组、归堆；

降维任务的本质是去掉数据冗余；

Conda虚拟环境

搭建虚拟环境

第一步：创建虚拟环境

打开Anaconda Powershell Prompt 通过输入conda create --name xxxx python==3.10 来创建虚拟环境

第二步：切换进入虚拟环境

输入conda env list罗列出所有已有的环境

输入conda activate xxx来进入虚拟环境

输入conda list查看当前环境中安装过的所有程序

输入pip list可以查看当前环境中所有的python模块

安装Python模块

使用pip install xxx

配置镜像

进入~目录创建pip文件夹

在pip文件夹内创建pip.ini文件

使用记事本打开并输入以下内容

[global]
;清华镜像源
index_url = https://pypi.tuna.tsinghua.edu.cn/simple
;豆瓣 http://pypi.douban.com/simple/
;阿里云 http://mirrors.aliyun.com/pypi/simple
[install]
trusted-host = pypi.tuna.tsinghua.edu.cn
;豆瓣 pypi.douban.com
;阿里云 mirrors.aliyun.com

linux配置镜像是修改~/.pip/pip.conf

安装模块

pip install xxx==xxx会安装相关依赖模块

卸载模块

pip uninstall xxxx只卸载指定模块

使用conda install

配置镜像

编辑~/.condarc

channels:
  - defaults
show_channel_urls: true
default_channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud

安装模块

conda install xxx==xxx会安装依赖模块

卸载模块

conda uninstall xxxx会卸载当前模块包括依赖模块

关联运行环境

Jupyter

进入虚拟环境pip install ipykernel

回到base环境将环境写入kernel

python -m ipykernel install --user --name 环境名称 --display-name 需要显示的环境名称

输入jupyter notebook启动或者选择更改使用指定环境

删除kernel环境jupyter kernelspec remove 环境名称

Python 语言的了解

python语言是强类型动态语言，原因不允许不同类型相加，不使用显示数据类型声明，在确定一个变量的类型是在给它赋值的时候

os模块

os.system("")直接调用系统命令;

os.startfile(r"文件路径")直接调用可执行文件；

os.getcwd()获取当前的工作目录；

os.chdir()改变当前工作目录;

os.mkdir()用于创建目录，不能用于创建多级目录

os.path.exists()用于判定是否存在指定目录

os.listdir()罗列文件夹里的文件

shutil模块

shutil模块主要用于文件的shutil.copy(src,dst):file shutil.copytree(src,dst):folder拷贝，shutil.move(src,dst)移动，shutil.rmtree(src):remove folder删除，zipfile.ZipFile(r"我创建的压缩包.zip", "w") as zipobj zipobj.write():create a zip file,zipobj.namelist():read the zip file and list it,zipobj.extract():压缩和解压zipfile

文件操作

readline方法每次读出一行读出时占用内存小，适合大文件。

readlines方法读取整个文件的所有行并存入列表，占用内存较多。

函数式编程

• map将传入函数依次作用到序列的每个元素，并把结果作为新的list返回

• reduce 使用from functools import reduce 接收两个参数第一个参数函数，第二个参数一个序列，reduce会将函数的第一份结果继续和序列的下一个元素进行累计计算。

  reduce(f,[x1,x2,x3])=f(f(x1,x2)x3)
  

• filter函数用于过滤序列，也接收一个函数和一个序列并把函数作用于序列的每个元素，并根据返回值为True还是False决定保留还是丢弃该元素。

• sorted比较序列的各元素大小并依次默认升序排序，可以添加key参数进行自定义排序，使用reserve进行逆序。

• lambda arg1,arg2...:<表达式>声明匿名函数 arg1..argn为函数的参数,表达式为函数体。

闭包

函数嵌套定义，调用外部函数时返回内部函数名作为返回结果，该过程称为函数闭包。

def func_out(num1):
	def func_in(num2):
		return num1+num2
    return func_in
f=func_out(10)
result=f(20)# result = 10 + 20

装饰器decorator

装饰器就是一种闭包，本质上就是一个返回函数的高阶函数。可以用来实现日志等功能…

def log(func):
	def wrapper():
		print("starting...")
		func()
		print("execute ended")
	return wrapper
	
@log
def func1():
	print("executing...")
	
func() 
'''
starting...
executing...
execute ended
'''

class类中内置方法

类

可以通过issubclass(sub,sup)判断sub是否是sup的继承,super可以调用父类的属性方法，python支持多继承和多重继承，使用mro()方法或者__mro__进行输出类的继承层次结构.

科学计数Numpy

numpy array和arange

使用numpy.shape查看数据维度

numpy.array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)返回类型ndarray. dtype指定数据类型，copy对象是否需要复制，order创建数组的样式C为行方向，F为列方向A为默认方向，ndmin指定生成数组的最小维度数。

生成随机数

注：np为numpy

np.random.random(size=None)该方法返回[0.0..1.0]范围的随机数。

np.random.seed()确定生成随机生成器的种子。

np.random.permutation()返回一个序列的随机排列或返回一个随机排列的范围

np.random.shuffle(arrayobj)对一个序列就地随机排列

np.random.rand()产生均匀分布的样本值

np.random.randint()该方法含有三个参数low,high,size默认high是None,如果只有low则范围就是[0,low).如果有high则为[low,high).

np.random.randn(d0,d1,d2..dn):randn函数返回一个或者一组样本，具有标准正态分布,dn表格每个维度,返回值为指定维度的array

np.random.normal(loc=,scale= ,size=()):正态分布,loc期望,scale:方差，size:形状。

ndaray对象

ndarray.ndim：秩，即轴的数量或者维度的数量

ndarray.shape：数组的维度，对于矩阵，n行m列

ndarray.size数组元素的总个数，相当于.shape中的n*m

ndarray.dtypendarray对象的元素类型

ndarray.itemsize：ndarray对象中每个元素的大小

ndarray.flags：ndarray的内存信息

ndarray.real：ndarray元素的实部

ndarray.imag：ndarray元素的虚部

ndarray.data：包含实际数组元素的缓冲区，由于一般通过数组索引获取元素，一般情况下不使用该属性。

np.zeros(shape,dtype=float,order='C')创建指定大小的以0填充的数组。类似的还有np.ones()纯1数组，np.empty()未初始化数组

np.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)：等差数列数组，start序列起始值，stop序列终止值，若endpoint为True则包含在序列中，num生成样本数量，默认50,endpoint序列是否包含stop值，retstep生成数据组会显示间距，反之不显示,dtype ndarray的数据类型。

np.logspace(0,9,10,base=2)以2为底从0到9之间取十个数的log值

np.zeros_like(ndarray_object)、np.ones_like()\np.empty_like()\np.equal\np.exp(2):$e^2$

ndarray_object.reshape()改变ndarray object的形状

改变数组的维度：

ndarray_object.revel()将三维数组降低为一维数组

ndarray_object.flatten()将二维数组降低为一维数组

数组拼接

np.hstack([a,b])实现二维数组a,b的水平拼接

np.vstack([a,b])实现二维数组a,b的垂直拼接

np.concatenate((a1,a2..),axis)沿着指定数轴进行连接形状相同的两个或者多个数组,axis指定数轴，默认为0.

数组分割

np.split(array,indices_or_sections,axis) array为被分割的数组,indices_or_sections切分位点，如果是一个整数，就用该数平均切分，即切为平均几份，如果是序列则是指定切分的位置，axis为切分的维度方向

水平切分hsplit()

垂直切分vsplit()

ndarray.transpose():ndarray进行二维转置

np.transpose(array,[1,2,3,0]):将形状为1334转置为3341

运算

如果参与运算的两个对象都是ndarray并且形状相同，那么会对位彼此之间进行(+ - * /)运算,Numpy算数函数包括简单的加减乘除add(),subtract(),multiply(),divide()

数学函数标准三角函数sin(),cos(),tan(),np.pi

np.around(a,decimals)返回指定数字的四舍五入值

decimals舍入的小数位，默认值为0,如果为负数，则舍入到小数点左侧

np.floor()返回数字的下舍整数

np.ceil()返回数字的上入整数

聚合函数

函数名	说明
np.sum()	求和
np.prod()	所有元素相乘
np.mean()	平均值
np.std()	标准差
np.var()	方差
np.median()	中数
np.power()	幂运算
np.sqrt()	开方
np.min()	最小值
np.max()	最大值
np.argmin()	最小值的下标
np.argmax()	最大值的下标
np.inf	无穷大
np.exp(10)	以e为底的指数
np.log(10)	对数

可视化绘图Matplotlib

import matplotlib.pyplot as plt

绘制基础

pylot的基本方法

方法名	说明
title()	设置图表的名称
xlabel()	设置x轴的名称
ylabel()	设置y轴的名称
xticks(x,ticks,rotation)	设置x轴的刻度,rotation旋转角度
yticks()	设置y轴的刻度
plot()	绘制线性图表
show()	显示图表
legend()	显示图例
text()	显示每条数据的值，x，y值的位置
figure(name,figsize=(w,h),dpi=n)	设置图片大小
savefig()	保存图片

plt.plot([0,2],[1,4]) #将(0,1)点和(2,4)点连接绘制一条直线

x=[..]
squares=[..]
plt.plot(x,squares) # 绘制一条折线

datas=[..]
squares=[..]
plt.plot(data,squares,linewidth=5)# 设置线条宽度为5
plt.title("Numbers",fontsize=24)# 设置图表的标题和字体大小
plt.xlabel("datas",fontsize=14) # 设置图表的x轴和字体大小
plt.ylabel("squares",fontsize=14)# 设置图表的y轴和字体大小
plt.show()

Matplotlib中文支持解决办法

plt.rcParams['font.sans-serif']=['SimHei']

绘制正余弦函数图像

x=np.linespace(0,10,100)
# 正弦曲线
sin_y=np.sin(x)
plt.plot(x,sin_y)
# 余弦曲线
cos_y=np.cos(x)
plt.plot(x,cos_y)
plt.show()

# 正弦散点图
plt.scatter(x,sin_y)
plt.show()


# 画10种大小,100种颜色的散点图
np.random.seed(0)
x=np.random.rand(100)
y=np.random.rand(100)
colors=np.random.rand(100)
size=np.random.rand(10)*1000
plt.scatter(x,y,c=colors,s=size,alpha=0.7)
plt.show()

plt.plot(x,y,'x',label='x') # x和y x形标记(默认格式化字符参见表3)+颜色(参见表4)  x图例
plt.legend(loc='lower right',fancybox=True ,framealpha=1,shadow=True,borderpad=1)
# 添加图例的位置 边框 透明度 阴影 边框宽度

zlib :758191532

字符	描述
-	实线样式
--	短横线样式
-.	点画线样式
:	虚线样式
.	点标记
,	像素标记
o	圆标记
v	倒三角标记
^	正三角标记
<	左三角标记
>	右三角标记
1	下箭头标记
2	上箭头标记
3	左箭头标记
4	右箭头标记
s	正方形标记
p	五边形标记
*	星形标记
h	六边形标记1
H	六边形标记2
+	加号标记
x	X标记
D	菱形标记
d	窄菱形标记
|	竖直线标记
_	水平线标记

字符	颜色
‘b’	蓝色
‘g’	绿色
‘r’	红色
‘c’	青色
‘m’	品红色
‘y’	黄色
‘k’	黑色
‘w’	白色

Matplotlib学习笔记（配置项，格式化字符，颜色，作图）

绘制柱形图

柱状图主要用于作横向对比和纵向对比

# bar绘制

plt.bar(x,y,width=3) # 设置柱形图并设置宽度为3

plt.rcParams['font.sans-serif']=['SimHei']
plt.xticks(x,x_labels) # 设置x轴的刻度
plt.xLabel()
plt.ylabel()
plt.title()
plt.show()

# barh绘制，并使用subplot进行画布规划

plt.subplot(1,2,1) # 将画布分割成一行两列，并指定第一列进行作图
v_bar=plt.bar(x,y)
plt.axhline(0,color="blue",linewidth=2)# 在第一幅画布中0的位置画一条蓝线
plt.subplot(1,2,2) # 将画布分割成一行两列，并指定第二列进行作图
h_bar=plt.barh(x,y,color='red') # barh将y和x轴对换，竖向为x轴
plt.axvline(0,color='red',linewidth=2)# 在第二列画布中0位置处画红色的线
plt.show()

# 柱状图设置颜色
v_bar=plt.bar(x,y,color='lightblue')
for bar,height in zip(v_bar,y):
    if height<0:
        bar.set(edgecolor='darkred',color='lightgreen',linewidth=3)
plt.show()


# plt.bar(x,y,color='b',width=width,label=label)

绘制饼状图

饼状图主要用于呈现比例

patches,texts,autotexts=plt.pie([比例列表..],labels=labels,colors=colors,explode=(0,0.5),autopct='%0.1f%%')
# labels 名称 colors 颜色 explode 分裂 autopct 显示百分比

#设置饼状图字体颜色
for text in autotexts:
    text.set_color('white')
    
# 设置字体大小
for text in texts+autotexts:
    text.set_fontsize(20)
    

绘制直方图

直方图主要用于观察数据分布，并不关心某一具体值

# 正太分布
x=np.random.randn(1000)
# 绘制正太分布图
plt.hist(x,bins=100) # 装箱操作，分成100个箱子，将每十个柱体装为一起,修改柱宽

# plt.hist(x,bins=100,alpha=0.4) bins：装箱 alpha：透明度
np.random.normal(0,0.8,1000) # 第一个参数为期望，第二个为均值

绘制等高线图

横坐标x和纵坐标y经过meshgrid(x,y)后返回了所有直线相交的网络坐标点的横坐标xx和纵坐标yy,xx数组和yy数组对应位置组成网络格点的坐标（1,2）（2,2）（3,2）（1,3）（2,3）等等

注意：meshgrid返回的xx和yy数组的大小总是一致的

meshgrid用于将数据网格化

contour用于绘制等高线边界处的轮廓线,而contourf会对两个相邻的轮廓线之间的登高区域进行颜色填充。

X,Y=np.meshgrid(x,y)

plt.contourf(X,Y,Z)# 登高区域填充涂色 越靠近边缘颜色越浅
plt.contour(X,Y,Z) # 等高线上色

绘制三维图像

from mpl_toolkits.mplot3d import Axes3D

# 创建X,Y,Z
X=[..]
Y=[..]
Z=[..]
fig=plt.figure()
# 创建一个Axes3D的子图放到figure画布里面
ax = Axes3D(fig)
ax.plot_trisurf(X,Y,Z)

Pandas数据分析库

pandas是基于Numpy的一套数据分析工具。提供了大量能使我们快速便捷地处理数据的函数和方法。

import pandas as pd

Pandas数据类型

pandas中两个重要的数据类型:Series和DataFrame。Series是数据列表——一维，DataFrame表示二维数据集。

Series

使用列表创建Series对象

data = pd.Series([..])

series对象包装的是一维数组，实际上是将一个列表和索引进行绑定，该对象有两个重要属性values和index

data.values,data.index

使用字典创建Series对象，默认将key作为index,若key不存在则值为NaN

dict_obj={'key':'value'}
series=pd.Series(dict_obj)
series

sub_series=pd.Series(dict_object,index=[..])# 如果index中的值在dict_obj里面则取该值，如果index里的值不在dict_obj里面则对应的该项为NaN

使用标量和index创建Series

data=pd.Series(10,index=[..])
"""
0	10
1	10
2	10
"""

DataFrame

将两个series作为字典的值创建DataFrame

population={"":""}
area={"":""}
population_series=pd.Series(population)
area_series=pd.Series(area)
city=pd.DataFrame("area":area_series,"population":population_series)

DataFrame的属性：values,index,columns

使用列表创建DataFrame则key为表头

population={"":""}
area={"":""}
city=pd.DataFrame([area,population],index=['area','population'],columns=[..]) # index和columns为可选参数，可以指定index属性和columns

使用二维数组并指定columns和index

pd.DataFrane(2darray,index=[..],columns=[..])

获取Series对象的值

Series对象的切片索引

data=pd.Series([..],index=[..])
# 根据key获取
display(data[key])
# 通过key切片获取
display(data[key1:key2])
# 通过index获取
display(data[0])
# 通过index切片:左闭右开
display(data[1:4])

位置索引与标签索引相同的问题,loc是标签索引，iloc是位置索引

data=pd.Series([..],index=[..])
data.loc[key]
data.iloc[index]

获取DataFrame的值

DataFrame对象后指明列名,如果只需要获取一列只需要传入一个列名，如果是选择多列，则使用列表传入列名。

data=pd.DataFrame(data,index=[..],columns=[..])
data[key] # key是
data[[key..]]

DataFrame对象获取列，除了传入具体列名，还可以传入具体列的位置，使用iloc方法根据位置获取数据。

data.iloc[:,0] # 单列
data.iloc[:,[1,2]] # 多个列
data.iloc[:,1:2] # 切片

连续某几列进行切片

data.loc[:,'key1':'key2']
data.iloc[:,1:4]

选择某一行或者某几行，使用普通索引或者位置索引

data.loc[key] # 获取key行，普通索引获取
data.iloc[0]  # 获取第一行 位置索引获取
data.loc[[key..]] # 获取key1,key2..对应的普通索引
data.loc[key1:key2] # 获取key1到key2的连续行
data.iloc[[0,1]]	# 获取第1行和第2行 位置索引
data.iloc[1:4]	# 获取第二行到第五行之间的数据 位置索引

行列同时选择，进行部分区域选择

data.loc['key1':'key2','Key1':'Key2'] # 同时获取key1到key2行，Key1到Key2列 普通索引

data.iloc[0:4,0:4] # 同时获取第1到第4行 第1到第5列 位置索引

同时选择不连续区域

data.loc[[key1,key2..],[Key1,Key2..]]

data.iloc[[index1,index2..],[Index1,Index2..]]

Series方法

使用mean、min、max、std等方法对数据集进行运算，并对数据集进行排序操作

mean对一列数据取平均值,min取最小值,max获取最大值,std获取标准差.

data=pd.DataFrame({
    'Name':['zs','lisi','ww'],
    'Sno':['1001','1002','1003'],
    'Sex':['man','woman','man'],
    'Age':[17,18,19],
    'Score':[80,75,94]
},columns=['Sno','Sex','Age','Score'],index=['zs','lisi','ww'])
display('数据集',data)
ages=data['Age']
display('获取数据集中Age列的所有',ages)
print('age的平均值',ages.mean())
print('age的最大值',ages.max())
print('age的最小值',ages.min())
print('age的标准差',ages.std())
display('对age进行降序排序:',ages.sort_values(ascending=False))

条件过滤

scores=data['Score']
display('筛选出成绩大于平均值的数据:',scores[scores>scores.mean()])

DataFrame方法

条件过滤

data=pd.DataFrame({
    'Name':['zs','lisi','ww'],
    'Sno':['1001','1002','1003'],
    'Sex':['man','woman','man'],
    'Age':[17,18,19],
    'Score':[80,75,94]
},columns=['Sno','Sex','Age','Score'],index=['zs','lisi','ww'])
scores=data['Score']
display('获取成绩中大于平均值值的所有记录，只显示Sno、Age、Score:',data[scores>score.mean()].loc[:,['Sno','Age','Score']])

ages=data['Age']
dispaly(data[(scores>scores.mean()) | (ages<19)])
dispaly(data[(scores>scores.mean()) & (ages<19)])

缺失值处理

缺省值是由于某些原因导致部分数据为空，对于为空的部分数据，一种是删除：把含有缺失值的数据删除，另一种是填充：把缺失值通过某个值进行代替。

缺失值查看

使用info()方法进行调用，就会返回每一列的缺失情况。

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,4,9]])
df.info()
"""

RangeIndex: 3 entries, 0 to 2   //一共3行
Data columns (total 3 columns): //一共3列
0	3 non-null int64            //无缺省值
1	2 non-null float64		   // 有2个非空值
2	2 non-null float64		   // 有2个非空值
dtypes:float64(2), int64(1)
memory usage:152.0 bytes
"""

可以用isnull()方法判断哪个值是缺失值，如果是缺失值则返回True，如果不是缺失值则返回False

获取所有缺失值

data=pd.DataFrame([3,4,np.nan,1,5,None])
# 使用isnull()方法判断是否是缺失值
print(data.isnull())
"""
0	False
1	False
2	True
3	False
4	False
5	True
dtype:bool
"""
# 获取空值
print(data[data.isnull()])
"""
2	NaN
5 	NaN
dtype:float64
"""
# 获取非空值
print(data[data.notnull()])
"""
0	3
1	4
3	1
4	5
"""

缺失值删除

两种缺失值类型，一整行缺失，单个字段缺失，调用dropna()方法删除缺省值，默认删除含有缺省值的行，如果需要按列删除则需要传入参数axis='columns'.如果只想删除空白行则需要dropna传入参数how='all',默认值是how='any'。

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,4,9]])
# 默认以行为单位进行剔除
display(df.dropna())
# 以列为单位进行剔除
display(df.dropna(axis='columns'))
# 所有值为nan时才进行删除
display(df.dropna(how='all'))
# 只要为nan时就进行删除
display(df.dropna(how='any'))

缺失值填充

数据是宝贵的，一般情况下数据缺失比例不高的话（不大于30%）尽量选择填充.使用fillna()方法对数据表中的所有缺失值进行填充，在fillna()方法中输入要填充的值，或者使用method参数使用前一个数和后一个数字进行填充。

Series对象缺失值填充。

data=pd.Series([3,4,np.nan,1,5,None])
# 以0进行填充
display(data.fillna(0))
# 以前一个数进行填充
display(data.fillna(method='ffill'))
# 以最后一个数进行填充
display(data.fillna(method='bfill'))
# 先按照前一个数字进行填充，然后按照后一个进行填充
display(data.fillna(method='ffill').fillna(method='bfill'))

DataFrame对象缺失值填充。

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,6,7]])
# 使用0进行填充
display(df.fillna(0))
# 使用行的前一个数进行填充
display(df.fillna(method='ffill'))
# 使用列的后一个数进行填充
display(df.fillna(method='bfill',axis=1))

列的平均值进行填充

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,6,7]])
for i in df.columns:
    df[i]=df[i].fillna(np.nanmean(df[i]))
display(df)

拼接

Series对象拼接

ser1=pd.Series([1,2,3],index=['A','B','C'])
ser2=pd.Series([4,5,6],index=['D','E','F'])
pd.concat([ser1,ser2])

DataFrame对象拼接

def make_df(cols,index):
    data={c:[str(c)+str(i) for i in index] for c in cols}
    return pd.DataFrame(data,index=index)

df1=make_df('AB',[1,2])
df2=make_df('AB',[3,4])
display(df1,df2)
"""
 	A 	B
1 	A1 	B1
2 	A2 	B2
	A 	B
3 	A3 	B3
4 	A4 	B4
"""
pd.concat([df1,df2])
"""
 	A 	B
1 	A1 	B1
2 	A2 	B2
3 	A3 	B3
4 	A4 	B4
"""
pd.concat([df1,df2],axis=1) # pd.concat([df1,df2],axis='columns')
"""
 	A 	B 	A 	B
1 	A1 	B1 	NaN NaN
2 	A2 	B2 	NaN NaN
3 	NaN NaN A3 	B3
4 	NaN NaN A4 	B4
"""

df1=make_df('AB',[1,2])
df2=make_df('AB',[1,2])
display(df1,df2)
"""
 	A 	B
1 	A1 	B1
2 	A2 	B2
	A 	B
1 	A1 	B1
2 	A2 	B2
"""
pd.concat([df1,df2])
"""
 	A 	B
1 	A1 	B1
2 	A2 	B2
1 	A1 	B1
2 	A2 	B2
"""
pd.concat([df1,df2],ignore_index=True) # 忽略原有索引，进行索引重排
"""
 	A 	B
0 	A1 	B1
1 	A2 	B2
2 	A1 	B1
3 	A2 	B2
"""
pd.concat([df1,df2],keys=['x','y']) #将dataframe按照keys进行归类
"""
 		A 	B
x 	1 	A1 	B1
	2 	A2 	B2
y 	1 	A1 	B1
	2 	A2 	B2
"""
df1=make_df('ABC',[1,2])
df2=make_df('ABC',[3,4])
display(df1,df2)
"""
	A 	B 	C
1 	A1 	B1 	C1
2 	A2 	B2 	C2
	A 	B 	C
3 	A3 	B3 	C3
4 	A4 	B4 	C4
"""

merge方法

merge用于两组有key和columns数据合并，统一索引数据。合并方式有4种how=['left','right','outer','inner']默认是how='inner'

left=pd.DataFrame({
    'key':['k0','k1','k2','k3'],
    'A':['A0','A1','A2','A3'],
    'B':['B0','B1','B2','B3']
})
right=pd.DataFrame({
    'key':['k0','k1','k4','k3'],
    'C':['C0','C1','C2','C3'],
    'D':['D0','D1','D2','D3']
})
result = pd.merge(left,right) # 按照相同列(key)取交集，然后合并
display(result)
"""

	key A 	B 	C 	D
0 	k0 	A0 	B0 	C0 	D0
1 	k1 	A1 	B1 	C1 	D1
2 	k3 	A3 	B3 	C3 	D3
"""
result = pd.merge(left,right, how='outer') # 按照相同列(key)取并集，然后合并
display(result)
"""
 	key A 	B 	C 	D
0 	k0 	A0 	B0 	C0 	D0
1 	k1 	A1 	B1 	C1 	D1
2 	k2 	A2 	B2 	NaN NaN
3 	k3 	A3 	B3 	C3 	D3
4 	k4 	NaN NaN C2 	D2
"""
result = pd.merge(left,right, how='left') # 依照左边为参考进行合并
display(result)
"""
 	key A 	B 	C 	D
0 	k0 	A0 	B0 	C0 	D0
1 	k1 	A1 	B1 	C1 	D1
2 	k2 	A2 	B2 	NaN NaN
3 	k3 	A3 	B3 	C3 	D3
"""
result = pd.merge(left,right, how='right') # 依照右边为参考进行合并
display(result)
"""
 	key A 	B 	C 	D
0 	k0 	A0 	B0 	C0 	D0
1 	k1 	A1 	B1 	C1 	D1
2 	k4 	NaN NaN C2 	D2
3 	k3 	A3 	B3 	C3 	D3
"""