如何在 Python 列表和字典中使用 `.pop()`

介绍

Python 的 .pop() 方法是一种强大而灵活的内置函数，允许您从列表和字典中移除并返回元素。这个方法在您需要在一次高效操作中提取和删除项目的场景中特别有用。无论您是实现栈（后进先出）、管理队列、清理配置数据，还是处理可选字典键，.pop() 都提供了一个简单的解决方案。

有关 Python 列表操作的全面概述，除了 .pop() 方法，请参阅关于如何在 Python 3 中使用列表方法的教程。

要了解如何有效地计算列表元素的平均值，请查看我们关于Python中列表平均值的指南。

要学习如何将多个列表合并为一个单一序列，请参阅有关在Python中连接列表的教程。

要学习如何在列表中定位和处理字符串元素，请查看关于在Python中查找列表中的字符串的教程。

关键要点

本指南涵盖了有关Python的.pop()方法的所有内容：

• 了解 .pop() 在列表和字典中的工作原理，包括语法、返回值和错误处理
• 了解何时使用 .pop() 与 .remove() 以及每种方法的影响
• 在现实场景中有效使用 .pop()，如栈、队列、配置管理和清理例程
• 避免在迭代过程中修改集合或从空结构中弹出元素等常见陷阱
• 探索高级用例和性能考虑，包括诸如 del、 popitem() 和 deque 的替代方案

一目了然：

• 在列表中，pop() 根据索引移除并返回一个元素（默认：最后一项）
• 在字典中，pop(key, default)通过键移除并返回一个值，如果键缺失，可以选择性地返回一个默认值。
• 在需要一步删除时使用pop()
• 在仅仅读取值而不进行修改时，优选 .get()

先决条件

要遵循本教程，您应该熟悉：

• 基本的 Python 语法和 Python 数据类型（列表和字典）
• 如何通过终端或IDE运行Python代码
• 使用 try/except 进行常见错误处理

Python 中的 .pop() 方法是什么？

• 对于列表，.pop()会删除并返回给定索引处的项（如果未提供索引，则默认为最后一项）。
• 对于字典，.pop() 会移除并返回指定键的值。如果未找到该键并且提供了默认值，它将返回默认值而不是引发错误。

这种双重功能使得 .pop() 成为许多常见编程任务的首选方法，例如：

• 从列表或堆栈中消费项目
• 安全地从字典中提取和移除配置或用户输入值
• 在处理数据结构时清理它们

语法备忘单：.pop() 在列表与字典中的使用

列表的语法

list.pop(index=-1)

list.pop(index=-1) 方法接受一个可选的整数索引，从指定位置移除一个元素。如果省略索引，则默认值为 -1，在常量时间内（O(1)）移除最后一个项目。如果指定其他索引，则会触发后续所有元素的移动，这导致线性时间复杂度（O(n)），因为需要重新分配元素。

字典的语法

dict.pop(key, default)

dict.pop(key, default) 方法移除与给定 key 相关的条目并返回其值。如果 key 缺失，则返回可选的 default 值，而不是引发 KeyError。在内部，这执行了哈希表查找和删除，保持平均情况的常数时间复杂度 (O(1))。

为什么我们应该使用 .pop() 方法？

• 效率: .pop() 方法是高度有效的，因为它将删除和检索项目这两个操作合并为一个单一的原子操作。这不仅减少了你需要编写的代码量，还最小化了计算开销，使你的程序更快、更简洁，特别是在数据处理任务中。

• 可读性: 在你的代码中使用 .pop() 使得你的意图对任何阅读它的人都显而易见。它表明你想要同时访问和移除集合中的一个项目，这提高了代码的清晰度。这种自文档化的方法帮助其他开发者快速理解每个操作背后的逻辑和目的。

• 稳健的错误处理：在处理字典时，.pop() 提供了一种内置方式，通过允许您指定默认返回值来优雅地处理缺失的键。这意味着，如果键不存在，您的代码可以避免引发 KeyError 异常，从而导致更稳健、容错的程序，能够顺利处理边界情况和意外输入。

何时应该使用 .pop()？

1. 处理和移除集合中的项目

当您需要处理列表或字典中的元素并在处理时将其移除时，请使用 .pop()。这在消耗数据的算法中尤其有用，例如解析、过滤或转换集合，以确保处理过的项目不会在您的数据结构中被重新访问或遗留。

