Kai Site

简体中文

English

简体中文

English

外观

NumPy 数值计算

16802 字约 56 分钟

2025-01-20

本页定位

这篇笔记整理 NumPy 的数组计算能力，是 Pandas、科学计算和机器学习库的底层基础。

学习重点

  • 理解 ndarray、维度、形状和数据类型。
  • 掌握切片、广播、向量化计算和常用统计函数。
  • 为后续特征矩阵、模型输入和高效计算打基础。

1-1 安装NumPy

1-1-1 使用pip安装NumPy

  1. 打开命令行界面

    • 在Windows上，可以按 Win + R，输入 cmd，然后按回车键。
    • 在Mac或Linux上，可以打开终端（Terminal）。

  2. 确保已安装Python和pip

    • 在命令行中输入以下命令检查Python版本：
      python --version
    • 输入以下命令检查pip版本：
      pip --version
    • 如果未安装pip，可以参考官方文档进行安装。

  3. 使用pip安装NumPy

    • 输入以下命令来安装NumPy：
      pip install numpy
    • 如果需要安装特定版本，可以使用：
      pip install numpy==1.21.0
    • 安装完成后，命令行会显示安装成功的消息。

1-1-2 使用conda安装NumPy

  1. 打开命令行界面

    • 同样的，打开命令行界面（cmd或Terminal）。

  2. 确保已安装Anaconda或Miniconda

    • 输入以下命令检查conda版本：
      conda --version
    • 如果未安装conda，请访问Anaconda官方网站下载并安装。

  3. 使用conda创建新的虚拟环境（可选）

    • 创建一个新的虚拟环境（例如：myenv）：
      conda create --name myenv
    • 激活虚拟环境：
      conda activate myenv

  4. 使用conda安装NumPy

    • 输入以下命令来安装NumPy：
      conda install numpy
    • 安装完成后，会显示安装成功的消息。

1-1-3 安装过程中的常见问题及解决方法

  • 问题1：无法找到pip或conda命令

  • 问题2：权限错误

    • 如果在安装过程中遇到权限错误，可以尝试以管理员身份运行命令提示符（在Windows上右键点击cmd选择“以管理员身份运行”），或者在Linux/Mac上使用 sudo 命令：
      sudo pip install numpy

  • 问题3：安装超时或失败

    • 检查网络连接，确保能够访问PyPI（Python Package Index）或Anaconda仓库。
    • 可以尝试更换安装源，例如使用国内的镜像：
      pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

1-1-4 验证NumPy安装是否成功

  1. 打开Python交互式环境

    • 在命令行中输入 python，进入Python的交互式命令行界面。

  2. 导入NumPy库

    • 输入以下命令：
      import numpy as np

  3. 检查NumPy版本

    • 输入以下命令来查看安装的NumPy版本：
      print(np.__version__)
    • 如果能够成功导入NumPy且显示版本号，说明NumPy安装成功。

  4. 执行简单的NumPy操作

    • 你可以执行以下简单操作来测试NumPy是否工作正常：
      a = np.array([1, 2, 3])
print(a)
    • 如果输出 [1 2 3]，说明NumPy功能正常。

2. NumPy Ndarray对象

2-1 NumPy Ndarray对象概述

2-1-1 Ndarray的定义与特性

  • 定义：Ndarray（N-dimensional array）是NumPy库中用于存储多维数组的核心对象。它是一个同质（homogeneous）数据容器，意味着所有元素的数据类型必须相同。

  • 特性：

    • 多维性：Ndarray可以是1维、2维或更高维度的数组，适用于各种复杂数据的存储。
    • 高效性：由于使用连续的内存块存储数据，Ndarray在数据操作上具有高效性。
    • 功能丰富：NumPy提供了大量的内置函数，可以方便地对Ndarray进行数学运算、逻辑运算等。
    • 广播机制：在进行运算时，NumPy能够自动扩展数组的形状，支持不同形状数组之间的操作。

2-1-2 如何创建Ndarray对象

创建Ndarray对象的方法有很多，以下是几种常用的方法：

  1. 从列表或元组创建：

    import numpy as np

# 从列表创建一维数组
arr1 = np.array([1, 2, 3, 4])
print("一维数组:", arr1)

# 从嵌套列表创建二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print("二维数组:\n", arr2)

  2. 使用arange函数创建数组：

    # 创建一个从0到9的数组
arr3 = np.arange(10)
print("使用arange创建的数组:", arr3)

# 创建从0到9的数组，步长为2
arr4 = np.arange(0, 10, 2)
print("步长为2的数组:", arr4)

  3. 使用linspace函数创建数组：

    # 创建一个包含5个均匀分布的数的数组
arr5 = np.linspace(0, 1, 5)
print("使用linspace创建的数组:", arr5)

  4. 创建特殊数组：

    # 创建全为0的数组
arr6 = np.zeros((2, 3))  # 2行3列
print("全为0的数组:\n", arr6)

# 创建全为1的数组
arr7 = np.ones((2, 3))
print("全为1的数组:\n", arr7)

# 创建未初始化的数组
arr8 = np.empty((2, 3))
print("未初始化的数组:\n", arr8)

  5. 使用随机数生成数组：

    # 创建包含5个随机数的数组
arr9 = np.random.rand(5)  # 均匀分布的随机数
print("随机数数组:", arr9)

# 创建一个2x3的随机整数数组
arr10 = np.random.randint(0, 10, (2, 3))  # 0到10之间的随机整数
print("随机整数数组:\n", arr10)

2-2 Ndarray的基本操作

2-2-1 数据访问与修改

  • 访问元素：

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

# 访问第一行第二列的元素
print("访问元素:", arr[0, 1])  # 输出: 2

  • 修改元素：

    arr[0, 1] = 10
print("修改后的数组:\n", arr)

  • 访问整行或整列：

    # 访问第一行
print("第一行:", arr[0])

# 访问第二列
print("第二列:", arr[:, 1])  # 使用冒号(:)表示选择所有行

2-2-2 数据切片与索引

  • 基本切片：

    # 获取前两行和前两列的子数组
sub_array = arr[:2, :2]
print("切片后的数组:\n", sub_array)

  • 高级切片：

    # 使用步长切片
arr2 = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print("步长切片:", arr2[0, ::2])  # 获取第一行的每隔一个元素

  • 布尔索引：

    # 获取大于5的元素
bool_idx = arr > 5
print("布尔索引结果:", arr[bool_idx])

  • 花式索引（Fancy Indexing）：

    # 使用整数数组索引
indices = np.array([0, 1])
print("花式索引结果:\n", arr[indices, [1, 2]])  # 访问(0,1)和(1,2)的元素

2-3 Ndarray与Python列表的比较

2-3-1 性能差异

  • 内存占用：Ndarray使用连续的内存块存储数据，相比Python列表可以更有效地利用内存。
  • 运算速度：Ndarray的操作在C语言层面实现，速度通常比Python列表要快得多，尤其是在处理大型数据时。
import time

# 测试性能
size = 1000000

# 使用Python列表
py_list = list(range(size))
start_time = time.time()
py_list = [x * 2 for x in py_list]
print("Python列表运算时间:", time.time() - start_time)

# 使用NumPy Ndarray
np_array = np.arange(size)
start_time = time.time()
np_array = np_array * 2
print("NumPy Ndarray运算时间:", time.time() - start_time)

2-3-2 功能差异

  • 数据类型限制：Ndarray中所有元素的数据类型必须相同，而Python列表可以存储不同类型的对象。
  • 操作便利性：NumPy提供了许多便捷的数学运算和函数，支持广播、向量化运算等，方便进行数据分析和科学计算。
# 使用Ndarray进行数学运算
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print("NumPy数组加法:", a + b)  # 元素逐个相加

# 使用Python列表进行相同操作
list_a = [1, 2, 3]
list_b = [4, 5, 6]
print("Python列表加法:", [x + y for x, y in zip(list_a, list_b)])  # 使用zip进行逐个相加

3. 数据类型

3-1 NumPy数据类型概述

NumPy中的数据类型（dtype）用于描述数组中元素的类型，合理的数据类型选择对于内存使用和运算性能至关重要。以下是一些常见的数据类型：

3-1-1 常见数据类型（int, float, complex, str等）

  1. 整数类型（int）：

    • np.int8：8位整数，范围为-128到127
    • np.int16：16位整数，范围为-32768到32767
    • np.int32：32位整数，范围为-2147483648到2147483647
    • np.int64：64位整数，范围为-9223372036854775808到9223372036854775807
    import numpy as np

int_array = np.array([1, 2, 3], dtype=np.int32)
print("整数数组:", int_array)
print("数据类型:", int_array.dtype)  # 输出: int32

  2. 浮点数类型（float）：

    • np.float16：16位浮点数
    • np.float32：32位浮点数
    • np.float64：64位浮点数，通常为默认类型
    float_array = np.array([1.0, 2.5, 3.7], dtype=np.float64)
print("浮点数数组:", float_array)
print("数据类型:", float_array.dtype)  # 输出: float64

  3. 复数类型（complex）：

    • np.complex64：64位复数（32位实部和32位虚部）
    • np.complex128：128位复数（64位实部和64位虚部）
    complex_array = np.array([1+2j, 3+4j], dtype=np.complex128)
print("复数数组:", complex_array)
print("数据类型:", complex_array.dtype)  # 输出: complex128

  4. 字符串类型（str）：

    • np.str_：字符串类型，默认大小为256字符（可以通过指定大小来改变）。
    str_array = np.array(['hello', 'world'], dtype=np.str_)
print("字符串数组:", str_array)
print("数据类型:", str_array.dtype)  # 输出: <U5

  5. 布尔类型（bool）：

    • np.bool_：布尔类型，值为True或False。
    bool_array = np.array([True, False, True], dtype=np.bool_)
print("布尔数组:", bool_array)
print("数据类型:", bool_array.dtype)  # 输出: bool

3-2 数据类型转换

在使用NumPy时，可能需要将数组从一种数据类型转换为另一种数据类型。NumPy提供了几种方法来实现这一点。

3-2-1 如何转换数据类型

  1. 使用astype()方法：

    • astype()方法用于转换数组的数据类型。
    arr = np.array([1.5, 2.7, 3.9])
