如何在 Python 中拆分列表：基础与进阶方法

Q: 拆分 Python 列表与 partition() 有何区别？

partition() 方法返回包含三部分的元组，其中条件参数位于中间。

Q: 我可以用特定分隔符或指定值拆分 Python 列表吗？

您需要指定用于拆分列表的分隔符或值。

Python 列表是用于存储有序项的动态可变数组数据类型。在 Python 中拆分列表是常见任务，对于高效地操作和分析数据至关重要。

您可以通过学习 Data Analyst with Python 职业学习路径来提升技能，其中深入讲解了在 Python 中拆分列表的多种方法，并配有实用示例与最佳实践。

掌握这些技巧将提升您的编码能力，使脚本更高效、更易维护。我们开始吧。

快速答案：如何在 Python 中拆分列表

在 Python 中拆分列表的最简单方法是使用 : 运算符进行切片。例如，我们可以这样拆分列表：split_list = my_list[:5]，它会在第 5 个索引处拆分列表。
本文的其余部分将探讨其他拆分列表的方法，包括列表推导式、itertools、numpy 等。每种方法各有优势，适用于不同场景，下面将一一说明。

最常见的方法：使用切片拆分列表

在指定索引处拆分 Python 列表可能是最常见的技巧。切片方法可确保将列表在指定索引处拆分为子列表。以下是如何在 Python 中实现切片的分步指南。

定义列表：假设有一个列表 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，您希望在特定索引 n 处拆分。
确定拆分索引：指定要切片的索引 n。
创建第一段切片：在下面的代码中，创建 first_slice，其包含从列表开头到索引 n（不含）的元素。
创建第二段切片：定义 second_slice，其包含从索引 n 到列表末尾的所有元素。

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Index where the list will be split
n = 4

# Slice the list from the beginning to the nth index (not inclusive)
first_slice = my_list[:n]

# Slice the list from the nth index to the end
second_slice = my_list[n:]

# Print the first slice of the list
print("First slice:", first_slice)

# Print the second slice of the list
print("Second slice:", second_slice)

# Expected output:
# First slice: [1, 2, 3, 4]
# Second slice: [5, 6, 7, 8, 9, 10]技术支持

理解 Python 中的列表拆分

Python 中的列表切片是指从主列表中提取一个或多个子列表。要在 Python 中拆分列表，您需要理解切片语法，以准确获得所需的子列表。切片语法为 slice[start:stop:step]。

start 表示切片起始索引。
stop 表示切片结束索引。
step 表示切片的步长（默认为 1）。

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

# Expected output: [3, 4, 5, 6, 7]技术支持

根据上述代码，切片从索引 2 到索引 6，因为子列表不包含索引 7。

在代码可读性与效率方面，Python 拆分列表的好处包括：

简化数据管理：通过将数据拆分为易管理的块，数据科学家可以轻松划分机器学习中的训练集与测试集。
提升模块化：使用特定子列表编写函数可增强代码的模块化。
优化性能：使用更小的列表块处理速度通常比处理完整列表更快。
增强内存效率：该方法创建的块不会复制底层数据，更加节省内存。

在 Python 中拆分列表的不同技术

在 Python 中有多种拆分列表的方法。以下是数据从业者在实践中常见的一些示例。

使用列表切片

Python 列表切片使用 : 运算符在索引处拆分列表。此方法利用索引技术来指定切片的起点和终点。

切片的不同技巧包括：

正向索引切片

该方法使用从左到右的正索引来访问列表中的元素。

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

# Expected output: [3, 4, 5, 6, 7]技术支持

负向索引切片

这种 Python 列表拆分方法使用负索引值，从列表的最后一个元素开始，方向为从右到左。

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get the last 5 elements
sublist = my_list[-5:]

# Print the sliced sublist containing the last 5 elements
print(sublist)

# Slice the list to get all elements except the last 3
sublist = my_list[:-3]

# Print the sliced sublist containing all but the last 3 elements
print(sublist)

# Expected output:
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7]技术支持

使用步长

此方法在访问不同元素时通过设定步长来切分列表。

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get every second element, starting from the beginning
sublist = my_list[::2]

# Print the sliced sublist containing every second element
print(sublist) 