2. 实现栈或队列数据结构

.pop() 方法非常适合用于在 Python 中实现栈（后进先出）和队列（先进先出）。对于栈，可以使用 list.pop() 而不指定索引来高效地删除最后一个项目。对于队列，可以使用 pop(0) 来删除第一个项目，尽管对于大型队列，建议使用 collections.deque 以获得更好的性能。

3. 避免使用未使用或过时的数据

当您想保持您的集合整洁，避免未使用或过时的数据时，.pop() 通过在数据不再需要时立即移除项目来帮助您。这种做法在长期运行的程序或对内存敏感的应用程序中非常重要，因为它可以防止过时数据的积累以及潜在的内存泄漏。

4. 在字典中优雅地处理缺失的键

在字典中，.pop(key, default) 允许你尝试移除一个键并获取其值，同时在键不存在时提供一个后备值。这种方法可以帮助你避免 KeyError 异常，并使你的代码在处理可选或不可预测的数据源时更加稳健。

这个快速的视觉表格帮助你记住 .pop() 的作用、适用范围以及它在不同数据类型中的表现。

如何在列表中使用 .pop()

Python 列表中的 .pop() 方法是一个多功能的工具，用于移除和检索元素。这使得它非常适合于栈操作、队列管理，以及需要处理和丢弃元素的情况。

语法

list.pop(index=-1)

• 索引（可选）：要移除的项目位置。如果省略，则移除最后一个项目。
• 返回被移除的项目。
• 如果列表为空或索引超出范围，则抛出IndexError。

例子

colors = ['red', 'green', 'blue']
print(colors.pop())      # Output: blue (removes the last item)
print(colors.pop(0))     # Output: red (removes the item at index 0)
print(colors)            # Output: ['green']

您可以使用 .pop() 来实现栈 (后进先出) 或队列 (先进先出) 逻辑：

Stack (LIFO)
stack = [1, 2, 3]
print(stack.pop())  # Output: 3

Queue (FIFO)
queue = [1, 2, 3]
print(queue.pop(0)) # Output: 1

.pop() 的内部工作原理

在底层，Python 列表是动态数组。当调用 .pop() 而不带索引时，它通过简单地截断末尾执行 O(1) 操作。然而，使用 .pop(index) 会涉及移动元素，复杂度为 O(n)。

例如：

nums = [10, 20, 30, 40, 50]
nums.pop(2)  # Slower than nums.pop() due to element shifting

在性能重要且只需要删除最后一项时，请使用 .pop() 不带参数。

如何在字典中使用 .pop()

字典的 .pop() 方法允许您删除一个键并同时检索它的值。这在数据处理、配置管理或当您想确保一个键仅使用一次时特别有用。

示例语法

dict.pop(key, default)

• 关键: 移除的关键。
• 默认 (可选): 当未找到该键时返回的值。如果省略并且缺少该键，将引发 KeyError。
• 返回与已删除键相关联的值。

字典示例

settings = {'theme': 'dark', 'lang': 'en'}
print(settings.pop('theme'))             # Output: dark
print(settings.pop('timezone', 'UTC'))   # Output: UTC (since 'timezone' is missing and UTC is default value)
print(settings)                          # Output: {'lang': 'en'}

当你想提取并丢弃配置或负载键时，这种模式很常见：

user_data = {"name": "Alice", "email": "alice@example.com"}
email = user_data.pop("email", None)
print(email)         # Output: alice@example.com
print(user_data)     # Output: {'name': 'Alice'}

用例：API 有效负载清理

在处理第三方API负载时，您可能想要提取并丢弃不再使用的密钥。

payload = {
    "user": "admin",
    "token": "abc123",
    "meta": {"timestamp": "2025-07-23"}
}

token = payload.pop("token", None)
print(token)       # Output: abc123
print(payload)     # Output: {'user': 'admin', 'meta': {...}}

.pop() 在列表和字典中

理解 .pop() 在不同数据结构中的行为对于在现实世界的 Python 程序中有效使用它至关重要。该方法在列表和字典中提供了类似的功能，但它在每种情况下的操作方式反映了底层数据模型。

