numpy部分函数实例

自用过的numpy函数

---

提示：以下是本篇文章正文内容，下面案例可供参考

numpy函数

1．np.argsort

需求：按矩阵中的某一行的值排序，并返回索引值
使用：使用NumPy中的argsort函数来对矩阵中的某一行的值进行排序，并返回排序后的元素的索引值。以下是一个示例：
代码如下（示例）：

import numpy as np

# 创建一个示例矩阵
matrix = np.array([[4, 2, 6],
                  [1, 7, 5],
                  [9, 3, 8]])

# 选择要排序的行的索引
row_index = 1  # 选择第二行（索引从0开始）

# 使用argsort函数对该行进行排序，并返回排序后的元素的索引
sorted_indices = np.argsort(matrix[row_index, :])

# 打印排序后的索引
print(sorted_indices)

2. np.tile

需求：python将一串自然数重复三次存入一维矩阵中，并打乱顺序
使用：用NumPy库来创建一个一维矩阵（也称为NumPy数组），其中包含一串自然数重复三次并打乱顺序。以下是一个示例：
代码如下（示例）：

import numpy as np

# 创建一个自然数序列，例如从1到20
natural_numbers = np.arange(1, 21)

# 将自然数序列重复三次
repeated_numbers = np.tile(natural_numbers, 3)
#　[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20  1  2  3  4
  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20  1  2  3  4  5  6  7  8
  9 10 11 12 13 14 15 16 17 18 19 20]

# 打乱顺序
np.random.shuffle(repeated_numbers)

# 打印结果
print(repeated_numbers)

首先使用np.arange创建了一个从1到10的自然数序列。然后，使用np.tile函数将这个序列重复三次，得到一个包含重复自然数的一维矩阵。最后，我们使用np.random.shuffle函数来打乱这个矩阵的顺序，以生成一个包含重复自然数并已打乱顺序的一维矩阵。

3．np.repeat

需求：创建一个矩阵，其中某一序列的元素重复三遍，并且其他元素为零，你可以使用NumPy库轻松实现这个任务。以下是一个示例：

import numpy as np

# 创建一个空矩阵，假设是6x6的
matrix = np.zeros((6, 6))

# 选择要重复的序列
sequence = [1, 2, 3]

# 将序列的每个元素重复三次
repeated_sequence = np.repeat(sequence, 3)
# [1 1 1 2 2 2 3 3 3]

# 将重复后的序列赋值到矩阵中
matrix[0, :len(repeated_sequence)] = repeated_sequence

# 打印结果
print(matrix)

首先创建了一个6x6的零矩阵。然后，它选择了要重复的序列（在示例中是[1, 2, 3]），使用np.repeat函数将每个元素重复三次，最后将重复后的序列赋值到矩阵的第一行。其余元素仍然保持为零。
注意与tile的区别

4．np.repeat

需求：要按列对二维矩阵进行打乱

import numpy as np

# 创建一个示例的二维矩阵
matrix = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])

# 获取矩阵的行数和列数
rows, cols = matrix.shape

# 生成一个包含列索引的随机排列
random_col_indices = np.random.permutation(cols)

# 使用随机排列的列索引重新排列矩阵的列
shuffled_matrix = matrix[:, random_col_indices]

# 打印结果
print(shuffled_matrix)

我们首先获取了矩阵的行数和列数，然后使用np.random.permutation函数生成列索引的随机排列。最后，我们使用这个随机排列的列索引重新排列矩阵的列，生成一个按列打乱的矩阵。

5. np.astype

需求：矩阵设置某一行的数值类型

import numpy as np

# 创建一个示例矩阵
matrix = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])

# 指定要设置类型的行索引
row_index = 1

# 指定要设置的新数据类型
new_dtype = np.float64  # 例如，设置为浮点数类型

# 使用astype函数设置行的数据类型
matrix[row_index, :] = matrix[row_index, :].astype(new_dtype)

