教你如何绘制数学函数图像——numpy和matplotlib的简单应用

numpy和matplotlib的简单应用

一、numpy库

1.什么是numpy

NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。

numpy是科学计算包，支持N维数组运算、处理大型矩阵、成熟的广播函数库、矢量运算、线性代数、傅里叶变换、随机数生成，并可与C++/Fortran语言无缝结合。

2.numpy的安装

在Python v3中默认安装已经包含了numpy

如果没有安装，可以在命令行（ctrl+R，输入cmd）中输入pip install numpy即可自动安装使用

3.numpy的使用

注意：这里的矩阵跟线性代数（高等代数）中的矩阵一致，运算方法一致

（1）导入模块

import numpy as np  #用np来代替numpy

（2）生成数组(创建数组）

import numpy as np
print(np.array([1, 2, 3, 4, 5]))        # 把列表转换为数组
print(np.array((1, 2, 3, 4, 5)))        # 把元组转换成数组
print(np.array(range(5)))               # 把range对象转换成数组
print(np.array([[1, 2, 3], [4, 5, 6]])) # 二维数组
print(np.arange(8))                     # 类似于内置函数range()
print(np.arange(1, 10, 2))
print(np.linspace(0, 10, 11))         # 等差数组，包含11个数
print(np.linspace(0, 10, 11, endpoint=False)) # 不包含终点
print(np.logspace(0, 100, 10))        # 对数数组
print(np.logspace(1,6,5, base=2))     # 对数数组，相当于2 ** np.linspace(1,6,5)
print(np.zeros(3))                    # 全0一维数组
print(np.ones(3))                     # 全1一维数组
print(np.zeros((3,3)))              # 全0二维数组，3行3列
print(np.zeros((3,1)))              # 全0二维数组，3行1列
print(np.zeros((1,3)))              # 全0二维数组，1行3列
print(np.ones((1,3)))               # 全1二维数组
print(np.ones((3,3)))               # 全1二维数组
print(np.identity(3))      # 单位矩阵
print(np.identity(2))
print(np.empty((3,3)))     # 空数组，只申请空间而不初始化，元素值是不确定的

结果如图所示（因为是一次性输出全部，所以显示不是很好）

（3）数组的运算

1/ 数组与数值的运算

x=np.array((1,2,3,4,5))    #创建数组

x*2 　　  #乘法

x/2　　   #除法

x//2　　  #整除

x**3　　  #幂次方

x+2　　   #加法

x%3　　   #求余

2**x      #2的（x中的每一个元素）次方，同时生成另一个数组

2/x　　   #2除以x中的每一个元素，同时生成另外一个数组

63//x     #63除以x中的每一个元素，取整数，同时生成另外一个数组

 

2/ 数组与数组的运算

a= np.array((1,2,3))                             #先创建两个数组

b=np.array(([1,2,3],[4,5,6],[7,8,9]))

数组之间的基本运算

c=a*b　　　　

c/b

a+a

a*a

c-a

c/a

 

（4） 数组的转置

b=np.array(([1,2,3],[4,5,6],[7,8,9]))

b.T             #转置

值得注意的是：一维数组转置以后和原来是一样的

 

（5）点积和内积

 a = np.array((5, 6, 7))                                #创建数组a

 b = np.array((6, 6, 6))                                #创建数组b

 a.dot(b)                                　　　　　　　 #向量内积

 np.dot(a,b)

 c = np.array(([1,2,3],[4,5,6],[7,8,9]))     　  　　　 # 二维数组

  c.dot(a)                                　　　　　　  # 二维数组的每行与一维向量计算内积

  a.dot(c)                　　　　　　　　　　  　　　　# 一维向量与二维向量的每列计算内积

 

（6） 元素访问

b = np.array(([1,2,3],[4,5,6],[7,8,9]))

b[0]              　　　　　　　　　　　　　　　　　　　# 第0行

b[0][0] 　　　　　　　　　　　  　　　　　　　　　　　　# 第0行第0列的元素值

b[0,2]            　　　　　　　　   　　　　　　　　　 # 第0行第2列的元素值

b[[0,1]]          　　　　　　　　　　　　　　　　　　　# 第0行和第1行

b[[0,1], [1,2]]   　　　　　　　　  　　　　　　　　　　#第0行第1列的元素和第1行第2列的元素

 x = np.arange(0,100,10,dtype=np.floating)

 x[[1, 3, 5]]                 　　　　　　　  　　　　　# 同时访问多个位置上的元素

 x[[1, 3, 5]] = 3             　　　　　　　　　　　　　# 把多个位置上的元素改为相同的值

 x[[1, 3, 5]] = [34, 45, 56]  　　　　　  　　　　　　　# 把多个位置上的元素改为不同的值

 

（7）数组支持函数运算

np.sin(x)                       　　　　　　　　　　　　#求正弦值

np.cos(x)　　　　　　　　　　　　　　　　　　　　　　　 #求余弦值

np.round(_)　　　　　　　　　　　　　　　　　　　　　　 #四舍五入

x = np.random.rand(10) * 10                     　　　　# 包含10个随机数的数组

np.floor(x)                           　　　　　　 　　 # 所有元素向下取整

np.ceil(x) 　　　　　　　　　　　　　　　　　　　　　　 # 所有元素向上取整

（8） 改变数组大小

a = np.arange(1, 11, 1)                                 #创建一维数组

a.shape = 2, 5　　　　　　　　　　　   　　　　　　　　 #将数组改为2行5列

a.shape = 5, -1                        　　　　   　　  #将元素分成5列， -1表示自动计算，原地修改

b = a.reshape(2,5)                     　　　　 　　　　# reshape()方法返回新数组

（9） 切片操作

a[::-1]                           　　　　　　　　　　　# 反向切片

a[::2]                            　　　　　　　　　　　# 隔一个取一个元素

a[:5]                             　　　　　　　　　　　# 前5个元素

c[0, 2:5]            　　　 　　　　　　　　　　　　　　# 第0行中下标[2,5)之间的元素值

c[1]                  　　　  　　　　　　　　　　　　　# 第1行所有元素

c[2:5, 2:5]           　　   　　　　　　　　　　　　　 # 行下标和列下标都介于[2,5)之间的元素值

（10） 布尔运算（结果一般是True或者False显示)

