Python - 删除集合元素

上一页
下一页

删除集合元素

删除集合元素意味着从集合中删除元素。在 Python 中，集合是可变的、无序的、由唯一元素组成的集合，有多种方法可以根据不同的条件从集合中删除元素。

我们可以使用多种方法从 Python 集合中删除元素，例如 remove()、discard()、pop()、clear() 和集合推导式。每种方法都提供不同的方式，根据特定条件删除集合中的元素。

使用 remove() 方法删除集合元素

Python 中的 remove() 方法用于从集合中删除指定元素的第一个出现。

我们可以通过指定要从集合中删除的元素来使用 remove() 方法删除集合元素。如果集合中存在该元素，则将其删除。但是，如果找不到该元素，remove() 方法将引发 KeyError 异常。

示例

在下面的示例中，我们使用 remove() 方法从集合 "my_set" 中删除元素 "Physics"：

my_set = {"Rohan", "Physics", 21, 69.75}
print ("Original set: ", my_set)

my_set.remove("Physics")
print ("Set after removing: ", my_set)

它将产生以下输出：

Original set:  {21, 69.75, 'Rohan', 'Physics'}
Set after removing:  {21, 69.75, 'Rohan'}

示例

如果要删除的元素在集合中找不到，remove() 方法将引发 KeyError 异常：

my_set = {"Rohan", "Physics", 21, 69.75}
print ("Original set: ", my_set)

my_set.remove("PHP")
print ("Set after removing: ", my_set)

我们将得到如下所示的错误：

Original set:  {'Physics', 21, 69.75, 'Rohan'}
Traceback (most recent call last):
  File "/home/cg/root/664c365ac1c3c/main.py", line 4, in <module>
    my_set.remove("PHP")
KeyError: 'PHP'

使用 discard() 方法删除集合元素

集合类中的 discard() 方法类似于 remove() 方法。唯一的区别是，即使要删除的对象不在集合中，它也不会引发错误。

示例

在这个例子中，我们使用 discard() 方法删除集合中的元素，无论它是否存在：

my_set = {"Rohan", "Physics", 21, 69.75}
print ("Original set: ", my_set)

# removing an existing element
my_set.discard("Physics")
print ("Set after removing Physics: ", my_set)

# removing non-existing element
my_set.discard("PHP")
print ("Set after removing non-existent element PHP: ", my_set)

以下是上述代码的输出：

Original set:  {21, 'Rohan', 69.75, 'Physics'}
Set after removing Physics:  {21, 'Rohan', 69.75}
Set after removing non-existent element PHP:  {21, 'Rohan', 69.75}

使用 pop() 方法删除集合元素

我们还可以使用 pop() 方法删除集合元素，该方法将删除并返回集合中的任意元素。如果集合为空，pop() 方法将引发 KeyError 异常。

示例

在下面的示例中，我们定义了一个包含元素 "1" 到 "5" 的集合，并使用 pop() 方法从中删除任意元素：

# Defining a set
my_set = {1, 2, 3, 4, 5}

# removing and returning an arbitrary element from the set
removed_element = my_set.pop()

# Printing the removed element and the updated set
print("Removed Element:", removed_element)
print("Updated Set:", my_set)

我们将得到如下所示的输出：

Removed Element: 1
Updated Set: {2, 3, 4, 5}

示例

如果我们尝试从空集合中删除元素，pop() 方法将引发 KeyError 异常：

# Defining an empty set
empty_set = set()

# Removing an arbitrary element from the empty set
removed_element = empty_set.pop()

产生的错误如下所示：

Traceback (most recent call last):
  File "/home/cg/root/664c69620cd40/main.py", line 5, in <module>
removed_element = empty_set.pop()
KeyError: 'pop from an empty set'

使用 clear() 方法删除集合元素

集合类中的 clear() 方法删除集合对象中的所有项，留下一个空集合。

我们可以使用 clear() 方法删除集合中的所有元素，从而使其为空。

示例

在下面的示例中，我们定义了一个包含元素 "1" 到 "5" 的集合，然后使用 clear() 方法删除集合中的所有元素：

# Defining a set with multiple elements
my_set = {1, 2, 3, 4, 5}

# Removing all elements from the set
my_set.clear()
# Printing the updated set
print("Updated Set:", my_set)

它将产生以下输出：

Updated Set: set()

删除同时存在于两个集合中的元素

