博客

12Python基础-集合Set

  • Post author:
  • Post category:python


Python基础-集合Set



什么是集合

Python 中的集合是一个由

不可变元素

组成的

无序

的

不重复元素

的列表。

即上述概括有如下特点：

  • 无序性：集合中的元素没有顺序
  • 元素不重复：集合中的元素具有唯一性。集合中不允许存在重复的元素。
  • 元素不可变：集合中的元素只能是不可变对象，例如数字、字符串以及元组。集合中的元素不能是列表或者字典。



创建集合

1.使用{}创建一个集合 

set1 = {1,2,3}
print(set1) # {1,2,3}

注意创建空集合时，不能使用{}，因为{}是创建空字典，使用函数set()可创建空集合 

# 创建一个空集合
set1 = set()
print(set1.__len__())

# 利用set创建一个非空集合
a = [1,2,3]
set1 = set(a)
print(set1) # {1,2,3}



集合的增删



增加元素

  1. s.add( x )：向集合内添加一个元素
  • 举例： 
set1 = {1,2,3}

# 向集合内添加一个元素
set1.add(4)
print(set1) #{1,2,3,4}

# 当添加的元素已经存在
set1.add(1)
print(set1) # {1,2,3,4} 此时还是1,2,3,4  1已经存在于集合中，不会重复，即上述说的集合的元素不重复性质
  1. s.update( param )：将列表，元组，字典等序列内的元素添加至集合中
  • 举例： 
set2= {1,2,3}
a = [1,2,3,4]
set2.update(a)
print(set2) # {1, 2, 3, 4} 无重复元素

b = ('a','b','c')
set2.update(b) 
print(set2) # {1, 'a', 2, 3, 4, 'c', 'b'}

c={"语文":10,"数学":20}
set2.update(c) # 默认添加字典的key值
print(set2) # {1, 'a', 2, 3, 4, 'c', '数学', '语文', 'b'}



删除元素

  1. remove( x )：删除集合中的一个元素，如果待删除元素不在集合中，则报错。通常和in一起用
  • 举例： 
# 删除一个存在元素
set3 = {1, 2, 3, 4, 'a', 'b', 'c'}
set3.remove(1)
print(set3) # {2, 3, 4, 'c', 'b', 'a'}

# 删除一个不存在元素
set3.remove(5) # 元素5不存在于集合set3中，报错
# Traceback (most recent call last):
#   File "E:/code_py/myPython/20220315.py", line 7, in <module>
#     set3.remove(5)
# KeyError: 5

# 所以在使用remove()删除集合中元素时，需要先判断元素是否已存在集合中
if 5 in set3:
    set3.remove(5)
  1. discard( x )：移除集合中的元素，且如果元素不存在，不会发生错误
  • 举例： 
# 删除一个存在元素
set4 = {1, 2, 3, 4, 'a', 'b', 'c'}
set4.discard(1)
print(set4) # {2, 3, 4, 'b', 'c', 'a'}

# 删除一个不存在元素
set4.discard(5) # 不报错
print(set4) # {2, 3, 4, 'b', 'c', 'a'}
  1. pop()： 随机删除集合中的一个元素

    多次执行测试结果都不一样。

    set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
  • 举例： 
# 随机删除一个元素
set5 = {1, 2, 3, 4, 'a', 'b', 'c'}
set5.pop()
print(set5)
# 第一次运行
# {2, 3, 4, 'a', 'b', 'c'}
#第二次运行
# {1, 2, 3, 4, 'a', 'c'}
  1. clear()：清空集合所有元素
  • 举例： 
set6 = {1, 2, 3, 4}
set6.clear()
print(set6) # set()



遍历集合

集合是一种可遍历对象，我们可以使用 for 循环遍历集合中的元素。例如： 

set7 = {1, 2, 3, 4, 5, 'a', 'b', 'c'}
for i in set7:
	print(i,end='\t')
# 因为集合是无序的，每次遍历元素的顺序不一致
# 第一次遍历结果
# 1	2	3	4	5	a	c	b	
# 第一次遍历结果
# 1	2	3	4	5	b	a	c

如果想要在循环内部访问当前元素的下标，可以使用内置的 enumerate() 函数，默认情况下，元素的下标从 0 开始。如果想要改变这种行为，可以为 enumerate() 函数指定第二个参数。例如： 

