numpy 模块

NumPy说明

NumPy（Numerical Python）是 Python 科学计算的核心库。

NumPy 基础

安装与导入

# 安装
pip install numpy

# 标准导入方式
import numpy as np
print(f"NumPy 版本: {np.__version__}")

创建数组的 10 种方法

import numpy as np

# 1. 从 Python 列表创建
arr1 = np.array([1, 2, 3, 4, 5])
print(f"1. 从列表创建: {arr1}")
# 从列表创建: [1 2 3 4 5]

# 2. 从元组创建
arr2 = np.array((1.5, 2.5, 3.5))
print(f"2. 从元组创建: {arr2}")
# 从元组创建: [1.5 2.5 3.5]

# 3. 创建全零数组
zeros = np.zeros(5)
print(f"3. 全零数组: {zeros}")
# 全零数组: [0. 0. 0. 0. 0.]

# 4. 创建全一数组
ones = np.ones((3, 4))  # 3行4列
print(f"4. 全一数组:\n{ones}")
# [[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]]

# 5. 创建单位矩阵
eye = np.eye(3)  # 3×3单位矩阵
print(f"5. 单位矩阵:\n{eye}")
# [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

# 6. 创建等差数列
lin = np.linspace(0, 10, 5)  # 从0到10，5个等间距点
print(f"6. 等差数列: {lin}")
# 等差数列: [ 0. 2.5  5. 7.5 10. ]

# 7. 创建等间隔数组
arange = np.arange(0, 10, 2)  # 从0到10，步长为2
print(f"7. 等间隔数组: {arange}")
# 等间隔数组: [0 2 4 6 8]

# 8. 创建随机数组
rand = np.random.rand(3, 3)  # 3×3的[0,1)均匀分布
print(f"8. 随机数组:\n{rand}")
# 随机数组: [[0.57980982 0.16965838 0.26229211] [0.44653552 0.17974408 0.43776795] [0.58904302 0.60921252 0.01472058]]

# 9. 创建空数组（未初始化，值随机）
empty = np.empty((2, 3))
print(f"9. 空数组:\n{empty}")
# 空数组: [[6.93704801e-310 0.00000000e+000 6.93772010e-310] [1.98483372e-263 2.93192686e-315 4.23406404e-307]]

# 10. 创建全值数组
full = np.full((2, 2), 7)  # 2×2全为7
print(f"10. 全值数组:\n{full}")
# 全值数组: [[7 7] [7 7]]

# 11. 从字符串创建
arr_str = np.array('1 2 3 4 5'.split(), dtype=int)
print(f"11. 从字符串创建: {arr_str}")
# 从字符串创建: [1 2 3 4 5]

# 12. 从函数创建
def func(i, j):
    return i + j

arr_func = np.fromfunction(func, (3, 3))
print(f"12. 从函数创建:\n{arr_func}")
# 从函数创建: [[0. 1. 2.] [1. 2. 3.] [2. 3. 4.]]

数组属性和数据类型

数组属性详解

# 创建一个示例数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print("数组属性:")
print("="*50)

# 基本属性
print(f"1. 数组维度 (ndim): {arr.ndim}")  # 数组维度 (ndim): 2
print(f"2. 数组形状 (shape): {arr.shape}") # 数组形状 (shape): (3, 3)
print(f"3. 数组大小 (size): {arr.size}")  # 数组大小 (size): 9
print(f"4. 数据类型 (dtype): {arr.dtype}") # 数据类型 (dtype): int64
print(f"5. 每个元素字节数 (itemsize): {arr.itemsize} bytes") # 每个元素字节数 (itemsize): 8 bytes
print(f"6. 总字节数 (nbytes): {arr.nbytes} bytes") # 总字节数 (nbytes): 72 bytes
print(f"7. 转置 (T):\n{arr.T}") # 转置 (T): [[1 4 7] [2 5 8] [3 6 9]]
print(f"8. 实部 (real):\n{arr.real}") # 实部 (real):[[1 2 3] [4 5 6] [7 8 9]]
print(f"9. 虚部 (imag):\n{arr.imag}") # 虚部 (imag):[[0 0 0] [0 0 0] [0 0 0]]

# 复数数组示例
complex_arr = np.array([1+2j, 3+4j, 5+6j])
print(f"10. 复数数组实部: {complex_arr.real}")  # 复数数组实部: [1. 3. 5.]
print(f"11. 复数数组虚部: {complex_arr.imag}")  # 复数数组虚部: [2. 4. 6.]

# 扁平迭代器
print(f"12. 扁平迭代器 (flat):")  # 扁平迭代器 (flat):  
for item in arr.flat:
    print(f"  {item}", end=" ") # 1   2   3   4   5   6   7   8   9
print()

# 数据指针
print(f"13. 数据指针 (data): {arr.data}") # 数据指针 (data): <memory at 0x0000024A1DA6A9B0>

数据类型 (dtype) 详解

# NumPy 支持的数据类型
dtypes = {
    '整数': {
        'int8': '8位整数 (-128 to 127)',
        'int16': '16位整数 (-32768 to 32767)',
        'int32': '32位整数 (-2147483648 to 2147483647)',
        'int64': '64位整数',
        'uint8': '8位无符号整数 (0 to 255)',
        'uint16': '16位无符号整数 (0 to 65535)',
        'uint32': '32位无符号整数 (0 to 4294967295)',
        'uint64': '64位无符号整数',
    },
    '浮点数': {
        'float16': '半精度浮点',
        'float32': '单精度浮点',
        'float64': '双精度浮点',
        'float128': '扩展精度浮点',
    },
    '复数': {
        'complex64': '复数，两个32位浮点',
        'complex128': '复数，两个64位浮点',
        'complex256': '复数，两个128位浮点',
    },
    '其他': {
        'bool': '布尔型 (True/False)',
        'object': 'Python对象',
        'string_': '字符串',
        'unicode_': 'Unicode字符串',
    }
}

print("NumPy 数据类型:")
print("="*50)
for category, types in dtypes.items():
    print(f"\n{category}:")
    for dtype_name, description in types.items():
        print(f"  {dtype_name:<12} - {description}")

# 数据类型示例
print("\n数据类型示例:")
print("="*50)

# 创建不同数据类型的数组
examples = [
    ("int8", np.array([1, 2, 3], dtype=np.int8)),
    ("uint8", np.array([1, 2, 3], dtype=np.uint8)),
    ("int16", np.array([1000, 2000, 3000], dtype=np.int16)),
    ("float32", np.array([1.1, 2.2, 3.3], dtype=np.float32)),
    ("float64", np.array([1.1, 2.2, 3.3], dtype=np.float64)),
    ("complex64", np.array([1+2j, 3+4j], dtype=np.complex64)),
    ("bool", np.array([True, False, True], dtype=bool)),
    ("string", np.array(['a', 'bc', 'def'], dtype='S3')),  # 最大长度3字节
]

for dtype_name, arr in examples:
    print(f"{dtype_name:<10}: {arr} (dtype: {arr.dtype})")

# 数据类型转换
print("\n数据类型转换:")
print("="*50)

arr_int = np.array([1, 2, 3, 4])
print(f"原始数组: {arr_int}, dtype: {arr_int.dtype}")

# 转换方法1: astype()
arr_float = arr_int.astype(np.float32)
print(f"转换为float32: {arr_float}, dtype: {arr_float.dtype}")

# 转换方法2: np.asarray()
arr_complex = np.asarray(arr_int, dtype=np.complex64)
print(f"转换为complex64: {arr_complex}, dtype: {arr_complex.dtype}")

# 转换方法3: 视图 (view)
if arr_int.dtype == np.int32:
    arr_view = arr_int.view(np.float32)
    print(f"视图转换: {arr_view}, dtype: {arr_view.dtype}")

# 检查类型
print(f"\n类型检查:")
print(f"  np.issubdtype(arr_int.dtype, np.integer): {np.issubdtype(arr_int.dtype, np.integer)}")
print(f"  np.issubdtype(arr_float.dtype, np.floating): {np.issubdtype(arr_float.dtype, np.floating)}")
print(f"  np.issubdtype(arr_complex.dtype, np.complexfloating): {np.issubdtype(arr_complex.dtype, np.complexfloating)}")

