【莫烦】Numpy & Pandas

最新推荐文章于 2024-10-29 11:52:49 发布

原创最新推荐文章于 2024-10-29 11:52:49 发布 · 328 阅读

2 ·

CC 4.0 BY-SA版权

学习笔记专栏收录该内容

16 篇文章

订阅专栏

本文深入探讨了Numpy和Pandas在数据处理和分析中的应用，包括矩阵创建、基础运算、索引选取、数据合并及图表绘制等关键功能，通过实例展示了如何高效地操作数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Numpy

创建矩阵

import numpy as np
# np为numpy常见简写
# np为基于矩阵的运算模块

#把列表转换为矩阵的方法
array = np.array([[1,2,3],
                  [2,3,4]])
print(array)
# 维数
print('number of dim:',array.ndim)
# 行列数
print('shape:',array.shape)
# 一共多少元素
print('size:',array.size)

""""""""""创建矩阵或数组"""""""""
## dtype 定义整数或小数 int/float默认int64/float64 也可以设置为32/16 位数越小占用的内存/空间越小
## 矩阵被两个[]包裹 列表中的列表
a = np.array([2,23,4],dtype=np.int32)
## 全0矩阵
b = np.zeros((3,4))
print('zero:\n',b)
## 全1矩阵
c = np.ones((3,4),dtype=np.int16)
print('one:\n',c)
## 接近0的矩阵
d = np.empty((3,4),dtype=np.float32)
print('empty:\n',d)
## 生成有序的矩阵
e = np.arange(start=8,stop=31,step=2)
print('range:\n',e)
##重新定义行列数
e = e.reshape((3,4))
print('reshape:\n',e)
## 线段
### num:将[star,stop]分成num个数，生成步长
f = np.linspace(start=1,stop=10,num=5)
print('linspace:\n',f)

## 随机[0,1]生成的矩阵
g = np.random.random((2,4))
print('random:\n',g)

基础运算

import numpy as np

"""""""""基础运算"""""""""
a = np.array([10,20,30,40])
b = np.arange(4)

# 对应元素相减/平方/函数运算
c = a-b
d = b**2
e = 10*np.sin(a)
print('minutes：\n','a:\n',a,'\nb:\n',b,'\nc=a-b:\n',c)
print('square:\n','d=b^2:\n',d)
print('function:\n','e=10*sin(a):\n',e)

# 判断矩阵中 >/</= 某个值的元素个数
a = np.array([[1,1],[0,1]])
b = b.reshape((2,2))
print('a:\n',a,'\nb:\n',b)
#print('b:\n',b,'\nb<3逻辑判断:\n',b<3)

# 矩阵逐个对应相乘
c = a*b
print('c=a*b\n',c)
# 矩阵乘法
c_dot = np.dot(a,b)
##等价于
c_dot_2 = a.dot(b)
print('c_dot:\n',c_dot)
print('c_dot_2:\n',c_dot_2)

#输出求和\最大值\最小值
## 随机[0,1]生成的矩阵
g = np.random.random((2,4))
print('random:\n',g)
print('所有元素的和：',np.sum(g))
print('按列求和：',np.sum(g,axis=0))
print('按行求和：',np.sum(g,1))
print('矩阵最大值',np.max(g))
print('矩阵按行最大值',np.max(g,axis=1))
print('矩阵最小值',np.min(g))

A = np.arange(2,14).reshape(3,4)
print(A)
#最大/小值的索引
print('最大值索引：',np.argmax(A))
#所有元素的均值
print('所有元素的均值：\nnp.mean:',np.mean(A),'\nA.mean:',A.mean(),'\nnp.average',np.average(A))
#中位数
print('所有元素的中位数：\nnp.median:',np.median(A))
#累加和
print('累加：\nA:\n',A,'\n','np.cumsum',np.cumsum(A))
#逐行每两个数的差
print('两数的差：\nA:\n',A,'\n','np.diff\n',np.diff(A))
#非零的数的行号列号
print('非零',a,'\n',np.nonzero(a))
# 逐行排序
print('sort\ng：\n',g,'\nnp.sort(g):\n',np.sort(g))
# 转置
print('转置：\ng:\n',g,'\nnp.transpose:\n',np.transpose(g),'\ng.T\n',g.T)
# np.clip(a,a_min,a_max) 矩阵中>a_max的赋值为a_max,<a_min的赋值为a_min,∈[a_min,a_max]的保留
print(np.clip(g,0.2,0.6))
# aixs=0 对列计算 aix=1 对行计算

