Numpy
引入Numpy
获取并安装numpy包：
conda install numpy
或
pip install numpy
引入numpy:import numpy as np
空值: numpy.nan
e: numpy.e
圆周率: numpy.pi
正无穷大: numpy.inf
其他常量用到了再查
import numpy as np
创建ndarray数组对象
创建一个数组
numpy.array()
创建一个数组
np.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None) -> ndarray
参数说明：
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型(numpy的数据类型详见https://www.runoob.com/numpy/numpy-dtype.html) |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
arr1 = np.array([[12,3,4],
[23,4,67]], dtype = complex)
print(arr1)
[[12.+0.j 3.+0.j 4.+0.j]
[23.+0.j 4.+0.j 67.+0.j]]
创建一个空数组
numpy.empty()
创建一个空数组(其实是生成一个各个元素都十分接近0的数组)
numpy.empty(shape, dtype = float, order = 'C') -> ndarray
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
arr2 = np.empty((2,3))
print(arr2)
[[0. 0. 0.]
[0. 0. 0.]]
创建一个零数组
numpy.zeros()
创建一个零数组
numpy.zeros(shape, dtype = float, order = 'C') -> ndarray
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
arr3 = np.zeros((2,3))
print(arr3)
[[0. 0. 0.]
[0. 0. 0.]]
创建一个所有元素都为1的数组
numpy.ones()
创建指定形状的数组，数组元素以 1 来填充：
numpy.ones(shape, dtype = None, order = 'C') -> ndarray
同numpy.zeros()
从数值范围创建数组
numpy.arange()
从数值范围创建数组, 用于创建一个一维数组，使用 arange 函数创建数值范围并返回 ndarray 对象
numpy.arange(start, stop, step, dtype) -> ndarray
根据 start 与 stop 指定的范围（含左不含右）以及 step 设定的步长，生成一个 ndarray。
参数说明：
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
arr4 = np.arange(9, 3, -1).reshape((2,3))
print(arr4)
[[9 8 7]
[6 5 4]]
创建一个等差数列构成的数组
numpy.linspace()
从数值范围创建数组,用于创建一个一维数组，数组是一个
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) -> ndarray
参数说明：
| 参数 | 描述 |
|---|---|
| start | 序列的起始值 |
| stop | 序列的终止值，如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| retstep | 如果为 True 时，生成的数组中会显示间距，反之不显示。 |
| dtype | ndarray 的数据类型 |
print(np.linspace(1,10,10))
print(np.linspace(1,10,10, endpoint = False))
创建一个等比数列构成的数组
numpy.logspace()
从数值范围创建数组,用于创建一个一维数组，数组是一个等比数列构成的
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None) -> ndarray
参数说明：
| 参数 | 描述 |
|---|---|
| start | 序列的起始值为：base ** start |
| stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| base | 对数 log 的底数。 |
| dtype | ndarray 的数据类型 |
print (np.logspace(0,9,10))
print (np.logspace(0,9,10,base=2))
[1.e+00 1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09]
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
创建一个元素为随机数的数组
numpy.random.random()
创建一个指定size的数组，其元素由位于[0,1)的随机数组成
numpy.random.random(size: Any = None) -> ndarray
参数说明：
| 参数 | 描述 |
|---|---|
| size | 数组的形状 |
print(np.random.random((2,4)))
[[0.89708488 0.18298315 0.91853714 0.72948609]
[0.97949962 0.9876352 0.11712189 0.99488907]]
创建一个对角线元素是1，其余为0的数组
numpy.eye()
创建一个矩阵，对角线元素为 1，其他位置为零。
numpy.eye(N, M=None, k=0, dtype=float, order='C', *, like=None) -> ndarray
| 参数 | 描述 |
|---|---|
| N | 矩阵的行数 |
| M | 矩阵的列数，默认为 N |
| k | 对角线的索引 |
| dtype | 数据类型 |
| order | 储存方式，‘C’：行优先 (C-Fstyle) 或’F’：c列优先 (Fortran-style) |
print (np.eye(5, 7, dtype = float))
[[1. 0. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0.]
[0. 0. 1. 0. 0. 0. 0.]
[0. 0. 0. 1. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0.]]
创建一个单位阵
numpy.identity(n, dtype=None, *, like=None) -> ndarray
| 参数 | 描述 |
|---|---|
| n | 矩阵的行数 |
| dtype | 数据类型 |
从已有的数组创建数组：
numpy.asarray(a, dtype = None, order = None)
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
numpy.fromiter(iterable, dtype, count=-1)
详见https://www.runoob.com/numpy/numpy-array-from-existing-data.html
ndarray 重定义形状的方法
- ndarray.reshape()
ndarray.reshape(object, order='C') -> ndarray
从object传入一个数组（如(3,4)）将ndarray对象重新定义为该形状，如上面numpy.arange()的示例中就用到了该方法
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
- ndarray.flatten()
ndarray.flatten(order='C') -> ndarray
将数组转为一维行向量
参数说明:
| 参数 | 描述 |
|---|---|
| order | {‘C’, ‘F’, ‘A’, ‘K’} 可选的，指定折叠的顺序。'C’表示按照行优先（C风格）的顺序折叠。'F’表示按照列优先（Fortran风格）的顺序折叠。'A’表示如果a在内存中是Fortran连续的，就按照列优先的顺序折叠，否则按照行优先的顺序折叠。‘K’表示按照元素在内存中出现的顺序折叠。默认值是’C’。 |
注意:ndarray.flat是得到一个迭代每一个元素的迭代器
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 1 1]的shape是(3,)
[[1 1 1]]的shape是(3, 1)
两个数组的shape并不相同
我们发现，我们不能通过ndarray.T来得到一个一维行向量的转置，究其原因，是因为这个矩阵的属性中，只有维度0（行），没有维度1（列）。为了解决这个问题，我们可以使用numpy.newaxis这个量来为数组新增维度。
如：
A = A[numpy.newaxis, :]来为矩阵A在第一个轴之前新增一个轴
A = A[:, numpy.newaxis]来为矩阵A在最后一个轴之后新增一个轴
numpy中ndarray的基础运算
arr5 = np.array([[1,2],
[3,4]])
arr6 = np.array([[11,12],
[13,14]])
逐个元素的计算
现有两个数组：arr5、arr6，可以通过以下方式对这两个数组中的元素进行逐个计算
- 二元操作符
arr5 + arr6 -> ndarray：arr5与arr6中的对应元素逐个相加arr5 - arr6 -> ndarray：arr5中的元素逐个减去arr6中的对应元素arr5 * arr6 -> ndarray：arr5与arr6中的对应元素逐个相乘arr5 / arr6 -> ndarray：arr5与arr6中的对应元素逐个相除(注意除数不能为0)arr5 ** arr6 -> ndarray：arr5中的元素逐个取arr6中的对应元素次方(arr5[i]=arr5[i]**arr6[i])
- 三角函数运算
numpy.sin(object) -> ndarray/float：可传入ndarray、int等类型、np.pi,会对ndarray中的每个元素分别取正弦（弧度制），传入int等类型时，则计算它的正弦值numpy.arcsin -> ndarray/float：同上，计算反正弦值numpy.sinh -> ndarray/float：同上，计算双曲正弦值numpy.cos -> ndarray/float：同上，计算余弦值
- 比较大小
arr5 > i -> ndarray：返回一个dtype为bool，size与arr5相同的数组，该数组的每个对应元素为：arr5[i] > i得到的bool值arr5 >= i -> ndarray：同上arr5 < i -> ndarray：同上arr5 <= i -> ndarray：同上arr5 == i -> ndarray：同上
求和、求最小值、求最大值
- numpy.sum()
求和
numpy.sum(a, axis = None, dtype = None, out = None, keepdims = <no value>, initial = <no value>, where = <no value>) -> any
参数说明:
| 参数 | 描述 |
|---|---|
| a | array_like 这意味着输入可以是任何可以转换为数组的对象，比如列表，元组，或者另一个数组。 |
| axis | None or int or tuple of ints, optional 这意味着你可以指定沿哪个轴或哪些轴进行求和。如果你不指定任何轴，求和会计算输入数组的所有元素。如果你指定一个负数的轴，它会从最后一个轴开始往前数。比如，axis=-1表示输入数组的最后一个轴。如果你指定一个整数的元组，求和会同时计算元组中指定的多个轴。比如，axis=(0,1)表示求和会计算输入数组的第一和第二个轴。 |
| dtype | dtype, optional 这意味着你可以指定输出数组和中间计算的数据类型。如果你不指定任何数据类型，输入数组的数据类型会被默认使用。但是，如果输入数组有一个比默认平台整数更低精度的整数数据类型，那么会使用一个不同的数据类型。比如，如果你的平台默认使用64位整数，而你的输入数组有32位整数，那么输出数组会有64位整数。如果你的输入数组有有符号整数，那么输出数组也会有有符号整数。如果你的输入数组有无符号整数，那么输出数组也会有无符号整数。 |
| out | ndarray, optional 这意味着你可以提供一个已存在的数组来存储求和的结果。这个数组的形状必须和预期输出的形状一致。如果这个数组的数据类型和输出的数据类型不同，那么输出值会被转换为适合这个数组的数据类型。 |
| keepdims | bool, optional 这意味着你可以选择是否保留或移除被求和减少的轴。如果你设置这个为True，那么减少的轴会保留在输出中，作为大小为一的维度。这可以帮助你正确地将输出和输入数组进行广播。比如，如果你的输入数组有形状(3,4)，并且你沿着axis=1进行求和，并且keepdims=True，那么你的输出数组会有形状(3,1)，而不是(3,)。如果你不提供任何值给keepdims，那么它不会被传递给ndarray子类的sum方法。但是，如果你提供了一个非默认值给keepdims，那么它会被传递给ndarray子类的sum方法。如果子类没有实现keepdims，那么会抛出异常。 |
| initial | scalar, optional 这意味着你可以提供一个求和的初始值。这在你想要在求和之前给数组的所有元素加上一个常数值时很有用。比如，如果你的输入数组有值[1,2,3]，并且你提供了一个初始值10，那么你的输出会是16而不是6。 |
| where | array_like of bool, optional 这意味着你可以提供一个布尔掩码来选择哪些元素参与求和。这个掩码的形状必须和输入数组的形状一致。只有掩码为True的元素才会被求和。比如，如果你的输入数组有值[1,-2,-3]，并且你的掩码是[True,False,True]，那么你的输出会是-2 |
- numpy.min()
求最小值
numpy.min(a, axis = None, dtype = None, out = None, keepdims = <no value>, initial = <no value>, where = <no value>) -> any
参数同上
- numpy.max()
求最大值
numpy.max(a, axis = None, dtype = None, out = None, keepdims = <no value>, initial = <no value>, where = <no value>) -> any
参数同上
一般而言，可以先学会a和axis参数，其他参数等需要时再了解
求定轴最值
numpy.amin() 和 numpy.amax()
numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
最小值索引、最大值索引
- numpy.argmin()
argmin(a , axis = None, out = None, *, keepdims = np._NoValue) -> Any
求数组中最小值的索引
参数说明
| 参数 | 描述 |
|---|---|
| a | array_like 这意味着输入可以是任何可以转换为数组的对象，比如列表，元组，或者另一个数组。 |
| axis | None or int or tuple of ints, optional 这意味着你可以指定沿哪个轴或哪些轴进行求和。如果你不指定任何轴，求和会计算输入数组的所有元素。如果你指定一个负数的轴，它会从最后一个轴开始往前数。比如，axis=-1表示输入数组的最后一个轴。如果你指定一个整数的元组，求和会同时计算元组中指定的多个轴。比如，axis=(0,1)表示求和会计算输入数组的第一和第二个轴。 |
| out | ndarray, optional 这意味着你可以提供一个已存在的数组来存储求和的结果。这个数组的形状必须和预期输出的形状一致。如果这个数组的数据类型和输出的数据类型不同，那么输出值会被转换为适合这个数组的数据类型。 |
| keepdims | bool, optional 这意味着你可以选择是否保留或移除被求和减少的轴。如果你设置这个为True，那么减少的轴会保留在输出中，作为大小为一的维度。这可以帮助你正确地将输出和输入数组进行广播。比如，如果你的输入数组有形状(3,4)，并且你沿着axis=1进行求和，并且keepdims=True，那么你的输出数组会有形状(3,1)，而不是(3,)。如果你不提供任何值给keepdims，那么它不会被传递给ndarray子类的sum方法。但是，如果你提供了一个非默认值给keepdims，那么它会被传递给ndarray子类的sum方法。如果子类没有实现keepdims，那么会抛出异常。 |
- numpy.argmax()
求数组中最大值的索引
参数同上
print(arr6.T)
print(arr6.T.argmax())
print(arr6.T.argmax(axis = 1))
[[11 13]
[12 14]]
3
[1 1]
求平均值
- numpy.mean()/nbarray.mean()
计算数组中元素的平均值
numpy.sum(a, axis = None, dtype = None, out = None, keepdims = <no value>, initial = <no value>, where = <no value>) -> any
参数同numpy.sum()
- numpy.average()
计算数组中元素的加权平均值
average(a, axis = None, weights = None, returned = False, *, keepdims = np._NoValue) -> tuple[Any, Any | None]
参数说明:
| 参数 | 描述 |
|---|---|
| a | array_like 这意味着输入可以是任何可以转换为数组的对象，比如列表，元组，或者另一个数组。 |
| axis | None or int or tuple of ints, optional 这意味着你可以指定沿哪个轴或哪些轴进行求和。如果你不指定任何轴，求和会计算输入数组的所有元素。如果你指定一个负数的轴，它会从最后一个轴开始往前数。比如，axis=-1表示输入数组的最后一个轴。如果你指定一个整数的元组，求和会同时计算元组中指定的多个轴。比如，axis=(0,1)表示求和会计算输入数组的第一和第二个轴。 |
| weights | 一个权重的数组 |
| returned | 默认为false,如果设为 true，则返回权重的和 |
| keepdims | bool, optional 这意味着你可以选择是否保留或移除被求和减少的轴。如果你设置这个为True，那么减少的轴会保留在输出中，作为大小为一的维度。这可以帮助你正确地将输出和输入数组进行广播。比如，如果你的输入数组有形状(3,4)，并且你沿着axis=1进行求和，并且keepdims=True，那么你的输出数组会有形状(3,1)，而不是(3,)。如果你不提供任何值给keepdims，那么它不会被传递给ndarray子类的sum方法。但是，如果你提供了一个非默认值给keepdims，那么它会被传递给ndarray子类的sum方法。如果子类没有实现keepdims，那么会抛出异常。 |
print(np.array([[1,2,3,4],
[3,4,5,6]]))
print (np.average([[1,2,3,4],
[3,4,5,6]],weights = [[4,3,2,1],[3,4,5,6]], returned = True))
[[1 2 3 4]
[3 4 5 6]]
(3.7857142857142856, 28.0)
求中位数
numpy.median()
numpy.median(a, axis=None, out=None, overwrite_input=False, keepdims=False)
参数说明:
| 参数 | 描述 |
|---|---|
| overwrite_input | 默认为False,如果为True,则在计算中会直接使用原数组而不是使用副本进行计算,虽然这会改变原数组,但是可以节省内存。如果原数组不再使用,可以将此参数设置为True.同时,如果“overwrite_input”为“True”而“a”不是“ndarray”类型，将报错。 |
print(np.array([[1,2,3,4],
[3,4,5,6]]))
print (np.median([[1,2,3,4],
[3,4,5,6]], overwrite_input = True))
[[1 2 3 4]
[3 4 5 6]]
3.5
求标准差
numpy.std(ndarray)
求方差
np.var(ndarray， ddof = 0)
参数说明:
ddof ： 自由度，无偏估计方差的ddof为1
求百分位数
numpy.percentile()
百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。
numpy.percentile(a, q, axis)
参数说明：
a: 输入数组
q: 要计算的百分位数，在 0 ~ 100 之间
axis: 沿着它计算百分位数的轴
求极差
numpy.ptp()
numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
每个元素累加
numpy.cumsum()
numpy.cumsum(a, axis=None, dtype=None, out=None) -> ndarray
生成一个元素分别为数组a中对应元素与索引更小的元素的累加的一维数组
print(np.array([[1,2,3,4],
[3,4,5,6]]))
print (np.cumsum([[1,2,3,4],
[3,4,5,6]]))
[[1 2 3 4]
[3 4 5 6]]
[ 1 3 6 10 13 17 22 28]
按轴每两个元素取差
numpy.diff()
这是一个用于计算沿着给定轴的n阶离散差分的函数1。离散差分是指相邻元素之间的差值，例如，一阶差分由out[i] = a[i+1] - a[i]沿着给定轴计算，更高阶的差分可以通过递归地使用diff函数计算2。
numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue) -> ndarray
参数说明:
| 参数 | 描述 |
|---|---|
| a | 输入的数组 |
| n | 差分的次数。如果为零，直接返回输入数组。默认为1。 |
| axis | 差分的轴，即沿着哪个维度进行差分。默认为最后一个轴。 |
| prepend,append | array_like, optional 在执行差分之前，在轴的前面或后面添加的值。如果是标量值，会扩展成长度为1的数组，并沿着其他轴保持输入数组的形状。否则，除了轴之外，必须和输入数组的维度和形状匹配。这个参数在版本1.16.0中新增。 |
print(np.array([[1,2,3,4],
[3,4,5,6]]))
print (np.diff([[1,2,3,4],
[3,4,5,6]]))
[[1 2 3 4]
[3 4 5 6]]
[[1 1 1]
[1 1 1]]
查找非0的数的索引
numpy.nonzero()
这是一个用于返回数组中非零元素的索引的函数。它返回一个元组，每个元组的元素是一个数组，表示对应维度上非零元素的索引。数组中的值总是按照行优先，C风格的顺序进行测试和返回。
numpy.nonzero(a) -> tuple
返回的元组中包含数组维度数个数的元素,分别是一个ndarray,对应的是非0元素的位置
print(np.array([[0,2,3,4],
[3,4,0,6]]))
print(np.nonzero([[0,2,3,4],
[3,4,0,6]]))
[[0 2 3 4]
[3 4 0 6]]
(array([0, 0, 0, 1, 1, 1], dtype=int64), array([1, 2, 3, 0, 1, 3], dtype=int64))
排序
numpy.sort()
numpy.sort(a, axis=-1, kind=None, order=None) -> ndarray
sort是一个函数，它可以对一个类似数组的对象进行排序，并返回一个排序后的副本。函数返回一个和a类型和形状相同的数组，表示排序后的结果。
参数说明:
| 参数 | 描述 |
|---|---|
| a | 类似数组的对象，需要被排序的对象。 |
| axis | 整数或者None，可选的，指定沿着哪个轴进行排序。如果是None，那么对象会被展平成一维再排序。默认值是-1，表示沿着最后一个轴排序。 |
| kind | {‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’} 可选的，指定排序算法。默认值是’quicksort’。注意，'stable’和’mergesort’都使用了timsort或者radix sort作为底层实现，而且一般来说，实际的实现会根据数据类型而变化。'mergesort’选项是为了向后兼容而保留的。在1.15.0版本中，增加了’stable’选项。 |
| order | 字符串或者字符串列表，可选的，当a是一个有字段定义的数组时，这个参数指定哪些字段先比较，哪些字段后比较等等。一个字段可以用一个字符串来指定，而且不需要指定所有的字段，但是没有指定的字段仍然会被使用，在它们在数据类型中出现的顺序来打破平局。 |
print(np.array([[0,2,3,4],
[3,4,0,6]]))
print(np.array([[0,2,3,4],
[3,4,0,6]]))
print(np.sort([[0,2,3,4],
[3,4,0,6]], axis=None).reshape((2,4)))
[[0 2 3 4]
[3 4 0 6]]
[[0 2 3 4]
[3 4 0 6]]
[[0 0 2 3]
[3 4 4 6]]
clip限幅滤波
numpy.clip()
clip函数可以对一个数组中的值进行限制。给定一个区间，超出区间的值会被裁剪到区间的边界。例如，如果指定一个[0, 1]的区间，小于0的值变成0，大于1的值变成1。
numpy.clip(a, a_min, a_max, out=None, **kwargs) -> ndarray
参数说明:
| 参数 | 描述 |
|---|---|
| a | 类似数组的对象，包含需要被裁剪的元素。 |
| a_min | 最小值,所有小于这个值的元素都会等于这个值。如果是None,则不会进行对这个边界的裁剪 |
| a_max | 最大值,所有大于这个值的元素都会等于这个值。如果是None,则不会进行对这个边界的裁剪 |
| out | 可选的，结果会被放在这个数组中。它可以是输入数组，用于原地裁剪。 |
| **kwargs | 其他的只能用关键字的参数，参见ufunc文档。 |
线性代数
矩阵转置
numpy.transpose(a, axes=None) -> ndarray
求矩阵a的转置矩阵
参数说明:
| 参数 | 描述 |
|---|---|
| a | ndarray 数组 |
| axes | 整数元组或者整数列表，如果指定了，它必须是一个包含[0,1,…,N-1]的排列，其中N是a的轴数。返回的数组的第i个轴会对应输入的第axes[i]个轴。如果没有指定，默认值是range(a.ndim)[::-1]，也就是反转轴的顺序。 |
a.T
返回矩阵a的转置矩阵,没有参数
print(arr5)
print(np.transpose(arr5))
print(arr5.T)
[[1 2]
[3 4]]
[[1 3]
[2 4]]
[[1 3]
[2 4]]
两个数组的点乘（积）
numpy.dot(a, b, out=None) -> ndarray
矩阵a与矩阵b点乘（AB）
参数说明：
| 参数 | 描述 |
|---|---|
| a | ndarray 数组 |
| b | ndarray 数组 |
| out | ndarray, 可选，用来保存dot()的计算结果 |
ndarray.dot(self, *args, **kwargs) -> ndarray
同样是点乘，不过是一个ndarray的方法，a.dot(b)与numpy.dot(a,b)等价
print(np.dot(arr5,arr6))
print(arr5.dot(arr6))
[[37 40]
[85 92]]
[[37 40]
[85 92]]
两个向量的点乘（积）
numpy.vdot(a, b) -> ndarray
计算两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。
参数说明：
| 参数 | 描述 |
|---|---|
| a | ndarray 数组 |
| b | ndarray 数组 |
两个数组的内积
numpy.inner(a, b) -> ndarray
返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。
参数说明：
| 参数 | 描述 |
|---|---|
| a | ndarray 数组 |
| b | ndarray 数组 |
print (np.inner(np.array([1,2,3]),np.array([0,1,0])))
# 等价于 1*0+2*1+3*0
2
两个数组的矩阵积
numpy.matmul(x1, x2) -> ndarray
原代码：def matmul(x1, x2, *args, **kwargs):
返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。
参数说明：
| 参数 | 描述 |
|---|---|
| x1 | ndarray 数组 |
| x2 | ndarray 数组 |
对于二维数组，它就是矩阵乘法
# 二维和二维运算
print("二维和二维运算:")
a = [[1,0],[0,1]]
b = [[4,1],[2,2]]
print (np.matmul(a,b))
#二维和一维运算
print("二维和一维运算:")
a = [[1,0],[0,1]]
b = [1,2]
print (np.matmul(a,b))
print (np.matmul(b,a))
# 维度大于二的数组
print("维度大于二的数组:")
a = np.arange(8).reshape(2,2,2)
b = np.arange(4).reshape(2,2)
print(np.matmul(a,b))
二维和二维运算:
[[4 1]
[2 2]]
二维和一维运算:
[1 2]
[1 2]
维度大于二的数组:
[[[ 2 3]
[ 6 11]]
[[10 19]
[14 27]]]
数组的行列式(determinant)
numpy.linalg.det(a) -> Any
求数组的行列式
| 参数 | 描述 |
|---|---|
| a | ndarray 数组 |
print(np.linalg.det(np.array([[1,2],
[3,4]])))
-2.0000000000000004
求解线性矩阵方程
numpy.linalg.solve(a, b) -> Any
求解线性方程AX = B中的X
| 参数 | 描述 |b
| — | — |
| a | ndarray 数组,AX = B中的A |
| b | ndarray 数组,AX = B中的B |
计算矩阵的乘法逆矩阵
numpy.linalg.inv(a) -> ndarray
计算矩阵的逆矩阵
x = np.array([[1,2],[3,4]])
y = np.linalg.inv(x)
print (x)
print (y)
print (np.dot(x,y))
[[1 2]
[3 4]]
[[-2. 1. ]
[ 1.5 -0.5]]
[[1.00000000e+00 1.11022302e-16]
[0.00000000e+00 1.00000000e+00]]
广播机制(Broadcast)
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式
详见https://www.runoob.com/numpy/numpy-broadcast.html
增删改
numpy索引
对于一个ndarray对象,其索引的方式和多维列表方式一样
arr7 = np.arange(3,15).reshape((3,4))
print(arr7)
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
可以使用多个中括号进行索引
print(arr7[2])
print(arr7[2][1])
[11 12 13 14]
12
可以使用逗号分隔的一个中括号进行索引
print(arr7[2,1])
12
可以使用切片（用冒号表示索引范围）(含左不含右)
print(arr7[2,1:3])
print(arr7[2,:])
[12 13]
[11 12 13 14]
ndarray迭代
语法
语法:
for value in ndarray:
......
value得到迭代的一个行向量(一维数组)
-
如果数组不是一个行向量,则对ndarray沿最后一个轴迭代(如对二维数组,就是对行迭代)
-
如果数组是一个行向量,则对每个元素进行迭代
可以通过一定的计算来进行对其他轴的迭代,
如对一个二维数组进行列迭代:
for column in A.T:
print(column)
对每个元素进行迭代: ndarray.flat得到迭代每个元素的迭代器
for item in A.flat:
print(item)
print(np.array([[1,2,3],
[2,3,4]]))
for row in np.array([[1,2,3],
[2,3,4]]):
print(row)
for column in np.array([[1,2,3],
[2,3,4]]).T:
print(column)
for item in np.array([[1,2,3],
[2,3,4]]).flat:
print(item)
[[1 2 3]
[2 3 4]]
[1 2 3]
[2 3 4]
[1 2]
[2 3]
[3 4]
1
2
3
2
3
4
迭代器对象
nditer迭代器对象提供了一种灵活遍历所有元素的方法
numoy.nditer(a, order='C', op_flags=['read-only']) -> nditer
for x in numpy.nditer(a, order='F', op_flags=['read-only']):
...
参数说明：
| 参数 | 描述 |
|---|---|
| a | ndarray 数组 |
| order | 迭代顺序，“F”:Fortran order，即是列序优先; “C”:C order，即是行序优先，默认为"C" |
| op_flags | 遍历模式，默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 readwrite 或者 writeonly 的模式。 |
print(arr7)
for x in np.nditer(arr7):
print(x)
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
3
4
5
6
7
8
9
10
11
12
13
14
数组的合并(连接数组)
连接沿现有轴的数组序列
numpy.concatenate(arrays, axis=None, out=None, *, dtype=None, casting=None) -> ndarray
一般用：numpy.concatenate((a1, a2, ...), axis) -> ndarray
参数说明：
| 参数 | 描述 |
|---|---|
| arrays | 一个数组的元组 a1, a2, …：相同类型的数组 |
| axis | 沿着它连接数组的轴，默认为 0 |
| out | 输出的数组 |
| dtype | 指定输出数组和中间计算的数据类型 |
| casting | {‘no’， ‘equiv’， ‘safe’， ‘same_kind’， ‘unsafe’}， 控制可能发生的数据转换类型。默认为“same_kind”。 |
沿着新的轴加入一系列数组
stack(arrays, axis=0, out=None, *, dtype=None, casting="same_kind") -> ndarray
一般用：numpy.stack(arrays, axis) -> ndarray
参数说明：
| 参数 | 描述 |
|---|---|
| arrays | 一个数组的元组 a1, a2, …：相同类型的数组 |
| axis | 沿着它连接数组的轴，默认为 0 |
| out | 输出的数组 |
| dtype | 指定输出数组和中间计算的数据类型 |
| casting | {‘no’， ‘equiv’， ‘safe’， ‘same_kind’， ‘unsafe’}， 控制可能发生的数据转换类型。默认为“same_kind”。 |
水平堆叠序列中的数组（列方向）
numpy.hstack(tup, *, dtype=None, casting="same_kind") -> ndarray
一般用：numpy.hstack(tup) -> ndarray
numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。
参数说明：
| 参数 | 描述 |
|---|---|
| tup | 水平拼接的数组的元组 |
| dtype | 指定输出数组和中间计算的数据类型 |
| casting | {‘no’， ‘equiv’， ‘safe’， ‘same_kind’， ‘unsafe’}， 控制可能发生的数据转换类型。默认为“same_kind”。 |
竖直堆叠序列中的数组（行方向）
numpy.vstack(tup, *, dtype=None, casting="same_kind") -> ndarray
一般用：numpy.vstack(tup) -> ndarray
numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。
参数说明：
| 参数 | 描述 |
|---|---|
| tup | 竖直拼接的数组的元组 |
| dtype | 指定输出数组和中间计算的数据类型 |
| casting | {‘no’， ‘equiv’， ‘safe’， ‘same_kind’， ‘unsafe’}， 控制可能发生的数据转换类型。默认为“same_kind”。 |
print(arr5)
print(arr6)
print(np.vstack((arr5, arr6)))
[[1 2]
[3 4]]
[[11 12]
[13 14]]
[[ 1 2]
[ 3 4]
[11 12]
[13 14]]
数组的分割
将一个数组分割为多个子数组
numpy.split(ary, indices_or_sections, axis=0) -> list of ndarrays
参数说明：
| 参数 | 描述 |
|---|---|
| ary | 被分割的数组 |
| indices_or_sections | 切分方式，如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭） |
| axis | 设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。 |
hsplit 将一个数组水平分割为多个子数组（按列）
vsplit 将一个数组垂直分割为多个子数组（按行）
将一个数组水平分割为多个子数组（按列）
numpy.hsplit(ary, indices_or_sections) -> list of ndarrays
参数说明：
| 参数 | 描述 |
|---|---|
| ary | 被分割的数组 |
| indices_or_sections | 切分方式，如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭） |
将一个数组垂直分割为多个子数组（按行）
numpy.vsplit(ary, indices_or_sections) -> list of ndarrays
参数说明：
| 参数 | 描述 |
|---|---|
| ary | 被分割的数组 |
| indices_or_sections | 切分方式，如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭） |
数组的副本和视图
视图（浅拷贝）
使用A = ndarray.view()创建一个视图
改变A的shape：A.shape = 2,3，不会改变原数组的shape
改变A的元素会改变原数组的对应元素
副本（深拷贝）
一个数组直接复制给另外一个变量，两个变量都指向同一个数组，相当于两个指针变量指向同一块内存
A = arr7
print(A is arr7)
True
当需要一个数组的拷贝时，我们可以使用A = ndarray.copy()对数组进行深拷贝
数组A已经分配了一个新的内存，与原数组无关了
B = arr7.copy()
print(B is arr7)
False
Pandas
import pandas as pd
设置可以展示的行数和列数
pd.set_option('max_columns', 100)
设置为最大可以展示100列
pd.set_option('max_rows', 500)
设置为最大可以展示500行
数据结构
Series
一维数组，与Numpy中的一维array类似，二者与Python中的List也很类似。Series能保存不同的数据类型，字符串、boolean值、数字等都能保存在Series中。
一维Series可以使用一维列表给化：
pandas.Series(data, index, dtype, name, copy, fastpath) -> Series
参数说明：
| 参数 | 描述 |
|---|---|
| data | 数据 |
| index | 索引 |
| dtype | 数据类型 |
| name | Series的名称 |
| copy | 复制 |
| fastpath |
data: Any = None,
index: Any = None,
dtype: ExtensionDtype | str | dtype | Type[str] | Type[complex] | Type[bool] | Type[object] | None = None,
name: Any = None,
copy: bool | None = None,
fastpath: bool = False
s = pd.Series([1,3,5,np.nan,6,6], index = ["a", "b", "c", "d", "e", "f"])
print(s)
a 1.0
b 3.0
c 5.0
d NaN
e 6.0
f 6.0
dtype: float64
默认情况下，Series的下标都是数字（可以使用额外参数指定），类型是统一的。
查看index和values
Series.index
查看Series的所有索引
Series.alues
查看Series的所有值
s.index
Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
s.values
array([ 1., 3., 5., nan, 6., 6.])
可以使用索引和切片
print(s[2:5])
print(s[::2])#步长为2
c 5.0
d NaN
e 6.0
dtype: float64
a 1.0
c 5.0
e 6.0
dtype: float64
Series的属性
| 属性 | 描述 |
|---|---|
| data | 数据 |
| index | 索引 |
| dtype | 数据类型 |
| name | Series的名称 |
| copy | 复制 |
| fastpath |
s.name = "索引"
print(s)
a 1.0
b 3.0
c 5.0
d NaN
e 6.0
f 6.0
Name: 索引, dtype: float64
DataFrame
二维的表格型数据结构。很多功能与data.frame类似。可以将DataFrame理解为Series的容器。
DataFrane则是个二维结构，这里首先构造一组时间序列，作为我们第一维的下标：
然后创健一个DataFrane结构：
默认情况下，如果不指定i1dex静数和c0l,那么他们的值将用从0开始的数字替代.
除了向DataFr中传入二雄数相，我们也可以使用字典传入数据：
字典的每个key代表一列，其value可以是名种够转化为S:es的对象。
与5 eries要求所有的类型都一数不同，DntaFrase只要求每一列数的格式相同：
DataFrane则是个二维结构，这里首先构造一组时间序列，作为我们第一维的下标：
创建Index序列
用时间创建Index序列
date = pd.date_range("20180101",periods = 6)
print(date)
创健一个DataFrane结构
pd.DataFrame(data,index,columns,dtype,copy) -> DataFrame
| 参数 | 描述 |
|---|---|
| data | 数据 |
| index | 行索引 |
| columns | 列索引 |
| dtype | 数据类型 |
| copy | 是否创建副本 |
df = pd.DataFrame(np.random.randn(6,4),index=date,columns=list('ABCD'))
df
特别地，若data传入了一个字典，则字典的key就列名，value则是每一列的数据
df2 = pd.DataFrame({'A':pd.Series(1,index=list(range(4)),dtype=float),"B":np.array([3]*4,dtype=int),"C":pd.Categorical(["test","train","test","train"]),'D':pd.Timestamp('20181001')})
df2
DataFrame只要求每一列数据的类型相同
查看数据
按行查看数据
DataFrame.head(n)
查看前n行数据(n默认为5)
DataFrame.tail(n)
查看后n行数据(n默认为5)
df.head()
查看每列数据的数据类型
DataFrame.dtypes
df2.dtypes
查看行标、列标、数据
DataFrame.index
查看行标
DataFrame.columns
查看列标
DataFrame.values
查看数据
df2.index
df2.values
查看行数(数据条数)
使用len：
len(DataFrame)
索引
也可用DataFrame[]这样的索引、切片形式来指定返回的行
可以用DataFrame[]来查看指定索引的列的数据
DataFrame[一个或多个列索引(逗号分隔)/列切片][一个或多个行索引(逗号分隔)/行切片]来查看指定索引的行列的数据，如：df['名字','类型'][:5]
也有条件取数据的语法(原理：df[‘A’]==0这类语法返回一个bool形的列表,再放进索引的位置，用作掩码)：
df[df['A']==0][:5]#提取数据(筛选条件: A列中数字为0的数据所在的前5行)
df[df['产地']=='美国'&df['评分']>9]
也可写作：
df[df.产地=='美国'&df.评分>9]
索引只能在列上使用列标，而行上只能使用索引，所以要访问行的话，还是用loc更方便，可以使用行标
查看DataFrame详细信息
DataFrame.info()
读取数据及数据操作
读数据
pandas.read_excel()
pandas.read_csv()
pandas.read_json()
以及更多
使用路径时，在字符串前加r表示不需要转义(原生字符串)，如r'F:\PythonStudy\Notebook'
我们详细讲pandas.read_excel()：
| 参数 |
|---|
| io |
| sheet_name=0 |
| header=0 |
| names=None |
| index_col=None |
| usecols=None |
| squeeze=False |
| dtype=None |
| engine=None |
| converters=None |
| true_values=None |
| false_values=None |
| skiprows=None |
| nrows=None |
| na_values=None |
| keep_default_na=True |
| verbose=False |
| parse_dates=False |
| date_parser=None |
| thousands=None |
| comment=None |
| skipfooter=0 |
| convert_float=True |
| mangle_dupe_cols=True |
| **kwds |
参数看着很多，但其实我们日常用到的就几个，：
| 参数 | 说明 |
|---|---|
| io | （str）读取的文件路径 |
| sheet_name=0 | （str, int, list, None, default 0）默认为0，读取第一个sheet的全部数据该参数可以为:str字符串用于引用的sheet的名称int整数用于引用的sheet的索引（从0开始）字符串或整数组成的列表用于引用特定的sheetNone 表示引用所有sheet注意，如果读取了多个sheet，读取后的数据类型是OrderedDict,它将两个sheet的数据合并到了一个list中 |
| header=0 | （int, list of int, default 0）表示用第几行作为表头，舍弃表头之前的行的数据，可以为（int, list of int, default 0）hearder=[1,2,3]：选择第2,3,4行的数据作为表头，第二行之上的数据不用header=None :表示不使用数据源中的表头 |
| names=None | (array-like, default None)表示自定义表头的名称，需要传递数组参数。 |
| index_col=None | （int, list of int, default None）指定列为索引列，默认为None，也就是索引为0的列用作DataFrame的行标签。 |
| usecols=None | (int, str, list-like, or callable default None)默认为None，解析所有列。如果为str，则表示Excel列字母和列范围的逗号分隔列表（例如“ A：E”或“ A，C，E：F”）。范围全闭。如果为int，则表示解析到第几列。如果为int列表，则表示解析那几列。 |
| squeeze=False | (bool, default False)默认为False。如果设置squeeze=True则表示如果解析的数据只包含一列，则返回一个Series。 |
| dtype=None | （Type name or dict of column -> type, default None）列的类型名称或字典，默认为None，也就是不改变数据类型。其作用是指定列的数据类型。dtype={0:"float64",2:str}设置第一列为float64类型，第三列为str类型 |
| engine=None | （str, default None）可以接受的参数有“ xlrd”，“ openpyxl”或“ odf”，用于使用第三方的库去解析excel文件。 |
| converters=None | （dict, default None）对指定列的数据进行指定函数的处理，传入参数为列名与函数组成的字典。key 可以是列名或者列的序号，values是函数，可以def函数或者直接lambda都行。 |
| true_values=None | （list，default None）将指定的文本转换为True，默认为None |
| false_values=None | （list，default None）将指定的文本转换为False，默认为None |
| skiprows=None | （list like）跳过指定的行。skiprows=1 跳过第1行skiprows=3 跳过前3行skiprows=[1,3,5] 跳过第1,3,5行skiprows=lambda x: x % 2 == 0 跳过偶数行 |
| nrows=None | （int, default None）指定需要读取前多少行，通常用于较大的数据文件中nrows=3 读取前三行 |
| na_values=None | （scalar, str, list-like, or dict, default None）指定某些列的某些值为NaN。na_values='大专'，指定大专为NaN |
| keep_default_na=True | (bool, default True)表示导入数据时是否导入空值。默认为True，即自动识别空值并导入 |
df3 = pd.read_excel('豆瓣电影数据.xlsx',index_col=0)
df3.head()
| 名字 | 投票人数 | 类型 | 产地 | 上映时间 | 时长 | 年代 | 评分 | 首映地点 | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 肖申克的救赎 | 692795.0 | 剧情/犯罪 | 美国 | 1994-09-10 00:00:00 | 142 | 1994 | 9.6 | 多伦多电影节 |
| 1 | 控方证人 | 42995.0 | 剧情/悬疑/犯罪 | 美国 | 1957-12-17 00:00:00 | 116 | 1957 | 9.5 | 美国 |
| 2 | 美丽人生 | 327855.0 | 剧情/喜剧/爱情 | 意大利 | 1997-12-20 00:00:00 | 116 | 1997 | 9.5 | 意大利 |
| 3 | 阿甘正传 | 580897.0 | 剧情/爱情 | 美国 | 1994-06-23 00:00:00 | 142 | 1994 | 9.4 | 洛杉矶首映 |
| 4 | 霸王别姬 | 478523.0 | 剧情/爱情/同性 | 中国大陆 | 1993-01-01 00:00:00 | 171 | 1993 | 9.4 | 香港 |
取数据
DataFrame.iloc[行号，列号]属性，用行号、列号来表示查看哪几行。若有多个，行号、列号需要分别是个列表。可以是索引形式，左闭右开
df3.iloc[:3]
DataFrame.loc[行标，列标]属性，用行标、列标来取数据,可以是索引形式，若有多个，行号、列号需要分别是个列表。，左闭右闭，如df.loc[:,['A','B']]
该属性有一种条件选择语法，即根据某个数据的值是否符合条件来提取数据
df.loc[df['A']==0][:5]#提取数据(筛选条件: A列中数字为0的数据所在的前5行)
df3.loc[:3]
在末尾添加行
DataFrame._append() -> DataFrame
会创建一个副本
| 参数 | 说明 |
|---|---|
| other: Any | （DataFrame，Series，Iterable[DataFrame |
| ignore_index: bool = False | Can only append a dict if ignore_index=True |
| verify_integrity: bool = False | |
| sort: bool = False |
注：DataFrame.append()即将弃用
定义要加入的行的字典
dit = {'名字':'复仇者联盟3','投票人数':'123456','类型':'剧情/科幻','产地':'美国','上映时间':'2018-05-04 00:00:00','时长':'142','年代':'2018','评分':'8.7','首映地点':'美国'}
转化为Series
sdit = pd.Series(dit)
sdit.name = 38738#name属性添加进DataFrame后就是行标
sdit
在末尾添加数据
df3 = df3._append(sdit)
df3[-5:]
增加一列
DataFrame['新列标'] = 一列的值(可以是列表等，也可以用range)
df3['序号'] = range(1, len(df3) + 1)
df3[:5]
删除行或列
DataFrame.drop() -> DataFrame
| 参数 | 说明 |
|---|---|
| labels | 一个字符或者数值，加上axis ，表示带label标识的行或者列；如 (labels=‘A’, axis=1) 表示A列 |
| axis = 0 | 维数，axis=0表示行，axis=1表示列 |
| columns | 列名 |
| index | 表示dataframe的index, 如index=1, index=a |
| inplace = False | True表示删除某行后原dataframe变化，False不改变原始dataframe |
# 删除一行
df3 = df3.drop([38738])
# 删除一列
#df3 = df3.drop('序号',axis=1)
# 选择性删除
# df3.drop(df3[df3['年代']>2023].index,inplace=True)
df3[-5:]
数据随机抽样
DataFrame.sample( self: NDFrameT, n: int | None = None, frac: float | None = None, replace: bool_t = False, weights=None, random_state: RandomState | None = None, axis: Axis | None = None, ignore_index: bool_t = False, ) -> DataFrame
sample 是 pandas 库中 DataFrame 和 Series 对象的一个方法，它用来从对象的指定轴返回随机样本。你可以使用 random_state 参数来保证可重复性。
下面是 sample 方法中每个参数的解释：
n: 要从轴返回的项目数。不能与 frac 一起使用。如果 frac 为 None，则默认为 1。
frac: 要返回的轴项目的比例。不能与 n 一起使用。
replace: 是否允许对同一行进行多次抽样。默认为 False。
weights: 权重。默认为 ‘None’，表示所有项目的概率相
等。如果传递一个 Series，则会根据索引与目标对象对齐。在权重中未找到的采样对象的索引值将被忽略，而在采样对象中未在权重中找到的索引值将被分配零权重。如果在 DataFrame 上调用，则当 axis = 0 时，将接受列名。除非权重是一个 Series，否则权重必须与被采样的轴长度相同。如果权重之和不为 1，则它们将被归一化为总和为 1。权重列中的缺失值将被视为零。不允许无限值。
random_state: 随机数生成器的种子。如果是 int、array-like 或 BitGenerator，则用作随机数生成器的种子。如果是 np.random.RandomState 或 np.random.Generator，则按给定方式使用。
返回值是一个新的 DataFrame 或 Series 对象。
可以通过将frac设为1来打乱数据顺序
缺失值以及异常值的处理
缺失值处理方法：
| 方法 | 说明 |
|---|---|
| dropna | 根据标签中的缺失值进行过滤，删除缺失值所在行 |
| fillna | 对缺失值进行填充 |
| isnull | 返回一个布尔值对象，判断哪些值是缺失值（缺失值为True） |
| notnull | isnull的否定形式（非缺失值为True） |
判断哪些值是缺失值/非缺失值
DataFrame.isnull() -> DataFrame
返回一个布尔值对象，判断哪些值是缺失值（缺失值为True）
DataFrame.notnull() -> DataFrame
isnull的否定形式（非缺失值为True）
df3[df3.名字.isnull()][:5]
填充缺失值
DataFrame.fillna(value, method, axis, inplace, limit, downcast) -> DataFrame
| 参数 | 说明 |
|---|---|
| value | 填充值 |
| method | |
| axis | 进行操作的维数 |
| inplace = False | 是否直接使用原数据进行操作 |
| limit | |
| downcast |
用均值填充：
df3.评分.fillna(np.mean(df.评分)， inplace = True)
删除缺失值
DataFrame.dropna(axis, how, thresh, subset, inplace, ignore_index) -> DataFrame
| 参数 | 说明 |
|---|---|
| axis | 进行操作的维数 |
| how = ‘any’ | (‘any’, ‘all’)any:存在NA(空)即删除all:全为NA才删除 |
| thresh | int, optionalRequire that many non-NA values. Cannot be combined with how. |
| subset | column label or sequence of labels, optional,Labels along other axis to consider, e.g. if you are dropping rowsthese would be a list of columns to include. |
| inplace = False | 是否使用原数据操作 |
| ignore_index | If True, the resulting axis will be labeled 0, 1, …, n - 1. |
异常值处理
异常值，即在数起朱中存在不合理的恒，又你离群点。比如年龄为-1，笔记本电脑重量为1屯等，都属于异常值的范围。
对于异常值。一股来说数量都会很少，在不影响整体数据分布的情况下，我们直接删除就可以了。
其他属性的异常值处理，我们会在格式转换部分，进一步讨论。
因为删除了一些值以后，DataFrame的index已经不再连续，有必要的话，我们可以重新为它赋值使它连续：
df3.index = range(len(df3))
df3[(df3.投票人数 < 0 ) | ((df3.投票人数 % 1 )!= 0)]
| 名字 | 投票人数 | 类型 | 产地 | 上映时间 | 时长 | 年代 | 评分 | 首映地点 | |
|---|---|---|---|---|---|---|---|---|---|
| 19777 | 皇家大贼 皇家大 | -80.00 | 剧情/犯罪 | 中国香港 | 1985-05-31 00:00:00 | 60.0 | 1985 | 6.3 | 美国 |
| 19786 | 日本的垃圾去中国大陆 にっぽんの“ゴミ” 大陆へ渡る ～中国式リサイクル錬 | -80.00 | 纪录片 | 日本 | 1905-06-26 00:00:00 | 60.0 | 2004 | 7.9 | 美国 |
| 19791 | 女教师 女教 | 8.30 | 剧情/犯罪 | 日本 | 1977-10-29 00:00:00 | 100.0 | 1977 | 6.6 | 日本 |
| 19797 | 女教徒 | -118.00 | 剧情 | 法国 | 1966-05-06 00:00:00 | 135.0 | 1966 | 7.8 | 美国 |
| 19804 | 女郎漫游仙境 ドレミファ娘の血は騒 | 5.90 | 喜剧/歌舞 | 日本 | 1985-11-03 00:00:00 | 80.0 | 1985 | 6.7 | 日本 |
| 19820 | 女仆日记 | 12.87 | 剧情 | 法国 | 2015-04-01 00:00:00 | 96.0 | 2015 | 5.7 | 法国 |
| 38055 | 逃出亚卡拉 | 12.87 | 剧情/动作/惊悚/犯罪 | 美国 | 1979-09-20 00:00:00 | 112.0 | 1979 | 7.8 | 美国 |
直接将数据覆盖
df3 = df3[(df3.投票人数 > 0 ) & (df3.投票人数 % 1 == 0)]
df3 = df3[df3.时长 < 2000]
替换数据
DataFrame.replace(to_replace,value,inplace,limit,regex,method) -> DataFrame
| 参数 | 说明 |
|---|---|
| to_replace=None | 要替换的值 |
| value=lib.no_default | 用于替换的值 |
| inplace: bool = False | 是否使用原数据进行操作 |
| limit: int | None = None |
| regex: bool = False | — |
| method: Literal[“pad”, “ffill”, “bfill”] | lib.NoDefault = lib.no_default | — |
数据保存
DataFrame.to_excel(io)
| 参数 | 说明 |
|---|---|
| io | 保存路径 |
-
DataFrame.to_csv() -
DataFrame.to_json() -
DataFrame.to_html()
等等
数据类型转换
在做数据分析的时候，原始数据往往会因为各种各样的原因产生各种数据类型的问题。
数据类型是我们非常需要注意的一点，数据类型错误往往会造成很严重的后果。
并且，很多异常值也是我们经过数据类型转换之后才会发现，对我们规整数据，清洗数据有着重要的作用。
查看数据类型
DataFrame[列标].dtype
只能查看一列（可以算作是是通过DataFrame[列标]得到Series后再dtype?）
df3['序号'].dtype
数据类型转换
DataFrame[列标].astype(dtype, copy) -> DataFrame
| 参数 | 说明 |
|---|---|
| dtype | (str)目标数据类型 |
| copy | bool, default TrueReturn a copy when copy=True (be very careful settingcopy=False as changes to values then may propagate to otherpandas objects). |
print(df3.投票人数.dtype)
df3['投票人数'] = df3['投票人数'].astype('int')
print(df3.投票人数.dtype)
数据类型转换排错案列
将"年代"转换为int类型
首先执行df3.年代.astype("int")
得到报错ValueError: invalid literal for int() with base 10: ‘2008\u200e’
再查找该条目df3[df3.年代 = 2008\u200e]
print(df3[df3.年代 == '2008\u200e']['年代'])
print(df3[df3.年代 == '2008\u200e']['年代'].values)
15205 2008
Name: 年代, dtype: object
['2008\u200e']
替换该条目的"年代"字段
df3.loc[15205,'年代'] = 2008
再次将"年代"转换为int类型
df3.年代 = df3.年代.astype("int")
成功
同样的，再对其他有必要的列进行数据转换
df3.评分 = df3.评分.astype("float")
print(df3[df3.时长 == '8U']['时长'])
df3 = df3.drop([31644])
print(df3[df3.时长 == '12J']['时长'])
df3 = df3.drop([32949])
Series([], Name: 时长, dtype: object)
32949 12J
Name: 时长, dtype: object
df3.时长 = df3.时长.astype("float")
排序
按值排序
DataFrame.sort_values(by,ascending,axis,kind,inplace,ignore_index) -> DataFrame
该方法用于按指定列的值对DataFrame进行排序。
| 参数 | 说明 |
|---|---|
by | 排序参照的列标,可以为列标的列表，表示按照列标在列表中的索引相对应的优先度进行排序 |
axis | 要排序的轴。可以是0或1，或者是’index’或’columns’。默认值为0。 |
ascending | 是否按升序排序。可以是布尔值或布尔值列表。默认值为True。 |
inplace | 是否在原地修改DataFrame。如果为True，则不返回任何值，而是直接修改原DataFrame。默认值为False。 |
kind | 排序算法。可以是’quicksort’、‘mergesort’或’heapsort’。默认值为’quicksort’。 |
na_position | 如何处理缺失值。可以是’first’或’last’。默认值为’last’。 |
ignore_index=False | — |
按索引排序
DataFrame.sort_index(axis,level,ascending,inplace,kind,na_position,sort_remaining,ignore_index,key) -> DataFrame
| 参数 | 说明 |
|---|---|
axis | 要排序的轴。可以是0或1，或者是’index’或’columns’。默认值为0。 |
level | 要排序的索引级别。可以是字符串、数字或字符串/数字列表。默认值为None。 |
ascending | 是否按升序排序。可以是布尔值或布尔值列表。默认值为True。 |
inplace | 是否在原地修改DataFrame。如果为True，则不返回任何值，而是直接修改原DataFrame。默认值为False。 |
kind | 排序算法。可以是’quicksort’、‘mergesort’或’heapsort’。默认值为’quicksort’。 |
na_position | 如何处理缺失值。可以是’first’或’last’。默认值为’last’。 |
基本统计分析
描述性统计
DataFrame.describe() -> DataFrame
对DataFrame中的数值型数据进行描述性统计
得到包含以下条目的DatuniqueaFrame：
| 条目 | 描述 |
|---|---|
| count | 总条目数 |
| unique | 不同的值数 |
| mean | 均值 |
| std | 标准差 |
| min | 最小值 |
| 25% | 处于从低到高25%位置处的数（25%分位数） |
| 50% | 中位数 |
| 75% | 处于从低到高75%位置处的数（75%分位数） |
| max | 最大值 |
df3.describe()
很明显，可以通过描述性统计发现，有很多错误数据
求最值
DataFrame[列标].max(axis = 0, skipna = True, numeric_only = False) -> Any
求最大值
DataFrame[列标].min(axis = 0, skipna = True, numeric_only = False) -> Any
求最小值
求最值的索引
Series.idxmax() -> Series
获取最大值的索引
Series.idxmin() -> Series
获取最小值的索引
示例:
- 得到一个series的最大值和它的index
# 创建一个 Series 对象
s = pd.Series([1, 3, 7, 2, 4])
# 获取最大值的索引
max_index = s.idxmax()
# 获取最大值
max_value = s.loc[max_index]
print(f"Max value: {max_value}, Index: {max_index}")
Max value: 7, Index: 2
- 获取DataFrame中一行的最小值及其索引
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
# 获取第一行数据
row = df.loc[0]
# 获取最小值的索引
min_index = row.idxmin()
# 获取最小值
min_value = row.loc[min_index]
print(f"Min value: {min_value}, Index: {min_index}")
Min value: 1, Index: A
求均值和中值
DataFrame[列标].mean(axis = 0, skipna = True, numeric_only = False) -> Any
求均值
DataFrame[列标].median(axis = 0, skipna = True, numeric_only = False) -> Any
求中位数
求方差和标准差
DataFrame[列标].var(axis = 0, ddof = 1，skipna = True, numeric_only = False) -> Any
求方差
DataFrame[列标].std(axis = 0, ddof = 1，skipna = True, numeric_only = False) -> Any
求标准差
求和
DataFrame[列标].sum(axis = 0，skipna = True, numeric_only = False) -> Any
求和
求相关系数和协方差
DataFrame[['列标1', '列标2']].corr(method: CorrelationMethod = "pearson",min_periods = 1,numeric_only = False) -> DataFrame
求两列的相关系数
DataFrame[['列标1', '列标2']].cov(min_periods = None,ddof = 1,numeric_only = False,)-> DataFrame
求两列的协方差
df3[['投票人数', '评分']].corr()
计数
len(DataFrame) -> int
求总数据条目数
DataFrame['列标'].unique() -> ndarray
求所有唯一值
len(DataFrame['列标'].unique()) -> int/DataFrame['列标'].nunique() -> DataFrame
求唯一值数目
可以通过求唯一值发现一些错误，在上面的数据里，产地中包含了一些重复的数据，例如美国和USA,德国和西德，俄罗斯和苏联
我们可以通过数据替换的方法将这些相同国家的电影数据合并一下。
df3['产地'].replace('USA','美国', inplace = True)
df3['产地'].replace(['西德','苏联'],['德国','俄罗斯'], inplace = True)
df3['产地'].unique()
df3['产地'].nunique()
DataFrame['列标'].value_counts(subset,normalize,sort,ascending,dropna) -> Series
对一列中每个唯一值计算出现次数,默认降序排列
| 参数 | 说明 |
|---|---|
| subset: Sequence[Hashable] | None = None | 用于计算唯一组合的列标签或标签列表。 |
| normalize: bool = False | 如果为 True，则返回比例而不是频率，默认值为 False。 |
| sort: bool = True | 按频率排序，默认值为 True。 |
| ascending: bool = False | 按升序排序，默认值为 False。 |
| dropna: bool = True | 不包括包含 NA 值的行的计数，默认值为 True。 |
数据透视
创建数据透视表
pandas.pivot_table(data,values,index,columns,aggfunc,fill_value,margins,dropna,margins_name,observed,sort: bool = True) -> DataFrame
也可以用方法:DataFrame.pivot_table() -> DataFrame,它没有data参数
pivot_table 是 pandas 库中的一个函数，它可以从给定的 DataFrame 中创建一个类似于电子表格的数据透视表。使用数据透视表，我们可以快速分析数据，并且它可以提供更多的灵活性来制作给定 DataFrame 的 Excel 表单形式。它可以将数值列与两个分类列进行交叉汇总1。
| 参数 | 说明 |
|---|---|
| data: DataFrame | 必需，表示要使用的 DataFrame。 |
| values: Any = None | 可选，表示要聚合的列。可以用列表指定多个，默认为全部数值型列 |
| index: Any = None | 可选，表示在数据透视表索引(行)上分组的键。 |
| columns: Any = None | 可选，表示在数据透视表列上分组的键。 |
| aggfunc: (…) -> Any | str | list[(…) -> Any | str] | dict[Hashable, (…) -> Any | str | list[(…) -> Any | str]] = “mean” | 可选，默认为 ‘mean’，表示聚合函数。 |
| fill_value: Any = None | 可选，用于替换缺失值(或不可计算值)的值。 |
| margins: bool = False | 可选，默认为 False。如果为 True，则添加特殊的“总计”列和行。 |
| dropna: bool = True | 可选，默认为 True。如果为 True，则不包含所有条目都为 NaN 的列。 |
| margins_name: Hashable = “All” | 可选，默认为 ‘All’。当 margins 为 True 时包含总计的行/列的名称。 |
| observed: bool = False | 可选，默认为 False。仅当任何分组器为分类时适用。 |
| sort: bool = True | 可选，默认为 True。指定结果是否应排序。 |
以指定列对所有数值型列创建一个均值透视表
pd.pivot_table(df3,index=["年代","产地"],values="投票人数",aggfunc="sum")
pd.pivot_table(df3,index="产地",values=["投票人数","评分"],aggfunc=[np.sum, np.mean],fill_value=0,margins=True)
透视表过滤
把得到的透视表赋值，当作新的DataFrame进行操作，可以选择性的查看所需要的数据、进行排序或者进行其他操作
数据重塑和轴向旋转
层次化索引
Series和DataFrame可以有多个索引，层次化索引的实现是把index中靠前的索引中，相同的索引合并起来，类似于excel合并单元格，达到层次化的效果
Serie只有一个维度，只可以在这个维度上进行层次化索引，DataFrame可以在行和列上都进行层次化索引
s = pd.Series(np.arange(1,10),index=[['a','a','a','b','b','c','c','d','d'],[1,2,3,1,2,3,1,2,1]])
s
s.index
层次化索引在取值时可以用逗号隔开不同层次的索引
s['a']
s['a':'c']
s[:,1]
层次化索引展开与堆叠
展开
DataFrame.unstack(self, level: Level = -1, fill_value=None) -> DataFrame
Series.unstack(self, level: Level = -1, fill_value=None) -> DataFrame
将多层索引展开得到一个新DataFrame，不同层次的索引会作为不同的轴。
series通过unstack转成DataFrame有时会产生缺失值
s.unstack()
堆叠
DataFrame.stack(self, level: Level = -1, dropna: bool = True) -> DataFrame
Series.stack(self, level: Level = -1, fill_value=None) -> DataFrame
将不同的轴的索引堆叠为层次化索引
s.unstack().stack()
DataFrame层次化索引的创建
行索引通过设置index值，列索引通过设置column值
data = pd.DataFrame(np.arange(12).reshape(4,3),index=[['a','a','b','b',],['1','2','1','2']],columns=[['A','A','B'],['x','y','z']])
data
层次化索引的命名
之前我们知道可以通过设置names属性为索引命名，层次化索引可以为每个层次的索引分别命名
data.index.names=['row1','row2']
data.columns.names=['col1','col2']
data
交换俩个层次索引的层次
DataFrame.swaplevel(self, i: Axis = -2, j: Axis = -1, axis: Axis = 0) -> DataFrame
Series.swaplevel(self, i: Axis = -2, j: Axis = -1, axis: Axis = 0) -> DataFrame
返回互换了级别i和j的新对象，不改变原数据,i和j可以是索引所在的层次，也可以是是索引的名称
data.swaplevel('row1','row2')
索引排序
DataFrame.sort_index() -> DataFrame
参数等用到了再查
将列设置为索引
DataFrame.set_index(keys: Any,drop: bool = True,append: bool = False,inplace: bool = False,verify_integrity: bool = False) -> DataFrame
keys传入设置为索引的列名列标，以按顺序构建层次化索引
df3=df3.set_index(['产地','年代'])
df3
每一个索引都是一个元组
df3.index[0]
df3.loc[('美国',1994),['名字','评分']]
data.columns
取消层次化索引
DataFrame.reset_index() -> DataFrame
df3 = df3.reset_index()
df3
行列转换
DataFrame.T -> DataFrame
df3[:5].T
数据分组、分组运算
可以做到类似于数据透视表的效果，会更方便点
DataFrame.groupby(by,axis,level，as_index,sort,group_keys,observed,dropna,) -> DataFrameGroupBy
得到的DataFrameGroupBy对象可以使用基本统计分析的方法进行数据计算和分析
| 参数 | 说明 |
|---|---|
| by=None | 用于确定 groupby 的组。可以是Seires、映射、函数、标签、pd.Grouper 或这些的列表。 |
| axis: Axis = 0 | 要分组的轴。默认为0。 |
| level: IndexLabel | None = None |
| as_index: bool = True | 是否将分组键作为索引返回。默认为True。 |
| sort: bool = True | 是否对分组键进行排序。默认为True。 |
| group_keys: bool = True | 是否在应用函数时添加组键作为索引。默认为True。 |
| observed: bool = False | 如果此参数为True，则仅使用分类数据中观察到的类别进行分组。默认为False。 |
| dropna: bool = True | 如果此参数为True，则删除所有NaN观察值。默认为True。 |
#对评分按年代分组
#df3["评分"].groupby(df3['年代']).mean()
df3.loc[:,["评分","投票人数"]].groupby([df3['产地'],df3['年代']]).mean()
离散化处理
在实际的数据分析项目中，对有的数据属性，我们往往并不关注数据的绝对取值，只关注它所处的区间或者等级。
离散化也可称为分组、区间化。
Pandas提供了方便的函数cut():
pandas.cut(x,bins,right,labels.retbins,precision,include_lowest,duplicates)-> Series
返回值是一个分类对象。
| 参数 | 说明 |
|---|---|
x | 要被切分的类数组（array-like）数据（可以是Series、DataFrame对象），必须是1维的。 |
bins | 被切割后的区间（或者叫“桶”、“箱”、“面元”），有3种形式：一个int型的标量、标量序列（数组）或者pandas.IntervalIndex。如果填入整数n，则表示将x中的数值分成等宽的n份（即每一组内的最大值与最小值之差约相等）；如果是标量序列，序列中的数值表示用来分档的分界值。 |
right=True | 布尔值，默认为True表示包含最右侧的数值。 |
labels=None | 数组或布尔值，可选。指定分箱的标签。如果是数组，长度要与分箱个数一致；如果为False，则仅返回分箱的整数指示符，即x中的数据在第几个箱子里。 |
retbins=False | 布尔值，可选。是否显示分箱的分界值。 |
precision=3 | 整数，默认3，存储和显示分箱标签的精度。 |
include_lowest=False | 布尔值，表示区间的左边是开还是闭，默认为false，也就是不包含区间左边。 |
duplicates=True | 如果分箱临界值不唯一，则引发ValueError或丢弃非唯一。 |
df3['评分等级'] = pd.cut(df3['评分'],[0,3,5,7,9,10],labels=['E','D','C','B','A'])
#定义分隔的区间，此处是得到投票人数处于百分数处的值
#结果为：array([-118.0, 78.0, 198.0, 617.0, 2746.0, 692795.0], dtype=object)
bins = np.percentile(df3['投票人数'],[0,20,40,60,80,100])
#离散化
df3["热门程度"] = pd.cut(df3['投票人数'],bins,labels=['E','D','C','B','A'])
df3
可以通过此得到冷门高分电影
df3[(df3.热门程度=='E')&(df3.评分等级=='A')]
合并数据集
DataFrame._append(DataFrame)
将参数中的DataFrame上下合并进数据，这就要求所有列标都对的上。
通常用于因为数据量太大，存在了多个excel表格中，读取时进行的合并。
该方法会直接修改原数据。
pandas.merge(left,right,how,on,left_on,right_on,left_index,right_index,sort,suffixes,copy,indicator,validate) -> DataFrame
也可以使用方法DataFrame.merge() -> DataFrame,相应的没有left参数，其他一样。
| 参数 | 说明 |
|---|---|
left | 要合并的第一个 DataFrame 或 Series 对象。 |
right | 要合并的第二个 DataFrame 或 Series 对象。 |
how | 合并方式。可选值为 “left”, “right”, “inner”, “outer” 和 “cross”。默认为 “inner”。“left”: 左连接，仅保留左侧 DataFrame 中的键。“right”: 右连接，仅保留右侧 DataFrame 中的键。“inner”: 内连接，仅保留两个 DataFrame 中都存在的键。“outer”: 外连接，保留两个 DataFrame 中所有的键。“cross”: 交叉连接，返回两个 DataFrame 的笛卡尔积。 |
on | 用于连接的列名。必须在两个 DataFrame 对象中都存在。如果未指定，则默认为两个 DataFrame 对象中都存在的列名的交集。 |
left_on | 左侧 DataFrame 中用于连接的列名。 |
right_on | 右侧 DataFrame 中用于连接的列名。 |
left_index | 如果为 True，则使用左侧 DataFrame 的索引作为连接键。默认为 False。 |
right_index | 如果为 True，则使用右侧 DataFrame 的索引作为连接键。默认为 False。 |
sort | 按照连接键对结果 DataFrame 进行排序。默认为 False。 |
suffixes | 用于重叠列名的字符串后缀元组。默认为 (“_x”, “_y”)。 |
copy | 如果为 True，则总是从传递的 DataFrame 对象复制数据（注意，避免复制可能会影响在其他地方使用的数据）。默认为 None，表示仅在必要时才复制数据。 |
indicator | 如果为 True，则在输出 DataFrame 中添加一列名为 _merge 的 Categorical 类型列，用于指示合并情况。如果传递字符串，则该字符串将用作列名。默认为 False。 |
validate | 如果指定，则检查合并键上是否存在重复项。可选值有 “one_to_one”、“one_to_many” 或 “many_to_one”。 “one_to_one”: 检查合并键在左侧和右侧 DataFrame 中都是唯一的。“one_to_many”: 检查合并键在左侧 DataFrame 中是唯一的。“many_to_one”: 检查合并键在右侧 DataFrame 中是唯一的。如果检查失败，则会引发一个 MergeError 异常。 |
pandas.concat(objs: Iterable[NDFrame] | Mapping[HashableT, NDFrame],*,axis: Axis = 0,join: str = "outer",ignore_index: bool = False,keys=None,levels=None,names=None,verify_integrity: bool = False,sort: bool = False,copy: bool | None = None,)
批量合并数据
| 参数 | 说明 |
|---|---|
objs | 要连接的 pandas 对象序列或映射。如果传递了映射，则连接的键将用作结果对象中的键。 |
axis | 要连接的轴。默认为 0。 |
join | 连接方式。可选值为 “outer” 和 “inner”。默认为 “outer”。 |
ignore_index | 如果为 True，则不使用连接轴上的索引值。结果轴将被重新索引为默认整数索引。默认为 False。 |
keys | 用于构造分层索引的序列，默认为 None。如果传递了多个级别，则应该包含元组。 |
levels | 指定用于构造分层索引的级别，默认为 None。 |
names | 用于结果轴的名称列表，默认为 None。 |
verify_integrity | 如果为 True，则检查新连接的轴是否包含重复项。如果检查失败，则会引发异常。默认为 False。 |
sort | 按字典顺序对非连接轴进行排序，以避免在连接时重新排序。默认为 False。 |
copy | 如果为 True，则总是从传递的 DataFrame 对象复制数据（注意，避免复制可能会影响在其他地方使用的数据）。默认为 None，表示仅在必要时才复制数据。 |
如：df = pd.concat([df1,df2,df3])
Matplotlib
matplotlib是一个Python的2D图形包。pyplot封装了很多画图的函数。
导入相关的包：
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt
matplotlib.pyplot包含一系列类似MATLAB中绘图函数的相关函数。每个matplotlib.pyplot中的函数对当前的图像进行一些修改，例如：产生新的图像，在图像中产生新的绘图区域，在绘图区域中画线，给绘图加上标记，等等.…matplotlib.pyplot会自动记住当前的图像和绘图区域，因此这些函数会直接作用在当前的图像上。
在实际的使用过程中，常常以plt作为matplotlib.pyplot的省略。
除此之外,还有一个包: mlab
import matplotlib.mlab as mlab
设置参数以正常显示中文和负号等内容
-
plt.rcParams['font.sans-serif'] = ['SimHei']设置字体为黑体(以正常显示中文) -
plt.rcParams['axes.unicode_minus'] = False设置正常显示负号
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
关闭警告
import warnings
warnings.filterwarnings('ignore')
这样就不会跳出一些关于函数即将弃用和函数即将被取代的警告了
展示图象
plt.show0函数
默认情况下，matplotlib.pyplot不会直接显示图像，只有调用plt.show0函数时，图像才会显示出来。
plt.sow0默认是在新窗口打开一幅图像，并且提供了对图像进行操作的按钮。
不过在ipython命令行中，我们可以使用魔术命令将它插入到notebook中，并目不需要调用plt.show()也可以显示：
-
%matplotlib notebook -
%matplotlib inline
不过在实际写程序中，我们还是习惯调用plt.show()函数将图像显示出来。
绘制线型图
plt.plot(*args: Any, scalex: bool = True, scaley: bool = True, data: Any = None, **kwargs: Any) ->
| 参数 | 说明 |
|---|---|
*args | 一组表示 x 和 y 坐标的位置参数。先x后y。可以是多种形式，例如两个一维数组 x 和 y，或者一个二维数组 y。如果不指定x坐标，则自动以索引为x坐标。 |
scalex | 如果为 True，则自动缩放 x 轴。默认为 True。 |
scaley | 如果为 True，则自动缩放 y 轴。默认为 True。 |
data | 可选参数。如果给定，则使用它来构造默认变量。 |
**kwargs | 一组关键字参数，用于控制线条的外观和其他绘图选项。 |
返回值是一个Line2D对象或多个Line2D对象的列表，表示绘制的线条。
可以通关循环式的传入参数来绘制多条线
plt.plot([1, 2, 3, 3])
plt.show()
temp = np.arange(0,5,0.2)
plt.plot(temp,temp,"r--",
temp,np.e**temp,
temp,temp**3,"g:d")
plt.show()
添加标题
plt.title(label, fontdict=None, loc=None, pad=None, *, y=None, **kwargs)
| 参数 | 描述 |
|---|---|
label | 此参数接受一个字符串，表示要应用的标题。 |
fontdict | 此参数允许您为标题文本指定字体属性。 |
loc | 此参数控制文本的位置。 |
pad | 此参数控制标题与轴顶部的偏移量。 |
y | 此参数控制标题的垂直对齐方式。 |
**kwargs | 允许您传递任意数量的关键字参数，以进一步自定义标题。 |
**kwargs参数支持的关键字参数：
| 参数 | 描述 |
|---|---|
| fontsize | 控制字体大小。 |
| fontweight | 控制字体粗细。 |
| fontstyle | 控制字体样式。 |
| fontfamily | 控制字体族。 |
| color | 控制文本颜色。 |
- fontstyle参数用于控制字体样式。它可以接受以下值之一：
| 值 | 描述 |
|---|---|
| ‘normal’ | 正常字体。 |
| ‘italic’ | 斜体。 |
| ‘oblique’ | 倾斜字体。 |
- fontfamily参数用于控制字体族。它可以接受以下值之一：
| 值 | 描述 |
|---|---|
| ‘serif’ | 衬线字体。 |
| ‘sans-serif’ | 无衬线字体。 |
| ‘cursive’ | 草书字体。 |
| ‘fantasy’ | 幻想字体。 |
| ‘monospace’ | 等宽字体。 |
- color参数用于控制文本颜色。它可以接受多种格式的颜色值，包括：
| 格式 | 示例 |
|---|---|
| 十六进制RGB或RGBA字符串 | '#FF0000' |
| RGB或RGBA元组 | (1, 0, 0) |
| 灰度值的字符串表示形式 | '0.5' |
| 单个字符的简写表示法 | 'r' |
| 不带空格的X11/CSS4颜色名称 | 'red' |
指定x坐标名称和y坐标名称
plt.ylabel(ylabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)
指定y坐标名称
| 参数 | 解释 |
|---|---|
ylabel | y 轴标签的文本。 |
fontdict | 可选字典，用于控制文本的外观。支持的键包括 ‘fontsize’、‘fontweight’ 等。 |
labeyylpad | 标签与轴之间的间距（以点为单位）。默认为 None，表示使用 rcParams[“axes.labelpad”] 的值。 |
loc | 标签位置。可选值为 ‘center’、‘top’ 和 ‘bottom’。默认为 None，表示使用 xrcParams[“yaxis.labellocation”] 的值。 |
**kwargs | 一组关键字参数，用于控制文本的外观。 |
plt.xlabel(xlabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)
指定x坐标名称
参数同plt.ylabel()
plt.plot([1,2,3,4],[1,4,9,16])
plt.xlabel("x")
plt.ylabel("y")
plt.show()
线条样式控制
线条样式控制可以通过在绘制图片的函数的参数中加入字符串参数来实现，在参数定义中为**kwargs
| 参数 | 说明 |
|---|---|
| color | 修改颜色，可以简写成c |
| linestyle | 修改线条的样式 可以简写成 ls |
| marker | 标注(点型) |
| linewidth | 设置线条粗细 可以简写成 lw （lw=2） |
| markeredgecolor | 点边缘的颜色 |
| markeredgewidth | 点边缘粗细 |
| markeredgecolor | 点内部颜色 |
| markersize | 点的大小 |
下面是各个参数可选的字符：
颜色：
marker点型：
线条样式：
用法：
plt.plot([1,2,3,4],[1,4,9,16],c='r',linestyle='--',marker='o')
也可以直接用一个字符：
plt.plot([1,2,3,4],[1,4,9,16],'r--o')
plt.plot([1,2,3,4],[1,4,9,16],'r--o')
plt.show()
线条属性设置
可以通过绘图函数返回的Line2D对象来设置线条属性
Line2D.set_antialiased()是否抗锯齿，该属性默认为True
也可以使用plt.setp(obj: Any, *args: Any, **kwargs: Any) -> list[Any | None] | None函数来设置
temp2 = np.linspace(-np.pi,np.pi)
line1, line2 = plt.plot(temp2, np.sin(temp2), temp2, np.sin(temp2) + 1)
# 关闭抗锯齿
line2.set_antialiased(False)
# 设置线条宽度为5
plt.setp(line2, linewidth=5)
# 使用MatLab风格的参数
plt.setp(line2, 'color','r','linestyle','--')
plt.show()
显示范围控制
plt.axis([xmin, xmax, ymin, ymax])
plt.plot([1,2,3,4],[1,4,9,16],'r--o')
plt.axis([0, 6, 0, 20])
plt.show()
设置刻度线样式
plt.tick_params(axis, which, reset, **kwargs)
该函数用于更改刻度线、刻度标签和网格线的外观。除非reset为True，否则未使用关键字参数显式设置的刻度属性将保持不变。有关当前样式设置，请参阅Axis.get_tick_params。
| 参数 | 说明 |
|---|---|
axis='both' | 应用参数的轴。可以是 'x'、'y' 或 'both'。默认值为 'both'。 |
which='major' | 应用参数的刻度组。可以是 'major'、'minor' 或 'both'。默认值为 'major'。 |
reset=False | 是否在处理其他关键字参数之前将所有参数重置为默认值。 |
**kwargs | 其他关键字参数。 |
该函数的**kwargs参数支持以下关键字参数：
| 参数 | 说明 |
|---|---|
direction | 刻度线的方向。可以是 'in'、'out' 或 'inout'。 |
length | 刻度线的长度（以点为单位）。 |
width | 刻度线的宽度（以点为单位）。 |
color | 刻度线的颜色。 |
pad | 刻度线和标签之间的距离（以点为单位）。 |
labelsize | 刻度标签的字体大小（以点为单位），也可以是字符串（例如 'large'）。 |
labelcolor | 刻度标签的颜色。 |
colors | 刻度线和标签的颜色。 |
zorder | 刻度线和标签的zorder。 |
bottom, top, left, right | 是否绘制相应的刻度线。 |
labelbottom, labeltop, labelleft, labelright | 是否绘制相应的刻度标签。 |
labelrotation | 刻度标签旋转角度。 |
grid_color | 网格线颜色。 |
grid_alpha | 网格线透明度：0（透明）到1（不透明）。 |
grid_linewidth | 网格线宽度（以点为单位）。 |
grid_linestyle | 任何有效的Line2D线条样式规范。 |
设置横纵标签样式
plt.xticks(ticks, labels, **kwargs)
该函数用于获取或设置x轴的刻度位置和标签。如果不传递任何参数，则返回当前值而不修改它们。
plt.yticks(ticks, labels, **kwargs)
该函数用于获取或设置y轴的刻度位置和标签。如果不传递任何参数，则返回当前值而不修改它们。
| 参数 | 说明 |
|---|---|
ticks | 刻度位置的数组。如果传递一个空列表，则删除所有xticks。 |
labels | 要放置在给定刻度位置的标签。 |
**kwargs | 用于控制标签外观的文本属性。 |
该函数的**kwargs参数支持文本属性，用于控制标签的外观。这些属性包括：
| 参数 | 说明 |
|---|---|
fontsize | 字体大小。 |
fontweight | 字体粗细。 |
fontstyle | 字体样式。 |
fontfamily | 字体族。 |
color | 文本颜色。 |
rotation | 文本旋转角度。 |
添加文本
plt.text(x, y, s, fontdict, **kwargs)
该函数用于在坐标轴上添加文本。它将文本s添加到数据坐标中的位置x，y。
| 参数 | 说明 |
|---|---|
x | 文本的x坐标。 |
y | 文本的y坐标。 |
s | 要添加的文本。 |
fontdict | 用于覆盖默认文本属性的字典。如果fontdict为None，则默认值由rcParams确定。 |
**kwargs | 文本属性。 |
该函数的**kwargs参数支持文本属性，用于控制文本的外观。这些属性包括：
| 参数 | 说明 |
|---|---|
fontsize | 字体大小。 |
fontweight | 字体粗细。 |
fontstyle | 字体样式。 |
fontfamily | 字体族。 |
color | 文本颜色。 |
rotation | 文本旋转角度。 |
horizontalalignment | 可以简写为ha，水平对齐方式。可以是 'left'、'center' 或 'right'。 |
verticalalignment | 可以简写为va，垂直对齐方式。可以是 'top'、'center' 或 'bottom'。 |
添加箭头注释点
plt.annotate()
该函数用于向图表添加注释。
| 参数 | 说明 |
|---|---|
text | 注释文本 |
xy | 要注释的点 (x, y) |
xytext | 文本位置 (x, y)。如果为 None，则默认为 xy |
xycoords | xy 所给出的坐标系 |
textcoords | xytext 所给出的坐标系。如果为 None，则默认为 xycoords |
arrowprops | 绘制从文本到被注释点的箭头的属性字典 |
annotation_clip | 当被注释点在轴区域外时是否绘制注释 |
**kwargs | 其他关键字参数 |
arrowprops 参数支持的关键字参数及其值：
| 关键字参数 | 值 |
|---|---|
width | 箭头宽度（以点为单位） |
headwidth | 箭头底部宽度（以点为单位） |
headlength | 箭头长度（以点为单位） |
shrink | 从两端收缩的总长度的百分比 |
facecolor | 箭头颜色 |
edgecolor | 箭头边缘颜色 |
arrowstyle | 箭头样式 |
connectionstyle | 箭头连接样式 |
relpos | 箭头相对于文本的位置 |
此函数返回一个注释对象。
网格线设置
plt.grid()
该函数用于配置网格线。它接受以下参数：
| 参数 | 说明 |
|---|---|
visible | 是否显示网格线。如果提供了任何kwargs，则假定您希望网格打开且visible将设置为True。如果visible为None且没有kwargs，则切换线的可见性。 |
which | 应用更改的网格线。可以是 'major', 'minor', 或 'both'. 默认值为 'major'. |
axis | 应用更改的轴。可以是 'both', 'x', 或 'y'. 默认值为 'both'. |
**kwargs | Line2D属性，用于定义网格线的线条属性，例如：grid(color=‘r’, linestyle=‘-’, linewidth=2) |
绘制图例
plt.legend()
该函数用于在当前坐标轴上添加图例。下面是对它的参数的解释：
| 参数 | 默认值 | 说明 |
|---|---|---|
handles | None | 要添加到图例中的艺术家（线条，补丁）列表 |
labels | None | 要显示在艺术家旁边的标签列表 |
loc | 'best' | 图例的位置 |
ncol | 1 | 图例中的列数 |
fontsize | 'medium' | 字体大小 |
title | None | 图例标题 |
loc 参数可以取多种值来控制图例的位置。下面是一些可用的值：
| 值 | 说明 |
|---|---|
'best' | 让 matplotlib 自动选择最佳位置 |
'upper right' | 将图例放在坐标轴的右上角 |
'upper left' | 将图例放在坐标轴的左上角 |
'lower left' | 将图例放在坐标轴的左下角 |
'lower right' | 将图例放在坐标轴的右下角 |
'right' | 将图例放在坐标轴的右侧 |
'center left' | 将图例放在坐标轴的左侧中央 |
'center right' | 将图例放在坐标轴的右侧中央 |
'lower center' | 将图例放在坐标轴的底部中央 |
'upper center' | 将图例放在坐标轴的顶部中央 |
'center' | 将图例放在坐标轴的中心 |
改变背景色
ax = plt.gca()
获取当前的坐标系对象
ax.patch.set_facecolor('gray')
将背景色设置为灰色
ax.set_alpha(0.3)
设置背景透明度为0.3
子图
plt.figure(num,figsize,dpi,facecolor,edgecolor,frameon,FigureClass,clear,**kwargs)
figure 是一个函数，它用于创建一个新的图形或激活(表示现在要对指定的一个图象进行操作)现有图形。它接受以下参数：
| 参数 | 说明 |
|---|---|
num=None | 图形编号，如果为 None 则自动递增，否则为 1-N 的整数 |
figsize=None | 图形大小，默认为 rc figure.figsize |
dpi=None | 分辨率，默认为 rc figure.dpi |
facecolor=None | 图形背景颜色，默认为 rc figure.facecolor |
edgecolor=None | 图形边框颜色，默认为 rc figure.edgecolor |
frameon=True | 是否绘制图形边框，默认为 True |
FigureClass=Figure | 图形类，默认为 Figure |
clear=False | 如果为 True，则清除现有图形，默认为 False |
**kwargs | 其他关键字参数 |
plt.subplot(numrows,numcols,fignum)
subplot函数用于在一个图形中创建多个子图。它接受以下参数：
一般会用到的参数：
| 参数 | 说明 |
|---|---|
numrows=1 | 子图网格的行数 |
numcols=1 | 子图网格的列数 |
fignum | 选择对第几个子图进行做题，子图的编号为从1开始，从左到右，从上到下依次递增。 |
详细参数：
| 参数 | 说明 |
|---|---|
nrows=1 | 子图网格的行数 |
ncols=1 | 子图网格的列数 |
sharex=False | 控制 x 轴的属性共享。可以是布尔值或 {‘none’, ‘all’, ‘row’, ‘col’} 中的一个，默认值为 False。 |
sharey=False | 控制 y 轴的属性共享。可以是布尔值或 {‘none’, ‘all’, ‘row’, ‘col’} 中的一个，默认值为 False。 |
squeeze=True | 是否从返回的 Axes 数组中挤出额外的维度 |
subplot_kw=None | 传递给用于创建每个子图的 add_subplot 调用的关键字参数字典 |
gridspec_kw=None | 传递给用于创建子图所放置的网格的 GridSpec 构造函数的关键字参数字典 |
**fig_kw | 所有其他关键字参数都传递给 pyplot.figure 调用 |
返回值为一个包含图形和 Axes 对象（或 Axes 对象数组）的元组。您可以使用这些对象来自定义子图的布局和外观。
当numrows*numcols < 10时，中间的逗号可以省略，因此plt.subplot(211)就相当于plt.subplot(2,1,1)。
def f(t):
return np.exp(-t)*np.cos(2*np.pi*t)
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
# 创建一张图
plt.figure(figsize=(5,6))
# 告诉电脑这张图的子表为2*1，并且选择第一个子表
plt.subplot(211)
#对第一个子表进行绘制
plt.plot(t1,f(t1),'bo', t2, f(t2), 'k')
# 告诉电脑这张图的子表为2*1，并且选择第二个子表
plt.subplot(212)
#对第二个子表进行绘制
plt.plot(t2, np.cos(2*np.pi*t2),'r--')
plt.show()
绘制柱状图
plt.bar(x,height,width,bottom,align,data,**kwargs)
该函数用于在当前坐标轴上创建条形图。
| 参数 | 说明 |
|---|---|
x | 条形的 x 坐标 |
height | 条形的高度 |
width=0.8 | 条形的宽度 |
bottom=None | 条形的 y 坐标 |
align='center' | 条形的对齐方式，可以是 ‘center’ 或 ‘edge’，默认值为 ‘center’。 |
data=None | 可选参数，用于构造默认数据 |
**kwargs | 其他关键字参数 |
该函数返回一个由当前坐标轴上的条形组成的容器 。
data = df3['产地'].value_counts()
data
美国 11866
日本 5053
中国大陆 3803
中国香港 2852
法国 2817
英国 2763
其他 1920
韩国 1351
德国 902
意大利 749
加拿大 723
中国台湾 618
西班牙 447
印度 357
澳大利亚 300
泰国 294
苏联 256
俄罗斯 221
丹麦 198
瑞典 194
波兰 181
荷兰 155
比利时 139
西德 130
墨西哥 119
阿根廷 116
USA 113
巴西 101
Name: 产地, dtype: int64
# 定义x轴
x=data.index
# 定义y轴
y=data.values
# 创建图象
plt.figure(figsize=(10,6))
# 绘制图象
plt.bar(x,y,color='g')
# 设置
plt.title('各国家或地区电影数量', fontsize=20)
plt.xlabel('国家或地区', fontsize=18)
plt.ylabel('电影数量', fontsize=18)
plt.tick_params(labelsize=14)
plt.xticks(rotation=90)
# 添加详细数据的显示
for a, b in zip(x, y):
plt.text(a, b, b, ha = 'center', va = 'bottom', fontsize = 10)
plt.show()
绘制折线(线型)图,参数见上方绘制线型图
plt.plot()
绘制线型图
data = df3['年代'].value_counts()
data = data.sort_index()[:-3]#去除包括2016年的不合理数据,2016年只记录了几个月的数据,其他年份都记录了一年的数据
data
1888 2
1890 1
1892 1
1894 3
1895 8
...
2011 1866
2012 2042
2013 2001
2014 1887
2015 1592
Name: 年代, Length: 125, dtype: int64
data.max()
2042
x = data.index
y = data.values
plt.plot(x,y,color='b')
plt.title('每年电影数据', fontsize=20)
plt.xlabel('年份', fontsize=18)
plt.ylabel('电影数量', fontsize=18)
# 每隔十年显示具体数值
for a, b in zip(x[::10], y[::10]):
plt.text(a, b+10, b, ha = 'center', va = 'bottom', fontsize = 10)
# 绘制注释
plt.annotate(str(data.idxmax())+'年达到最大值', xy=(data.idxmax(),data.max()),xytext=(data.idxmax(),data.max()+300), arrowprops=dict(facecolor='white', edgecolor='red'))
plt.show
<function matplotlib.pyplot.show(close=None, block=None)>
绘制饼图
plt.pie(x, explode, labels, colors, autopct, pctdistance, shadow, labeldistance, startangle, radius, counterclock, wedgeprops, textprops, center, frame, rotatelabels, *, normalize, hatch, data)
| 参数 | 说明 |
|---|---|
x | 饼图每个扇形的大小，可以使用归一化后的数据,也可以使用未归一化(sum(x)>1)的数据,未归一化的数据会自动使用sum(x)归一化 |
explode=None | 每个扇形与中心的偏移量 |
labels=None | 每个扇形的标签 |
colors=None | 每个扇形的颜色 |
autopct=None | 用于标记每个扇形百分比的字符串或函数,'%1.1f’指小数点前后位数(没有用空格补齐) |
pctdistance=0.6 | 百分比标记与中心的距离相对于半径的比例 |
shadow=False | 是否绘制阴影 |
labeldistance=1.1 | 标签与中心的距离相对于半径的比例,<1会绘制在饼图内侧 |
startangle=0 | 起始角度，以 x 轴正方向为 0 度，逆时针旋转 |
radius=1 | 饼图半径 |
counterclock=True | 是否逆时针绘制饼图 |
wedgeprops=None | 扇形属性字典 |
textprops=None | 文本属性字典 |
center=(0,0) | 饼图中心位置 |
frame=False | 是否绘制轴框架 |
rotatelabels=False | 是否旋转每个标签到指定角度 |
normalize=True | 是否将 x 归一化为和为1 |
hatch =None | 每个扇形的阴影填充样式 |
data=None | 可选参数，用于构造默认数据 |
返回值：如果没有设置autopct,.返回(patches, (标注的文字的可迭代对象))
如果设置autopct,返回(patches, texts(标注的文字的可迭代对象), autotexts(百分比文字的可迭代对象))
可以通过返回值对各个文字进行设置
data = pd.cut(df3['时长'],[0,60,90,110,1000]).value_counts()
data
(90, 110] 13233
(0, 60] 10324
(60, 90] 7727
(110, 1000] 7450
Name: 时长, dtype: int64
y = data.values
# y = y/sum(y)
# 绘制饼图
plt.figure(figsize=(7,7))
plt.title('电影时长占比',fontsize=15)
patches, text_1, text_p = plt.pie(y, labels=data.index, autopct='%.1f %%', colors='bygr', startangle=90, shadow=True)
# 设置文字属性
for i in text_p:
i.set_size(15)
i.set_color('w')
for i in text_1:
i.set_size(15)
i.set_color('r')
# 绘制图例
plt.legend(loc='upper left')
plt.show()
直方图
plt.hist()
该函数的参数非常多，但常用的就这六个，只有第一个是必须的，后面可选
| 参数 | 说明 |
|---|---|
| arr | 需要计算直方图的一维数组 |
| bins | 直方图的柱数，可选项，默认为10 |
| normed | 是否将得到的直方图向量归一化。默认为0 |
| facecolor | 直方图领色 |
| edgecolor | 直方图边框颜色 |
| alpha | 透明度 |
| histtype | 直方图类型’bar’,barstacked’,‘step’,‘stepfilled’ |
返回值：
n:直方图向量，是否归一化由参数normed设定
bins:返回各个bin的区间范围
patches:返回每个bin里面包含的数据，是一个list
可以通过返回值设置各种属性
plt.figure(figsize=(10,6))
plt.hist(df3['评分'],bins=20,edgecolor='k',alpha=0.5)
plt.show()
可以看到,电影评分是个左偏的正态分布
绘制双轴图
注:之前我们是使用api方式进行的绘图,在这里,我们使用面向对象方式绘图
ax2=ax1.twinx()
生成共用x轴,不共用y轴的图象
from scipy.stats import norm
fig=plt.figure(figsize=(10,6))
ax1=fig.add_subplot(111)
n, bins, patches = ax1.hist(df3['评分'],bins=100,color='m')
ax1.set_ylabel('电影数量',fontsize=15)
ax1.set_xlabel('评分',fontsize=15)
ax1.set_title('频率分布图',fontsize=20)
# 计算正态概率密度函数
#scipy.stats.norm.pdf(bins,mu,sigma)
y=norm.pdf(bins,df3['评分'].mean(),df3['评分'].std())
# 生成与ax1共用x轴,不共用y轴的图象
ax2=ax1.twinx()
ax2.plot(bins,y,'b--')
ax2.set_ylabel('概率分布', fontsize=15)
plt.show()
绘制散点图
plt.scatter()
该函数用于在当前坐标轴上创建散点图。下面是对它的参数的解释：
| 参数 | 说明 |
|---|---|
x | x 坐标数据 |
| y | y 坐标数据 |
| s=None | 点的大小（以点为单位） |
| c=None | 点的颜色 |
| marker=None | 点的形状 |
| cmap=None | 颜色映射表 |
| norm=None | 归一化方法，用于将数据映射到 [0,1] 区间 |
| vmin=None | 颜色映射表的最小值 |
| vmax=None | 颜色映射表的最大值 |
| alpha=None | 透明度 |
| linewidths=None | 线宽 |
| edgecolors=None | 边缘颜色 |
| plotnonfinite=False | 是否绘制非有限值（例如 NaN 和 inf） |
| data=None | 可选参数，用于构造默认数据 |
x=df3['时长'][::100]
y=df3['评分'][::100]
plt.figure(figsize=(10,6))
plt.scatter(x,y,color='c',marker='p')
plt.title('电影时长与评分散点图',fontsize=20)
plt.xlabel('时长',fontsize=18)
plt.ylabel('评分',fontsize=18)
plt.show()
绘制箱形图(盒须图、盒式图、箱线图)
plt.boxplot()
| 参数 | 说明 |
|---|---|
| x | 指定要绘制箱线图的数据 |
| notch | 是否是凹口的形式展现箱线图，默认非凹口 |
| sym | 指定异常点的形状，默认为+号显示 |
| vert | 是否需要将箱线图垂直摆放，默认垂直摆放 |
| whis | 指定上下须与上下四分位的距离，默认为1.5倍四分位差 |
| positions | 指定箱线图的位置，默认为[0,1,2] |
| widths | 指定箱线图的宽度，默认为0.5 |
| patch_artist | 是否填充箱体的颜色 |
| meanline | 是否用线的形式表示均值，默认用点来表示 |
| showmeans | 是否显示均值，默认不显示 |
| showcaps | 是否显示箱线图顶端和末端的两条线，默认显示 |
| showbox | 是否显示箱线图的箱体，默认显示 |
| showfliers | 是否显示异常值，默认显示 |
| boxprops | 设置箱体的属性，如边框色，填充色等 |
| labels | 为箱线图添加标签，类似于图例的作用 |
| flierprops | 设置异常值的属性，如异常点的形状、大小、填充色等 |
| medianprops | 设置中位数的属性，如线的类型、粗细等 |
| meanprops | 设置均值的属性，如点的大小、颜色等 |
| capprops | 设置箱线图顶端和末端线条的属性，如颜色、粗细等 |
| whiskerprops | 设置须的属性，如颜色、粗细、线的类型等 |
一般计算过程
(1)计算上四分位数(Q3),中位数，下四分位数(Q1)
(2)计算上四分位数和下四分位数之间的差值，即四分位数差(IQR,interquartile range)Q3-Q1
(3)绘制箱线图的上下范围，上限为上四分位数，下限为下四分位数。在箱子内部中位数的位置绘制横线
(4)大于上四分位数1.5倍四分位数差的值，或者小于下四分位数1.5倍四分位数差的值，划为异常值(outliers)
(5)异常值之外，最靠近上边缘和下边缘的两个值处，画横线，作为箱线图的触须
(6)极端异常值，即超出四分位数差3倍距离的异常值，用实心点表示；较为温和的异常值，即处于1.5倍-3倍四分位数差之间的异常值，用空心点表示
(7)为箱线图添加名称，数轴等
data = df3[df3.产地=='美国']['评分']
plt.figure(figsize=(10,6))
plt.boxplot(data,whis=2,flierprops={'marker':'o','markerfacecolor':'r','color':'k'},
patch_artist=True,boxprops={'color':'k','facecolor':'#9999ff'})
plt.title("美国电影评分",fontsize=20)
plt.show()
- 多组数据箱线图
datal=df3[df3.产地=='中国大陆']['评分']
data2=df3[df3.产地=='日本']['评分']
data3=df3[df3.产地=='中国香港']['评分']
data4=df3[df3.产地=='英国']['评分']
data5=df3[df3.产地=='法国']['评分']
plt.figure(figsize=(12,8))
plt.boxplot([datal,data2,data3,data4,data5],labels=['中国大陆','日木','中国香港','英国','法国'],whis=2,
flierprops={'marker':'o','markerfacecolor':'r','color':'k'},
patch_artist=True,boxprops={'color':'k','facecolor':'#9999ff'},vert=False)
plt.title('电影评分箱线图',fontsize=20)
plt.show()
相关系数矩阵图–热力图
data=df3[['投票人数','评分','时长']]
data[:5]
| 投票人数 | 评分 | 时长 | |
|---|---|---|---|
| 0 | 692795.0 | 9.6 | 142.0 |
| 1 | 42995.0 | 9.5 | 116.0 |
| 2 | 327855.0 | 9.5 | 116.0 |
| 3 | 580897.0 | 9.4 | 142.0 |
| 4 | 478523.0 | 9.4 | 171.0 |
pandas本身也封装了画图函数
我们可以画出各个属性之间的散点图，对角线是分布图
#用%pylab inline魔术命令使pandas的图象显示在jupyter notebook中
#result=pd.scatter_matrix(data[::100],diagonal='kde',alpha=0.3,figsize=(10,10))已弃用
result=pd.plotting.scatter_matrix(data[::100],diagonal='kde',alpha=0.3,figsize=(10,10))
我们可以画出各个属性之间的散点图，对角线是直方图
result=pd.plotting.scatter_matrix(data[::100],diagonal='hist',alpha=0.3,figsize=(10,10))
现在我们来画电影时长，投票人数，评分的一个相关系数矩阵图
seaborn是一个精简的oython库，可以创建具有统计意义的图表，能理解pandas的DataFrame类型
参数详解
seaborn.heatmap(data,vmin=None,vmax=None,cmap=None,center=None,robust=False,annot=None,fmt=‘.2g’,annot_kws=None,linewidths=0,linecolor=‘white’,cbar=True,cbar_kws=None,cbar_ax=None,square=False,xticklabels=‘auto’,yticklabels=‘auto’,mask=None,ax=None,"kwargs)
(1)热力图输入数据参数：
data:矩阵数据集，可以是numpy的数组(array),也可以是pandas的DataFrame.。如果是DataFrame,则df的lifidex/column信息会分别对应到heatmap的columns和rows,即pt.index是热力图的行标，pt.columns:是热力图的列标
(2)热力图矩阵块颜色参数：
vmax,vmin:分别是热力图的颜色取值最大和最小范围，默认是根据data数据表里的取值确定cmap:从数字到色彩空间的映射，取值是matplotlib包里的colormap名
称或颜色对象，或者表示颜色的列表：改参数默认值：根据center参数设定center:数据表取值有差异时，设置热力图的色彩中心对齐值；通过设置centerf值，可以
调整生成的图像颜色的整体深浅：设置center数据时，如果有数据溢出，则手动设置的vmax、vmin会自动改变robust:默认取值False;如果是False,且没设定vmin和vmax的值
(3)热力图矩阵块注释参数：
annot(annotate的缩写)：默认取值False:如果是True,在热力图每个方格写入数据；如果是矩阵，在热力图每个方格写入该矩阵对应位置数据fmt:字符串格式代
码，矩阵上标识数字的数据格式，比如保留小数点后几位数字annot_kws:默认取值False;如果是True,设置热力图矩阵上数字的大小颜色字体，matplotlib包text类下的字体设置：
(4)热力图矩阵块之间间隔及间隔线参数：
linewidths:定义热力图里表示两两特征关系的矩阵小块"之间的间隔大小linecolor:切分热力图上每个矩阵小块的线的颜色，默认值是white’
(5)热力图颜色刻度条参数：
cbar:是否在热力图侧边绘制颜色刻度条，默认值是True cbar_kws:热力图侧边绘制颜色刻度条时，相关字体设置，默认值是None cbar_ax:热力图侧边绘制颜色刻度条时，刻度条位置设置，默认值是None
(6)square:设置热力图矩阵小块形状，默认值是False
xticklabels,yticklabels:xticklabels控制每列标签名的输出：yticklabels控制每行标签名的输出。默认值是auto。如果是True,则以DataFrame的列名作为标签名。如果是Fs,则不添加行标签名。如果是列表，则标签名改为列表中给的内容。如果是整数K,则在图上每隔K个标签进行一次标注。
import seaborn as sns
corr=data.corr()
corr=abs(corr)
fig=plt.figure(figsize=(10,8))
#ax=fig.add_subplot(figsize=(10,8))
ax=plt.subplots(figsize=(10,8))
ax=sns.heatmap(corr,vmax=1,vmin=0,annot=True,annot_kws={'size':13,'weight':'bold'},linewidths=0.05)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.show()
<Figure size 1000x800 with 0 Axes>
Scipy
Scipy是依赖于Numpy的科学计算库
SciPy模块功能表
| 模块 | 功能 |
|---|---|
| scipy.cluster | 聚类分析等 |
| scipy.constants | 物理和数学常数 |
| scipy.fftpack | 傅里叶变换 |
| scipy.integrate | 积分 |
| scipy.interpolate | 插值 |
| scipy.io | 数据输入和输出 |
| scipy.linalg | 线性代数 |
| scipy.ndimage | n维图像 |
| scipy.odr | 正交距离回归 |
| scipy.optimize | 优化 |
| scipy.signal | 信号处理 |
| scipy.sparse | 稀疏矩阵 |
| scipy.spatial | 空间数据结构和算法 |
| scipy.special | 特殊函数 |
| scipy.stats | 统计 |
1061
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