# Slice the list to get every second element, starting from index 1
sublist = my_list[1::2]

# Print the sliced sublist containing every second element, starting from index 1
print(sublist) 

# Slice the list to get the elements in reverse order
sublist = my_list[::-1]

# Print the sliced sublist containing the elements in reverse order
print(sublist) 

# Expected output:
# [1, 3, 5, 7, 9]
# [2, 4, 6, 8, 10]
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]技术支持

省略索引

该方法通过省略索引，仅返回列表中所需的元素来完成切片。

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from the start to index 5 (index 5 not inclusive)
sublist = my_list[:5]

# Print the sliced sublist containing elements from the start to index 4
print(sublist) 

# Slice the list from index 5 to the end
sublist = my_list[5:]

# Print the sliced sublist containing elements from index 5 to the end
print(sublist) 

# Slice the list to get the entire list
sublist = my_list[:]

# Print the sliced sublist containing the entire list
print(sublist) 

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]技术支持

使用列表推导式

Python 列表推导式允许根据现有列表的值将列表拆分为块。

# Define a function to split a list into chunks of a specified size
def split_list(lst, chunk_size):
    # Use a list comprehension to create chunks
    # For each index 'i' in the range from 0 to the length of the list with step 'chunk_size'
    # Slice the list from index 'i' to 'i + chunk_size'
    return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into chunks of size 3 using the split_list function
chunks = split_list(my_list, 3)

# Print the resulting list of chunks
print(chunks)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]技术支持

上述代码使用 Python 将列表拆分为大小为 3 的 n 个块，返回一个由多个长度为 3 的子列表组成的新列表。

使用 Itertools

使用 itertools 拆分 Python 列表是借助该模块通过迭代来转换数据。

# Import the islice function from the itertools module
from itertools import islice
# Define a function to yield chunks of a specified size from an iterable
def chunks(iterable, size):
    # Create an iterator from the input iterable
    iterator = iter(iterable)
    
    # Loop over the iterator, taking the first element in each iteration
    for first in iterator:
        # Yield a list consisting of the first element and the next 'size-1' elements from the iterator
        yield [first] + list(islice(iterator, size - 1))

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Convert the generator returned by the chunks function into a list of chunks
chunked_list = list(chunks(my_list, 3))

# Print the resulting list of chunks
print(chunked_list)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]技术支持

使用 numpy

Python 中的 numpy 库有助于将数组拆分为子列表。.array_split() 函数允许按指定的拆分次数进行切分。

# Import the numpy library and alias it as np
import numpy as np

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Use numpy's array_split function to split the list into 3 chunks
chunks = np.array_split(my_list, 3)

# Convert each chunk back to a regular list and print the resulting list of chunks
print([list(chunk) for chunk in chunks])

# Expected output:
# [[np.int32(1), np.int32(2), np.int32(3), np.int32(4), np.int32(5)], [np.int32(6), np.int32(7), np.int32(8), np.int32(9), np.int32(10)], [np.int32(11), np.int32(12), np.int32(13), np.int32(14), np.int32(15)]]技术支持

将列表拆分为多个块

以下 Python 函数也可将列表拆分为多个块。这些块可以根据用户需要自定义大小。

# Define a function to split a list into chunks of a specified size
def split_into_chunks(lst, chunk_size):
    chunks = []  # Initialize an empty list to store chunks
    
    # Iterate over the list with a step of chunk_size
    for i in range(0, len(lst), chunk_size):
        # Slice the list from index 'i' to 'i + chunk_size' and append it to chunks
        chunks.append(lst[i:i + chunk_size])
    
    return chunks  # Return the list of chunks

# Define a list of integers from 1 to 16
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

# Split the list into chunks of size 4 using the split_into_chunks function
chunks = split_into_chunks(my_list, 4)

# Print the resulting list of chunks
print(chunks)

# Expected output:
# [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]技术支持

基于条件拆分列表

当您想在 Python 中拆分列表时，可以为子列表设置规则/条件。该方法允许创建满足条件的子列表。

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# List comprehension to filter elements divisible by 3
div_3 = [x for x in my_list if x % 3 == 0]

