Numpy基础知识学习day03

于 2024-10-18 16:29:54 发布
阅读量1k 收藏 17
点赞数 30
分类专栏： 数据分析 文章标签： numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_52854529/article/details/143052017
版权

目录

1、矩阵（二维数组）

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

下面进行索引和切片

在这里插入图片描述
Numpy索引和切片

聚合矩阵（aggregated vectors）

在这里插入图片描述
在这里插入图片描述

2、矩阵加法和乘法

在这里插入图片描述
矩阵的加法和乘法是线性代数中的基本运算，它们在各种科学计算、工程和数据分析领域中都有广泛的应用。NumPy 提供了简单而强大的方法来实现这些运算。

矩阵加法

矩阵加法要求两个矩阵具有相同的形状（即相同数量的行和列）。加法是逐元素进行的。

示例代码
import numpy as np

# 创建两个 2x2 矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵加法
C = A + B

print("Matrix A:")
print(A)
print("Matrix B:")
print(B)
print("Matrix A + Matrix B:")
print(C)
# 输出:
# Matrix A:
# [[1 2]
#  [3 4]]
# Matrix B:
# [[5 6]
#  [7 8]]
# Matrix A + Matrix B:
# [[ 6  8]
#  [10 12]]

矩阵乘法

矩阵乘法有两种常见的形式：点积（内积）和哈达玛积（Hadamard 乘积）。

点积（内积）

点积（内积）是标准的矩阵乘法，它要求第一个矩阵的列数等于第二个矩阵的行数。结果矩阵的形状为第一个矩阵的行数乘以第二个矩阵的列数。

示例代码
import numpy as np

# 创建两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 使用 @ 运算符进行矩阵乘法
C = A @ B

print("Matrix A:")
print(A)
print("Matrix B:")
print(B)
print("Matrix A @ Matrix B (Dot Product):")
print(C)
# 输出:
# Matrix A:
# [[1 2]
#  [3 4]]
# Matrix B:
# [[5 6]
#  [7 8]]
# Matrix A @ Matrix B (Dot Product):
# [[19 22]
#  [43 50]]
哈达玛积（Hadamard 乘积）

哈达玛积是两个矩阵对应元素的逐元素乘法。这要求两个矩阵具有相同的形状。

示例代码
import numpy as np

# 创建两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 使用 * 运算符进行逐元素乘法
C = A * B

print("Matrix A:")
print(A)
print("Matrix B:")
print(B)
print("Matrix A * Matrix B (Hadamard Product):")
print(C)
# 输出:
# Matrix A:
# [[1 2]
#  [3 4]]
# Matrix B:
# [[5 6]
#  [7 8]]
# Matrix A * Matrix B (Hadamard Product):
# [[ 5 12]
#  [21 32]]

使用 NumPy 函数

NumPy 也提供了专门的函数来进行矩阵乘法和逐元素乘法。

使用 np.dot 进行点积
import numpy as np

# 创建两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 使用 np.dot 进行矩阵乘法
C = np.dot(A, B)

print("Matrix A:")
print(A)
print("Matrix B:")
print(B)
print("Matrix A @ Matrix B (Dot Product):")
print(C)
# 输出:
# Matrix A:
# [[1 2]
#  [3 4]]
# Matrix B:
# [[5 6]
#  [7 8]]
# Matrix A @ Matrix B (Dot Product):
# [[19 22]
#  [43 50]]
使用 np.multiply 进行逐元素乘法
import numpy as np

# 创建两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 使用 np.multiply 进行逐元素乘法
C = np.multiply(A, B)

print("Matrix A:")
print(A)
print("Matrix B:")
print(B)
print("Matrix A * Matrix B (Hadamard Product):")
print(C)
# 输出:
# Matrix A:
# [[1 2]
#  [3 4]]
# Matrix B:
# [[5 6]
#  [7 8]]
# Matrix A * Matrix B (Hadamard Product):
# [[ 5 12]
#  [21 32]]

总结

  • 矩阵加法：使用 + 运算符或相应的 NumPy 函数。
  • 点积（内积）：使用 @ 运算符或 np.dot 函数。
  • 逐元素乘法（哈达玛积）：使用 * 运算符或 np.multiply 函数。

3、矩阵的广播机制