索引

import numpy笔记 as np

A = np.arange(3,15).reshape((3,4))
print('A:\n',A)
print('A的第二行\nA[1]:\n',A[1],'\nA[1,:]\n',A[1,:])
print('A的第一列\nA[:,0]\n',A[:,0])
print('A的第二行第一列：\n','A[1][0]:\n',A[1][0],'\nA[1,0]：\n',A[1,0])
print('A[1,1:3]:\n',A[1,1:3])
#按行逐行
for row in A:
    print(row)
#按列迭代
for column in A.T:
    print(column)

#逐个元素迭代
##按行拉直 返回迭代器：A.flat 返回拉直后的行：A.flatten()
for item in A.flat:
    print(item)

行列处理

import numpy笔记 as np

"""""""""""数组的合并"""""""""""
A = np.array([1,1,1])
B = np.array([2,2,2])

print('A:',A,'\nB：',B)
print('按行上下合并:\n',np.vstack((A,B))) # vertical stack
print('按列左右合并:\n',np.hstack((A,B))) # horizontal stack

#按列合并
## 把数组变换为n行一列的矩阵
print('reshape:\n',A.reshape(A.size,1))
###加一个维度，原本为(3,) A[np.newaxis,:]后变为(1,3) A[:,np.newaxis]变为(3,1)
print('A:',A.shape,'\nA[np.newaxis,:]:',A[np.newaxis,:].shape,'\nA[:,np.newaxis]',A[:,np.newaxis].shape)
print('newaxis',A[:,np.newaxis])
print('按列合并:\n',np.hstack((A[:,np.newaxis],B[:,np.newaxis])))

#多个数组的合并
print('stack:\n',np.vstack((A,B,A,B)))
print('concatenate:\n',np.concatenate((A[:,np.newaxis],B[:,np.newaxis],A[:,np.newaxis],B[:,np.newaxis]),axis=1))

"""""""""""数组的分割"""""""""""
#均分
C = np.arange(12).reshape((3,4))
print('C:\n',C)
## indices or sections:平均分成多少片段 axis:分割方向
print('纵向均分成2块',np.split(C,2,1))
print('纵向均分成2块',np.hsplit(C,2))
print('横向均分成3块',np.vsplit(C,3))
#不等分
##indices or sections:可以为不均分的整数 或者为元组或列表 列表[i,j]表示在第i列/行和第j列/行前面切一刀
print('横向不等的分成(1,2,1)3块:\n',np.array_split(C,[1,3],1))
""""""""""""""""""""""""""""""""

复制

import numpy as np
a = np.arange(4)
#浅拷贝 一模一样的东西
print(a)
b = a
c = b
#深copy 只要值而不关联
d = a.copy() #deep copy
a[0]=11
#判断是不是一模一样的东西
print('b is a:',b is a)
print('c is a:',c is a)
print('d is a:',d is a)
print('a:',a,'\nb:',b,'\nc:',c,'\nd:',d)

Pandas

选择数据

一. 行，列 --> df[]
二. 区域 --> df.loc[], df.iloc[], df.ix[]
三. 单元格 --> df.at[], df.iat[]
参考

行，列

说明：当未设置行列名时，标签索引跟数字索引无明显区别，设置行列名后只支持标签索引的函数无法进行数字索引。

1. df[]:

一维
行维度： 整数切片、标签切片、<布尔数组>
列维度： 标签索引、标签列表、Callable

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.randn(6,4), index=list('abcdef'), columns=list('ABCD'))
 # 前三行（布尔数组长度等于行数）
df[:3]
df['a':'c']
df[[True,True,True,False,False,False]]

df[df['A']>0] # A列值大于0的行
df[(df['A']>0) | (df['B']>0)] # A列值大于0，或者B列大于0的行
df[(df['A']>0) & (df['C']>0)] # A列值大于0，并且C列大于0的行
 
df['A']
df[['A','B']]
df[lambda df: df.columns[0]] # Callable

区域

2. df.loc[]

select by label 纯标签筛选
二维，先行后列
行维度： 标签索引、标签切片、标签列表、<布尔数组>、Callable
列维度： 标签索引、标签切片、标签列表、<布尔数组>、Callable
深绿为与df[]区别处

