python基础

Posted on | In | | Visitors:

NumPy

NumPy Ndarray对象

1
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
参数说明
名称 描述
object 数组或嵌套的数列
dtype 数组元素的数据类型，可选
copy 对象是否需要复制，可选
order 创建数组的样式，C为行方向，F为列方向，A为默认方向
subok 默认返回一个与基类类型一致的数组
ndmin 指定生成数组的最小维度

NumPy数据类型

bool_ 布尔型数据类型（True 或者 False）
int_ 默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc 与 C 的 int 类型一样，一般是 int32 或 int 64
intp 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8 字节（-128 to 127）
int16 整数（-32768 to 32767）
int32 整数（-2147483648 to 2147483647）
int64 整数（-9223372036854775808 to 9223372036854775807）
uint8 无符号整数（0 to 255）
uint16 无符号整数（0 to 65535）
uint32 无符号整数（0 to 4294967295）
uint64 无符号整数（0 to 18446744073709551615）
float_ float64 类型的简写
float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_ complex128 类型的简写，即 128 位复数
complex64 复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128 复数，表示双 64 位浮点数（实数部分和虚数部分）

数据类型对象

数据类型对象是用来描述与数组对应的内存区域如何使用，这依赖如下几个方面：

  • 数据的类型（整数，浮点数或者 Python 对象）
  • 数据的大小（例如， 整数使用多少个字节存储）
  • 数据的字节顺序（小端法或大端法）
  • 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
  • 如果数据类型是子数组，它的形状和数据类型

字节顺序是通过对数据类型预先设定”<”或”>”来决定的。”<”意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。”>”意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。

dtype 对象是使用以下语法构造的：
numpy.dtype(object, align, copy)
object - 要转换为的数据类型对象
align - 如果为 true，填充字段使其类似 C 的结构体。
copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

每个内建类型都有一个唯一定义它的字符代码，如下：

字符 对应类型
b 布尔型
i (有符号) 整型
u 无符号整型 integer
f 浮点型
c 复数浮点型
m timedelta（时间间隔）
M datetime（日期时间）
O (Python) 对象
S, a (byte-)字符串
U Unicode
V 原始数据 (void)

NumPy数组

NumPy 的数组中比较重要 ndarray 对象属性

属性 说明
ndarray.ndim 秩，即轴的数量或维度的数量
ndarray.shape 数组的维度，对于矩阵，n 行 m 列
ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype ndarray 对象的元素类型
ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags ndarray 对象的内存信息
ndarray.real ndarray元素的实部
ndarray.imag ndarray 元素的虚部
ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

数组创建

1
2
3
4
numpy.empty(shape, dtype = float, order = 'C')# 数组元素随机
numpy.zeros(shape, dtype = float, order = 'C')# 数组元素以0填充
numpy.ones(shape, dtype = None, order = 'C')# 数组元素以1填充
numpy.asarray(a, dtype = None, order = None)# 从已有数组创建

参数说明：

参数 描述
shape 数组形状
dtype 数据类型，可选
order 有”C”和”F”两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
a 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 
1
2
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
# 用于实现动态数组,接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

参数说明：

参数 描述
buffer 可以是任意对象，会以流的形式读入。
dtype 返回数组的数据类型，可选
count 读取的数据数量，默认为-1，读取所有数据。
offset 读取的起始位置，默认为0。 
1
2
numpy.arange(start, stop, step, dtype)
# 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

NumPy切片和索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import numpy as np
a = np.arange(10)
# 从索引 2 开始到索引 7 停止，间隔为2
s = slice(2,7,2)
# 也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作
b = a[2:7:2]
print (a[s])
print(b)


输出结果为
[2  4  6]

# 冒号的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。
# 如果为 [2:]，表示从该索引开始以后的所有项都将被提取。
# 如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素


