Numpy基础核心内容

首先导入库

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.gridspec as mg
from mpl_toolkits.mplot3d import axes3d
import matplotlib.animation as ma
%matplotlib inline

np.array()数组存储详解：

引入概念：数组的存储

因为1个字节8bit，所以两个int8等于int16

num1 = np.array([0x1234],dtype=('>u2',#类型1:无符号整形,因为是uint16给与两个字节,'>':大端字节序，低数位高地址{'lo':('u1',0),'hi':('u1',1)}#自定义的类型(必须添加偏移量:单位(字节,8bit)
))
#dtype接收元组类型时，可以把单个数组以多个类型来标识print('{:x}'.format(num1[0]))#16进制
print("当自定义类型前面是>号时")
print('{:x}  {:x}'.format(num1['lo'][0],num1['hi'][0]))
#因为自定义类型是把整体与数值相互绑定，都是整体，所以索引时必须索引完整
print("当自定义类型前面是<号时")num1 = np.array([0x1234],dtype=('<u2',#类型1:无符号整形,因为是uint16给与两个字节,'<':小端字节序，地数位低地址{'lo':('u1',0),'hi':('u1',1)}#自定义的类型(必须添加偏移量:单位(字节,8bit)
))
print('{:x}  {:x}'.format(num1['lo'][0],num1['hi'][0]))

1234
当自定义类型前面是>号时
12  34
当自定义类型前面是<号时
34  12

Numpy切片：

特殊索引值:
’ . . . ’ , ’ : ’ , ’ : : '

一维数组：

a = np.arange(1,10)
print(a[::])
print(a[...])#可以输出，但不会被jupyter(ipython)识别
print(a[:])
#print(a[])，不能这样写不然解释器报错

[1 2 3 4 5 6 7 8 9]
[1 2 3 4 5 6 7 8 9]
[1 2 3 4 5 6 7 8 9]

多维数组：

b = np.arange(1,25).reshape(2,3,4)
print(b,'\n')
print('特殊索引后：\n',b[0, ...])
print('\n',b[:,:,1])#行优先print("结果不一样")
print(b[... , 1])#结果不一样，前面的特殊索引代表前面的所有维度都是默认值
print('-----------')
print(b[: , 1])#第一个 : 代表第一维度，第二个代表第二维度，没有第三个

[[[ 1  2  3  4][ 5  6  7  8][ 9 10 11 12]][[13 14 15 16][17 18 19 20][21 22 23 24]]] 特殊索引后：[[ 1  2  3  4][ 5  6  7  8][ 9 10 11 12]][[ 2  6 10][14 18 22]]
结果不一样
[[ 2  6 10][14 18 22]]
-----------
[[ 5  6  7  8][17 18 19 20]]

改变维度：

视图变维:
针对一个数组对象获取器不同维度的视图(原数组不变)

num1 = np.arange(24).reshape(2,3,4)#数组.reshape(新维度) -> 数组的新维度视图
print('维度改变后：\n',num1.reshape(3,2,4),'\n但原始数组没有改变')
print(num1)print("-----------")
#数组.ravel() -> 数组的一维视图
print('返回一维视图\n',num1.ravel())

