Python列表转集合的3种方法

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《Python列表转集合方法详解》，聊聊，我们一起来看看吧！

列表转集合可去重并提升查找效率，但会丢失顺序；集合适合唯一性、成员检测和集合运算，列表则适用于需顺序、索引或重复元素的场景。

Python中将列表（list）转换为集合（set）是一个非常常见的操作，主要目的是为了去重和利用集合的高效查找特性。反过来，当你需要对去重后的数据进行索引访问或保持特定顺序时，又会将其转换回列表。核心操作很简单：set(my_list) 完成列表到集合的转换，而 list(my_set) 则将集合变回列表。这个过程里最关键的，是理解转换带来的数据结构特性变化，尤其是关于元素唯一性和顺序的。

解决方案

将Python列表转换为集合，我们直接使用内置的 set() 构造函数即可。这个操作会遍历列表中的所有元素，并将其添加到一个新的集合中。由于集合的特性，所有重复的元素都会被自动去除，并且元素的原始顺序会丢失。

# 列表转换为集合
my_list = [1, 2, 2, 3, 4, 4, 5, 1]
my_set = set(my_list)
print(f"原始列表: {my_list}")
print(f"转换后的集合: {my_set}")
# 输出：
# 原始列表: [1, 2, 2, 3, 4, 4, 5, 1]
# 转换后的集合: {1, 2, 3, 4, 5} (顺序可能不同)

从集合转换回列表也同样直观，使用 list() 构造函数即可。这会创建一个新的列表，包含集合中的所有元素。需要注意的是，因为集合本身是无序的，所以转换回列表后，元素的顺序是任意的，不会是原始列表的顺序（如果集合是由列表转换而来）。

# 集合转换为列表
my_set_from_list = {1, 2, 3, 4, 5} # 假设这是从上面转换来的集合
my_new_list = list(my_set_from_list)
print(f"原始集合: {my_set_from_list}")
print(f"转换后的列表: {my_new_list}")
# 输出：
# 原始集合: {1, 2, 3, 4, 5}
# 转换后的列表: [1, 2, 3, 4, 5] (顺序可能不同，但包含所有唯一元素)

这个过程看似简单，但背后蕴含着两种数据结构的设计哲学差异，理解这些差异，才能在实际开发中做出明智的选择。

为什么要把Python列表转换为集合？它有什么实际用途？

说实话，我个人觉得列表转集合最直接、最常用的一个场景就是“去重”。你可能遇到过这样的情况：从数据库里拉了一堆用户ID，或者从日志文件里解析出一堆IP地址，结果发现里面有很多重复的。这时候，如果想快速得到一个不重复的唯一列表，set() 简直就是救星。

比如，我们有一份销售记录，里面有很多商品ID，现在想知道到底卖了多少种不同的商品：

sales_items = ["apple", "banana", "apple", "orange", "banana", "grape"]
unique_items = set(sales_items)
print(f"销售的唯一商品种类有: {unique_items}")
# 输出: 销售的唯一商品种类有: {'orange', 'apple', 'banana', 'grape'}

除了去重，集合在成员检测（membership testing）方面有着列表无法比拟的优势。如果你需要频繁地检查某个元素是否存在于一个大型集合中，使用集合会比列表快得多。这是因为集合内部是基于哈希表实现的，查找一个元素平均只需要常数时间（O(1)），而列表则需要遍历，平均是线性时间（O(n)）。

想象一下，你有一个包含百万个有效IP地址的黑名单列表，每次用户访问时，你都要检查他们的IP是否在黑名单里。如果用列表，每次查询都可能要遍历百万个IP，这效率肯定不行。但如果把黑名单做成集合，查询速度会像闪电一样快。

import time

large_list = list(range(1000000))
large_set = set(large_list)

# 列表查找
start_time = time.time()
_ = 999999 in large_list
end_time = time.time()
print(f"列表查找耗时: {end_time - start_time:.6f} 秒")

# 集合查找
start_time = time.time()
_ = 999999 in large_set
end_time = time.time()
print(f"集合查找耗时: {end_time - start_time:.6f} 秒")
# 实际输出会显示集合查找远快于列表

此外，集合还天然支持数学上的集合操作，比如并集、交集、差集等。这在处理数据关系时非常方便。比如，找出两个用户共同关注的好友，或者找出某个用户关注了但另一个用户没关注的人。

user_a_friends = {"Alice", "Bob", "Charlie", "David"}
user_b_friends = {"Bob", "Eve", "Frank", "Charlie"}

# 共同好友 (交集)
common_friends = user_a_friends.intersection(user_b_friends)
print(f"共同好友: {common_friends}") # {'Bob', 'Charlie'}

# A关注了但B没关注的好友 (差集)
a_only_friends = user_a_friends.difference(user_b_friends)
print(f"A独有的好友: {a_only_friends}") # {'Alice', 'David'}

这些场景下，集合的优势是显而易见的。

将列表转换成集合后，元素顺序会发生变化吗？如何保留或恢复顺序？

是的，元素顺序会发生变化。这是集合的一个基本特性：它是无序的。当你把一个列表转换成集合时，原始的元素插入顺序就丢失了。集合只关心元素是否存在，不关心它们的排列位置。所以，当你再把这个集合转换回列表时，得到的列表元素顺序是任意的，并不能保证与原始列表的顺序一致。

这其实是个挺有意思的问题，因为有时候我们既想要去重，又希望能保留原始的插入顺序。单纯的 set() 转换是做不到的。

如果你需要去重并保留原始插入顺序，有几种方法可以实现：

1. 手动迭代与辅助集合（通用且易懂）