NumPy 数据类型:
==================================================

整数:
  int8         - 8位整数 (-128 to 127)
  int16        - 16位整数 (-32768 to 32767)
  int32        - 32位整数 (-2147483648 to 2147483647)
  int64        - 64位整数
  uint8        - 8位无符号整数 (0 to 255)
  uint16       - 16位无符号整数 (0 to 65535)
  uint32       - 32位无符号整数 (0 to 4294967295)
  uint64       - 64位无符号整数

浮点数:
  float16      - 半精度浮点
  float32      - 单精度浮点
  float64      - 双精度浮点
  float128     - 扩展精度浮点

复数:
  complex64    - 复数，两个32位浮点
  complex128   - 复数，两个64位浮点
  complex256   - 复数，两个128位浮点

其他:
  bool         - 布尔型 (True/False)
  object       - Python对象
  string_      - 字符串
  unicode_     - Unicode字符串

数据类型示例:
==================================================
int8      : [1 2 3] (dtype: int8)
uint8     : [1 2 3] (dtype: uint8)
int16     : [1000 2000 3000] (dtype: int16)
float32   : [1.1 2.2 3.3] (dtype: float32)
float64   : [1.1 2.2 3.3] (dtype: float64)
complex64 : [1.+2.j 3.+4.j] (dtype: complex64)
bool      : [ True False  True] (dtype: bool)
string    : [b'a' b'bc' b'def'] (dtype: |S3)

数据类型转换:
==================================================
原始数组: [1 2 3 4], dtype: int64
转换为float32: [1. 2. 3. 4.], dtype: float32
转换为complex64: [1.+0.j 2.+0.j 3.+0.j 4.+0.j], dtype: complex64

类型检查:
  np.issubdtype(arr_int.dtype, np.integer): True
  np.issubdtype(arr_float.dtype, np.floating): True
  np.issubdtype(arr_complex.dtype, np.complexfloating): True

数组索引和切片

一维数组索引

# 创建一维数组
arr = np.arange(10, 20)
print(f"原始数组: {arr}")  
# 原始数组: [10 11 12 13 14 15 16 17 18 19]

print("\n一维数组索引:")
print("="*50)

# 基本索引
print(f"1. 单个索引 arr[3]: {arr[3]}")  # 单个索引 arr[3]: 13
print(f"2. 负索引 arr[-1]: {arr[-1]}")  # 负索引 arr[-1]: 19
print(f"3. 负索引 arr[-2]: {arr[-2]}")  # 负索引 arr[-2]: 18

# 切片
print(f"\n切片操作:")
print(f"4. arr[2:6]: {arr[2:6]}")      # 索引2到5 arr[2:6]: [12 13 14 15]
print(f"5. arr[:5]: {arr[:5]}")        # 前5个元素 arr[:5]: [10 11 12 13 14]
print(f"6. arr[5:]: {arr[5:]}")        # 从索引5开始 arr[5:]: [15 16 17 18 19]
print(f"7. arr[::2]: {arr[::2]}")      # 步长为2 arr[::2]: [10 12 14 16 18]
print(f"8. arr[::-1]: {arr[::-1]}")    # 反转数组 arr[::-1]: [19 18 17 16 15 14 13 12 11 10]
print(f"9. arr[1:8:3]: {arr[1:8:3]}")  # 从索引1到7，步长为3 arr[1:8:3]: [11 14 17]

二维数组索引

# 创建二维数组
arr_2d = np.array([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12]])

print("二维数组:")
print(arr_2d)
print(f"形状: {arr_2d.shape}")

print("\n二维数组索引:")
print("="*50)

# 行索引
print(f"1. 单行 arr_2d[1]: {arr_2d[1]}")          # 第二行 单行 arr_2d[1]: [5 6 7 8]
print(f"2. 多行 arr_2d[[0, 2]]:\n{arr_2d[[0, 2]]}")  # 第一和第三行  多行 arr_2d[[0, 2]]:[[ 1  2  3  4] [ 9 10 11 12]]

# 列索引
print(f"3. 单列 arr_2d[:, 2]: {arr_2d[:, 2]}")    # 第三列 单列 arr_2d[:, 2]: [ 3  7 11]
print(f"4. 多列 arr_2d[:, [0, 3]]:\n{arr_2d[:, [0, 3]]}")  # 第一和第四列 多列 arr_2d[:, [0, 3]]:[[ 1  4] [ 5  8] [ 9 12]]

# 行列组合索引
print(f"5. 单个元素 arr_2d[1, 2]: {arr_2d[1, 2]}")  # 第二行第三列 单个元素 arr_2d[1, 2]: 7
print(f"6. 多个元素 arr_2d[[0, 2], [1, 3]]: {arr_2d[[0, 2], [1, 3]]}")  # [ 2 12] , [0, 2]代表行索引、[1, 3]列索引 == (0,1)和(2,3)
 
# 布尔索引
print(f"\n布尔索引:")
bool_mask = arr_2d > 5
print(f"7. 布尔掩码:\n{bool_mask}")  # 布尔掩码:[[False False False False] [False  True  True  True] [ True  True  True  True]]
print(f"8. 布尔索引结果: {arr_2d[bool_mask]}") # 布尔索引结果: [ 6  7  8  9 10 11 12]

# 条件索引
print(f"9. 条件索引 arr_2d[arr_2d > 7]: {arr_2d[arr_2d > 7]}")  # 条件索引 arr_2d[arr_2d > 7]: [ 8  9 10 11 12]
print(f"10. 多条件索引 arr_2d[(arr_2d > 3) & (arr_2d < 9)]: {arr_2d[(arr_2d > 3) & (arr_2d < 9)]}") # 多条件索引 arr_2d[(arr_2d > 3) & (arr_2d < 9)]: [4 5 6 7 8]

三维数组索引

# 创建三维数组
arr_3d = np.array([[[1, 2, 3],
                    [4, 5, 6]],
                   
                   [[7, 8, 9],
                    [10, 11, 12]],
                   
                   [[13, 14, 15],
                    [16, 17, 18]]])

print("三维数组形状:", arr_3d.shape)  # (3, 2, 3)
print("\n三维数组:")
print(arr_3d)

print("\n三维数组索引:")
print("="*50)

# 各维度索引
print(f"1. 第一个二维数组 arr_3d[0]:\n{arr_3d[0]}") # 第一个二维数组 arr_3d[0]: [[1 2 3] [4 5 6]]
print(f"2. 第一个二维数组的第一行 arr_3d[0, 0]: {arr_3d[0, 0]}") #  第一个二维数组的第一行 arr_3d[0, 0]: [1 2 3]
print(f"3. 第一个二维数组的第一行第一列 arr_3d[0, 0, 0]: {arr_3d[0, 0, 0]}") # 第一个二维数组的第一行第一列 arr_3d[0, 0, 0]: 1
print(f"4. 所有二维数组的第一行 arr_3d[:, 0]:\n{arr_3d[:, 0]}") # 所有二维数组的第一行 arr_3d[:, 0]: [[ 1  2  3] [ 7  8  9] [13 14 15]]
print(f"5. 所有二维数组的第一行第一列 arr_3d[:, 0, 0]: {arr_3d[:, 0, 0]}") # 所有二维数组的第一行第一列 arr_3d[:, 0, 0]: [ 1  7 13]

# 切片
print(f"\n切片操作:")
print(f"6. 前两个二维数组 arr_3d[:2]:\n{arr_3d[:2]}") # 前两个二维数组 arr_3d[:2]:[[[ 1  2  3]  [ 4  5  6]] [[ 7  8  9]  [10 11 12]]]
print(f"7. 所有二维数组的奇数行 arr_3d[:, ::2]:\n{arr_3d[:, ::2]}") # 所有二维数组的奇数行 arr_3d[:, ::2]:[[[ 1  2  3]] [[ 7  8  9]] [[13 14 15]]]
print(f"8. 所有二维数组的奇数列 arr_3d[..., ::2]:\n{arr_3d[..., ::2]}") # 所有二维数组的奇数列 arr_3d[..., ::2]:[[[ 1  3]  [ 4  6]] [[ 7  9]  [10 12]] [[13 15]  [16 18]]]

