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

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


文章目录

  • 【Python】第七部分 元组和集合
  • 7. 元组和集合
    • 7.1 什么是元组?
    • 7.2 什么是可变序列?什么是不可变序列?
    • 7.3 为什么要将元组设计成不可变序列?
    • 7.4 元组相关操作
    • 7.5 什么是集合?
    • 7.6 集合的创建
    • 7.7 集合相关操作
    • 7.8 判断集合的关系
    • 7.9 集合的数据类型
    • 7.10 集合生成式
    • 7.11 总结列表、元组、字典、集合
  • 总结


7. 元组和集合

7.1 什么是元组?

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


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

  1. 可变序列可以对序列进行增删改,并且对象的地址不发生改变

  2. 不可变序列没有增删改的操作


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

  1. 多任务环境下,同时操作对象的时候不需要加锁

  2. 不可变序列,没有增删改的操作,所以只能去查看,这就是第一点说的不需要加锁

  3. 需要注意的是:元组中存储的是对象的引用

  4. 如果元组中的对象是不可变对象,则不能在引用其他的对象

  5. 如果元组中的对象是可变对象,则可变对象的引用不可改变,但是数据可以改变

# 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 集合的创建

  1. {value,value}
  2. 使用内置的set()函数
# 1. {value,value}
s = {123, 456, 789}
print(s, type(s))  # {456, 123, 789} 

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

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

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

7.7 集合相关操作

  1. 判断操作
    • in 判断是否存在
    • not in 判断是否不存在
  2. 新增操作
    • add( ) 一次新增一个元素
    • update( ) 一次新增多个元素
  3. 删除操作
    • 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 判断集合的关系

  1. == != 判断集合是否相等
  2. issubset() 判断一个集合是否是另一个集合的子集
  3. issuperset() 判断一个集合是否是另一个集合的超集
  4. 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 集合的数据类型

  1. 交集 intersection()
  2. 并集 union()
  3. 差集 difference()
  4. 对称差集 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} 

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

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

总结

以上就是今天要讲的内容,希望对大家有所帮助!!!

你可能感兴趣的:(Python,python,开发语言)