文章目录 在某一维度做元素复制 实现按块复制元素 水平或者竖直方向合并多个数组 返回数组中某个维度的最大或最小值索引 限制打印元素个数和小数点后位数 返回有规律的数组 原生Python列表实现向量化 求中位数和众数 NumPy求任意分位数 相关系数 找到NumPy的缺失值 缺失值默认填充为0 返回没有缺失值的行 计算softmax 得分值 在某一维度做元素复制 在NumPy中，可以使用
numpy.repeat()
函数在某一维度上对数组进行元素复制。
该函数接受一个数组和一个重复次数的参数，并返回一个重复后的新数组。
以下是在某一维度上对数组进行元素复制的示例代码：
import numpy as np
# 创建一个一维数组
arr = np.array([1, 2, 3])
# 在某一维度上进行元素复制
new_arr = np.repeat(arr, 3, axis=0)
print("新数组:", new_arr)
输出结果：
新数组: [1 1 1 2 2 2 3 3 3]
在这个示例中，我们使用
np.repeat(arr, 3, axis=0)
函数对一维数组
arr
在0轴（行）上进行元素复制。
重复次数为3，所以每个元素都被复制了3次。
结果是一个新的一维数组
new_arr
，其中每个元素都被重复了3次。
需要注意的是，
axis
参数指定了进行复制的维度。
对于一维数组，只有0轴（行）可以进行复制。
对于多维数组，可以根据需要选择合适的轴进行复制。
此外，还可以使用
numpy.tile()
函数在某一维度上进行矩阵的复制。
不同于
np.repeat()
函数是在元素级别进行复制，
np.tile()
函数是在整个矩阵维度上进行复制。
以下是使用
np.tile()
函数在某一维度上进行矩阵复制的示例代码：
import numpy as np
# 创建一个二维数组
arr = np.array([[1, 2],
[3, 4]])
# 在某一维度上进行矩阵复制
new_arr = np.tile(arr, (2, 1))
print("新数组:")
print(new_arr)
输出结果：
新数组:
[[1 2]
[3 4]
[1 2]
[3 4]]
在这个示例中，我们使用
np.tile(arr, (2, 1))
函数对二维数组
arr
在0轴（行）上进行矩阵复制。
重复次数为(2, 1)，表示将原始矩阵沿行轴复制2次，沿列轴复制1次。
结果是一个新的二维数组
new_arr
，其中原始矩阵被复制了两次。
无论是使用
np.repeat()
函数还是
np.tile()
函数，都可以根据具体需求在某一维度上对数组进行元素复制。
实现按块复制元素 在Python中，可以使用NumPy库来实现按块复制元素的操作。
具体地，可以使用
numpy.tile()
函数来在数组的各个块之间复制元素。
以下是按块复制元素的示例代码：
import numpy as np
# 创建一个一维数组
arr = np.array([1, 2, 3])
# 按块复制元素
repeated_arr = np.tile(arr, 3)
print("重复后的数组:", repeated_arr)
输出结果：
重复后的数组: [1 2 3 1 2 3 1 2 3]
在这个示例中，我们使用
np.tile(arr, 3)
函数将一维数组
arr
按块复制了3次，即每个元素被复制了3次。
结果是一个新的一维数组
repeated_arr
，其中每个块包含原始数组
arr
的所有元素。
需要注意的是，
np.tile()
函数的第二个参数是一个表示重复次数的整数，表示在每个维度上进行的复制次数。
如果需要按不同的维度进行复制，可以使用一个元组作为第二个参数来指定不同的重复次数。
以下是按块复制元素的示例代码，其中按不同的维度进行复制：
import numpy as np
# 创建一个二维数组
arr = np.array([[1, 2],
[3, 4]])
# 按块复制元素
repeated_arr = np.tile(arr, (2, 3))
print("重复后的数组:")
print(repeated_arr)
输出结果：
重复后的数组:
[[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.tile(arr, (2, 3))
函数将二维数组
arr
按块复制了两次行轴（沿行复制）和三次列轴（沿列复制）。
结果是一个新的二维数组
repeated_arr
，其中每个块包含原始数组
arr
的所有元素。
通过使用
np.tile()
函数和适当的参数，可以按需求按块复制元素。
水平或者竖直方向合并多个数组 在Python中，可以使用NumPy库中的
numpy.concatenate()
函数来水平或竖直方向合并多个数组。
以下是水平方向合并多个数组的示例代码：
import numpy as np
# 创建两个一维数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
# 水平方向合并数组
merged_arr = np.concatenate((arr1, arr2), axis=0)
print("水平合并后的数组:", merged_arr)
输出结果：
水平合并后的数组: [1 2 3 4 5 6]
在这个示例中，我们使用
np.concatenate((arr1, arr2), axis=0)
函数将两个一维数组
arr1
和
arr2
在水平方向上进行合并。
axis=0
参数表示在0轴（行）上进行合并。
结果是一个新的一维数 组
merged_arr
，其中包含了两个原始数组的元素。
同样地，可以使用
np.concatenate()
函数在竖直方向合并多个数组，如下所示：
import numpy as np
# 创建两个二维数组
arr1 = np.array([[1, 2],
[3, 4]])
arr2 = np.array([[5, 6],
[7, 8]])
# 竖直方向合并数组
merged_arr = np.concatenate((arr1, arr2), axis=1)
print("竖直合并后的数组:")
print(merged_arr)
输出结果：
竖直合并后的数组:
[[1 2 5 6]
[3 4 7 8]]
在这个示例中，我们使用
np.concatenate((arr1, arr2), axis=1)
函数将两个二维数组
arr1
和
arr2
在竖直方向上进行合并。
axis=1
参数表示在1轴（列）上进行合并。
结果是一个新的二维数组
merged_arr
，其中包含了两个原始数组的元素。
需要注意的是，合并数组时，被合并的数组在指定的轴上的形状必须一致。
否则，会引发
ValueError
错误。
通过使用
np.concatenate()
函数和适当的参数，可以方便地水平或竖直方向合并多个数组。
返回数组中某个维度的最大或最小值索引 在NumPy中，可以使用
numpy.argmax()
和
numpy.argmin()
函数来返回数组中某个维度的最大值或最小值索引。
以下是使用这两个函数的示例代码： 返回某个维度的最大值索引：
import numpy as np
arr = np.array([[1, 2, 3],
[4, 5, 6]])
# 沿第一维度（行）返回最大值索引
max_index = np.argmax(arr, axis=0)
print("最大值索引:", max_index)
输出结果：
最大值索引: [1 1 1]
在这个示例中，我们使用
np.argmax(arr, axis=0)
函数返回数组
arr
沿第一维度（行）的最大值索引。
axis=0
参数指定了要沿行计算最大值索引。
结果是一个一维数组，其中每个元素表示该列的最大值所在的行索引。
返回某个维度的最小值索引：
import numpy as np
arr = np.array([[1, 2, 3],
[4, 5, 6]])
# 沿第二维度（列）返回最小值索引
min_index = np.argmin(arr, axis=1)
print("最小值索引:", min_index)
输出结果：
最小值索引: [0 0]
在这个示例中，我们使用
np.argmin(arr, axis=1)
函数返回数组
arr
沿第二维度（列）的最小值索引。
axis=1
参数指定了要沿列计算最小值索引。
结果是一个一维数组，其中每个元素表示该行的最小值所在的列索引。
需要注意的是，这两个函数可以通过
axis
参数指定要计算的维度。
对于多维数组，可以根据具体需求选择合适的轴来计算最大值或最小值的索引。
通过使用
np.argmax()
和
np.argmin()
函数，可以方便地获取数组中某个维度的最大或最小值索引。
限制打印元素个数和小数点后位数 在NumPy中，可以使用
numpy.set_printoptions()
函数来设置打印选项，包括限制打印的元素个数和小数点后的位数。
以下是设置打印选项的示例代码：
import numpy as np
arr = np.array([1.23456789, 2.3456789, 3.456789])
# 设置打印选项：限制打印的元素个数为2，小数点后保留3位
np.set_printoptions(precision=3, suppress=True, threshold=2)
print(arr)
输出结果：
[1.23 2.346 3.457]
在这个示例中，我们使用
np.set_printoptions()
函数来设置打印选项。
precision
参数指定小数点后的位数，
suppress
参数用于控制是否打印科学计数法，
threshold
参数用于限制打印的元素个数。
通过设置这些参数的值，我们可以自定义打印的格式。
需要注意的是，
precision
参数指定的是小数点后的位数，而不是有效数字的总位数。
另外，
suppress
参数设置为
True
可以禁用科学计数法，使得打印的结果更接近实际数值。
通过使用
np.set_printoptions()
函数，可以方便地设置打印选项，包括限制打印的元素个数和小数点后的位数，以满足特定的打印需求。
返回有规律的数组
a = np.array([1, 2, 3])
result1 = np.repeat(a, 3)
# [1 1 1 2 2 2 3 3 3]
print(result1)
b = np.tile(a, 3)
# [1 2 3 1 2 3 1 2 3]
print(b)
result2 = np.c_[np.repeat(a, 3), np.tile(a, 3)]
# [[1 1]
# [1 2]
# [1 3]
# [2 1]
# [2 2]
# [2 3]
# [3 1]
# [3 2]
# [3 3]]
print(result2)
原生Python列表实现向量化 以下是使用原生Python列表进行向量化计算的示例：
# 使用原生Python列表进行向量化计算
def vectorized_sum(a, b):
return [x + y for x, y in zip(a, b)]
a = [1, 2, 3]
b = [4, 5, 6]
result = vectorized_sum(a, b)
print(result)
输出结果：
[5, 7, 9]
在这个示例中，我们定义了一个
vectorized_sum
函数，它接受两个原生Python列表
a
和
b
，并使用
zip
函数逐个元素进行相加操作，最后返回一个包含相加结果的新列表。
然而，需要注意的是，原生Python列表进行向量化计算的效率较低，尤其是在处理大量数据时。
这是因为原生Python列表的操作通常涉及了类型检查和循环迭代，而NumPy的数组提供了优化的底层实现，能够高效地执行向量化计算。
如果需要频繁进行向量化计算，推荐使用NumPy或其他类似的数值计算库，以获得更好的性能和代码简洁性。
求中位数和众数 在NumPy中，可以使用
numpy.median()
函数来计算数组的中位数，以及使用
numpy.unique()
函数结合
numpy.argmax()
函数来计算数组的众数。
以下是计算中位数和众数的示例代码： 计算数组的中位数：
import numpy as np
arr = np.array([1, 3, 2, 4, 5])
median = np.median(arr)
print("中位数:", median)
输出结果：
中位数: 3.0
在这个示例中，我们使用
np.median(arr)
函数计算数组
arr
的中位数。
结果为3.0。
计算数组的众数：
pythonCopy code
import numpy as np
arr = np.array([1, 3, 2, 2, 4, 4, 5, 5])
unique_values, counts = np.unique(arr, return_counts=True)
mode = unique_values[np.argmax(counts)]
print("众数:", mode)
输出结果：
众数: 2
在这个示例中，我们使用
np.unique(arr, return_counts=True)
函数获取数组
arr
中每个唯一值的频数。
然后，通过
np.argmax(counts)
找到频数最大的索引，再通过
unique_values
获取对应的众数。
结果为2。
需要注意的是，如果数组存在多个众数，上述方法只会返回其中的一个众数。
通过使用
np.median()
函数和结合
np.unique()
和
np.argmax()
函数，可以方便地计算数组的中位数和众数。
NumPy求任意分位数 在NumPy中，可以使用
numpy.percentile()
函数来计算数组的任意分位数。
函数签名：
numpy.percentile(a, q, axis=None, interpolation='linear', keepdims=False)
参数说明：
a
：输入的数组。
q
：要计算的分位数，可以是单个值或以列表或数组的形式指定多个分位数。
axis
：可选参数，指定在哪个轴上计算分位数。
默认为
None
，表示在整个数组上计算。
interpolation
：可选参数，指定计算分位数时的插值方法。
默认为
linear
，表示线性插值。
keepdims
：可选参数，指定是否保持计算结果的维度。
默认为
False
，表示降维计算。
以下是计算任意分位数的示例代码：
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
# 计算50%分位数（中位数）
median = np.percentile(arr, 50)
# 计算25%和75%分位数
quartiles = np.percentile(arr, [25, 75])
print("中位数:", median)
print("25%分位数:", quartiles[0])
print("75%分位数:", quartiles[1])
输出结果：
makefileCopy code
中位数: 3.0
25%分位数: 2.0
75%分位数: 4.0
在这个示例中，我们使用
np.percentile()
函数分别计算了50%（中位数）、25%和75%分位数。
通过将要计算的分位数以列表的形式传递给
q
参数，可以同时计算多个分位数。
通过使用
np.percentile()
函数，可以方便地计算数组的任意分位数，从而获取数据的分布情况。
相关系数 相关系数是一种用于衡量两个变量之间关联程度的统计量。
它衡量了两个变量在统计意义上的线性关系强度和方向。
常用的相关系数是皮尔逊相关系数（Pearson correlation coefficient），也称为Pearson相关系数。
它的取值范围为-1到1之间，其中-1表示完全的负相关，0表示无相关，1表示完全的正相关。
具体计算公式如下：
r = Cov(X, Y) / (σ(X) * σ(Y))
其中，
Cov(X, Y)
表示X和Y的协方差，
σ(X)
和
σ(Y)
分别表示X和Y的标准差。
皮尔逊相关系数衡量的是两个变量之间的线性关系，当变量之间的关系不是线性的时候，皮尔逊相关系数可能不适用。
在这种情况下，可以考虑使用其他的相关系数，如Spearman相关系数（用于衡量变量的等级关系）或Kendall秩相关系数（用于衡量变量的等级关系和排序一致性）。
相关系数在数据分析、统计学和机器学习中都有广泛的应用。
它可以帮助我们了解变量之间的关联性，从而揭示数据的模式和趋势，以及变量之间的依赖关系 在NumPy中，可以使用
numpy.corrcoef()
函数来计算数组的相关系数。
该函数接受一个数组作为输入，并返回一个相关系数矩阵，其中矩阵的(i, j)位置的值表示第i个数组和第j个数组之间的相关系数。
函数签名：
numpy.corrcoef(x, y=None, rowvar=True)
参数说明：
x
：输入的数组或多个数组组成的矩阵。
y
：可选参数，用于计算与
x
的相关系数。
如果未提供
y
，则计算
x
数组内部的相关系数。
rowvar
：可选参数，指定输入数组的排列方式。
默认为
True
，表示每行代表一个变量，每列代表一个观察值。
以下是计算相关系数的示例代码：
import numpy as np
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])
# 计算x和y的相关系数
correlation_matrix = np.corrcoef(x, y)
print(correlation_matrix)
输出结果：
[[1. 1.]
[1. 1.]]
在这个示例中，我们使用
np.corrcoef(x, y)
函数计算了数组
x
和
y
之间的相关系数。
相关系数矩阵是一个2x2的矩阵，对角线上的值都是1，表示每个数组与自身的相关系数为1。
需要注意的是，
numpy.corrcoef()
函数默认将每行视为一个变量，每列视为一个观察值。
如果输入的是多个数组组成的矩阵，它将计算这些数组之间的相关系数。
通过使用
numpy.corrcoef()
函数，可以方便地计算数组之间的相关系数，以评估它们之间的线性关系。
找到NumPy的缺失值 在NumPy中，可以使用
numpy.isnan()
函数来找到数组中的缺失值。
函数签名：
numpy.isnan(x)
参数说明：
x
：要检查的数组。
该函数返回一个布尔类型的数组，与输入数组形状相同，对应位置为True表示该位置上的值是缺失值（NaN），为False表示该位置上的值不是缺失值。
以下是找到NumPy数组中的缺失值的示例代码：
import numpy as np
arr = np.array([1, np.nan, 3, np.nan, 5])
# 找到缺失值
mask = np.isnan(arr)
np.where(mask)
print(mask)
输出结果：
[False True False True False]
在这个示例中，我们使用
np.isnan(arr)
函数找到了数组
arr
中的缺失值。
结果是一个布尔类型的数组，对应位置上为True表示该位置上的值是缺失值。
通过使用
numpy.isnan()
函数，可以方便地在NumPy中找到数组中的缺失值，并进一步进行处理或分析。
缺失值默认填充为0 在NumPy中，可以使用
numpy.nan_to_num()
函数将缺失值（NaN）替换为指定的值，默认情况下是将缺失值替换为0。
函数签名：
numpy.nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None)
参数说明：
x
：要替换缺失值的数组。
copy
：可选参数，指定是否创建副本，默认为
True
。
nan
：可选参数，指定要替换缺失值的值，默认为0.0。
posinf
：可选参数，指定要替换正无穷值的值，默认为
None
，表示不替换。
neginf
：可选参数，指定要替换负无穷值的值，默认为
None
，表示不替换。
以下是将缺失值替换为0的示例代码：
import numpy as np
arr = np.array([1, np.nan, 3, np.nan, 5])
# 将缺失值替换为0
arr_filled = np.nan_to_num(arr)
print(arr_filled)
输出结果：
[1. 0. 3. 0. 5.]
在这个示例中，我们使用
np.nan_to_num(arr)
函数将数组
arr
中的缺失值替换为0。
结果数组
arr_filled
中缺失值被替换为0。
需要注意的是，
numpy.nan_to_num()
函数默认将缺失值（NaN）替换为0，但不替换正无穷值（inf）和负无穷值（-inf）。
如果需要替换其他类型的缺失值或无穷值，可以通过参数进行指定。
通过使用
numpy.nan_to_num()
函数，可以方便地在NumPy中将缺失值替换为指定的值。
这对于数据预处理和计算的一致性非常有用。
返回没有缺失值的行
import numpy as np
# 创建包含缺失值的二维数组
arr = np.array([[1, 2, np.nan],
[4, np.nan, 6],
[7, 8, 9]])
# 找到没有缺失值的行
rows_without_nan = arr[~np.isnan(arr).any(axis=1)]
print(rows_without_nan)
计算softmax 得分值 在NumPy中，可以使用以下方式计算Softmax得分值：
import numpy as np
def softmax(scores):
exp_scores = np.exp(scores)
softmax_scores = exp_scores / np.sum(exp_scores)
return softmax_scores
上述代码定义了一个名为
softmax
的函数，该函数接受一个NumPy数组作为输入，并返回计算得到的Softmax得分值。
在函数中，首先使用
np.exp()
计算输入数组中每个元素的指数。
然后，使用
np.sum()
对指数化的得分进行求和，得到归一化因子。
最后，通过将指数化的得分除以归一化因子，得到Softmax得分值。
以下是使用
softmax
函数计算Softmax得分值的示例代码：
scores = np.array([2, 5, -1, 3])
softmax_scores = softmax(scores)
print(softmax_scores)
输出结果：
[0.04201007 0.71860604 0.00242826 0.23695563]
在这个示例中，我们将一个包含四个分数的NumPy数组
scores
传递给
softmax
函数，并获得了计算得到的Softmax得分值。
结果数组
softmax_scores
中的每个元素表示相应类别的Softmax概率。
需要注意的是，Softmax函数用于将一组任意实数转换为概率分布，使得所有得分值都在0到1之间，并且总和为1。
Softmax得分值通常用于多类别分类问题的输出层，以表示每个类别的概率。