【速通Python】Day 6【元组 创建方式 tuple() 遍历 for...in... 集合 创建方式 set() 判断 增删操作 集合关系判断 数学操作 集合生成式】

元组 集合

• 元组
  • Python的内置数据结构之一，是一个不可变序列
• 不可变序列与可变序列
  • 不可变序列：字符串，元组
    • 没有增，删，改操作
  • 可变序列：列表，字典
    • 可以对序列进行增，删，改操作，对象地址不发生改变

"""可变序列  列表，字典"""
lst = [10, 20, 30]
print(id(lst))
lst.append(666)
print(id(lst))

'''不可变序列  字符串，元组'''
s = 'hello'
print(id(s))
s = s + 'world'  # 2138059117872
print(s, id(s))  # helloworld 2138059421232 拼接成功，但id发生了变化

创建方式

• 直接小括号
• 使用内置函数 tuple()
• 只包含一个元素的元组需要使用逗号和小括号

'''元组的创建方式'''
'''第一种，使用()'''
t = ('python', 'world', 98)
print(t)
print(type(t))

t2 = 'Python', 'world', 98  # 省略了小括号
print(t2)
print(type)

t3 = ('Python')
print(t3)
print(type(t3))  # <class 'str'>
# 只包含一个元素的元组需要使用逗号和小括号
t4 = ('Python',)
print(t4, type(t4))  # ('Python',) <class 'tuple'>

'''第二种，使用内置函数tuple()'''
t1 = tuple(('Python', 'world', 98))
print(t1)
print(type(t1))

# 空元组的创建方式
lst = []
lst1 = list()

d = {}
d2 = dict()

t5 = ()
t6 = tuple()

print('空列表', lst, lst1)
print('空字典', d, d2)
print('空元组', t5, t6)

为什么要把元组设计为不可变序列

• 在多任务环境（很多人要去操作）下，同时操作元组对象时不需要加锁（也即可以看但是不能增删改）
• 在程序中尽量使用不可变序列

当元组中存储的是对象的引用时，

1. 如果元组中的对象本身是不可变对象（比如说整数），则不能再引用其他对象
2. 如果元组中的对象是可变对象（比如说列表），则可变对象的引用不允许改变，但其中的数据可以改变（比如可以向列表中添加元素）

t = (10, [20, 30], 9)
print(t)
print(type(t))

print(t[0], type(t[0]), id(t[0]))  # 10 <class 'int'> 2847844139536
print(t[1], type(t[1]), id(t[1]))  # [20, 30] <class 'list'> 2847845532416
print(t[2], type(t[2]), id(t[2]))

'''尝试将t[1]修改为100'''
# t[1] = 100  # 元组是不允许修改元素的  # TypeError: 'tuple' object does not support item assignment

print(id(100))

'''由于[20, 30]列表，其为可变序列，所以可以向列中添加元素，而列表的内存地址不变'''
t[1].append(100)  # 向列表中添加元素
print(t, id(t[1]))  # 每次运行的结果内存地址都不一样，但是列表的内存地址在添加元素后不变

元组的遍历

• 元组元素的获取可以像列表一样通过索引去获取，但在使用索引时需要知道列表或元组当中有多少个元素，否则的话会出现索引越界的问题
• 如果不知道元组当中有多少元素时，最好的方法就是使用for…in进行遍历

t = ('Python', 'world', 98)

print(t[0])
print(t[1])
print(t[2])
# print(t[3])  # IndexError: tuple index out of range

for item in t:
    print(item)
# 输出了元组当中的每一个元素

集合

• Python语言提供的内置数据结构
• 与列表、字典一样都属于可变类型的序列
• 集合是没有value（值）的字典，简记为只有key（键）的字典

s = {2, 3, 4, 5, 5, 6, 7, 7}
print(s)  # {2, 3, 4, 5, 6, 7}

# 集合和字典的键相似，不能重复
# 会自动将重复的覆盖掉

s1 = set(range(6))
print(s1, type(s1))  # {0, 1, 2, 3, 4, 5} <class 'set'>