数组形状操作 

改变数组形状

# 创建数组
arr = np.arange(12)
print(f"原始数组: {arr}")  # 原始数组: [ 0  1  2  3  4  5  6  7  8  9 10 11] 
print(f"原始形状: {arr.shape}") # 原始形状: (12,)

print("\n改变数组形状:")
print("="*50)

# reshape
reshaped = arr.reshape(3, 4)
print(f"1. reshape(3, 4):\n{reshaped}") # reshape(3, 4):[[ 0  1  2  3] [ 4  5  6  7] [ 8  9 10 11]]

# resize (会改变原数组)
arr_resized = arr.copy()
arr_resized.resize(2, 6)
print(f"2. resize(2, 6):\n{arr_resized}") # resize(2, 6):[[ 0  1  2  3  4  5] [ 6  7  8  9 10 11]]

# flatten (返回扁平副本)
flattened = arr.flatten()
print(f"3. flatten(): {flattened}") # flatten(): [ 0  1  2  3  4  5  6  7  8  9 10 11]

# ravel (返回扁平视图)
raveled = arr.ravel()
print(f"4. ravel(): {raveled}") # ravel(): [ 0  1  2  3  4  5  6  7  8  9 10 11]

# 转置
transposed = reshaped.T
print(f"5. 转置:\n{transposed}") # 转置: [[ 0  4  8] [ 1  5  9] [ 2  6 10] [ 3  7 11]]

# 交换轴
arr_3d = np.arange(24).reshape(2, 3, 4)
print(f"6. 原始3D数组形状: {arr_3d.shape}") # 原始3D数组形状: (2, 3, 4)   
swapped = np.swapaxes(arr_3d, 0, 2)
print(f"   交换轴(0,2)后形状: {swapped.shape}") # 交换轴(0,2)后形状: (4, 3, 2)

# 移动轴
moved = np.moveaxis(arr_3d, 0, -1)
print(f"7. 移动轴(0到-1)后形状: {moved.shape}") # 移动轴(0到-1)后形状: (3, 4, 2)

数组堆叠

# 创建示例数组
a = np.array([[1, 2],
              [3, 4]])

b = np.array([[5, 6],
              [7, 8]])

print("数组a:")
print(a)
print("\n数组b:")
print(b)

print("\n数组堆叠操作:")
print("="*50)

# 垂直堆叠
vstack = np.vstack((a, b))
print(f"1. vstack (垂直堆叠):\n{vstack}") # vstack (垂直堆叠):[[1 2] [3 4] [5 6] [7 8]]

# 水平堆叠
hstack = np.hstack((a, b))
print(f"2. hstack (水平堆叠):\n{hstack}") # hstack (水平堆叠):[[1 2 5 6] [3 4 7 8]]

# 深度堆叠
dstack = np.dstack((a, b))
print(f"3. dstack (深度堆叠):\n{dstack}") # dstack (深度堆叠):[[[1 5]  [2 6]] [[3 7]  [4 8]]]

# 列堆叠
column_stack = np.column_stack((a.ravel(), b.ravel()))
print(f"4. column_stack:\n{column_stack}") # column_stack:[[1 5] [2 6] [3 7] [4 8]]

# 行堆叠
row_stack = np.row_stack((a.ravel(), b.ravel()))
print(f"5. row_stack:\n{row_stack}") # row_stack:[[1 2 3 4] [5 6 7 8]]

# concatenate
concatenate_axis0 = np.concatenate((a, b), axis=0)
print(f"6. concatenate axis=0:\n{concatenate_axis0}") # concatenate axis=0:[[1 2] [3 4] [5 6] [7 8]]

concatenate_axis1 = np.concatenate((a, b), axis=1)
print(f"7. concatenate axis=1:\n{concatenate_axis1}") # concatenate axis=1:[[1 2 5 6] [3 4 7 8]]

数组运算

算术运算

# 创建数组
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

print("数组运算:")
print("="*50)

# 基本运算
print(f"数组a: {a}")
print(f"数组b: {b}")

print(f"\n1. 加法 a + b: {a + b}") # 加法 a + b: [ 6  8 10 12]
print(f"2. 减法 a - b: {a - b}")  # a - b: [-4 -4 -4 -4]
print(f"3. 乘法 a * b: {a * b}")  # 乘法 a * b: [ 5 12 21 32]
print(f"4. 除法 a / b: {a / b}")  # 除法 a / b: [0.2        0.33333333 0.42857143 0.5       ]
print(f"5. 整除 a // b: {a // b}") # 整除 a // b: [0 0 0 0]
print(f"6. 取余 a % b: {a % b}") # 取余 a % b: [1 2 3 4]
print(f"7. 幂运算 a ** 2: {a ** 2}") # 幂运算 a ** 2: [ 1  4  9 16]
print(f"8. 平方根 √a: {np.sqrt(a)}") # 平方根 √a: [1.         1.41421356 1.73205081 2.        ]
print(f"9. 指数 e^a: {np.exp(a)}") # 指数 e^a: [ 2.71828183  7.3890561  20.08553692 54.59815003]
print(f"10. 对数 log(a): {np.log(a)}") # 对数 log(a): [0.         0.69314718 1.09861229 1.38629436]

# 广播运算
print(f"\n广播运算:")
print(f"11. 标量加法 a + 10: {a + 10}") # 标量加法 a + 10: [11 12 13 14]
print(f"12. 标量乘法 a * 2: {a * 2}") # 标量乘法 a * 2: [2 4 6 8]

统计运算

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

print("统计运算:")
print("="*50)
print(f"数组:\n{arr}")

# 基本统计
print(f"\n1. 总和 np.sum(arr): {np.sum(arr)}") # 总和 np.sum(arr): 78
print(f"2. 均值 np.mean(arr): {np.mean(arr)}") # 均值 np.mean(arr): 6.5
print(f"3. 标准差 np.std(arr): {np.std(arr)}") # 标准差 np.std(arr): 3.452052529534663
print(f"4. 方差 np.var(arr): {np.var(arr)}") # 方差 np.var(arr): 11.916666666666666
print(f"5. 最小值 np.min(arr): {np.min(arr)}") # 最小值 np.min(arr): 1
print(f"6. 最大值 np.max(arr): {np.max(arr)}") # 最大值 np.max(arr): 12
print(f"7. 中位数 np.median(arr): {np.median(arr)}") # 中位数 np.median(arr): 6.5
print(f"8. 百分位数 np.percentile(arr, 75): {np.percentile(arr, 75)}") # 百分位数 np.percentile(arr, 75): 9.25

# 沿轴统计
print(f"\n沿轴统计:")
print(f"9. 每行和 np.sum(arr, axis=1): {np.sum(arr, axis=1)}") # 每行和 np.sum(arr, axis=1): [10 26 42]
print(f"10. 每列和 np.sum(arr, axis=0): {np.sum(arr, axis=0)}") # 每列和 np.sum(arr, axis=0): [15 18 21 24]
print(f"11. 每行均值 np.mean(arr, axis=1): {np.mean(arr, axis=1)}") # 每行均值 np.mean(arr, axis=1): [ 2.5  6.5 10.5]
print(f"12. 每列均值 np.mean(arr, axis=0): {np.mean(arr, axis=0)}") # 每列均值 np.mean(arr, axis=0): [5. 6. 7. 8.]

# 累积运算
print(f"\n累积运算:")
print(f"13. 累积和 np.cumsum(arr): {np.cumsum(arr)}") # 累积和 np.cumsum(arr): [ 1  3  6 10 15 21 28 36 45 55 66 78]
print(f"14. 累积积 np.cumprod(arr): {np.cumprod(arr)}") # 累积积 np.cumprod(arr): [ 1  2  6  24 120 720  5040 40320    362880   3628800  39916800 479001600]

