马士兵python学习杨淑娟老师第七章--元组和集合

什么是元组

        元组是Python内置的数据结构之一，是一个不可变序列。t=('Python','hello',90)#        

        不可变序列：字符串、元组，没有增删改操作

        可变序列：列表、字典，可以对序列执行增删改操作，对象地址不发生改变

# 元组的创建方式

#直接小括号

t=('python','hello',98) #此处的小括号可以省略

print(t,type(t))

#使用内置函数

t=tuple(('python','hello',98))

print(t)

#如果只包含一个元素的元组，逗号不能省略

t1=(10) #int类型

print(t1,type(t1))

t2=(10,) #tuple类型

print(t2,type(t2))

#空列表的创建方式

lst=[]

lst1=list()

print('空列表',lst)

print('空列表',lst1)

#空字典的创建方式

d={}

d2=dict()

print('空字典',d)

print('空字典',d2)

#空元组的创建方式

t3=()

t4=tuple()

print('空元组',t3)

print('空元组',t4)

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

#         在多任务环境下，同时操作对象时不需要加锁。因此，在程序中尽量使用不可变对象。

#         注意事项：元组中存储的是对象的引用。如果元组中对象本身是不可变对象，则不能再引起其他对象；如果元组中的对象本身是可变对象，则可变对象的引用不允许改变，但数据可以改变。例如t=(10,[20,30],9)中，由于[20,30]是列表（可变序列）所以可以向列表中添加元素，而列表的内存地址不变。

#元组是不可变序列

t=(10,[20,30],90)

print(t,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].append(100) #在列表中添加元素100 或者 t[1] = t[1] + [100] 或者 t[1] = append(100)

print(t,id(t[1]))   # t[1]是列表，是可变序列，可以向列中添加元素，而列表的内存地址不变

#元组的遍历

t=tuple(('python','hello',90))

for item in t:

    print(item)

# 使用索引获得元组元素

print(t[0])

print(t[1])

print(t[2])

# 集合：Python语言提供的内置数据结构；与列表、字典一样都属于可变类型序列；集合是没有value的字典。

# 集合的创建

#直接使用{}

s={'python','hello',90}

print(s)

#使用内置函数

s1=set(range(6))

print(s1,type(s1))

print(set([3,4,53,56]))  #无序

print(set((3,4,43,435)))

print(set('python'))

print(set({124,3,4,4,5})) #集合不允许元素重复

#定义一个空集合

s2=set()  #s2={}创建的变量属于字典类型

print(s2,type(s2))

# 集合的相关操作

#判断

s={10,20,30,40,50,60}

print(10 in s)

print(100 in s)

print(100 not in s)

#新增，add()一次新增一个元素，update()至少添加一个元素

s.add(70)

print(s)

s.update({80,90})  #update可放集合

print(s)

s.update([100,110]) #update可放列表

print(s)

s.update((120,130)) #update可放元组

print(s)

#删除，remove，discard，pop，clear

s.remove(130) #一次删除一个指定元素，如果指定元素不存在，会报错

print(s)

'''s.remove(140)

print(s)会报错'''

s.discard(120)

print(s)

s.discard(140)  #一次删除一个指定元素，如果指定元素不存在，不会报错

print(s)

s.pop()  #不能指定参数，任意删除一个

print(s)

s.clear() #清空集合元素

print(s)

# 集合间的关系

#两个集合是否相等==,!=

s={10,20,30,40}

s1={30,40,20,10}

print(s==s1) #True, sets are equal iff their sets of elements are equal.

print(s!=s1) #false

#一个集合是否是另一个集合的子集

s2={10,20,30,40,50,60}

s3={10,20,30,40}

s4={10,20,40,90}

s5={70,80,90}

print(s3.issubset(s2)) #true

print(s4.issubset(s2)) #false

#一个集合是否是另一个集合的超集

print(s2.issuperset(s3)) #true

print(s2.issuperset(s4)) #false

#两个集合是否没有交集

print(s2.isdisjoint(s3)) #false 有交集

print(s2.isdisjoint(s4)) #false 有交集

print(s5.isdisjoint(s2)) #true 没有交集

#集合的数学操作

#交集操作

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)

# 集合生成式

s={i*i for i in range(1,10)}

print(s)

# 列表生成式

s=[i*i for i in range(1,10)]

print(s)

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

数据结构	是否可变	是否重复	是否有序	定义符号
列表list	可变	可重复	有序	[]
元组tuple	不可变	可重复	有序	()
字典dict	可变	key不可重复，value可重复	无序	{key,value}
集合set	可变	不可重复	无序	{}