集合内置函数

# -*- coding: utf-8 -*-
# @Time: 
# @Auther: kongweixin
# @File:
# 集合（Set）: 集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
# 和高中学习的集合一样  无序性  互异性  确定性
# 创建集合：(集合是无序的，因此您无法确定项目的显示顺序)
# thisset = {"apple", "banana", "cherry"}
# print(thisset)


# 访问项目: 您无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。
#           但是可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。

# thisset = {"apple", "banana", "cherry"}
# for x in thisset:#遍历集合，并打印值：
#   print(x)#多次运行就会发现没有顺序


#实例: 检查 set 中是否存在 “banana”：
# thisset = {"apple", "banana", "cherry"}
# print("banana" in thisset)

# 更改项目: 集合一旦创建，您就无法更改项目，但是您可以添加新项目。

# 添加项目: 要将一个项添加到集合，请使用 add() 方法。
#          要向集合中添加多个项目，请使用 update() 方法。

# 使用 add() 方法向 set 添加项目：
# thisset = {"apple", "banana", "cherry"}
# thisset.add("orange")
# print(thisset)

# 使用 update() 方法将多个项添加到集合中：
# 互异性:
# thisset = {"apple", "banana", "cherry"}
# thisset.update(["banana", "orange", "mango", "grapes"])
# print(thisset)

#Set 的长度 :要确定集合中有多少项，使用 len() 方法。

# 获取集合中的项目数：
# thisset = {"apple", "banana", "cherry"}
# print(len(thisset))


# 删除项目:要删除集合中的项目，请使用 remove() 或 discard() 方法。

# 使用 remove() 方法来删除 “banana”：但是如果要删除的项目不存在，则 remove() 将引发错误。
# thisset = {"apple", "banana", "cherry"}
# thisset.remove("banana")
# print(thisset)


# 使用 discard() 方法来删除 “banana”： 如果要删除的项目也不存在，则 discard() 也将引发错误。
# thisset = {"apple", "banana", "cherry"}
# thisset.discard("banana")
# print(thisset)


# pop() 方法删除项目，但此方法将删除最后一项。请记住，set 是无序的，因此不会知道被删除的是什么项目。
# pop() 方法的返回值是被删除的项目。

# 实例1:使用 pop() 方法删除最后一项：
# thisset = {"apple", "banana", "cherry"}
# 集合是无序的，因此在使用 pop() 方法时，你不会知道删除的是哪个项目。
# x = thisset.pop()
# print(x)
# print(thisset)


# clear() 方法清空集合：
# thisset = {"apple", "banana", "cherry"}
# thisset.clear()
# print(thisset)


# del 彻底删除集合：
# thisset = {"apple", "banana", "cherry"}
# del thisset
# print(thisset)

# 合并两个集合

# union() 方法返回包含两个集合中所有项目的新集合，也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中：

# union() 方法返回一个新集合，其中包含两个集合中的所有项目：
# set1 = {"a", "b" , "c"}
# set2 = {1, 2, 3}
# set3 = set1.union(set2)
# print(set3)

# update() 方法将 set2 中的项目插入 set1 中：
# set1 = {"a", "b" , "c"}
# set2 = {1, 2, 3}
# set1.update(set2)
# print(set1)


# set() 构造函数: 也可以使用 set() 构造函数来创建集合。

# 实例: 使用 set() 构造函数来创建集合：
# thisset = set(("apple", "banana", "cherry")) # 请留意这个双括号
# print(thisset)


"""

集合内置函数大集合
方法                 描述
add()                  向集合添加元素。
clear()                    删除集合中的所有元素。
copy()                 返回集合的副本。
difference()           返回包含两个或更多集合之间差异的集合。
difference_update()        删除此集合中也包含在另一个指定集合中的项目。
discard()              删除指定项目。
intersection()         返回为两个其他集合的交集的集合。
intersection_update()  删除此集合中不存在于其他指定集合中的项目。
isdisjoint()           返回两个集合是否有交集。
issubset()             返回另一个集合是否包含此集合。
issuperset()           返回此集合是否包含另一个集合。
pop()                  从集合中删除一个元素。
remove()               删除指定元素。
symmetric_difference() 返回具有两组集合的对称差集的集合。
symmetric_difference_update()  插入此集合和另一个集合的对称差集。
union()                    返回包含集合并集的集合。
update()               用此集合和其他集合的并集来更新集合。

"""
# add()                    向集合添加元素。

# 定义和用法
# add() 方法向集合添加元素。
# 如果该元素已存在，则 add() 方法就不会添加元素。
# 语法: set.add(element)
# 参数值
# 参数        描述
# element  必需。要添加到集合的元素。

# 实例: fruits 集合添加一个元素：
# fruits = {"apple", "banana", "cherry"}
# fruits.add("orange")
# print(fruits)
# 请尝试添加已存在的元素：
# fruits = {"apple", "banana", "cherry"}
# fruits.add("apple")
# print(fruits)


# clear()                  删除集合中的所有元素。