# 最值索引
print(f"\n最值索引:")
print(f"15. 最大值索引 np.argmax(arr): {np.argmax(arr)}") # 最大值索引 np.argmax(arr): 11
print(f"16. 最小值索引 np.argmin(arr): {np.argmin(arr)}") # 最小值索引 np.argmin(arr): 0
print(f"17. 每行最大值索引 np.argmax(arr, axis=1): {np.argmax(arr, axis=1)}") # 每行最大值索引 np.argmax(arr, axis=1): [3 3 3]

逻辑运算

# 创建数组
a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 4, 3, 2, 1])

print("逻辑运算:")
print("="*50)
print(f"数组a: {a}")
print(f"数组b: {b}")

# 比较运算
print(f"\n比较运算:")
print(f"1. 大于 a > 3: {a > 3}")
print(f"2. 小于 a < 3: {a < 3}")
print(f"3. 等于 a == 3: {a == 3}")
print(f"4. 不等于 a != 3: {a != 3}")
print(f"5. 大于等于 a >= 3: {a >= 3}")
print(f"6. 小于等于 a <= 3: {a <= 3}")
print(f"7. 数组比较 a > b: {a > b}")

# 逻辑运算
print(f"\n逻辑运算:")
mask1 = a > 2
mask2 = b < 4
print(f"8. 掩码1 (a>2): {mask1}")
print(f"9. 掩码2 (b<4): {mask2}")
print(f"10. 逻辑与 np.logical_and(mask1, mask2): {np.logical_and(mask1, mask2)}")
print(f"11. 逻辑或 np.logical_or(mask1, mask2): {np.logical_or(mask1, mask2)}")
print(f"12. 逻辑非 np.logical_not(mask1): {np.logical_not(mask1)}")
print(f"13. 异或 np.logical_xor(mask1, mask2): {np.logical_xor(mask1, mask2)}")

# 条件判断
print(f"\n条件判断:")
print(f"14. 是否全为真 np.all(a > 0): {np.all(a > 0)}")
print(f"15. 是否有真 np.any(a > 4): {np.any(a > 4)}")
print(f"16. 是否包含 np.isin(a, [2, 4]): {np.isin(a, [2, 4])}")

逻辑运算:
==================================================
数组a: [1 2 3 4 5]
数组b: [5 4 3 2 1]

比较运算:
1. 大于 a > 3: [False False False  True  True]
2. 小于 a < 3: [ True  True False False False]
3. 等于 a == 3: [False False  True False False]
4. 不等于 a != 3: [ True  True False  True  True]
5. 大于等于 a >= 3: [False False  True  True  True]
6. 小于等于 a <= 3: [ True  True  True False False]
7. 数组比较 a > b: [False False False  True  True]

逻辑运算:
8. 掩码1 (a>2): [False False  True  True  True]
9. 掩码2 (b<4): [False False  True  True  True]
10. 逻辑与 np.logical_and(mask1, mask2): [False False  True  True  True]
11. 逻辑或 np.logical_or(mask1, mask2): [False False  True  True  True]
12. 逻辑非 np.logical_not(mask1): [ True  True False False False]
13. 异或 np.logical_xor(mask1, mask2): [False False False False False]

条件判断:
14. 是否全为真 np.all(a > 0): True
15. 是否有真 np.any(a > 4): True
16. 是否包含 np.isin(a, [2, 4]): [False  True False  True False]

线性代数运算

矩阵运算

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

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

v = np.array([1, 2, 3])

print("线性代数运算:")
print("="*50)
print(f"矩阵A:\n{A}")
print(f"\n矩阵B:\n{B}")
print(f"\n向量v: {v}")

# 矩阵乘法
print(f"\n矩阵运算:")
print(f"1. 矩阵乘法 A @ B:\n{A @ B}")
print(f"2. 矩阵向量乘法 A @ v: {A @ v}")

# 转置
print(f"3. 矩阵转置 A.T:\n{A.T}")

# 逆矩阵
C = np.array([[4, 7],
              [2, 6]])
try:
    inv_C = np.linalg.inv(C)
    print(f"4. 逆矩阵 inv(C):\n{inv_C}")
except np.linalg.LinAlgError:
    print(f"4. 矩阵C不可逆")

# 行列式
det_A = np.linalg.det(A)
print(f"5. 行列式 det(A): {det_A}")

# 特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)
print(f"6. 特征值: {eigenvalues}")
print(f"7. 特征向量:\n{eigenvectors}")

# 矩阵秩
rank_A = np.linalg.matrix_rank(A)
print(f"8. 矩阵秩 rank(A): {rank_A}")

# 矩阵的迹
trace_A = np.trace(A)
print(f"9. 矩阵迹 trace(A): {trace_A}")

# 解线性方程组
# Ax = b
b = np.array([1, 2, 3])
try:
    x = np.linalg.solve(A, b)
    print(f"10. 解方程 Ax = b: {x}")
except np.linalg.LinAlgError:
    print("10. 矩阵A奇异，无法求解")
    # 使用最小二乘法
    x_lstsq = np.linalg.lstsq(A, b, rcond=None)[0]
    print(f"   最小二乘解: {x_lstsq}")

# 范数
print(f"\n范数:")
print(f"11. 向量v的L2范数: {np.linalg.norm(v)}")
print(f"12. 向量v的L1范数: {np.linalg.norm(v, ord=1)}")
print(f"13. 矩阵A的Frobenius范数: {np.linalg.norm(A, 'fro')}")

线性代数运算:
==================================================
矩阵A:
[[1 2 3]
 [4 5 6]
 [7 8 9]]

矩阵B:
[[9 8 7]
 [6 5 4]
 [3 2 1]]

向量v: [1 2 3]

矩阵运算:
1. 矩阵乘法 A @ B:
[[ 30  24  18]
 [ 84  69  54]
 [138 114  90]]
2. 矩阵向量乘法 A @ v: [14 32 50]
3. 矩阵转置 A.T:
[[1 4 7]
 [2 5 8]
 [3 6 9]]
4. 逆矩阵 inv(C):
[[ 0.6 -0.7]
 [-0.2  0.4]]