x > 0.5               　　　　　　　　　　　　　　　　　# 比较数组中每个元素值是否大于0.5

x[x>0.5]              　　　   　　　　　　　　　　　　 # 获取数组中大于0.5的元素，可用于检测和过滤异常值

x < 0.5

np.all(x<1) 　　　　　　 　　　　 　　　　　　　　　　　# 测试是否全部元素都小于1

np.any([1,2,3,4])         　  　　　　　　　　　　　　　# 是否存在等价于True的元素

a > b                    　　　  　　　　　　　　　　　 # 两个数组中对应位置上的元素比较

a[a>b]　　　　　　　　  　　　　　　　　　　　　　　　　#输出相对应元素a>b的元素位置

（11）取整运算

x = np.random.rand(10)*50      　　　　　　　　　　　　 # 10个随机数

np.int64(x) 　　　　　　　　　　  　　　　　　　　　　  # 取整

np.int32(x)

（12）广播

a = np.arange(0,60,10).reshape(-1,1)     　　　　　　   # 创建列向量

b = np.arange(0,6)                       　　　　　 　　# 创建行向量

a[0] + b                                 　　　　　　　 # 数组与标量的加法

a + b　　　　　　　　　　　　　　　　　  　　　　　　　 #行向量与列向量的相加

a*b　　　　　　　　　　　　　　　　　　 　　　　　　　　#行向量与列向量的相乘

（13） 计算唯一值以及出现的次数

x = np.random.randint(0, 10, 7)                         #创建0到10之间的随机数，个数为7

np.bincount(x)　　　　　　　　　　　　　  　　　　　　　#计算元素出现的次数，由最小的元素开始，到最大值

np.sum(_)        　　　　　　　　　　　　　　　　　　　 # 所有元素出现次数之和等于数组长度

np.unique(x)     　　　　　　　　　　　　　　　　　　　 # 返回唯一元素值

（14） 矩阵运算

a_list = [3, 5, 7]

a_mat = np.matrix(a_list)            　　　　　   　　  # 创建矩阵

a_mat.T                              　　　　　　　　　 # 矩阵转置

a_mat.shape                          　　　　　　　　　 # 矩阵形状

a_mat.size                           　　　　　　　　　 # 元素个数

a_mat.mean()                        　　　　　　　      # 元素平均值

a_mat.sum() # 所有元素之和

a_mat.max() # 最大值

a_mat.max(axis=1)                   　　　　　　 　　   # 横向最大值

a_mat.max(axis=0) 　　　　　　　　　　     　　　　　　 # 纵向最大值

a_mat * b_mat.T                      　　　　　　   　　# 矩阵相乘

c_mat = np.matrix([[1, 5, 3], [2, 9, 6]])               # 创建二维矩阵

c_mat.argsort(axis=0)                                   # 纵向排序后的元素序号

c_mat.argsort(axis=1)                     　　　　   　 # 横向排序后的元素序号

d_mat.diagonal()                                        # 矩阵对角线元素

x = np.matrix(np.random.randint(0, 10, size=(3,3)))

x.std()                         　　　　　　　　　　    # 标准差

x.std(axis=1)                   　　　　　　　　        # 横向标准差

x.std(axis=0)                   　　　　　　　　　  　　# 纵向标准差

x.var(axis=0) 　　　　　　　　　　　　　　  　　　　　　# 纵向方差

二、matplotlib库

1.什么是matplotlib库

matplotlib模块依赖于numpy模块和tkinter模块，可以绘制多种形式的图形，包括线图、直方图、饼状图、散点图、误差线图等等。

