一、 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数组。
python">numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
python">import numpy as np
arr1=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 函数。
python">numpy.arange([start,] stop[, step,], dtype=None)
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
python">import numpy as np
arr1=np.arange(1,10,1)
print(arr1)
'''
[1 2 3 4 5 6 7 8 9]
'''3.3、zeros函数
创建一个指定形状的数组，所有元素初始化为0。
python">numpy.zeros(shape, dtype=float, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| dtype | 可选参数，指定数组元素的数据类型。默认为 float |
| order | 可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风 格），‘F’ 表示按列（Fortran风格） |
python">import numpy as np
arr1=np.zeros(10)
print(arr1)
'''
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
'''python">import numpy as np
arr2=np.zeros((3,3))
print(arr2)
'''
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
'''3.4、ones函数
创建一个指定形状的数组，所有元素初始化为1。
python">numpy.ones(shape, dtype=float, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| dtype | 可选参数，指定数组元素的数据类型。默认为 float |
| order | 可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风 格），‘F’ 表示按列（Fortran风格） |
python">import numpy as np
arr1=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函数
创建一个指定形状的数组，未初始化，元素值可能是随机的。
python">numpy.empty(shape, dtype=float, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| dtype | 可选参数，指定数组元素的数据类型。默认为 float |
| order | 可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风 格），‘F’ 表示按列（Fortran风格） |
python">import numpy as np
arr1=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-057
5.42801934e-096 5.98147383e-154 3.98454986e+252 5.12981117e-115
1.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函数
创建一个指定形状的数组，所有元素初始化为用户定义的值。
python">numpy.full(shape, fill_value, dtype=None, order='C')| 参数 | 描述 |
|---|---|
| shape | 一个整数或整数元组，用于指定输出数组的形状 |
| fill_value | 用于填充数组的值 |
| dtype | 可选，指定数组元素的数据类型。如果未指定，则从 fill_value 推 断。 |
| order | 可选，指定数组数据在内存中的存储顺序。‘C’ 表示按行优先顺序；‘F’ 表 示按列优先顺序。 |
python">import numpy as np
arr1=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）。
python">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’ 表 示按列优先顺序。 |
python">import numpy as np
arr1=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函数
创建一个均匀分布的数组，包含指定数量的值。
python">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 的数据类型 |
python">import numpy as np
arr1=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.94736842
33.68421053 38.42105263 43.15789474 47.89473684 52.63157895
57.36842105 62.10526316 66.84210526 71.57894737 76.31578947
81.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函数
创建一个对数均匀分布的数组，指定范围的对数数值。
python">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 的数据类型 |
python">import numpy as np
arr1=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+090
1.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算法。
python">import numpy as np
np.random.seed(42)4.2、rand函数
生成均匀分布的随机数（0到1之间），可以指定形状。
python">numpy.random.rand(d0, d1, ..., dn)| 函数 | 说明 |
|---|---|
| d0, d1, ..., dn | 这些参数定义了输出数组的形状。它们是整数，指定了每个 维度的大小。例如，d0 是第一个维度的大小，d1 是第二个维度的大小，依此类 推。 |
python">import numpy as np
arr1=np.random.rand(10)
print(f'arr1===\n{arr1}')
'''
arr1===
[0.92463939 0.94486905 0.74476479 0.25784553 0.85425486 0.57160725
0.95990865 0.36395052 0.41709035 0.82599918]
'''4.3、random函数
与 rand 类似，但提供更灵活的随机数生成。
python">numpy.random.random(size=None)| 函数 | 说明 |
|---|---|
| size | 这是一个可选参数，用于指定输出数组的形状。它可以是一个整数，也 可以是一个元组。如果 size 是一个整数，则返回一个一维数组；如果 一个元组，则返回一个多维数组，其形状与元组指定的一致 |
python">import numpy as np
arr1=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.55075353
0.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）的随机数。
python">numpy.random.randn(d0, d1, ..., dn)| 函数 | 说明 |
|---|---|
| d0, d1, ..., dn | 这些参数指定了输出数组的维度。如果你只提供一个数字， 它将返回一个一维数组；如果你提供多个数字，它将返回一个多维数组，其中每 个维度的大小由对应的参数指定 |
python">import numpy as np
arr1=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函数
生成给定均值和标准差的正态分布随机数。
python">numpy.random.normal(loc=0.0, scale=1.0, size=None)| 函数 | 说明 |
|---|---|
| loc | 正态分布的均值，对应于分布的中心位置，默认值为 0.0 |
| scale | 正态分布的标准差，对应于分布的宽度，默认值为 1.0 |
| size | 输出数组的形状。如果是一个整数，返回一维数组。如果是一个元组，返回多维数组。默认为None返回一个随机数 |
python">import numpy as np
arr1=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函数
生成指定范围内的随机整数。
python">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 |
python">import numpy as np
arr1=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函数
生成指定范围内的均匀分布随机数。
python">numpy.random.uniform(low=0.0, high=1.0, size=None)| 函数 | 说明 |
|---|---|
| low | 浮点数或类似浮点数的数组，表示样本抽取区间的下限，默认值为 0 |
| high | 浮点数或类似浮点数的数组，表示样本抽取区间的上限，默认值为 1 |
| size | 整数或元组，可选参数，表示输出的形状。如果未提供，则返回单个浮 点数。如果提供了一个整数，则返回一个一维数组；如果提供了一个元组，则返 回一个多维数组 |
python">import numpy as np
arr1=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函数
对数组进行随机重排，原地改变数组顺序。
python">numpy.random.shuffle(x)| 函数 | 说明 |
|---|---|
| x | 要打乱的数组 |
python">import numpy as np
arr1=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]]
'''五、思维导图