5. 行列式 det(A): 0.0
6. 特征值: [ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
7. 特征向量:
[[-0.23197069 -0.78583024  0.40824829]
 [-0.52532209 -0.08675134 -0.81649658]
 [-0.8186735   0.61232756  0.40824829]]
8. 矩阵秩 rank(A): 2
9. 矩阵迹 trace(A): 15
10. 矩阵A奇异，无法求解
   最小二乘解: [-0.05555556  0.11111111  0.27777778]

范数:
11. 向量v的L2范数: 3.7416573867739413
12. 向量v的L1范数: 6.0
13. 矩阵A的Frobenius范数: 16.881943016134134

随机数生成

各种随机分布

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

print("随机数生成:")
print("="*50)

# 均匀分布
print("1. 均匀分布 [0,1):")
uniform = np.random.rand(3, 3)
print(f"np.random.rand(3,3):\n{uniform}")

# 标准正态分布
print("\n2. 标准正态分布:")
normal = np.random.randn(3, 3)
print(f"np.random.randn(3,3):\n{normal}")

# 整数随机数
print("\n3. 整数随机数:")
integers = np.random.randint(1, 100, size=(3, 4))
print(f"np.random.randint(1, 100, (3,4)):\n{integers}")

# 随机选择
print("\n4. 随机选择:")
choices = np.random.choice(['A', 'B', 'C', 'D'], size=10, p=[0.1, 0.2, 0.3, 0.4])
print(f"np.random.choice(['A','B','C','D'], size=10, p=[0.1,0.2,0.3,0.4]): {choices}")

# 打乱数组
print("\n5. 打乱数组:")
arr = np.arange(10)
np.random.shuffle(arr)
print(f"打乱后: {arr}")

# 各种概率分布
print("\n6. 各种概率分布:")
print(f"  a. 正态分布 (μ=0, σ=1): {np.random.normal(0, 1, 5)}")
print(f"  b. 均匀分布 [0,1): {np.random.random(5)}")
print(f"  c. 二项分布 (n=10, p=0.5): {np.random.binomial(10, 0.5, 5)}")
print(f"  d. 泊松分布 (λ=3): {np.random.poisson(3, 5)}")
print(f"  e. 指数分布 (λ=1): {np.random.exponential(1, 5)}")
print(f"  f. 伽马分布 (k=2, θ=2): {np.random.gamma(2, 2, 5)}")
print(f"  g. 贝塔分布 (α=0.5, β=0.5): {np.random.beta(0.5, 0.5, 5)}")

随机数生成:
==================================================
1. 均匀分布 [0,1):
np.random.rand(3,3):
[[0.37454012 0.95071431 0.73199394]
 [0.59865848 0.15601864 0.15599452]
 [0.05808361 0.86617615 0.60111501]]

2. 标准正态分布:
np.random.randn(3,3):
[[-0.58087813 -0.52516981 -0.57138017]
 [-0.92408284 -2.61254901  0.95036968]
 [ 0.81644508 -1.523876   -0.42804606]]

3. 整数随机数:
np.random.randint(1, 100, (3,4)):
[[80 15 62 62]
 [47 62 51 55]
 [64  3 51  7]]

4. 随机选择:
np.random.choice(['A','B','C','D'], size=10, p=[0.1,0.2,0.3,0.4]): ['B' 'A' 'D' 'D' 'D' 'C' 'A' 'D' 'C' 'B']

5. 打乱数组:
打乱后: [6 8 4 9 1 3 0 5 2 7]

6. 各种概率分布:
  a. 正态分布 (μ=0, σ=1): [-0.74240684  2.77831304  1.19363972  0.21863832  0.88176104]
  b. 均匀分布 [0,1): [0.92187424 0.0884925  0.19598286 0.04522729 0.32533033]        
  c. 二项分布 (n=10, p=0.5): [5 4 7 4 4]
  d. 泊松分布 (λ=3): [3 3 4 1 3]
  e. 指数分布 (λ=1): [0.37248835 0.39331421 1.30787578 1.01488936 2.18225191]        
  f. 伽马分布 (k=2, θ=2): [1.30758995 3.14141472 8.87729661 4.28497711 2.40636036]   
  g. 贝塔分布 (α=0.5, β=0.5): [0.00243295 0.27644666 0.92984312 0.2278109  0.89831048]

文件输入输出

保存和加载数组

import os
import tempfile

# 创建示例数组
arr1 = np.array([[1, 2, 3],
                 [4, 5, 6]])
arr2 = np.array([7, 8, 9])

print("文件输入输出:")
print("="*50)

# 创建临时目录
temp_dir = tempfile.mkdtemp()
print(f"临时目录: {temp_dir}")

# 保存和加载单个数组
print("\n1. 单个数组保存/加载:")
np.save(os.path.join(temp_dir, 'array1.npy'), arr1)
loaded_arr1 = np.load(os.path.join(temp_dir, 'array1.npy'))
print(f"保存的数组:\n{arr1}")
print(f"加载的数组:\n{loaded_arr1}")
print(f"是否相等: {np.array_equal(arr1, loaded_arr1)}")

# 保存和加载多个数组
print("\n2. 多个数组保存/加载:")
np.savez(os.path.join(temp_dir, 'arrays.npz'), arr1=arr1, arr2=arr2)
loaded_npz = np.load(os.path.join(temp_dir, 'arrays.npz'))
print(f"保存的数组: arr1={arr1.tolist()}, arr2={arr2.tolist()}")
print(f"加载的数组: arr1={loaded_npz['arr1'].tolist()}, arr2={loaded_npz['arr2'].tolist()}")

# 压缩保存
print("\n3. 压缩保存/加载:")
np.savez_compressed(os.path.join(temp_dir, 'arrays_compressed.npz'), arr1=arr1, arr2=arr2)
loaded_compressed = np.load(os.path.join(temp_dir, 'arrays_compressed.npz'))
print(f"压缩保存成功，文件大小较小")

# 文本文件保存/加载
print("\n4. 文本文件保存/加载:")
txt_file = os.path.join(temp_dir, 'array.txt')
np.savetxt(txt_file, arr1, delimiter=',', fmt='%d')
loaded_txt = np.loadtxt(txt_file, delimiter=',')
print(f"文本文件内容:\n{open(txt_file).read()}")
print(f"加载的数组:\n{loaded_txt}")

# CSV文件
print("\n5. CSV文件保存/加载:")
csv_file = os.path.join(temp_dir, 'array.csv')
np.savetxt(csv_file, arr1, delimiter=',', fmt='%.2f')
loaded_csv = np.loadtxt(csv_file, delimiter=',')
print(f"CSV文件内容:\n{open(csv_file).read()}")
print(f"加载的数组:\n{loaded_csv}")

# 清理临时文件
import shutil
shutil.rmtree(temp_dir)
print(f"\n已清理临时目录")

高级功能

广播机制

print("广播机制:")
print("="*50)

# 示例1: 标量与数组
arr = np.array([1, 2, 3])
print(f"1. 数组: {arr}")
print(f"   标量加法: {arr + 10}")
print(f"   标量乘法: {arr * 2}")

# 示例2: 不同形状数组
a = np.array([[1, 2, 3],
              [4, 5, 6]])
b = np.array([10, 20, 30])

print(f"\n2. 数组a:\n{a}")
print(f"   数组b: {b}")
print(f"   广播加法:\n{a + b}")

# 示例3: 维度扩展
c = np.array([1, 2, 3])
d = np.array([[1], [2], [3]])

print(f"\n3. 数组c: {c}")
print(f"   数组d:\n{d}")
print(f"   广播乘法:\n{c * d}")

# 手动广播
print(f"\n4. 手动广播:")
a = np.array([1, 2, 3])
b = np.array([[1], [2], [3]])
print(f"   a形状: {a.shape}")
print(f"   b形状: {b.shape}")
print(f"   a[:, np.newaxis]:\n{a[:, np.newaxis]}")
print(f"   a + b:\n{a + b}")

广播机制:
==================================================
1. 数组: [1 2 3]
   标量加法: [11 12 13]
   标量乘法: [2 4 6]

2. 数组a:
[[1 2 3]
 [4 5 6]]
   数组b: [10 20 30]
   广播加法:
[[11 22 33]
 [14 25 36]]

3. 数组c: [1 2 3]
   数组d:
[[1]
 [2]
 [3]]
   广播乘法:
[[1 2 3]
 [2 4 6]
 [3 6 9]]

4. 手动广播:
   a形状: (3,)
   b形状: (3, 1)
   a[:, np.newaxis]:
[[1]
 [2]
 [3]]
   a + b:
[[2 3 4]
 [3 4 5]
 [4 5 6]]

向量化操作

print("向量化操作:")
print("="*50)

# 创建大型数组
large_arr = np.random.randn(1000000)

# Python循环 vs 向量化操作
import time

# 方法1: Python循环
start = time.time()
result_python = []
for x in large_arr[:1000000]:  # 只取前1000000个
    result_python.append(x * 2 + 1)
time_python = time.time() - start

# 方法2: NumPy向量化
start = time.time()
result_numpy = large_arr[:1000000] * 2 + 1
time_numpy = time.time() - start

print(f"Python循环时间: {time_python:.6f}秒")
print(f"NumPy向量化时间: {time_numpy:.6f}秒")

# 避免除以零错误
if time_numpy > 0:
    print(f"速度提升: {time_python/time_numpy:.2f}倍")
else:
    print("速度提升: 无穷大（NumPy向量化操作时间过短，无法测量）")

# 使用np.vectorize
print("\n使用np.vectorize:")
def my_func(x):
    if x > 0:
        return x ** 2
    else:
        return -x

vectorized_func = np.vectorize(my_func)
arr = np.array([-2, -1, 0, 1, 2])
print(f"原始数组: {arr}")
print(f"向量化函数结果: {vectorized_func(arr)}")

向量化操作:
==================================================
Python循环时间: 0.273143秒
NumPy向量化时间: 0.003739秒
速度提升: 73.06倍

使用np.vectorize:
原始数组: [-2 -1  0  1  2]
向量化函数结果: [2 1 0 1 4]

内存视图 

print("内存视图:")
print("="*50)

# 创建数组
arr = np.arange(10)
print(f"原始数组: {arr}")

# 创建视图
view = arr.view()
view[0] = 100
print(f"修改视图后原始数组: {arr}")

# 创建副本
copy = arr.copy()
copy[0] = 999
print(f"修改副本后原始数组: {arr}")

# 内存布局
print(f"\n内存布局:")
print(f"数组是C连续: {arr.flags['C_CONTIGUOUS']}")
print(f"数组是F连续: {arr.flags['F_CONTIGUOUS']}")
print(f"数组是否可写: {arr.flags['WRITEABLE']}")
print(f"数组是否拥有数据: {arr.flags['OWNDATA']}")

内存视图:
==================================================
原始数组: [0 1 2 3 4 5 6 7 8 9]
修改视图后原始数组: [100   1   2   3   4   5   6   7   8   9]
修改副本后原始数组: [100   1   2   3   4   5   6   7   8   9]

内存布局:
数组是C连续: True
数组是F连续: True
数组是否可写: True
数组是否拥有数据: True

实用技巧和最佳实践

性能优化技巧

print("性能优化技巧:")
print("="*50)

# 1. 预分配数组
print("1. 预分配数组:")
size = 100000

# 不好的方式
start = time.time()
result = np.array([])
for i in range(size):
    result = np.append(result, i**2)
time_bad = time.time() - start
print(f"  动态追加: {time_bad:.4f}秒")

# 好的方式
start = time.time()
result = np.empty(size)
for i in range(size):
    result[i] = i**2
time_good = time.time() - start
print(f"  预分配: {time_good:.4f}秒")
print(f"  速度提升: {time_bad/time_good:.2f}倍")

# 2. 使用inplace操作
print("\n2. 使用inplace操作:")
arr = np.random.randn(1000, 1000)

start = time.time()
arr = arr + 1
time_not_inplace = time.time() - start

arr = np.random.randn(1000, 1000)
start = time.time()
arr += 1
time_inplace = time.time() - start

print(f"  普通操作: {time_not_inplace:.6f}秒")
print(f"  inplace操作: {time_inplace:.6f}秒")
print(f"  内存节省: 普通操作创建新数组，inplace操作修改原数组")

# 3. 避免不必要的复制
print("\n3. 避免不必要的复制:")
large_array = np.random.randn(10000, 10000)

# 不好的方式：创建副本
start = time.time()
copy_array = large_array.copy()
time_copy = time.time() - start

# 好的方式：使用视图
start = time.time()
view_array = large_array[:5000, :5000]
time_view = time.time() - start

print(f"  复制时间: {time_copy:.4f}秒")
print(f"  视图时间: {time_view:.6f}秒")
print(f"  内存占用: 复制占用额外内存，视图共享内存")

1. 预分配数组:
  动态追加: 4.1569秒
  预分配: 0.0430秒
  速度提升: 96.75倍

2. 使用inplace操作:
  普通操作: 0.001502秒
  inplace操作: 0.000000秒
  内存节省: 普通操作创建新数组，inplace操作修改原数组

3. 避免不必要的复制:
  复制时间: 0.1915秒
  视图时间: 0.000000秒
  内存占用: 复制占用额外内存，视图共享内存

常见错误和解决方案

print("常见错误和解决方案:")
print("="*50)

# 1. 广播错误
print("1. 广播维度不匹配:")
try:
    a = np.array([[1, 2, 3]])
    b = np.array([[1, 2]])
    result = a + b
except ValueError as e:
    print(f"   错误: {e}")
    print(f"   解决方案: 确保数组形状兼容")

# 2. 类型转换错误
print("\n2. 类型转换:")
arr = np.array([1.5, 2.7, 3.1])
int_arr = arr.astype(int)
print(f"   浮点数数组: {arr}")
print(f"   转换为整数: {int_arr} (注意: 向下取整)")

# 3. 原地操作和副本
print("\n3. 原地操作问题:")
arr = np.array([1, 2, 3, 4, 5])
subset = arr[1:4]
subset[0] = 999
print(f"   修改子集后原数组: {arr} (被修改!)")
print(f"   解决方案: 使用 arr[1:4].copy()")

# 4. 内存溢出
print("\n4. 内存溢出预防:")
try:
    # 尝试创建非常大的数组
    huge_array = np.zeros((10000, 10000, 10000))
except MemoryError as e:
    print(f"   内存错误: {e}")
    print(f"   解决方案:")
    print(f"     a. 使用稀疏矩阵")
    print(f"     b. 使用内存映射文件")
    print(f"     c. 分批处理")

完整实战示例

图像处理示例

# 模拟图像处理
print("图像处理示例:")
print("="*50)

# 创建模拟图像 (300x400 RGB)
height, width, channels = 300, 400, 3
image = np.random.randint(0, 256, (height, width, channels), dtype=np.uint8)

print(f"图像形状: {image.shape}")
print(f"图像数据类型: {image.dtype}")
print(f"像素值范围: [{image.min()}, {image.max()}]")

# 图像操作
print("\n图像操作:")

# 转换为灰度图
gray_image = np.mean(image, axis=2).astype(np.uint8)
print(f"1. 灰度图形状: {gray_image.shape}")

# 调整亮度
bright_image = np.clip(image.astype(np.int16) + 50, 0, 255).astype(np.uint8)
print(f"2. 调整亮度后范围: [{bright_image.min()}, {bright_image.max()}]")

# 图像旋转
rotated_image = np.rot90(image)
print(f"3. 旋转后形状: {rotated_image.shape}")

# 图像裁剪
cropped_image = image[50:250, 100:300, :]
print(f"4. 裁剪后形状: {cropped_image.shape}")

# 添加噪声
noise = np.random.normal(0, 25, image.shape).astype(np.int16)
noisy_image = np.clip(image.astype(np.int16) + noise, 0, 255).astype(np.uint8)
print(f"5. 加噪声后SNR: {np.std(image)/np.std(noise):.2f}")

图像处理示例:
==================================================
图像形状: (300, 400, 3)
图像数据类型: uint8
像素值范围: [0, 255]

图像操作:
1. 灰度图形状: (300, 400)
2. 调整亮度后范围: [50, 255]
3. 旋转后形状: (400, 300, 3)
4. 裁剪后形状: (200, 200, 3)
5. 加噪声后SNR: 3.01

机器学习数据预处理

# 机器学习数据预处理
print("\n机器学习数据预处理:")
print("="*50)

# 创建模拟数据集
n_samples = 1000
n_features = 20

# 特征矩阵
X = np.random.randn(n_samples, n_features)

# 添加一些异常值和缺失值
X[10, 5] = 100  # 异常值
X[20, 10] = np.nan  # 缺失值

# 目标变量
y = np.random.randn(n_samples)

print(f"数据集形状: X={X.shape}, y={y.shape}")

# 数据预处理步骤
print("\n数据预处理步骤:")

# 1. 处理缺失值
from numpy import nanmean
X_filled = np.where(np.isnan(X), nanmean(X, axis=0), X)
print(f"1. 缺失值处理: 用列均值填充")

# 2. 去除异常值
from scipy import stats
z_scores = np.abs(stats.zscore(X_filled))
X_no_outliers = X_filled[(z_scores < 3).all(axis=1)]
print(f"2. 异常值处理: 去除{len(X_filled)-len(X_no_outliers)}个样本")

# 3. 标准化
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_no_outliers)
print(f"3. 标准化: 均值={X_scaled.mean():.2f}, 标准差={X_scaled.std():.2f}")

