首先，安装numpy在一个虚拟环境中：cmd打开终端

然后输入

conda activate

再输入

conda activate "你的环境" 

激活并进入虚拟环境，然后就可以在这里下第三方库了。

再输入

pip install numpy==1.26.0 -i https://pypi.tuna.tsinghua.edu.cn/simple/

下载numpy。

一.Numpy基础

• Python 的第三方扩展包,主要用来计算、处理一维或多维数组

• 底层主要用 C语言编写,因此它能够高速地执行数值计算

• 提供了多种数据结构,这些数据结构能够非常契合的应用在数组和矩阵的运算上

• 数组算术计算方面,提供了大量的数学函数

1.1 与列表的区别

1. NumPy 数组是同质数据类型（homogeneous），Python 列表是异质数据类型（heterogeneous），即列表中的元素可以是不同的类型。

2. 列表提供了基本的列表操作，如添加、删除、切片、排序等

3. NumPy 数组提供了丰富的数学函数和操作，如矩阵运算、线性代数、傅里叶变换等

二.ndarray对象

一个 n 维数组对象，是一个一系列相同类型元素组成的数组集合，每个元素都占有大小相同的内存。内存常用的布局方式有两种，即按行（C语言）或者按列（Fortran语言）。

2.1 ndarray对象创建

NumPy 的内置函数 array() 可以创建 ndarray 对象。

# 先导入numpy
import numpy
 
# 用法
ndarray = numpy.array(object, dtype = None, copy = True, order = None,ndmin = 0)
print(type(ndarray))

结果：

<class 'numpy.ndarray'>

| object | 表示一个数组序列 |
| dtype | 可选参数，通过它可以更改数组的数据类型 |
| copy | 可选参数，表示数组能否被复制，默认是 True |
| order | 以哪种内存布局创建数组，有 3 个可选值，分别是 C(行序列)/F(列序列)/A(默认) |
| ndmin | 用于指定数组的维度 |

1. object

# 先导入numpy
import numpy
 
# 创建两个数组
a = numpy.array((1, 2, 3))
b = numpy.array([1, 2, 3])
print(a)
print(b)

结果：

[1 2 3]
[1 2 3]

可以看到数组与列表的差异还是明显的，其中元素以空格分割，而列表以逗号分割。且传进arrary函数的参数可以是任意可迭代对象。

2. dtype

# 先导入numpy
import numpy
 
# 其可改变存在数组中元素的数据类型
a = numpy.array((1, 2, 3),dtype=str)
print(a)

结果：

['1' '2' '3']

3. ndmin

# 先导入numpy
import numpy
 
# 创建一个二维数组
a = numpy.array((1, 2, 3),ndmin=2)
 
# 创建一个正常的二维数组
b = numpy.array(((4, 5, 6),(7,8,9)),ndmin=2)
print(a)
 
# 换个行
print()
 
print(b)

结果：

[[1 2 3]]

[[4 5 6]
[7 8 9]]

尝试查看数组形状:

# 先导入numpy
import numpy
 
 
b = numpy.array(((4, 5, 6),(7,8,9)),ndmin=2)
print(b)
 
# 来个换行
print()
 
# 看看几行几列，返回一个元组，如果是一维的只有一个数，第二个是空的，俩用逗号隔开
print(b.shape)

结果：

[[4 5 6]
[7 8 9]]

(2, 3)

2.2 zeros()

创建指定大小的数组，数组元素以 0 来填充。

numpy.zeros(shape, dtype = float, order = 'C')

| shape | 数组形状 |
| dtype | 数据类型 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |

# 示例
import numpy
 
a = numpy.zeros((4,4))
print(a)

结果：

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

注意：这里的 ‘0.’ 代表的是浮点数, ‘0.’ 即 ‘0.0’

2.3 ones()

创建指定形状的数组，数组元素以 1来填充,参数与zeros一致。

numpy.ones(shape, dtype = None, order = 'C')

# 示例
import numpy
 
x = numpy.ones((3,4))
print(x)

结果：

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

2.4 full()

full()用于创建一个填充指定值的数组。

numpy.full(shape, fill_value, dtype=None, order='C')

| shape | 数组的形状（如 (2, 3) 表示 2 行 3 列的数组） |
| fill_value | 填充的值 |
| dtype | 数组的数据类型（如 np.float32） |
| order | 数组的内存布局（如 'C' 表示 C 风格，'F' 表示 Fortran 风格） |

# 示例
import numpy
 
a = numpy.full((3, 3), 7)
 
print(a)

结果：

[[7 7 7]
 [7 7 7]
 [7 7 7]]

可以看到这里传一个整数进去那数组内部默认就是整数了，而不是浮点数。

2.5 arrange()

用于创建一个等差数列的数组。它类似于 Python 内置的 range() 函数，但返回的是一个 NumPy 数组。

numpy.arange(start, stop, step, dtype)

| start | 起始值，默认为 0 |
| stop | 终止值（不包含） |
| step | 步长，默认为 1 |
| dtype | 返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型 |

# 示例
import numpy
 
a = numpy.arange(0,10,2)
print(a)

结果：

[0 2 4 6 8]

2.6 linspace()

在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分 50 份。

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