• 在列表中，.pop() 根据元素的位置或索引移除一个元素。如果没有指定索引，它默认会移除最后一个 item。这在顺序重要的场景中，例如栈和队列，尤其理想。
• 在字典中，.pop()使用键删除项目。它还允许指定一个备用值，以防键丢失，这在防御性编程中尤其有用，因为键的存在并不总能得到保证。

这种二元性使得 .pop() 成为一种高度多功能的方法，非常适合需要一种紧凑、直观方式来访问和修改数据集合的开发者。

下面的插图总结了.pop()在这两种数据结构中的行为:

将这个视觉备忘单用作快速提醒，关于列表和字典中 .pop() 的语法、行为和最佳用例。

.pop() 和 .remove() 之间的区别

理解 .pop() 和 .remove() 之间的区别在使用 Python 列表时至关重要，因为它们有不同的目的和行为。

视觉比较

何时使用 .pop()

在以下情况下使用 .pop()：

• 你知道要移除的元素的索引（对于列表）或键（对于字典）。
• 你需要同时删除和检索该元素。
• 您正在处理堆栈或实现数据处理例程，在这些例程中，您逐渐消耗和丢弃数据。

List example
data = [10, 20, 30]
value = data.pop(1)  # Removes and returns 20
print(data)          # Output: [10, 30]

Dictionary example
config = {'debug': True, 'port': 8000}
port = config.pop('port', 8080)  # Removes and returns 8000

何时使用 .remove()

在以下情况下使用 .remove()：

• 你只知道元素的值，而不知道索引。
• 您想在列表中删除该值的第一次出现。
• 您不需要检索值，只需将其删除。

List example
fruits = ['apple', 'banana', 'cherry']
fruits.remove('banana')  # Deletes the first occurrence of 'banana'
print(fruits)            # Output: ['apple', 'cherry']

注意：.remove() 仅在 列表 上有效，如果值不存在则会引发 ValueError。

行为的主要区别

• .pop() 更具多功能性：它可以在列表和字典上使用，并支持检索。
• .remove() 仅限于列表，并且只能删除第一个匹配的值。
• 如果你需要优雅地处理未知的键或值，.pop() 为字典提供了默认的备用选项，而 .remove() 则没有。

性能考虑

• list.pop() 不带索引时时间复杂度为 O(1)，而 .remove() 和 pop(index) 的时间复杂度为 O(n)，因为要进行元素的移动。
• 在性能至关重要且不需要移除特定值的情况下，建议使用 .pop() 而不传入参数。

通过理解这些差异，您可以根据用例选择最合适的方法，无论您是在清理数据、实施算法还是构建动态逻辑。

使用 remove() 的示例列表

fruits = ['apple', 'banana', 'cherry']
fruits.remove('banana')  # Removes 'banana'

.pop()的实际使用案例

.pop() 方法在涉及数据检索和变更的现实场景中被广泛使用。这里有一些实际示例：

栈操作（后进先出）

在实现栈数据结构（后进先出）时，.pop() 是移除顶部元素的标准方式：

stack = [1, 2, 3]
while stack:
    print(stack.pop())  # Output: 3, 2, 1

配置清理

您可以使用 .pop() 来提取敏感或已使用的配置值，并将其从字典中删除:

config = {'token': 'abc123', 'user': 'admin'}
token = config.pop('token', None)

此模式防止敏感数据的意外重用或泄漏。

安全弹出备份

在处理用户输入或外部数据时，您可以安全地尝试弹出一个键并提供一个备用方案：

payload = {'id': 42}
value = payload.pop('name', 'anonymous')  # Returns 'anonymous'

缓存和过期系统

如果您正在实现一个带有TTL（生存时间）的缓存，.pop() 在检索过期键的值时非常有用。

cache = {'session1': 'data1', 'session2': 'data2'}
expired = cache.pop('session1', None)

这个模式确保过时的数据不会在内存中滞留。

常见错误及其处理方式

IndexError

KeyError

if my_list:
    my_list.pop()

value = my_dict.pop('nonexistent', 'fallback')

使用 .pop() 的最佳实践

使用 pop() 可以一步检索和移除元素。
当你需要同时访问一个元素的值并删除它时，.pop() 可以通过将这些操作结合在一起来简化你的代码。这种原子化的方法减少了冗余的查找，最小化了变量的使用，并确保物品在检索后不会被意外重用。它非常适用于像队列处理、栈管理或者一次性键提取的工作流程，确保项目在检索后不会持久化。

