文章目录
在某一维度做元素复制
在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得分值通常用于多类别分类问题的输出层，以表示每个类别的概率。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