维度改变后：[[[ 0  1  2  3][ 4  5  6  7]][[ 8  9 10 11][12 13 14 15]][[16 17 18 19][20 21 22 23]]]
但原始数组没有改变
[[[ 0  1  2  3][ 4  5  6  7][ 8  9 10 11]][[12 13 14 15][16 17 18 19][20 21 22 23]]]
-----------
返回一维视图[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

复制变维:
针对一个数组兑现获取其不同的维度副本

因为numpy的数组他的属性和值是不会放在一起的，所以变换了维度只是先创建了一个新的内存单元，然后指针指向源数据

num2 = np.arange(1,9)
#数组.flattern() -> 数组的一维副本(所以指针不会指向源数据，所以如果源数据有改动也不会与他有任何关系)
#数组.copy()  也是新的开辟新的内存单元，源数据不会受影响print("原数组：\n",num2)print("原数组加上10\n")
num2 += 10A = num2.reshape(2,4)
print("指针指向的是同一个内存，所以会改变\n",A)
B = num2.reshape(2,2,2).copy
print("\n因为是拷贝的，所以不会改变\n",B)
C = num2.flatten()
print("\n因为是副本所以不会改变\n",C)

原数组：[1 2 3 4 5 6 7 8]
原数组加上10指针指向的是同一个内存，所以会改变[[11 12 13 14][15 16 17 18]]因为是拷贝的，所以不会改变<built-in method copy of numpy.ndarray object at 0x000001D62C4A60D0>因为是副本所以不会改变[11 12 13 14 15 16 17 18]

就地变维:
直接修改数组属性

num3 = np.arange(1,9)#数组.shape = (新维度)
print('原数组：\n',num3)
num3.shape = (2,2,2)
print("\n改变后：\n",num3)#数组.resize(新维度)
num3.resize(2,4)
print("\n改变后\n",num3)

原数组：[1 2 3 4 5 6 7 8]改变后：[[[1 2][3 4]][[5 6][7 8]]]改变后[[1 2 3 4][5 6 7 8]]

视图转置:
要想实现转置，数组至少是二维数组
所以可以人为加维度：np.array([数组])

num4 = np.arange(1,9).reshape(2,4)
#数组.transpose() -> 数组的转置视图
A = num4.transpose()
print("转置后\n",A,"\n与reshape排列方式不同")#数组.T -> 转置视图的属性
A = num4.T
print("\n运行效果是一样的:\n",A)

转置后[[1 5][2 6][3 7][4 8]]
与reshape排列方式不同运行效果是一样的:[[1 5][2 6][3 7][4 8]]

数组.reshape():当他是一维数组时，不用特定的方法转置的话，就可以.reshape(-1,1)，因为-1是一个不存在的维度，系统就直接默认所有(不能填 : 因为一维数组转成二维是没有真正的多维度的)

组合与拆分

垂直组合/拆分
np.vstack((上,下))
np.vsplit((数组,份数)) -> 元组(子数组的集合)

#需要使用的变量
a = np.arange(11,20).reshape(3,3)
print("a原数组值:\n",a)
b = np.arange(21,30).reshape(3,3)
print("\nb原数组值:\n",b)

a原数组值:[[11 12 13][14 15 16][17 18 19]]b原数组值:[[21 22 23][24 25 26][27 28 29]]

#垂直组合
c = np.vstack((a,b))#把a放在b的上面并生成一个新的数组
print("vstack生成过后的数组:\n",c)#垂直拆分
a,b = np.vsplit(c,2)
print("拆分后结果相同:\n",'a:\n',a,'\nb:\n',b)

vstack生成过后的数组:[[11 12 13][14 15 16][17 18 19][21 22 23][24 25 26][27 28 29]]
拆分后结果相同:a:[[11 12 13][14 15 16][17 18 19]]
b:[[21 22 23][24 25 26][27 28 29]]

水平组合/拆分
np.hstack((左,右))
np.hsplit((数组,份数)) -> 元组(子数组的集合)

#水平组合
c = np.hstack((a,b))#把a放在b的左边并生成一个新的数组
print("hstack生成过后的数组:\n",c)#水平拆分
a,b = np.hsplit(c,2)
print("拆分后结果相同:\n",'a:\n',a,'\nb:\n',b)

hstack生成过后的数组:[[11 12 13 21 22 23][14 15 16 24 25 26][17 18 19 27 28 29]]
拆分后结果相同:a:[[11 12 13][14 15 16][17 18 19]]
b:[[21 22 23][24 25 26][27 28 29]]

深度组合/拆分

np.dstack((前,后))
np.dsplit((数组,份数)) -> 元组(子数组的集合)

#深度组合
c = np.dstack((a,b))
print("深度组合:\n",c,"\n")
#假设a，b是两个卡片，然后a在b前面从平面穿过一条线将a,b穿透,在线上的数值就被拿出来做成数组的低维度#深度拆分
c1 = np.dsplit(c,2)
print("深度拆分:\n",c1)#不会被差分成原来的维度
a,b = np.dsplit(c,2)
print("\n还原维度：\n", a.T[0].T ,'\n\n', b.T[0].T)

深度组合:[[[11 21][12 22][13 23]][[14 24][15 25][16 26]][[17 27][18 28][19 29]]] 深度拆分:[array([[[11],[12],[13]],[[14],[15],[16]],[[17],[18],[19]]]), array([[[21],[22],[23]],[[24],[25],[26]],[[27],[28],[29]]])]还原维度：[[11 12 13][14 15 16][17 18 19]] [[21 22 23][24 25 26][27 28 29]]

行列组合/拆分

组合:
np.row_stack((上,下))
np.column_stack((左,右))

拆分:
np.row_split((数组,份数)) -> 元组(子数组的集合)
np.column_split((数组,份数)) -> 元组(子数组的集合)

a = a.ravel()
b = b.ravel()
print('原数组:\na:\n',a,'\nb:\n',b)

原数组:
a:[11 12 13 14 15 16 17 18 19]
b:[21 22 23 24 25 26 27 28 29]

#行列组合
#行列拆分

Ndarray类的属性

dtype - 元素类型
shape - 数组维度
T - 转置视图
ndim - 维数
size - 元素数
itemsize - 元素的字节数
nbytes - 总字节数 = size * itemsize
flat - 扁平迭代器
real - 实部数组
imag - 虚部数组

#属性
#flat扁平迭代器  相当于一维数组
num5 = np.array([[1+9j,2+8j,3+7j],[4+6j,5+5j,6+4j],[7+3j,8+2j,9+1j]])
print("原数组:\n",num5)print("\n扁平化后会变成地址指针：\n",num5.flat)
print("\n直接遍历后相当于一维数组，更节省内存空间")
for i in num5.flat:print(i)#因为相当于一维数组，所有肯定是可以被索引的
print("\n索引后的结果：\n",num5.flat[[2,4,6]])#其他属性
print("dtype: \n",num5.dtype,num5.dtype.str,num5.dtype.char)
print("real/imag: \n",num5.real,num5.imag,sep='\n')

原数组:[[1.+9.j 2.+8.j 3.+7.j][4.+6.j 5.+5.j 6.+4.j][7.+3.j 8.+2.j 9.+1.j]]扁平化后会变成地址指针：<numpy.flatiter object at 0x000001D61A377C30>直接遍历后相当于一维数组，更节省内存空间
(1+9j)
(2+8j)
(3+7j)
(4+6j)
(5+5j)
(6+4j)
(7+3j)
(8+2j)
(9+1j)索引后的结果：[3.+7.j 5.+5.j 7.+3.j]
dtype: complex128 <c16 D
real/imag: [[1. 2. 3.][4. 5. 6.][7. 8. 9.]]
[[9. 8. 7.][6. 5. 4.][3. 2. 1.]]

数组.tolist() - 列表对象

def fun(a,b):a.append(b)return a#数组.tolist()
x = np.array([10,20,30])
y = 40
#x = fun(x,y)  #会直接报错，因为ndarray没有append
x = fun(x.tolist(),y)
print("增加后的值：\n",x)#这是list#其他追加方式
x = np.append(x,50)#他是一个函数，所以要把返回值赋值给变量
print("\n增加后的值：\n",x)

增加后的值：[10, 20, 30, 40]增加后的值：[10 20 30 40 50]

数据可视化

matplotlib绘图

mp.plot(x数组,y数组,linestyle=线型,linewidth=线宽,color=颜色

#np.linspace
'''在指定的间隔内返回均匀间隔的数字;返回num均匀间隔的样本, 在[start，stop]区间内计算;可以选择排除间隔的终点.
'''x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)plt.plot(x,cos_y)
plt.plot(x,sin_y)

[<matplotlib.lines.Line2D at 0x1d62c52cee0>]

显示范围设置：
plt.xlim(左边界,右边界)
plt.ylim(顶边界,底边界)

x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)plt.xlim(x.min(),x.max())
plt.ylim(sin_y.min(),sin_y.max())plt.plot(x,cos_y)
plt.plot(x,sin_y)

[<matplotlib.lines.Line2D at 0x1d62e62be20>]

显示刻度设置：
plt.xticks(刻度位置数组,刻度文本数组)
plt.yticks(刻度位置数组,刻度文本数组)

tips: matplotlib有自己特殊的标记符，都是用$$括起来,字符串前要加个r(取消转义)

x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)plt.yticks([-0.75,0.25,0.5], ['A','B','C'])
plt.xticks([-np.pi , -np.pi/2, 0 , np.pi*3/4 , np.pi],[r'$-\pi$','$- \frac{\pi}{2}$',r'$0$',r'$\frac{\pi}{2}$',r'$\frac{3\pi}{4}$'])
plt.plot(x,cos_y)
plt.plot(x,sin_y)#\frac{}{}  第一个{}是分子，第二个{}是分母

[<matplotlib.lines.Line2D at 0x1d62e6c6440>]

平面直角坐标系画法：
ax = plt.gac - 获取当前坐标轴
ax.spines[‘边框’].set_position((‘data’,0))
ax.spines[‘边框’].set_color(‘颜色’)
ax的属性有spines,这是一个字典,可以set_position设置位置,参数在’data’数据层的0点

x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)plt.yticks([-0.75,0.25,0.5], ['A','B','C'])
plt.xticks([-np.pi , -np.pi/2, 0 , np.pi*3/4 , np.pi],[r'$-\pi$','$- \frac{\pi}{2}$',r'$0$',r'$\frac{\pi}{2}$',r'$\frac{3\pi}{4}$'])ax = plt.gca()
ax.spines['left'].set_position(('data',0))
ax.spines['bottom'].set_position(('data',0))
ax.spines['right'].set_color('none')#设置无色
ax.spines['top'].set_color('none')#设置无色plt.plot(x,cos_y)
plt.plot(x,sin_y)

[<matplotlib.lines.Line2D at 0x1d62e811bd0>]

图例：
plt.plot(…,label=图例文本)
plt.legend(loc=‘位置’) #best比较常用