始终为字典的 pop() 指定一个默认值。
提供后备值可以防止在缺失键时出现 KeyError 异常。通过使用 dict.pop(key, default)，您的代码可以优雅地处理缺失的条目，返回已知值，而不是中断执行。这种防御性编程技术在处理不可预测或可选的数据源时至关重要，有助于维护数据解析和配置逻辑的稳定性。

避免在迭代循环中弹出元素。
在for循环中修改列表或字典可能会导致跳过项目、索引错误或由于元素移动或键集变化而发生逻辑缺陷。相反，请使用while循环，遍历集合的副本，或先收集键后再弹出。这可以保持迭代的一致性，防止数据处理程序中的微妙错误。

在需要保持原件完整时，请对副本进行操作。
如果必须保留源集合，请使用 .copy() 为字典创建浅拷贝，使用 list(...) 或切片为列表创建浅拷贝，然后再调用 .pop()。这种隔离可以防止对共享数据结构的意外副作用，支持在大型系统中需要原始数据集以便于重播、比较或回滚的场景。

在仅仅读取值时更推荐使用 get()。
如果您不需要删除条目，请使用 dict.get(key, default) 来访问值，而不改变数据结构。这种方法避免了副作用，使您的代码更安全、更可预见，特别是在像验证检查、日志记录或需要维护数据完整性的条件读取等环境中。

记录或文档 .pop() 操作以便调试。
在复杂或长期运行的系统中，跟踪何时以及为什么移除项目可以明确状态变化并简化故障排除。在 .pop() 调用之前和之后添加注释或日志语句，可以记录移除的键/值及其上下文，有助于未来的维护，并防止在收集器随时间变化时引起混淆。

深入探讨：.pop() 在列表中的工作原理

内部机制与性能

Python 列表是作为动态数组实现的。当你调用 list.pop() 时，Python 会移除并返回指定索引上的项（默认为最后一项）。以下是其背后的工作原理：

• pop() 无索引: 移除最后一个元素。这是一个 O(1) 操作，执行非常快，因为它只是缩短了数组。
• pop(index)：删除给定索引上的元素。该索引之后的所有元素都会向左移动一个位置。在最坏情况下（从开始位置弹出时），这是一个O(n)操作。

import timeit
lst = list(range(10000))
Popping from end
print(timeit.timeit('lst.pop()', setup='lst = list(range(10000))', number=10000))
Popping from start
print(timeit.timeit('lst.pop(0)', setup='lst = list(range(10000))', number=10000))

提示： 在栈式（LIFO）场景中，使用 pop() 时不带索引以获得最佳性能。

使用负索引弹出

您可以使用负索引从末尾弹出：

nums = [10, 20, 30, 40]
print(nums.pop(-2))  # Output: 30

在嵌套列表中弹出

pop() 只会从外部列表中删除。对于嵌套列表，必须索引到子列表中。

matrix = [[1, 2], [3, 4]]
print(matrix[1].pop())  # Output: 4
print(matrix)           # Output: [[1, 2], [3]]

循环中的弹出: 陷阱

在迭代时修改列表可能会导致跳过元素或出错：

lst = [1, 2, 3, 4]
for i in range(len(lst)):
    lst.pop()  # This is safe (removes from end)

But this is unsafe:
lst = [1, 2, 3, 4]
for x in lst:
    lst.pop(0)  # May skip elements or cause logic errors

最佳实践：如果你需要弹出多个项目，请使用 while 循环:

while lst:
    lst.pop()

处理空列表

在弹出之前始终检查列表是否非空，以避免 IndexError:

if my_list:
    my_list.pop()

深入分析：.pop() 在字典中的操作方式

内部机制与秩序

在 Python 3.7 及更高版本中，字典保持插入顺序。当你调用 dict.pop(key) 时，Python:

• 查找键（平均情况为 O(1)）
• 删除键值对并返回值
• 如果缺少键，则引发KeyError（除非提供了默认值）

对比 pop()、del、popitem() 和 get()

Python提供了几种方法来删除或访问字典和列表中的项目。理解它们的区别可以帮助你为工作选择合适的工具。

1. 弹出（key[, default]）

• 删除并返回指定键的值。
• 接受一个可选的default，如果缺少键则返回此值，从而避免KeyError。
• 平均情况时间复杂度：O(1)。适合于带控制的删除和检索。

