文章目录
- 一、函数详解
- np.empty(num_points)
- np.zeros(shape, dtype=float, order='C')
- np.tile(A, reps)
- np.newaxis
- np.stack(arrays, axis=0)
- np.roll(a, shift, axis=None)
- np.repeat(a, repeats, axis=None)
- arr.reshape(shape)
- arr.ravel()
- np.mean(a, axis=None, dtype=None,keepdims=np._NoValue)
- np.where(condition, x, y)
- np.maximum(array1, array2)
- np.all(array, axis=None)
- 二、实例
一、函数详解
np.empty(num_points)
用于创建一个指定大小的未初始化的数组的函数。该函数会返回一个指定大小的数组,但是数组的内容是未定义的,即数组中的元素可能是任意值。
参数说明:
- num_points:指定数组的大小,可以是一个整数或元组
import numpy as np
# 创建一个大小为5的未初始化数组
arr = np.empty(5)
print(arr)
# 输出结果可能会是类似于以下的内容(具体数值可能不同):
[1. 2. 3. 4. 5.]
np.zeros(shape, dtype=float, order=‘C’)
NumPy中用于创建指定形状的全零数组的函数。该函数接受一个表示数组形状的元组作为参数,并返回一个对应形状且所有元素都为零的数组。
参数解释:
- shape:表示数组形状的元组,如(2, 3)表示2行3列的数组
- dtype:可选参数,指定数组的数据类型,默认为float
- order:可选参数,指定数组元素在内存中的存储顺序,'C’表示按行存储,'F’表示按列存储
import numpy as np
# 创建一个3x4的全零数组
zeros_array = np.zeros((3, 4))
print(zeros_array)
输出结果:
array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
np.tile(A, reps)
用于在不同维度上复制数组。具体来说,np.tile(A, reps)会将数组A沿各个维度复制指定的次数,形成一个新的数组。
参数解释:
- A:要复制的数组
- reps:指定每个维度上复制的次数,可以是一个整数或一个元组。如果reps是一个整数n,则表示沿着每个维度将数组复制n次;如果reps是一个元组(m, n),则表示沿着每个维度将数组复制m次沿第一个轴,n次沿第二个轴,依此类推。
import numpy as np
# 创建一个数组
arr = np.array([1, 2, 3])
# 将数组沿着第一个轴复制3次
result1 = np.tile(arr, 3)
print(result1)
# 输出结果为:
[1 2 3 1 2 3 1 2 3]
A = np.array([[1, 2], [3, 4]])
result2 = np.tile(A, (2, 3))
print(result2)
# 输出结果为:
array([[1, 2, 1, 2, 1, 2],
[3, 4, 3, 4, 3, 4],
[1, 2, 1, 2, 1, 2],
[3, 4, 3, 4, 3, 4]])
np.newaxis
一种在NumPy中用于改变数组维度的常见操作
当使用np.newaxis
时,它实际上是一个None
对象的别名,用于增加数组的维度。通过在切片操作中使用np.newaxis
,可以改变数组的维度,从而方便进行矩阵运算。
import numpy as np
# 创建一个一维数组
arr = np.array([1, 2, 3, 4])
# 使用np.newaxis增加一个新的轴
new_arr = arr[:, np.newaxis]
print(new_arr)
print(new_arr.shape)
输出结果:
array([[1],
[2],
[3],
[4]])
(4, 1)
np.stack(arrays, axis=0)
用于沿着新的轴堆叠数组序列。具体来说,np.stack
可以将多个数组沿着指定的轴(axis)进行堆叠,生成一个新的数组。
参数说明:
arrays
:要堆叠的数组序列,可以是多个数组组成的列表或元组。axis
:指定沿着哪个轴进行堆叠。默认值为 0,表示沿着新的第一个轴进行堆叠。axis=-1
表示沿着数组的最后一个轴进行堆叠操作。
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
stacked_array = np.stack((arr1, arr2))
print(stacked_array)
输出结果:
[[1 2 3]
[4 5 6]]
np.roll(a, shift, axis=None)
用于对数组进行循环移位操作的函数。该函数可以将数组沿指定轴进行循环移位,即将数组的元素按照指定的偏移量进行重新排列。
参数说明:
- a:输入数组
- shift:循环移位的偏移量,可以是正数或负数
- axis:指定沿着哪个轴进行循环移位操作,如果不指定则将数组展平后进行移位操作
import numpy as np
# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5])
# 对数组进行循环右移两位
result = np.roll(arr, 2)
print(result)
# 输出结果为:
[4 5 1 2 3]
np.repeat(a, repeats, axis=None)
用于重复数组中的元素的函数。它可以在指定轴上重复数组中的元素
参数解释:
- a:要重复的数组
- repeats:整数或整数数组,指定每个元素重复的次数
- axis:指定沿着哪个轴重复元素,默认为None,表示将数组展平后重复
import numpy as np
# 创建一个数组
arr = np.array([1, 2, 3])
# 将数组中的每个元素重复2次
repeated_arr = np.repeat(arr, 2)
print(repeated_arr)
输出结果:
[1 1 2 2 3 3]
# 创建一个二维数组
arr = np.array([[1, 2], [3, 4]])
# 在轴0上重复每行2次
repeated_arr_axis0 = np.repeat(arr, 2, axis=0)
print(repeated_arr_axis0)
输出结果:
[[1 2]
[1 2]
[3 4]
[3 4]]
# 创建一个二维数组
arr = np.array([[1, 2], [3, 4]])
# 在轴1上重复每列3次
repeated_arr_axis1 = np.repeat(arr, 3, axis=1)
print(repeated_arr_axis1)
输出结果:
[[1 1 1 2 2 2]
[3 3 3 4 4 4]]
arr.reshape(shape)
NumPy中用于改变数组形状的函数。它可以将数组重新排列为指定形状,但要确保新形状与原始数组包含的元素数量一致。
参数解释:
- shape:新的形状,可以是一个整数元组,表示数组的维度 ,
import numpy as np
# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5, 6])
# 将一维数组reshape为二维数组
reshaped_arr = arr.reshape(2, 3)
print(reshaped_arr)
输出结果:
[[1 2 3]
[4 5 6]]
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
#-1表示第二维的大小则根据总元素数量和前两维的大小自动计算得出。
reshaped_array = arr.reshape(6, -1, 2)
输出结果:
[[[ 1 2]
[ 3 4]]
[[ 5 6]
[ 7 8]]
[[ 9 10]
[11 12]]]
arr.ravel()
用于将多维数组展平为一维数组。具体来说,ravel()
函数会返回一个包含原始数组所有元素的一维数组,元素的顺序是按照原始数组在内存中的顺序来展开的。
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
raveled_arr = arr.ravel()
print("原始数组:")
print(arr)
print("\n展平后的一维数组:")
print(raveled_arr)
原始数组:
[[1 2 3]
[4 5 6]]
展平后的一维数组:
[1 2 3 4 5 6]
np.mean(a, axis=None, dtype=None,keepdims=np._NoValue)
- a:要计算均值的数组或矩阵。
- axis:指定计算均值的轴方向。默认为None,表示计算整个数组或矩阵的均值;如果指定为0,则沿着列方向计算均值;如果指定为1,则沿着行方向计算均值。
- dtype:指定返回结果的数据类型。
- keepdims=True时,结果将保持原始数组的维度,即返回的结果会是一个具有相同维度的数组。这在进行广播操作时非常有用。
import numpy as np
# 创建一个二维数组
arr = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
=# 计算整个数组的均值,并保持维度
mean_all = np.mean(arr, keepdims=True)
print("整个数组的均值(保持维度):")
print(mean_all)
print("维度:", mean_all.shape)
# 沿着列方向计算均值,并保持维度
mean_col = np.mean(arr, axis=0, keepdims=True)
print("每列的均值(保持维度):")
print(mean_col)
print("维度:", mean_col.shape)
# 沿着行方向计算均值,并保持维度
mean_row = np.mean(arr, axis=1, keepdims=True)
print("每行的均值(保持维度):")
print(mean_row)
print("维度:", mean_row.shape)
整个数组的均值(保持维度):
[[5.]]
维度: (1, 1)
每列的均值(保持维度):
[[4. 5. 6.]]
维度: (1, 3)
每行的均值(保持维度):
[[2.]
[5.]
[8.]]
维度: (3, 1)
np.where(condition, x, y)
参数说明:
- condition:表示条件表达式,可以是一个布尔数组或条件表达式。
- x:表示满足条件时返回的值或数组。
- y:表示不满足条件时返回的值或数组。
import numpy as np
# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])
# 使用np.where()函数找出数组中大于2的元素的索引
indices = np.where(arr > 2)
print("大于2的元素的索引:", indices)
# 使用np.where()函数将数组中大于2的元素替换为0,小于等于2的元素替换为1
new_arr = np.where(arr > 2, 0, 1)
print("替换后的数组:", new_arr)
输出结果:
大于2的元素的索引: (array([2, 3, 4], dtype=int64),)
替换后的数组: [1 1 0 0 0]
np.maximum(array1, array2)
np.maximum()
函数会返回一个新的数组,其中每个位置的元素是两个输入数组对应位置元素的最大值。
参数说明:
array1
:第一个输入数组。array2
:第二个输入数组。
下面是一个示例,说明如何使用np.maximum()
函数:
import numpy as np
# 创建两个数组
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([3, 2, 1, 5, 4])
# 使用np.maximum()函数逐元素取最大值
result = np.maximum(arr1, arr2)
print("逐元素最大值:", result)
输出结果:
逐元素最大值: [3 2 3 5 5]
np.all(array, axis=None)
np.all()
函数会返回一个布尔值,如果数组中的所有元素都满足条件,则返回True
,否则返回False
。
参数说明:
array
:输入的数组。axis
:指定沿着哪个轴进行操作,如果不指定,则会将整个数组视为一个一维数组。
下面是一个示例,说明如何使用np.all()
函数:
import numpy as np
# 创建一个数组
arr = np.array([[1, 2, 3],
[4, 5, 6]])
# 检查数组中的所有元素是否大于0
result = np.all(arr > 0)
print("数组中的所有元素是否大于0:", result)
# 沿着列的方向检查每列元素是否都大于0
result_col = np.all(arr > 0, axis=0)
print("每列元素是否都大于0:", result_col)
# 沿着行的方向检查每行元素是否都大于0
result_row = np.all(arr > 0, axis=1)
print("每行元素是否都大于0:", result_row)
输出结果:
数组中的所有元素是否大于0: True
每列元素是否都大于0: [ True True True]
每行元素是否都大于0: [ True True]
在上面的示例中,我们首先创建了一个二维数组arr
,然后使用np.all()
函数检查数组中的所有元素是否大于0,并沿着列和行的方向分别检查每列和每行的元素是否都大于0。接下来,我们输出了相应的结果。
在上面的示例中,我们创建了两个数组arr1
和arr2
,然后使用np.maximum()
函数逐元素地取两个数组对应位置的最大值,并将结果存储在result
中。
二、实例
矩阵进行扩展三行,使得每一行都与第一行相同
import numpy as np
# 定义原始矩阵
matrix = np.array([[1, 2, 3]])
# 复制第一行,扩展为3行
extended_matrix = np.tile(matrix, (3, 1))
print(extended_matrix)
输出结果:
[[1 2 3]
[1 2 3]
[1 2 3]]
二维数组每行减去不同的数
import numpy as np
# 创建输入数组
input_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 创建要减去的数组
to_subtract = np.array([1, 2, 3])
# 使用广播功能实现减法操作
result = input_array - to_subtract[:, np.newaxis]
print(result)
输出结果为:
[[0 1 2]
[2 3 4]
[4 5 6]]
两个二维数组对应点生成坐标
import numpy as np
xv = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
yv = np.array([[0, 0, 0, 0],
[1, 1, 1, 1],
[2, 2, 2, 2]])
stacked_array = np.stack([yv, xv], axis=-1)
print("\n沿最后一个轴堆叠后的数组:")
print(stacked_array)
沿最后一个轴堆叠后的数组:
[[[ 0 1]
[ 0 2]
[ 0 3]
[ 0 4]]
[[ 1 5]
[ 1 6]
[ 1 7]
[ 1 8]]
[[ 2 9]
[ 2 10]
[ 2 11]
[ 2 12]]]