元组基础
#
# 主题：元组基础
#
if __name__ == '__main__':
# 元组是不可变序列，没有增删改操作
# 修改不可变序列后，会生成新的对象，储存在新的位置
# 可变序列：列表、字典
# 不可变序列：字符串、元组
创建元组
#
# 主题：创建元组
#
if __name__ == '__main__':
# 使用 ()
t = ('python', 'world', 98)
print(t) # ('python', 'world', 98)
print(type(t)) # <class 'tuple'>
t = 'python', 'world', 100
print(t) # ('python', 'world', 100)
print(type(t)) # <class 'tuple'>
# 使用 tuple 函数
t1 = tuple(('python', 'world', 99))
print(t1) # ('python', 'world', 99)
print(type(t1)) # <class 'tuple'>
# 元组中只含有一个元素时，要加上逗号
t2 = (10, )
print(t2) # (10,)
print(type(t2)) # <class 'tuple'>
# 创建空元组
t = ()
print(t) # ()
t = tuple()
print(t) # ()
元组设计成不可变序列的原因
#
# 主题：元组设计成不可变序列的原因
#
if __name__ == '__main__':
# 可以规避因修改数据而导致的错误
# 在其他语言中，多个程序访问同一个对象时，需要锁的概念
# 元组在多任务环境下，同时操作对象时不需要加锁。因为元组的元素都是只读的而不能修改的
# 元组中对象是不可变对象，则不能再引用其他对象
# 元组中对象是可变对象，则可变对象的引用不允许改变，但数据可变
#
# 主题：元组设计成不可变序列的原因
#
if __name__ == '__main__':
# 元组中对象是不可变对象，则不能再引用其他对象
t = (10, [20, 30], 9)
print(t) # (10, [20, 30], 9)
print(type(t)) # <class 'tuple'>
for i in range(0,3):
print(t[i], type(t[i]), id(t[i])) # t[0] = 10, t[1] = [20, 30], t3 = 9
# type(t[0]) = int, type(t[1]) = list, type(t[2]) = int
# t 中三个对象的地址不相同
# 元组中对象是可变对象，则可变对象的引用不允许改变，但数据可变
# t[1] = 100 # 报错，因为元组不允许修改元素
print(id(t[1])) # 2317358293576
t[1].append(100) # 向 t[1] 的末尾添加元素
print(t) # (10, [20, 30, 100], 9)
# t[1] 是可变序列，允许增删改
print(id(t[1])) # 2317358293576
# 添加前后，t[1] 的地址未发生改变
遍历元组
#
# 主题：遍历元组
#
if __name__ == '__main__':
t = ('python', 'world', 99)
for item in t:
print(item)
集合基础
#
# 主题：集合
#
if __name__ == '__main__':
# 可变序列：列表、字典、集合
# 集合的存储地址与存储先后顺序无关，故集合中的元素出现顺序和储存的先后顺序无关（说明集合中的元素无序）
创建集合
#
# 主题：创建集合
#
if __name__ == '__main__':
# 使用 {}
s = {2, 3, 4, 5, 6, 7, 7}
print(s) # {2, 3, 4, 5, 6, 7}
# 集合中的元素不能重复
# 使用 set 函数
s = set(range(6))
print(s) # {0, 1, 2, 3, 4, 5}
print(type(s)) # <class 'set'>
s = set([1, 2, 3, 4, 5])# 将数列转换为集合
print(s) # {1, 2, 3, 4, 5}
print(type(s)) # <class 'set'>
s = set((1, 2, 3, 4)) # 将元组转换为集合
print(s) # {1, 2, 3, 4}
print(type(s)) # <class 'set'>
s = set('python') # 将字符串转换为集合
print(s) # {'h', 't', 'o', 'p', 'n', 'y'}
# 说明集合中的元素无序
print(type(s)) # <class 'set'>
s = set({1, 2, 3, 4}) # 将集合转换为集合
print(s) # {1, 2, 3, 4}
print(type(s)) # <class 'set'>
# 创建空集合
s = {}
print(type(s)) # <class 'dict'>
s = set()
print(type(s)) # <class 'set'>
判断集合元素
#
# 主题：判断集合元素
#
if __name__ == '__main__':
s = {1, 2, 3, 4, 5}
print(10 in s) # False
print(10 not in s) # True
添加集合元素
#
# 主题：添加集合元素
#
if __name__ == '__main__':
s = {1, 2, 3, 4, 5}
# add 方法添加一个集合元素
s.add(6)
print(s) # {1, 2, 3, 4, 5, 6}
# update 方法添加多个集合元素
s.update({10, 20, 30})
s.update([40, 50])
s.update((60, 70))
print(s) # {1, 2, 3, 4, 5, 6, 70, 40, 10, 50, 20, 60, 30}
集合的删除操作
#
# 主题：集合的删除操作
#
if __name__ == '__main__':
s = {1, 2, 3, 4, 5, 6, 7, 8}
s.remove(8) # 若要删除的元素不在原集合中，则报错 KeyError
print(s) # {1, 2, 3, 4, 5, 6, 7}
s.discard(6) # 若要删除的元素不在原集合中，则不报错
print(s) # {1, 2, 3, 4, 5, 7}
s.pop() # 删除任意元素
# 小括号内不能指定要删除的元素
print(s) # {2, 3, 4, 5, 7}
s.clear() # 清空集合
print(s) # set()
集合间的关系
#
# 主题：集合间的关系
#
if __name__ == '__main__':
# 判断两个集合是否相等
s1 = {10, 20, 30, 40}
s2 = {40, 30, 20, 10}
print(s1 == s2) # True
print(s1 != s2) # False
# 元素相同，则集合相等
# 判断一个集合是否是另一个集合的子集
s1 = {10, 20, 30, 40, 50, 60}
s2 = {40, 30, 20, 10}
s3 = {1, 2, 10}
print(s2.issubset(s1)) # True s2 是 s1 的子集
print(s3.issubset(s1)) # False s3 不是 s1 的子集
# 判断一个集合是否是另一个集合的超集
s1 = {10, 20, 30, 40, 50, 60}
s2 = {40, 30, 20, 10}
s3 = {1, 2, 10}
print(s1.issuperset(s2)) # True
print(s1.issuperset(s3)) # False
# 判断两个集合是否没有交集
s1 = {10, 20, 30, 40, 50, 60}
s2 = {40, 30, 20, 10}
s3 = {1, 2, 10}
print(s1.isdisjoint(s3)) # False s1 与 s3 有交集
print(s2.isdisjoint(s3)) # False s2 与 s3 有交集
集合的数学操作
#
# 主题：集合的数学操作
#
if __name__ == '__main__':
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
# 交集
print(s1.intersection(s2)) # {40, 20, 30}
print(s1 & s2) # {40, 20, 30}
# 并集
print(s1.union(s2)) # {40, 10, 50, 20, 60, 30}
print(s1 | s2) # {40, 10, 50, 20, 60, 30}
# 差集
print(s1.difference(s2)) # {10}
print(s1 - s2) # {10}
# 对称差集
print(s1.symmetric_difference(s2)) # {50, 10, 60}
print(s1 ^ s2) # {50, 10, 60}
总结