set8 = {1, 2, 3, 4, 5, 'a', 'b', 'c'}
# 默认下标从0开始
for index, i in enumerate(set8):
    print(f"{index}.{i}",end='; ')
# 0.1; 1.2; 2.3; 3.4; 4.5; 5.a; 6.c; 7.b; 
# 0.1; 1.2; 2.3; 3.4; 4.5; 5.a; 6.b; 7.c; 

# 指定下标从1开始
for index, i in enumerate(set8,1):
    print(f"{index}.{i}",end='; ')
# 1.1; 2.2; 3.3; 4.4; 5.5; 6.b; 7.c; 8.a;
# 1.1; 2.2; 3.3; 4.4; 5.5; 6.c; 7.a; 8.b;



集合推导式

利用集合推导式可以对集合内元素做修改 或过滤操作，生成一个新的集合

  • 语法： 
{expression for element in set if condition}
  • 举例： 
# 集合推导式-过滤
	# 基于已有集合创建一个新的集合。将集合中字符串元素全部转小写
	# 这里集合是一个元素类型混合的集合,判断元素是否是字符串，使用了type,其实还有isinstance方法
set9 = {1, 2, 3, 'Python', 'Java', 'CSDN'}
set9_1 = { i.lower() if 'str' in str(type(i)) else i for i in set9}
print(set9_1) # {1, 2, 3, 'java', 'python', 'csdn'}

	#isinstance方法
set9_2 = { i.lower() if isinstance(i,str) else i for i in set9}
print(set9_2) # {1, 2, 3, 'java', 'python', 'csdn'}

# 集合推导式-过滤
	#将元素小于60的数值过滤
set10 = {100, 20, 70, 9, 110}
set10_1 = { i for i in set10 if i >= 60}
print(set10) # {100, 70, 9, 110, 20}
print(set10_1) # {110, 100, 70}



集合间的关系

和数学上的集合一样，两个或多个集合之间存在一定的关系，从而产生新的集合。下面一起看下集合的交并差集



集合的交集

  • 定义：所谓集合的交集，即两个集合中的共同元素组成的新的集合。类似sql中的inner join关联。

    在这里插入图片描述
  • 实现：我们可以使用集合的 intersection() 方法或者交集操作符（&）返回两个或多个集合的交集。 
# 两个集合交集
set11_01 = {'python','java','c++'}
set11_02 = {'java','c','python'}
	#intersection方法
set11_12_1 = set11_01.intersection(set11_02)
print(set11_12_1 ) # {'java', 'python'}

	# &运算符
set11_12_2 = set11_01 & set11_02
print(set11_12_2 ) # {'java', 'python'}


# 多个集合交集
set11_03 = {1, 2, 3}
set11_04 = {2, 3, 4}
set11_05 = {3, 4, 5}
	#intersection方法
set11_345_1 = set11_03.intersection(set11_04).intersection(set11_05)
print(set11_345_1) # {3}

	# &运算符
set11_345_2 = set11_03 & set11_04 & set11_05
print(set11_345_2) # {3}
  • intersection() 方法 和 交集操作符（&）的特点

    intersection() 方法可以支持任何可遍历对象，包括字符串、列表以及字典等。

    交集操作符（&）只支持集合对象。 
#示例使用 intersection() 方法返回一个集合与一个列表的交集
numbers = {1, 2, 3}
scores = [2, 3, 4]
numbers = numbers.intersection(scores)
print(numbers) #{2, 3}

#使用交集运算符，将会返回一个错误 TypeError: unsupported operand type(s) for &: 'set' and 'list'
numbers = numbers & scores



集合的并集

  • 定义：所谓集合的并集，即两个集合中的所有元素组成的新的集合。类似sql中的full outer join关联。

    在这里插入图片描述
  • 实现：我们可以使用集合的 union() 方法或者并集操作符（|）返回两个或多个集合的并集。 
# 两个集合并集
set12_01 = {'python','java','c++'}
set12_02 = {'java','c','python'}
	#union方法
set12_12_1 = set12_01.union(set12_02)
print(set12_12_1) # {'python','java','c++', 'c'}

	# |运算符
set12_12_2 = set12_01 | set12_02
print(set12_12_2) # {'python','java','c++', 'c'}


# 多个集合并集
set12_03 = {1, 2, 3}
set12_04 = {2, 3, 4}
set12_05 = {3, 4, 5}
	#union方法