# List comprehension to filter elements not divisible by 3
not_div_3 = [x for x in my_list if x % 3 != 0]

# Print the list of elements divisible by 3
print(div_3)

# Print the list of elements not divisible by 3
print(not_div_3)

# Expected output:
# [3, 6, 9, 12, 15]
# [1, 2, 4, 5, 7, 8, 10, 11, 13, 14]技术支持

使用 for 循环

也可以通过条件与迭代使用 for 循环来拆分 Python 列表。

# Define a function to split a list into sub-lists of size n
def split_by_n(lst, n):
    # Use a list comprehension to create sub-lists
    # For each index 'i' in the range from 0 to the length of the list with step 'n'
    # Slice the list from index 'i' to 'i + n'
    return [lst[i:i + n] for i in range(0, len(lst), n)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into sub-lists of size 5 using the split_by_n function
sub_lists = split_by_n(my_list, 5)

# Print the resulting list of sub-lists
print(sub_lists) 

# Expected output:
# [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]技术支持

使用 zip() 函数

您也可以在 Python 中使用 zip() 函数通过配对来拆分列表。

# Define two lists: list1 containing integers from 1 to 10, and list2 containing letters from 'a' to 'j'
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list2 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Use the zip function to pair corresponding elements from list1 and list2 into tuples
paired = list(zip(list1, list2))

# Print the list of paired tuples
print(paired)

# Expected output:
# [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'i'), (10, 'j')]技术支持

使用 enumerate() 函数

enumerate() 函数通过索引条件来拆分 Python 列表。该函数通过迭代将列表拆分为等大小的块。

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Define the chunk size for splitting the list
chunk_size = 5

# Create a list of empty lists, one for each chunk
split_list = [[] for _ in range(chunk_size)]

# Iterate over the elements and their indices in my_list
for index, value in enumerate(my_list):
    # Calculate the index of the sublist where the current value should go using modulo operation
    sublist_index = index % chunk_size
    
    # Append the current value to the corresponding sublist in split_list
    split_list[sublist_index].append(value)

# Print the list of sublists after splitting my_list into chunks
print(split_list)

# Expected output:
# [[1, 6, 11], [2, 7, 12], [3, 8, 13], [4, 9, 14], [5, 10, 15]]技术支持

Python 将字符串拆分为列表

使用 split() 方法

split() 方法会根据指定分隔符将字符串拆分为列表。该方法会根据字符串中分隔符的数量返回若干子串。

# Define a string
myString = "Goodmorning to you"

# Split the string into a list of words based on whitespace (default separator)
my_list = myString.split()

# Print the resulting list
print(my_list) 

# Expected output: ['Goodmorning', 'to', 'you']技术支持

使用 splitlines() 方法

splitlines() 方法根据换行符将字符串拆分为列表。

# Define a string with newline characters
myString = "Goodmorning\nto\nyou"

# Split the string into a list of lines based on newline characters
my_list = myString.splitlines()

# Print the resulting list
print(my_list)

# Expected output: ['Goodmorning', 'to', 'you']技术支持

使用 partition() 方法

partition() 方法通过给定分隔符将字符串拆分为列表。该方法返回三部分：分隔符前的字符串、分隔符本身以及分隔符后的所有内容，作为一个列表（元组）。

# Define a string with a delimiter '/'
myString = "Goodmorning/to you"

# Use the partition() method to split the string into three parts based on the first occurrence of '/'
my_list = myString.partition('/')

# Print the resulting tuple
print(my_list)

# Expected output: ('Goodmorning', '/', 'to you')技术支持

使用正则表达式

在 Python 中，也可以使用正则表达式将字符串拆分为列表。下面的示例展示了如何用空白字符来进行拆分。

# Import the 're' module for regular expressions
import re

# Define a string
myString = "Goodmorning to you"

# Use re.split() to split the string based on whitespace ('\s' matches any whitespace character)
# Returns a list of substrings where the string has been split at each whitespace
my_list = re.split('\s', myString)

# Print the resulting list
print(my_list)

# Expected output: ['Goodmorning', 'to', 'you']技术支持

对比表

下表可帮助您一目了然地了解不同技术可能适用的场景。实际上，同一种技术在许多情况下都能奏效，且性能差异并不明显，因此对某些技术“最有用时机”的提示可能略显夸张。

技术	用例	适用时机
切片	在特定索引或索引区间拆分列表。	适合简单、直接的拆分。
列表推导式	基于列表中的值或条件创建子列表。	适合更复杂的基于条件的拆分。
itertools.islice	使用迭代器将列表按指定大小拆分为块。	适合高效处理大型列表。
numpy.array_split	根据期望的拆分数量将数组拆分为子列表。	适合高效处理数值数据。
基于条件的拆分	按可整除性等条件拆分列表。	适合将数据划分为有意义的子列表。
for 循环	遍历列表以创建特定大小的子列表。	适合对拆分过程进行更精细的控制。
zip() 函数	将两个列表的元素配对。	适合合并两份相关列表的数据。
enumerate() 函数	使用索引条件拆分列表，常用于等大小的块。	适合创建均匀分布的子列表。
split() 方法	根据指定分隔符将字符串拆分为列表。	适合处理文本数据。
splitlines() 方法	根据换行符将字符串拆分为列表。	适合读取多行文本数据。
partition() 方法	根据指定分隔符将字符串拆分为三部分。	适用于特定文本处理场景。
正则表达式	使用正则将字符串按复杂模式拆分为列表。	适合高级文本数据处理。

常见陷阱与规避方法

数据从业者在处理 Python 列表拆分时可能会遇到一些常见错误。以下列出常见陷阱及其规避方式。

越界一位（Off-by-one）错误

在基本切片中，若包含的索引比所需少或多一个，就会出现越界一位错误。

my_list = [1, 2, 3, 4, 5]

# Trying to get sublist from index 2 to 4, inclusive
sublist = my_list[2:5]  # Correct: my_list[2:5]
print(sublist)

# Incorrect usage:
sublist = my_list[2:4]  # Incorrect, excludes index 4
print(sublist)

# Expected output:
# [3, 4, 5]
# [3, 4]技术支持

要避免此错误，需理解 Python 的索引规则，明确切片时哪些索引应包含或排除。

所用包相关的错误

当拆分方法依赖 Python 模块时，也可能遇到包相关错误。例如 numpy、re 和 itertools。为避免此类错误，请确保正确加载这些包并使用兼容版本。

处理边界情况

在进行 Python 列表拆分时，若未考虑某些场景，可能会出现边界情况。例如，下面的代码尝试将仅包含 4 个元素的列表拆分为 5 份。

import numpy as np

my_list = [1, 2, 3, 4]
chunks = np.array_split(my_list, 5)
print(chunks)

# Expected output: 
# [array([1]), array([2]), array([3]), array([4]), array([], dtype=int32)]技术支持

为避免此问题，可使用条件语句处理边界情况，如下所示。

import numpy as np

my_list = [1, 2, 3, 4]
if len(my_list) < 5:
    chunks = [my_list]
else:
    chunks = np.array_split(my_list, 5)
print(chunks)

# Expected output: [[1, 2, 3, 4]]技术支持

处理特殊字符

在拆分字符串列表时未正确处理特殊字符也会导致错误。这些特殊字符包括空格、逗号或字母数字混合等。

下面的示例通过指定用于拆分字符串列表的字符来避免该错误。

# Example list with special characters
my_list = ["apple, orange", "dog, mouse", "green, blue"]

# Splitting each string by the comma
split_list = [s.split(",") for s in my_list]
print(split_list)

# Expected output:
# [['apple', ' orange'], ['dog', ' mouse'], ['green', ' blue']]技术支持

最佳实践与指南

由于在数据分析中拆分列表是常见操作，遵循一些实践以确保效率非常重要。建议包括：

尽可能保持不可变性：如果不应修改原始列表，请确保您的切片操作不会改变原列表。切片会创建新列表，通常无此问题，但在处理更复杂的数据结构时需注意。
优化性能：处理大型列表时，请关注性能影响。切片通常高效，但对大型列表的不必要复制会导致性能瓶颈。
处理边界情况：考虑诸如空列表、在列表开头或末尾拆分、无效索引等情况。确保代码能优雅地处理这些场景。
加入错误处理与校验：当您需要将列表拆分为多个列表时，错误处理尤为重要，以避免代码崩溃并带来意外结果。

DataCamp 的 Python Programming 课程详细讲解了高效编写代码的最佳实践，涵盖错误处理与性能等常见概念。

进阶列表拆分技巧

通过使用多种方法来获得更强的控制力与灵活性，您可以将列表拆分提升到更高层次。

将列表拆分为多个列表

您可以通过在特定索引处指定拆分来将 Python 列表拆分为多个列表。例如，下面的代码在索引 2, 5, 7 处拆分列表。

def split_at_indices(lst, indices):
    result = []
    prev_index = 0
    for index in indices:
        result.append(lst[prev_index:index])
        prev_index = index
    result.append(lst[prev_index:])
    return result

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
indices = [2, 5, 7]
split_lists = split_at_indices(my_list, indices)
print(split_lists)

# Expected output: [[1, 2], [3, 4, 5], [6, 7], [8, 9, 10]]技术支持

将列表拆分为等份

您也可以使用诸如“numpy”等内置库，按照所需份数将 Python 列表拆分为等份。

import numpy as np

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
num_parts = 3
split_lists = np.array_split(my_list, num_parts)
print([list(arr) for arr in split_lists])

# Expected output:
# [[np.int32(1), np.int32(2), np.int32(3), np.int32(4), np.int32(5)], [np.int32(6), np.int32(7), np.int32(8), np.int32(9), np.int32(10)], [np.int32(11), np.int32(12), np.int32(13), np.int32(14), np.int32(15)]]技术支持

将列表一分为二

可以使用切片将 Python 列表一分为二。

def split_in_half(lst):
    # Calculate the midpoint index of the list
    mid_index = len(lst) // 2
    # Return the two halves of the list
    return lst[:mid_index], lst[mid_index:]

# Example list
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Split the list into two halves
first_half, second_half = split_in_half(my_list)
print(first_half)
print(second_half)

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9, 10]技术支持