int_arr = arr.astype(np.int32)  # 转换为整数类型
print("转换后的整数数组:", int_arr)  # 输出: [1 2 3]

  2. 直接创建数组时指定数据类型：

    • 在创建数组时，可以直接通过dtype参数指定数据类型。
    arr_float = np.array([1, 2, 3], dtype=np.float32)
print("创建时指定浮点数类型:", arr_float)

3-2-2 常见的数据类型转换示例

  1. 浮点数转整数：

    • 浮点数转换为整数时，会丢失小数部分。
    float_arr = np.array([1.9, 2.8, 3.5])
int_arr = float_arr.astype(np.int32)
print("浮点数转整数:", int_arr)  # 输出: [1 2 3]

  2. 整数转浮点数：

    • 整数转换为浮点数时，不会丢失数据。
    int_arr = np.array([1, 2, 3])
float_arr = int_arr.astype(np.float64)
print("整数转浮点数:", float_arr)  # 输出: [1. 2. 3.]

  3. 布尔数组转整数：

    • 在将布尔数组转换为整数时，True会转换为1，False会转换为0。
    bool_arr = np.array([True, False, True])
int_from_bool = bool_arr.astype(np.int32)
print("布尔转整数:", int_from_bool)  # 输出: [1 0 1]

  4. 字符串转浮点数：

    • 字符串数组可以转换为浮点数数组，前提是字符串格式正确。
    str_arr = np.array(['1.1', '2.2', '3.3'])
float_from_str = str_arr.astype(np.float64)
print("字符串转浮点数:", float_from_str)  # 输出: [1.1 2.2 3.3]

  5. 复数转换为浮点数：

    • 将复数转换为浮点数时，只保留实部。
    complex_arr = np.array([1+2j, 3+4j])
float_from_complex = complex_arr.astype(np.float64)
print("复数转浮点数:", float_from_complex)  # 输出: [1. 3.]

  6. 处理异常数据类型转换：

    • 尝试将无效的字符串转换为数值类型将会抛出错误。
    invalid_str_arr = np.array(['1.1', 'two', '3.3'])
try:
    float_invalid = invalid_str_arr.astype(np.float64)
except ValueError as e:
    print("错误:", e)  # 输出: could not convert string to float: 'two'

4. 数组属性

4-1 数组的属性介绍

NumPy数组具有多个重要的属性，这些属性可以帮助用户理解数组的结构和内容。以下是一些常用的数组属性：

4-1-1 shape、ndim、size、dtype等属性

  1. shape属性：

    • shape属性返回一个元组，表示数组在每个维度上的大小。它可以帮助我们了解数组的结构，例如行数和列数。
    import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("数组形状:", arr.shape)  # 输出: (2, 3)，表示2行3列

  2. ndim属性：

    • ndim属性返回数组的维度数。可以用来判断数组是几维的。
    print("数组维度数:", arr.ndim)  # 输出: 2，表示这是一个二维数组

  3. size属性：

    • size属性返回数组中所有元素的总数，即数组的大小。
    print("数组大小:", arr.size)  # 输出: 6，表示数组中总共有6个元素

  4. dtype属性：

    • dtype属性返回数组中元素的数据类型。可以用来检查数组元素的类型。
    print("数组数据类型:", arr.dtype)  # 输出: int64，表示数组元素是64位整数

  5. itemsize属性：

    • itemsize属性返回数组中每个元素所占用的字节数。可以用来估算数组占用的内存大小。
    print("每个元素占用的字节数:", arr.itemsize)  # 输出: 8，表示每个元素占用8字节（对于int64）

  6. nbytes属性：

    • nbytes属性返回数组的总字节数，即数组大小和每个元素大小的乘积。
    print("数组总占用字节数:", arr.nbytes)  # 输出: 48，表示数组总共占用48字节（6个元素，每个8字节）

4-2 如何获取与修改数组属性

4-2-1 获取数组属性

获取数组的属性非常简单，只需访问对应的属性即可。例如：

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

# 获取属性
print("数组形状:", arr2.shape)  # 输出: (3, 4)
print("数组维度数:", arr2.ndim)  # 输出: 2
print("数组大小:", arr2.size)    # 输出: 12
print("数组数据类型:", arr2.dtype)  # 输出: int64
print("每个元素占用的字节数:", arr2.itemsize)  # 输出: 8
print("数组总占用字节数:", arr2.nbytes)  # 输出: 96

4-2-2 修改数组属性

虽然某些属性（如ndim和dtype）无法直接修改，但可以通过其他方法间接修改数组的结构。下面是一些常见的操作：

  1. 修改数组的形状：

    • 使用reshape()方法可以更改数组的形状，但前提是总元素数量不变。
    arr3 = np.arange(12)  # 创建一个包含12个元素的数组
print("原数组:", arr3)

reshaped_arr = arr3.reshape(3, 4)  # 将其重塑为3行4列
print("重塑后的数组:\n", reshaped_arr)

  2. 更改数据类型：

    • 可以通过astype()方法将数组转换为其他数据类型。
    arr4 = np.array([1.5, 2.3, 3.1])
print("原始数组:", arr4)

arr4_int = arr4.astype(np.int32)  # 转换为整数类型
print("转换后的整数数组:", arr4_int)

  3. 改变元素的值：

    • 直接通过索引访问并修改数组元素的值。
    arr5 = np.array([[1, 2], [3, 4]])
print("修改前的数组:\n", arr5)

arr5[0, 1] = 10  # 修改第一行第二列的值
print("修改后的数组:\n", arr5)

  4. 添加新维度：

    • 使用np.newaxis或reshape方法添加新维度。
    arr6 = np.array([1, 2, 3])
print("原数组:", arr6)

# 使用np.newaxis添加新维度
arr6_2d = arr6[:, np.newaxis]  # 将一维数组转换为二维列数组
print("添加新维度后的数组:\n", arr6_2d)

5. 创建数组

5-1 NumPy创建数组的方法

在NumPy中，可以通过多种方式创建数组，以下是一些常用的方法。

5-1-1 从已有数组创建

可以通过将现有的数组传递给np.array()函数来创建新数组。这对于复制数组或对数组进行类型转换非常有用。

import numpy as np

# 从列表创建数组
original_array = np.array([1, 2, 3, 4, 5])
print("原始数组:", original_array)

# 从已有数组创建新数组
new_array = np.array(original_array)
print("从已有数组创建的新数组:", new_array)

# 修改新数组不会影响原始数组
new_array[0] = 10
print("修改后的新数组:", new_array)  # 输出: [10  2  3  4  5]
print("原始数组不变:", original_array)  # 输出: [1  2  3  4  5]

5-1-2 从数值范围创建（arange, linspace）

  1. 使用arange()函数：

    • np.arange(start, stop, step)返回一个范围内的数组，类似于Python的range()函数，但返回的是NumPy数组。
    # 创建从0到9的数组
arr_arange = np.arange(10)
print("使用arange创建的数组:", arr_arange)  # 输出: [0 1 2 3 4 5 6 7 8 9]

# 创建从0到9的数组，步长为2
arr_arange_step = np.arange(0, 10, 2)
print("步长为2的数组:", arr_arange_step)  # 输出: [0 2 4 6 8]

  2. 使用linspace()函数：

    • np.linspace(start, stop, num)返回一个数组，该数组包含从start到stop之间的num个均匀分布的样本。
    # 创建一个包含5个均匀分布的数的数组
arr_linspace = np.linspace(0, 1, 5)
print("使用linspace创建的数组:", arr_linspace)  # 输出: [0.   0.25 0.5  0.75 1.  ]

5-1-3 创建特殊数组（zeros, ones, empty）

  1. 使用np.zeros()创建全零数组：

    • np.zeros(shape)返回指定形状的数组，所有元素初始化为0。
    # 创建一个2x3的全零数组
zeros_array = np.zeros((2, 3))
print("全零数组:\n", zeros_array)

  2. 使用np.ones()创建全一数组：

    • np.ones(shape)返回指定形状的数组，所有元素初始化为1。
    # 创建一个3x2的全一数组
ones_array = np.ones((3, 2))
print("全一数组:\n", ones_array)

  3. 使用np.empty()创建未初始化数组：

    • np.empty(shape)返回指定形状的数组，但数组中的值是未初始化的，可能是随机的。
    # 创建一个2x2的未初始化数组
empty_array = np.empty((2, 2))
print("未初始化数组:\n", empty_array)  # 输出内容会是随机的

5-2 使用随机数创建数组

NumPy提供了random模块，可以方便地生成随机数。下面是一些常见用法。

5-2-1 random模块的使用

  1. 生成均匀分布的随机数：

    • np.random.rand(d0, d1, ..., dn)生成一个给定形状的数组，其中包含在半开区间[0.0, 1.0)上的随机浮点数。
    # 创建一个2x3的数组，随机数在[0, 1)之间
random_uniform = np.random.rand(2, 3)
print("均匀分布随机数数组:\n", random_uniform)

  2. 生成标准正态分布的随机数：

    • np.random.randn(d0, d1, ..., dn)生成一个给定形状的数组，其中包含标准正态分布（均值为0，标准差为1）的随机数。
    # 创建一个3x2的数组，随机数符合标准正态分布
random_normal = np.random.randn(3, 2)
print("标准正态分布随机数数组:\n", random_normal)

  3. 生成指定范围内的随机整数：

    • np.random.randint(low, high, size)生成指定范围内的随机整数。
    # 创建一个2x3的数组，随机整数范围在[0, 10)
random_integers = np.random.randint(0, 10, (2, 3))
print("随机整数数组:\n", random_integers)

  4. 设置随机种子：

    • 使用np.random.seed(seed)可以设置随机种子，以便在多次运行代码时生成相同的随机数。
    np.random.seed(42)  # 设置随机种子
seed_random = np.random.rand(3)
print("设置种子的随机数:\n", seed_random)  # 每次运行都会得到相同的输出

6. 切片和索引

6-1 基本切片与索引

切片和索引是NumPy数组处理的基础，可以方便地访问和修改数组中的元素。

6-1-1 一维、二维和多维数组的索引

  1. 一维数组的索引：

    • 一维数组使用单个索引值访问元素。
    import numpy as np