# 4. 特征选择 (基于方差)
variances = np.var(X_scaled, axis=0)
high_var_features = np.where(variances > 0.1)[0]
print(f"4. 特征选择: 保留{len(high_var_features)}个高方差特征")

# 5. 数据集划分
train_size = int(0.8 * len(X_scaled))
X_train, X_test = X_scaled[:train_size], X_scaled[train_size:]
y_train, y_test = y[:train_size], y[train_size:]
print(f"5. 数据集划分: 训练集{X_train.shape}, 测试集{X_test.shape}")

机器学习数据预处理:
==================================================
数据集形状: X=(1000, 20), y=(1000,)

数据预处理步骤:
1. 缺失值处理: 用列均值填充
2. 异常值处理: 去除58个样本
3. 标准化: 均值=0.00, 标准差=1.00
4. 特征选择: 保留20个高方差特征
5. 数据集划分: 训练集(753, 20), 测试集(189, 20)

NumPy 最佳实践总结

代码规范

# ✅ 推荐的做法
import numpy as np

# 清晰的变量名
data_matrix = np.random.randn(100, 50)
row_sums = np.sum(data_matrix, axis=1)
column_means = np.mean(data_matrix, axis=0)

# 使用向量化操作而不是循环
result = np.sqrt(data_matrix ** 2 + 1)