可以对不同大小的矩阵执行这些算术运算，但前提是一个矩阵只有一列或一行。在这种情况下，NumPy 将使用其广播规则进行操作。
在这里插入图片描述
矩阵的广播机制（Broadcasting）是 NumPy 中处理数组之间形状不匹配的一种方法。当执行涉及不同形状的数组的操作时，NumPy 会尝试通过扩展较小的数组的形状来使两个数组的形状匹配，从而使得操作能够顺利进行。这种方法避免了显式循环和手动填充数据，使得代码更加简洁和高效。

广播的基本规则

广播机制遵循以下三个基本规则：

  1. 对齐规则：从右向左比较两个数组的维度大小，如果某个维度的大小不相等，则较小的数组将在这一维度上重复数据，直到与较大数组的维度大小相等。
  2. 维度扩展规则：如果较小的数组缺少某些维度，则认为这些维度的大小为 1，然后将这些维度扩展到与较大数组相同的大小。
  3. 维度匹配规则：如果两个数组在某个维度上的大小不相等且不为 1，则无法进行广播。

示例

示例 1: 一维数组与标量的加法

假设我们有一个一维数组 arr 和一个标量 scalar，我们想将标量加到数组的每个元素上。

import numpy as np

# 创建一个一维数组
arr = np.array([1, 2, 3])

# 创建一个标量
scalar = 10

# 将标量加到数组的每个元素上
result = arr + scalar

print("Original array:", arr)
print("Scalar:", scalar)
print("Result after broadcasting:", result)
# 输出:
# Original array: [1 2 3]
# Scalar: 10
# Result after broadcasting: [11 12 13]

在这个例子中，标量 scalar 被隐式地扩展成了一个形状为 (3,) 的数组 [10, 10, 10]，然后与原数组 arr 进行逐元素加法。

示例 2: 二维数组与一维数组的加法

假设我们有一个二维数组 matrix 和一个一维数组 vector，我们想将一维数组加到二维数组的每一行上。

import numpy as np

# 创建一个二维数组
matrix = np.array([[1, 2], [3, 4], [5, 6]])

# 创建一个一维数组
vector = np.array([10, 20])

# 将一维数组加到二维数组的每一行上
result = matrix + vector

print("Original matrix:")
print(matrix)
print("Vector:")
print(vector)
print("Result after broadcasting:")
print(result)
# 输出:
# Original matrix:
# [[1 2]
#  [3 4]
#  [5 6]]
# Vector:
# [10 20]
# Result after broadcasting:
# [[11 22]
#  [13 24]
#  [15 26]]

在这个例子中，一维数组 vector 被隐式地扩展成了一个形状为 (3, 2) 的数组，然后与二维数组 matrix 进行逐元素加法。

示例 3: 二维数组与二维数组的加法

假设我们有两个形状不同的二维数组 matrix_a 和 matrix_b，我们想将它们相加。

import numpy as np

# 创建两个二维数组
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[10, 10], [10, 10], [10, 10]])

# 尝试将两个二维数组相加
try:
    result = matrix_a + matrix_b
except ValueError as e:
    print(e)
# 输出:
# operands could not be broadcast together with shapes (2,2) (3,2)

在这个例子中，两个二维数组的形状不匹配，且不能通过广播机制来匹配，因此会抛出 ValueError 异常。

广播的具体步骤

  1. 对齐维度：从右向左对齐两个数组的维度，直到长度相等。
  2. 扩展维度：如果某个维度的大小为 1 或者不存在，则将该维度扩展到与另一个数组的相应维度大小相同。
  3. 逐元素操作：进行逐元素操作。

总结

  • 广播机制：允许不同形状的数组进行操作。
  • 规则：从右向左对齐维度，扩展尺寸为 1 的维度，直至维度匹配。
  • 应用：简化数组操作，避免显式循环和手动填充数据。

4、数组的生成速度

当 NumPy 打印 N 维数组时，最后一个轴的循环速度最快，而第一个轴的循环速度最慢。（轴就是维度）
在 NumPy 中，数组的存储方式遵循 C 语言的行主序（row-major order），即在内存中是按照行优先的方式存储数据的。具体来说，这意味着最后一个轴（维度）的变化频率最高，而第一个轴的变化频率最低。这种存储方式有助于优化内存访问效率。

解释