one_d_array = np.array([10, 20, 30, 40, 50])
print("一维数组:", one_d_array)

# 访问第一个元素
print("第一个元素:", one_d_array[0])  # 输出: 10

# 访问最后一个元素
print("最后一个元素:", one_d_array[-1])  # 输出: 50

  2. 二维数组的索引：

    • 二维数组使用两个索引值访问元素，第一个索引表示行，第二个索引表示列。
    two_d_array = np.array([[1, 2, 3], [4, 5, 6]])
print("二维数组:\n", two_d_array)

# 访问第一行第二列的元素
print("第一行第二列的元素:", two_d_array[0, 1])  # 输出: 2

# 访问第二行第三列的元素
print("第二行第三列的元素:", two_d_array[1, 2])  # 输出: 6

  3. 多维数组的索引：

    • 多维数组的索引方法与二维数组相似，只是增加了更多的索引。
    three_d_array = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("三维数组:\n", three_d_array)

# 访问第一组第二行第一列的元素
print("第一组第二行第一列的元素:", three_d_array[0, 1, 0])  # 输出: 3

6-2 高级切片

高级切片提供了更多灵活的方式来选择和操作数组元素。

6-2-1 布尔索引

布尔索引使用条件表达式生成布尔数组，从而选择满足条件的元素。

# 创建一个数组
data = np.array([10, 20, 30, 40, 50])

# 使用布尔条件选择元素
condition = data > 25
print("满足条件(data > 25):", condition)  # 输出: [False False  True  True  True]

# 使用布尔索引选择元素
filtered_data = data[condition]
print("选择的元素:", filtered_data)  # 输出: [30 40 50]

# 直接在选择中使用条件
filtered_data_direct = data[data < 30]
print("直接使用条件选择的元素:", filtered_data_direct)  # 输出: [10 20]

6-2-2 花式索引（Fancy Indexing）

花式索引允许通过整数数组选择数组中的特定元素。

# 创建一个数组
arr = np.array([10, 20, 30, 40, 50])

# 使用整数数组进行花式索引
indices = np.array([0, 2, 4])  # 选择第0、2、4个元素
fancy_indexed_array = arr[indices]
print("花式索引结果:", fancy_indexed_array)  # 输出: [10 30 50]

# 对于二维数组的花式索引
two_d_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
row_indices = np.array([0, 2])  # 选择第0行和第2行
col_indices = np.array([1, 1])  # 选择第1列
fancy_indexed_2d = two_d_array[row_indices, col_indices]
print("二维数组的花式索引结果:", fancy_indexed_2d)  # 输出: [2 8]

6-3 练习

import numpy as np

# 创建一维数组
one_d_array = np.array([10, 20, 30, 40, 50])
print("一维数组:", one_d_array)
print("第一个元素:", one_d_array[0])  # 访问第一个元素
print("最后一个元素:", one_d_array[-1])  # 访问最后一个元素

# 创建二维数组
two_d_array = np.array([[1, 2, 3], [4, 5, 6]])
print("\n二维数组:\n", two_d_array)
print("第一行第二列的元素:", two_d_array[0, 1])  # 访问元素

# 创建三维数组
three_d_array = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("\n三维数组:\n", three_d_array)
print("第一组第二行第一列的元素:", three_d_array[0, 1, 0])  # 访问元素

# 布尔索引示例
data = np.array([10, 20, 30, 40, 50])
print("\n布尔索引结果:", data[data > 25])  # 选择满足条件的元素

# 花式索引示例
arr = np.array([10, 20, 30, 40, 50])
indices = np.array([0, 2, 4])  # 选择第0、2、4个元素
print("\n花式索引结果:", arr[indices])  # 输出: [10 30 50]

# 二维数组的花式索引
two_d_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
row_indices = np.array([0, 2])  # 选择第0行和第2行
col_indices = np.array([1, 1])  # 选择第1列
print("二维数组的花式索引结果:", two_d_array[row_indices, col_indices])  # 输出: [2 8]

7. 高级索引

7-1 使用切片与索引获取子数组

高级索引允许用户更灵活地选择数组的特定部分。可以使用切片和多个索引来获取子数组。

  1. 获取一维数组的子数组：

    • 可以通过切片语法（start:stop:step）选择一维数组的一部分。
    import numpy as np

one_d_array = np.array([10, 20, 30, 40, 50])
sub_array = one_d_array[1:4]  # 获取从索引1到索引4（不包括4）的子数组
print("一维数组的子数组:", sub_array)  # 输出: [20 30 40]

  2. 获取二维数组的子数组：

    • 对于二维数组，可以指定行和列的切片。
    two_d_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
sub_array_2d = two_d_array[0:2, 1:3]  # 获取前两行和第二、第三列的子数组
print("二维数组的子数组:\n", sub_array_2d)

7-2 修改子数组的值

可以直接通过索引访问并修改子数组的值。这会影响原始数组，因为NumPy数组在切片时返回的是对原数组的视图，而不是副本。

# 创建一个二维数组
original_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("原始数组:\n", original_array)

# 获取子数组并修改其值
sub_array = original_array[1:3, 0:2]  # 获取子数组
print("子数组:\n", sub_array)

# 修改子数组的值
sub_array[0, 0] = 99
print("修改后的子数组:\n", sub_array)
print("修改后原始数组:\n", original_array)  # 原始数组也随之修改

7-3 复杂数据选择与操作

复杂数据选择包括使用布尔索引和花式索引等方法，可以选择特定元素或条件下的多个元素。

  1. 使用布尔索引选择特定元素：

    • 通过条件表达式选择数组中的元素。
    data = np.array([1, 2, 3, 4, 5, 6])
condition = data % 2 == 0  # 条件选择偶数
even_numbers = data[condition]
print("选择的偶数:", even_numbers)  # 输出: [2 4 6]

  2. 使用花式索引选择特定行或列：

    • 使用整数数组选择特定的行和列。
    two_d_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
row_indices = np.array([0, 2])  # 选择第一行和第三行
selected_rows = two_d_array[row_indices]
print("选择的行:\n", selected_rows)

  3. 综合使用切片和布尔索引：

    • 可以将切片与布尔索引结合起来，选择特定的子集。
    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 选择大于5的元素并获取其行和列
result = arr[arr > 5]
print("选择的元素（大于5）:", result)  # 输出: [6 7 8 9]

7-4 练习

以下是一个练习代码块，回顾并实践上述知识点：

import numpy as np

# 创建一个3x3的二维数组
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("原始数组:\n", array)

# 7-1: 使用切片获取子数组
sub_array = array[0:2, 1:3]  # 获取前两行的第二、第三列
print("\n子数组:\n", sub_array)

# 7-2: 修改子数组的值
sub_array[0, 0] = 99
print("\n修改后的子数组:\n", sub_array)
print("修改后原始数组:\n", array)  # 原始数组的值也会随之变化

# 7-3: 使用布尔索引选择特定元素
bool_condition = array > 5
selected_elements = array[bool_condition]
print("\n选择的元素（大于5）:", selected_elements)

# 7-3: 使用花式索引选择特定行
row_indices = np.array([0, 2])
selected_rows = array[row_indices]
print("\n选择的行:\n", selected_rows)

# 7-3: 综合使用切片和布尔索引
result = array[array < 5]
print("\n选择的元素（小于5）:", result)  # 输出: [1 2 3 4]

8. 数组运算

8-1 数组的基本运算

NumPy提供了对数组的基本运算，包括加、减、乘、除等操作，所有这些运算都是元素级的，即每个操作都应用于数组中的相应元素。

8-1-1 加减乘除操作

  1. 加法：

    • 对两个数组执行元素相加操作。
    import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
sum_array = a + b
print("加法结果:", sum_array)  # 输出: [5 7 9]

  2. 减法：

    • 对两个数组执行元素相减操作。
    difference_array = b - a
print("减法结果:", difference_array)  # 输出: [3 3 3]

  3. 乘法：

    • 对两个数组执行元素相乘操作。
    product_array = a * b
print("乘法结果:", product_array)  # 输出: [4 10 18]

  4. 除法：

    • 对两个数组执行元素相除操作。
    division_array = b / a
print("除法结果:", division_array)  # 输出: [4.  2.5 2. ]

  5. 标量运算：

    • NumPy数组也可以与标量进行运算，标量将应用于数组中的每个元素。
    scalar_add = a + 10
print("与标量相加:", scalar_add)  # 输出: [11 12 13]

8-2 广播机制（Broadcasting）

广播机制是NumPy的一个重要特性，它允许不同形状的数组之间进行运算。小数组会被“广播”到大数组的形状以进行元素级运算。

8-2-1 广播的原理与应用示例

  1. 广播的原理：

    • 当两个数组的形状不同时，NumPy会按照一定的规则来扩展小数组的形状，使其与大数组的形状一致。这种扩展不会占用额外的内存。

  2. 广播示例：

    • 例如，一个1维数组与一个2维数组相加：
    a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([10, 20, 30])  # 1维数组

# b会被广播到与a相同的形状
result_broadcast = a + b
print("广播加法结果:\n", result_broadcast)
# 输出:
# [[11 22 33]
#  [14 25 36]]

  3. 不同形状的数组相加：

    • 广播也适用于不同维度的数组。例如：
    c = np.array([[1], [2], [3]])  # 形状为(3, 1)
result_broadcast_2 = a + c
print("不同形状广播加法结果:\n", result_broadcast_2)
# 输出:
# [[ 2  3  4]
#  [ 6  7  8]
#  [ 9 10 11]]

8-3 数组的聚合操作

NumPy提供了一系列聚合函数，用于对数组进行统计计算，例如求和、平均值、最小值和最大值等。

8-3-1 sum、mean、min、max等函数的使用

  1. sum()函数：

    • 计算数组元素的总和。
    total_sum = np.sum(a)
print("总和:", total_sum)  # 输出: 6

  2. mean()函数：

    • 计算数组元素的平均值。
    average = np.mean(a)
print("平均值:", average)  # 输出: 2.0

  3. min()和max()函数：

    • 计算数组元素的最小值和最大值。
    minimum = np.min(a)