# 适当使用注释
# 标准化数据: (x - mean) / std
normalized_data = (data_matrix - np.mean(data_matrix)) / np.std(data_matrix)

# 处理边界情况
safe_data = np.where(np.isnan(data_matrix), 0, data_matrix)

性能优化

# 性能优化技巧总结
optimization_tips = {
    '预分配内存': '使用 np.empty() 或 np.zeros() 预分配数组',
    '向量化操作': '避免 Python 循环，使用 NumPy 向量化',
    '使用视图': '切片返回视图，而不是副本',
    '适当的数据类型': '使用最小够用的数据类型',
    '内存连续': '确保数组在内存中是连续的',
    '批量操作': '一次处理大量数据，而不是逐个处理',
    '使用内置函数': '优先使用 NumPy 内置函数',
    '避免不必要的复制': '使用 copy() 只在需要时',
}

print("NumPy 性能优化技巧:")
for tip, description in optimization_tips.items():
    print(f"  ✅ {tip}: {description}")

常用函数速查表

基础创建

函数	说明	示例	返回值
np.array()​	创建数组	np.array([1,2,3])	[1 2 3]
np.asarray()​	转换为数组	np.asarray([1,2,3])	[1 2 3]
np.arange()​	等间隔数组	np.arange(0, 5, 1)	[0 1 2 3 4]
np.linspace()​	等差数列	np.linspace(0, 1, 5)	[0. 0.25 0.5 0.75 1.]
np.logspace()​	等比数列	np.logspace(0, 2, 3)	[1. 10. 100.]
np.geomspace()​	几何间隔	np.geomspace(1, 8, 4)	[1. 2. 4. 8.]

特殊数组

函数	说明	示例	形状
np.zeros()​	全零数组	np.zeros((2,3))	(2,3)
np.ones()​	全一数组	np.ones((3,2))	(3,2)
np.full()​	全值数组	np.full((2,2), 7)	(2,2)全7
np.empty()​	未初始化数组	np.empty((3,3))	(3,3)
np.eye()​	单位矩阵	np.eye(3)	3×3单位阵
np.identity()​	单位矩阵	np.identity(3)	3×3单位阵
np.diag()​	对角矩阵	np.diag([1,2,3])	3×3对角阵

网格创建

函数	说明	示例
np.meshgrid()​	坐标矩阵	x,y = np.meshgrid([0,1],[0,1])
np.mgrid()​	密集网格	x,y = np.mgrid[0:2, 0:2]
np.ogrid()​	开放网格	x,y = np.ogrid[0:2, 0:2]
np.indices()​	索引网格	np.indices((2,3))

数组操作函数

形状操作

函数	说明	示例
reshape()​	改变形状	arr.reshape(2,3)
resize()​	调整大小	np.resize(arr, (3,3))
flatten()​	扁平化(副本)	arr.flatten()
ravel()​	扁平化(视图)	arr.ravel()
T​	转置	arr.T
transpose()​	转置	arr.transpose()
swapaxes()​	交换轴	arr.swapaxes(0,1)
moveaxis()​	移动轴	np.moveaxis(arr, 0, -1)
squeeze()​	删除单维度	arr.squeeze()
expand_dims()​	增加维度	np.expand_dims(arr, axis=0)

数组组合

函数	说明	示例
concatenate()​	连接数组	np.concatenate((a,b), axis=0)
stack()​	堆叠数组	np.stack((a,b), axis=0)
vstack()​	垂直堆叠	np.vstack((a,b))
hstack()​	水平堆叠	np.hstack((a,b))
dstack()​	深度堆叠	np.dstack((a,b))
column_stack()​	列堆叠	np.column_stack((a,b))
row_stack()​	行堆叠	np.row_stack((a,b))
block()​	块组合	np.block([[a,b],[c,d]])

数组分割

函数	说明	示例
split()​	分割数组	np.split(arr, 3)
array_split()​	不等分割	np.array_split(arr, 3)
vsplit()​	垂直分割	np.vsplit(arr, 2)
hsplit()​	水平分割	np.hsplit(arr, 2)
dsplit()​	深度分割	np.dsplit(arr, 2)

数组复制

函数	说明	示例
copy()​	深度复制	arr.copy()
view()​	创建视图	arr.view()
astype()​	类型转换	arr.astype(np.float32)
tobytes()​	转为字节	arr.tobytes()
tolist()​	转为列表	arr.tolist()

数学运算函数

算术运算

函数	说明	示例
np.add()​	加法	np.add(a, b)
np.subtract()​	减法	np.subtract(a, b)
np.multiply()​	乘法	np.multiply(a, b)
np.divide()​	除法	np.divide(a, b)
np.floor_divide()​	整除	np.floor_divide(a, b)
np.mod()​	取余	np.mod(a, b)
np.power()​	幂运算	np.power(a, 2)
np.sqrt()​	平方根	np.sqrt(a)
np.square()​	平方	np.square(a)
np.absolute()​	绝对值	np.absolute(a)
np.fabs()​	浮点绝对值	np.fabs(a)
np.sign()​	符号函数	np.sign(a)
np.ceil()​	向上取整	np.ceil(a)
np.floor()​	向下取整	np.floor(a)
np.trunc()​	截断取整	np.trunc(a)
np.rint()​	四舍五入	np.rint(a)
np.round()​	舍入	np.round(a, 2)

指数对数

函数	说明	示例
np.exp()​	e的指数	np.exp(a)
np.expm1()​	exp(x)-1	np.expm1(a)
np.exp2()​	2的指数	np.exp2(a)
np.log()​	自然对数	np.log(a)
np.log10()​	常用对数	np.log10(a)
np.log2()​	以2为底对数	np.log2(a)
np.log1p()​	log(1+x)	np.log1p(a)

三角函数

函数	说明	示例
np.sin()​	正弦	np.sin(a)
np.cos()​	余弦	np.cos(a)
np.tan()​	正切	np.tan(a)
np.arcsin()​	反正弦	np.arcsin(a)
np.arccos()​	反余弦	np.arccos(a)
np.arctan()​	反正切	np.arctan(a)
np.deg2rad()​	度转弧度	np.deg2rad(180)
np.rad2deg()​	弧度转度	np.rad2deg(np.pi)
np.hypot()​	斜边长度	np.hypot(3,4)

统计函数

基本统计

函数	说明	示例
np.sum()​	求和	np.sum(arr)
np.mean()​	均值	np.mean(arr)
np.average()​	加权平均	np.average(arr, weights=w)
np.median()​	中位数	np.median(arr)
np.std()​	标准差	np.std(arr)
np.var()​	方差	np.var(arr)
np.min()​	最小值	np.min(arr)
np.max()​	最大值	np.max(arr)
np.ptp()​	极差(最大-最小)	np.ptp(arr)
np.percentile()​	百分位数	np.percentile(arr, 75)
np.quantile()​	分位数	np.quantile(arr, 0.75)

累积统计

函数	说明	示例
np.cumsum()​	累积和	np.cumsum(arr)
np.cumprod()​	累积积	np.cumprod(arr)
np.nancumsum()​	忽略NaN的累积和	np.nancumsum(arr)
np.nancumprod()​	忽略NaN的累积积	np.nancumprod(arr)

最值索引

函数	说明	示例
np.argmin()​	最小值索引	np.argmin(arr)
np.argmax()​	最大值索引	np.argmax(arr)
np.argsort()​	排序索引	np.argsort(arr)
np.argwhere()​	非零索引	np.argwhere(arr > 0)
np.nanargmin()​	忽略NaN的最小值索引	np.nanargmin(arr)
np.nanargmax()​	忽略NaN的最大值索引	np.nanargmax(arr)