x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)#轴设置
plt.yticks([-0.75,0.25,0.5], ['A','B','C'])
plt.xticks([-np.pi , -np.pi/2, 0 , np.pi*3/4 , np.pi],[r'$-\pi$','$- \frac{\pi}{2}$',r'$0$',r'$\frac{\pi}{2}$',r'$\frac{3\pi}{4}$'])#边框设置
ax = plt.gca()
ax.spines['left'].set_position(('data',0))
ax.spines['bottom'].set_position(('data',0))
ax.spines['right'].set_color('none')#设置无色
ax.spines['top'].set_color('none')#设置无色#图例
plt.plot(x,cos_y,label=r'$y=\frac{1}{2}cos(x)$')
plt.plot(x,sin_y,label=r'$y=sin(x)$')
plt.legend(loc='best')
#label与legend搭配使用

<matplotlib.legend.Legend at 0x1d62e870b80>

散点图:
也可以拿来在图中绘制标点
plt.scatter([x,x],[y,y],marker=点型,s=大小,edgecolor=勾边色,facecolor=填充色,zorder=Z序(绘制顺序))
#Z序：越靠0的越先画

x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)#轴设置
plt.yticks([-0.75,0.25,0.5], ['A','B','C'])
plt.xticks([-np.pi , -np.pi/2, 0 , np.pi*3/4 , np.pi],[r'$-\pi$','$- \frac{\pi}{2}$',r'$0$',r'$\frac{\pi}{2}$',r'$\frac{3\pi}{4}$'])#绘制点
xo = np.pi * 3/4
yo_cos = np.cos(xo) / 2
yo_sin = np.sin(xo)
plt.scatter([xo,xo],[yo_sin,yo_cos],s=60,edgecolor='green',facecolor='white',zorder=2)
#zorder：因为有两条线，所以要在第2层就可以让线穿透
#一条标记线
plt.plot([xo,xo],[yo_sin,yo_cos],'--',linewidth=1,color='blue')#边框设置
ax = plt.gca()
ax.spines['left'].set_position(('data',0))
ax.spines['bottom'].set_position(('data',0))
ax.spines['right'].set_color('none')#设置无色
ax.spines['top'].set_color('none')#设置无色#图例
plt.plot(x,cos_y,label=r'$y=\frac{1}{2}cos(x)$')
plt.plot(x,sin_y,label=r'$y=sin(x)$')
plt.legend(loc='best')

<matplotlib.legend.Legend at 0x1d62e7ffa00>

添加备注:
plt.annotate(备注文本,xy=备注位置,xycoords=目标坐标系,xytext=文本位置,textcoords=文本坐标系,fontsize=字体大小,arrowprops=箭头属性)

x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)#轴设置
plt.yticks([-0.75,0.25,0.5], ['A','B','C'])
plt.xticks([-np.pi , -np.pi/2, 0 , np.pi*3/4 , np.pi],[r'$-\pi$','$- \frac{\pi}{2}$',r'$0$',r'$\frac{\pi}{2}$',r'$\frac{3\pi}{4}$'])#绘制点
xo = np.pi * 3/4
yo_cos = np.cos(xo) / 2
yo_sin = np.sin(xo)
plt.scatter([xo,xo],[yo_sin,yo_cos],s=60,edgecolor='green',facecolor='white',zorder=2)
#zorder：因为有两条线，所以要在第2层就可以让线穿透
#一条标记线
plt.plot([xo,xo],[yo_sin,yo_cos],'--',linewidth=1,color='blue')#边框设置
ax = plt.gca()
ax.spines['left'].set_position(('data',0))
ax.spines['bottom'].set_position(('data',0))
ax.spines['right'].set_color('none')#设置无色
ax.spines['top'].set_color('none')#设置无色#图例
plt.plot(x,cos_y,label=r'$y=\frac{1}{2}cos(x)$')
plt.plot(x,sin_y,label=r'$y=sin(x)$')
plt.legend(loc='best')#备注
plt.annotate(r'$\frac{1}{2}cos(\frac{3\pi}{4})=-\frac{\sqrt{2}}{4}$',xy=(xo,yo_cos),xycoords='data',xytext=(-90,-40),textcoords="offset points",fontsize=14,arrowprops=dict(arrowstyle='->',connectionstyle='arc3,rad=.2 '))plt.annotate(r'$sin(\frac{3\pi}{4})=-\frac{\sqrt{2}}{2}$',xy=(xo,yo_sin),xycoords='data',xytext=(20,20),textcoords="offset points",fontsize=14,arrowprops=dict(arrowstyle='->',connectionstyle='arc3,rad=.2 '))

Text(20, 20, '$sin(\\frac{3\\pi}{4})=-\\frac{\\sqrt{2}}{2}$')

备注参数详解：
plt.annotate(r’ 1 2 c o s ( 3 π 4 ) = − 2 4 \frac{1}{2}cos(\frac{3\pi}{4})=-\frac{\sqrt{2}}{4} 21cos(43π)=−42 ’
,xy=(xo,yo_cos) #备注的位置
,xycoords=‘data’ #备注目标的坐标系
,xytext=(-90,-40) #以文本为中心添加偏移量(x,y)
,textcoords=“offset points” #文本与对应数据的位置(偏移点)
,fontsize=14 #字体大小
,arrowprops=dict(arrowstyle=’->’ #箭头风格
,connectionstyle='arc3,rad=.2 ')) #arc3:是连接类型(圆弧线连接)因为有圆弧线，那就必须要有半径,rad=.2

图形对象

plt.figure(图形对像名(相当于文件名),figsize=窗口大小,dpi=分辨率,facecolor=颜色)

#设置默认中文格式
matplotlib.rcParams['font.family']='STSong'
matplotlib.rcParams['font.size']=20x = np.linspace(-np.pi,np.pi,1000)
cos_y = np.cos(x) / 2
sin_y = np.sin(x)plt.figure('Figure Object 1',figsize=(4,3),dpi=120,facecolor='lightgray')
plt.title('Figure Object',fontsize=16)#正标题
plt.xlabel('这是x轴标签',fontsize=12)
plt.ylabel('这是y轴标签',fontsize=12)plt.tick_params(labelsize=10)#设置刻度字体大小
plt.grid(linestyle=':')#设置网格

plt.figure()与plt.show()之间的语句就会画在前面调的figure上面，如果想在其他的figure中间画上另外一个figure，就直接再调用一次只加图像名称不加参数

子图：
1.缺省布局
plt.subplot(行,列,图号)#中间逗号可以省略

plt.figure(facecolor='lightgray')
for i in range(2):for j in range(3):k = i*3+j+1        plt.subplot(2,3,k)plt.xticks(())plt.yticks(())plt.text(0.5,0.5,str(k),ha='center',va='center',size=36,alpha=0.5)#添加文本
plt.tight_layout()#紧凑布局

2.栅格布局
import matplotlib.gridspec as mg
gs = mg.GridSpec(行数,列数) #栅格布局器
plt.subplot(gs[行,列])