# 打印结果
print(matrix)

首先创建一个示例矩阵。然后，我们指定要设置类型的行索引（在示例中是第二行，索引为1）和新的数据类型（在示例中是浮点数类型 np.float64）。最后，我们使用astype函数来将第二行的数据类型转换为浮点数类型。

6. np.lexsort

np.lexsort 是NumPy库中的一个函数，用于执行间接排序。它可以用于按多个键对数据进行排序，类似于Python的sorted函数的key参数，但是更强大。np.lexsort用于返回一组索引，这些索引用于对数据进行排序，使得在不同键上的排序都可以考虑。
np.lexsort的语法如下：

indices = np.lexsort(keys, axis=-1)

其中：

keys：是一个包含排序键的元组，列表或数组。这些排序键指定了排序的优先级。例如，如果有两个排序键，第一个键用于主要排序，第二个键用于次要排序。
axis：（可选）指定排序操作的轴，默认值为-1，表示在最后一个轴上进行排序。
np.lexsort 返回一组整数索引，这些索引可以用于对数据进行排序。在这些索引中，第一个索引指定了最高优先级的排序，第二个索引指定了次高优先级的排序，以此类推。

import numpy as np

# 创建示例数据
names = np.array(['Alice', 'Bob', 'Charlie', 'David', 'Eve'])
scores = np.array([85, 92, 78, 95, 92])

# 使用np.lexsort对数据进行排序
sorted_indices = np.lexsort((-scores, names))  # 先按分数降序排序，然后按名字升序排序

# 根据排序索引获取排好序的数据
sorted_names = names[sorted_indices]
sorted_scores = scores[sorted_indices]

# 打印结果
for name, score in zip(sorted_names, sorted_scores):
    print(name, score)

7. np.random.permutation

np.random.permutation 函数是 NumPy 库中用于生成随机排列的函数。它接受一个整数或一个数组作为输入，并返回一个随机排列的副本。

如果输入是一个整数 n，np.random.permutation 将返回一个包含范围 [0, n) 内整数的随机排列。

import numpy as np

# 生成一个范围在 [0, 10) 内整数的随机排列
random_permutation = np.random.permutation(10)
print(random_permutation)

# 生成一个数组的随机排列
original_array = np.array([1, 2, 3, 4, 5])
random_permutation_array = np.random.permutation(original_array)
print(random_permutation_array)

注意，np.random.permutation 返回的是一个副本，而不是在原地修改输入。如果你想在原地修改数组，可以使用 np.random.shuffle 函数。

# 在原地对数组进行随机排列
np.random.shuffle(original_array)
print(original_array)

8. np.arange

np.arange 是 NumPy 库中用于创建等差数组的函数。它返回一个由指定范围内的值组成的数组，可以通过指定开始值、结束值和步长来生成。
函数的基本语法如下：

numpy.arange([start, ]stop, [step, ], dtype=None)

参数说明：
start：起始值（可选，默认为0）。
stop：终止值（不包含在数组中）。
step：步长（可选，默认为1）。
dtype：返回数组的数据类型（可选）。

import numpy as np

# 生成一个包含 [0, 1, 2, ..., 9] 的数组
arr1 = np.arange(10)
print(arr1)

# 生成一个包含 [3, 6, 9, 12, 15] 的数组
arr2 = np.arange(3, 18, 3)
print(arr2)

# 生成一个包含 [0.0, 0.1, 0.2, ..., 0.9] 的数组
arr3 = np.arange(0, 1, 0.1)
print(arr3)

需要注意的是，np.arange 生成的数组不包含终止值，即 stop 参数指定的值不会出现在结果数组中。如果需要包含终止值，可以考虑使用 np.linspace 函数。

# 生成一个包含 [0, 1, 2, ..., 9, 10] 的数组
arr4 = np.linspace(0, 10, 11)
print(arr4)

---