s2 = set([1, 2, 4, 34, 234, 2])
print(s2, type(s2))  # {1, 2, 34, 4, 234} <class 'set'>  同时去掉了列表中的重复元素 2

s3 = set((1, 65, 3, 4, 4, 5, 57))  # {65, 1, 3, 4, 5, 57} <class 'set'> 集合中的元素是无序的，可见出现了乱序
print(s3, type(s3))

s4 = set('python')  # 字符串序列
print(s4, type(s4))  # {'h', 'o', 't', 'n', 'y', 'p'} <class 'set'>

s5 = set({12, 4, 3, 234, 43, 34})
print(s5, type(s5))  # {34, 3, 4, 234, 43, 12} <class 'set'>

# 定义一个空集合
s6 = {}  # <class 'dict'> 字典类型
print(type(s6))

s7 = set()  # <class 'set'>
print(type(s7))

创建方式

• 直接**{}花括号**
  如：s = {‘Python’, ‘hello’, 90}
• 使用内置函数set()

集合的相关操作

• 判断操作 in 和 not in
• 新增操作
  • 调用 add()方法，一次添加一个元素
  • 调用 update()方法，一次至少添加一个元素
• 删除操作
  • 调用 remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出 KeyError
  • 调用 discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛出异常
  • 调用 pop()方法，一次只删除一个任意元素
  • 调用 clear()方法，清空集合

s = {10, 20, 30, 40, 50}
print(10 in s)  # True
print(100 in s)  # False
print(10 not in s)  # False
print(100 not in s)  # True

s.add(99)  # 一次添加一个元素
print(s)
s.update({200, 400, 300})  # 一次至少添加一个元素
print(s)
s.update([100, 98, 8])
s.update((78, 64, 56))
print(s)

s.remove(100)
print(s)
# s.remove(500)  # KeyError: 500
s.discard(500)  # 比remove()好些，不会抛异常
print(s)

s.pop()
s.pop()
# s.pop(400)  # TypeError: set.pop() takes no arguments (1 given) pop()是没有参数的
print(s)

s.clear()
print(s)  # set() 清空集合

集合之间的关系

• 使用== 或 != 判断两个集合是否相等
• 调用方法 issubset 判断一个集合是否是另一个集合的子集
• 调用方法 issuperset 判断一个集合是否是另一个集合的超集
• 调用方法 isdisjoint 判断两个集合是否没有交集

s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
# 列表是有序的，集合是无序的(其底层的存储顺序是相同的)
print(s == s2)  # True
print(s != s2)  # False

''' 一个集合是否是另一个集合的子集  超集'''
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.issubset(s1))  # True
print(s3.issubset(s1))  # False

print(s1.issuperset(s2))  # True
print(s1.issuperset(s3))  # False

''' 两个集合是否没有交集'''
print(s2.isdisjoint(s3))  # False  有交集
s4 = {100, 200, 300}

print(s2.isdisjoint(s4))  # True  无交集

集合的数学操作

交集
并集
差集
对称差集

# 交集操作
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))
print(s1 & s2)  # 并且 用来求交集， 与intersection()是等价的

# 并集操作
print(s1.union(s2))
print(s1 | s2)  # {40, 10, 50, 20, 60, 30} Python中 union() 与 | 是等价的并集操作

print(s1)
print(s2)  # 原集合没有发生变化

# 差集操作
print(s1.difference(s2))
print(s1 - s2)  # {10} - 和 difference() 等价的差集操作

print(s1)
print(s2)  # 原集合同样没有发生变化

# 对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)  # {50, 10, 60} 对称差集  并集相对于交集的补集

集合生成式

• 用于生成集合的公式
  元组是我们所学的四种中唯一一个不可变序列，所以元组是没有生成式的
• 将[]改为{}即可

lst = [i * i for i in range(6)]
print(lst)  # [0, 1, 4, 9, 16, 25]

s = {i * i for i in range(6)}
print(s)  # {0, 1, 4, 9, 16, 25}

s2 = {i * i for i in range(10)}
print(s2)  # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25} 无序