线性代数函数

矩阵运算

函数	说明	示例
np.dot()​	点积	np.dot(a, b)
@运算符​	矩阵乘法	a @ b
np.inner()​	向量内积	np.inner(a, b)
np.outer()​	向量外积	np.outer(a, b)
np.cross()​	向量叉积	np.cross(a, b)
np.tensordot()​	张量点积	np.tensordot(a, b, axes=1)
np.kron()​	Kronecker积	np.kron(a, b)

矩阵分解

函数	说明	示例
np.linalg.inv()​	矩阵求逆	np.linalg.inv(A)
np.linalg.pinv()​	伪逆	np.linalg.pinv(A)
np.linalg.det()​	行列式	np.linalg.det(A)
np.linalg.eig()​	特征值/特征向量	np.linalg.eig(A)
np.linalg.eigvals()​	特征值	np.linalg.eigvals(A)
np.linalg.svd()​	奇异值分解	np.linalg.svd(A)
np.linalg.qr()​	QR分解	np.linalg.qr(A)
np.linalg.cholesky()​	Cholesky分解	np.linalg.cholesky(A)

线性方程

函数	说明	示例
np.linalg.solve()​	解线性方程	np.linalg.solve(A, b)
np.linalg.lstsq()​	最小二乘解	np.linalg.lstsq(A, b)
np.linalg.matrix_rank()​	矩阵秩	np.linalg.matrix_rank(A)
np.trace()​	矩阵迹	np.trace(A)
np.linalg.norm()​	范数	np.linalg.norm(v)
np.linalg.cond()​	条件数	np.linalg.cond(A)

随机数函数

基础随机

函数	说明	示例
np.random.rand()​	[0,1)均匀分布	np.random.rand(3,3)
np.random.randn()​	标准正态分布	np.random.randn(3,3)
np.random.randint()​	随机整数	np.random.randint(0,10,5)
np.random.random()​	随机浮点数	np.random.random(5)
np.random.choice()​	随机选择	np.random.choice([1,2,3], 5)
np.random.shuffle()​	打乱数组	np.random.shuffle(arr)
np.random.permutation()​	随机排列	np.random.permutation(arr)
np.random.seed()​	设置随机种子	np.random.seed(42)

概率分布

函数	说明	示例
np.random.uniform()​	均匀分布	np.random.uniform(0,1,5)
np.random.normal()​	正态分布	np.random.normal(0,1,5)
np.random.binomial()​	二项分布	np.random.binomial(10,0.5,5)
np.random.poisson()​	泊松分布	np.random.poisson(3,5)
np.random.exponential()​	指数分布	np.random.exponential(1,5)
np.random.gamma()​	伽马分布	np.random.gamma(2,2,5)
np.random.beta()​	贝塔分布	np.random.beta(2,5,5)
np.random.chisquare()​	卡方分布	np.random.chisquare(2,5)
np.random.f()​	F分布	np.random.f(5,2,5)
np.random.geometric()​	几何分布	np.random.geometric(0.5,5)

逻辑函数

比较运算

函数	说明	示例
np.greater()​	大于	np.greater(a, b)
np.greater_equal()​	大于等于	np.greater_equal(a, b)
np.less()​	小于	np.less(a, b)
np.less_equal()​	小于等于	np.less_equal(a, b)
np.equal()​	等于	np.equal(a, b)
np.not_equal()​	不等于	np.not_equal(a, b)
np.array_equal()​	数组相等	np.array_equal(a, b)

逻辑运算

函数	说明	示例
np.logical_and()​	逻辑与	np.logical_and(a>0, b>0)
np.logical_or()​	逻辑或	np.logical_or(a>0, b>0)
np.logical_not()​	逻辑非	np.logical_not(a>0)
np.logical_xor()​	逻辑异或	np.logical_xor(a>0, b>0)
np.all()​	所有为真	np.all(a>0)
np.any()​	任一为真	np.any(a>0)
np.isclose()​	近似相等	np.isclose(a, b)
np.allclose()​	全部近似相等	np.allclose(a, b)
np.isnan()​	是否是NaN	np.isnan(a)
np.isinf()​	是否是无穷	np.isinf(a)
np.isfinite()​	是否有限	np.isfinite(a)
np.isreal()​	是否是实数	np.isreal(a)
np.iscomplex()​	是否是复数	np.iscomplex(a)
np.isin()​	是否包含	np.isin(a, [1,2,3])

集合函数

函数	说明	示例
np.unique()​	唯一值	np.unique(arr)
np.intersect1d()​	交集	np.intersect1d(a, b)
np.union1d()​	并集	np.union1d(a, b)
np.setdiff1d()​	差集	np.setdiff1d(a, b)
np.setxor1d()​	对称差	np.setxor1d(a, b)
np.in1d()​	元素是否在数组中	np.in1d(a, b)

排序搜索函数

1. 排序

函数	说明	示例
np.sort()​	排序	np.sort(arr)
np.argsort()​	排序索引	np.argsort(arr)
np.lexsort()​	多键排序	np.lexsort((a, b))
np.msort()​	沿第一轴排序	np.msort(arr)
np.sort_complex()​	复数排序	np.sort_complex(arr)
np.partition()​	部分排序	np.partition(arr, 3)
np.argpartition()​	部分排序索引	np.argpartition(arr, 3)

搜索

函数	说明	示例
np.where()​	条件索引	np.where(arr>5)
np.searchsorted()​	查找插入位置	np.searchsorted(arr, 5)
np.extract()​	提取满足条件元素	np.extract(arr>5, arr)
np.nonzero()​	非零元素索引	np.nonzero(arr)
np.flatnonzero()​	扁平数组非零索引	np.flatnonzero(arr)
np.count_nonzero()​	非零元素计数	np.count_nonzero(arr)

输入输出函数

文件操作

函数	说明	示例
np.save()​	保存数组(.npy)	np.save('arr.npy', arr)
np.load()​	加载数组	np.load('arr.npy')
np.savez()​	保存多个数组(.npz)	np.savez('data.npz', a=arr1, b=arr2)
np.savez_compressed()​	压缩保存	np.savez_compressed('data.npz', arr)
np.savetxt()​	保存为文本	np.savetxt('data.txt', arr)
np.loadtxt()​	加载文本	np.loadtxt('data.txt')
np.genfromtxt()​	从文本生成数组	np.genfromtxt('data.csv', delimiter=',')
np.fromfile()​	从文件读取	np.fromfile('data.bin', dtype=float)
np.tofile()​	写入文件	arr.tofile('data.bin')

实用工具函数

类型检查

函数	说明	示例
np.isscalar()​	是否是标量	np.isscalar(5)
np.iscomplexobj()​	是否是复数对象	np.iscomplexobj(arr)
np.isrealobj()​	是否是实数对象	np.isrealobj(arr)
np.issubdtype()​	是否是子类型	np.issubdtype(arr.dtype, np.integer)
np.can_cast()​	是否可以类型转换	np.can_cast(arr.dtype, np.float32)

数组操作

函数	说明	示例
np.pad()​	填充数组	np.pad(arr, 1, mode='constant')
np.repeat()​	重复元素	np.repeat(arr, 3)
np.tile()​	平铺数组	np.tile(arr, (2,3))
np.flip()​	翻转数组	np.flip(arr)
np.fliplr()​	左右翻转	np.fliplr(arr)
np.flipud()​	上下翻转	np.flipud(arr)
np.rot90()​	旋转90度	np.rot90(arr)
np.roll()​	滚动元素	np.roll(arr, 2)
np.rollaxis()​	滚动轴	np.rollaxis(arr, 0, 2)
np.diff()​	差分	np.diff(arr)
np.gradient()​	梯度	np.gradient(arr)
np.cumsum()​	累积和	np.cumsum(arr)
np.triu()​	上三角矩阵	np.triu(arr)
np.tril()​	下三角矩阵	np.tril(arr)
np.diag()​	提取/创建对角线	np.diag(arr)
np.diagflat()​	创建对角矩阵	np.diagflat(arr)
np.trace()​	矩阵迹	np.trace(arr)