df.loc['a', :]
df.loc['a':'d', :]
df.loc[['a','b','c'], :]
df.loc[[True,True,True,False,False,False], :] # 前三行（布尔数组长度等于行数）
df.loc[df['A']>0, :]
df.loc[df.loc[:,'A']>0, :]
df.loc[df.iloc[:,0]>0, :]
df.loc[lambda _df: _df.A > 0, :]

df.loc[:, 'A']
df.loc[:, 'A':'C']
df.loc[:, ['A','B','C']]
df.loc[:, [True,True,True,False]] # 前三列（布尔数组长度等于行数）
df.loc[:, df.loc['a']>0]          # a行大于0的列
df.loc[:, df.iloc[0]>0]           # 0行大于0的列
df.loc[:, lambda _df: ['A', 'B']]

df.A.loc[lambda s: s > 0]

3. df.iloc[]

select by position 纯数字筛选
二维，先行后列
行维度： 整数索引、整数切片、整数列表、<布尔数组>
列维度： 整数索引、整数切片、整数列表、<布尔数组>、Callable

df.iloc[3, :]
df.iloc[:3, :]
df.iloc[[0,2,4], :]
df.iloc[[True,True,True,False,False,False], :] # 前三行（布尔数组长度等于行数）
df.iloc[df['A']>0, :]       #× 为什么不行呢？想不通！
df.iloc[df.loc[:,'A']>0, :] #×
df.iloc[df.iloc[:,0]>0, :]  #×
df.iloc[lambda _df: [0, 1], :]

df.iloc[:, 1]
df.iloc[:, 0:3]
df.iloc[:, [0,1,2]]
df.iloc[:, [True,True,True,False]] # 前三列（布尔数组长度等于行数）
df.iloc[:, df.loc['a']>0] #×
df.iloc[:, df.iloc[0]>0]  #×
df.iloc[:, lambda _df: [0, 1]]

4. df.ix[]

mixed selection 标签、数字混合筛选
二维，先行后列
行维度： 整数索引、整数切片、整数列表、标签索引、标签切片、标签列表、<布尔数组>、Callable
**列维度：**整数索引、整数切片、整数列表、标签索引、标签切片、标签列表、<布尔数组>、Callable

df.ix[0, :]
df.ix[0:3, :]
df.ix[[0,1,2], :]

df.ix['a', :]
df.ix['a':'d', :]
df.ix[['a','b','c'], :]


df.ix[:, 0]
df.ix[:, 0:3]
df.ix[:, [0,1,2]]

df.ix[:, 'A']
df.ix[:, 'A':'C']
df.ix[:, ['A','B','C']]

单元格

5. df.at[]

精确定位单元格
**行维度：**标签索引
**列维度：**标签索引

df.at['a', 'A']

6. df.iat[]

精确定位单元格

行维度： 整数索引
列维度: 整数索引

df.iat[0, 0]

重新赋值

单元格/区域/按条件赋同一值

单元格索引后可以直接赋值

df.ix[2,2] = 1234
df[df.A>3] = 0 #筛选行的所有列
df.A[df.A>3] = 0 #只改一列

按行或列

新添一列，且值为NaN

df['F'] = np.nan

添加序列
用上面的方法也可以加上 Series 序列（但是长度必须对齐，若已经声名行名，则新增也需声名）。

df['E'] = pd.Series([1,2,3,4,5,6],index=['a','b','c','d','f','e'])
"""
         A         B         C         D  E
a -0.013245 -0.019354  0.244709  0.092578  1
b  0.803507 -0.235273 -1.020049  1.507931  2
c  0.581436 -0.035007  0.657033 -0.470292  3
d  0.668195 -0.345460  1.412867 -1.960768  4
e -2.631842  1.203515  0.804148  1.753115  6
f -2.362749 -0.667286 -1.215777 -0.084359  5
"""

缺失值处理

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
"""
             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 的行或列

pd.dropna()

df.dropna(
    axis=0,     # 0: 对行进行操作; 1: 对列进行操作
    how='any'   # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop 
    )

用其他值代替NaN

pd.fillna()

df.fillna(value=0)

判断是否有缺失数据

pd.isnull() 为 True 表示缺失数据:

df.isnull() 
"""
                A      B      C      D