maximum = np.max(a)
print("最小值:", minimum)  # 输出: 1
print("最大值:", maximum)  # 输出: 3

  4. 沿特定轴的聚合：

    • 可以指定轴（axis）进行聚合操作，例如对二维数组进行行或列的求和。
    two_d_array = np.array([[1, 2, 3], [4, 5, 6]])
sum_axis0 = np.sum(two_d_array, axis=0)  # 沿着列求和
sum_axis1 = np.sum(two_d_array, axis=1)  # 沿着行求和
print("按列求和:", sum_axis0)  # 输出: [5 7 9]
print("按行求和:", sum_axis1)  # 输出: [ 6 15]

8-4 练习

以下是一个练习代码块，回顾并实践上述知识点：

import numpy as np

# 8-1: 数组的基本运算
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print("a + b:", a + b)  # 加法
print("b - a:", b - a)  # 减法
print("a * b:", a * b)  # 乘法
print("b / a:", b / a)  # 除法

# 8-2: 广播机制
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([10, 20, 30])  # 1维数组
broadcast_result = c + d
print("\n广播加法结果:\n", broadcast_result)

# 8-3: 聚合操作
total_sum = np.sum(c)
average = np.mean(c)
minimum = np.min(c)
maximum = np.max(c)
print("\n聚合操作:")
print("总和:", total_sum)
print("平均值:", average)
print("最小值:", minimum)
print("最大值:", maximum)

# 按行和按列的求和
sum_axis0 = np.sum(c, axis=0)
sum_axis1 = np.sum(c, axis=1)
print("按列求和:", sum_axis0)  # 输出: [5 7 9]
print("按行求和:", sum_axis1)  # 输出: [ 6 15]

9. 数组操作

9-1 数组的拼接与分割

NumPy提供了多种方法来拼接（连接）和分割数组，以便进行更复杂的数据操作。

9-1-1 vstack、hstack、dstack、concatenate

  1. 使用vstack()进行垂直拼接：

    • vstack()将多个数组沿垂直方向（行）拼接，前提是它们的列数相同。
    import numpy as np

arr1 = np.array([[1, 2, 3], [4, 5, 6]])  # 2行3列
arr2 = np.array([[7, 8, 9]])              # 1行3列
vertical_stack = np.vstack((arr1, arr2))
print("垂直拼接结果:\n", vertical_stack)
# 输出:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

  2. 使用hstack()进行水平拼接：

    • hstack()将多个数组沿水平方向（列）拼接，前提是它们的行数相同。
    arr3 = np.array([[10, 11, 12], [13, 14, 15]])  # 2行3列
horizontal_stack = np.hstack((arr1, arr3))  # 水平拼接
print("水平拼接结果:\n", horizontal_stack)
# 输出:
# [[ 1  2  3 10 11 12]
#  [ 4  5  6 13 14 15]]

  3. 使用dstack()进行深度拼接：

    • dstack()将多个数组沿第三个维度（深度）拼接，适用于三维数组。
    arr4 = np.array([[1, 2, 3], [4, 5, 6]])
depth_stack = np.dstack((arr4, arr4))
print("深度拼接结果:\n", depth_stack)
# 输出:
# [[[1 1]
#   [2 2]
#   [3 3]]
#
#  [[4 4]
#   [5 5]
#   [6 6]]]

  4. 使用concatenate()进行拼接：

    • concatenate()可以沿任意指定的轴拼接数组。
    arr5 = np.array([[1, 2, 3], [4, 5, 6]])
arr6 = np.array([[7, 8, 9]])
concat_result = np.concatenate((arr5, arr6), axis=0)  # 沿着行拼接
print("拼接结果（axis=0）:\n", concat_result)
# 输出:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

9-2 数组的重塑（reshape）

重塑数组是指改变数组的形状，但保持数据的顺序不变。使用reshape()方法可以实现这一点。

# 创建一个一维数组
arr = np.arange(12)  # 创建一个包含12个元素的数组
print("原始数组:", arr)

# 使用reshape将其转换为二维数组
reshaped_array = arr.reshape(4, 3)  # 变为4行3列
print("重塑后的数组:\n", reshaped_array)

注意：重塑时，数组的总元素数量必须保持不变。

9-3 数组的复制与视图

NumPy提供了两种方式来处理数组的引用：复制和视图。理解它们之间的区别非常重要，以避免不必要的错误。

9-3-1 copy与view的区别及使用场景

  1. copy()方法：

    • 创建数组的独立副本。对副本的修改不会影响原始数组。
    original_array = np.array([1, 2, 3])
copied_array = original_array.copy()
copied_array[0] = 99  # 修改副本
print("副本修改后:", copied_array)  # 输出: [99  2  3]
print("原始数组未变:", original_array)  # 输出: [1 2 3]

  2. 视图（View）：

    • 创建原始数组的视图，任何对视图的修改都会影响原始数组。
    view_array = original_array[1:3]  # 创建视图
view_array[0] = 100  # 修改视图
print("视图修改后:", view_array)  # 输出: [100  3]
print("原始数组受影响:", original_array)  # 输出: [1 100 3]

  3. 使用场景：

    • 当需要独立操作数组内容而不影响原始数组时，使用copy()。
    • 当希望对数组进行修改且希望原数组也相应更新时，使用视图。

9-4 练习

以下是一个练习代码块，回顾并实践上述知识点：

import numpy as np

# 9-1: 数组的拼接
arr1 = np.array([[1, 2, 3], [4, 5, 6]])  # 2行3列
arr2 = np.array([[7, 8, 9]])              # 1行3列

# 使用vstack进行垂直拼接
vertical_stack = np.vstack((arr1, arr2))
print("垂直拼接结果:\n", vertical_stack)

# 创建arr3，确保它与arr1有相同的行数
arr3 = np.array([[10, 11, 12], [13, 14, 15]])  # 2行3列

# 水平拼接
horizontal_stack = np.hstack((arr1, arr3))  # 水平拼接
print("水平拼接结果:\n", horizontal_stack)

# 9-2: 数组的重塑
arr4 = np.arange(12)
reshaped_array = arr4.reshape(4, 3)
print("\n重塑后的数组:\n", reshaped_array)

# 9-3: 数组的复制与视图
original_array = np.array([1, 2, 3, 4, 5])
copied_array = original_array.copy()
view_array = original_array[1:4]  # 视图
view_array[0] = 99  # 修改视图
print("\n原始数组:", original_array)  # 应受影响
print("副本未受影响:", copied_array)  # 应保持不变

# 确保结果
print("\n视图:", view_array)  # 输出: [99 3 4]
print("原始数组:", original_array)  # 输出: [ 1 99  3  4  5]

10. 数学函数

10-1 NumPy数学函数概述

NumPy提供了丰富的数学函数，可以用于对数组执行各种数学运算。这些函数通常都是元素级的，即它们会对数组中的每个元素进行操作，返回一个新的数组。

注意： 使用数学函数时，确保输入数组的元素类型适合所执行的数学操作。例如，对于对数和平方根等函数，输入值必须是非负数。

10-2 常用数学函数

NumPy中常用的数学函数包括三角函数、指数函数和对数函数等。

10-2-1 sin、cos、exp、log等

  1. 三角函数：

    • np.sin()、np.cos()和np.tan()分别计算正弦、余弦和正切值。输入值通常是弧度。
    import numpy as np

angles = np.array([0, np.pi/2, np.pi])  # 0, 90, 180度
sin_values = np.sin(angles)
cos_values = np.cos(angles)
print("正弦值:", sin_values)  # 输出: [0. 1. 0.]
print("余弦值:", cos_values)  # 输出: [ 1. 0. -1.]

  2. 指数函数：

    • np.exp()计算以e为底的指数。
    x = np.array([0, 1, 2])
exp_values = np.exp(x)
print("指数值:", exp_values)  # 输出: [1.         2.71828183 7.3890561 ]

  3. 对数函数：

    • np.log()计算自然对数，np.log10()计算以10为底的对数。
    y = np.array([1, np.e, 10])
log_values = np.log(y)
log10_values = np.log10(y)
print("自然对数值:", log_values)  # 输出: [0. 1. 2.30258509]
print("以10为底的对数值:", log10_values)  # 输出: [0. 0.43429448 1. ]

10-3 应用示例

以下是一个综合示例，展示如何使用NumPy的数学函数进行实际的计算。

import numpy as np
import matplotlib
matplotlib.use('TkAgg')  # 确保使用合适的后端
import matplotlib.pyplot as plt

# 生成数据
x = np.linspace(0, 2 * np.pi, 100)  # 生成从0到2π的100个点
y_sin = np.sin(x)                    # 计算正弦值
y_cos = np.cos(x)                    # 计算余弦值
y_exp = np.exp(x)                    # 计算指数值
y_log = np.log(x + 1e-10)            # 计算自然对数（避免对0取对数）

# 绘制结果
plt.figure(figsize=(12, 8))

plt.subplot(2, 2, 1)
plt.plot(x, y_sin, label='sin(x)')
plt.title('正弦函数')
plt.xlabel('x (弧度)')
plt.ylabel('sin(x)')
plt.grid()
plt.legend()

plt.subplot(2, 2, 2)
plt.plot(x, y_cos, label='cos(x)', color='orange')
plt.title('余弦函数')
plt.xlabel('x (弧度)')
plt.ylabel('cos(x)')
plt.grid()
plt.legend()

plt.subplot(2, 2, 3)
plt.plot(x, y_exp, label='exp(x)', color='green')
plt.title('指数函数')
plt.xlabel('x')
plt.ylabel('exp(x)')
plt.grid()
plt.legend()

plt.subplot(2, 2, 4)
plt.plot(x, y_log, label='log(x)', color='red')
plt.title('对数函数')
plt.xlabel('x')
plt.ylabel('log(x)')
plt.grid()
plt.legend()

plt.tight_layout()
plt.show()  # 显示图形

注意： 在计算对数时，确保输入值为正数，以避免出现无效的计算（例如对0取对数）。

image-20241104145419593

10-4 练习

以下是一个练习代码块，回顾并实践上述知识点：

import numpy as np

# 创建一个数组
angles = np.array([0, np.pi/6, np.pi/4, np.pi/3, np.pi/2])

