Numpy

Numpy：Python科学计算的基石

Numpy（Numerical Python）是Python中用于科学计算的核心库。它提供了一个强大的N维数组对象ndarray，以及用于处理这些数组的各种函数。Numpy是许多其他科学计算库（如Pandas、Scipy、Matplotlib）的基础，理解Numpy对于进行数据分析、机器学习和科学建模至关重要。

1. Ndarray：Numpy的核心数据结构

ndarray是Numpy的核心数据结构，它是一个多维同质数组。这意味着ndarray中的所有元素必须是相同的数据类型，例如整数、浮点数或复数。

1.1 创建Ndarray

Numpy提供了多种创建ndarray的方法：

• numpy.array(): 从Python列表或元组创建ndarray。

  import numpy as np
  # 从列表创建
  list_data = [1, 2, 3, 4, 5]
  array_from_list = np.array(list_data)
  print(array_from_list) # Output: [1 2 3 4 5]
  # 从元组创建
  tuple_data = (6, 7, 8, 9, 10)
  array_from_tuple = np.array(tuple_data)
  print(array_from_tuple) # Output: [ 6  7  8  9 10]
  ​

• numpy.zeros(): 创建一个指定形状和数据类型的数组，所有元素初始化为0。

  zero_array = np.zeros((2, 3))  # 创建一个2x3的零矩阵
  print(zero_array)
  # Output:
  # [[0. 0. 0.]
  #  [0. 0. 0.]]
  ​

• numpy.ones(): 创建一个指定形状和数据类型的数组，所有元素初始化为1。

  ones_array = np.ones((3, 2))  # 创建一个3x2的单位矩阵
  print(ones_array)
  # Output:
  # [[1. 1.]
  #  [1. 1.]
  #  [1. 1.]]
  ​

• numpy.empty(): 创建一个指定形状和数据类型的数组，但不对元素进行初始化（内容是内存中的现有值）。

  empty_array = np.empty((2, 2))
  print(empty_array)
  # Output: (内容不确定，取决于内存状态)
  ​

• numpy.arange(): 创建一个包含指定范围内值的数组，类似于Python的range()函数。

  arange_array = np.arange(0, 10, 2)  # 从0到10，步长为2
  print(arange_array) # Output: [0 2 4 6 8]
  ​

• numpy.linspace(): 创建一个包含指定数量的均匀间隔值的数组。

  linspace_array = np.linspace(0, 1, 5)  # 从0到1，包含5个均匀间隔的值
  print(linspace_array) # Output: [0.   0.25 0.5  0.75 1.  ]
  ​

1.2 Ndarray的属性

ndarray对象有许多重要的属性，用于描述数组的形状、数据类型和内存布局：

• ndarray.shape: 一个元组，表示数组的维度。

  arr = np.array([[1, 2, 3], [4, 5, 6]])
  print(arr.shape)  # Output: (2, 3)
  ​

• ndarray.ndim: 数组的维度数量。

  print(arr.ndim)  # Output: 2
  ​

• ndarray.dtype: 数组中元素的数据类型。

  print(arr.dtype)  # Output: int64 (或者其他整数类型，取决于系统)
  ​

• ndarray.size: 数组中元素的总数。

  print(arr.size)  # Output: 6
  ​

• ndarray.itemsize: 每个元素占用的字节数。

  print(arr.itemsize) # Output: 8 (如果是int64)
  ​

1.3 数据类型

Numpy支持多种数据类型，包括：

• int8, int16, int32, int64: 有符号整数

• uint8, uint16, uint32, uint64: 无符号整数

• float16, float32, float64: 浮点数

• complex64, complex128: 复数

• bool: 布尔值

• object: Python对象

可以在创建数组时指定数据类型：

float_array = np.array([1, 2, 3], dtype=np.float64)
print(float_array.dtype) # Output: float64
​

2. 数组操作

Numpy提供了丰富的数组操作函数，包括索引、切片、重塑、合并、分割等。

2.1 索引和切片

Numpy数组的索引和切片类似于Python列表，但更加强大。

arr = np.arange(10)
print(arr[0])    # Output: 0
print(arr[2:5])  # Output: [2 3 4]
print(arr[:5])   # Output: [0 1 2 3 4]
print(arr[5:])   # Output: [5 6 7 8 9]
print(arr[-1])   # Output: 9 (最后一个元素)
# 多维数组
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2d[0, 0])  # Output: 1
print(arr2d[1, :])  # Output: [4 5 6] (第二行)
print(arr2d[:, 2])  # Output: [3 6 9] (第三列)
​