settings = {'timeout': 30}
timeout = settings.pop('timeout', 60)  # Returns 30
missing = settings.pop('retry', 3)     # Returns 3, no error

2. del dict[key]

• 删除键值对而不返回值。
• 如果键不存在，则引发 KeyError。
• 时间复杂度：O(1)。仅在您只需要删除时使用。

data = {'a': 1, 'b': 2}
del data['a']  # data is now {'b': 2}

3. popitem()

• 删除并返回最后插入的键值对作为一个 (键, 值) 元组。
• 如果字典为空，则引发 KeyError。
• 对字典执行类栈（LIFO）操作很有用。

history = {'step1': True, 'step2': False}
last = history.popitem()  # ('step2', False)

4. get(key[, default])

• 如果存在，返回key的值，否则返回default（或None）。
• 不移除该项。
• 安全地只读访问，无需修改。

config = {'host': 'localhost'}
host = config.get('host')      # 'localhost'
port = config.get('port', 80)  # 80, config unchanged

通过选择适当的方法，您可以编写更清晰、更高效的代码，以便精确处理数据的移除和访问。

在嵌套字典中弹出

要从嵌套字典中弹出元素，请索引到子字典：

data = {'user': {'name': 'Alice', 'age': 30}}
name = data['user'].pop('name')
print(name)  # Output: Alice

弹出多个键

要删除多个键，使用循环或理解式：

keys_to_remove = ['a', 'b']
for k in keys_to_remove:
    d.pop(k, None)

处理缺失的键

始终提供一个默认值以避免 KeyError:

value = d.pop('missing', 'default')

.pop() 的高级用例

1. 算法：栈/队列，深度优先搜索，广度优先搜索

.pop() 在需要栈或队列行为的算法中是必不可少的：

Depth-First Search (DFS) using stack
stack = [start_node]
visited = set()
while stack:
    node = stack.pop()
    if node not in visited:
        visited.add(node)
        stack.extend(graph[node])

Breadth-First Search (BFS) using queue
queue = [start_node]
visited = set()
while queue:
    node = queue.pop(0)
    if node not in visited:
        visited.add(node)
        queue.extend(graph[node])

2. 数据清洗和ETL

在处理数据时，.pop() 可以帮助提取和移除已处理的字段：

def clean_payload(payload):
    user_id = payload.pop('user_id', None)
    timestamp = payload.pop('timestamp', None)
    # ... process ...
    return user_id, timestamp, payload  # payload now has only unprocessed keys

3. 事务操作（撤销/重做）

撤销/重做的栈通常使用 .pop() 实现:

undo_stack = ['edit1', 'edit2']
last_action = undo_stack.pop()  # Undo last action

4. 内存管理和副作用

从列表或字典中弹出大型对象可以帮助释放内存，特别是在长时间运行的进程中。

性能和并发考虑因素

本节详细分析了.pop()的性能特征，并强调了在某些情况下，其他技术或数据结构可能更适合的场景。

运行时基准测试：.pop() 与其他替代方案

• list.pop()（无索引）： O(1) 用于移除最后一个元素，适合栈操作。
• list.pop(0) 或 remove(): O(n)，因为元素必须移动以填补空缺，这可能会在大型列表上降低性能。
• collections.deque.popleft(): O(1) 从前面移除，非常适合用于队列实现。
• dict.pop()（键）： 平均情况下 O(1) 的查找和删除，适用于动态的基于键的删除。

何时避免 .pop()

• 保留原始数据： 如果源数据必须保持不变，请在浅拷贝上操作（lst.copy() 或 dict.copy()）.
• 安全迭代：避免在 for 循环中修改集合；相反，可以遍历快照或使用 while 循环来弹出项目。
• 大规模前移除：反复在列表上弹出索引0是耗费资源的，使用deque可以实现前后弹出操作的O(1)复杂度。

线程安全和并发性

Python自带的list和dict类型在并发修改时不安全。对于多线程场景：

• 使用线程安全的队列： queue.Queue 提供了用于生产者-消费者模式的同步FIFO操作。
• 利用 deque 和锁： 将 collections.deque 与 threading.Lock 结合，以实现两端的原子追加/弹出操作。
• 保护关键区域： 当直接锁定是必要的时，将 .pop() 调用包裹在 threading.Lock 中，以防止竞争条件并确保数据完整性。