# 计算正弦和余弦
sin_values = np.sin(angles)
cos_values = np.cos(angles)
print("角度:", angles)
print("正弦值:", sin_values)
print("余弦值:", cos_values)

# 计算指数和对数
x = np.array([1, 2, 3, 4, 5])
exp_values = np.exp(x)
log_values = np.log(x)
print("\n指数值:", exp_values)
print("对数值:", log_values)

image-20241104145338287

11. 统计函数

11-1 统计函数概述

NumPy提供了一系列统计函数，可以帮助用户对数组数据进行统计分析。这些函数可以用于计算均值、中位数、标准差、方差等，从而为数据分析提供重要的信息。

11-2 描述性统计

描述性统计是对数据集进行总结的统计分析，主要包括集中趋势和离散程度的度量。

11-2-1 mean、median、std、var等

  1. 均值（mean）：

    • np.mean()用于计算数组元素的平均值。
    import numpy as np

data = np.array([1, 2, 3, 4, 5])
mean_value = np.mean(data)
print("均值:", mean_value)  # 输出: 3.0

  2. 中位数（median）：

    • np.median()用于计算数组元素的中位数。
    median_value = np.median(data)
print("中位数:", median_value)  # 输出: 3.0

  3. 标准差（std）：

    • np.std()用于计算数组元素的标准差，表示数据的离散程度。
    std_value = np.std(data)
print("标准差:", std_value)  # 输出: 1.4142135623730951

  4. 方差（var）：

    • np.var()用于计算数组元素的方差。
    var_value = np.var(data)
print("方差:", var_value)  # 输出: 2.0

11-3 统计分析实例

下面是一个实际的统计分析示例，展示如何使用NumPy的统计函数对数据进行分析。

import numpy as np
import matplotlib.pyplot as plt

# 生成随机数据
data = np.random.normal(loc=0, scale=1, size=1000)  # 生成1000个正态分布的随机数

# 计算统计量
mean_value = np.mean(data)
median_value = np.median(data)
std_value = np.std(data)
var_value = np.var(data)

print("数据的统计量:")
print("均值:", mean_value)
print("中位数:", median_value)
print("标准差:", std_value)
print("方差:", var_value)

# 绘制直方图
plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, alpha=0.7, color='blue', edgecolor='black')
plt.axvline(mean_value, color='red', linestyle='dashed', linewidth=1, label='均值')
plt.axvline(median_value, color='yellow', linestyle='dashed', linewidth=1, label='中位数')
plt.title('正态分布随机数的直方图')
plt.xlabel('值')
plt.ylabel('频率')
plt.legend()
plt.grid()
plt.show()

注意： 使用统计函数时，确保对数据的特性有足够的了解，以便更好地解释结果。

11-4 练习

以下是一个练习代码块，回顾并实践上述统计函数的知识点：

import numpy as np

# 创建一个包含随机数的数组
data = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])

# 计算统计量
mean_value = np.mean(data)
median_value = np.median(data)
std_value = np.std(data)
var_value = np.var(data)

print("统计量:")
print("均值:", mean_value)
print("中位数:", median_value)
print("标准差:", std_value)
print("方差:", var_value)

image-20241104145540644

12. 排序与选择

12-1 数组的排序

NumPy提供了多种排序功能，可以对数组进行排序操作。

12-1-1 sort与argsort的使用

  1. 使用sort()进行排序：

    • np.sort()可以对数组进行排序，返回排序后的新数组。
    import numpy as np

arr = np.array([3, 1, 2, 5, 4])
sorted_array = np.sort(arr)  # 对数组进行排序
print("排序后的数组:", sorted_array)  # 输出: [1 2 3 4 5]
    • 注意：sort()返回的是新数组，原始数组不变。如果想就地排序，可以使用sort()方法：
    arr.sort()  # 对原数组进行就地排序
print("原数组经过就地排序:", arr)  # 输出: [1 2 3 4 5]

  2. 使用argsort()获取排序索引：

    • np.argsort()返回排序后元素的索引，这可以用于获取排序的顺序。
    arr = np.array([3, 1, 2, 5, 4])
sorted_indices = np.argsort(arr)  # 获取排序后的索引
print("排序索引:", sorted_indices)  # 输出: [1 2 0 4 3]

# 可以使用这些索引对原数组进行排序
sorted_by_index = arr[sorted_indices]
print("通过索引排序的数组:", sorted_by_index)  # 输出: [1 2 3 4 5]

12-2 条件选择与过滤

NumPy支持条件选择与过滤，通过逻辑条件从数组中选择元素。

12-2-1 使用where、nonzero等函数

  1. 使用np.where()进行条件选择：

    • np.where()根据给定的条件返回满足条件的元素的索引，或者可以用来根据条件生成新数组。
    arr = np.array([10, 20, 30, 40, 50])
condition = arr > 30  # 创建条件
indices = np.where(condition)  # 获取满足条件的索引
print("满足条件的索引:", indices)  # 输出: (array([3, 4]),)

# 直接返回满足条件的元素
selected_elements = arr[condition]
print("满足条件的元素:", selected_elements)  # 输出: [40 50]

  2. 使用np.nonzero()获取非零元素的索引：

    • np.nonzero()返回数组中非零元素的索引。
    arr = np.array([0, 1, 2, 0, 3, 0, 4])
nonzero_indices = np.nonzero(arr)  # 获取非零元素的索引
print("非零元素的索引:", nonzero_indices)  # 输出: (array([1, 2, 4, 6]),)

# 使用这些索引选择非零元素
nonzero_elements = arr[nonzero_indices]
print("非零元素:", nonzero_elements)  # 输出: [1 2 3 4]

12-3 练习

以下是一个练习代码块，回顾并实践上述知识点：

import numpy as np

# 创建一个数组
arr = np.array([5, 3, 8, 1, 4])

# 12-1: 数组的排序
sorted_array = np.sort(arr)
print("排序后的数组:", sorted_array)  # 输出: [1 3 4 5 8]

# 使用argsort获取排序索引
sorted_indices = np.argsort(arr)
print("排序索引:", sorted_indices)  # 输出: [3 1 4 0 2]

# 12-2: 条件选择与过滤
# 使用where选择大于3的元素
condition = arr > 3
selected_elements = arr[condition]
print("大于3的元素:", selected_elements)  # 输出: [5 8 4]

# 使用nonzero获取非零元素的索引
nonzero_indices = np.nonzero(arr)
print("非零元素的索引:", nonzero_indices)  # 输出: (array([0, 1, 2, 3, 4]),)

image-20241104145729721

13. 字符串函数

13-1 NumPy字符串函数概述

NumPy提供了一些用于处理字符串的函数，这些函数能够高效地对字符串数组进行操作。NumPy的字符串函数通常以np.char开头，支持各种字符串操作，如连接、分割、查找、替换等。

13-2 字符串处理示例

以下是一些常用的字符串处理示例，包括字符串连接、分割和查找。

13-2-1 字符串连接、分割、查找

  1. 字符串连接：

    • 使用np.char.add()可以连接两个字符串数组。
    import numpy as np

arr1 = np.array(['Hello', 'World'])
arr2 = np.array([' NumPy', ' Tutorial'])

# 使用add进行字符串连接
concatenated = np.char.add(arr1, arr2)
print("字符串连接结果:", concatenated)  # 输出: ['Hello NumPy' 'World Tutorial']

  2. 字符串分割：

    • 使用np.char.split()可以将字符串按指定分隔符进行分割。
    arr3 = np.array(['Hello NumPy Tutorial', 'Welcome to Python'])

# 使用split进行字符串分割
split_result = np.char.split(arr3)
print("字符串分割结果:", split_result)
# 输出: [list(['Hello', 'NumPy', 'Tutorial']) list(['Welcome', 'to', 'Python'])]

  3. 字符串查找：

    • 使用np.char.find()可以查找子字符串在主字符串中的位置。如果找不到，返回-1。
    arr4 = np.array(['Hello', 'World', 'NumPy'])

# 使用find查找字符
find_result = np.char.find(arr4, 'o')
print("查找结果:", find_result)  # 输出: [4 1 -1]

  4. 字符串替换：

    • 使用np.char.replace()可以将字符串中的某个子字符串替换为另一个字符串。
    arr5 = np.array(['Hello World', 'NumPy is great'])

# 使用replace进行字符串替换
replaced_result = np.char.replace(arr5, 'World', 'NumPy')
print("替换结果:", replaced_result)  # 输出: ['Hello NumPy' 'NumPy is great']

13-3 练习

以下是一个练习代码块，回顾并实践上述字符串函数的知识点：

import numpy as np

# 创建字符串数组
strings = np.array(['apple', 'banana', 'cherry'])

# 13-1: 字符串连接
more_fruits = np.array([' and orange', ' and grape', ' and kiwi'])
connected = np.char.add(strings, more_fruits)
print("连接结果:", connected)  # 输出: ['apple and orange' 'banana and grape' 'cherry and kiwi']

# 13-2: 字符串分割
sentence = np.array(['I love Python programming.'])
split_sentence = np.char.split(sentence)
print("分割结果:", split_sentence)  # 输出: [list(['I', 'love', 'Python', 'programming.'])]

# 13-3: 字符串查找
find_result = np.char.find(strings, 'a')
print("查找结果:", find_result)  # 输出: [0 1 2]，表示'a'的位置

image-20241104145900283

14. 线性代数

14-1 线性代数基础

线性代数是数学的一个分支，主要研究向量、矩阵及其运算。在NumPy中，线性代数的功能主要集中在numpy.linalg模块中，提供了矩阵运算和线性方程求解等功能。

14-2 向量与矩阵操作

14-2-1 矩阵的乘法、转置、逆

  1. 矩阵的乘法：

    • 使用np.dot()或@操作符进行矩阵乘法。矩阵A的列数必须等于矩阵B的行数。
    import numpy as np

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

# 矩阵乘法
product = np.dot(A, B)  # 或者使用 A @ B
print("矩阵乘法结果:\n", product)
# 输出:
# [[19 22]
#  [43 50]]

  2. 矩阵的转置：

    • 使用.T属性或np.transpose()函数对矩阵进行转置。
    C = np.array([[1, 2, 3], [4, 5, 6]])