2.2 重塑数组

numpy.reshape()函数用于改变数组的形状。

arr = np.arange(12)
reshaped_arr = arr.reshape(3, 4)  # 变为3x4的数组
print(reshaped_arr)
# Output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
​

2.3 合并数组

• numpy.concatenate(): 沿现有轴连接数组序列。

  arr1 = np.array([[1, 2], [3, 4]])
  arr2 = np.array([[5, 6], [7, 8]])
  concatenated_arr = np.concatenate((arr1, arr2), axis=0)  # 沿行连接
  print(concatenated_arr)
  # Output:
  # [[1 2]
  #  [3 4]
  #  [5 6]
  #  [7 8]]
  concatenated_arr = np.concatenate((arr1, arr2), axis=1)  # 沿列连接
  print(concatenated_arr)
  # Output:
  # [[1 2 5 6]
  #  [3 4 7 8]]
  ​

• numpy.stack(): 沿着新的轴连接数组序列。

  arr1 = np.array([1, 2, 3])
  arr2 = np.array([4, 5, 6])
  stacked_arr = np.stack((arr1, arr2), axis=0)  # 沿行堆叠
  print(stacked_arr)
  # Output:
  # [[1 2 3]
  #  [4 5 6]]
  stacked_arr = np.stack((arr1, arr2), axis=1)  # 沿列堆叠
  print(stacked_arr)
  # Output:
  # [[1 4]
  #  [2 5]
  #  [3 6]]
  ​

• numpy.hstack(): 水平堆叠数组（按列）。相当于 concatenate with axis=1。

• numpy.vstack(): 垂直堆叠数组（按行）。相当于 concatenate with axis=0。

2.4 分割数组

• numpy.split(): 将一个数组分割成多个子数组。

  arr = np.arange(9)
  split_arr = np.split(arr, 3)  # 分割成3个子数组
  print(split_arr) # Output: [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
  ​

• numpy.hsplit(): 水平分割数组（按列）。

• numpy.vsplit(): 垂直分割数组（按行）。

3. 数组运算

Numpy提供了大量的数学和统计函数，可以对数组进行各种运算。

3.1 元素级运算

这些运算直接应用于数组中的每个元素。

• 加法：+ 或 numpy.add()

• 减法：- 或 numpy.subtract()

• 乘法：* 或 numpy.multiply()

• 除法：/ 或 numpy.divide()

• 幂运算：** 或 numpy.power()

• 取余：% 或 numpy.mod()

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(arr1 + arr2)  # Output: [5 7 9]
print(arr1 * arr2)  # Output: [ 4 10 18]
print(arr1 ** 2)   # Output: [1 4 9]
​

3.2 矩阵运算

• numpy.dot(): 计算两个数组的点积。对于二维数组，它执行矩阵乘法。

  arr1 = np.array([[1, 2], [3, 4]])
  arr2 = np.array([[5, 6], [7, 8]])
  dot_product = np.dot(arr1, arr2)
  print(dot_product)
  # Output:
  # [[19 22]
  #  [43 50]]
  ​

• numpy.transpose(): 转置数组。

  arr = np.array([[1, 2, 3], [4, 5, 6]])
  transposed_arr = np.transpose(arr)
  print(transposed_arr)
  # Output:
  # [[1 4]
  #  [2 5]
  #  [3 6]]
  ​

3.3 统计函数

• numpy.mean(): 计算数组的平均值。

• numpy.median(): 计算数组的中位数。

• numpy.std(): 计算数组的标准差。

• numpy.var(): 计算数组的方差。

• numpy.sum(): 计算数组的总和。

• numpy.min(): 找到数组中的最小值。

• numpy.max(): 找到数组中的最大值。

• numpy.argmin(): 找到数组中最小值的索引。

• numpy.argmax(): 找到数组中最大值的索引。

arr = np.array([1, 2, 3, 4, 5])
print(np.mean(arr))  # Output: 3.0
print(np.sum(arr))   # Output: 15
print(np.max(arr))   # Output: 5
​

3.4 广播 (Broadcasting)

