从 Python 中的字典列表中删除字典

在 Python 中从字典列表中删除一个字典

要从词典列表中删除词典：

使用for循环迭代列表的副本。
检查每个字典是否是要删除的字典。
使用list.remove()方法从列表中删除匹配的字典。

主程序


my_list = [
    {'id': 1, 'fruit': 'apple'},
    {'id': 2, 'fruit': 'banana'},
    {'id': 3, 'fruit': 'kiwi'},
]

for item in my_list.copy():
    if item.get('id') == 2:
        my_list.remove(item)
        break

# 👇️ [{'id': 1, 'fruit': 'apple'}, {'id': 3, 'fruit': 'kiwi'}]
print(my_list)

该示例使用for 循环从字典列表中删除字典。

我们使用该list.copy()方法来获取列表的副本。

list.copy方法返回调用该方法的对象的浅表副本。

这是必要的，因为我们不允许在遍历列表时从列表中删除元素。

但是，我们可以遍历列表的副本并从原始列表中删除元素。

主程序


my_list = [
    {'id': 1, 'fruit': 'apple'},
    {'id': 2, 'fruit': 'banana'},
    {'id': 3, 'fruit': 'kiwi'},
]

for item in my_list.copy():
    if item.get('id') == 2:
        my_list.remove(item)
        break

# 👇️ [{'id': 1, 'fruit': 'apple'}, {'id': 3, 'fruit': 'kiwi'}]
print(my_list)

在每次迭代中，我们检查当前字典是否具有id 值为的键2，如果满足条件，我们使用方法将其删除。 list.remove()

如果键在字典中，则 dict.get 方法返回给定键的值，否则返回默认值。

该方法采用以下 2 个参数：

姓名	描述
钥匙	返回值的键
默认	如果字典中不存在提供的键，则返回默认值（可选）

default如果未提供参数值，则默认为None，因此该get()方法永远不会引发. KeyError

list.remove ()方法从列表中删除第一项，其值等于传入的参数。

该remove()方法改变了原始列表并
返回 None。

找到要删除的字典后，我们使用语句跳出循环。 breakfor

break语句跳出最内层的封闭或for循环while。

使用该break语句可以帮助我们避免在从列表中删除字典后进行不必要的迭代。

在迭代时从列表中删除项目时要注意的最重要的事情是使用方法list.copy()迭代列表的副本。

如果您在迭代时尝试
从原始列表中删除元素，您可能会遇到难以定位的错误。

或者，您可以使用
列表理解。

使用列表理解从字典列表中删除字典

这是一个三步过程：

使用列表理解来遍历列表。
从新列表中排除匹配字典。
列表理解将返回一个不包含指定字典的新列表。

主程序


my_list = [
    {'id': 1, 'fruit': 'apple'},
    {'id': 2, 'fruit': 'banana'},
    {'id': 3, 'fruit': 'kiwi'},
]

new_list = [
    item for item in my_list if item.get('id') != 2
]

# 👇️ [{'id': 1, 'fruit': 'apple'}, {'id': 3, 'fruit': 'kiwi'}]
print(new_list)

我们使用列表理解来迭代字典列表。

列表推导用于对每个元素执行某些操作或选择满足条件的元素子集。

在每次迭代中，我们检查当前字典是否没有id值为的键2并返回结果。

新列表包含没有键值id为的字典2。

如果您必须从列表中删除一个或多个词典，则使用列表理解更合适。删除第一个字典后，列表理解会继续迭代。

如果您只需要从列表中删除单个字典，请使用for循环方法。

第一个示例中的列表理解不会改变原始列表，它会返回一个新列表。

使用重新分配从字典列表中删除字典

如果要更改原始列表的内容，请使用
列表切片。

主程序


my_list = [
    {'id': 1, 'fruit': 'apple'},
    {'id': 2, 'fruit': 'banana'},
    {'id': 3, 'fruit': 'kiwi'},
]


my_list[:] = [
    item for item in my_list if item.get('id') != 2
]

# 👇️ [{'id': 1, 'fruit': 'apple'}, {'id': 3, 'fruit': 'kiwi'}]
print(my_list)

我们使用my_list[:]语法来获取代表整个列表的切片，因此我们可以直接分配给变量。

主程序


my_list = [
    {'id': 1, 'fruit': 'apple'},
    {'id': 2, 'fruit': 'banana'},
    {'id': 3, 'fruit': 'kiwi'},
]

# 👇️ [{'id': 1, 'fruit': 'apple'}, {'id': 2, 'fruit': 'banana'}, {'id': 3, 'fruit': 'kiwi'}]
print(my_list[:])

切片my_list[:]代表整个列表，所以当我们在左侧使用它时，我们正在分配给整个列表。

这种方法改变了原始列表的内容。

使用 filter() 从字典列表中删除一个字典

您还可以使用该filter()函数从字典列表中删除字典。

主程序