对于元素个数为奇数的列表，您可以指定将中间元素包含在前一半中。

def split_in_half(lst):
    # Calculate the midpoint index of the list, including the middle element in the first half if the length is odd
    mid_index = (len(lst) + 1) // 2
    # Return the two halves of the list
    return lst[:mid_index], lst[mid_index:]

# Example list
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Split the list into two halves, handling odd-length
first_half, second_half = split_in_half(my_list)
print(first_half) 
print(second_half) 

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9]技术支持

Python Developer 也提供了编写高级代码的见解，帮助您理解进阶的列表拆分技巧。

结论

在 Python 中有多种拆分列表的方法。每种方法取决于列表的类型以及用户对效率的偏好。作为数据从业者，选择适合您分析需求的拆分方法非常重要。

若想全面理解 Python 的列表拆分，您可以学习我们的课程 Python Fundamentals。您还可以选修 Introduction to Python 课程，确保掌握对列表和其他数据类型的操作。Python 新手速查表也可帮助您快速回顾如何在 Python 中拆分列表。

作者

Allan Ouko

数据科学技术写作者，具备数据分析、商业智能和数据科学的一线实践经验。我撰写以行业为导向的实用内容，涵盖 SQL、Python、Power BI、Databricks 和数据工程，并以真实的分析工作为基础。我的写作兼顾技术深度与业务影响，帮助专业人士将数据转化为自信的决策。

常见问题

我什么时候需要在 Python 中拆分列表？

在数据处理时，Python 列表拆分非常重要，尤其是在处理大型数据集时。当您需要拆分数据以进行分析（如训练与测试机器学习模型）时，这些转换就会派上用场。

如果 itertools 和 numpy 模块报错，我该怎么办？

请确保已安装相应的 Python 库。若错误仍然存在，请升级并使用这些库的兼容版本。

拆分 Python 列表与 partition() 有何区别？

partition() 方法返回包含三部分的元组，其中条件参数位于中间。

我可以用特定分隔符或指定值拆分 Python 列表吗？

您需要指定用于拆分列表的分隔符或值。

将列表拆分为多个列表时，如何提升代码性能？

当将一个列表拆分为多个列表时，请使用可复用函数。这种方法更高效。

主题

Python 数据分析