为了更好地理解这句话，我们可以分解如下：

  1. 最后一个轴的循环速度最快：

    • 这意味着当你遍历数组时，最后一个轴（维度）上的元素是最紧密相连的。在内存中，相邻的元素在最后一个轴上是连续存储的。
    • 例如，在二维数组中，如果数组的形状为 (m, n)，那么同一行内的元素是连续存储的。这意味着当你遍历一行内的所有元素时，内存访问是连续的，效率较高。

  2. 第一个轴的循环速度最慢：

    • 这意味着当你遍历数组时，第一个轴（维度）上的元素是最分散的。在内存中，相邻的元素在第一个轴上间隔较大。
    • 例如，在二维数组中，如果你遍历所有的行，那么每行之间的元素在内存中不是连续的，而是间隔了一行的宽度（即列数）。

示例

让我们通过具体的例子来进一步说明这一点。

二维数组的存储方式

假设我们有一个形状为 (2, 3) 的二维数组 arr：

import numpy as np

# 创建一个 2x3 的二维数组
arr = np.array([[1, 2, 3],
                [4, 5, 6]])

print("Original array:")
print(arr)
# 输出:
# Original array:
# [[1 2 3]
#  [4 5 6]]

在内存中，这个数组会被存储为：

[1, 2, 3, 4, 5, 6]

这里，元素 1、2 和 3 是连续存储的，因为它们在同一行内。同样，元素 4、5 和 6 也是连续存储的。但是，元素 3 和 4 之间间隔了三个元素（即一行的宽度）。

访问示例

逐行访问

如果我们逐行访问这个数组，内存访问模式如下：

# 逐行访问数组
for row in arr:
    print(row)
# 输出:
# [1 2 3]
# [4 5 6]

这里的内存访问是跳跃式的，因为每行之间有间隔。

逐列访问

如果我们逐列访问这个数组，内存访问模式如下：

# 逐列访问数组
for col in range(arr.shape[1]):
    print(arr[:, col])
# 输出:
# [1 4]
# [2 5]
# [3 6]

这里的内存访问也是跳跃式的，因为每次访问的元素之间有间隔。

总结

  • 最后一个轴（维度）的变化频率最高，意味着在这个轴上的元素在内存中是连续存储的。
  • 第一个轴（维度）的变化频率最低，意味着在这个轴上的元素在内存中是间隔较大的。
  • 这种存储方式有助于优化内存访问效率，特别是在需要访问连续数据时。

5、生成全1/全0/随机数字的多维度矩阵（数组）

在这里插入图片描述
在这里插入图片描述

6、生成随机数

随机数生成的使用是许多数值和机器学习算法的配置和评估的重要组成部分。无论您需要随机初始化人工神经网络中的权重、将数据拆分为随机集，还是随机洗牌数据集，能够生成随机数（实际上是可重复的伪随机数）都是至关重要的。

> random模块

在 NumPy 中，生成随机数是通过 numpy.random 模块实现的。这个模块提供了丰富的随机数生成功能，既可以生成基本的随机数，也支持更高级的分布、采样和随机数控制方法。

1. 基础随机数生成

1.1 numpy.random.rand：生成 [0, 1) 区间上的均匀分布随机数

这是最常见的生成随机数的函数，用于生成给定形状的随机数组，随机数在 [0, 1) 区间内，服从均匀分布。

import numpy as np

# 生成一个随机数（标量）
print(np.random.rand())  # 输出：0.528...

# 生成一个 3x3 的随机数组
print(np.random.rand(3, 3))  # 输出：
# [[0.172 0.893 0.719]
#  [0.419 0.942 0.459]
#  [0.361 0.795 0.125]]
1.2 numpy.random.randn：生成标准正态分布的随机数

randn 生成的随机数服从标准正态分布，即均值为 0，标准差为 1。

import numpy as np

# 生成一个标准正态分布的随机数（标量）
print(np.random.randn())  # 输出：0.762...

# 生成一个 3x3 的标准正态分布随机数组
print(np.random.randn(3, 3))  # 输出：
# [[ 1.256 -0.317  1.580]
#  [ 0.765 -0.647  0.124]
#  [-0.398  0.942 -1.348]]
1.3 numpy.random.randint：生成指定范围的随机整数

randint 用于生成指定范围内的整数随机数。可以生成单个整数，也可以生成多维数组。