my_list = [
    {'id': 1, 'fruit': 'apple'},
    {'id': 2, 'fruit': 'banana'},
    {'id': 3, 'fruit': 'kiwi'},
]

new_list = list(filter(
    lambda dictionary: dictionary['id'] != 2,
    my_list
))

# 👇️ [{'id': 1, 'fruit': 'apple'}, {'id': 3, 'fruit': 'kiwi'}]
print(new_list)

filter函数接受一个函数和一个可迭代对象作为参数，并从可迭代对象的元素构造一个迭代器，函数返回一个真值。

我们传递给的 lambda 函数filter被列表中的每个字典调用。

该函数检查id每个字典的键是否不等于 2。

该filter对象只包含满足条件的字典。

最后一步是使用list()类将对象转换filter为列表。

从 Python 中的字典列表中删除空字典

使用列表理解从字典列表中删除空字典。

列表理解将返回一个不包含任何空字典的新列表。

主程序


# ✅ Remove empty dictionaries from a list (using list comprehension)

list_of_dicts = [{'id': 1}, {}, {'id': 2}, {}, {'id': 3}]

new_list = [item for item in list_of_dicts if item]
print(new_list)  # 👉️ [{'id': 1}, {'id': 2}, {'id': 3}]

# ---------------------------------------------

# ✅ Remove empty dictionaries from a list (using filter())

new_list = list(filter(None, list_of_dicts))
print(new_list)  # 👉️ [{'id': 1}, {'id': 2}, {'id': 3}]

# ---------------------------------------------

# ✅ Remove empty dictionaries from a list (using for loop)

for item in list_of_dicts.copy():
    if item == {}:
        list_of_dicts.remove(item)

print(list_of_dicts)  # 👉️ [{'id': 1}, {'id': 2}, {'id': 3}]

第一个示例使用列表理解从字典列表中删除空字典。

列表推导用于对每个元素执行某些操作或选择满足条件的元素子集。

主程序


list_of_dicts = [{'id': 1}, {}, {'id': 2}, {}, {'id': 3}]

new_list = [item for item in list_of_dicts if item]
print(new_list)  # 👉️ [{'id': 1}, {'id': 2}, {'id': 3}]

在每次迭代中，我们检查当前项是否为真并返回结果。

空字典是虚假值，因此它们会被过滤掉。

列表理解创建一个新列表，它不会改变原始列表。

如果要从原始列表中删除空字典，请使用列表切片。

主程序


list_of_dicts = [{'id': 1}, {}, {'id': 2}, {}, {'id': 3}]

list_of_dicts[:] = [item for item in list_of_dicts if item]
print(list_of_dicts)  # 👉️ [{'id': 1}, {'id': 2}, {'id': 3}]

我们使用my_list[:]语法来获取代表整个列表的切片，因此我们可以直接分配给变量。

The slice my_list[:] represents the entire list, so when we use it on the left-hand side, we are assigning to the entire list.

This approach changes the contents of the original list.

Alternatively, you can use the filter() function.

# Remove empty dictionaries from list of dicts using filter()

This is a three-step process:

Use the filter() function to filter out the empty dictionaries.
Use the list() class to convert the filter object to a list.
The new list won’t contain any empty lists.

main.py


list_of_dicts = [{'id': 1}, {}, {'id': 2}, {}, {'id': 3}]


new_list = list(filter(None, list_of_dicts))
print(new_list)  # 👉️ [{'id': 1}, {'id': 2}, {'id': 3}]

We used the filter() function to remove the empty dictionaries from a list of
dictionaries.

The filter function
takes a function and an iterable as arguments and constructs an iterator from
the elements of the iterable for which the function returns a truthy value.

If you pass None for the function argument, all falsy elements of the iterable are removed.

An empty dictionary is a falsy value, so all empty dictionaries get removed.

The last step is to use the list() class to convert the filter object to a
list.

Alternatively, you can use a for loop.

# Remove empty dictionaries from list of dicts using for loop

This is a three-step process:

Use a for loop to iterate over a copy of the list.
On each iteration, check if the current item is an empty dictionary.
Use the list.remove() method to remove the empty dictionaries.

main.py


list_of_dicts = [{'id': 1}, {}, {'id': 2}, {}, {'id': 3}]

for item in list_of_dicts.copy():
    if item == {}:
        list_of_dicts.remove(item)

print(list_of_dicts)  # 👉️ [{'id': 1}, {'id': 2}, {'id': 3}]

On each iteration, we check if the current item is an empty dictionary and use the list.remove() method to remove the matching elements.

The list.remove() method removes the first
item from the list whose value is equal to the passed in argument.

The remove() method mutates the original list and
returns None.

The most important thing to note when removing items from a list in a for loop
is to use the list.copy() method to iterate over a copy of the list.

If you try to iterate over the original list and remove items from it, you might
run into difficult to locate bugs.

我还写了一篇关于
如何从字典列表中删除重复项的文章。

额外资源

您可以通过查看以下教程来了解有关相关主题的更多信息：