2.matplotlib库的安装

在命令行（ctrl+R，输入cmd）中输入pip install matplotlib即可自动安装使用

3.matplotlib库的的使用

导入

import matplotlib 

 绘制正弦函数图像

import numpy as np
import pylab as pl

t = np.arange(0.0, 2.0*np.pi, 0.01)  #生成数组，0到2π之间，以0.01为步长
s = np.sin(t)                        #对数组中所有元素求正弦值，得到新数组
pl.plot(t,s)                         #画图，以t为横坐标，s为纵坐标
pl.xlabel('x')                       #设置坐标轴标签
pl.ylabel('y')
pl.title('sin')                                    #设置图形标题
pl.show()                                          #显示图形

结果如图所示

 

绘制散点图

import numpy as np
import pylab as pl
a = np.arange(0, 2.0*np.pi, 0.1)
b = np.cos(a)
pl.scatter(a,b)
pl.show()

结果如图所示

 绘制带有中文标签和图例的图像

import numpy as np
import pylab as pl
import matplotlib.font_manager as fm

myfont = fm.FontProperties(fname=r'C:\Windows\Fonts\STKAITI.ttf') #设置字体
t = np.arange(0.0, 2.0*np.pi, 0.01)                       # 自变量取值范围
s = np.sin(t)                                             # 计算正弦函数值
z = np.cos(t)                                             # 计算余弦函数值
pl.plot(t, s, label='正弦')
pl.plot(t, z, label='余弦')
pl.xlabel('x-变量', fontproperties='STKAITI', fontsize=18) # 设置x标签
pl.ylabel('y-正弦余弦函数值', fontproperties='simhei', fontsize=18)
pl.title('sin-cos函数图像', fontproperties='STLITI', fontsize=24)
pl.legend(prop=myfont)                                                          # 设置图例
pl.show()

结果如图所示

 

等等~~~~~~~~~~~~~~~

 

三、用雷达图表示python123中的成绩数据

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['font.family']='LiSu'#定义字体
matplotlib.rcParams['font.sans-serif'] = ['LiSu']
labels=np.array(['第一周','第二周','第三周','第四周','第五周','第六周'])#定义标签
data=np.array([8,10,9,10,11,7])
angles=np.linspace(0,2*np.pi,6,endpoint=False)
data=np.concatenate((data,[data[0]]))
angles=np.concatenate((angles,[angles[0]]))
fig=plt.figure(facecolor="yellow")#颜色设置
plt.subplot(111,polar=True)
plt.plot(angles,data,'bo-',color='g',linewidth=2)
plt.fill(angles,data,facecolor='g',alpha=0.25)
plt.thetagrids(angles*180/np.pi,labels)
plt.figtext(0.52,0.95,'xiayiLL的python123成绩雷达图',ha='center')#图像命名
plt.grid(True)
plt.show()

结果如图所示

 四、自定义手绘风

 代码如下

# -*- coding: utf-8 -*-

''' 手绘图像效果 '''
import numpy as np
from PIL import Image
vec_el = np.pi/2.2   # 光源的俯视角度，弧度值
vec_az = np.pi/4.    # 光源的方位角度，弧度值
depth = 6.          # 深度权值，值越小背景区域越接近白色，值越大背景区域越接近黑色
im = Image.open('C:\\Users\Administrator\Desktop\spyder\路飞.jpg').convert('L')     # 打开图像并转变为灰度模式
a = np.asarray(im).astype('float')
grad = np.gradient(a)              # 取图像灰度的梯度值
grad_x, grad_y = grad              # 分别取图像的横纵梯度值
grad_x = grad_x * depth / 100.
grad_y = grad_y * depth / 100.
dx = np.cos(vec_el) * np.cos(vec_az) # 光源对x轴的影响
dy = np.cos(vec_el) * np.sin(vec_az) # 光源对y轴的影响
dz = np.sin(vec_el)                  # 光源对z轴的影响
A = np.sqrt(grad_x**2 + grad_y**2 + 1.)
uni_x = grad_x/A
uni_y = grad_y/A
uni_z = 1./A
a2 = 255*(dx * uni_x + dy * uni_y + dz * uni_z) # 光源归一化
a2 = a2.clip(0, 255)                 # 预防溢出
im2 = Image.fromarray(a2.astype('uint8'))       # 重构图像
im2.save('HandMade_.jpg') # 保存图像
im2.show()                # 显示图像

原图如下

经代码转变手绘图

 五、感兴趣的图像

 分段函数图像，代码如下

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(0,100,1000)
interval0 = [1 if (i<30) else 0 for i in x]
interval1 = [1 if (i>=30 and i<50) else 0 for i in x]
interval2 = [1 if (i>=50) else 0 for i in x]
y = np.cos(x)* interval0 + x * interval1 + np.sin(x)*interval2
plt.plot(x,y)
plt.show()

结果如图所示