一、 Numpy库简介
1.1、概念
NumPy(Numerical Python)是一个开源的Python科学计算库，旨在为Python提供 高性能的多维数组对象和一系列工具。NumPy数组是Python数据分析的基础，许多 其他的数据处理库（如Pandas、SciPy）都依赖于NumPy。
NumPy的一些主要特点：
1. 高性能：NumPy底层主要采用C语言编写，相比于python来说运算速度快，性能 优越，并且保留了python的易用性。
2. 多维数组：NumPy提供了强大的n维数组对象ndarray，可进行高效的数据处 理，这是Numpy进行数据处理的核心对象。
3. 丰富的函数：NumPy内置了大量数学、统计和线性代数函数，方便进行数据计 算，除此之外还具有广播功能，可以允许不同形状的数组进行算术运算。
4. 广泛的接口：NumPy与许多其他科学计算库（如Matplotlib、SciPy）兼容，可 轻松实现数据交换和集成，此外，在人工智能领域中也可以很方便的和神经网络 中使用的张量进行结构转换。
1.2、安装
pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple/
二、Numpy-array与list的区别
Python中的list虽然可以灵活的处理多个元素，但它的效率很低，一般情况下 的科学运算的数据量是非常庞大的，所以list的效率低会导致整个科学运算的过程变 得非常慢。与之相比，Ndarray数组具有以下特点：
1. Ndarray数组所有元素的数据类型相同、数据地址连续，批量操作数组元素时速 度更快，而list中元素的数据类型可能不同，需要通过寻址的方式找到下一个元 素。
2. Ndarray数组支持广播机制，矩阵运算时不需要写for循环。
3. 底层主要使用C语言实现，运行速度远高于Python代码。
三、数组的创建
3.1、array创建数组
创建一个数组，可以转换任何形式的序列（如列表或元组）为NumPy数组。
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
import numpy as nparr1=np.array([1,2,3,4,5,6]
)
arr2=np.array([[1,2,3],[4,5,6],[7,8,9]]
)print(arr1)
print(arr2)'''
[1 2 3 4 5 6]
[[1 2 3][4 5 6][7 8 9]]
'''3.2、arange创建数组
创建一个均匀间隔的数值数组，类似于Python的内置 range 函数。
numpy.arange([start,] stop[, step,], dtype=None)
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
import numpy as nparr1=np.arange(1,10,1)print(arr1)'''
[1 2 3 4 5 6 7 8 9]
'''3.3、zeros函数
创建一个指定形状的数组，所有元素初始化为0。
numpy.zeros(shape, dtype=float, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| dtype | 可选参数，指定数组元素的数据类型。默认为 float |
| order | 可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风 格），‘F’ 表示按列（Fortran风格） |
import numpy as nparr1=np.zeros(10)print(arr1)'''
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
'''import numpy as nparr2=np.zeros((3,3))print(arr2)'''
[[0. 0. 0.][0. 0. 0.][0. 0. 0.]]
'''3.4、ones函数
创建一个指定形状的数组，所有元素初始化为1。
numpy.ones(shape, dtype=float, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| dtype | 可选参数，指定数组元素的数据类型。默认为 float |
| order | 可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风 格），‘F’ 表示按列（Fortran风格） |
import numpy as nparr1=np.ones(10)
arr2=np.ones((3,3))print(f'arr1==={arr1}')
print()
print(f'arr2==={arr2}')'''
arr1===[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]arr2===[[1. 1. 1.][1. 1. 1.][1. 1. 1.]]
'''3.5、empty函数
创建一个指定形状的数组，未初始化，元素值可能是随机的。
numpy.empty(shape, dtype=float, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| dtype | 可选参数，指定数组元素的数据类型。默认为 float |
| order | 可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风 格），‘F’ 表示按列（Fortran风格） |
import numpy as nparr1=np.empty(10)
arr2=np.empty((3,3))print(f'arr1==={arr1}')
print()
print(f'arr2==={arr2}')'''
arr1===[2.09197419e-076 1.87725413e-009 1.41866238e+161 3.56792062e-0575.42801934e-096 5.98147383e-154 3.98454986e+252 5.12981117e-1151.02245668e-259 2.25563609e-153]arr2===[[0.0000000e+000 0.0000000e+000 0.0000000e+000][0.0000000e+000 0.0000000e+000 3.1224949e-321][0.0000000e+000 0.0000000e+000 3.2845213e-287]]
'''3.6、full函数
创建一个指定形状的数组，所有元素初始化为用户定义的值。
numpy.full(shape, fill_value, dtype=None, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| fill_value | 用于填充数组的值 |
| dtype | 可选，指定数组元素的数据类型。如果未指定，则从 fill_value 推 断。 |
| order | 可选，指定数组数据在内存中的存储顺序。‘C’ 表示按行优先顺序；‘F’ 表 示按列优先顺序。 |
import numpy as nparr1=np.full(10,10)
arr2=np.full((3,3),3)print(f'arr1==={arr1}')
print()
print(f'arr2==={arr2}')'''
arr1===[10 10 10 10 10 10 10 10 10 10]arr2===[[3 3 3][3 3 3][3 3 3]]
'''3.7、eye函数
创建一个单位矩阵（对角线为1，其余为0）。
eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
| 参数 | 描述 |
|---|---|
| N | 矩阵的行数。如果只指定 N，则返回一个 N×N 的单位矩阵 |
| M | 矩阵的列数。如果指定，返回一个形状为 (N, M) 的矩阵 |
| k | 对角线的偏移量。k 为 0 时返回主对角线的单位矩阵；k > 0 时返回主对角线上方的对角线；k < 0 时返回主对角线下方的对角线 |
| dtype | 可选，指定数组元素的数据类型。如果未指定，则从 fill_value 推 断。 |
| order | 可选，指定数组数据在内存中的存储顺序。‘C’ 表示按行优先顺序；‘F’ 表 示按列优先顺序。 |
import numpy as nparr1=np.eye(10)
arr2=np.eye(3,3)print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.][0. 1. 0. 0. 0. 0. 0. 0. 0. 0.][0. 0. 1. 0. 0. 0. 0. 0. 0. 0.][0. 0. 0. 1. 0. 0. 0. 0. 0. 0.][0. 0. 0. 0. 1. 0. 0. 0. 0. 0.][0. 0. 0. 0. 0. 1. 0. 0. 0. 0.][0. 0. 0. 0. 0. 0. 1. 0. 0. 0.][0. 0. 0. 0. 0. 0. 0. 1. 0. 0.][0. 0. 0. 0. 0. 0. 0. 0. 1. 0.][0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]arr2===
[[1. 0. 0.][0. 1. 0.][0. 0. 1.]]
'''3.8、linspace函数
创建一个均匀分布的数组，包含指定数量的值。
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 序列的起始值 |
| stop | 序列的终止值，如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。 |
| retstep | 如果为 True 时，生成的数组中会显示间距，反之不显示。 |
| dtype | ndarray 的数据类型 |
import numpy as nparr1=np.linspace(10,100,20)
arr2=np.linspace(3,3)print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[ 10. 14.73684211 19.47368421 24.21052632 28.9473684233.68421053 38.42105263 43.15789474 47.89473684 52.6315789557.36842105 62.10526316 66.84210526 71.57894737 76.3157894781.05263158 85.78947368 90.52631579 95.26315789 100. ]arr2===
[3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.3. 3.]
'''3.9、logspace函数
创建一个对数均匀分布的数组，指定范围的对数数值。
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 序列的起始值为：base ** start |
| stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。 |
| base | 对数 log 的底数。 |
| dtype | ndarray 的数据类型 |
import numpy as nparr1=np.logspace(10,100,10)
arr2=np.logspace(3,3)print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[1.e+010 1.e+020 1.e+030 1.e+040 1.e+050 1.e+060 1.e+070 1.e+080 1.e+0901.e+100]arr2===
[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.1000. 1000.]
'''四、随机数组的创建
| 函数 | 说明 |
|---|---|
| seed | 确定随机生成器种子 |
| rand | 产生均匀分布的样本值 |
| random(size=None) | 该方法返回[0.0, 1.0)范围的随机数。 |
| randn(d0,d1,…,dn) | randn函数返回一个或一组样本，具有标准正态分布（期望为0，方差为1）。dn表格每个维度，返回值为指定维度的array |
| normal | 用于从具有指定平均值（mean）和标准差（standard deviation）的正态分 布（也称为高斯分布）中抽取样本。 |
| randint | 该方法有三个参数low、high、size三个参数。默认high是None,如果只有low，那范围就是[0,low)。如果有high，范围就是[low,high)。 |
| uniform | 该函数用于从均匀分布中抽取一个浮点数 |
| shuffle | 对一个序列就地随机排列 |
4.1、seed函数
随机数种子（random seed）是一个用于初始化随机数生成器（random number generator, RNG）的值。在计算机科学中，大多数的随机数生成器实际上是伪随机 数生成器（pseudo-random number generators, PRNGs），它们通过一个算法来 生成一系列看似随机的数字。伪随机数生成器的特点是可以重现生成的随机数序列， 这是通过设置相同的随机数种子来实现的。
设置随机数种子，种子值可以是任何整数，通常是正整数。
特点：
1. 可重现性：通过设置相同的随机数种子，每次程序运行时生成的随机数序列都是 相同的。这对于调试程序、进行科学计算或模拟时保持实验结果的一致性非常有 用。
2. 算法确定性：伪随机数生成器是确定性的，这意味着给定的种子会总是产生相同 的随机数序列，这与真正的随机数生成器不同，后者总会生成不同的随机数。
3. 种子来源：随机数种子的值可以是任意的。在许多编程环境中，如果不显式设置 种子，通常会使用当前时间作为种子，这样每次程序运行时都会产生不同的随机 数序列。
4. 跨平台差异：不同的操作系统或硬件平台可能会产生不同的随机数序列，即使种 子相同。这是因为不同的平台可能有不同的PRNG算法。
import numpy as np
np.random.seed(42)4.2、rand函数
生成均匀分布的随机数（0到1之间），可以指定形状。
numpy.random.rand(d0, d1, ..., dn)| 函数 | 说明 |
|---|---|
| d0, d1, ..., dn | 这些参数定义了输出数组的形状。它们是整数，指定了每个 维度的大小。例如，d0 是第一个维度的大小，d1 是第二个维度的大小，依此类 推。 |
import numpy as nparr1=np.random.rand(10)print(f'arr1===\n{arr1}')'''
arr1===
[0.92463939 0.94486905 0.74476479 0.25784553 0.85425486 0.571607250.95990865 0.36395052 0.41709035 0.82599918]
'''4.3、random函数
与 rand 类似，但提供更灵活的随机数生成。
numpy.random.random(size=None)| 函数 | 说明 |
|---|---|
| size | 这是一个可选参数，用于指定输出数组的形状。它可以是一个整数，也 可以是一个元组。如果 size 是一个整数，则返回一个一维数组；如果 一个元组，则返回一个多维数组，其形状与元组指定的一致 |
import numpy as nparr1=np.random.random(10)arr2=np.random.random((3,3))print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[0.62721499 0.21350623 0.83140219 0.41729457 0.70818569 0.550753530.57016909 0.42416555 0.11372102 0.7405065 ]arr2===
[[0.96151613 0.96612422 0.49951694][0.9377553 0.61001206 0.88551393][0.22225505 0.51794861 0.36731721]]
'''4.4、randn函数
生成标准正态分布（均值为0，标准差为1）的随机数。
numpy.random.randn(d0, d1, ..., dn)| 函数 | 说明 |
|---|---|
| d0, d1, ..., dn | 这些参数指定了输出数组的维度。如果你只提供一个数字， 它将返回一个一维数组；如果你提供多个数字，它将返回一个多维数组，其中每 个维度的大小由对应的参数指定 |
import numpy as nparr1=np.random.randn(10)arr2=np.random.randn(3,4)print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[-0.49202485 -0.26029324 0.46349285 -1.4871595 -1.15332575 0.48229266-1.04077328 0.52712378 -0.40422044 1.82175024]arr2===
[[ 0.0348239 0.96843211 0.41392382 0.51399037][ 1.13157601 -1.35735621 -2.2765836 -0.52266114][-0.8062335 -0.55222009 -1.00520723 -1.84433436]]
'''4.5、normal函数
生成给定均值和标准差的正态分布随机数。
numpy.random.normal(loc=0.0, scale=1.0, size=None)| 函数 | 说明 |
|---|---|
| loc | 正态分布的均值，对应于分布的中心位置，默认值为 0.0 |
| scale | 正态分布的标准差，对应于分布的宽度，默认值为 1.0 |
| size | 输出数组的形状。如果是一个整数，返回一维数组。如果是一个元组，返回多维数组。默认为None返回一个随机数 |
import numpy as nparr1=np.random.normal(size=10)arr2=np.random.normal(size=(3,4))print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[-0.23383662 0.97632058 0.48245764 -1.71405263 0.0625902 2.32371938-1.16770879 0.20876465 -2.16149186 -0.05048533]arr2===
[[-0.68925419 -2.12716386 -1.06562238 1.11568077][ 0.02078178 -0.31270599 -1.90545882 -0.850884 ][ 0.66213069 2.28670915 -0.88748761 0.13641803]]
'''4.6、randint函数
生成指定范围内的随机整数。
numpy.random.randint(low, high=None, size=None, dtype=int)| 函数 | 说明 |
|---|---|
| low | 生成随机数的起始点（包含）。如果只提供了low参数而没有提供high参数，那么随机整数的范围将是从 0 到low （不包含 low本身） |
| high | 生成随机数的结束点（不包含） |
| size | 定义输出数组形状的整数或元组。例如，size(m，n)将生成 一个 m 行 n 列的数组 |
| dtype | 指定返回数组的数据类型，默认为int |
import numpy as nparr1=np.random.randint(0,10,size=10)arr2=np.random.randint(0,10,size=(3,4))print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[3 1 3 7 2 7 0 5 4 8]arr2===
[[4 7 9 6][3 8 2 0][2 0 4 5]]'''4.7、uniform函数
生成指定范围内的均匀分布随机数。
numpy.random.uniform(low=0.0, high=1.0, size=None)| 函数 | 说明 |
|---|---|
| low | 浮点数或类似浮点数的数组，表示样本抽取区间的下限，默认值为 0 |
| high | 浮点数或类似浮点数的数组，表示样本抽取区间的上限，默认值为 1 |
| size | 整数或元组，可选参数，表示输出的形状。如果未提供，则返回单个浮 点数。如果提供了一个整数，则返回一个一维数组；如果提供了一个元组，则返 回一个多维数组 |
import numpy as nparr1=np.random.uniform(0,10,size=5)arr2=np.random.uniform(0,10,size=(3,4))print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')'''
arr1===
[7.96891358 0.19647614 5.42047937 1.49001317 9.04060667]arr2===
[[3.44988119 0.82911361 7.53272753 2.65165757][6.13385131 2.30715477 0.73983801 7.05093042][5.82714561 2.25635848 3.37875838 8.62424195]]
'''4.8、shuffle函数
对数组进行随机重排，原地改变数组顺序。
numpy.random.shuffle(x)| 函数 | 说明 |
|---|---|
| x | 要打乱的数组 |
import numpy as nparr1=np.array([[1,2,3],[4,5,6],[7,8,9]
])
print('改变之前')
print(f'arr1===\n{arr1}')np.random.shuffle(arr1)print('改变之后')
print(f'arr1===\n{arr1}')'''
arr1===
改变之前
arr1===
[[1 2 3][4 5 6][7 8 9]]
改变之后
arr1===
[[1 2 3][7 8 9][4 5 6]]'''五、思维导图
