可变序列有：列表，字典
不可变序列：字符串，元组

元组

元组是Python内置结构之一，是一个不可变序列。

元组的创建

1.第一种创建方式：使用（）

print('使用()的时候')
t = ('Python','world',98)
print(t)
print(type(t))

print('不使用()的时候')
t = 'Python','world',98
print(t)
print(type(t))

print('只有一个元素的时候')
t = 'Python',                  #这里不加，系统就会认为是str类型
print(t)
print(type(t))

2.第二种创建方式：使用函数tuple()

print('使用函数tuple()的时候')
t1= tuple(('Python','world',99))
print(t1)
print(type(t1))

对比：空列表、空字典、空元组

lst=[]
lst1=list()

d={}
d1 = dict()

t = ()
t4 = tuple()
print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',t,t4)

为什么要把元组设计成不可变序列？
答：在多任务环境下，同时操作对象时需要加锁，保证了数据的安全性。而使用元组这种不可变序列，用户都不能进行增、删、改的操作，所以保证了数据的安全。

注意：元组中存储的是对象的引用
1.如果元组中对象本身不可变对象，则不能引用其他对象（10,9这样的整数不可变的）
2.如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。（元组中的列表是可变的）
如下列的代码所示：

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]))

print('尝试将t1修改为100,未果，只能添加列表后的元素')

#  t[1]=100          元组不可以被修改

t[1].append(100)
print(t,id(t[1]))           #ID不变

元组的遍历

1.第一种方式就是使用 索引，缺点是要提前知道有多少元素。

t=('Python','world',98)
print(t[0])
print(t[1])
print(t[2])
#   print(t[3])  报错

2.第二种方法就是使用遍历元组。

print('2使用遍历元组')
for item in t:
    print(item)

没有元组生成式！

集合

与列表，字典一样都属于可变类型的序列
集合是没有value的字典！与字典具有相同的特点：
1.是无序的，通过哈希函数来定位。
2字典中要求key不相同，所以集合中的元素不予许重复。

#集合的创建
1直接创建,用{}

s={2,3,4,5,5,6,7,7}
print(s)              #结果为{2, 3, 4, 5, 6, 7}  ，说明集合不允许重复

2使用内置函数set（）

s1=set(range(6))
print('s1:',s1,type(s1)) 

s2=set([1,2,4,5,5,5,6,6])
print('s2:',s2,type(s2))          #将列表转换成了集合，同时去掉了相同的元素

s3=set('Python')
print('s3:',s3,type(s3))               #{'h', 't', 'y', 'o', 'P', 'n'}明显是无序的

s4=set({12,4,34,44,98,66})
print('s4:',s4,type(s4))              #{34, 98, 4, 66, 12, 44}也是无序的

s5=set()
print('s5:',s5,type(s5))

集合的相关操作

1.集合元素的判断操作：in or not in

s={2,3,4,5,5,6,7,7}
print(10 in s)   #False
print(7 in s)    #True

2。集合元素的新增操作：.add() .update()

s={2,3,4,5,5,6,7,7}
s.add(80)                       #add一次添加一个元素
print(s)

s.update({200,400,300})          #update添加多个元素，字典、列表、元组  都可以使用
s.update([100,99,8])
s.update((78,64,56))
print(s)

3.集合元素的删除操作
remove()、 discard()、 pop() 、clear()

s.remove(100)               #不能删除里面没有的元素
print(s)

s.discard(500)                #里面没有这个元素也不会报错
print(s)

s.pop()
print(s)                    #不能指定参数

s.clear()
print(s)                #全部清空

集合之间的关系

1.两个集合相等，再次说明集合是无序的。

s={10,20,30,40}
s2={30,40,20,10}
print(s==s2)           #True
print(s!=s2)           #False      

2.一个是另一个的子集 ： issubset（）

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

3.一个是另一个集合的超集：issuperset（）

s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s1.issuperset(s2))       #True
print(s1.issuperset(s3))       #False

4.判断是否交集的关系 ： isdisjoint（） 是没有交集的意思

s2={10,20,30,40}
s3={10,20,90}
s4={100,200,300}
print(s2.isdisjoint(s3))                 #False
print(s2.isdisjoint(s4))             #True

集合的数学操作

1交集 2并集 3 差集 4 对称差集

1交集 .intersection() 或者 &

s1={10,20,30,40,50,60}
s2={10,20,30,70}
print(s1.intersection(s2))          #也是无序的
print(s1 & s2)

2并集 .union() 或者 |

s1={10,20,30,40,50,60}
s2={10,20,30,70}
s3={10,20,90}
print(s1.union(s3))
print(s1|s2)

3 差集

s1={10,20,30,40,50,60}
s2={10,20,30,70}
print(s1.difference(s2))         #相当于  s1-s1s2
print(s1-s2)

4 对称差集

s1={10,20,30,40,50,60}
s2={10,20,30,70}
print(s1.symmetric_difference(s2))

结合生成式 {}

只用把列表生成式的[]改为{}就是集合生成式

lst=[i*i for i in range(10)]
print(lst)       #有序的列表

s={i*i for i in range(10)}
print(s)      #无序的集合

总结