如何检查列表项是否在字典中？及值为列表的字典中列表存在性与键获取

Hey there! Let's break down these two common Python dictionary-list checking questions for you—they come up a lot when working with nested data structures.

This question has two main scenarios depending on whether you're checking against the dictionary's keys or values:

场景A：检查列表元素是否是字典的键 #

Python's in keyword is perfect here—dictionary key lookups are O(1) operations, so they're super efficient:

my_dict = {"a": 1, "b": 2, "c": 3}
my_list = ["a", "d"]

for item in my_list:
    if item in my_dict:
        print(f"元素 {item} 存在于字典的键中")
    else:
        print(f"元素 {item} 不存在于字典的键中")

场景B：检查列表元素是否存在于字典的值中 #

If you need to check against values, you can either directly check against dict.values() or convert values to a set for faster lookups (great for large datasets):

my_dict = {"a": 1, "b": 2, "c": 3}
my_list = [2, 4]

# 基础方法：直接遍历值
for item in my_list:
    if item in my_dict.values():
        print(f"元素 {item} 存在于字典的值中")
    else:
        print(f"元素 {item} 不存在于字典的值中")

# 优化方法：转成集合提升效率（适合值为可哈希类型）
value_set = set(my_dict.values())
for item in my_list:
    if item in value_set:
        print(f"元素 {item} 存在于字典的值中")
    else:
        print(f"元素 {item} 不存在于字典的值中")

Your example mentions that [1,0,3] should match [0,1,3] in dict1 = {0:[0,1,3], 1:[0,2,3]}—since lists are ordered, a direct equality check won't work here. Here are two reliable solutions:

方法1：转成集合比较（适合无重复元素的列表） #

Sets are unordered, so converting both the target list and dictionary values to sets will let you compare regardless of order. Note: This only works if your lists have no duplicate elements (since sets automatically remove duplicates):

dict1 = {0:[0,1,3], 1:[0,2,3]}
target_list = [1,0,3]
target_set = set(target_list)

# 遍历字典键值对查找匹配
for key, value in dict1.items():
    if set(value) == target_set:
        print(f"列表 {target_list} 存在于字典中，对应的键是 {key}")
        break
else:
    print(f"列表 {target_list} 不存在于字典中")

方法2：排序后比较（适合有重复元素的列表） #

If your lists might have duplicates (like [0,1,1,3]), sorting both lists before comparing is the safer approach—it preserves all element counts:

dict1 = {0:[0,1,3], 1:[0,2,3]}
target_list = [1,0,3]
sorted_target = sorted(target_list)

for key, value in dict1.items():
    if sorted(value) == sorted_target:
        print(f"列表 {target_list} 存在于字典中，对应的键是 {key}")
        break
else:
    print(f"列表 {target_list} 不存在于字典中")

扩展：封装成复用函数 #

If you need to do this check multiple times, wrap the logic in a function for convenience:

def find_matching_key(target_list, data_dict, ignore_order=True):
    if ignore_order:
        sorted_target = sorted(target_list)
        for key, val in data_dict.items():
            if sorted(val) == sorted_target:
                return key
    else:
        # 如果需要严格匹配顺序，直接比较列表
        for key, val in data_dict.items():
            if val == target_list:
                return key
    return None

# 测试你的示例
dict1 = {0:[0,1,3], 1:[0,2,3]}
print(find_matching_key([1,0,3], dict1))  # 输出: 0
print(find_matching_key([2,3], dict1))    # 输出: None

内容的提问来源于stack exchange，提问作者utij2004