set12_345_1 = set12_03.union(set12_04).union(set12_05)
print(set12_345_1) # {1, 2, 3, 4, 5}

	# |运算符
set12_345_2 = set12_03 | set12_04 | set12_05
print(set12_345_2) # {1, 2, 3, 4, 5}
  • union() 方法 和 并集操作符（|）的特点

    union() 方法可以支持任何可遍历对象，包括字符串、列表以及字典等。

    交集操作符（|）只支持集合对象。 
#示例使用 union() 方法返回一个集合与一个列表的并集
numbers = {1, 2, 3}
scores = [2, 3, 4]
numbers = numbers.union(scores)
print(numbers) #{1, 2, 3, 4}

#使用并集运算符，将会返回一个错误 TypeError: unsupported operand type(s) for |: 'set' and 'list'
numbers = numbers | scores



集合的差集

  • 定义：所谓集合的差集，即两个集合中第一个集合中存在，但第二个集合中不存在的所有元素。类似sql中的left join关联。

    在这里插入图片描述
  • 实现：我们可以使用集合的 difference() 方法或者差集操作符（-）返回两个或多个集合的差集。 
# 两个集合并集
set13_01 = {'python','java','c++'}
set13_02 = {'java','c','python'}
	#difference方法
set13_12_1 = set13_01.difference(set13_02)
print(set13_12_1) # {'c++'}

	# |运算符
set13_12_2 = set12_01 - set12_02
print(set13_12_2) # {'c++'}


# 多个集合差集
set13_03 = {1, 2, 3, 6}
set13_04 = {2, 3, 4}
set13_05 = {1, 4, 5}
	#difference方法
set13_345_1 = set13_03.difference(set13_04).difference(set13_05)
print(set13_345_1) # {{6}

	# -运算符
set13_345_2 = set13_03 - set13_04 - set13_05
print(set13_345_2) # {6}
  • difference() 方法 和 差集操作符（-）的特点

    difference() 方法可以支持任何可遍历对象，包括字符串、列表以及字典等。

    交集操作符（-）只支持集合对象。 
#示例使用 difference() 方法返回一个集合与一个列表的差集
numbers = {1, 2, 3}
scores = [2, 3, 4]
numbers = numbers.difference(scores)
print(numbers) #{1}

#使用并集运算符，将会返回一个错误 TypeError: unsupported operand type(s) for |: 'set' and 'list'
numbers = numbers - scores



集合的子集

  • 定义：所谓集合的子集，即两个集合中第一个集合中所有元素都存在于第二个集合中，则第一个集合是第二个集合的子集。

    在这里插入图片描述

    对于集合 A 和 B，如果 A 中的所有元素都属于 B，那么 A 就是 B 的子集（subset）。此时，集合 B 就是 A 的超集或父集（superset）。集合 A 和 集合 B 可以相同。如果集合 A 和 B 不同，A 是 B 的真子集（proper subset）

  • 实现：我们可以使用集合的 issubset() 方法或者子集操作符（<=）来判断两个集合是否存在子集关系。 

# 两个集合并集
set14_01 = {1, 2, 3, 4, 5}
set14_02 = {1, 2, 3}
	#issubset方法
set14_12_1 = set14_02.issubset(set14_01) 
# 注意理解 set14_02 是不是 set14_01 的子集 =》 set14_02.issubset(set14_01) 
print(set14_12_1) # True

	# <=运算符
set14_12_2 = set14_02 <= set14_01
# 注意理解 set14_02 是不是 set14_01 的子集 =》 set14_02 <= set14_01
# 或者说 set14_01 是不是 set14_02 的超集或父集 set14_01 >= set14_02
print(set14_12_2) # True

	# <运算符 判断真子集
set14_12_3 = set14_02 < set14_01
print(set14_12_3) # True



集合的不相交集

  • 定义：所谓集合的不相交集，即两个集合中第一个集合中所有元素都不存在于第二个集合中，则这两个集合是不相交集。

    在这里插入图片描述
  • 实现：我们可以使用集合的 isdisjoint() 方法判断两个集合是否为不相交集 
set15_01 = {1, 2, 3}
set15_02 = {4, 5, 6}
set15_12 = set15_01.isdisjoint(set15_02)
print(set15_12) # True


版权声明：本文为i_mycode原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。