# 矩阵转置
transposed_C = C.T
print("矩阵转置结果:\n", transposed_C)
# 输出:
# [[1 4]
#  [2 5]
#  [3 6]]

  3. 矩阵的逆：

    • 使用np.linalg.inv()函数计算可逆矩阵的逆。只有方阵才能计算逆，且该矩阵必须是可逆的。
    D = np.array([[1, 2], [3, 4]])

# 计算矩阵的逆
D_inv = np.linalg.inv(D)
print("矩阵的逆:\n", D_inv)
# 输出:
# [[-2.   1. ]
#  [ 1.5 -0.5]]
    • 注意：在计算逆之前，确保矩阵是可逆的，可以通过判断行列式是否为零。
    det_D = np.linalg.det(D)
print("行列式:", det_D)  # 输出: -2.0，表示D是可逆的

14-3 特征值与特征向量的计算

特征值和特征向量是线性代数的重要概念，主要用于对矩阵进行特征分解。在NumPy中，可以使用np.linalg.eig()函数计算。

# 创建一个方阵
E = np.array([[2, 1], [1, 2]])

# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(E)
print("特征值:", eigenvalues)  # 输出: 特征值
print("特征向量:\n", eigenvectors)  # 输出: 特征向量

14-4 练习

以下是一个练习代码块，回顾并实践上述线性代数相关知识点：

import numpy as np

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

# 14-1: 矩阵乘法
product = np.dot(A, B)
print("矩阵乘法结果:\n", product)

# 14-2: 矩阵转置
transposed_A = A.T
print("矩阵A的转置:\n", transposed_A)

# 14-3: 矩阵的逆
A_inv = np.linalg.inv(A)
print("矩阵A的逆:\n", A_inv)

# 14-4: 特征值与特征向量
C = np.array([[3, 1], [1, 3]])
eigenvalues, eigenvectors = np.linalg.eig(C)
print("矩阵C的特征值:", eigenvalues)
print("矩阵C的特征向量:\n", eigenvectors)

image-20241104150027821

15. 文件输入与输出

NumPy提供了一些函数用于方便地读取和写入数组数据到文件中，支持多种文件格式，特别是文本文件和二进制文件。

15-1 从文件读取数组

15-1-1 使用loadtxt与genfromtxt

  1. 使用np.loadtxt()从文本文件读取数组：

    • np.loadtxt()用于加载文本文件的数据并返回数组。该函数适合读取格式一致的文本文件。
    import numpy as np

# 假设有一个文本文件 data.txt，内容如下：
# 1.0 2.0 3.0
# 4.0 5.0 6.0
# 7.0 8.0 9.0

# 使用loadtxt读取文件
data_array = np.loadtxt('data.txt')
print("读取的数据:\n", data_array)
# 输出:
# [[1. 2. 3.]
#  [4. 5. 6.]
#  [7. 8. 9.]]

  2. 使用np.genfromtxt()从文本文件读取数组：

    • np.genfromtxt()与loadtxt()类似，但更灵活，可以处理缺失值和不同的数据类型。
    # 假设有一个文本文件 data_with_nan.txt，内容如下：
# 1.0 2.0 3.0
# 4.0 NaN 6.0
# 7.0 8.0 9.0

# 使用genfromtxt读取文件
data_with_nan = np.genfromtxt('data_with_nan.txt', filling_values=0)  # 将NaN替换为0
print("读取的数据（处理NaN）:\n", data_with_nan)
# 输出:
# [[1. 2. 3.]
#  [4. 0. 6.]
#  [7. 8. 9.]]

15-2 保存数组到文件

15-2-1 使用savetxt与save

  1. 使用np.savetxt()将数组保存为文本文件：

    • np.savetxt()用于将数组保存为文本文件，支持自定义分隔符和格式。
    # 创建一个数组
array_to_save = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 保存数组到文本文件
np.savetxt('saved_data.txt', array_to_save, delimiter=',', fmt='%d')  # 使用逗号作为分隔符
print("数组已保存为文本文件: saved_data.txt")

  2. 使用np.save()将数组保存为二进制文件：

    • np.save()用于将数组以二进制格式保存为.npy文件。这种格式是NumPy的专用格式，读取速度更快，支持保存更多数据类型。
    # 保存数组到二进制文件
np.save('saved_array.npy', array_to_save)
print("数组已保存为二进制文件: saved_array.npy")
    • 使用np.load()可以加载保存的二进制文件。
    loaded_array = np.load('saved_array.npy')  # 加载保存的数组
print("加载的数组:\n", loaded_array)
# 输出:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

15-3 练习

以下是一个练习代码块，回顾并实践上述文件输入与输出相关知识点：

import numpy as np

# 15-1: 从文件读取数组
# 假设文件 data.txt 已经存在且格式正确
data_array = np.loadtxt('data.txt')
print("从文件读取的数据:\n", data_array)

# 15-2: 保存数组到文件
array_to_save = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])

# 保存为文本文件
np.savetxt('saved_data.txt', array_to_save, delimiter=',', fmt='%d')
print("数组已保存为文本文件: saved_data.txt")

# 保存为二进制文件
np.save('saved_array.npy', array_to_save)
print("数组已保存为二进制文件: saved_array.npy")

# 加载保存的二进制文件
loaded_array = np.load('saved_array.npy')
print("加载的数组:\n", loaded_array)

image-20241104150313471

16. 与其他库的结合

16-1 NumPy与Pandas结合使用

Pandas是基于NumPy构建的，用于数据分析和数据操作的强大工具。Pandas中的DataFrame和Series对象都基于NumPy数组，因此可以非常方便地与NumPy结合使用。

  1. 创建Pandas对象：

    • 可以使用NumPy数组创建Pandas的DataFrame和Series。
    import numpy as np
import pandas as pd

# 创建NumPy数组
data = np.array([[1, 2, 3], [4, 5, 6]])

# 使用NumPy数组创建DataFrame
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
print("DataFrame:\n", df)
# 输出:
#    A  B  C
# 0  1  2  3
# 1  4  5  6

  2. 从Pandas对象中获取NumPy数组：

    • 可以使用.values属性或.to_numpy()方法将DataFrame或Series转换为NumPy数组。
    # 从DataFrame获取NumPy数组
array_from_df = df.values
print("从DataFrame获取的NumPy数组:\n", array_from_df)

  3. 利用NumPy进行数据处理：

    • 在Pandas中，可以利用NumPy的函数进行数据处理，例如计算均值、标准差等。
    mean_values = np.mean(df, axis=0)  # 计算每列的均值
print("每列的均值:", mean_values)

16-2 NumPy与Matplotlib结合使用

Matplotlib是一个用于绘图的强大库，常与NumPy结合使用，以便将数据可视化。

  1. 使用NumPy生成数据并绘图：

    • NumPy可以生成数据，然后利用Matplotlib进行绘制。
    import numpy as np
import matplotlib
matplotlib.use('TkAgg')  # 确保使用合适的后端
import matplotlib.pyplot as plt

# 生成x数据
x = np.linspace(0, 10, 100)  # 从0到10生成100个点
y_sin = np.sin(x)  # 计算y值
y_cos = np.cos(x)  # 计算y值

# 绘制正弦和余弦函数图
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.plot(x, y_sin, label='sin(x)', color='blue')
plt.title('正弦函数')
plt.xlabel('x (弧度)')
plt.ylabel('sin(x)')
plt.grid()
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(x, y_cos, label='cos(x)', color='orange')
plt.title('余弦函数')
plt.xlabel('x (弧度)')
plt.ylabel('cos(x)')
plt.grid()
plt.legend()

plt.tight_layout()
plt.show()  # 显示图形

  2. 利用NumPy进行数据分析后绘图：

    • 可以在对数据进行分析（如求平均值）后，利用Matplotlib进行结果可视化。
    # 生成随机数据
data = np.random.randn(1000)  # 生成1000个正态分布随机数
plt.hist(data, bins=30, alpha=0.7, color='blue', edgecolor='black')
plt.title('Histogram of Random Data')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.grid()
plt.show()

16-3 NumPy与SciPy结合使用

SciPy是一个基于NumPy的科学计算库，提供了许多用于优化、插值、积分等高级数学函数。

  1. 线性代数操作：

    • SciPy提供了更高效的线性代数功能，通常用于处理NumPy数组。
    from scipy.linalg import inv

A = np.array([[1, 2], [3, 4]])
A_inv = inv(A)  # 计算矩阵的逆
print("矩阵的逆:\n", A_inv)

  2. 优化与最小化：

    • SciPy可以用于求解最优化问题，例如最小化函数。
    from scipy.optimize import minimize

# 定义一个简单的二次函数
def objective(x):
    return x**2 + 3*x + 2

result = minimize(objective, 0)  # 从0开始寻找最小值
print("优化结果:", result)

  3. 插值：

    • SciPy支持多种插值方法，可以用于数据平滑和数据填充。
    from scipy.interpolate import interp1d

x = np.array([1, 2, 3, 4])
y = np.array([1, 4, 9, 16])

# 创建插值函数
f = interp1d(x, y, kind='linear')
x_new = np.linspace(1, 4, 10)
y_new = f(x_new)

plt.plot(x, y, 'o', label='data points')
plt.plot(x_new, y_new, '-', label='linear interpolation')
plt.legend()
plt.show()

16-4 练习

以下是一个练习代码块，回顾并实践上述NumPy与其他库结合使用的相关知识点：

import numpy as np
import pandas as pd
import matplotlib
matplotlib.use('TkAgg')  # 确保使用合适的后端
import matplotlib.pyplot as plt
from scipy import stats

# 16-1: NumPy与Pandas结合使用
data = np.array([[1, 2, 3], [4, 5, 6]])
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
print("DataFrame:\n", df)

# 16-2: NumPy与Matplotlib结合使用
x = np.linspace(0, 10, 100)
y = np.cos(x)
plt.plot(x, y, label='cos(x)')
plt.title('Cosine Function')
plt.xlabel('x')
plt.ylabel('cos(x)')
plt.grid()
plt.legend()
plt.show()

# 16-3: NumPy与SciPy结合使用
# 使用SciPy进行正态分布的概率密度函数计算
mu, sigma = 0, 1  # 均值和标准差
s = np.random.normal(mu, sigma, 1000)  # 生成1000个样本
count, bins, ignored = plt.hist(s, 30, density=True)
plt.show()

