{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 函数绘图"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## matplotlib方法与数组"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"绘制线型图一般需要先导入matplotlib模块的pyplot子库，一般起别名为plt，方便引用 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"最主要的两个方法：\n",
"plt.plot():用于绘制图形\n",
"plt.show()：用于显示绘制的结果"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"plt.plot(x, y) # 根据坐标 x, y 值绘图\n",
"# x, y是列表或数组类型\n",
"\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"# x 可以缺省\n",
"# y 为必备参数\n",
"# fmt表示可将颜色、线型与标记写成一个字符串做参数，如'r-o'表示：红色实线圆点标记\n",
"\n",
"plot([x], y, [fmt], *, data=None, **kwargs)\n",
"plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pip install matplotlib\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"y = [1, 4, 9, 16, 25] # N: 5个数\n",
"# x取0...N-1。 0,1,2,3,4\n",
"\n",
"plt.plot(y) # 根据坐标 x, y 值绘图\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"x = [1, 2, 3, 4, 5]\n",
"y = [1, 4, 9, 16,19]\n",
"\n",
"plt.plot(x, y) # 根据坐标 x, y 值绘图\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"x = [1, 2, 3, 4, 5]\n",
"y = [i**3 for i in x]\n",
"\n",
"plt.plot(x, y) # 根据坐标 x, y 值绘图\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font face='楷体' color='red' size=5> 练一练 </font>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"x取值1到100，模仿前面的代码，绘制$y=x^{1/2}$的曲线"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 补充你的代码\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"颜色、线型、标记可以直接用参数值，也可以用fmt值"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"x = [1, 2, 3, 4, 5]\n",
"y = [1, 4, 9, 16, 25] # N: 5个数\n",
"plt.plot(x, y, color='green', marker='o', linestyle='dashed',\n",
" linewidth=2, markersize=12) # 绿色，圆点，虚线\n",
"\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"x = [1, 2, 3, 4, 5]\n",
"y = [1, 4, 9, 16, 25] # N: 5个数\n",
"plt.plot(x, y, 'go--', linewidth=2, markersize=12) # fmt-string\n",
"\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font face='楷体' color='red' size=5> 练一练 </font>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"参考以上代码，将线型改为实线，颜色设为蓝色。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 补充你的代码\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"利用range可以产生整数序列，利用列表推导式和math库中的函数，可以产生系列函数值的列表，绘制函数曲线。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"x = range(1, 6)\n",
"y = [i ** 2 for i in x]\n",
"\n",
"plt.plot(x, y) # 根据坐标 x, y 值绘图\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 绘制温度曲线图"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[某月温度.txt](images/ch9/某月温度.txt)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"def read_txt(file):\n",
" \"\"\"读文件中的数据到二维列表，返回二维列表\"\"\"\n",
" with open(file, 'r', encoding='utf-8') as fr:\n",
" data_ls = [x.strip().split() for x in fr]\n",
" return data_ls\n",
"\n",
"\n",
"def draw_curve(data_ls):\n",
" \"\"\"接收二维列表，绘制温度曲线，无返回值\"\"\"\n",
" date = [int(x[0]) for x in data_ls] # 获取日期的列表\n",
" high_temperature = [int(x[1]) for x in data_ls] # 高温数据列表\n",
" plt.plot(date, high_temperature) # 绘制高温曲线\n",
" plt.show() # 显示绘制结果\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" data_lst = read_txt('images/ch9/某月温度.txt')\n",
" draw_curve(data_lst)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"def read_txt(file):\n",
" \"\"\"读文件中的数据到二维列表，返回二维列表\"\"\"\n",
" with open(file, 'r', encoding='utf-8') as fr:\n",
" data_ls = [x.strip().split() for x in fr]\n",
" return data_ls\n",
"\n",
"\n",
"def draw_curve(data_ls):\n",
" \"\"\"接收二维列表，绘制温度曲线，无返回值\"\"\"\n",
" date = [int(x[0]) for x in data_ls] # 获取日期的列表\n",
" high_temperature = [int(x[1]) for x in data_ls] # 高温数据列表\n",
" low_temperature = [int(x[2]) for x in data_ls] # 低温数据列表\n",
" plt.plot(date, high_temperature) # 绘制高温曲线\n",
" plt.plot(date, low_temperature) # 绘制低温曲线\n",
" plt.show() # 显示绘制结果\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" data_lst = read_txt('images/ch9/某月温度.txt')\n",
" draw_curve(data_lst)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"def read_txt(file):\n",
" \"\"\"读文件中的数据到二维列表，返回二维列表\"\"\"\n",
" with open(file, 'r', encoding='utf-8') as fr:\n",
" data_ls = [x.strip().split() for x in fr]\n",
" return data_ls\n",
"\n",
"\n",
"def draw_curve(data_ls):\n",
" \"\"\"接收二维列表，绘制温度曲线，无返回值\"\"\"\n",
" date = [int(x[0]) for x in data_ls] # 获取日期的列表\n",
" high_temperature = [int(x[1]) for x in data_ls] # 高温数据列表\n",
" low_temperature = [int(x[2]) for x in data_ls] # 低温数据列表\n",
" plt.plot(date, high_temperature) # 绘制高温曲线\n",
" plt.plot(date, low_temperature) # 绘制低温曲线\n",
" plt.plot(date, [0] * len(date)) # 获取与date等数量的0的数组，绘制x轴\n",
" plt.show() # 显示绘制结果\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" data_lst = read_txt('images/ch9/某月温度.txt')\n",
" draw_curve(data_lst)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"range只能产生整数序列，数据点较少时，只能绘制折线图，无法绘制圆滑曲线。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import math\n",
"\n",
"x = range(0, 8)\n",
"sin_lsx = [math.sin(i) for i in x] # 根据x值计算系列sin(x)值\n",
"cos_lsx = [math.cos(i) for i in x] # 根据x值计算系列cos(x)值\n",
"\n",
"plt.plot(x, sin_lsx) # 根据坐标 x, sin_lsx 值绘sin(x)图\n",
"plt.plot(x, cos_lsx) # 根据坐标 x, cos_lsx 值绘cos(x)图\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"若希望绘制更平滑的函数曲线，可以利用numpy提供的函数产生系列浮点数的数组。 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## numpy数组运算"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"numpy提供的函数可以产生系列浮点数的数组，这些数据可以通过运算，直接得到数组中每个值对应的函数值构成的另一个数组。 \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"| 函数 | 描述 |\n",
"| :---- | :---- |\n",
"| array([x,y,x],dtype = int) | 将序列对象转换为数组，np.array([1, 2, 3, 4])返回数组 [1 2 3 4] |\n",
"| arange([x,]y[,i]) | 创建从x到y，步长为i的数组。np.**arange**(6) 返回数组[0 1 2 3 4 5] |\n",
"| linspace(x,y[,n]) | 参数为起始值、终止值和元素总数(默认50)，创建一维等差数组。\n",
"np.**linspace**(1, 5, 5) 返回数组 [1. 2. 3. 4. 5.] |\n",
"| logspace(x,y[,n]) | 参数为起始值、终止值和元素总数，创建一维等比数组。 |\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"x = np.array(range(1, 6)) # 将序列转换为数组，元素默认整数\n",
"y = x ** 2 # 数组运算，每个元素平方，[1 4 9 16 25]\n",
"print(x) # [1 2 3 4 5]\n",
"print(y) # [ 1 4 9 16 25]\n",
"plt.plot(x, y) # 根据坐标 x, y 值绘图\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"np.arange([x,] y [,i], dtype=int)\n",
"创建从x到y，步长为i的数组，步长可为小数"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"x = np.arange(1, 6, 0.1) # 创建从1到6，步长为0.1的整数数组\n",
"y = x ** 2 # 数组运算，每个元素平方\n",
"\n",
"plt.plot(x, y) # 根据坐标 x, y 值绘图\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"np.linspace([x,] y [,i]）\n",
"创建从x到y，i个数的等差的数组"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"numpy.linspace(start, stop, num=50, \n",
" endpoint=True, retstep=False, dtype=None, axis=0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"x = np.linspace(1, 10, 10)\n",
"print(x) # [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font face='楷体' color='red' size=5> 练一练 </font>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"利用linspace()产生0到$2\\pi$之间256个点的数据。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 补充你的代码\n",
"import numpy as np\n",
"\n",
"x = np.linspace(1, 2*np.pi, 256)\n",
"print(x) \n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"x = np.linspace(0, 5) # [0,5)，产生50个点的等差数组,x = np.linspace(0, 5, 50)\n",
"y1 = x\n",
"y2 = x ** 2 # 生成一系列x平方值的数组\n",
"y3 = x ** 3 # 生成一系列x立方值的数组\n",
"plt.plot(x, y1) # 绘制二次函数曲线\n",
"plt.plot(x, y2) # 绘制二次函数曲线\n",
"plt.plot(x, y3) # 绘制三次函数曲线\n",
"plt.show() # 显示创建的绘图对象"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## lanczos曲线\n"
]
},
{
"attachments": {
"b3cc9e8c-f0e4-496f-91ec-18f57dead0c2.png": {
"image/png": "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"
}
},
"cell_type": "markdown",
"metadata": {},
"source": [
"lanczos曲线常常用在图像插值中，这个算法在放大和缩小中都能较好的抵制锯齿，在插值时，不仅有正的插值系数，也有负的系数，比较适用于自然图像。\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"\n",
"x = np.arange(-10, 10, 0.1)\n",
"y = np.sinc(x) * np.sinc(x/5)\n",
"\n",
"plt.plot(x, y) # 绘制三次函数曲线\n",
"plt.show() # 显示创建的绘图对象"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font face='楷体' color='red' size=5> 练一练 </font>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"参考上述代码，绘制-10到10之间，$y=x^3$的曲线"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 补充你的代码\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"def f(x):\n",
" return 5*x**2-3*x-9\n",
"\n",
"\n",
"x = np.linspace(-10, 10)\n",
"y = [f(i) for i in x]\n",
"\n",
"plt.plot(x, y) # 绘制三次函数曲线\n",
"plt.show() # 显示创建的绘图对象"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 函数绘图"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NumPy还提供了sin()、cos()、tan()等三角函数及反三角函数，exp()、log()等指数与对数函数，add()、power()、sqrt()和mod()等数学运算函数，这些函数可接受列表或数组为参数，返回包括系列函数值的数组。\n",
"下面利用np.linspace()产生包含50个x值的数组，利用np.sin()和np.cos()分别计算得到50个y值，绘制平滑的正余弦曲线图。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt # 导入pyplot子库命名为plt\n",
"import numpy as np # 导入numpy库命名为np\n",
"\n",
"x_arr = np.linspace(0, 2*np.pi) # 0到2pi之间产生50个等间距的点的数组\n",
"sin_arr = np.sin(x_arr) # 根据x值计算50个sin(x)值，数组类型\n",
"cos_arr = np.cos(x_arr) # 根据x值计算50个cos(x)值，数组类型\n",
"\n",
"plt.plot(x_arr, sin_arr) # 根据坐标 x, sin_lsx 值绘sin(x)曲线图\n",
"plt.plot(x_arr, cos_arr) # 根据坐标 x, cos_lsx 值绘cos(x)曲线图\n",
"plt.show() # 显示绘制结果\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"\n",
"def plot_sin_cos(x): \n",
" sin_x = np.sin(x) # 生成正弦值的数组\n",
" cos_x = np.cos(x) # 生成余弦值的数组\n",
"\n",
" plt.plot(x, sin_x) # 绘制正弦函数曲线\n",
" plt.plot(x, cos_x) # 绘制余弦函数曲线\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi) # [0,2pi)，产生50个点为的等差数组\n",
" plot_sin_cos(x_data)\n",
" plt.show() # 显示创建的绘图对象\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"\n",
"t = np.linspace(-np.pi, np.pi, 201)\n",
"x = np.sin(9 * t + np.pi/2)\n",
"y = np.sin(8 * t)\n",
"\n",
"plt.plot(x, y) # 绘制函数曲线\n",
"plt.show() # 显示创建的绘图对象"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font face='楷体' color='red' size=5> 练一练 </font>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"绘制正切函数曲线"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 补充你的代码\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<font face='楷体' color='red' size=5> 练一练 </font>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"绘制-pi/2到pi/2之间正弦函数曲线和-1到1之间反正弦函数曲线"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 补充你的代码\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 标注与美化"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Matplotlib中支持对曲线进行各种标注与美化，规定线条颜色、线型、线标识、图名等操作。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"plot([x], y, [fmt]) # 绘制单条曲线\n",
"plot([x], y, [fmt], [x2], y2, [fmt2], ...) # 同时绘制多条曲线"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"x,y：参数x,y可为数组类型数据或标量 \n",
"fmt：表示线条颜色、标记和线型的格式的字符串类型可选参数 \n",
"fmt = '[color][marker][line]' \n",
"例如'go--'表示颜色为“green”、标记为“o”（圆点）、线型为破折线 \n",
"等价于“color= 'green', marker='*', linestyle= '--'”"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(x, y, 'go--') # 'go--'等价于color='green', marker='o', linestyle='dashed'\n",
"plt.plot(x, y, color='green', marker='o', linestyle='dashed')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"plot()还可以通过以下参数设置线条属性："
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"线条属性：\n",
"\n",
"| 属性 | 描述 |\n",
"| :---- | :---- |\n",
"| `color`或 c | 颜色 |\n",
"| `label` | 曲线标识 |\n",
"| `linestyle` 或 ls | 线型 |\n",
"| `linewidth` 或 lw | 线宽度 |\n",
"| `marker` | 数据点标记 |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"线条风格（linestyle或ls）\n",
"\n",
"| 线条风格 | 符号|描述| \n",
"| :---- | :---- | :---- | \n",
"|'solid' | - |实线 |\n",
"|'dashed' | -- |破折线 |\n",
"|'dotted' | : |虚线 |\n",
"|'dashdot'| -. |点划线 |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src=\"images/ch9/1.png\" width = '800'>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(x, y, '--') \n",
"plt.plot(x, y, linestyle='--')\n",
"plt.plot(x, y, linestyle='dashed')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"线条颜色（color 或 c）\n",
"\n",
"| color | 别名 | 颜色 | color | 别名 | 颜色 |\n",
"| :---- | :---- | :---- | :---- | :---- | :---- |\n",
"| blue | b | 蓝色 | green | g | 绿色 |\n",
"| red | r | 红色 | yellow | y | 黄色 |\n",
"| cyan | c | 青色 | black | k | 黑色 |\n",
"| magenta | m | 洋红色 | white | w | 白色 |"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(x, y, 'g') # 'g'等价于color='green'l\n",
"plt.plot(x, y, color='green')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"常用线条标记（marker）\n",
"\n",
"| 标记 | 描述 | 标记 | 描述 |\n",
"| :---- | :---- | :---- | :---- |\n",
"| “,” | 像素 | “>” | 右三角形 |\n",
"| “. ” | 点 | “<” | 左三角形 |\n",
"| “o” | 圆 | “v” | 倒三角形 |\n",
"| “D” | 菱形 | “^” | 正三角形 |\n",
"| “d” | 小菱形 | “1” | 正三分支 |\n",
"| “s” | 正方形 | “2” | 倒三分支 |\n",
"| “p” | 五边形 | “3” | 左三分支 |\n",
"| “h” | 六边形 | “4” | 右三分支 |\n",
"| “H” | 六边形 | “*” | 星号 |\n",
"| “8” | 八边形 | “+” | 加号 |\n",
"| “|” | 竖直线 | “P” | 填充的加号 |\n",
"| “_” | 水平线 | “x” | 乘号 |\n",
"| “None”, “ ” , “” | 无标记 | '$...$' | 字符串转为数学文本描述 |\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(x, y, 'o-') # marker单用时无线，需指定线型\n",
"plt.plot(x, y, marker='o')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"线条标记效果："
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src=\"images/ch9/2.png\" width = '800'>\n",
"<img src=\"images/ch9/3.png\" width = '800'>\n",
"<img src=\"images/ch9/4.png\" width = '800'>\n",
"<img src=\"images/ch9/5.png\" width = '800'>\n",
"<img src=\"images/ch9/6.png\" width = '800'>\n",
"<img src=\"images/ch9/7.png\" width = '800'>\n",
"<img src=\"images/ch9/8.png\" width = '800'>\n",
"<img src=\"images/ch9/9.png\" width = '800'>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 设置线型、宽度、颜色与标记"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"linewidth 或 lw：浮点数，线条宽度\n",
"label：设置用于显示的线的标签"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower left')\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" plt.show() # 显示创建的绘图对象\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"标签相关函数\n",
"\n",
"| 函数 | 描述 |\n",
"| :---- | :---- |\n",
"| title() | 为当前绘图添加标题 |\n",
"| legend() | 为当前绘图放置图注 |\n",
"| annotate() | 为指定数据点创建注释 |\n",
"| xlabel(s) | 设置x轴标签 |\n",
"| ylabel(s) | 设置y轴标签 |\n",
"| xticks() | 设置x轴刻度位置和标签 |\n",
"| yticks() | 设置y轴刻度位置和标签 |"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"matplotlib.pyplot.yticks(ticks=None, labels=None, **kwargs)\n",
"matplotlib.pyplot.xticks(ticks=None, labels=None, **kwargs)\n",
"\n",
"ticks: array-like, optional\n",
"labels:array-like, optional\n",
"\n",
"matplotlib.pyplot.axhline(y=0, xmin=0, xmax=1, **kwargs)\n",
"matplotlib.pyplot.axvline(x=0, ymin=0, ymax=1, **kwargs)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 设定图名与线条标注"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower left')\n",
"\n",
"\n",
"def draw_label():\n",
" plt.title('curve of sin and cos')\n",
" plt.xlabel('x')\n",
" plt.ylabel('y')\n",
"\n",
" \n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" draw_label()\n",
" plt.show() # 显示创建的绘图对象"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"坐标轴相关函数\n",
"\n",
"| 函数 | 描述 |\n",
"| :---- | :---- |\n",
"| xlim(xmin,xmax) | 设置当前x轴取值范围 |\n",
"| ylim(ymin,ymax) | 设置当前y轴取值范围 |\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"绘制直线相关函数\n",
"\n",
"| 函数 | 描述 |\n",
"| :---- | :---- |\n",
"| axhline(x=0, ymin=0, ymax=1) | 绘制水平线，y取值从0到1为整个区间。 |\n",
"| hlines() | 绘制水平线 |\n",
"| axvline(x=0, ymin=0, ymax=1) | 绘制垂直线，y取值从0到1为整个区间。 |\n",
"| vlines() | 绘制垂直线 |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 设定坐标轴上下限"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def draw_lim():\n",
" plt.ylim(-1.1, 1.1) # 设置纵轴的上下限\n",
" plt.yticks([-1, 0, +1]) # 设置纵轴刻度\n",
" plt.xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi],\n",
" [r'$0$', r'$\\pi/2$', r'$\\pi$', r'$3\\pi/2$', r'$2\\pi$']) # 转数学表示\n",
" plt.axhline(0, linestyle='--', color='black', linewidth=1) # 绘制水平线x轴,0可省\n",
" plt.axvline(0, linestyle='--', color='black', linewidth=1) # 绘制垂直线y轴,0可省\n"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"[0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi] 需要显示的标记点\n",
"\n",
"[r'$0$', r'$\\pi/2$', r'$\\pi$', r'$3\\pi/2$', r'$2\\pi$']\n",
"r 表示原生字符串\n",
"$$符号之间的字符串会转为数学表示"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"plt.rcParams['font.sans-serif'] = ['SimSun'] # 在此页面上只可用此字体，本地可以使用'FangSong'和Simhei等字体\n",
"plt.rcParams['axes.unicode_minus'] = False\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower left')\n",
"\n",
"\n",
"def draw_lim():\n",
" plt.ylim(-1.1, 1.1) # 设置纵轴的上下限\n",
" plt.yticks([-1, 0, +1]) # 设置纵轴刻度\n",
" plt.xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi],\n",
" [r'$0$', r'$\\pi/2$', r'$\\pi$', r'$3\\pi/2$', r'$2\\pi$']) # 转数学表示\n",
" plt.axhline(0, linestyle='--', color='black', linewidth=1) # 绘制水平线x轴,0可省\n",
" plt.axvline(0, linestyle='--', color='black', linewidth=1) # 绘制垂直线y轴,0可省\n",
" # plt.axvline(np.pi,linestyle='--', color='black', linewidth=1) # 绘制垂直线,pi\n",
"\n",
"\n",
"def draw_label():\n",
" plt.title('curve of sin and cos')\n",
" plt.xlabel('x')\n",
" plt.ylabel('y')\n",
"\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" draw_label()\n",
" draw_lim()\n",
" plt.show() # 显示创建的绘图\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"填充相关函数\n",
"\n",
"| 函数 | 描述 |\n",
"| :---- | :---- |\n",
"| axhspan() | 水平区域 |\n",
"| axvspan() | 竖直区域 |\n",
"| fill_between() | 填充两条曲线围起的区域，区间由横坐标限定 |\n",
"| fill_betweenx() | 填充两条曲线围起的区域，区间由纵坐标限定 |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 填充区域"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def fill_area(x):\n",
" \"\"\"填充pi/2与3*pi/2之间，x轴与cos(x)包围的区域\"\"\"\n",
" plt.fill_between(x, np.cos(x), where=((x >= np.pi / 2) & (x <= 3 * np.pi / 2)), facecolor='grey', alpha=0.25)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def fill_span_area():\n",
" \"\"\"填充x轴上方y值在(0.25,0.5)之间区域，绿色，透明度50%；\n",
" 填充x轴上方y值在(-0.5，-0.25)之间区域，绿色，透明度25%；\n",
" 填充x轴上方x值在(3*np.pi/2-0.3,3*np.pi/2+0.3)之间区域，红色，透明度25%\n",
" 填充x轴上方x值在(np.pi/2-0.3,np.pi/2+0.3)之间区域，红色，透明度50%\n",
" \"\"\"\n",
" # 整个区间为0，1.0，此例中0,0.5表示取x轴前半部分区间，0.5,1.0表示取后半部区间\n",
" plt.axhspan(0.25, 0.5, 0, 0.5, color='green', alpha=0.5)\n",
" plt.axhspan(-0.5, -0.25, color='green', alpha=0.25)\n",
" plt.axvspan(3 * np.pi / 2 - 0.3, 3 * np.pi / 2 + 0.3, color='red', alpha=0.25)\n",
" # 整个区间为0，1.0，此例中0.5，1.0表示取x轴上部区间，0，0.5表示取x轴下部区间\n",
" plt.axvspan(np.pi / 2 - 0.3, np.pi / 2 + 0.3, 0.5, 1.0, color='red', alpha=0.5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"plt.rcParams['font.sans-serif'] = ['SimSun'] # 在此页面上只可用此字体，本地可以使用'FangSong'和Simhei等字体\n",
"plt.rcParams['axes.unicode_minus'] = False\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower left')\n",
"\n",
"\n",
"def draw_lim():\n",
" plt.ylim(-1.1, 1.1) # 设置纵轴的上下限\n",
" plt.yticks([-1, 0, +1]) # 设置纵轴刻度\n",
" plt.xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi],\n",
" [r'$0$', r'$\\pi/2$', r'$\\pi$', r'$3\\pi/2$', r'$2\\pi$']) # 转数学表示\n",
" plt.axhline(0, linestyle='--', color='black', linewidth=1) # 绘制水平线x轴,0可省\n",
" plt.axvline(0, linestyle='--', color='black', linewidth=1) # 绘制垂直线y轴,0可省\n",
" # plt.axvline(np.pi,linestyle='--', color='black', linewidth=1) # 绘制垂直线,pi\n",
"\n",
"\n",
"def draw_label():\n",
" plt.title('curve of sin and cos')\n",
" plt.xlabel('x')\n",
" plt.ylabel('y')\n",
"\n",
"\n",
"def fill_area(x):\n",
" \"\"\"填充pi/2与3*pi/2之间，x轴与cos(x)包围的区域\"\"\"\n",
" plt.fill_between(x, np.cos(x), where=((x >= np.pi / 2) & (x <= 3 * np.pi / 2)), facecolor='grey', alpha=0.25)\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" draw_label()\n",
" draw_lim()\n",
" fill_area(x_data)\n",
" plt.show() # 显示创建的绘图\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"plt.rcParams['font.sans-serif'] = ['SimSun'] # 在此页面上只可用此字体，本地可以使用'FangSong'和Simhei等字体\n",
"plt.rcParams['axes.unicode_minus'] = False\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower left')\n",
"\n",
"\n",
"def draw_lim():\n",
" plt.ylim(-1.1, 1.1) # 设置纵轴的上下限\n",
" plt.yticks([-1, 0, +1]) # 设置纵轴刻度\n",
" plt.xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi],\n",
" [r'$0$', r'$\\pi/2$', r'$\\pi$', r'$3\\pi/2$', r'$2\\pi$']) # 转数学表示\n",
" plt.axhline(0, linestyle='--', color='black', linewidth=1) # 绘制水平线x轴,0可省\n",
" plt.axvline(0, linestyle='--', color='black', linewidth=1) # 绘制垂直线y轴,0可省\n",
" # plt.axvline(np.pi,linestyle='--', color='black', linewidth=1) # 绘制垂直线,pi\n",
"\n",
"\n",
"def draw_label():\n",
" plt.title('curve of sin and cos')\n",
" plt.xlabel('x')\n",
" plt.ylabel('y')\n",
"\n",
"\n",
"def fill_span_area():\n",
" \"\"\"填充x轴上方y值在(0.25,0.5)之间区域，绿色，透明度50%；\n",
" 填充x轴上方y值在(-0.5，-0.25)之间区域，绿色，透明度25%；\n",
" 填充x轴上方x值在(3*np.pi/2-0.3,3*np.pi/2+0.3)之间区域，红色，透明度25%\n",
" 填充x轴上方x值在(np.pi/2-0.3,np.pi/2+0.3)之间区域，红色，透明度50%\n",
" \"\"\"\n",
" # 整个区间为0，1.0，此例中0,0.5表示取x轴前半部分区间，0.5,1.0表示取后半部区间\n",
" plt.axhspan(0.25, 0.5, 0, 0.5, color='green', alpha=0.5)\n",
" plt.axhspan(-0.5, -0.25, color='green', alpha=0.25)\n",
" plt.axvspan(3 * np.pi / 2 - 0.3, 3 * np.pi / 2 + 0.3, color='red', alpha=0.25)\n",
" # 整个区间为0，1.0，此例中0.5，1.0表示取x轴上部区间，0，0.5表示取x轴下部区间\n",
" plt.axvspan(np.pi / 2 - 0.3, np.pi / 2 + 0.3, 0.5, 1.0, color='red', alpha=0.5)\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" draw_label()\n",
" draw_lim()\n",
" fill_span_area()\n",
" plt.show() # 显示创建的绘图\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"保存与显示相关函数\n",
"\n",
"| 函数 | 描述 |\n",
"| :---- | :---- |\n",
"| savefig('文件名') | 保存绘制的图像，必须置于绘制完成之后和show()之前<br />需先pip install pillow库 |\n",
"| show() | 显示绘制的图像，同时清空缓冲区 |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 保存图片文件"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"注意：savefig()函数必须置于绘制完成之后和show()之前"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower left')\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" plt.savefig('sin_cos.jpg')\n",
" plt.show() # 显示创建的绘图对象"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 中文显示--rc参数"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"matplotlib默认字体由一组rcParams控制，默认使用安装在用户计算机上的英文字体系列，如Helvetica, Times等，中文无法正常显示。 \n",
"可以通过设置rcParams参数值来修改用于显示的中文字体。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"在此页面上<font color=Red>__只可用SimSun__</font>字体，本地可以使用<font color=Red>__'FangSong'和Simhei等__</font>字体"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"| **序号** | **属性** | **说明** |\n",
"| :---- | :---- | :---- |\n",
"| 1 | plt.rcParams[**'**axes.unicode_minus**'**] = False | 字符显示 |\n",
"| 2 | plt.rcParams[**'**font.sans-serif**'**] = **'**SimHei**'** | 设置字体 |\n",
"| 3 | plt.rcParams[**'**lines.linestyle**'**] = **'**-.** '** | 线条样式 |\n",
"| 4 | plt.rcParams[**'**lines.linewidth**'**] = 3 | 线条宽度 |\n",
"| 5 | plt.rcParams[**'**lines.color**'**] = **'**blue**'** | 线条颜色 |\n",
"| 6 | plt.rcParams[**'**lines.marker**'**] = None | 默认标记 |\n",
"| 7 | plt.rcParams[**'**lines.markersize**'**] = 6 | 标记大小 |\n",
"| 8 | plt.rcParams[**'**lines.markeredgewidth**'**] = 0.5 | 标记附近的线宽 |\n",
"| 9 | plt.rcParams[**'**xtick.labelsize**'**] | 横轴字体大小 |\n",
"| 10 | plt.rcParams[**'**ytick.labelsize**'**] | 纵轴字体大小 |\n",
"| 11 | plt.rcParams[**'**xtick.major.size**'**] | x轴最大刻度 |\n",
"| 12 | plt.rcParams[**'**ytick.major.size**'**] | y轴最大刻度 |\n",
"| 13 | plt.rcParams[**'**axes.titlesize**'**] | 子图的标题大小 |\n",
"| 14 | plt.rcParams[**'**axes.labelsize**'**] | 子图的标签大小 |\n",
"| 15 | plt.rcParams[**'**figure.dpi**'**] | 图像分辨率 |\n",
"| 16 | plt.rcParams[**'**figure.figsize**'**] | 图像显示大小 |\n",
"| 17 | plt.rcParams[**'**savefig.dpi**'**] | 图片像素 |"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.rcParams['font.sans-serif'] = ['SimSun'] # 宋体\n",
"# Mac下面用：Heiti TC、Songti SC或Arial Unicode MS\n",
"plt.rcParams['axes.unicode_minus'] = False\n",
"# 解决保存图像是负号'-'显示为方块的问题\n"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"在需要显示中文的语句中fontproperties指定字体（不是所有plt方法都支持此属性）"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.title('正弦余弦图像',fontproperties=\"SimSun\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"plt.rcParams['font.sans-serif'] = ['SimSun'] # 宋体\n",
"plt.rcParams['axes.unicode_minus'] = False\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower left')\n",
"\n",
"\n",
"def draw_label():\n",
" plt.title('正弦余弦函数曲线')\n",
" # plt.title('正弦余弦图像',fontproperties=\"SimSun\") # 可以在语句中指定中文字体\n",
" plt.xlabel('x(弧度)')\n",
" plt.ylabel('y')\n",
"\n",
" \n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" draw_label()\n",
" plt.show() # 显示创建的绘图对象"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 数据点标注"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"matplotlib.pyplot.annotate(text, xy, *args, **kwargs)\n",
"参数：\n",
"text：str，标注的文本\n",
"\n",
"xy：(float, float)，(横坐标，纵坐标) 箭头尖端，需要加标注的点的坐标\n",
"\n",
"xytext：(float, float), 缺省为 xy，(横坐标，纵坐标) 放置标注文本的点的坐标 (x, y) \n",
"\n",
"xycoords：被注释点的坐标系属性\n",
"\n",
"textcoords ：注释文本的坐标系属性，默认与xycoords属性值相同，允许输入以下两种：\n",
" 'offset points'相对于被注释点xy的偏移量（单位是点）\n",
" 'offset pixels'相对于被注释点xy的偏移量（单位是像素）\n",
" \n",
"arrowprops：箭头，字典类型，{facecolor= '颜色',shrink = '数字' <1 收缩箭头}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"plt.rcParams['font.sans-serif'] = ['SimSun'] # 在此页面上只可用此字体，本地可以使用'FangSong'和Simhei等字体\n",
"plt.rcParams['axes.unicode_minus'] = False\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower right')\n",
"\n",
"\n",
"def draw_lim():\n",
" plt.ylim(-1.1, 1.1) # 设置纵轴的上下限\n",
" plt.yticks([-1, 0, +1]) # 设置纵轴刻度\n",
" plt.xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi],\n",
" [r'$0$', r'$\\pi/2$', r'$\\pi$', r'$3\\pi/2$', r'$2\\pi$']) # 转数学表示\n",
" plt.axhline(0, linestyle='--', color='black', linewidth=1) # 绘制水平线x轴,0可省\n",
" plt.axvline(0, linestyle='--', color='black', linewidth=1) # 绘制垂直线y轴,0可省\n",
" # plt.axvline(np.pi,linestyle='--', color='black', linewidth=1) # 绘制垂直线,pi\n",
"\n",
"\n",
"def draw_label():\n",
" plt.title('正弦余弦函数曲线')\n",
" plt.xlabel('x(弧度)')\n",
" plt.ylabel('y')\n",
"\n",
"\n",
"def add_annotate_upper():\n",
" \"\"\"数据点标注\"\"\"\n",
" t = 2 * np.pi / 3\n",
" plt.plot([t, t], [0, np.sin(t)], color='red', linewidth=2.5, linestyle=\"--\") # 过(t,0),(t,sin(t))画线段，红色，破折线\n",
" plt.scatter([t, ], [np.cos(t), ], 50, color='blue') # 为 (t,cos(t))处画一个蓝色圆点\n",
" # 为 sin(t)处加注释\n",
" plt.annotate(r'$\\sin(\\frac{2\\pi}{3})=\\frac{\\sqrt{3}}{2}$',\n",
" xy=(t, np.sin(t)), xycoords='data',\n",
" xytext=(+30, 0), textcoords='offset points', fontsize=16,\n",
" arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"arc3,rad=.2\"))\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" draw_label()\n",
" draw_lim()\n",
" add_annotate_upper()\n",
" plt.show() # 显示创建的绘图"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"plt.rcParams['font.sans-serif'] = ['SimSun'] # 在此页面上只可用此字体，本地可以使用'FangSong'和Simhei等字体\n",
"plt.rcParams['axes.unicode_minus'] = False\n",
"\n",
"\n",
"def plot_sin_cos(x):\n",
" sin_x = np.sin(x)\n",
" cos_x = np.cos(x)\n",
" plt.plot(x, cos_x, color=\"blue\", marker='o', linewidth=2, linestyle=\"-\", label=\"cos(x)\")\n",
" plt.plot(x, sin_x, color=\"red\", linewidth=2, linestyle=\"--\", label=\"sin(x)\")\n",
" # 绘制正弦曲线，使用红色的、破折线，宽度为 2 像素的线条\n",
" plt.legend(loc='lower right')\n",
"\n",
"\n",
"def draw_lim():\n",
" plt.ylim(-1.1, 1.1) # 设置纵轴的上下限\n",
" plt.yticks([-1, 0, +1]) # 设置纵轴刻度\n",
" plt.xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi],\n",
" [r'$0$', r'$\\pi/2$', r'$\\pi$', r'$3\\pi/2$', r'$2\\pi$']) # 转数学表示\n",
" plt.axhline(0, linestyle='--', color='black', linewidth=1) # 绘制水平线x轴,0可省\n",
" plt.axvline(0, linestyle='--', color='black', linewidth=1) # 绘制垂直线y轴,0可省\n",
" # plt.axvline(np.pi,linestyle='--', color='black', linewidth=1) # 绘制垂直线,pi\n",
"\n",
"\n",
"def draw_label():\n",
" plt.title('正弦余弦函数曲线')\n",
" plt.xlabel('x(弧度)')\n",
" plt.ylabel('y')\n",
"\n",
"\n",
"def add_annotate_lower():\n",
" \"\"\"数据点标注\"\"\"\n",
" t = 2 * np.pi / 3\n",
" plt.plot([t, t], [0, np.cos(t)], color='blue', linewidth=2.5, linestyle=\"--\") # 过(t,0),(t,cos(t))画线段，蓝色，破折线\n",
" plt.scatter([t, ], [np.sin(t), ], 50, color='red') # 为 (t,sin(t))处画一个红色圆点\n",
" # 为 cos(t)处加注释\n",
" plt.annotate(r'$\\cos(\\frac{2\\pi}{3})=-\\frac{1}{2}$',\n",
" xy=(t, np.cos(t)), xycoords='data',\n",
" xytext=(-90, -50), textcoords='offset points', fontsize=16,\n",
" arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"arc3,rad=.2\"))\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_data = np.linspace(0, 2 * np.pi)\n",
" plot_sin_cos(x_data)\n",
" draw_label()\n",
" draw_lim()\n",
" add_annotate_lower()\n",
" plt.show() # 显示创建的绘图"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 绘制多子图"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Matplotlib提供将同一画布划分成多个子区域的方法，可以将多个图形在同一个画布上不同区域绘制。可应用subplot()函数实现，使用语法如下："
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"subplot(nrows, ncols, index, **kwargs)\n",
"subplot(pos, **kwargs)\n",
"subplot(**kwargs)\n",
"subplot(ax)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"参数nrows, ncols, index分别表示行数、列数和序号。 \n",
"当前画布被划分为nrows×ncols个子区域，index表示当前图绘制在第index个子区域。 \n",
"当行数、列数和序号全部小于10时，也可以将三个数字合并成一个三位数字来表示。 \n",
"例如subplot(2, 3, 3) 和subplot(233) 都可以创建一个2行3列的绘图区域，当前图占用序号为3的区域。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"将一个画布分三个子图区域，第一行分两个子图，分别绘制正弦和余弦函数曲线，第二行为一个子图区域，绘制函数sin(6x)的曲线。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt # 导入pyplot子库命名为plt\n",
"import numpy as np # 导入numpy库命名为np\n",
"\n",
"x_arr = np.linspace(0, 2*np.pi, 256) # 0到2pi之间产生256个等间距的点的数组\n",
"sin_arr = np.sin(x_arr) # 根据x值计算50个sin(x)值，数组类型\n",
"cos_arr = np.cos(x_arr) # 根据x值计算50个cos(x)值，数组类型\n",
"plt.subplot(2, 2, 1) # 分成2行2列，占用第1个位置\n",
"plt.plot(x_arr, sin_arr, '--r', lw=2) # 红色破折线\n",
"plt.subplot(2, 2, 2) # 分成2行2列，占用第2个\n",
"plt.plot(x_arr, cos_arr, ':g') # 绿色虚线\n",
"plt.subplot(2, 1, 2) # 分成2行1列，占用第2个\n",
"plt.plot(x_arr, np.sin(6*x_arr), '-b', lw=2) # y=\"sin(6x)\"函数曲线\n",
"plt.show() # 显示绘制结果"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 用函数实现结构更清晰\n",
"\n",
"import matplotlib.pyplot as plt # 导入pyplot子库命名为plt\n",
"import numpy as np # 导入numpy库命名为np\n",
"\n",
"def sub_plot():\n",
" plt.subplot(2, 2, 1) # 分成2行2列，占用第1个位置\n",
" plt.plot(x_arr, sin_arr, '--r', lw=2) # 红色破折线\n",
" plt.subplot(2, 2, 2) # 分成2行2列，占用第2个\n",
" plt.plot(x_arr, cos_arr, ':g') # 绿色虚线\n",
" plt.subplot(2, 1, 2) # 分成2行1列，占用第2个\n",
" plt.plot(x_arr, np.sin(6*x_arr), '-b', lw=2) # y=\"sin(6x)\"函数曲线\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" x_arr = np.linspace(0, 2 * np.pi, 256) # 0到2pi之间产生256个等间距的点的数组\n",
" sin_arr = np.sin(x_arr) # 根据x值计算50个sin(x)值，数组类型\n",
" cos_arr = np.cos(x_arr) # 根据x值计算50个cos(x)值，数组类型\n",
" sub_plot()\n",
" plt.show() # 显示绘制结果"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