您可以使用 difference_update() 方法或减法运算符 (-=) 删除同时存在于两个集合中的元素（即两个集合的交集）。这将从原始集合中删除同时存在于两个集合中的所有元素。

示例

在这个例子中，我们定义了两个集合“s1”和“s2”，然后使用`difference_update()`方法从“s1”中移除也存在于“s2”中的元素。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
print ("s1 before running difference_update: ", s1)
s1.difference_update(s2)
print ("s1 after running difference_update: ", s1)

执行上述代码后，我们将得到以下输出：

s1 before running difference_update: {1, 2, 3, 4, 5}
s1 after running difference_update: {1, 2, 3}
set()

移除在任一集合中存在的项

要移除在两个集合中的任一个集合中存在的项，可以使用对称差运算。两个集合的对称差运算结果是一个集合，该集合包含存在于任一集合中，但不包含在其交集中的元素。

在Python中，可以使用^运算符或`symmetric_difference()`方法执行对称差运算。

示例

在下面的例子中，我们定义了两个集合“set1”和“set2”。然后，我们使用对称差运算符（^）创建一个新的集合“result_set”，其中包含存在于“set1”或“set2”中，但不同时存在于两者中的元素。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# Removing items that exist in either set 
result_set = set1 ^ set2
print("Resulting Set:", result_set)

以下是上述代码的输出：

Resulting Set: {1, 2, 5, 6}

移除不相同的集合项

可以使用`intersection_update()`方法移除两个集合之间不相同的项。两个集合的交集运算结果是一个集合，该集合只包含同时存在于两个集合中的元素。

为了在一个原始集合中只保留公共元素并移除不公共的元素，可以使用其交集更新集合。

示例

在这个例子中，我们定义了两个集合“set1”和“set2”。然后，我们使用`intersection_update()`方法修改“set1”，使其只包含也存在于“set2”中的元素。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# Keeping only common items in set1
set1.intersection_update(set2)
print("Set 1 after keeping only common items:", set1)

上述代码的输出如下所示：

Set 1 after keeping only common items: {3, 4}

intersection() 方法

集合类中的`intersection()`方法与其`intersection_update()`方法类似，不同之处在于它返回一个新的集合对象，该对象包含现有集合中共同的项。

语法

以下是`intersection()`方法的基本语法：

set.intersection(obj)

其中，obj是一个集合对象。

返回值

`intersection()`方法返回一个集合对象，只保留自身和obj中共同的项。

示例

在下面的例子中，我们定义了两个集合“s1”和“s2”，然后使用`intersection()`方法创建一个新的集合“s3”，其中包含“s1”和“s2”中共同的元素。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
print ("s1: ", s1, "s2: ", s2)
s3 = s1.intersection(s2)
print ("s3 = s1 & s2: ", s3)

它将产生以下输出：

s1: {1, 2, 3, 4, 5} s2: {4, 5, 6, 7, 8}
s3 = s1 & s2: {4, 5}

集合项的对称差更新

两个集合的对称差是所有不相同项的集合，排除了相同元素。`symmetric_difference_update()`方法使用自身和作为参数给出的集合之间的对称差更新集合。

示例

在下面的例子中，我们定义了两个集合“s1”和“s2”，然后使用`symmetric_difference_update()`方法修改“s1”，使其包含存在于“s1”或“s2”中，但不同时存在于两者中的元素。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
print ("s1: ", s1, "s2: ", s2)
s1.symmetric_difference_update(s2)
print ("s1 after running symmetric difference ", s1)

得到的结果如下所示：

s1: {1, 2, 3, 4, 5} s2: {4, 5, 6, 7, 8}
s1 after running symmetric difference {1, 2, 3, 6, 7, 8}

集合项的对称差

集合类中的`symmetric_difference()`方法与其`symmetric_difference_update()`方法类似，不同之处在于它返回一个新的集合对象，该对象包含来自两个集合的所有项，减去公共项。

示例

在下面的例子中，我们定义了两个集合“s1”和“s2”。然后，我们使用`symmetric_difference()`方法创建一个新的集合“s3”，其中包含存在于“s1”或“s2”中，但不同时存在于两者中的元素。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
print ("s1: ", s1, "s2: ", s2)
s3 = s1.symmetric_difference(s2)
print ("s1 = s1^s2 ", s3)

它将产生以下输出：

s1: {1, 2, 3, 4, 5} s2: {4, 5, 6, 7, 8}
s1 = s1^s2 {1, 2, 3, 6, 7, 8}
打印页面
上一页
下一页
广告