| start | 起始值，默认为 0 |
| stop | 终止值（默认包含） |
| num | 要生成多少个均匀的样本，默认为 50 |
| endpoint | 是否包含终止值，默认为 True |
| retstep | 是否返回步长，如果为 True，则返回一个包含数组和步长的元组，如果为 False，则只返回数组。默认为 False |
| dtype | 返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型，默认None |

# 示例
import numpy 
 
a = numpy.linspace(1, 10, 19,retstep=True)
print(a)

结果：

(array([ 1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ,  5.5,  6. ,
        6.5,  7. ,  7.5,  8. ,  8.5,  9. ,  9.5, 10. ]), 0.5)

注意，如果要以0.5为步长的话，应该取(stop-start)的2倍再加1，直接用差值2倍会少取一个

容易出问题的地方如下：

import numpy 
 
a = numpy.linspace(1, 10, 20,retstep=True)
print(a)

结果：

(array([ 1.        ,  1.47368421,  1.94736842,  2.42105263,  2.89473684,
        3.36842105,  3.84210526,  4.31578947,  4.78947368,  5.26315789,
        5.73684211,  6.21052632,  6.68421053,  7.15789474,  7.63157895,
        8.10526316,  8.57894737,  9.05263158,  9.52631579, 10.        ]), 0.47368421052631576)

因此延伸出步长的计算：

step = (stop - start) / (num - 1)

• 差了(stop - start)这么多数

• 分成(num - 1)份

三.numpy数据类型

• NumPy 提供了比 Python 更加丰富的数据类型

• NumPy 中每种数据类型都有一个唯一标识的字符码，int8, int16, int32, int64 四种数据类型可以使用字符串 ‘i1’, ‘i2’,’i4’,’i8’ 代替

print(data.dtype)	#输出：[('name', 'S10'), ('age', '<i4')]

• 可以使用数组的 dtype 属性来获取数组中元素的数据类型

• 可以使用 astype() 方法来转换数组中元素的数据类型

import numpy as np
 
arr = np.array([1, 2, 3]).astype(np.float64)
print(arr)
 
print(arr.dtype)

结果：

[1. 2. 3.]
float64

• 也可以在数组中直接声明数据类型

import numpy as np
 
arr = np.array([1, 2, 3],dtype = (np.float64))
 
print(arr)

结果：

[1. 2. 3.]

在编程中，字节序标记用于指定数据的字节顺序。常见的字节序标记包括：

1. < : 小端序，数据的最低有效字节存储在内存的最低地址，而最高有效字节存储在内存的最高地址。

2. > : 大端序，数据的最高有效字节存储在内存的最低地址，而最低有效字节存储在内存的最高地址。

四.简单数组属性

4.1 shape

通过赋值，可以用来调整数组形状，也可以通过直接访问返回一个元组。

import numpy
 
a = numpy.array([1,2,3])
print(a.shape)
 
# 换个行
print()
 
# 更改维度
a.shape = (3,1)
print(a)

结果：

(3,)

[[1]
 [2]
 [3]]

可以看到，a之前是一个一维数组无所谓行列，但是更改形状后拥有了行列，变成了二维数组,行列都是关于二维数组来讲的。

注意：这里的（3,）表示数组里有3个元素，没有规定是一行还是一列。

4.2 数组维度 ndmin

ndim 是 NumPy 数组的一个属性，用于返回数组的维度数（即数组的秩）。

数组的维度就是一个数组中的某个元素，当用数组下标表示的时候，需要用几个数字来表示才能唯一确定这个元素，这个数组就是几维。

import numpy
 
a = numpy.array([1, 2, 3])
print(a.ndim)

结果：

1

4.3 flags

1. C_CONTIGUOUS:

表示数组在内存中是 C 风格连续的（行优先）。

如果为 True，则数组是 C 风格连续的。

2. F_CONTIGUOUS:

表示数组在内存中是 Fortran 风格连续的（列优先）。

如果为 True，则数组是 Fortran 风格连续的。

3. OWNDATA:

表示数组是否拥有自己的数据（即是否是视图）。

如果为 True，则数组拥有自己的数据；如果为 False，则数组可能是从另一个数组或对象借用数据的。

4. WRITEABLE:

表示数组是否可写。

如果为 True，则数组是可写的；如果为 False，则数组是只读的。

5. ALIGNED:

表示数组是否对齐。

如果为 True，则数组的数据在内存中是对齐的。

6. WRITEBACKIFCOPY:

表示数组是否是通过 np.copy 创建的副本，并且需要将更改写回原始数组。

如果为 True，则数组是通过 np.copy 创建的副本，并且需要将更改写回原始数组。

7. UPDATEIFCOPY:

表示数组是否是通过 np.copy 创建的副本，并且需要将更改写回原始数组。

如果为 True，则数组是通过 np.copy 创建的副本，并且需要将更改写回原始数组。

import numpy
 
a = numpy.array([[1, 2, 3],[4, 5, 6]])
 
print(a.flags)

结果：

C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False

4.4.item()

.item()作用是将数组中的单个元素转换为 Python

import cv2 as cv
import numpy as np
# 注意只能有一个元素
a = np.array([1])
print(a.item())

结果：

1