python如何将list转换为set_python列表list与集合set的相互转换

尼克

发布时间：2025-09-17 17:20:02

1074人浏览过

来源于php中文网

原创

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

python如何将list转换为set_python列表list与集合set的相互转换

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免费学习笔记（深入）”；

为什么要把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版本中都能良好运行。

Favird No-Code Tools

无代码工具的聚合器

下载

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)。