12Python基础-集合Set

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}

集合的增删

增加元素

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已经存在于集合中，不会重复，即上述说的集合的元素不重复性质

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'}

删除元素

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)

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'}

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'}

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

12Python基础-集合Set相关推荐

javaSE基础——集合全面解析笔记
javaSE基础--集合全面解析笔记英文单词一.容器定义 1.1.容器继承体系二.Set--------容器类部分方法数学集合意义 2.1 HashSet 2.1.1 基本用法 2.1.2 特 ...
Scala编程基础——集合高阶函数
Scala编程基础--集合&高阶函数集合 Scala中集合分为可变集合和不可变集合可变集合:可以修改.添加.移除一个集合的元素. 不可变集合:安全的并发访问. 不可变集合,相比之下,永远不 ...
J2EE基础集合框架之Set
今天将进行介绍的是J2EE基础集合框架之Set,其主要分为四个点目录 1,set集合特点&遍历集合 2,set集合去重原理 3,set集自然排序接口 4,set集合比较器排序 1,set集合 ...
java基础—集合框架
java基础-集合框架 JDK1.2开始引入了集合框架的概念,以弥补java中只有数组这种容器的单一问题,这些框架多数由接口构成,另外也包含了一些对于接口实现的类,其中这些接口的最上层接口为java. ...
java基础习题集_java基础集合经典训练题
第一题:要求产生10个随机的字符串,每一个字符串互相不重复,每一个字符串中组成的字符(a-zA-Z0-9)也不相同,每个字符串长度为10; 分析:*1.看到这个题目,或许你脑海中会想到很多方法,比如判 ...
Java基础---集合的概述---list、set、map、泛型、collections
集合的概述单列集合的体系: Collection 单列集合的顶层接口 List Collection的子接口,增加了一些特有的方法,有序可以重复有索引 ArrayList 底层采用的数组结构实现 ...
Java基础-------集合框架
一,集合简介 1.1 集合由来: 对象的存储:①数组(基本数据类型 & 引用数据类型) ②集合(引用数据类型) >数组存储数据的弊端:长度一旦初始化以后,就不可变:真正给数组 ...
JAVA基础---集合（一）--集合框架概述
为什么用集合如何合理用集合,以及如何实现的和他们的实现原理,如果搞清了对于之后学习其他知识和开发是很有大帮助性的. 什么是集合框架? 集合框架是表示和操作集合的统一体系结构.所有集合框架都包含以下内容 ...
JAVA基础+集合+多线程+JVM
1. Java 基础 1.1. 面向对象和面向过程的区别面向过程性能比面向对象高. 因为类调用时需要实例化,开销比较大,比较消耗资源,所以当性能是最重要的考量因素的时候等一般采用面向过程开发.但是 ...