【Python】第七部分元组和集合

文章目录

【Python】第七部分元组和集合
7. 元组和集合
总结

7. 元组和集合

7.1 什么是元组？

它是python中内置的数据结构之一，是不可变序列，有序，可以重复值。

7.2 什么是可变序列？什么是不可变序列？

可变序列：可以对序列进行增删改，并且对象的地址不发生改变
不可变序列：没有增删改的操作

7.3 为什么要将元组设计成不可变序列?

在多任务环境下,同时操作对象的时候不需要加锁
不可变序列,没有增删改的操作,所以只能去查看,这就是第一点说的不需要加锁
需要注意的是:元组中存储的是对象的引用
如果元组中的对象是不可变对象,则不能在引用其他的对象
如果元组中的对象是可变对象,则可变对象的引用不可改变,但是数据可以改变

# t是元组,里面的[20,30]是列表,列表是可变序列
# 但是地址不可变，可以修改值，对应第5点
t = (10, 30, 40)
t[1] = 50  # 报错不可以修改

# 因为t[1]是列表是可变序列，所以可以进行增删改
t = (10,[20,30],40)
t[1][0] = 50
print(t) # (10,[50,30],40)

# 需要注意的是如果值定义一个元组那么需要加 ，
t2 = ['hello',]

7.4 元组相关操作

t = (10, [20, 30], 40)
for item in t:
    print(item, end='\t')  # 10	 [20, 30]  40
print()

# 找到指定数据的下标
t1 = ('a','b','c')
print(t1.index('c'))

# 计算该元素出现的次数
t1 = ('a','b','c','a')
print(t1.count('a'))

# 该元组的长度
print(len(t1))

7.5 什么是集合？

集合是没有value的字典,它也是可变序列

7.6 集合的创建

{value,value}
使用内置的set()函数

# 1. {value,value}
s = {123, 456, 789}
print(s, type(s))  # {456, 123, 789} <class 'set'>

# 2. 使用内置的set()函数
s1 = set(range(1, 10))
print(s1, type(s1))  # {1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>

s2 = set('helloworld')
print(s2, type(s2))  # {'r', 'w', 'h', 'l', 'e', 'o', 'd'} <class 'set'>

# 创建空集合
s3 = {}
s4 = set()

7.7 集合相关操作

判断操作：
- in 判断是否存在
- not in 判断是否不存在
新增操作
- add( ) 一次新增一个元素
- update( ) 一次新增多个元素
删除操作
- remove( ) 一次删除一个指定的元素，如果该元素不存在会报错
- discard( ) 一次删除一个指定的元素，如果该元素不存在不会报错
- pop( ) 随机删除一个元素
- clear( ) 清空集合

# 集合的相关操作
# 1. 判断操作
s4 = {10, 20, 30, 40}
print(10 in s4)  # True
print(10 not in s4)  # False

# 2.新增操作
# 　如果添加一个元素使用add()
s5 = {10, 20, 30}
s5.add(40)

# 如果添加多个元素使用update()
s6 = {10, 230, 32, 2352, 6}
s6.update({10, 30, 2})
s6.update([66, 77, 888])
s6.update((55, 22, 3333))
print(s6)  # {32, 2, 66, 3333, 230, 6, 10, 77, 2352, 22, 55, 888, 30}
# 根据输出我们可以发现只输出了一个10，集合对于重复的值，只保留一个

# 3. 删除操作
s7 = {15, 5465, 478, 14, 4345, 634, 423}
# 1.remove(xx)　
# 一次删除一个指定的元素，如果该元素不存在会报错
s7.remove(15)
print(s7)  # {4345, 423, 14, 5465, 634, 478}

# 2.discard(xx)
# 一次删除一个指定的元素，如果该元素不存在不会报错
s7.discard(478)
print(s7)  # {4345, 423, 14, 5465, 634}

# 3. pop()
# 随机删除一个元素
s7.pop()
print(s7)  # {423, 14, 5465, 634}

# 4. clear()
# 清空集合
s7.clear()
print(s7)  # set()

7.8 判断集合的关系

== 和 != 判断集合是否相等
issubset() 判断一个集合是否是另一个集合的子集
issuperset() 判断一个集合是否是另一个集合的超集
isdisjoint() 判断两个集合是否没有交集

# 1. == 和 != 判断集合是否相等
j = {123, 456, 789}
i = {123, 456}
print(i == j)  # False
print(i != j)  # True

# 2. issubset(),判断一个集合是否是另一个集合的子集
print(j.issubset(i))  # False
print(i.issubset(j))  # True

# 3. issuperset(),判断一个集合是否是另一个集合的超集
print(j.issuperset(i))  # True
print(i.issuperset(j))  # False

# 4. isdisjoint(),判断两个集合是否没有交集
print(j.isdisjoint(i))  # False

7.9 集合的数据类型

交集 intersection()
并集 union()
差集 difference()
对称差集 symmetric_difference(s2)

# 1. 取交集
s1 = {123, 456, 789, 111}
s2 = {222, 123, 456, 789}
print(s1.intersection(s2))  # {456, 123, 789}
print(s1 & s2)  # {456, 123, 789}

# 2. 取并集
print(s1.union(s2))  # {456, 111, 789, 123, 222}
print(s1 | s2)  # {456, 111, 789, 123, 222}

# 3. 差集(s1有的，s2没有)
print(s1.difference(s2))  # {111}
print(s1 - s2)  # {111}

# 4. 对称差集 (除去交集外的元素)
print(s1.symmetric_difference(s2))  # {222, 111}
print(s1 ^ s2)  # {222, 111}

7.10 集合生成式

g = {item*item for item in range(10)}
print(g, type(g))  # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25} <class 'set'>

7.11 总结列表、元组、字典、集合

数据类型	是否可变	是否重复	是否有序	定义的符号
列表	可变	可以重复	有序	[ ]
元组	不可变	可以重复	有序	( )
字典	可变	key不可以重复，value可以重复	无序	{ key:value }
集合	可变	不可以重复	无序	{ }