plt.figure(facecolor='lightgray')
gs = mg.GridSpec(3,3)#相当于创建一个3x3的表格(与二维数组类似)
#绘图区域1
plt.subplot(gs[0,:2])
plt.xticks(())#取消刻度
plt.yticks(())
plt.text(0.5,0.5,1,ha='center',va='center',size=36,alpha=0.5)
plt.tight_layout()#绘图区域2
plt.subplot(gs[1:,0])
plt.xticks(())
plt.yticks(())
plt.text(0.5,0.5,2,ha='center',va='center',size=36,alpha=0.5)
plt.tight_layout()#绘图区域3
plt.subplot(gs[2,1:])
plt.xticks(())
plt.yticks(())
plt.text(0.5,0.5,3,ha='center',va='center',size=36,alpha=0.5)
plt.tight_layout()#绘图区域4
plt.subplot(gs[:2,2])
plt.xticks(())
plt.yticks(())
plt.text(0.5,0.5,4,ha='center',va='center',size=36,alpha=0.5)
plt.tight_layout()#绘图区域5
plt.subplot(gs[1,1])
plt.xticks(())
plt.yticks(())
plt.text(0.5,0.5,5,ha='center',va='center',size=36,alpha=0.5)
plt.tight_layout()

3.自由布局
plt.axes([左下角水平坐标,左下角垂直坐标,宽度,高度])
其中所有的尺寸参数都是相对比例