常见陷阱和反模式

• 在迭代过程中变异：

  • 在遍历列表或字典时，不要弹出条目。这可能导致跳过条目或运行时错误。

• 意外副作用：

  • 从共享数据结构中弹出数据可能会导致错误，如果其他代码期望数据保持不变。

• 弹出理解：

  • 在列表/字典推导式中避免使用 .pop()，因为这会导致代码混乱和副作用。

常见问题解答 (FAQs)

我可以对自定义对象使用.pop()吗？

是的，如果您子类化list或dict，您将继承.pop()。您也可以重写它以实现自定义行为。

class MyList(list):
    def pop(self, index=-1):
        print(f"Popping at {index}")
        return super().pop(index)

如果我从一个在其他地方使用的列表/字典中弹出元素，会发生什么？

如果其他变量引用同一个列表/字典，弹出操作将影响所有引用（因为它们指向同一个对象）。

.pop() 与替代方案：快速参考表

pop()

remove()

del

popitem()

get()

示例解决方案：

def pop_last_n(lst, n):
    return [lst.pop() for _ in range(min(n, len(lst)))]

lst = [1, 2, 3, 4, 5]
print(pop_last_n(lst, 3))  # Output: [5, 4, 3]
print(lst)                 # Output: [1, 2]

.pop() 在 Python 中做什么？

Python 中的 .pop() 方法从列表或字典中移除并返回一个元素。在列表中，它接受一个可选的索引，并移除该位置的元素（默认是最后一个）。在字典中，它移除给定键的值。这种双重功能使得 .pop() 在需要一步完成删除和获取时成为一个方便的工具。

在Python中，pop()和remove()之间有什么区别？

pop() 会根据索引（在列表中）或键（在字典中）删除一个项目并返回其值。remove() 会从列表中删除第一个匹配的值并且不返回。与 pop() 不同，remove() 不支持字典。如果你需要同时检索和删除，优先选择 pop()；当仅按值删除时使用 remove().

如果我在一个空列表或缺失的键上使用 .pop() 会发生什么？

在空列表上使用 .pop() 会引发 IndexError，而在字典上调用一个不存在的键且没有默认值时会引发 KeyError。为了避免这些情况，提前检查列表的长度或使用 dict.pop(key, default) 提供一个后备值，当键不存在时使用。

在 Python 中，栈的 pop() 方法是做什么的？

在栈操作（后进先出）中，pop() 会移除最近添加的项目。Python 列表原生支持这种行为，使用 list.pop()。这在撤销机制、递归解析和算法如深度优先搜索（DFS）中非常有用。为了确保 O(1) 的栈操作，总是使用不带索引的 pop()。

如何在Python中从列表中弹出字符串？

如果已知字符串的位置，请使用 pop(index)。如果不知道，请使用 remove()。例如：

names = ['Alice', 'Bob', 'Eve']
names.pop(1)  # Removes 'Bob'

请注意，pop() 通过索引操作，如果索引超出范围，会引发错误。

如果您需要直接从字符串中删除字符，请参阅有关在 Python 中从字符串中删除字符的教程。

我可以在循环中使用 .pop() 吗？

是的，但请谨慎。在遍历列表或字典时弹出元素可能会导致跳过某些元素或意外行为。用while循环替代for，或者遍历一个副本。这确保了一致的逻辑，并避免在迭代过程中修改集合。

.pop() 在多线程代码中安全吗？

不直接。Python 内置的 list 和 dict 类型在被并发修改时不是线程安全的。为了安全地并发访问，请使用线程安全的集合，例如 queue.Queue 或 collections.deque 来实现类似列表的行为，并用锁包装字典访问。

使用 .pop() 的性能影响是什么？

使用 list.pop() 而不指定索引是一个非常快速的 O(1) 操作。相比之下，list.pop(index) 是 O(n)，因为索引之后的元素必须被移动。对于字典来说，pop() 通常是 O(1)。如果你关心大型集合的性能，请坚持使用不带索引的 pop()，或使用 collections.deque 进行高效的队列操作。

• 如何在 Python 3 中使用列表方法
• Python: 从字符串中移除一个字符
• 在Python中列表的平均值
• 在Python中连接列表
• 在Python中查找列表中的字符串