输出结果为：
[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

NumPy迭代数组

NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
迭代器最基本的任务的可以完成对数组元素的访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
 
a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('\n')
print ('迭代输出元素：')
for x in np.nditer(a):
    print (x, end=", " )
print ('\n')

输出结果为：

原始数组是：
[[0 1 2]
 [3 4 5]]


迭代输出元素：
0, 1, 2, 3, 4, 5,

控制遍历顺序

1
2
3
4
for x in np.nditer(a, order='F'):
# Fortran order，即是列序优先；
for x in np.nditer(a.T, order='C'):
# C order，即是行序优先；

修改数组中元素的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import numpy as np
 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：')
print (a)
print ('\n')
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x 
print ('修改后的数组是：')
print (a)


输出结果为：

原始数组是：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


修改后的数组是：
[[  0  10  20  30]
 [ 40  50  60  70]
 [ 80  90 100 110]]

Numpy数组操作

修改数组形状

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： 

1
numpy.reshape(arr, newshape, order='C')
  • arr：要修改形状的数组
  • newshape：整数或者整数数组，新的形状应当兼容原有形状
  • order：’C’ — 按行，’F’ — 按列，’A’ — 原顺序，’k’ — 元素在内存中的出现顺序。

numpy.ndarray.flat是一个数组元素迭代器

1
2
for element in a.flat:
    print (element)

numpy.ndarray.flatten 返回一份数组拷贝（展开），对拷贝所做的修改不会影响原始数组

1
ndarray.flatten(order='C')
  • order：’C’ — 按行，’F’ — 按列，’A’ — 原顺序，’K’ — 元素在内存中的出现顺序。

numpy.ravel 展平的数组元素，顺序通常是”C风格”，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

1
numpy.ravel(a, order='C')
  • order：’C’ — 按行，’F’ — 按列，’A’ — 原顺序，’K’ — 元素在内存中的出现顺序。

翻转数组

numpy.transpose 函数用于对换数组的维度

1
numpy.transpose(arr, axes)
  • arr：要操作的数组
  • axes：整数列表，对应维度，通常所有维度都会对换。

numpy.ndarray.T 类似 numpy.transpose
numpy.rollaxis 函数向后滚动特定的轴到一个特定位置

1
numpy.rollaxis(arr, axis, start)
  • arr：数组
  • axis：要向后滚动的轴，其它轴的相对位置不会改变
  • start：默认为零，表示完整的滚动。会滚动到特定位置。

numpy.swapaxes 函数用于交换数组的两个轴。

1
numpy.swapaxes(arr, axis1, axis2)
  • arr：输入的数组
  • axis1：对应第一个轴的整数
  • axis2：对应第二个轴的整数

修改数组维度

numpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。

1
b = np.broadcast(x,y)

numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。

1
numpy.broadcast_to(array, shape, subok)

numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状

1
numpy.expand_dims(arr, axis)
  • arr：输入数组
  • axis：新轴插入的位置

numpy.squeeze 函数从给定数组的形状中删除一维的条目

1
numpy.squeeze(arr, axis)
  • arr：输入数组
  • axis：整数或整数元组，用于选择形状中一维条目的子集

连接数组

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组

1
numpy.concatenate((a1, a2, ...), axis)
  • a1, a2, …：相同类型的数组
  • axis：沿着它连接数组的轴，默认为 0

numpy.stack 函数用于沿新轴连接数组序列

1
numpy.stack(arrays, axis)
  • arrays相同形状的数组序列
  • axis：返回数组中的轴，输入数组沿着它来堆叠

分割数组

numpy.split 函数沿特定的轴将数组分割为子数组

1
numpy.split(ary, indices_or_sections, axis)
  • ary：被分割的数组
  • indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
  • axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。

数组元素的添加与删除

numpy.resize 函数返回指定大小的新数组。如果新数组大小大于原始大小，则包含原始数组中的元素的副本。

1
numpy.resize(arr, shape)
  • arr：要修改大小的数组
  • shape：返回数组的新形状

numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。append 函数返回的始终是一个一维数组。

1
numpy.append(arr, values, axis=None)
  • arr：输入数组
  • values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
  • axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。

numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。

1
numpy.insert(arr, obj, values, axis)
  • arr：输入数组
  • obj：在其之前插入值的索引
  • values：要插入的值
  • axis：沿着它插入的轴，如果未提供，则输入数组会被展开

numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

1
Numpy.delete(arr, obj, axis)
  • arr：输入数组
  • obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
  • axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

numpy.unique 函数用于去除数组中的重复元素。

1
numpy.unique(arr, return_index, return_inverse, return_counts)
  • arr：输入数组，如果不是一维数组则会展开
  • return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
  • return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
  • return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

NumPy 字符串函数

以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。
这些函数在字符数组类（numpy.char）中定义。

函数 描述
add() 对两个数组的逐个字符串元素进行连接
multiply() 返回按元素多重连接后的字符串
center() 居中字符串
capitalize() 将字符串第一个字母转换为大写
title() 将字符串的每个单词的第一个字母转换为大写
lower() 数组元素转换为小写
upper() 数组元素转换为大写
split() 指定分隔符对字符串进行分割，并返回数组列表
splitlines() 返回元素中的行列表，以换行符分割
strip() 移除元素开头或者结尾处的特定字符
join() 通过指定分隔符来连接数组中的元素
replace() 使用新字符串替换字符串中的所有子字符串
decode() 数组元素依次调用str.decode
encode() 数组元素依次调用str.encode

NumPy 函数

三角函数

NumPy 提供了标准的三角函数：sin()、cos()、tan()。
arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。
这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度。

算数函数

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。
需要注意的是数组必须具有相同的形状或符合数组广播规则。
numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。
numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

统计函数

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
numpy.median() 函数用于计算数组 a 中元素的中位数（中值）。
numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。算术平均值是沿轴的元素的总和除以元素的数量。
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。
numpy.std() 函数用于计算数组的标准差
numpy.var() 函数用于计算数组的方差

NumPy 矩阵库(Matrix)

NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。
NumPy 中除了可以使用 numpy.transpose 函数来对换数组的维度，还可以使用 T 属性。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('转置数组：')
print (a.T)

输出结果如下：

原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


转置数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

1
2
3
4
numpy.matlib.empty(shape, dtype, order)# 填充为随机数据
numpy.matlib.rand()# 函数创建一个给定大小的矩阵，数据是随机填充的。
np.matlib.zeros(shape)# 以 0 填充
np.matlib.ones(shape)# 以 1 填充
  • shape: 定义新矩阵形状的整数或整数元组
  • dtype: 可选，数据类型
  • order: C（行序优先） 或者 F（列序优先）
1
2
numpy.matlib.eye(n, M,k, dtype)# 返回一个矩阵，对角线元素为 1，其他位置为零。
numpy.matlib.identity(n, dtype)# 函数返回给定大小的单位矩阵。
  • n: 返回矩阵的行数
  • M: 返回矩阵的列数，默认为 n
  • k: 对角线的索引
  • dtype: 数据类型

NumPy 线性代数

函数 描述
dot 两个数组的点积，即元素对应相乘。
vdot 两个向量的点积
inner 两个数组的内积
matmul 两个数组的矩阵积
determinant 数组的行列式
solve 求解线性矩阵方程
inv 计算矩阵的乘法逆矩阵

NumPy IO

Numpy 可以读写磁盘上的文本数据或二进制数据。
NumPy 为 ndarray 对象引入了一个简单的文件格式：npy。
npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。
常用的 IO 函数有：

  • load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。
  • savze() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。
  • loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)