2013-01-01  False   True  False  False
2013-01-02  False  False   True  False
2013-01-03  False  False  False  False
2013-01-04  False  False  False  False
2013-01-05  False  False  False  False
2013-01-06  False  False  False  False
"""
检测在数据中是否存在 NaN, 如果存在就返回 True:
```py
np.any(df.isnull()) == True  
# True

导入导出数据

官方文档

读取CSV

import pandas as pd #加载模块

#读取csv
data = pd.read_csv('student.csv')

#打印出data
print(data)

存成pickle

data.to_pickle('student.pickle')

合并数据

concat

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

仔细观察会发现结果的index是0, 1, 2, 0, 1, 2, 0, 1, 2，若要将index重置，请看例子二。

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

结果的index变0, 1, 2, 3, 4, 5, 6, 7, 8。

join (合并方式)

join=‘outer’

join='outer’为预设值，因此未设定任何参数时，函数默认join=‘outer’。此方式是依照column来做纵向合并，有相同的column上下合并在一起，其他独自的column个自成列，原本没有值的位置皆以NaN填充。(外连接要求column的值也相同，此处不需要)

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

join=‘inner’

原理同上个例子的说明，但只有相同的column合并在一起，其他的会被抛弃。

#承上一个例子

#纵向"内"合并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

#重置index并打印结果
res = pd.concat([df1, df2], axis=0, join='inner', ignore_index=True)
print(res)
#     b    c    d
# 0  0.0  0.0  0.0
# 1  0.0  0.0  0.0
# 2  0.0  0.0  0.0
# 3  1.0  1.0  1.0
# 4  1.0  1.0  1.0
# 5  1.0  1.0  1.0

join_axes (依照 axes 合并)

没有设定join_axes时行列号会结合两组数据的情况取并集，当设定了，就只以取设定的集合

#定义资料集
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])

#打印结果
print(res)
#     a    b    c    d    b    c    d    e
# 1  0.0  0.0  0.0  0.0  NaN  NaN  NaN  NaN
# 2  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
# 3  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0

#移除join_axes，并打印结果
res = pd.concat([df1, df2], axis=1)
print(res)
#     a    b    c    d    b    c    d    e
# 1  0.0  0.0  0.0  0.0  NaN  NaN  NaN  NaN
# 2  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
# 3  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
# 4  NaN  NaN  NaN  NaN  1.0  1.0  1.0  1.0

append (添加数据)

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

merge （相当于SQL的join）

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)
#    A   B key
# 0  A0  B0  K0
# 1  A1  B1  K1
# 2  A2  B2  K2
# 3  A3  B3  K3

print(right)
#    C   D key
# 0  C0  D0  K0
# 1  C1  D1  K1
# 2  C2  D2  K2
# 3  C3  D3  K3

#依据key column合并，并打印出
res = pd.merge(left, right, on='key')

print(res)
     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

how(连接方式)

依据两组key合并
合并时有4种方法how = [‘left’, ‘right’, ‘outer’, ‘inner’]，预设值how=‘inner’。相当于SQL的左连接、右连接、内连接、外连接

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)
#    A   B key1 key2
# 0  A0  B0   K0   K0
# 1  A1  B1   K0   K1
# 2  A2  B2   K1   K0
# 3  A3  B3   K2   K1

print(right)
#    C   D key1 key2
# 0  C0  D0   K0   K0
# 1  C1  D1   K1   K0
# 2  C2  D2   K1   K0
# 3  C3  D3   K2   K0

#依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print(res)
#    A   B key1 key2   C   D
# 0  A0  B0   K0   K0  C0  D0
# 1  A2  B2   K1   K0  C1  D1
# 2  A2  B2   K1   K0  C2  D2

res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
print(res)
#     A    B key1 key2    C    D
# 0   A0   B0   K0   K0   C0   D0
# 1   A1   B1   K0   K1  NaN  NaN
# 2   A2   B2   K1   K0   C1   D1
# 3   A2   B2   K1   K0   C2   D2
# 4   A3   B3   K2   K1  NaN  NaN
# 5  NaN  NaN   K2   K0   C3   D3

res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print(res)
#    A   B key1 key2    C    D
# 0  A0  B0   K0   K0   C0   D0
# 1  A1  B1   K0   K1  NaN  NaN
# 2  A2  B2   K1   K0   C1   D1
# 3  A2  B2   K1   K0   C2   D2
# 4  A3  B3   K2   K1  NaN  NaN

res = pd.merge(left, right, on=['key1', 'key2'], how='right')
print(res)
#     A    B key1 key2   C   D
# 0   A0   B0   K0   K0  C0  D0
# 1   A2   B2   K1   K0  C1  D1
# 2   A2   B2   K1   K0  C2  D2
# 3  NaN  NaN   K2   K0  C3  D3

Indicator

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)
#   col1 col_left
# 0     0        a
# 1     1        b

print(df2)
#   col1  col_right
# 0     1          2
# 1     2          2
# 2     2          2

# 依据col1进行合并，并启用indicator=True，最后打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
print(res)
#   col1 col_left  col_right      _merge
# 0   0.0        a        NaN   left_only
# 1   1.0        b        2.0        both
# 2   2.0      NaN        2.0  right_only
# 3   2.0      NaN        2.0  right_only

# 自定indicator column的名称，并打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
print(res)
#   col1 col_left  col_right indicator_column
# 0   0.0        a        NaN        left_only
# 1   1.0        b        2.0             both
# 2   2.0      NaN        2.0       right_only
# 3   2.0      NaN        2.0       right_only

依据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)
#     A   B
# K0  A0  B0
# K1  A1  B1
# K2  A2  B2

print(right)
#     C   D
# K0  C0  D0
# K2  C2  D2
# K3  C3  D3

#依据左右资料集的index进行合并，how='outer',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)
#      A    B    C    D
# K0   A0   B0   C0   D0
# K1   A1   B1  NaN  NaN
# K2   A2   B2   C2   D2
# K3  NaN  NaN   C3   D3

#等价于
result = left.join(right, how='outer')

#依据左右资料集的index进行合并，how='inner',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
print(res)
#     A   B   C   D
# K0  A0  B0  C0  D0
# K2  A2  B2  C2  D2

#等价于
 result = left.join(right, how='inner')

给原来名字一样的列合并后加上尾缀

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)
#    age_boy   k  age_girl
# 0        1  K0         4
# 1        1  K0         5

#自动命名
res = pd.merge(boys,girls,on='k')
print(res)
#     k  age_x  age_y
# 0  K0      1      4
# 1  K0      1      5

Pandas plot 出图

折线图

创建一个Series。这是一个线性的数据，我们随机生成1000个数据，Series 默认的 index 就是从0开始的整数，但是这里我显式赋值以便让大家看的更清楚。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 随机生成1000个数据
data = pd.Series(np.random.randn(1000),index=np.arange(1000))
 
# 为了方便观看效果, 我们累加这个数据
#data = data.cumsum()

# pandas 数据可以直接观看其可视化形式
data.plot()

plt.show()

就这么简单，熟悉 matplotlib 的朋友知道如果需要plot一个数据，我们可以使用 plt.plot(x=, y=)，把x,y的数据作为参数存进去，但是data本来就是一个数据，所以我们可以直接plot。生成的结果就是下图：
在这里插入图片描述

Dataframe 可视化

我们生成一个1000*4 的DataFrame，并对他们累加

data = pd.DataFrame(
    np.random.randn(1000,4),
    index=np.arange(1000),
    columns=list("ABCD")
    )
data = data.cumsum()
data.plot()
plt.show()

Pandas plot 出图

这个就是我们刚刚生成的4个column的数据，因为有4组数据，所以4组数据会分别plot出来。plot 可以指定很多参数，具体的用法大家可以自己查一下这里

scatter 散点图

除了plot，我经常会用到还有scatter，这个会显示散点图，首先给大家说一下在 pandas 中有多少种方法

bar 条形图
hist 柱状图
box 箱线图
kde
area
scatter 散点图
hexbin
但是我们今天不会一一介绍，主要说一下 plot 和 scatter. 因为scatter只有x，y两个属性，我们我们就可以分别给x, y指定数据

ax = data.plot.scatter(x='A',y='B',color='DarkBlue',label='Class1')

然后我们在可以再画一个在同一个ax上面，选择不一样的数据列，不同的 color 和 label

# 将之下这个 data 画在上一个 ax 上面
data.plot.scatter(x='A',y='C',color='LightGreen',label='Class2',ax=ax)
plt.show()

下面就是我plot出来的图片

在这里插入图片描述
这就是我们今天讲的两种呈现方式，一种是线性的方式，一种是散点图

提升Numpy的效率

https://morvanzhou.github.io/tutorials/data-manipulation/np-pd/4-1-speed-up-numpy/