import numpy as np

# 生成一个随机整数，范围在 [0, 10) 之间
print(np.random.randint(0, 10))  # 输出：5

# 生成一个 3x3 的随机整数数组，范围在 [0, 10) 之间
print(np.random.randint(0, 10, size=(3, 3)))  # 输出：
# [[4 0 7]
#  [1 6 3]
#  [8 2 5]]

2. 控制随机数的种子（seed）

随机数的生成是基于一定的算法，使用伪随机数生成器（PRNG）。为了保证每次生成的随机数可重复（即生成相同的随机数序列），你可以使用 numpy.random.seed 函数来设置随机数的种子。

import numpy as np

# 设置随机种子为 42
np.random.seed(42)

# 生成 3x3 的随机数矩阵
print(np.random.rand(3, 3))  # 每次执行，输出结果都相同

随机数种子（seed） 是用于初始化伪随机数生成器的一个值。在计算机中，随机数并不是完全随机的，而是通过**伪随机数生成器（PRNG，Pseudo-Random Number Generator）**生成的。伪随机数生成器基于某个算法生成一个确定的随机数序列，而这个序列的起点就是由种子值决定的。

通过设置相同的种子，可以使得每次运行程序时生成的随机数序列相同，这在调试和测试中非常有用，因为它可以确保结果的可重复性。

随机数生成的过程
  1. 伪随机数生成器会根据给定的种子值生成一个初始状态。
  2. 通过算法从这个初始状态生成一个确定的伪随机数序列。
  3. 同样的种子值总是会生成相同的伪随机数序列。
为什么使用种子？
  • 可重复性：在程序的不同运行中，如果使用相同的种子，随机数的输出会保持一致，这对于调试和测试非常有帮助。
  • 控制随机性：在某些情况下，完全随机的行为不适合测试，因此使用固定的种子可以模拟随机但可控的情况。
  • 调试方便：由于随机数生成器的输出是基于种子的，如果在不同的运行中随机数发生变化，可能会导致难以追踪错误。使用相同种子，可以确保生成相同的随机数序列，有助于定位和修复问题。
如何使用 seed 在 NumPy 中
1. 使用 numpy.random.seed

在旧的 NumPy 随机数生成器 API 中，可以使用 numpy.random.seed 来设置种子。

import numpy as np

# 设置随机数种子为 42
np.random.seed(42)

# 生成一组随机数
print(np.random.rand(3))  # 输出：[0.37454012 0.95071431 0.73199394]

# 每次运行相同的代码都会生成相同的随机数
np.random.seed(42)
print(np.random.rand(3))  # 输出：[0.37454012 0.95071431 0.73199394]
2. 使用新的 Generator API

从 NumPy 1.17 开始，推荐使用新的 Generator API，通过 numpy.random.default_rng(seed) 来设置种子。

import numpy as np

# 创建一个随机数生成器并设置种子为 42
rng = np.random.default_rng(42)

# 生成一组随机数
print(rng.random(3))  # 输出：[0.77395605 0.43887844 0.85859792]

# 设置相同的种子时，每次生成的随机数相同
rng = np.random.default_rng(42)
print(rng.random(3))  # 输出：[0.77395605 0.43887844 0.85859792]
总结
  • 随机数种子（seed） 控制伪随机数生成器的起点。相同的种子值会生成相同的随机数序列。
  • 使用种子确保可重复性，特别在调试和测试时非常有用。
  • 在 NumPy 中，旧的 API 使用 numpy.random.seed()，新的推荐 API 是使用 numpy.random.default_rng(seed) 创建随机数生成器。

3. 高级随机数生成

3.1 从给定的概率分布生成随机数

NumPy 提供了多种常见概率分布的随机数生成函数，如均匀分布、正态分布、二项分布等。

  • 均匀分布 (numpy.random.uniform)：生成指定范围内的均匀分布随机数。
# 生成范围在 [1, 10) 内的均匀分布随机数
print(np.random.uniform(1, 10, size=(3, 3)))  # 输出：
# [[5.482 7.637 6.727]
#  [1.376 9.616 2.190]
#  [1.500 6.151 1.191]]
  • 正态分布 (numpy.random.normal)：生成正态分布随机数。