# 定义和用法: clear() 方法删除集合中的所有元素。
# 语法:set.clear()
# 参数值:无参数。

# 实例:从 fruits 集合删除所有元素：
# fruits = {"apple", "banana", "cherry"}
# fruits.clear()
# print(fruits)


# copy()                   返回集合的副本。

# 定义和用法:copy() 方法复制集合。
# 语法: set.copy()
# 参数值: 无参数。

#实例1:复制 fruits 集合：
# fruits = {"apple", "banana", "cherry"}
# x = fruits.copy()
# print(x)


# difference()         返回包含两个或更多集合之间差异的集合。

# 定义和用法:different() 方法返回一个包含两个集合之间的差异的集合。
# 含义：返回的集合包含仅在第一个集合中存在的项目，而同时不存在于两个集合中。

# 语法: set.difference(set)
# 参数值
# 参数 描述 set 必需。要检查其中差异的项目。

# 实例1：返回一个集合，其中包含仅存在于集合 x 中而不存在于集合 y 中的项目：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# z = x.difference(y)
# print(z)

#实例2：反转第一个例子。返回一个集合，其中包含仅存在于集合 y 中而不存在于集合 x 中的项目：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# z = y.difference(x)
# print(z)


# difference_update()      删除此集合中也包含在另一个指定集合中的项目。

# 定义和用法
# different_update() 方法将删除两个集合中都存在的项目。
# difference_update() 方法与 difference() 方法不同，因为 difference() 方法返回一个新集合，其中没有不需要的项目，而 difference_update() 方法从原始集中删除了不需要的项目。
# 语法：set.difference_update(set)
# 参数值
# 参数   描述
# set      必需。要检查其中差异的集合。

# 实例1:删除两个集合中都存在的项目：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# x.difference_update(y)
# print(x)


# discard()                删除指定项目。

# 定义和用法
# discard() 方法从集合中删除指定项目。
# 此方法与 remove() 方法不同，因为如果指定的项目不存在，则 remove() 方法将引发错误，而 discard() 方法不会。
# 语法: set.discard(value)
# 参数值
# 参数     描述
# value      必需。要检索并删除的项目。

# 实例1:从集合中删除 "banana"：
# fruits = {"apple", "banana", "cherry"}
# fruits.discard("banana")
# print(fruits)


# intersection()           返回为两个其他集合的交集的集合。

# 定义和用法
# intersection() 方法返回包含两个或更多集合之间相似性的集合。
# 含义：返回的集合仅包含两个集合中都存在的项目，或者如果使用两个以上的集合进行比较，则在所有集合中都存在。

# 语法:set.intersection(set1, set2 ... etc)
# 参数值
# 参数   描述
# set1 必需。要在其中检索相同项目的集合。
# set2 可选。其他需要在其中检索相同项目的集合。
#         可以比较任意多的集合。
#         集合之间由逗号分隔。

# 实例1:返回包含存在于集合 x 和集合 y 中的项目的集合：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# z = x.intersection(y)
# print(z)

# 实例3:对比 3 个集合，并返回存在于所有 3 个集合中的项目：
# x = {"a", "b", "c"}
# y = {"c", "d", "e"}
# z = {"f", "g", "c"}
# result = x.intersection(y, z)
# print(result)


# intersection_update()    删除此集合中不存在于其他指定集合中的项目。

# 定义和用法
# intersection_update() 方法会删除各集合中都不存在的项目。
# intersection_update() 方法与 intersection() 方法不同，因为 intersection() 方法返回一个新集合，其中没有不需要的项目，而 intersection_update() 方法从原始集中删除了不需要的项目。
# 语法: set.intersection_update(set1, set2 ... etc)
# 参数值
# 参数   描述
# set1 必需。要在其中检索相等项目的集合。
# set2 可选。要在其中检索相等项目的另一集合。
#         能够比较任意多的集合。集合由逗号分隔。

# 实例1:删除集合 x 和集合 y 都不存在的项目：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# x.intersection_update(y)
# print(x)

# 实例2:比较 3 个集合，返回的集合包含存在于所有 3 个集合中的项目：
# x = {"a", "b", "c"}
# y = {"c", "d", "e"}
# z = {"f", "g", "c"}
# x.intersection_update(y, z)
# print(x)


# isdisjoint()         返回两个集合是否有交集。

# 定义和用法: 如果没有项目同时存在于不同集合中，则 isdisjoint() 方法返回 True，否则返回 False。
# 语法: set.isdisjoint(set)
# 参数值
# 参数    描述
# set      必需。要在其中检索相同项目的集合。

# 实例1:所有集合 x 中没有项目存在于集合 y 中，则返回 True：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "facebook"}
# z = x.isdisjoint(y)
# print(z)

# 实例2：如果有项目同时存在于相同中会怎么样？
# 如果两个集合中都存在一个或多个项目，则返回 False：

# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# z = x.isdisjoint(y)
# print(z)


# issubset()               返回另一个集合是否包含此集合。