广播是 Numpy 的一个强大功能，它允许不同形状的数组进行算术运算。 Numpy 会自动扩展较小数组的形状，使其与较大数组兼容。

arr1 = np.array([1, 2, 3])
scalar = 2
print(arr1 + scalar)  # Output: [3 4 5]  (scalar被广播到与arr1相同的形状)
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = np.array([10, 20, 30])
print(arr2 + arr3)
# Output:
# [[11 22 33]
#  [14 25 36]] (arr3被广播到与arr2相同的形状)
​

广播规则：

1. 如果两个数组的维度数不同，则维度数较小的数组的形状将在其左侧填充 1，直到与另一个数组的维度数匹配。

2. 如果两个数组的形状在任何维度上不匹配，并且其中一个数组在该维度上的大小为 1，则该数组将沿该维度进行广播以匹配另一个数组的形状。

3. 如果在任何维度上，两个数组的形状都不匹配，并且两个数组在该维度上的大小都不为 1，则会引发错误。

4. 线性代数

Numpy 提供了 numpy.linalg 模块，用于执行各种线性代数操作。

• numpy.linalg.inv(): 计算矩阵的逆。

• numpy.linalg.det(): 计算矩阵的行列式。

• numpy.linalg.eig(): 计算矩阵的特征值和特征向量。

• numpy.linalg.solve(): 求解线性方程组。

import numpy.linalg as la
A = np.array([[1, 2], [3, 4]])
# 计算逆矩阵
A_inv = la.inv(A)
print(A_inv)
# Output:
# [[-2.   1. ]
#  [ 1.5 -0.5]]
# 计算行列式
det_A = la.det(A)
print(det_A) # Output: -2.0
# 求解线性方程组 Ax = b
b = np.array([5, 11])
x = la.solve(A, b)
print(x) # Output: [1. 2.]
​

5. 性能优势

Numpy 数组的性能优于 Python 列表，原因如下：

• 连续内存分配: Numpy 数组在内存中是连续存储的，这使得访问元素更快。

• 向量化操作: Numpy 的许多操作都是向量化的，这意味着它们可以一次性应用于整个数组，而无需使用循环。

• 底层实现: Numpy 的底层是用 C 语言编写的，这使得它比 Python 代码更快。

6. 代码示例及图示

示例：使用 Numpy 进行图像处理

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt  # 用于显示图像
# 1. 加载图像
image = Image.open("your_image.jpg")  # 替换为你的图像文件
image_array = np.array(image)
# 2. 查看图像数组的形状和数据类型
print("Image shape:", image_array.shape)
print("Image data type:", image_array.dtype)
# 3. 对图像进行一些处理 (例如，反色)
inverted_image_array = 255 - image_array  # 假设图像是 8-bit grayscale
# 4. 创建新的图像对象
inverted_image = Image.fromarray(inverted_image_array)
# 5. 显示原始图像和反色图像 (需要 matplotlib)
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.imshow(image_array)
plt.title("Original Image")
plt.axis('off')  # 关闭坐标轴
plt.subplot(1, 2, 2)
plt.imshow(inverted_image_array)
plt.title("Inverted Image")
plt.axis('off')
plt.show()
# 6. 保存反色图像
inverted_image.save("inverted_image.jpg")
​

图像处理流程图:

流程图解释：

1. 加载图像: 使用 PIL (Pillow) 库加载图像文件。

2. 转换为 Numpy 数组: 将图像数据转换为 Numpy 数组，以便进行数值计算。

3. 图像处理操作: 使用 Numpy 函数对图像数组进行各种处理，例如颜色反转、滤波、锐化等。

4. 转换为图像对象: 将处理后的 Numpy 数组转换回 PIL 图像对象，以便显示或保存。

5. 显示/保存图像: 使用 matplotlib 显示图像，或者使用 PIL 将图像保存到文件中。

7. 总结

Numpy 是 Python 科学计算的核心库，它提供了强大的 ndarray 对象和丰富的数组操作函数。 理解 Numpy 对于进行数据分析、机器学习和科学建模至关重要。 通过掌握 Numpy 的基本概念和操作，可以高效地处理和分析数据，并构建复杂的科学计算模型。 Numpy 的广播机制和底层 C 语言实现使其在性能方面具有显著优势。 结合其他科学计算库，Numpy 可以完成各种复杂的任务，例如图像处理、信号处理、数值模拟等。