Python数组操作详解及教程

Python中的数组操作主要涉及两种数据结构：内置的`list`（列表）和NumPy库提供的`ndarray`。`list`灵活易用，可存储不同类型数据，适合小规模数据和动态操作。而`ndarray`是同质多维数组，专为高效数值计算设计，尤其适用于大规模科学计算。本文将详细介绍这两种“数组”的创建、访问、修改、删除等操作，以及它们在数据类型、性能和功能上的核心区别。掌握`list`和`ndarray`的转换技巧，能让你在数据处理时更加灵活，充分发挥Python在数据分析和科学计算领域的优势。从切片索引到数据类型转换，助你玩转Python数组，提升代码效率。

Python中的“数组”主要指list和numpy.ndarray。list是内置的异构序列，支持多种数据类型和动态操作，适合小规模或非数值数据处理；而numpy.ndarray是同质多维数组，基于C实现，内存连续，支持高效数值运算和广播操作，适用于大规模科学计算。两者可通过np.array()和tolist()相互转换，核心区别在于数据类型一致性、性能和功能：list灵活但慢，ndarray高效专用于数值计算。

Python中，我们通常说的“数组”其实有两种主要形式：一种是内置的list（列表），它非常灵活，能存放各种类型的数据；另一种是numpy库提供的ndarray，这才是真正意义上的高性能、同质性数组，尤其适合数值计算和科学计算。理解这两种“数组”的差异和各自的操作方式，是高效编写Python代码的关键。

解决方案

谈到Python中的“数组”操作，我们基本上是在围绕list和numpy.ndarray打转。我个人觉得，对于初学者，先从list入手是比较自然的，因为它就在那里，开箱即用。而当你的数据量上去，或者需要进行复杂的数值运算时，numpy的强大就显现出来了。

1. Python内置列表（list）的操作：

list是最常用的数据结构之一，它允许你存储任意数量、任意类型的数据项。

• 创建列表：

  my_list = [1, 2, 3, 'hello', True]
  empty_list = []
  another_list = list(range(5)) # [0, 1, 2, 3, 4]

• 访问元素： 使用索引（从0开始）和切片。

  print(my_list[0])      # 1
  print(my_list[-1])     # True (访问最后一个元素)
  print(my_list[1:4])    # [2, 3, 'hello'] (切片操作，不包含结束索引)
  print(my_list[::2])    # [1, 3, True] (步长为2)

• 修改元素：

  my_list[0] = 100
  print(my_list)         # [100, 2, 3, 'hello', True]

• 添加元素：

  my_list.append('world')      # 在末尾添加
  my_list.insert(1, 'new')     # 在指定位置插入
  print(my_list)               # [100, 'new', 2, 3, 'hello', True, 'world']
  
  list_a = [1, 2]
  list_b = [3, 4]
  list_c = list_a + list_b     # 连接列表，生成新列表
  print(list_c)                # [1, 2, 3, 4]
  
  list_a.extend(list_b)        # 将list_b的元素添加到list_a末尾
  print(list_a)                # [1, 2, 3, 4]

• 删除元素：

  del my_list[1]               # 根据索引删除
  print(my_list)               # [100, 2, 3, 'hello', True, 'world']
  
  popped_element = my_list.pop() # 删除并返回最后一个元素
  print(popped_element)        # world
  print(my_list)               # [100, 2, 3, 'hello', True]
  
  my_list.remove(100)          # 删除第一个匹配的元素值
  print(my_list)               # [2, 3, 'hello', True]

• 其他常用操作： len()获取长度，sort()排序，reverse()反转，count()计数，index()查找索引。

2. NumPy ndarray的操作：

numpy是Python进行科学计算的核心库，它的ndarray对象是多维同质数组，专为高效数值运算设计。

• 安装NumPy： 如果没安装，先pip install numpy。

• 创建数组：

  import numpy as np
  
  np_array_1d = np.array([1, 2, 3, 4, 5])
  np_array_2d = np.array([[1, 2, 3], [4, 5, 6]])
  print(np_array_1d)
  print(np_array_2d)
  
  # 常用创建函数
  zeros_array = np.zeros((2, 3))    # 全0数组
  ones_array = np.ones((3, 2))      # 全1数组
  range_array = np.arange(0, 10, 2) # 类似range，但生成ndarray
  linspace_array = np.linspace(0, 1, 5) # 在指定区间内均匀生成N个点

• 访问元素与切片： 比列表更强大的多维切片。

  print(np_array_2d[0, 1])       # 访问第一行第二列的元素：2
  print(np_array_2d[:, 0])       # 访问所有行的第一列：[1 4]
  print(np_array_2d[0, :])       # 访问第一行的所有元素：[1 2 3]
  print(np_array_2d[0:2, 1:3])   # 切片：[[2 3], [5 6]]
  
  # 布尔索引
  mask = np_array_1d > 3
  print(np_array_1d[mask])       # [4 5]