# 计算并绘制正态分布的概率密度函数
pdf = stats.norm.pdf(bins, mu, sigma)
plt.plot(bins, pdf, 'r-', label='Normal Distribution')
plt.legend()
plt.show()

image-20241104150645138

17. NumPy的性能优化

17-1 使用NumPy优化性能的技巧

NumPy通过以下方式优化性能，使得数值计算更加高效：

  1. 使用矢量化操作：

    • 矢量化操作是指对整个数组进行操作，而不是使用循环。这样可以显著提高性能，因为NumPy底层实现使用了C语言进行优化。
    import numpy as np

# 创建两个大数组
a = np.random.rand(1000000)
b = np.random.rand(1000000)

# 矢量化操作
c = a + b  # 数组加法

  2. 避免使用Python循环：

    • 尽量避免在处理大数组时使用Python循环，而是使用NumPy提供的函数和方法，这样可以减少开销。
    # 不推荐的做法
result = []
for i in range(len(a)):
    result.append(a[i] + b[i])  # 使用循环

  3. 使用广播机制：

    • 广播允许不同形状的数组之间进行运算，而无需显式地重复数组的内容。这可以节省内存并提高计算效率。
    # 示例：将一个标量加到数组上
a = np.array([1, 2, 3])
b = 5
result = a + b  # 广播

  4. 合理选择数据类型：

    • 根据需要选择适当的数据类型可以减少内存消耗，提高计算效率。例如，使用float32而不是float64，如果不需要高精度。
    # 使用float32减少内存
a = np.array([1.0, 2.0, 3.0], dtype=np.float32)

  5. 利用NumPy内置函数：

    • NumPy提供了许多经过优化的内置函数，可以避免手动实现相同的功能。使用这些函数通常会比自定义实现更快。
    # 使用NumPy的内置函数
sum_value = np.sum(a)  # 计算数组的总和

17-2 使用NumPy进行大数据分析的优势

NumPy在进行大数据分析时具有多种优势：

  1. 高效的数组存储：

    • NumPy数组在内存中是连续存储的，这使得其比Python列表更紧凑，能够更有效地利用内存。

  2. 快速的数组操作：

    • NumPy使用C和Fortran编写的底层实现，能够执行快速的数组运算，大大提高了数据处理速度。

  3. 强大的数学运算能力：

    • NumPy提供了丰富的数学和统计函数，可以对大型数据集进行复杂的计算和分析。

  4. 与其他科学计算库的兼容性：

    • NumPy是许多其他科学计算库（如Pandas、SciPy、Matplotlib）的基础，便于在数据分析中使用多个库。

  5. 并行处理能力：

    • NumPy可以通过多线程和并行计算来加速数据处理过程，特别是在处理大规模数据时。

17-3 练习

以下是一个练习代码块，回顾并实践上述NumPy性能优化的相关知识点：

import numpy as np

# 17-1: 使用矢量化操作
# 创建大数组
a = np.random.rand(1000000)
b = np.random.rand(1000000)

# 矢量化加法
c = a + b

# 17-2: 使用广播机制
x = np.array([1, 2, 3])
y = 5
result = x + y  # 广播操作
print("广播结果:", result)  # 输出: [6 7 8]

# 17-3: 使用NumPy内置函数
mean_value = np.mean(a)  # 计算均值
print("数组的均值:", mean_value)

image-20241104150759078

18. 实际案例分析

18-1 数据预处理与清洗

我们将创建一个包含销售数据的Pandas DataFrame，并执行数据预处理和清洗操作。

import numpy as np
import pandas as pd
import matplotlib

# 在导入pyplot之前设置后端
matplotlib.use('TkAgg')  # 或者 'Qt5Agg'
import seaborn as sns
import matplotlib.pyplot as plt


# 创建示例数据集
data = {
    'Product': ['A', 'B', 'C', 'A', 'B', 'C', 'A', None, 'B'],
    'Sales': [250, 150, np.nan, 300, 200, np.nan, 350, 400, 450],
    'Profit': [50, 30, 10, 70, 20, 5, np.nan, 80, 90],
    'Quantity': [10, 5, 2, 15, 7, np.nan, 20, 25, 30]
}

df = pd.DataFrame(data)

print("原始数据:\n", df)

# 1. 检查缺失值
print("\n缺失值统计:\n", df.isnull().sum())

# 2. 填充缺失值
df['Sales'] = df['Sales'].fillna(df['Sales'].mean())  # 用平均值填充销售额
df['Profit'] = df['Profit'].fillna(df['Profit'].mean())  # 用平均值填充利润
df['Quantity'] = df['Quantity'].fillna(df['Quantity'].median())  # 用中位数填充数量
df['Product'] = df['Product'].fillna('Unknown')  # 用'Unknown'填充缺失的产品名

print("\n处理缺失值后的数据:\n", df)

18-2 数据可视化示例

在数据清洗完成后，我们可以使用Matplotlib进行数据可视化，以帮助更好地理解数据的特征和趋势。

plt.figure(figsize=(12, 6))
sns.scatterplot(x='Sales', y='Profit', hue='Product', data=df)
plt.title('Sales vs Profit by Product')
plt.xlabel('Sales')
plt.ylabel('Profit')
plt.grid()
plt.show()

# 2. 各产品的销售额条形图
plt.figure(figsize=(12, 6))
sns.barplot(x='Product', y='Sales', data=df, estimator=np.sum, palette='viridis')
plt.title('Total Sales by Product')
plt.xlabel('Product')
plt.ylabel('Total Sales')
plt.grid()
plt.show()

# 3. 销售数量的箱型图
plt.figure(figsize=(12, 6))
sns.boxplot(x='Product', y='Quantity', data=df)
plt.title('Quantity Distribution by Product')
plt.xlabel('Product')
plt.ylabel('Quantity')
plt.grid()
plt.show()

18-3 使用NumPy进行统计分析的实际案例

在这一部分，我们将使用NumPy进行更深入的统计分析，计算相关系数，标准差和利润率等。

### 18-3 使用NumPy进行统计分析的实际案例

# 将数据转换为NumPy数组进行分析
sales = df['Sales'].to_numpy()
profit = df['Profit'].to_numpy()
quantity = df['Quantity'].to_numpy()

# 1. 计算均值和标准差
mean_sales = np.mean(sales)
std_sales = np.std(sales)

print("\n销售额的均值:", mean_sales)
print("销售额的标准差:", std_sales)

# 2. 计算利润率
profit_margin = profit / sales
print("\n利润率:\n", profit_margin)

# 3. 计算相关系数
correlation = np.corrcoef(sales, profit)[0, 1]
print("\n销售额与利润的相关系数:", correlation)

# 4. 计算总销售额和总利润
total_sales = np.sum(sales)
total_profit = np.sum(profit)
print("\n总销售额:", total_sales)
print("总利润:", total_profit)

# 5. 绘制利润率的直方图
plt.figure(figsize=(10, 5))
plt.hist(profit_margin, bins=20, alpha=0.7, color='blue', edgecolor='black')
plt.title('Profit Margin Distribution')
plt.xlabel('Profit Margin')
plt.ylabel('Frequency')
plt.grid()
plt.show()

18-4 完整的代码

import numpy as np
import pandas as pd
import matplotlib

# 在导入pyplot之前设置后端
matplotlib.use('TkAgg')  # 或者 'Qt5Agg'
import seaborn as sns
import matplotlib.pyplot as plt


# 创建示例数据集
data = {
    'Product': ['A', 'B', 'C', 'A', 'B', 'C', 'A', None, 'B'],
    'Sales': [250, 150, np.nan, 300, 200, np.nan, 350, 400, 450],
    'Profit': [50, 30, 10, 70, 20, 5, np.nan, 80, 90],
    'Quantity': [10, 5, 2, 15, 7, np.nan, 20, 25, 30]
}

df = pd.DataFrame(data)

print("原始数据:\n", df)

# 1. 检查缺失值
print("\n缺失值统计:\n", df.isnull().sum())

# 2. 填充缺失值
df['Sales'] = df['Sales'].fillna(df['Sales'].mean())  # 用平均值填充销售额
df['Profit'] = df['Profit'].fillna(df['Profit'].mean())  # 用平均值填充利润
df['Quantity'] = df['Quantity'].fillna(df['Quantity'].median())  # 用中位数填充数量
df['Product'] = df['Product'].fillna('Unknown')  # 用'Unknown'填充缺失的产品名

print("\n处理缺失值后的数据:\n", df)

# 3. 删除重复值
df = df.drop_duplicates()
print("\n删除重复值后的数据:\n", df)

# 4. 确保数据类型一致
df['Sales'] = df['Sales'].astype(float)
df['Profit'] = df['Profit'].astype(float)
df['Quantity'] = df['Quantity'].astype(int)

print("\n数据类型处理后的数据:\n", df.dtypes)

### 18-2 数据可视化示例

# 1. 销售额和利润的散点图
plt.figure(figsize=(12, 6))
sns.scatterplot(x='Sales', y='Profit', hue='Product', data=df)
plt.title('Sales vs Profit by Product')
plt.xlabel('Sales')
plt.ylabel('Profit')
plt.grid()
plt.show()

# 2. 各产品的销售额条形图
plt.figure(figsize=(12, 6))
sns.barplot(x='Product', y='Sales', data=df, estimator=np.sum, palette='viridis')
plt.title('Total Sales by Product')
plt.xlabel('Product')
plt.ylabel('Total Sales')
plt.grid()
plt.show()

# 3. 销售数量的箱型图
plt.figure(figsize=(12, 6))
sns.boxplot(x='Product', y='Quantity', data=df)
plt.title('Quantity Distribution by Product')
plt.xlabel('Product')
plt.ylabel('Quantity')
plt.grid()
plt.show()

### 18-3 使用NumPy进行统计分析的实际案例

# 将数据转换为NumPy数组进行分析
sales = df['Sales'].to_numpy()
profit = df['Profit'].to_numpy()
quantity = df['Quantity'].to_numpy()

# 1. 计算均值和标准差
mean_sales = np.mean(sales)
std_sales = np.std(sales)