numpy.save()

numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。

1
numpy.save(file, arr, allow_pickle=True, fix_imports=True)
  • file：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
  • arr: 要保存的数组
  • allow_pickle: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
  • fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。
1
2
3
4
5
6
7
8
9
import numpy as np 
 
a = np.array([1,2,3,4,5]) 
 
# 保存到 outfile.npy 文件上
np.save('outfile.npy',a) 
 
# 保存到 outfile2.npy 文件上，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上
np.save('outfile2',a)

np.savez()

numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。

1
numpy.savez(file, *args, **kwds)
  • file：要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上。
  • args: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …　。
  • kwds: 要保存的数组使用关键字名称。
1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np 
 
a = np.array([[1,2,3],[4,5,6]])
b = np.arange(0, 1.0, 0.1)
c = np.sin(b)
# c 使用了关键字参数 sin_array
np.savez("runoob.npz", a, b, sin_array = c)
r = np.load("runoob.npz")  
print(r.files) # 查看各个数组名称
print(r["arr_0"]) # 数组 a
print(r["arr_1"]) # 数组 b
print(r["sin_array"]) # 数组 c

savetxt()

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。

1
2
np.loadtxt(FILENAME, dtype=int, delimiter=' ')
np.savetxt(FILENAME, a, fmt="%d", delimiter=",")

