numpy基本教程：Numpy实现数组的逻辑运算_当前观点

numpy基本教程 快速学会使用numpy

(资料图片)

了解数组的属性，形状、类型应用Numpy实现数组的基本操作应用随机数组的创建实现正态分布应用应用Numpy实现数组的逻辑运算应用Numpy实现数组的统计运算应用Numpy实现数组之间的运算

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

一个强大的N维数组对象 ndarray广播功能函数整合 C/C++/Fortran 代码的工具线性代数、傅里叶变换、随机数生成等功能

1.N维数组-ndarray

NumPy 提供了一个 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

1） ndarray的属性

a.ndarray的形状 ------ndarray.shape

ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"

创建数组

a = np.array([[1,2,3],[4,5,6]])b = np.array([1,2,3,4])c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])

调用shape

a.shape   b.shape   c.shape

输出

(2, 3)  # 二维数组(4,) # 一维数组(2, 2, 3) # 三维数组

b.返回数组的维数–ndarray.ndim

a.ndim   b.ndim   c.ndim

输出

2  # 二维数组1 # 一维数组3 # 三维数组

c.数组中的元素数量–ndarray.size

数组元素的总个数，相当于 .shape 中 n*m 的值

a.size b.size c.size

输出

6412

d.一个数组元素的长度（字节）ndarray.itemsize

ndarray.itemsize 以字节的形式返回数组中每一个元素的大小

例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。

# 数组的 类型 为 int8（一个字节）  x = np.array([1,2,3,4], dtype = np.int8)  print (x.itemsize)

输出 1

# 数组的 类型 现在为 float64（八个字节） y = np.array([1,2,3], dtype = np.float64)  print (y.itemsize)

输出 8

e.数组类型—numpy.dtype

创建数组的时候指定类型

a = np.array([[1, 2, 3],[4, 5, 6]], dtype=np.float32)a.dtype

输出 dtype(‘float32’)

b = np.array(["python", "C", "JAVA",], dtype = np.string_)b

输出 array([b’python’, b’C’, b’JAVA’], dtype=‘|S6’)

注意：创建数组时，若不指定，整数默认int64，小数默认float64

2. 创建数组

1）生成0和1的数组

np.ones(shape, dtype)

np.zeros(shape, dtype)

a. 创建指定大小的数组，数组元素以 1 来填充

ones = np.ones([5,8])ones

输出

array([[1., 1., 1., 1., 1., 1., 1., 1.],   [1., 1., 1., 1., 1., 1., 1., 1.],   [1., 1., 1., 1., 1., 1., 1., 1.],   [1., 1., 1., 1., 1., 1., 1., 1.],   [1., 1., 1., 1., 1., 1., 1., 1.]])

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

zeros = np.zeros([5,8])zeros

输出

array([[0., 0., 0., 0., 0., 0., 0., 0.],   [0., 0., 0., 0., 0., 0., 0., 0.],   [0., 0., 0., 0., 0., 0., 0., 0.],   [0., 0., 0., 0., 0., 0., 0., 0.],   [0., 0., 0., 0., 0., 0., 0., 0.]])

2）输入为矩阵x

a.输出为形状和a一致的矩阵，其元素全部为1

np.ones_like(a, dtype)

a = np.array([[1,2,3],[4,5,6]])np.ones_like(a)

输出

array([[1, 1, 1],   [1, 1, 1]])

b.输出为形状和a一致的矩阵，其元素全部为0

np.zeros_like(a, dtype)

np.zeros_like(a)

输出

array([[0, 0, 0],   [0, 0, 0]])

2）从已有数组生成

a.np.array(object, dtype)

a = np.array([[1,2,3],[4,5,6]])# 从现有的数组当中创建a1 = np.array(a)

输出 array([[1, 2, 3], [4, 5, 6]])

b.np.asarray(a, dtype)

# 相当于索引的形式，并没有真正的创建一个新的a2 = np.asarray(a)

输出

array([[1, 2, 3],   [4, 5, 6]])

两者区别：①numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个；numpy.asarray中还有一个参数order，他是可选的，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。②np.array为深 拷贝，numpy.asarray为浅拷贝。

3）生成固定范围的数组

a.创建等差数组 — 指定数量 np.linspace (start, stop, num, endpoint)

参数说明

start:序列的起始值stop:序列的终止值num:要生成的等间隔样例数量，默认为50endpoint:序列中是否包含stop值，默认为ture

np.linspace(0, 100, 6)# 生成等间隔的数组

输出

array([ 0., 20., 40., 60., 80., 100.])

b. 创建等比数列 np.logspace(start,stop, num,endpoint=True, base=10.0, dtype==None)

参数说明：

start:序列的起始值stop:序列的终止值num:要生成的等比数列数量，默认为50endpoint:该值为 true 时，数列中中包含stop值，反之不包含，默认是Truebase：对数 log 的底数。dtype：ndarray 的数据类型

np.logspace(0, 2, 3)

输出 array([ 1., 10., 100.]))

c.创建等差数组 — 指定步长 np.arange(start,stop, step, dtype)

参数说明：

start:序列的起始值（默认为0）stop:序列的终止值（不包含）step:步长,默认值为1dtype：ndarray 的数据类型

np.arange(10, 50, 2)

输出 array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])

4）生成随机数组–使用np.random模块

a.正态分布

b.均匀分布

3.数组的索引、切片

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样

1）直接进行索引,切片

对象[:, :] – 先行后列