# 生成均值为 5，标准差为 2 的正态分布随机数
print(np.random.normal(5, 2, size=(3, 3)))  # 输出：
# [[5.462 6.573 6.570]
#  [4.491 6.296 1.974]
#  [5.168 4.798 6.572]]
  • 二项分布 (numpy.random.binomial)：生成二项分布的随机数（即投掷硬币等实验的模拟）。
# 进行 10 次试验，每次成功概率为 0.5，生成 3x3 的随机数数组
print(np.random.binomial(10, 0.5, size=(3, 3)))  # 输出：
# [[3 6 4]
#  [5 5 6]
#  [5 5 6]]
3.2 从现有数组中随机抽样
  • numpy.random.choice：从给定的一维数组中随机选择元素，支持有放回和无放回抽样。
import numpy as np

arr = np.array([10, 20, 30, 40, 50])

# 从数组中随机选择 3 个元素（无放回）
print(np.random.choice(arr, 3, replace=False))  # 输出：例如 [40 50 10]

# 从数组中随机选择 3 个元素（有放回）
print(np.random.choice(arr, 3, replace=True))  # 输出：例如 [30 30 40]
3.3 打乱数组元素
  • numpy.random.shuffle：对原数组进行原地打乱操作。
  • numpy.random.permutation：返回一个打乱后的数组（不会改变原数组）。
import numpy as np

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

# 使用 shuffle 原地打乱数组
np.random.shuffle(arr)
print(arr)  # 输出：例如 [2 5 1 3 4]

# 使用 permutation 返回打乱后的数组
arr2 = np.array([1, 2, 3, 4, 5])
shuffled_arr = np.random.permutation(arr2)
print(shuffled_arr)  # 输出：例如 [4 1 5 3 2]
print(arr2)  # 原数组未变，输出：[1 2 3 4 5]

4. 生成多维随机数矩阵

除了生成一维或二维随机数数组，NumPy 还支持生成多维随机矩阵。

4.1 生成多维均匀分布随机数
import numpy as np

# 生成一个 2x3x4 的三维随机数组
arr = np.random.rand(2, 3, 4)
print(arr)
4.2 从多维数组中随机抽样
import numpy as np

# 从 2x3x4 的三维数组中进行随机选择，无放回抽样
arr = np.arange(24).reshape(2, 3, 4)
result = np.random.choice(arr.flat, 5, replace=False)  # 展平数组后抽样
print(result)  # 输出：例如 [14 15  0 18 10]

5. 随机数生成器对象（numpy.random.Generator）

在 NumPy 1.17 之后，推荐使用新的随机数生成器对象 numpy.random.Generator，它具有更多功能并提高了生成效率。你可以通过 numpy.random.default_rng() 创建生成器。

import numpy as np

# 创建随机数生成器对象
rng = np.random.default_rng()

# 使用生成器生成随机数
print(rng.random((3, 3)))  # 生成 3x3 的均匀分布随机数组

# 使用生成器生成指定范围的随机整数
print(rng.integers(1, 10, size=(3, 3)))  # 输出：
# [[7 1 6]
#  [9 9 3]
#  [9 4 7]]

6. 总结

NumPy 提供了多种随机数生成方法，涵盖从基本的均匀分布、正态分布到更高级的抽样、排列等功能。随机数生成的基础用法如下：

  • 生成标量或数组形式的随机数
  • 控制随机数的种子以实现可重复性
  • 从各种概率分布中生成随机数
  • 实现多维数组的随机生成和抽样

高级用法包括使用新的随机数生成器对象 numpy.random.Generator，从已有数组中抽样，或生成复杂概率分布下的随机数。

> Generator.integers

Generator.integers 是 NumPy 中 Generator 对象的一部分，用于生成指定范围内的随机整数。它是 NumPy 1.17 引入的新的随机数生成器 API 的一部分，相比旧的 numpy.random.randint，新 API 更加灵活和高效。

基础用法

函数签名：
Generator.integers(low, high=None, size=None, dtype=int, endpoint=False)
  • low：生成的随机整数的最小值（包含 low）。
  • high（可选）：生成的随机整数的最大值（不包含 high）。如果只指定 low，则生成范围为 [0, low)。
  • size（可选）：输出随机数的形状。默认为 None，即返回一个标量。如果指定为整数，则返回指定大小的数组。
  • dtype（可选）：输出数据的类型，默认为 int，可以为 int, np.int32, np.int64。
  • endpoint（可选）：如果为 True，则生成的随机整数包含 high，即 [low, high]，默认值为 False（不包含 high）。