参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。

Matplotlib

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。

基本内容

1
2
3
4
5
6
7
8
9
10
import numpy as np 
from matplotlib import pyplot as plt 
 
x = np.arange(1,11) 
y =  2  * x +  5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y) 
plt.show()

subplot() 函数允许你在同一图中绘制不同的东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import numpy as np 
import matplotlib.pyplot as plt 
# 计算正弦和余弦曲线上的点的 x 和 y 坐标 
x = np.arange(0,  3  * np.pi,  0.1) 
y_sin = np.sin(x) 
y_cos = np.cos(x)  
# 建立 subplot 网格，高为 2，宽为 1  
# 激活第一个 subplot
plt.subplot(2,  1,  1)  
# 绘制第一个图像 
plt.plot(x, y_sin) 
plt.title('Sine')  
# 将第二个 subplot 激活，并绘制第二个图像
plt.subplot(2,  1,  2) 
plt.plot(x, y_cos) 
plt.title('Cosine')  
# 展示图像
plt.show()

散点图

1
2
3
4
5
6
7
8
from pylab import *

n = 1024
X = np.random.normal(0,1,n)
Y = np.random.normal(0,1,n)

scatter(X,Y)
show()

条形图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pylab import *

n = 12
X = np.arange(n)
Y1 = (1-X/float(n)) * np.random.uniform(0.5,1.0,n)
Y2 = (1-X/float(n)) * np.random.uniform(0.5,1.0,n)

bar(X, +Y1, facecolor='#9999ff', edgecolor='white')
bar(X, -Y2, facecolor='#ff9999', edgecolor='white')

for x,y in zip(X,Y1):
    text(x+0.4, y+0.05, '%.2f' % y, ha='center', va= 'bottom')

ylim(-1.25,+1.25)
show()

等高线图

1
2
3
4
5
6
7
8
9
10
11
12
from pylab import *

def f(x,y): return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)

n = 256
x = np.linspace(-3,3,n)
y = np.linspace(-3,3,n)
X,Y = np.meshgrid(x,y)

contourf(X, Y, f(X,Y), 8, alpha=.75, cmap='jet')
C = contour(X, Y, f(X,Y), 8, colors='black', linewidth=.5)
show()

灰度图

1
2
3
4
5
6
7
8
9
from pylab import *

def f(x,y): return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)

n = 10
x = np.linspace(-3,3,4*n)
y = np.linspace(-3,3,3*n)
X,Y = np.meshgrid(x,y)
imshow(f(X,Y)), show()

饼状图

1
2
3
4
5
from pylab import *

n = 20
Z = np.random.uniform(0,1,n)
pie(Z), show()

3D 图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from pylab import *
from mpl_toolkits.mplot3d import Axes3D