这种方法是自己写循环，遍历原始列表，用一个辅助集合来记录已经出现过的元素，只有当元素是第一次出现时才添加到结果列表中。

def unique_elements_in_order(input_list):
    seen = set()
    result = []
    for item in input_list:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

my_list = [1, 5, 2, 5, 3, 1, 4]
ordered_unique = unique_elements_in_order(my_list)
print(f"原始列表: {my_list}")
print(f"保留顺序的唯一元素: {ordered_unique}")
# 输出: 保留顺序的唯一元素: [1, 5, 2, 3, 4]

这种方式虽然多了一些代码，但逻辑非常清晰，在任何Python版本中都能良好运行。

2. 利用 dict.fromkeys() （Python 3.7+ 推荐）

从 Python 3.7 开始，字典（dict）开始保证插入顺序。我们可以利用 dict.fromkeys() 方法来创建一个字典，它的键就是列表中的唯一元素，并且会保留这些键的首次出现顺序。然后，再把这个字典的键转换回列表。这是目前最简洁且高效的方法之一。

my_list = [1, 5, 2, 5, 3, 1, 4]
# dict.fromkeys(my_list) 会创建一个字典，键是my_list中的元素，值默认为None
# 字典的键是唯一的，且保留了插入顺序
ordered_unique_dict_keys = list(dict.fromkeys(my_list))
print(f"原始列表: {my_list}")
print(f"利用dict.fromkeys保留顺序的唯一元素: {ordered_unique_dict_keys}")
# 输出: 利用dict.fromkeys保留顺序的唯一元素: [1, 5, 2, 3, 4]

我个人在需要这种功能时，更倾向于使用 dict.fromkeys()，因为它写起来更Pythonic，而且性能也相当不错。

所以，如果你只是想去重，顺序不重要，直接 set() 完事。如果顺序很重要，那就得用点“小技巧”了。

列表和集合在性能上有什么区别？何时选择使用集合而非列表？

列表和集合在Python中是两种非常基础且常用的数据结构，但它们的设计目标和底层实现差异巨大，这直接导致了它们在性能上的表现也大相径庭。理解这些差异，是高效编写Python代码的关键。

1. 成员检测 (in 操作符)

• 列表 (list): 查找一个元素是否在列表中，通常需要从头到尾遍历列表。在最坏情况下，如果元素在列表末尾或不存在，需要遍历所有 n 个元素，所以时间复杂度是 O(n)（线性时间）。
• 集合 (set): 集合的底层是哈希表。查找一个元素时，Python会计算元素的哈希值，然后直接跳转到对应的存储位置。平均情况下，无论集合有多大，查找都只需要常数时间 O(1)。在最坏情况下（哈希冲突严重），也可能退化到 O(n)，但这在实际应用中非常罕见。

这一点是集合最显著的性能优势。如果你需要频繁地检查某个元素是否存在于一个大型集合中，集合会比列表快几个数量级。

2. 添加/删除元素

• 列表 (list):
  • append()（在末尾添加）：通常是 O(1)（摊销常数时间），因为列表内部会预留空间。
  • insert(index, element)（在任意位置插入）：需要移动插入点之后的所有元素，时间复杂度是 O(n)。
  • pop()（删除末尾元素）：O(1)。
  • pop(index)（删除指定位置元素）：需要移动删除点之后的所有元素，时间复杂度是 O(n)。
  • remove(value)（删除第一个匹配的元素）：需要查找元素（O(n)）并移动后续元素（O(n)），总共 O(n)。
• 集合 (set):
  • add()（添加元素）：平均是 O(1)。
  • remove(value) / discard(value)（删除元素）：平均是 O(1)。

在添加和删除方面，集合也表现出更好的平均性能，尤其是在删除指定值时。

3. 内存使用

• 集合通常会比列表占用更多的内存。这是因为哈希表需要额外的空间来存储哈希值和处理冲突。每个元素在集合中都需要一个哈希值，并且哈希表本身需要一些空槽来保持其效率。
• 然而，如果你的列表包含大量重复元素，并且你最终会将其去重，那么一个去重后的集合可能会比一个包含大量重复元素的列表占用更少的内存。

何时选择使用集合而非列表？

我总结了一下，当你遇到以下情况时，优先考虑使用集合：

• 需要确保元素唯一性： 这是集合最核心的特性。如果你不希望数据中有重复项，或者需要快速去除重复项，集合是首选。
• 需要频繁进行成员检测 (in 操作)： 当你在一个大型数据集中频繁查询某个元素是否存在时，集合的 O(1) 查找效率会带来巨大的性能提升。
• 需要执行数学集合操作： 如果你需要计算两个数据集的并集、交集、差集或对称差集，集合提供了非常简洁和高效的方法。
• 元素的顺序不重要： 如果你对元素的排列顺序没有要求，那么集合的无序性就不会成为问题。

何时选择使用列表而非集合？

反之，当以下情况出现时，列表通常是更好的选择：

• 元素的顺序至关重要： 列表会保留元素的插入顺序，并且允许你通过索引访问元素。
• 需要存储重复元素： 如果你的数据允许有重复项，并且这些重复项本身具有意义（例如，购物清单上的商品数量），那么列表是合适的。
• 需要通过索引访问元素： 列表支持 my_list[index] 这样的操作，而集合不支持。
• 需要频繁在列表的任意位置插入或删除元素（如果性能不是极端敏感）： 尽管列表在这些操作上是 O(n)，但在某些特定场景下，其灵活性可能更重要。

所以，选择哪种数据结构，最终取决于你的具体需求和对性能的权衡。没有绝对的“最好”，只有最适合当前场景的。

本篇关于《Python列表转集合的3种方法》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！