【Numpy】基础命令

0. 地址：

官网地址：https://numpy.org/
菜鸟教程：https://www.runoob.com/numpy/numpy-array-manipulation.html

1. 什么是Numpy？

NumPy（Numerical Python）是Python科学计算的基础包，它提供了：
 - 快速高效的多维数组对象 ndarray
 - 用于对数组执行元素级计算以及直接对数组执行数学运算的函数
 - 用于读写硬盘上基于数组的数据集的工具
 - 线性代数运算、傅里叶变换，以及随机数生成
 - 用于将C、C++、Fortran代码集成到Python的工具

2. Numpy的特点

高效的数组运算：比纯Python代码快10-100倍
丰富的数学函数：支持大量的数学运算
广播功能：不同形状的数组之间的数学运算
底层语言实现：核心代码用C语言编写，执行效率高

3. Numpy 的环境准备

# 使用 pip 安装
pip install numpy

# 使用 conda 安装
conda install numpy

# 导入 Numpy
import numpy as np

4. 创建数组

（1）array()：自定义数组

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

（2）zeros()：全 0 数组

np.zeros((2,3))

（3）ones()：全 1 数组

np.ones((3,2))

（4）arange()：等差整数序列

np.arange(0,10,2) # 0,2,4,6,8
# 起始，结束，步长

（5）linspace()：均匀浮点序列

np.linspace(0,10,5)
# 起点 和 节点之间均分的 N 个点

（6）rand()：0~1均匀随机数

np.random.rand(2,3)

（7）randn()：标准正态随机数

np.random.randn(3,4)

5. 数组的属性

（1）ndim：维度数

import numpy as np
zeros_data = np.zeros((2,3))
zeros_data.ndim  # 2

（2）shape：形状（行数，列数）

import numpy as np
zeros_data = np.zeros((2,3))
zeros_data.shape # (2, 3)

（3）size()：元素总数

import numpy as np
zeros_data = np.zeros((2,3))
zeros_data.size # 6

（4）dtype()：数据类型

import numpy as np
zeros_data = np.zeros((2,3))
zeros_data.dtype # dtype('float64')

6. 数组索引和切片

（1）创建示例数组

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

（2）索引

# 获取第一行第二个元素
print(arr[0, 1])
# 获取最后一行
print(arr[-1])
# 获取第二列
print(arr[:, 1])
# 获取最后一列
print(arr[:, -1])

（3）切片

# 获取前两行
print(arr[0:2])
# 获取前两行，前两列
print(arr[0:2, 0:2])
# 每隔一个元素获取一个值  【注意】'::2'：代表'起始|结束|步长'；
print(arr[::2, ::2])   # 第一个'::2'代表行；第二个'::2'代表列

（4）布尔索引

print(arr > 5)

# [[False False False False]
# [False  True  True  True]
# [ True  True  True  True]]

7. 数组的形状

（1）reshape()

• reshape() 执行完，返回新形状数组。不改变原数组。

• reshape() 只允许符合：总元素数 = 行数 * 列数的形状改变。不满足的会报错

  • 如：总元素为6 只允许(1，6), (2，3), (3，2), (6，1); 不允许(2, 2)。

arrs = np.arange(0, 10)

# -- 正常输出
arrs = arrs.reshape(2, 5)
print(arrs, type(arrs))

# 输出结果
# [[0 1 2 3 4]
#  [5 6 7 8 9]] <class 'numpy.ndarray'>

# ----------------------------------------

# -- 异常输出
arrs.reshape(3, 3)
# 输出结果
ValueError: cannot reshape array of size 10 into shape (3,3)
# ----------------------------------------

（2）resize()

• resize() ：修改原数组，强制改大小和增减元素。

  • 若 arr = np.array([1,2,3,4,5,6]) ；arr.resize(2, 2) 只有四个元素。所以后续元素会被丢弃。
  • 若 arr = np.array([1,2,3,4,5,6]) ；arr.resize(2, 4) 有八个元素。元素不足自动补0。

import numpy as np

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

# resize：直接修改 arr，元素数量可以变
arr.resize(2, 2, refcheck=False)  # 改成 2行2列（只有4个元素）
print("(2, 2)修改后的原数组：\n", arr)

arr.resize(2, 4, refcheck=False)  # 改成 2行4列（有8个元素）
print("(2, 4)修改后的原数组：\n", arr)

# -- 输出结果
(2, 2)修改后的原数组：
 [[1 2]
 [3 4]]
(2, 4)修改后的原数组：
 [[1 2 3 4]
 [0 0 0 0]]

（3）.T：转置。行和列互换

• 不修改原数据元素和形状，只给出一个"转置视角"
• transpose() 函数 简写。