示例用法

1. 生成单个随机整数
import numpy as np

# 创建一个默认的随机数生成器
rng = np.random.default_rng()

# 生成一个范围在 [0, 10) 之间的随机整数
print(rng.integers(10))  # 输出：例如 5
2. 生成指定范围的随机整数
# 生成一个范围在 [5, 15) 之间的随机整数
print(rng.integers(5, 15))  # 输出：例如 12
3. 生成多个随机整数（指定形状）
# 生成一个 3x3 的随机整数矩阵，范围在 [1, 10) 之间
print(rng.integers(1, 10, size=(3, 3)))  # 输出：
# [[6 2 4]
#  [3 7 9]
#  [2 5 1]]
4. 包含最大值 (endpoint=True)
# 生成一个包含最大值的随机整数，范围在 [1, 10] 之间（包含 10）
print(rng.integers(1, 10, endpoint=True))  # 输出：例如 10
5. 生成特定类型的随机整数

你可以通过 dtype 参数指定生成整数的类型，例如 32 位或 64 位整数。

# 生成一个 2x2 的随机整数数组，范围在 [0, 100) 之间，使用 64 位整数
print(rng.integers(0, 100, size=(2, 2), dtype=np.int64))  # 输出：
# [[95 22]
#  [68 47]]
6. 生成一维数组的随机整数
# 生成一个长度为 5 的一维随机整数数组，范围在 [1, 5) 之间
print(rng.integers(1, 5, size=5))  # 输出：例如 [2 3 1 4 2]

Generator.integers vs random.randint

  • Generator.integers 是新 API，推荐使用，并且更加灵活（如支持 endpoint=True）。
  • random.randint 是旧 API，功能较少，不支持包含区间的生成（endpoint=True）等高级特性。

总结

  • Generator.integers 用于生成随机整数，支持多种参数，范围可定制，输出形状灵活。
  • 可以通过设置 endpoint=True 来包含 high 值，或者使用 dtype 来指定生成整数的类型。

7、np.unique

numpy.unique(ar, return_index=False, 
return_inverse=False, 
return_counts=False, 
axis=None, *, equal_nan=True)

一维数组的情况

import numpy as np
rng = np.random.default_rng()

#生成一个随机的a数组
a = rng.integers(0, 20, size=10)
print(a,'\n')
#[12  7  8  8 12  6  2 15  3 13]


#打印数组中去掉重复项的所有元素（称作唯一元素）
print(np.unique(a),'\n')
#[ 2  3  6  7  8 12 13 15] 


#获取数组中唯一元素的索引
unique_elements, indices_list = np.unique(a,return_index = True)
print(indices_list)
print(unique_elements,'\n')
#[6 8 5 1 2 0 9 7]
#[ 2  3  6  7  8 12 13 15]


#获取数组中唯一值的个数
print(np.unique(a).size,'\n')#8


#获取数组中唯一项出现的次数
unique_elements, occurrence_count = np.unique(a,return_counts = True)
print(occurrence_count)
#[1 1 1 1 2 2 1 1]

二维数组的情况

a_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], 
                 [9, 10, 11, 12], [1, 2, 3, 4]])

#没有传递axis参数指定行列，则返回的是一个一维数组（自动展平多维）
unique_values = np.unique(a_2d)
print(unique_values,'\n')
#[ 1  2  3  4  5  6  7  8  9 10 11 12] 

# axis=0，则返回的是行，即返回的是二维数组；axis = 1，则返回的是列
unique_rows = np.unique(a_2d, axis=0)
print(unique_rows)
'''
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
'''

#要获取唯一行、索引位置和出现次数，可以使用：
unique_rows, indices, counts = np.unique(a_2d, axis = 0, return_index=True, return_counts=True)
print(unique_rows)
'''
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
 '''