plt.figure(facecolor='lightgray')
plt.axes([0.03#画布左右离边框的距离,0.038#画布上下离边框,0.94#单位1减去画布左右的距离,剩下的作为宽度,0.924])#单位1减去画布上下的距离,剩下的作为高度
plt.xticks(())
plt.yticks(())
plt.text(0.5,0.5,'1',ha='center',va='center',size=36,alpha=0.5)

Text(0.5, 0.5, '1')

plt.figure(facecolor='lightgray')
plt.axes([0.03#画布左右离边框的距离,0.038#画布上下离边框,0.94#单位1减去画布左右的距离,剩下的作为宽度,0.924])#单位1减去画布上下的距离,剩下的作为高度
plt.xticks(())
plt.yticks(())
plt.text(0.5,0.5,'1',ha='center',va='center',size=36,alpha=0.5)plt.axes([0.63#画布左右离边框的距离,0.076#画布上下离边框,0.31#单位1减去画布左右的距离,剩下的作为宽度,0.308])#单位1减去画布上下的距离,剩下的作为高度
plt.xticks(())
plt.yticks(())
plt.text(0.5,0.5,'2',ha='center',va='center',size=36,alpha=0.5)

Text(0.5, 0.5, '2')

4.刻度定位器
定位器对象 = plt.***Locator(…)
ax = mp.gca()
ax.(x/y)axis.set_major_locator(定位器对象) #主刻度
ax.(x/y)axis.set_minor_locator(定位器对象) #次刻度

def help_text():"""plt.text(x, y, s, fontsize, verticalalignment,horizontalalignment,rotation , **kwargs)x,y表示标签添加的位置，默认是根据坐标轴的数据来度量的，是绝对值，也就是说图中点所在位置的对应的值，特别的，如果你要变换坐标系的话，要用到transform=ax.transAxes参数。s表示标签的符号，字符串格式，比如你想加个“我爱三行科创”，更多的是你标注跟数据有关的主体，你如实写便是。fontsize顾名思义就是你加标签字体大小了，取整数。verticalalignment表示垂直对齐方式 ，可选 ‘center’ ，‘top’ ， ‘bottom’，‘baseline’ 等horizontalalignment表示水平对齐方式 ，可以填 ‘center’ ， ‘right’ ，‘left’ 等rotation表示标签的旋转角度，以逆时针计算，取整后面还有 family 用来设置字体，style 设置字体的风格，weight 字体的粗细, bbox 给字体添加框,如 bbox=dict(facecolor=‘red’, alpha=0.5) 等，各种风格，应有尽有，总有一款适合你。"""print("以上是函数说明")return 0import numpy as np
import matplotlib.pyplot as plt
import matplotlibplt.figure()
locators = ['plt.NullLocator()',  #空定位器：不绘制刻度'plt.MaxNLocator(nbins=3,steps=[1,3,5,7,9])',  #最大值定位器：最多绘制nbins个刻度，每两个刻度之间的间隔从steps列表中选择'plt.FixedLocator(locs=[0,2.5,5,7.5,10])',  #定点定位器：根据locs参数中的位置绘制刻度'plt.AutoLocator()',  #自动定位器；缺省定位器：由绘图系统来自动选择刻度的绘制位置'plt.IndexLocator(offset=0.5,base=1.5)',  #等间距定位器，索引定位器：由offset来确定起始刻度，由base来确定相邻可得的间隔'plt.MultipleLocator()',  #多点定位器，从0开始，按照参数指定的间隔(缺省1)绘制刻度，与IndexLocator方法类似 'plt.LinearLocator(numticks=21)',  #线性定位器：线性等分成 numticks-1份，绘制numticks刻度'plt.LogLocator(base=2,subs=[1.0])'  #对数定位器，以base为底，用subs中的元素作为指数增量，绘制刻度
]
n_locator = len(locators)
for i, locator in enumerate(locators):  #遍历列表的同时获取元素的索引值plt.subplot(n_locator, 1, i + 1)  #plt.subplot(行,列,图号),下标是从0开始plt.xlim(0, 10)  #显示区域plt.ylim(-1, 1)  #显示区域plt.yticks(())  #将y轴设置为空ax = plt.gca()  #获取轴ax.spines['left'].set_color('none')  #左边框设置为空ax.spines['top'].set_color('none')  #顶边框设置为空ax.spines['right'].set_color('none')  #右边框设置为空ax.spines['bottom'].set_position(('data', 0))  #底边框移动位置到0点ax.xaxis.set_major_locator(eval(locator))  #eval() 函数用来执行一个字符串表达式，并返回表达式的值。#下标为主刻度ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))  #多点定位器，从0开始，按照参数指定的间隔(缺省1)绘制刻度#也就是副刻度为0.1plt.plot(np.arange(11), np.zeros(11), c='none')  #画出一个x为1-10，y为0，无色的线条#就可以直接显示x轴的设置，无需再去绘画plt.text(5, 0.3, locator[3:], ha='center', size=12)#locator[3:]是名字作为字符串输出,去掉plt
plt.tight_layout()
help(help_text)  #详情间函数help_text()
plt.show()

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/3229400527.py:51: UserWarning: Tight layout not applied. tight_layout cannot make axes height small enough to accommodate all axes decorations.plt.tight_layout()Help on function help_text in module __main__:help_text()plt.text(x, y, s, fontsize, verticalalignment,horizontalalignment,rotation , **kwargs)x,y表示标签添加的位置，默认是根据坐标轴的数据来度量的，是绝对值，也就是说图中点所在位置的对应的值，特别的，如果你要变换坐标系的话，要用到transform=ax.transAxes参数。s表示标签的符号，字符串格式，比如你想加个“我爱三行科创”，更多的是你标注跟数据有关的主体，你如实写便是。fontsize顾名思义就是你加标签字体大小了，取整数。verticalalignment表示垂直对齐方式 ，可选 ‘center’ ，‘top’ ， ‘bottom’，‘baseline’ 等horizontalalignment表示水平对齐方式 ，可以填 ‘center’ ， ‘right’ ，‘left’ 等rotation表示标签的旋转角度，以逆时针计算，取整后面还有 family 用来设置字体，style 设置字体的风格，weight 字体的粗细, bbox 给字体添加框,如 bbox=dict(facecolor=‘red’, alpha=0.5) 等，各种风格，应有尽有，总有一款适合你。

散点图

plt.scatter()

引入概念：正态分布
记作: x ～ n x～n x～n 图形叫做正态曲线
越靠近峰值(分布中心平均值)的概率就越大，越偏离分布中心概率就越小，分布中心记作 μ \mu μ(niu)
标准差(分散性)：
会有高的正态分布，也会有低的正态分布
用低的正态分布和高的正态分布的高度之差表明分散性记作 σ \sigma σ，如果低的正态分布与x轴的面积为定值，标准差越大，低的正态分布越平坦，分散性越广泛，如果 σ \sigma σ值越小，就越集中。当 σ = 1 \sigma=1 σ=1, μ = 0 \mu=0 μ=0叫做标准正态分布

n = 1000
x = np.random.normal(0, 1, n)  #平均值，标准差，需要的数目
y = np.random.normal(0, 1, n)
d = np.sqrt(x**2 + y**2)#两点间距离公式plt.figure('Scatter', facecolor='lightgray')
plt.title('Scatter', fontsize=20)
plt.xlabel('x', fontsize=14)
plt.ylabel('y', fontsize=14)
plt.tick_params(labelsize=10)
plt.grid(':')plt.scatter(x, y, s=60, c=d, cmap='jet_r', alpha=0.5, marker='*')
#cmap:颜色预设(设置的颜色预设了渐变，数值越大颜色就越与数值低的不一样)
#c:作为数值
#因为正态分布是(x,y)每个点之间，因为标准正态分布的平均值(峰值)是0，所以以d为距离(x点与y点的中间数)来生成图像

<matplotlib.collections.PathCollection at 0x1d630476950>

区域填充：
plt.fill_between(水平坐标数组,垂直坐标起点数组,垂直坐标重点数组,条件,color=颜色,alpha=透明度)

n = 1000
x = np.linspace(0,8*np.pi,n)  #平均值，标准差，需要的数目
sin_y = np.sin(x)
cos_y = np.cos(x/2)/2plt.figure('Fill', facecolor='lightgray')
plt.title('Fill', fontsize=20)
plt.xlabel('x', fontsize=14)
plt.ylabel('y', fontsize=14)
plt.tick_params(labelsize=10)
plt.grid(':')plt.plot(x,sin_y,c='dodgerblue',label=r'$y=sin(x)$')
plt.plot(x,cos_y,c='orangered',label=r'$y=\frac{1}{2}cos(\frac{x}{2})$')#plt.fill_between(水平坐标数组,垂直坐标起点数组,垂直坐标重点数组,条件,color=颜色,alpha=透明度)
#plt.fill_between(x,cos_y,sin_y,color='dodgerblue',alpha=0.5)
#添加条件
plt.fill_between(x,cos_y,sin_y,cos_y < sin_y,color='dodgerblue',alpha=0.5)plt.fill_between(x,cos_y,sin_y,cos_y > sin_y,color='orange',alpha=0.5)
plt.legend()

<matplotlib.legend.Legend at 0x1d6304ad870>

柱状图

plt.bar(水平坐标数组,高度数组,ec=边缘颜色,fc=填充颜色,label=标签文本,alpha=透明度)

n = 12
x = np.arange(n)
y1 = (1 - x / n) * np.random.uniform(0.5, 1.0,n)  #均匀分布(每个产生的数概率都一样),在0.5到1均匀分布n个值
y2 = (1 - x / n) * np.random.uniform(0.5, 1.0, n)plt.figure('Bar', facecolor='lightgray')
plt.title('Bar', fontsize=20)
plt.ylim(-1.25, 1.25)#y的显示区域
plt.xlabel('x', fontsize=14)
plt.ylabel('y', fontsize=14)
plt.xticks(x, x + 1)#设置x轴的刻度
plt.tick_params(labelsize=10)#参数刻度线样式设置,设置刻度的大小
plt.grid(axis='y', linestyle=':')#只给y轴添加线#plt.bar(水平坐标数组,高度数组,ec=边缘颜色,fc=填充颜色,label=标签文本,alpha=透明度)#绘制上方图形
plt.bar(x, y1, ec='white', fc='dodgerblue', label='Sample 1')
for _x, _y in zip(x, y1):plt.text(_x, _y, '%.2f' % _y, ha='center', va='bottom', size=8)#绘制下方图形
plt.bar(x, -y2, ec='white', fc='dodgerblue', label='Sample 2', alpha=0.5)
for _x, _y in zip(x, y2):plt.text(_x, -_y - 0.015, '%.2f' % _y, ha='center', va='top', size=8)
plt.legend()

<matplotlib.legend.Legend at 0x1d631530880>

等高线图

引入概念：等高线
有两座山，当我们乘坐直升机俯视山时，相等海拔的地方用线连接起来就会围成一个圈，然后海拔越高离圆心越进

一般在计算时会先把 z z z提出来,先把 x , y x,y x,y画出，就会生成一片网格点就是一个平面的图形，然后再加上 z z z就画出了图形
因为单 x , y x,y x,y只能绘出线，所以要x与y相互倒换再绘图才会成为网格点,所以 x x x与 y y y和 z z z都要是二维数组
组别:
x:
- x与y的值
- y与x的值
y:
- y与x的值
- x与y的值
z:
- z与x的值
- z与y的值

def help_plt_clabel():'''cs ： ContourSet要标注的 ContourSet。(contour对象)levels ： 类似数组，可选应标记的级别值列表。该列表必须是 的子集cs.levels。如果没有给出，所有级别都会被标记。fontsize : 字符串或浮点数，可选以点为单位的大小或相对大小，例如“较小”、“x-large”。查看Text.set_size接受的字符串值。colors ： 颜色规格，可选标签颜色：如果None，每个标签的颜色与相应轮廓的颜色相匹配。如果一个字符串颜色，例如，colors = 'r' 或colors = 'red'，则所有标签都将以这种颜色绘制。如果 matplotlib 颜色参数（字符串、浮点数、rgb 等）的元组，不同的标签将按照指定的顺序以不同的颜色绘制。inline ： 布尔，可选如果True在放置标签的位置删除了基础轮廓。默认为True。inline_spacing : 浮动，可选放置内联时要在标签的每一侧留下的空间（以像素为单位）。默认为 5。对于轮廓笔直位置的标签，此间距将是准确的，而对于弯曲轮廓上的标签则更少。fmt : 字符串或字典，可选标签的格式字符串。默认为“%1.3f”或者，这可以是一个字典，将轮廓级别与用于每个轮廓级别的任意字符串匹配（即，fmt[level]=string），或者它可以是任何可调用的，例如Formatter实例，在调用时返回一个字符串数字等高线水平。manual ： 布尔或可迭代，可选如果True，将使用鼠标单击手动放置等高线标签。单击轮廓附近的第一个按钮以添加标签，单击第二个按钮（或可能同时单击两个鼠标按钮）以完成添加标签。第三个按钮可用于删除最后添加的标签，但前提是标签不是内联的。或者，键盘可用于选择标签位置（输入结束标签放置，删除或退格就像第三个鼠标按钮一样，任何其他键都将选择标签位置）。manual也可以是 x,y 元组的可迭代对象。将创建轮廓标签，就像在每个 x,y 位置单击鼠标一样。rightside_up : 布尔值，可选如果True，标签旋转将始终与水平面成正负 90 度。默认为True。use_clabeltext : bool，可选如果True，则使用ClabelText类（而不是Text）来创建标签。ClabelText在绘图期间重新计算文本的旋转角度，因此如果轴的方面发生变化，可以使用它。默认为False。label:Text标签的实例列表。'''return 0

plt.contour(x,y,z,线的数量,colors=颜色,linewidth=线宽)#绘制的是线
plt.contourf(x,y,z,线的数量,cmap=颜色映射,linewidth=线宽)#绘制的是线带(以颜色映射来填充)

np.meshgrid() 给出x,y自动生成网格返回x,y的坐标数值

n = 1000
x, y = np.meshgrid(np.linspace(-3, 3, n), np.linspace(-3, 3, n))
z = (1 - x / 2 + x**5 + x**3) * np.exp(-x**2 - y**2)plt.figure('Contour', facecolor='lightgray')
plt.title('Contour', fontsize=20)
plt.xlabel('x', fontsize=14)
plt.ylabel('y', fontsize=14)
plt.tick_params(labelsize=10)  #参数刻度线样式设置,设置刻度的大小
plt.grid(linestyle=':')  #只给y轴添加线#标明参数
cntr = plt.contour(x, y, z, 20, colors='black', linewidth=5)#得到等高线对象
plt.clabel(cntr,inline_spacing=1,fmt='%.1f',fontsize=10)
help(help_plt_clabel)#详情见help_plt_clabel#plt.contourf(x,y,z,20,cmap='jet')#画线带
plt.contour(x, y, z, 20, colors='black', linewidth=5)
#实线虚线之分：z>0的是实线,x<0的是虚线
#本数据z是海拔为0的数值,所以实线都是高于海平面，虚线是低于海平面

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/1344543040.py:14: UserWarning: The following kwargs were not used by contour: 'linewidth'cntr = plt.contour(x, y, z, 20, colors='black', linewidth=5)#得到等高线对象Help on function help_plt_clabel in module __main__:help_plt_clabel()cs ： ContourSet要标注的 ContourSet。(contour对象)levels ： 类似数组，可选应标记的级别值列表。该列表必须是 的子集cs.levels。如果没有给出，所有级别都会被标记。fontsize : 字符串或浮点数，可选以点为单位的大小或相对大小，例如“较小”、“x-large”。查看Text.set_size接受的字符串值。colors ： 颜色规格，可选标签颜色：如果None，每个标签的颜色与相应轮廓的颜色相匹配。如果一个字符串颜色，例如，colors = 'r' 或colors = 'red'，则所有标签都将以这种颜色绘制。如果 matplotlib 颜色参数（字符串、浮点数、rgb 等）的元组，不同的标签将按照指定的顺序以不同的颜色绘制。inline ： 布尔，可选如果True在放置标签的位置删除了基础轮廓。默认为True。inline_spacing : 浮动，可选放置内联时要在标签的每一侧留下的空间（以像素为单位）。默认为 5。对于轮廓笔直位置的标签，此间距将是准确的，而对于弯曲轮廓上的标签则更少。fmt : 字符串或字典，可选标签的格式字符串。默认为“%1.3f”或者，这可以是一个字典，将轮廓级别与用于每个轮廓级别的任意字符串匹配（即，fmt[level]=string），或者它可以是任何可调用的，例如Formatter实例，在调用时返回一个字符串数字等高线水平。manual ： 布尔或可迭代，可选如果True，将使用鼠标单击手动放置等高线标签。单击轮廓附近的第一个按钮以添加标签，单击第二个按钮（或可能同时单击两个鼠标按钮）以完成添加标签。第三个按钮可用于删除最后添加的标签，但前提是标签不是内联的。或者，键盘可用于选择标签位置（输入结束标签放置，删除或退格就像第三个鼠标按钮一样，任何其他键都将选择标签位置）。manual也可以是 x,y 元组的可迭代对象。将创建轮廓标签，就像在每个 x,y 位置单击鼠标一样。rightside_up : 布尔值，可选如果True，标签旋转将始终与水平面成正负 90 度。默认为True。use_clabeltext : bool，可选如果True，则使用ClabelText类（而不是Text）来创建标签。ClabelText在绘图期间重新计算文本的旋转角度，因此如果轴的方面发生变化，可以使用它。默认为False。label:Text标签的实例列表。

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/1344543040.py:20: UserWarning: The following kwargs were not used by contour: 'linewidth'plt.contour(x, y, z, 20, colors='black', linewidth=5)<matplotlib.contour.QuadContourSet at 0x1d6315330d0>

热像图

plt.imshow(矩阵,cmap=颜色映射,origin=垂直轴方向)

n = 1000
x, y = np.meshgrid(np.linspace(-3, 3, n), np.linspace(-3, 3, n))
z = (1 - x / 2 + x**5 + x**3) * np.exp(-x**2 - y**2)plt.figure('Hot', facecolor='lightgray')
plt.title('Hot', fontsize=20)
plt.xlabel('x', fontsize=14)
plt.ylabel('y', fontsize=14)
plt.tick_params(labelsize=10)  #参数刻度线样式设置,设置刻度的大小
plt.grid(linestyle=':')  #只给y轴添加线plt.imshow(z,cmap='jet',origin='lower')
#与countor上下颠倒

<matplotlib.image.AxesImage at 0x1d6326706d0>

饼图

plt.pie(值列表,间隙列表,标签,颜色列表,格式串,shadow=是否带阴影,startangle=起始角度)

plt.figure('Pie', facecolor='lightgray')
plt.title('Pie', )
plt.pie([26,17,21,29,11],[0.05 , 0.01 , 0.01 , 0.01 , 0.01],['Python','JavaScript','C++','C','PHP'],['dodgerblue','orangered','limegreen','violet','gold'],'%d%%',shadow=True,startangle=90)
plt.axis('equal')#设置了起始角度，图形不会在中间，需要设置轴比例相等

(-1.1378214315855841,1.1164326039920667,-1.1281760603396305,1.138380643792611)

三维曲面

导入库：from mpl_toolkits.mplot3d import axes3d

需要先获得3d坐标轴:
ax = mp.gca(projection=‘3d’)

ax.plot_surface(x,y,z,rstride=行距,cstride=列距,camp=颜色映射)绘制三维表面图像(在网格表面贴上颜色)
行距列距越小画的图越细，精度高速度慢
行距列距越大画的图越粗，精度低速度快

ax.plot_wireframe(x,y,z,rstride=行距,cstride=列距,linewidth=线宽,color=颜色)绘制三维线框图像(用线框出来的图形)

n = 1000
x, y = np.meshgrid(np.linspace(-3, 3, n), np.linspace(-3, 3, n))
z = (1 - x / 2 + x**5 + x**3) * np.exp(-x**2 - y**2)plt.figure('3D Wireframe')
ax = plt.gca(projection='3d')
plt.title('3D Wireframe',fontsize=20)
ax.set_xlabel('x',fontsize=14)
ax.set_ylabel('y',fontsize=14)
ax.set_zlabel('z',fontsize=14)
plt.tick_params(labelsize=10)
#选择30是因为这是经线和纬线之间的距离
ax.plot_wireframe(x,y,z,rstride=30,cstride=30,linewidth=0.5,color='orangered')

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/1487489030.py:6: MatplotlibDeprecationWarning: Calling gca() with keyword arguments was deprecated in Matplotlib 3.4. Starting two minor releases later, gca() will take no keyword arguments. The gca() function should only be used to get the current axes, or if no axes exist, create new axes with default keyword arguments. To create a new axes with non-default arguments, use plt.axes() or plt.subplot().ax = plt.gca(projection='3d')<mpl_toolkits.mplot3d.art3d.Line3DCollection at 0x1d632edbcd0>

n = 1000
x, y = np.meshgrid(np.linspace(-3, 3, n), np.linspace(-3, 3, n))
z = (1 - x / 2 + x**5 + x**3) * np.exp(-x**2 - y**2)plt.figure('3D Wireframe')
ax = plt.gca(projection='3d')
plt.title('3D Surface',fontsize=20)
ax.set_xlabel('x',fontsize=14)
ax.set_ylabel('y',fontsize=14)
ax.set_zlabel('z',fontsize=14)
plt.tick_params(labelsize=10)
#选择30是因为这是经线和纬线之间的距离
ax.plot_surface(x,y,z,rstride=30,cstride=30,cmap='jet')

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/297019136.py:6: MatplotlibDeprecationWarning: Calling gca() with keyword arguments was deprecated in Matplotlib 3.4. Starting two minor releases later, gca() will take no keyword arguments. The gca() function should only be used to get the current axes, or if no axes exist, create new axes with default keyword arguments. To create a new axes with non-default arguments, use plt.axes() or plt.subplot().ax = plt.gca(projection='3d')<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x1d633cb5cc0>

三维散点

ax.scatter(x,y,z,s=大小,c=颜色,marker=点型)
x,y,z都是一维数组不用网格化

n = 1000
x = np.random.normal(0, 1, n)  #平均值，标准差，需要的数目
y = np.random.normal(0, 1, n)
z = np.random.normal(0, 1, n)
d = np.sqrt(x**2 + y**2 + z**2)#两点间距离公式plt.figure('Scatter 3D', facecolor='lightgray')
ax = plt.gca(projection='3d')
plt.title('Scatter3D', fontsize=20)
ax.set_xlabel('x', fontsize=14)
ax.set_ylabel('y', fontsize=14)
ax.set_zlabel('z', fontsize=14)
plt.tick_params(labelsize=10)ax.scatter(x,y,z,s=60,c=d,cmap='jet_r',alpha=0.5,marker='o')

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/3973008839.py:8: MatplotlibDeprecationWarning: Calling gca() with keyword arguments was deprecated in Matplotlib 3.4. Starting two minor releases later, gca() will take no keyword arguments. The gca() function should only be used to get the current axes, or if no axes exist, create new axes with default keyword arguments. To create a new axes with non-default arguments, use plt.axes() or plt.subplot().ax = plt.gca(projection='3d')<mpl_toolkits.mplot3d.art3d.Path3DCollection at 0x1d633e634c0>

极坐标系

二维
首先需要得到参数:plt.gca(projection=‘polar’)
在极坐标系中:
x -> 极角
y -> 极径

t = np.linspace(0,2*np.pi,1001)#极角数:因为极角满足区间[0,2Π]
r_spiral = 0.8 * t #满足螺旋线方程
r_rose = 5 * np.sin( 6 * t )plt.figure('Polar', facecolor='lightgray')
ax = plt.gca(projection='polar')
plt.title('Polar', fontsize=20)
plt.xlabel(r'$\theta$',fontsize=14)
plt.ylabel(r'$\rho$', fontsize=14)
plt.tick_params(labelsize=10)
plt.grid(':')plt.plot(t,r_spiral,c='dodgerblue',label=r'$\rho=0.8\theta$')
plt.plot(t,r_rose,c='orangered',label=r'$\rho=5sin(6\theta)$')
plt.legend()

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/3487509688.py:6: MatplotlibDeprecationWarning: Calling gca() with keyword arguments was deprecated in Matplotlib 3.4. Starting two minor releases later, gca() will take no keyword arguments. The gca() function should only be used to get the current axes, or if no axes exist, create new axes with default keyword arguments. To create a new axes with non-default arguments, use plt.axes() or plt.subplot().ax = plt.gca(projection='polar')<matplotlib.legend.Legend at 0x1d633da9db0>

半对数坐标

plt.semilogy()

y = np.array([1,10,100,1000,100,10,1])#上图
plt.figure('Normal & Log', facecolor='lightgray')
plt.subplot(211)
plt.title('Normal', fontsize=20)
plt.ylabel(r'$\rho$', fontsize=12)
ax = plt.gca()
ax.xaxis.set_major_locator(plt.MultipleLocator(1))
ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))ax.yaxis.set_major_locator(plt.MultipleLocator(250))
ax.yaxis.set_minor_locator(plt.MultipleLocator(50))plt.tick_params(labelsize=10)plt.grid('-',which='major',axis='both',linewidth=0.75,color='lightgray')
plt.grid('-',which='minor',axis='both',linewidth=0.25,color='lightgray')plt.plot(y,'o-',c='dodgerblue',label='plot')
#plt.plot(t,r_rose,c='orangered',label=r'$\rho=5sin(6\theta)$')
plt.legend()#下图
plt.subplot(212)
plt.title('Log', fontsize=20)
plt.xlabel('x', fontsize=12)
plt.ylabel('y', fontsize=12)
ax = plt.gca()
ax.xaxis.set_major_locator(plt.MultipleLocator(1))
ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))ax.yaxis.set_major_locator(plt.MultipleLocator(250))
ax.yaxis.set_minor_locator(plt.MultipleLocator(50))plt.tick_params(labelsize=10)plt.grid('-',which='major',axis='both',linewidth=0.75,color='lightgray')
plt.grid('-',which='minor',axis='both',linewidth=0.25,color='lightgray')#半对数坐标更能观察到小的变化
plt.semilogy(y,'o-',c='orangered',label='semilog')
#plt.plot(t,r_rose,c='orangered',label=r'$\rho=5sin(6\theta)$')
plt.legend()
plt.tight_layout()

简单动画

首先导入库：import matplotlib,animation as ma
ma.FuncAnimation(图形对象,更新函数,生成器,interval=间隔时间(毫秒))
工作原理:
迭代一次生成器,把生成值给更新函数更新画面,然后再间隔时间继续迭代生成器,就可以动起来了

先定义函数
def 更新函数(顺序号):
更新画面帧
---------------------------------------------------------------------------------------------
或者使用生成器
def 更新函数(生成值):
更新画面帧

def 生成器():#不需要参数
产生新的数据
yield 生成值

yield介绍:每调用一次会产生一个值，调用完后内存中全部清空(与局部变量相同)

#自定义更新函数
n_bubbles= 100#定义气泡
'''每个气泡需要定义属性,那就把他规整成一个类就能一起做运算通过dtype自定义类型就可以把他定义成一个类position(位置)  size(大小)  growth(身长速度)  color(颜色)float(2)    float(1)     float(1)         float(4)       (x,y)     大小只需一个值    只需一个值   R G B alpha(透明度)#0-1之间的数
'''
bubbles = np.zeros(n_bubbles,dtype=[#复合结构对象('position',float,2),('size',float,1),('growth',float,1),('color',float,4),
])
'''np.random.uniform(low,high,size)low: 采样下界，float类型，默认值为0；high: 采样上界，float类型，默认值为1；size: 输出'样本'数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出m*n*k个'样本'，缺省时输出1个值。
'''bubbles['position'] = np.random.uniform(0,1,(n_bubbles,2))#因为要规范模型，所以位置规范到(0,1]之间,因为是二维数组所以是(n_bubbles,2)
bubbles['size'] = np.random.uniform(50,750,n_bubbles)#行优先
bubbles['growth'] = np.random.uniform(30,150,n_bubbles)
bubbles['color'] = np.random.uniform(0,1,(n_bubbles,4))plt.figure('Bubbles',facecolor='lightgray')
plt.title('Bubbles',fontsize=20)
plt.xticks(())
plt.yticks(())
sc = plt.scatter(bubbles['position'][:,0],#二维数组的切片bubbles['position'][:,1],s=bubbles['size'],#大小,如果每各时间变换一次就可以动起来了，就给与一个散点对象c=bubbles['color'])#颜色def update(number):#序列号bubbles['size'] += bubbles['growth']#之前定义的增长量burst = number % n_bubblesbubbles['position'][burst]=np.random.uniform(0,1,2)#重置位置字段bubbles['size'][burst] = 0#大小重置为0bubbles['growth'][burst]=np.random.uniform(30,150)bubbles['color'][burst]=np.random.uniform(0,1,4)sc.set_offsets(bubbles['position'])#重新设置posisionsc.set_sizes(bubbles['size'])#因为'size'在前面被更新了,重新设置sizesc.set_facecolor(bubbles['color'])#重新设置填充色#plt.gcf()  返回当前图
anim = ma.FuncAnimation(plt.gcf(),update,interval=10)
#因为是函数，如果不保存就会立即被执行完毕被销毁，所以要把它赋值给变量来延长他的时效性
plt.show()

C:\Users\Yuan\AppData\Local\Temp/ipykernel_6424/2393575389.py:10: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.bubbles = np.zeros(n_bubbles,dtype=[#复合结构对象

#生成器
'''完成的是类似于心电图的实时图形
'''#figure设置
plt.figure('Signal',facecolor='lightgray')
plt.title('Signal',fontsize=20)
plt.xlabel('Time',fontsize=14)
plt.ylabel('Signal',fontsize=14)
ax = plt.gca()
ax.set_ylim(-3,3)#设置y的范围
ax.set_xlim(0,10)#设置x的范围
plt.tick_params(labelsize=10)#设置刻度字体大小
plt.grid(':')#生成器
'''Matplotlib工作原理:生成图像时，会把(x,y)放入他的缓冲区，缓冲区数据和图是对应的,存放着图的所有属性当要产生图像时，会把缓冲区的数据放进系统的内部缓冲区里，然后show()的时候根据内部的缓冲区把图呈现出来API:这些封装好的函数，就叫做API(Application Programming Interface)，即应用程序编程接口思路:所以首先如果要成一个持续的图形,先让他有内部结构
'''pl = plt.plot([],[],c='orangered')[0]#因为是追加所以只需要第一个元素就行
'''
用pl来保存这个线的结构,因为包含了所有属性，那么就相当于缓冲区的数据
但是没有标明存放数据的地方,就调用set_data()
'''
pl.set_data([],[])#先把位置空出来 def update(data):#因为是生成器，不会要求有啥属性time , value = data #时间与信号值x , y = pl.get_data()#第一次肯定是空值，后面生成过后就会往pl里面添加值x.append(time)y.append(value)'''因为之前限制了x的范围，所以画图会出现画满就不画了，所以要更细他的显示范围'''''''''x_min , x_max = ax.get_xlim()#得到左右边界if time >= x_max:ax.set_xlim(time - (x_max- x_min),time)ax.figure.canvas.draw()#重新画画布    pl.set_data(x,y)#追加后再设置'''np.exp() 返回e的x倍的指数
'''
def generator():t = 0while True:v = np.sin(2 * np.pi * t) * np.exp(np.sin(0.2 * np.pi * t))#正弦函数标准方程yield t,vt += 0.05anim = ma.FuncAnimation(plt.gcf(),update,generator,interval=5)
plt.show()

C:\Python310\lib\site-packages\matplotlib\animation.py:889: UserWarning: Animation was deleted without rendering anything. This is most likely not intended. To prevent deletion, assign the Animation to a variable, e.g. `anim`, that exists until you have outputted the Animation using `plt.show()` or `anim.save()`.warnings.warn(

动图需要自己去运行一下哦

文章持有人：我怕是有点打脑壳
严禁转载

Numpy(附Matplotlib)基础核心内容相关推荐

数析三剑客 numpy pandas matplotlib 基础操作
NUMPY[一]: NumPy是Python的一种开源的数值计算扩展.这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多.Num ...
数据分析（1）Matplotlib基础内容
文章目录一. Matplotlib基础知识 (一)底层容器层 1. 画布Figure (1)plt.subplot() (2)plt.subplots() (3)fig.add_subplot() ...
python Numpy 的基础用法以及 matplotlib 基础图形绘制
python Numpy 的基础用法以及 matplotlib 基础图形绘制 1. 环境搭建 1.1 Anaconda anaconda 集成了数据分析,科学计算相关的所有常用安装包,比如Numo ...
python基础知识及数据分析工具安装及简单使用(Numpy/Scipy/Matplotlib/Pandas/StatsModels/Scikit-Learn/Keras/Gensim))
Python介绍. Unix & Linux & Window & Mac 平台安装更新 Python3 及VSCode下Python环境配置配置 python基础知识及数据分 ...
Python：十分基础的简要入门和补充鱼书中的numpy和matplotlib
最近在学习鱼书(深度学习入门),于是打算持续更新这个系列,由于自己有一定python基础,所以选择那些基础python没涉及到的东西摘抄并补充.在看书的过程中,感受到鱼书不愧于入门教程,十分的简洁,但 ...
[机器学习]Python中Numpy,Pandas,Matplotlib,Scipy,Seaborn介绍
Python做数据挖掘很强大,最近几年很火的机器学习以及较为前沿的自然语言处理也会选用Python作为基础工具. 其中python做数据挖掘足够强大,不用怀疑. #1. Numpy介绍 Numpy是P ...
Numpy and Matplotlib
Numpy介绍编辑一个用python实现的科学计算,包括:1.一个强大的N维数组对象Array:2.比较成熟的(广播)函数库:3.用于整合C/C++和Fortran代码的工具包:4.实用的线性代数 ...
matplotlib输出图形到网页_【Python】No.2 Numpy和Matplotlib初体验
上一次推送,我们了解了Python安装部署和conda管理,为后续的Python学习打下了基础,这次我们进入数据分析模块. Pandas.Numpy和Matplotlib被称为"数据分析三剑 ...
python可视化添加文本_python Matplotlib基础--如何添加文本和标注
创建一个优秀的可视化图表的关键在于引导读者,让他们能理解图表所讲述的故事.在一些情况下,这个故事可以通过纯图像的方式表达,不需要额外添加文字,但是在另外一些情况中,图表需要文字的提示和标签才能将故事讲 ...

Numpy(附Matplotlib)基础核心内容