• 元素级运算： 这是ndarray的巨大优势，直接对整个数组进行数学运算。

  a = np.array([1, 2, 3])
  b = np.array([4, 5, 6])
  print(a + b)                   # [5 7 9]
  print(a * 2)                   # [2 4 6]
  print(a * b)                   # 对应元素相乘：[4 10 18]
  print(np.sqrt(a))              # 逐元素求平方根

• 形状操作：

  reshaped_array = np_array_1d.reshape((5, 1)) # 改变数组形状
  print(reshaped_array)
  print(np_array_2d.T)           # 转置

• 聚合函数：

  print(np_array_1d.sum())       # 数组所有元素之和
  print(np_array_2d.mean(axis=0)) # 沿列求平均值
  print(np_array_2d.max())       # 最大值

Python列表与NumPy数组有什么区别？

这个问题问得非常好，因为这是初学者最容易混淆，也是最核心的一个点。说实话，我刚开始学Python的时候，也觉得“不都是存数据嘛，有啥区别？”但随着项目深入，你会发现它们的设计哲学和应用场景是截然不同的。

从我的经验来看，主要区别体现在以下几个方面：

1. 数据类型：

   • Python列表（list）： 是异构的，这意味着一个列表中可以同时存储整数、浮点数、字符串、甚至其他列表或对象。这种灵活性很强，但代价是内存占用和访问效率。
   • NumPy数组（ndarray）： 是同构的，即所有元素必须是相同的数据类型（例如，全部是整数，或者全部是浮点数）。如果你尝试放入不同类型的数据，NumPy会尝试向上转型以保持同质性。这种特性让NumPy能将数据紧密地存储在内存中，从而实现高效的数值运算。

2. 性能：

   • Python列表： 由于其异构性和动态大小的特性，列表中的每个元素实际上都存储为一个指向实际数据对象的指针。这意味着当你遍历列表或进行大量数值运算时，Python需要处理这些指针，导致性能开销较大，尤其是在处理大型数据集时。
   • NumPy数组： 底层是用C语言实现的，数据是连续存储在内存中的。这使得NumPy在进行大规模数值运算时，可以利用CPU的SIMD（单指令多数据）指令集，并避免Python的解释器开销，因此速度非常快。对于科学计算、机器学习等场景，NumPy是不可或缺的。

3. 功能和操作：

   • Python列表： 提供了非常通用的序列操作，比如append、insert、pop、sort等，更侧重于数据的组织和管理。
   • NumPy数组： 提供了极其丰富的数学函数和操作，可以直接对整个数组进行元素级的算术运算（如加减乘除）、线性代数、傅里叶变换、随机数生成等。它的设计目标就是为了高效地处理数值数据。比如，两个NumPy数组相加，array1 + array2会直接进行对应元素的相加，而两个列表相加list1 + list2则是拼接操作。

什么时候用哪个？

• 用list： 当你需要存储不同类型的数据，或者数据结构经常变化（频繁增删），或者数据量不大且不涉及大量数值计算时，list是更简单、更直观的选择。
• 用ndarray： 当你处理的是大型数值数据集，需要进行高效的数学运算、统计分析，或者进行机器学习、深度学习等任务时，numpy.ndarray是绝对的首选。它的性能优势是列表无法比拟的。

Python数组的切片和索引技巧有哪些？

切片和索引是操作Python“数组”最基础也最强大的方式之一。掌握好它们，能让你在数据处理时事半功倍。我发现很多初学者对负数索引和多维数组的切片感到困惑，这里我们来详细聊聊。

1. Python列表（list）的切片与索引：

列表的索引是基于0的，这意味着第一个元素的索引是0，第二个是1，以此类推。

• 基本索引：

  my_list = ['a', 'b', 'c', 'd', 'e']
  print(my_list[0])  # 'a'
  print(my_list[2])  # 'c'

• 负数索引： 负数索引从列表末尾开始计数。-1是最后一个元素，-2是倒数第二个，以此类推。这个真的非常方便，不用先len(list) - 1。

  print(my_list[-1]) # 'e'
  print(my_list[-3]) # 'c'

• 切片（[start:end:step]）： 切片会创建一个新列表，包含从start索引开始，到end索引（不包含）结束的元素。step是步长，默认为1。

  • start省略：从头开始。
  • end省略：到尾结束。
  • step为负数：表示反向切片。

  print(my_list[1:4])   # ['b', 'c', 'd'] (从索引1到索引3)
  print(my_list[:3])    # ['a', 'b', 'c'] (从头到索引2)
  print(my_list[2:])    # ['c', 'd', 'e'] (从索引2到尾)
  print(my_list[:])     # ['a', 'b', 'c', 'd', 'e'] (复制整个列表)
  print(my_list[::2])   # ['a', 'c', 'e'] (每隔一个取一个)
  print(my_list[::-1])  # ['e', 'd', 'c', 'b', 'a'] (反转列表，非常酷)

2. NumPy数组（ndarray）的切片与索引：

NumPy数组的索引和切片在单维度上与列表类似，但在多维数组上则展现出其真正的威力。