fig = figure()
ax = Axes3D(fig)
X = np.arange(-4, 4, 0.25)
Y = np.arange(-4, 4, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='hot')

show()

具体配置

默认配置

1
2
3
4
5
6
7
8
9
10
import numpy as np
import matplotlib.pyplot as plt

X = np.linspace(-np.pi, np.pi, 256, endpoint=True)
C,S = np.cos(X), np.sin(X)

plt.plot(X,C)
plt.plot(X,S)

plt.show()

默认配置的具体内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 导入 matplotlib 的所有内容（nympy 可以用 np 这个名字来使用）
from pylab import *

# 创建一个 8 * 6 点（point）的图，并设置分辨率为 80
figure(figsize=(8,6), dpi=80)

# 创建一个新的 1 * 1 的子图，接下来的图样绘制在其中的第 1 块（也是唯一的一块）
subplot(1,1,1)

X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
C,S = np.cos(X), np.sin(X)

# 绘制余弦曲线，使用蓝色的、连续的、宽度为 1 （像素）的线条
plot(X, C, color="blue", linewidth=1.0, linestyle="-")

# 绘制正弦曲线，使用绿色的、连续的、宽度为 1 （像素）的线条
plot(X, S, color="green", linewidth=1.0, linestyle="-")

# 设置横轴的上下限
xlim(-4.0,4.0)

# 设置横轴记号
xticks(np.linspace(-4,4,9,endpoint=True))

# 设置纵轴的上下限
ylim(-1.0,1.0)

# 设置纵轴记号
yticks(np.linspace(-1,1,5,endpoint=True))

# 以分辨率 72 来保存图片
# savefig("exercice_2.png",dpi=72)

# 在屏幕上显示
show()

改变线条的颜色和粗细

1
2
3
figure(figsize=(10,6), dpi=80)
plot(X, C, color="blue", linewidth=2.5, linestyle="-")
plot(X, S, color="red",  linewidth=2.5, linestyle="-")

设置图片边界

1
2
3
4
5
6
7
8
xmin ,xmax = X.min(), X.max()
ymin, ymax = Y.min(), Y.max()

dx = (xmax - xmin) * 0.2
dy = (ymax - ymin) * 0.2

xlim(xmin - dx, xmax + dx)
ylim(ymin - dy, ymax + dy)

设置记号

1
2
xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
yticks([-1, 0, +1])

设置记号的标签

1
2
3
4
5
6
# 可以使用LaTeX
xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
       [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])

yticks([-1, 0, +1],
       [r'$-1$', r'$0$', r'$+1$'])

移动坐标轴

1
2
3
4
5
6
7
ax = gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))

添加图例

1
2
3
4
plot(X, C, color="blue", linewidth=2.5, linestyle="-", label="cosine")
plot(X, S, color="red",  linewidth=2.5, linestyle="-", label="sine")

legend(loc='upper left')

给一些特殊点做注释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
t = 2*np.pi/3
plot([t,t],[0,np.cos(t)], color ='blue', linewidth=2.5, linestyle="--")
scatter([t,],[np.cos(t),], 50, color ='blue')

annotate(r'$\sin(\frac{2\pi}{3})=\frac{\sqrt{3}}{2}$',
         xy=(t, np.sin(t)), xycoords='data',
         xytext=(+10, +30), textcoords='offset points', fontsize=16,
         arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

plot([t,t],[0,np.sin(t)], color ='red', linewidth=2.5, linestyle="--")
scatter([t,],[np.sin(t),], 50, color ='red')

annotate(r'$\cos(\frac{2\pi}{3})=-\frac{1}{2}$',
         xy=(t, np.cos(t)), xycoords='data',
         xytext=(-90, -50), textcoords='offset points', fontsize=16,
         arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

格式化字符

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

颜色缩写

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

参考菜鸟教程

-------------本文结束感谢您的阅读-------------