# 定义和用法： 如果集合中的所有项目都存在于指定集合中，则 issubset() 方法将返回 True，否则返回 False。
# 语法：set.issubset(set)
# 参数值
# 参数   描述
# set      必需。在其中检索相等项目的集合。

# 实例1： 如果集合 y 中存在集合 x 中的所有项目，则返回 True：
# x = {"a", "b", "c"}
# y = {"f", "e", "d", "c", "b", "a"}
# z = x.issubset(y)
# print(z)

# 实例2：如果不是所有项目都出现在指定集中，会怎么样？
# 如果不是集合 x 中的所有项目都出现在集合 y 中，则返回 False：
# x = {"a", "b", "c"}
# y = {"f", "e", "d", "c", "b"}
# z = x.issubset(y)
# print(z)

# issuperset()         返回此集合是否包含另一个集合。

# 定义和用法： 如果指定集中的所有项目都存在于原始集中，则 issuperset() 方法将返回 True，否则返回 False。
# 语法：set.issuperset(set)
# 参数值
# 参数      描述
# set    必需。要在其中检索相等项目的集合。

# 实例1：假如集合 y 中的所有项目都存在于集合 x 中，则返回 True：
# x = {"f", "e", "d", "c", "b", "a"}
# y = {"a", "b", "c"}
# z = x.issuperset(y)
# print(z)

# 实例2：如果不是所有项目都存在于指定集合中会怎么样？
#        如果不是所有集合 y 中的项目都存在于集合 x 中，则返回 False：
# x = {"f", "e", "d", "c", "b"}
# y = {"a", "b", "c"}
# z = x.issuperset(y)
# print(z)


# pop()                    从集合中删除一个元素。

# 定义和用法： pop() 方法从集合中删除一个随机的项目。
# 此方法返回被删除的项目。
# 语法：set.pop()
# 参数值：无参数值。

# 实例1：从集合中删除一个随机的项目：
# fruits = {"apple", "banana", "cherry"}
# fruits.pop()
# print(fruits)

# 实例2:返回被删除的元素：pop() 返回被删除的值。
# fruits = {"apple", "banana", "cherry"}
# x = fruits.pop()
# print(x)
#


# remove()             删除指定元素。

# 定义和用法:remove() 方法从集合中删除指定的元素。
# 此方法与 discard() 不同，因为如果指定项目不存在，remove() 会引发错误，而 discard() 不会。
# 语法:set.remove(item)
# 参数值
# 参数      描述
# item 必需。需要检索并删除的项目。

# 实例1:从集合中删除 "banana"：
# fruits = {"apple", "banana", "cherry"}
# fruits.remove("banana")
# print(fruits)


# symmetric_difference()   返回具有两组集合的对称差集的集合。

# 定义和用法
# symmetric_difference() 方法返回一个集合，其中包含两个集合中的所有项目，但不包含两个集合中都存在的项目。
# 含义：返回的集合包含两个集合中都不存在的项的混合体。
# 语法:set.symmetric_difference(set)
# 参数值
# 参数     描述
# set    必需。用于检查匹配项的集合。

# 实例1:返回一个集合，其中包含两个集合中的所有项目，但两个集合中都存在的项目除外：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# z = x.symmetric_difference(y)
# print(z)


# symmetric_difference_update()    插入此集合和另一个集合的对称差集。

# 定义和用法: symmetric_difference_update() 方法通过删除两个集合中都存在的项目并插入其他项目来更新原始集合。
# 语法 ：set.symmetric_difference_update(set)
# 参数值
# 参数      描述
# set    必需。用于检查匹配项的集合。


# union()                  返回包含集合并集的集合。

# 定义和用法
# union() 方法返回一个集合，其中包含原始集合中的所有项目以及指定集合中的所有项目。
# 您可以指定任意数量的集合，以逗号分隔。
# 如果一项存在于多个集合中，则该项在结果中仅出现一次。
# 语法： set.union(set1, set2 ...)
# 参数值
# 参数   描述
# set1 必需。要整合的集合。
# set2 可选。要整合的另一集合。能够比较任意多的集合。集合由逗号分隔。
# 实例1：返回包含两个集合中所有项目的集合，重复项被排除在外：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# z = x.union(y)
# print(z)

# 实例2：整合两个以上的集合：
# x = {"a", "b", "c"}
# y = {"f", "d", "a"}
# z = {"c", "d", "e"}
# result = x.union(y, z)
# print(result)

# update()             用此集合和其他集合的并集来更新集合。

# 定义和用法
# update() 方法通过添加另一个集合中的项目来更新当前集合。
# 如果两个集合中都存在一个项目，则更新后的集合中将仅出现一次该项目。
# 语法: set.update(set)
# 参数值
# 参数         描述
# set      必需。插入当前集合的集合。

# 实例1: 把集合 y 中的项目插入集合 x：
# x = {"apple", "banana", "cherry"}
# y = {"google", "microsoft", "apple"}
# x.update(y)
# print(x)