arr = np.array([[1,2,3,4,5],[4,5,6,7,8]])
print(arr.T)
print(arr)

# -- 输出结果
[[1 4]
 [2 5]
 [3 6]
 [4 7]
 [5 8]]
[[1 2 3 4 5]
 [4 5 6 7 8]]

（4）flatten()：展平数组

• 不修改元数据，返回一个全新的一维数组。

arr = np.array([[1,2,3,4,5],[4,5,6,7,8]])
print(arr.flatten())

# -- 输出结果
[1 2 3 4 5 4 5 6 7 8]

8. 数学运算

（1）算数运算

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

print("数组a:", a)
print("数组b:", b)

# 算术运算
print("加法:", a + b)
print("减法:", a - b)
print("乘法:", a * b)
print("除法:", a / b)
print("幂运算:", a ** 2)

（2）比较运算

# 比较运算
print("大于比较:", a > 2)
print("等于比较:", a == b)

（3）矩阵乘法

【注意】点乘运算的核心规则：

（1）相邻两个矩阵必须满足：前一个矩阵的列数 = 后一个矩阵的行数。

（2）点乘的最终形状：(第一个矩阵的行数, 最后一个矩阵的列数)

（3）示例：

• 两个矩阵：A (m, n)・B (n, p) → 条件：n == n → 形状：(m, p)

• 三个矩阵：A (m, n)・B (n, k)・C (k, p) → 条件：n==n，k==k → 形状：(m, p)

• 四个矩阵：A (m, n)・B (n, x)・C (x, y)・D (y, p) → 条件：n==n，x==x，y==y → 形状：(m, p)

# 矩阵乘法
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])
print("矩阵乘法:\n", np.dot(matrix_a, matrix_b))

9. 统计计算

• 方差：它是'各个数据与平均数之差的平方的平均数'。计算方差时，为了避免正负偏差相互抵消，会把每个数据与平均值的差进行平方，然后再求平均。

  • 特点：方差越大，说明数据越分散；方差越小，说明数据越集中
  • 缺点：因为经国平方处理，方差的单位变成原数据单位的平方（比如原数据是“米”，方差单位就是“平方米”）直观上数据差异变大。

• 标准差：它是方差的算数平方根。它的出现正是为了解决方差单位不一致的问题。

  • 特点：标准差的单位与元数据完全一致。因此，标准差比方差更容易出现在分析报告中。
  • 关系：标准差 = 方差 ** 2

import numpy as np

arr = np.array([[1, 2, 3], 
                [4, 5, 6], 
                [7, 8, 9]])

print("数组:\n", arr)
print("总和:", np.sum(arr))
print("每列总和:", np.sum(arr, axis=0))  # 沿列方向
print("每行总和:", np.sum(arr, axis=1))  # 沿行方向

print("平均值:", np.mean(arr))
print("标准差:", np.std(arr))
print("方差:", np.var(arr))

print("最小值:", np.min(arr))
print("最大值:", np.max(arr))
print("最小值索引:", np.argmin(arr))
print("最大值索引:", np.argmax(arr))

10. Numpy广播机制

• 广播原理：小数组自动“复制扩展” 成和大数组合法形状，再逐元素计算
• 加法、乘法逻辑完全一样。只是运算符不同。

import numpy as np

# 广播示例
a = np.array([[1, 2, 3], 
              [4, 5, 6], 
              [7, 8, 9]])

b = np.array([10, 20, 30])

print("数组a:\n", a)
print("数组b:", b)
print("广播加法:\n", a + b)  # b被广播到a的每一行

# 另一个广播例子
c = np.array([[1], [2], [3]])
print("数组c:\n", c)
print("广播乘法:\n", a * c)  # c被广播到a的每一列

计算过程：

（1）a + b （行广播）

a 形状 (3,3)
[[1,2,3],
 [4,5,6],
 [7,8,9]]

b 形状 (3,) → [10,20,30]

广播逻辑：

• b会自动复制3行，变成和 a 一样的形状

[[10,20,30],
[10,20,30],
[10,20,30]]

• 然后逐元素增加。

1+10 2+20 3+30
4+10 5+20 6+30
7+10 8+20 9+30

• 最终结果

[[11,22,33],
[14,25,36],
[17,28,39]]

（2）a * b（列广播）

a 形状 (3,3)
[[1,2,3],
 [4,5,6],
 [7,8,9]]

c 形状 (3,1) → 一列
[[1],
 [2],
 [3]]

广播逻辑：

• C会自动复制3列，变成

[[1,1,1],
[2,2,2],
[3,3,3]]

• 然后逐元素相乘

1×1 2×1 3×1
4×2 5×2 6×2
7×3 8×3 9×3

• 最终结果

[[1, 2, 3],
[8,10,12],
[21,24,27]]