print(indices)
#[0 1 2]
print(counts)
#[2 1 1]
100天精通Python丨基础知识篇 —— 01、C站最全Python标准库总结
独木不成林，单弦不成音。
06-29 51万+
❤粉丝福利：免费下载海量【PPT模板、简历模板、学习资料】https://app.yinxiang.com/fx/13ce6bbd-f36f-4e92-be53-92dd381ed729
《Numpy 简易速速上手小册》第1章：Numpy 基础（2024 最新版）
最新发布
江帅帅
01-30 965
在 Numpy 中，这些运算通常是元素级别的，意味着它们将对数组中的每个元素单独应用。从基础的数组操作到复杂的数据分析和图像处理，Numpy 都是处理和分析数据的有力工具。这个案例中，我们首先访问了特定的一天的股价，然后通过切片获取了一个时间段内的股价，最后使用了布尔索引来找出特定条件下的数据。数组可以有不同的维度：一维数组像列表，二维数组像矩阵，更高维度的数组在数据科学中也非常常见。在这个案例中，我们处理了一个二维数组，首先访问了特定学生的特定科目分数，然后通过切片获取了部分学生在两门科目上的分数。
numpy两类乘法，五种表达方式
condom10010的博客
06-26 423
矩阵乘法e=a@a#矩阵乘法。
AI算法（一） Numpy基础
m0_60964321的博客
07-25 578
机器学习中数据的处理往往影响着一个demo的好坏。例如图片、音频或者文本数据传入到神经网络中会被转化为Tensor类型，Tensor其实就是高维数组。Python中的Numpy包提供了一种便携处理矩阵数据的办法。Numpy操作在机器学习深度学习中很重要，一部分Tensor操作其实跟Numpy操作非常类似。机器所能识别的虽然是数字，但这些数字在机器的思想里可以代表我们现实中的一些物体。最后，有不懂的地方欢迎私信留言哦。...
矩阵乘法 点积 哈达玛积 线性代数 机器学习 numpy
qq_50974223的博客
01-30 2269
Multiplication 1.Hadamard product（哈达玛积) 形式： A * B 定义： a,b 都是 i x j 的同阶矩阵,设 c 是两者哈达玛积后的结果 c(i) = a(i) * b(i) e.g. a = np.array([1,2,3]),b = np.array([4,5,6]) c = a * b = [4,10,18](当然，输出的时候肯定看不到逗号) a’ = np.array([[1,2,3],[4,5,6]]),b’ =np.array([[1,-1,1],[6
Vue基础-列表渲染
多一点开心
10-15 448
列表渲染一、v-for二、方法三、举例 一、v-for 二、方法 当我们想要修改数组里面的内容的时候，不能直接通过下标的形式改变数组，但是通过vue提供的方法来操作数组能实现数据发生变化页面也跟着变这种效果 pop：删除数组最后一项 push：在数组最后添加一项 shift：删除数组最后一项 unshift：删除数组最后一项 splice：删除数组最后一项 sort：删除数组最后一项 reserve：删除数组最后一项 三、举例 push方法可以给数组添加数据并在页面显示 但如果直接通过数组下标的形式添加
向量和矩阵运算及Numpy中对应方法
博客简介
06-18 2079
向量的内积等价于a@b向量的外积向量元素对应位置相乘等价于a*b矩阵点乘np.multiply(a,b)等价于a*b矩阵叉乘等价于a@b。
pytorch深度学习笔记(二）Jupyter Notebook的使用和Numpy基础知识
焦哥的博客
11-16 1924
文章目录使用Jupyter NotebookNumpy基础知识 使用Jupyter Notebook Jupyter Notebook（此前也被称为IPython Notebook）是一个交互式笔记本，支持多种编程语言。在需要文本和代码结合的场景下进行交流时，它是一个不可多得的首选环境。 Jupyter是Anconda默认安装的部分之一。所以已经安装Anconda的话，就可以马上进入Jupyter Notebook了。打开终端输入如下命令： (base) C:\Users\Administrator&gt
Day1-IPython与Numpy.xmind
01-13
整理python数据分析库的重要知识，包括ipython、numpy、pandas（重要，包括3个文档）、scipy包、matplotlib图形绘制,共计7个文档，里面涵盖基础操作，案例解析和注意事项，如果下载文档的博友有问题可以随时咨询我，...
神经网络与深度学习day01-基础知识
ABU366的博客
08-29 511
深度学习第一周练习内容
Hadamard Product（哈达玛乘积）
sxl的博客
03-31 1万+
哈达玛乘积是机器学习中常用的一种矩阵计算操作。不同于传统矩阵相乘计算方式，它是对应矩阵元素相乘，的是两个相乘的矩阵必须行列数相同。在Pytorch中的具体操作是（详情点击）。当然，Numpy中也能计算就是*这个运算。具体的相乘细节看下面的图即可。
数学中几种积：点积(数量积/标量积/内积)、叉积(叉乘/向量积)、外积(张量积/Kronecker积)、哈达玛积(元素积)
rosefun96的博客
01-16 3万+
1 点积 点积（dot product)，又称数量积、标量积. 输入： 一种接受两个等长的数字序列（通常是坐标向量）； 输出： 返回单个数字。 在欧几里几何空间中，向量的点积运算又称为内积。 表示 代数定义 推广 矩阵的点积/内积，为对应矩阵元素的积之和。 A，B是定义为两个相同大小的矩阵。 值得注意的是，一些对于A，B大小不同，可以分别把它们组成的向量进行内积。 比如在numpy中： im...
辨析matmul product（一般矩阵乘积），hadamard product（哈达玛积）、kronecker product（克罗内克积）
热门推荐
yjk13703623757的博客
08-09 4万+
矩阵乘法1. dot product（一般矩阵乘积）m x p矩阵A与p x n矩阵B，那么称 m x n 矩阵C为矩阵A与矩阵B的一般乘积，记作C = AB ，其中矩阵C元素$ [cij]为矩阵A、B对应两两元素之和，表示为：例子：2. Hadamard product（哈达玛积）m x n矩阵A = [aij]与矩阵$B = [bij]的Hadamard积，记为A * B 。新矩阵元素定义为
python中哈达玛积与矩阵乘法的区别
prostarmoon的博客
12-26 7358
矩阵乘法是线性代数的基础运算，例如矩阵A是3*2，矩阵B是3*2   哈达玛积是两个m*n矩阵相乘 那么在python中，他们是怎样计算的呢？ 当矩阵是 numpy.ndarray 时，A *  B 表示哈达玛积 当矩阵是numpy.matrix是，A*B表示矩阵相乘，紧接着上面的代码 这个是需要注意的地方...
hadamard积 matlab_矩阵乘法在numpy/matlab/数学上的不同
weixin_39636898的博客
12-24 2948
数学意义上的矩阵乘法注意事项：1、当矩阵A的列数(column)等于矩阵B的行数(row)时，A与B可以相乘。2、矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。乘积-哈达马积(hadamard product)乘积-克罗内克乘积MatLab中的乘法()和点乘(.)a * b 是进行矩阵相乘， a.*b是a...
Pytorch中的哈达玛积(Hadamard product)与矩阵乘积(Matrix product)的区别
qq_17464457的博客
12-18 1万+
在Pytorch中tensor处理时我们经常会遇到矩阵之间的乘法运算，而对于不同的要求会有不同的计算方式，特别是Hadamard积与矩阵乘积之间的差别。 哈达玛积：对于两个举证或者数组A和B，A和B的维度至少是2，如果是二位数组，则AB两个数组相对应的维度的值必须相等，例如A为m*n的数组，仅当数组B满足维度为m*n时，A与B才能进行哈达玛积运算，具体计算方式如下： 代码示例： a =...
【ML学习笔记】5：机器学习中的数学基础5(张量,哈达玛积,生成子空间,超平面,范数)
大桔骑士的学习笔记
11-22 3875
向量/矩阵/张量向量向量可以表示成一维数组，每个分量可以理解为向量所表示的点在空间中坐标的分量。矩阵矩阵可以表示成二维数组，上节理解了矩阵可以理解为线性映射在特定基下的一种定量描述。张量张量可以表示成任意维的数组，张量是向量概念向更高阶次的推广，向量是一维张量。 但不能把矩阵简单的看成二维张量，张量是几何的，矩阵是代数的。二阶张量和矩阵概念不同，但可以建立联系，矩阵可以描述二阶张量的一些特性(在确
Numpy基础与数据分析入门教程
标题中提到的 "python学习Numpy基础, 数据分析 day07.zip" 指出了本文件包含了关于Python语言使用Numpy库进行数据分析和学习的第七天的材料。Numpy是一个广泛使用的Python库，专门用于进行高效的数值计算。它为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

想要好名字

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值