a = np.array([[1,2,3],[4,5,6]])a[0, 0:3]

输出：

array([1, 2, 3])

2）三维数组索引方式：

# 三维

a1 = np.array([ [[1,2,3],[4,5,6]], [[12,3,34],[5,6,7]]])

输出 array([[[ 1, 2, 3], [ 4, 5, 6]],

[[12,  3, 34],[ 5,  6,  7]]])

索引、切片

a1[0, 0, 1]   # 输出: 2

4.形状修改

1 ndarray.reshape(shape, order)

返回一个具有相同数据域，但shape不一样的视图 行、列不进行互换

# 在转换形状的时候，一定要注意数组的元素匹配

a = np.random.normal(0, 1, (4, 5))a.reshape([5, 4])a.reshape([-1,10])  # 数组的形状被修改为: (2, 10), -1: 表示通过待计算

2 ndarray.resize(new_shape)

修改数组本身的形状（需要保持元素个数前后相同） 行、列不进行互换

a.resize([5, 4])    # 查看修改后结果    a.shape

(5, 4)

3 ndarray.T

数组的转置 将数组的行、列进行互换

a.T.shape(4, 5) #结果

5.类型修改

1 ndarray.astype(type)

返回修改了类型之后的数组

a.astype(np.int32)

2 ndarray.tostring([order])或者ndarray.tobytes([order])

构造包含数组中原始数据字节的Python字节

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[12, 3, 34], [5, 6, 7]]])arr.tostring()

6. 数组的去重

1. np.unique()

temp = np.array([[1, 2, 3, 4],[3, 4, 5, 6]])np.unique(temp)

输出 array([1, 2, 3, 4, 5, 6])

7. ndarray运算

1） 逻辑运算

# 生成10*5,值范围在30-100直接的随机数数组a = np.random.randint(30, 100, (10, 5))# 取出后4行数据，用于逻辑判断 b = a[6:, 0:5]# 逻辑判断, 如果元素大于60就标记为True 否则为False b > 60

输出

array([[ True,  True,  True, False,  True],   [ True,  True,  True, False,  True],   [ True,  True, False, False,  True],   [False,  True,  True,  True,  True]])

指定的值

# BOOL赋值, 将满足条件的设置为指定的值-布尔索引b[b > 60] = 1b

输出

array([[ 1,  1,  1, 52,  1],   [ 1,  1,  1, 59,  1],   [ 1,  1, 44, 44,  1],   [59,  1,  1,  1,  1]])

2） 通用判断函数

np.all()

# 判断前两行元素[0:2, :]是否大于60np.all(a[0:2, :] > 60)

输出

False

np.any()

# 判断前两行元素[0:2, :]是否大于80np.any(score[0:2, :] > 80)

输出

True

3） np.where（三元运算符）

a.通过使用np.where能够进行更加复杂的运算

np.where()

# 判断前四行元素，前四列元素，值大于60的值换为1，否则为0temp = a[:4, :4]np.where(temp > 60, 1, 0)

b.复合逻辑需要结合np.logical_and和np.logical_or使用

# 判断前四行元素，前四列元素，值大于60且小于90的值换为1，否则为0np.where(np.logical_and(temp > 60, temp < 90), 1, 0)# 判断前四行元素，前四列元素，值大于90且小于60的值换为1，否则为0np.where(np.logical_or(temp > 90, temp < 60), 1, 0)

4） 统计运算

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等

a = np.array([[3,7,5],[8,4,3],[2,4,9]])

np.max()np.min()np.median()np.mean() - 算术平均值np.std() - 标准差np.var() - 方差np.argmax(axis=) — 最大元素对应的下标np.argmin(axis=) — 最小元素对应的下标

8.数组间运算

1） 数组与数的运算

arr = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])

加法

arr + 1

输出

array([[2, 3, 4, 3, 2, 5],   [6, 7, 2, 3, 4, 2]])

乘法

arr / 2

输出

array([[0.5, 1. , 1.5, 1. , 0.5, 2. ],   [2.5, 3. , 0.5, 1. , 1.5, 0.5]])

2） 数组与数组的运算

a.广播机制

数组在进行矢量化运算时，要求数组的形状是相等的。当形状不相等的数组执行算术运算的时候，就会出现广播机制，该机制会对数组进行扩展，使数组的shape属性值一样，这样，就可以进行矢量化运算了。

arr1 = np.array([[0],[1],[2],[3]])arr1.shape# (4, 1)arr2 = np.array([1,2,3])arr2.shape# (3,)arr1+arr2# 结果是：array([[1, 2, 3],   [2, 3, 4],   [3, 4, 5],   [4, 5, 6]])

9.矩阵乘法

np.matmulnp.dot

区别：np.matmul中禁止矩阵与标量的乘法。 在矢量乘矢量的內积运算中，np.matmul与np.dot没有区别。

创建矩阵

a = np.array([[80, 86],[82, 80],[85, 78],[90, 90],[86, 82],[82, 90],[78, 80],[92, 94]])b = np.array([[0.7], [0.3]])

使用matmul()

np.matmul(a, b)

结果

array([[81.8],   [81.4],   [82.9],   [90. ],   [84.8],   [84.4],   [78.6],   [92.6]])

使用dot()

np.dot(a,0.1)

结果

array([[8. , 8.6],   [8.2, 8. ],   [8.5, 7.8],   [9. , 9. ],   [8.6, 8.2],   [8.2, 9. ],   [7.8, 8. ],