• 一维数组： 和列表几乎一样。

  import numpy as np
  arr_1d = np.array([10, 20, 30, 40, 50])
  print(arr_1d[1])    # 20
  print(arr_1d[-2])   # 40
  print(arr_1d[1:4])  # [20 30 40]
  print(arr_1d[::-1]) # [50 40 30 20 10]

• 多维数组： 使用逗号分隔的索引来指定每个维度的位置。

  arr_2d = np.array([[1, 2, 3],
                     [4, 5, 6],
                     [7, 8, 9]])
  print(arr_2d[0, 0])      # 1 (第一行第一列)
  print(arr_2d[1, 2])      # 6 (第二行第三列)
  print(arr_2d[0])         # [1 2 3] (访问第一行，等同于 arr_2d[0, :])

• 多维切片：

  # 获取第一行和第二行的所有列
  print(arr_2d[0:2, :])    # 或者 arr_2d[:2, :]
  # 输出：
  # [[1 2 3]
  #  [4 5 6]]
  
  # 获取所有行的第二列
  print(arr_2d[:, 1])
  # 输出：
  # [2 5 8]
  
  # 获取中间的子矩阵
  print(arr_2d[1:3, 1:3])
  # 输出：
  # [[5 6]
  #  [8 9]]

• 步长切片：

  arr_3d = np.arange(27).reshape((3, 3, 3))
  print(arr_3d[::2, ::2, ::2]) # 在所有维度上每隔一个取一个

• 布尔索引： 这是NumPy一个非常强大的特性，你可以用一个布尔数组来选择元素。

  arr = np.array([10, 20, 30, 40, 50])
  mask = (arr > 25) & (arr < 45) # 创建一个布尔掩码
  print(mask)                    # [False False  True  True False]
  print(arr[mask])               # [30 40] (只选择True对应的元素)
  
  # 修改满足条件的元素
  arr[arr % 2 == 0] = 0          # 将所有偶数改为0
  print(arr)                     # [ 0 20  0 40  0]

• 整数数组索引： 使用一个整数数组作为索引，可以按任意顺序选择元素。

  arr = np.array([10, 20, 30, 40, 50])
  indices = [0, 2, 4]
  print(arr[indices]) # [10 30 50]

掌握这些切片和索引的技巧，能让你在处理数据时更加灵活和高效，尤其是在数据分析和科学计算的场景中，这些操作是家常便饭。

Python中如何将列表转换为NumPy数组，反之亦然？

在实际的数据处理流程中，我们经常需要在Python的list和NumPy的ndarray之间进行转换。这通常发生在数据从外部源（比如CSV文件、数据库查询结果）加载进来时，它们可能最初以列表的形式存在，但为了进行高效的数值计算，我们需要将它们转换为NumPy数组。反过来，当你完成了NumPy数组的计算，可能需要将结果以列表的形式输出，或者与不接受NumPy数组的库进行交互。

1. Python列表转换为NumPy数组：

这是最常见的转换方向。NumPy提供了一个非常直观的函数np.array()来完成这个任务。

import numpy as np

# 一维列表转一维NumPy数组
my_list_1d = [1, 2, 3, 4, 5]
np_array_1d = np.array(my_list_1d)
print(f"列表: {my_list_1d}, 类型: {type(my_list_1d)}")
print(f"NumPy数组: {np_array_1d}, 类型: {type(np_array_1d)}")
# 输出:
# 列表: [1, 2, 3, 4, 5], 类型: <class 'list'>
# NumPy数组: [1 2 3 4 5], 类型: <class 'numpy.ndarray'>

# 二维列表（列表的列表）转二维NumPy数组
my_list_2d = [[10, 20, 30], [40, 50, 60]]
np_array_2d = np.array(my_list_2d)
print(f"\n二维列表:\n{my_list_2d}")
print(f"二维NumPy数组:\n{np_array_2d}")
# 输出:
# 二维列表:
# [[10, 20, 30], [40, 50, 60]]
# 二维NumPy数组:
# [[10 20 30]
#  [40 50 60]]

需要注意的细节：

• 数据类型推断： np.array()会尝试推断列表元素的统一数据类型。如果列表包含混合类型，NumPy会向上转型以保持同质性。例如，如果列表中有整数和浮点数，它会全部转为浮点数。

  mixed_list = [1, 2.5, 3]
  mixed_np_array = np.array(mixed_list)
  print(mixed_np_array)      # [1.  2.5 3. ]
  print(mixed_np_array.dtype) # float64

• 深拷贝： 默认情况下，np.array()会创建一个原始列表的深拷贝，这意味着修改NumPy数组不会影响原始列表，反之亦然。这通常是你想要的行为。

  original_list = [1, 2, 3]
  arr = np.array(original_list)
  arr[0] = 99
  print(original_list) # [1, 2, 3] (未改变)
  print(arr)           # [99  2  3]

2. NumPy数组转换为Python列表：

NumPy数组对象有一个tolist()方法，可以方便地将其转换为Python列表。对于多维数组，它会生成一个嵌套的列表。

# 一维NumPy数组转一维列表
np_array_1d = np

今天关于《Python数组操作详解及教程》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！