print("\n销售额的均值:", mean_sales)
print("销售额的标准差:", std_sales)

# 2. 计算利润率
profit_margin = profit / sales
print("\n利润率:\n", profit_margin)

# 3. 计算相关系数
correlation = np.corrcoef(sales, profit)[0, 1]
print("\n销售额与利润的相关系数:", correlation)

# 4. 计算总销售额和总利润
total_sales = np.sum(sales)
total_profit = np.sum(profit)
print("\n总销售额:", total_sales)
print("总利润:", total_profit)

# 5. 绘制利润率的直方图
plt.figure(figsize=(10, 5))
plt.hist(profit_margin, bins=20, alpha=0.7, color='blue', edgecolor='black')
plt.title('Profit Margin Distribution')
plt.xlabel('Profit Margin')
plt.ylabel('Frequency')
plt.grid()
plt.show()

19-练习题

1. 实现K-Means聚类算法

题目: 实现K-Means聚类算法，对一组随机生成的二维数据进行聚类，并可视化结果。

思路:

  • 随机生成数据点。
  • 随机初始化聚类中心。
  • 迭代分配数据点到最近的聚类中心，并更新聚类中心，直到收敛。
import numpy as np
import matplotlib
matplotlib.use('TkAgg')  # 或者 'Qt5Agg'
import matplotlib.pyplot as plt

# 生成随机数据
np.random.seed(0)
X = np.random.rand(300, 2)


# K-Means算法
def kmeans(X, k, max_iters=100):
	# 随机初始化聚类中心
	centroids = X[np.random.choice(X.shape[0], k, replace=False)]

	for _ in range(max_iters):
		# 计算距离
		distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
		# 分配每个点到最近的聚类中心
		labels = np.argmin(distances, axis=1)
		# 更新聚类中心
		new_centroids = np.array([X[labels == i].mean(axis=0) for i in range(k)])
		# 如果中心不再变化，退出循环
		if np.all(centroids == new_centroids):
			break
		centroids = new_centroids

	return labels, centroids


# 运行K-Means
k = 3
labels, centroids = kmeans(X, k)

# 可视化结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', s=50)
plt.scatter(centroids[:, 0], centroids[:, 1], c='red', s=200, alpha=0.75)
plt.title('K-Means聚类结果')
plt.show()

代码解释:

  • 使用随机数生成300个二维数据点。
  • kmeans函数实现K-Means聚类，分配点到最近的聚类中心并更新中心位置。
  • 最后可视化聚类结果。

image-20241104152126707

2. 主成分分析（PCA）

题目: 使用NumPy实现主成分分析（PCA）来降维。

思路:

  • 生成随机数据。
  • 标准化数据，计算协方差矩阵。
  • 计算特征值和特征向量，选择主成分。
import numpy as np
import matplotlib
matplotlib.use('TkAgg')  # 或者 'Qt5Agg'
import matplotlib.pyplot as plt

# 生成随机数据
np.random.seed(0)
data = np.random.rand(100, 5)

# 标准化数据
data_mean = np.mean(data, axis=0)
data_centered = data - data_mean

# 计算协方差矩阵
cov_matrix = np.cov(data_centered, rowvar=False)

# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)

# 选择前两个主成分
top_indices = np.argsort(eigenvalues)[-2:]  # 选择最大的两个特征值的索引
top_eigenvectors = eigenvectors[:, top_indices]

# 降维
reduced_data = data_centered.dot(top_eigenvectors)

# 可视化
plt.scatter(reduced_data[:, 0], reduced_data[:, 1])
plt.title('PCA降维结果')
plt.xlabel('主成分1')
plt.ylabel('主成分2')
plt.grid()
plt.show()

代码解释:

  • 生成100个5维随机数据，计算标准化后的协方差矩阵。
  • 计算特征值和特征向量，选择最大的两个特征值对应的特征向量进行降维。

image-20241104152207707

3. 时间序列数据分析

题目: 创建一个时间序列数据集，计算7天的移动平均，并绘制结果。

思路:

  • 生成日期范围和随机数作为数据。
  • 使用rolling()函数计算移动平均。
import pandas as pd
import numpy as np
import matplotlib
matplotlib.use('TkAgg')  
import matplotlib.pyplot as plt

# 生成日期范围
dates = pd.date_range(start='2021-01-01', periods=100)
data = np.random.rand(100) * 100  # 随机数据

# 创建时间序列
time_series = pd.Series(data, index=dates)

# 计算7天移动平均
moving_average = time_series.rolling(window=7).mean()

# 绘制结果
plt.figure(figsize=(12, 6))
plt.plot(time_series, label='原始数据')
plt.plot(moving_average, label='7天移动平均', color='red')
plt.title('时间序列数据及其移动平均')
plt.legend()
plt.show()

代码解释:

  • 生成随机数据作为时间序列，通过rolling(window=7).mean()计算7天的移动平均。
  • 使用Matplotlib绘制原始数据和移动平均结果。

image-20241104152334901

4. 数据的标准化和归一化

题目: 对给定数据进行标准化和归一化处理，并比较结果。

思路:

  • 使用StandardScaler和MinMaxScaler进行标准化和归一化。

from sklearn.preprocessing import StandardScaler, MinMaxScaler
import pandas as pd
import numpy as np
# 生成随机数据
data = np.random.rand(10, 2) * 100

# 标准化
scaler_standard = StandardScaler()
data_standardized = scaler_standard.fit_transform(data)

# 归一化
scaler_minmax = MinMaxScaler()
data_normalized = scaler_minmax.fit_transform(data)

# 打印结果
print("原始数据:\n", data)
print("标准化结果:\n", data_standardized)
print("归一化结果:\n", data_normalized)

代码解释:

  • 使用StandardScaler进行标准化处理，使数据均值为0，方差为1。
  • 使用MinMaxScaler进行归一化处理，将数据缩放到[0, 1]区间。

5. 统计分析—t检验

题目: 使用NumPy实现两个独立样本之间的t检验。

思路:

  • 使用scipy.stats.ttest_ind()进行t检验。
import numpy as np
from scipy import stats

# 生成两个独立样本
sample1 = np.random.normal(loc=50, scale=10, size=100)
sample2 = np.random.normal(loc=55, scale=10, size=100)

# 进行t检验
t_statistic, p_value = stats.ttest_ind(sample1, sample2)
print("t统计量:", t_statistic, "p值:", p_value)

image-20241104152506134

代码解释:

  • 生成两个正态分布的样本，通过t检验比较两者均值的显著性。

6. 自定义函数应用于数组

题目: 创建一个自定义函数，对数组进行操作，并应用到数组上。

思路:

  • 定义一个函数，计算数组每个元素的自定义操作。
# 自定义函数
def custom_operation(x):
    return np.sin(x) + np.log(x + 1)

arr = np.linspace(0, 10, 100)  # 生成0到10的线性空间
result = custom_operation(arr)   # 应用自定义函数

# 绘制结果
plt.plot(arr, result)
plt.title('自定义操作结果')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid()
plt.show()

代码解释:

  • 定义custom_operation函数，计算sin与log的组合，生成结果并绘制。

7. 多维数组的归一化

题目: 对一个多维数组的每一列进行归一化处理。

思路:

  • 自定义归一化函数并应用于每一列。
def normalize(arr):
    return (arr - np.min(arr)) / (np.max(arr) - np.min(arr))

data = np.random.rand(5, 3) * 100  # 生成随机数据
normalized_data = np.apply_along_axis(normalize, axis=0, arr=data)

print("原始数据:\n", data)
print("归一化后的数据:\n", normalized_data)

代码解释:

  • 自定义normalize函数，对数组进行列归一化，使用np.apply_along_axis应用于每一列。

8. 计算多项式拟合

题目: 使用NumPy对一组数据进行多项式拟合，并绘制结果。

思路:

  • 使用np.polyfit()拟合多项式，使用np.polyval()计算拟合值。
# 生成随机数据
np.random.seed(0)
x = np.linspace(0, 10, 30)
y = 2 * x + np.random.randn(30) * 2  # 添加噪声

# 多

项式拟合
coefficients = np.polyfit(x, y, 1)  # 线性拟合
polynomial = np.poly1d(coefficients)

# 计算拟合值
y_fit = polynomial(x)

# 绘制结果
plt.scatter(x, y, label='数据点')
plt.plot(x, y_fit, color='red', label='拟合线')
plt.title('多项式拟合')
plt.legend()
plt.show()

代码解释:

  • 使用np.polyfit()进行多项式拟合，生成拟合线并绘制原始数据和拟合结果。

9. 自定义聚类算法

题目: 实现简单的DBSCAN聚类算法。

思路:

  • 编写DBSCAN聚类算法，处理距离和密度。
from sklearn.datasets import make_moons
from sklearn.cluster import DBSCAN

# 生成数据
X, y = make_moons(n_samples=300, noise=0.1)

# 应用DBSCAN聚类
dbscan = DBSCAN(eps=0.2, min_samples=5)
labels = dbscan.fit_predict(X)

# 可视化结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='rainbow')
plt.title('DBSCAN聚类结果')
plt.show()

代码解释:

  • 使用sklearn中的make_moons生成非线性分布的数据，使用DBSCAN进行聚类并可视化结果。

10. 时间序列分析与ARIMA模型

题目: 使用NumPy和StatsModels对时间序列数据进行ARIMA建模。

思路:

  • 生成时间序列数据，使用ARIMA进行建模与预测。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.arima.model import ARIMA

# 生成时间序列数据
np.random.seed(0)
time_series = np.random.randn(100).cumsum()  # 随机游走生成序列
dates = pd.date_range(start='2021-01-01', periods=100)
ts = pd.Series(time_series, index=dates)

# 拟合ARIMA模型
model = ARIMA(ts, order=(1, 1, 1))
model_fit = model.fit()

# 进行预测
forecast = model_fit.forecast(steps=10)

# 绘制结果
plt.figure(figsize=(12, 6))
plt.plot(ts, label='原始数据')
plt.plot(forecast.index, forecast, label='预测值', color='red')
plt.title('ARIMA模型预测')
plt.legend()
plt.show()

image-20241104152632298

2023-2025 Powered by Kai with ❤️