Python中的元组和集合

1. 元组

1.1 什么是元组

Python内置的数据结构之一，是一个不可变序列。
例如： t=(‘python’,‘hello’,90)

1.1.1 不可变序列与可变序列

不可变序列：没有增、删、改的操作。
例如：字符串、元组。
可变序列
可以对序列执行增、删、改操作，对象地址不发生更改。
例如：列表、字典、集合。

# 可变序列：列表、字典
lst=[10,20,45]
print(lst,id(lst))
lst.append(30)
print(lst,id(lst))

# 不可变序列：元组、字符串
s='hello'
print(s,id(s))
s=s+'world'
print(s,id(s))

1.1.2 元组的创建方式

1. 直接小括号 t=(‘python’,‘hello’,90)
2. 使用内置函数t=tuple((‘python’,‘hello’,90))
3. 只包含一个元组的元素需要使用小括号和逗号 t=(10,)

# 元组的创建方式
'''第一种 使用小括号()'''
t=('python','world',20)
print(t,type(t))

t='python','world',20  # 元组的小括号可以省略
print(t,type(t))

t=('python',) # 如果元组种只含有一个元素，要加上逗号
print(t,type(t))

'''第二种创建方式 使用内置函数tuple()'''
t=tuple(('python','world',20))
print(t,type(t))

'''空列表的创建方式'''
lst=[]
lst1=list()
print(lst)
print(lst1)

'''空字典的创建方式'''
d={}
d1=dict()
print(d)
print(d1)

'''空元组的创建方式'''
t=()
t1=tuple()
print(t)
print(t1)

为什么要将元组设计成不可变序列？
在多任务环境下，同时操作对象时不需要加锁，因此，在程序种尽量使用不可变序列。

注意事项：元组中存储的是对象的引用。
a）如果元组中对象本身是不可变对象，则不能再引用其他对象。
b）如果元组中对象本身是可变对象，则可变对象的引用不允许改变，但数据可以改变。
示意图：

t=(10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
print(id(100))
#t[1]=100  元组不允许修改元素
'''由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变'''
t[1].append(100)
print(t,id(t))

1.2 元组的遍历

元组是可迭代对象，所以可以使用for in 遍历。

# 获取元组中的元素
'''第一种方式，通过索引的方式 但是必须知道元组中元素的个数'''
t=('python','world',98)
print(t[0])
print(t[1])
print(t[2])
'''第二种方式 for...in  遍历'''
for item in t:
    print(item)

2. 集合

2.1 什么是集合

1. python语言提供的内置数据结构
2. 与列表、字典一样都属于可变类型的序列
3. 集合是没有value的字典
   

2.2 集合的创建

1. 直接{ }
   例如 ：s={‘python’,‘hello’,90}
2. 使用内置函数set()
   例如 ：s=set(range(6))

# 集合的创建
'''第一种创建方式 使用花括号{}'''
s={2,3,55,6,6} # 集合中的元素不允许重复
print(s)

'''第二种创建方式 使用内置函数set()'''
s=set(range(6))
print(s,type(s))
s=set([10,20,30]) # 将列表数据类型转换成集合数据类型
print(s,type(s))
s=set((10,20,30,40)) # 将元组数据类型转换成集合数据类型
print(s,type(s))
s=set('python')  # 将字符串数据类型转换成集合数据类型
print(s,type(s))
s=set({12,3,456,8,3})
print(s)

'''定义空集合'''
# s={} 类型为dict
s=set()
print(s,type(s))

2.2 集合的增、删、改、查操作

2.2.1 集合元素的判断操作

in 或 not in

# 集合元素的判断操作
s={10,20,30,40,50}
print(10 in s)
print(100 in s)
print(10 not in s)
print(100 not in s)

2.2.2 集合元素的新增操作

1. 调用add()方法，一次添中一个元素
2. 调用update()方法，一次至少添中一个元素

# 集合元素的新增操作
'''一次添加一个元素'''
s.add(80)
print(s)
'''一次至少添加一个元素'''
s.update({200,400,300})
print(s)
print(s)
s.update([12,546,87])
print(s)
print(s)
s.update((45,89,76))
print(s)

2.2.3 集合元素的删除操作

1. 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
2. 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在抛出异常
3. 调用pop()方法，一次删除一个任意元素
4. 调用clear()方法，清空集合

# 集合元素的删除操作
'''一次删除一个指定元素'''
s.remove(89)
print(s)
# s.remove(500) 抛出异常
s.discard(500)  # 不会抛出异常
'''一次删除一个任意元素'''
s.pop()
print(s)
s.pop()
print(s)
# s.pop(400) 抛出异常 不能指定参数
'''清空集合'''
s.clear()
print(s)

2.3 集合生成式

2.3.1 集合间的相关关系

1. 集合是否相等
可以使用运算符==或！=进行判断
2. 一个集合是否是另一个集合的子集
可以调用issubset进行判断B是A的子集
3. 一个集合是否是另一个集合的超集
可以调用issuperset进行判断B是A的超集
4. 两个集合是否没有交集
可以调用isdisjoint方法进行判断

# 集合间的关系
'''两个集合是否相等（元素相同，就相等）'''
s1={10,20,30,40}
s2={30,40,20,10}
print(s1==s2)  # True 集合中的元素是无序的

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

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))
print(s1.issuperset(s3))

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

2.3.2 集合的数据操作

1. 交集操作
2. 并集操作
3. 差集操作
4. 对称差集操作

# 集合的数学操作
'''交集操作'''
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)

'''并集操作'''
print(s1.union(s2))
print(s1 | s2)

'''差集操作'''
print(s1.difference(s2))
print(s1-s2)

'''对称差集操作'''
print(s1.symmetric_difference(s2))
print(s1^s2)

2.3.3 集合生成式

集合生成式：生成集合的公式
$$i\ast iforiinrange(1,10)$$
注：没有元组生成式

# 集合生成式：生成集合的公式
s={i*i for i in range(10)}
print(s)