第八章 我也不知道叫啥

1.什么是元组

2.元组的创建方式

3.元组的遍历

4.什么是集合

5.集合的创建

6.集合的增删改查操作

7.集合生成式

（两种新的数据结构。不同于列表与字典

什么是元组

元组

python 内置的数据结构之一，是一个不可变序列（没有增删改操作）

不可变序列与可变序列

不可变：字符串，元组

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

'''不可变序列  可变序列'''
'''可变序列：列表，字典'''
lst=[19,2,222]
print(id(lst))
lst.append(30)
print(id(lst))#内存地址没有发生更改
'''不可变序列：字符串 元组'''
a='hello'
print(id(a))
a=a+'world'
print(id(a))#地址发生了更改
print(a)

元组的创建方式

'''直接使用（）'''

t=('python','world',98)
print(t)
print(type(t))

t2='python','world',98
print(t2)#这种方式小括号可以省略
print(type(t2))


'''使用内置函数tuple'''
t1=tuple(('pyhton',98))
print(t1)


'''注意：只包含一个元组的元素需要使用逗号'''
t3='python'
print(type(t3))
t4='python',
print(t4)
print(type(t4))


'''空元组的创建方式 '''
lst=[]
lst=list()
print(lst)#空列表的两种创建

d={}
d=dict()
print(d)#空字典的两种创建

t5=()
t5=tuple()
print(t5)#空元组的两种创建

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

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

注意：

元组存储的是对象的引用

a.如果元组中对象本身是不可变对象，则不能再引用其他对象

b.如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

t=(10,[30,40],9)
print(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,报错，元组不允许修改元素
'''列表是可变序列，可以向列表中添加元素，而列表的内存地址不变'''
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)#item代表元组当中每一个元素

什么是集合

1.python语言提供的内置数据结构

2.与列表、字典一样都属于可变类型的序列

3.集合是没有value的字典

集合的创建

'''第一种创建方式，使用{}'''
s={1,1,2,3,4,4}
print(s)#集合与字典相同，不能重复（字典是键不能重复）


'''第二种使用内置函数set（）'''

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

s2=set([1,2,2,3,4,5])
print(s2,type(s2))#去掉了重复元素，将列表转换为集合

s3=set((1,1,6,3,4,5,5,65))
print(s3,type(s3))#将元组转换为集合，顺序也变了，集合中的元素是无序的

s4=set('python')
print(s4,type(s4))

s5=set({1,2,3,21,34,11,1})
print(s5,type(s5))


#定义一个空集合
s6={}
print(type(s6))#这是个字典，这样定义不可以

s7=set()
print(s7,type(s7))

集合的相关操作

判断操作

in             not in

新增操作

'''集合元素的新增'''
#add一次添加一个元素
s={1,2,311,324,55,422}
s.add(80)
print(s)
#update一次至少添加一个元素
s.update({200,12,34,54})
print(s)

s.update([12,321,34])#添加列表
s.update((2,12,4343,44))#添加元组
print(s)

删除操作

'''集合元素的删除操作'''
#remove，一次删除一个指定元素，如果指定元素不存在，抛出keyerror
s.remove(1)
print(s)
#s.remove(3),元素一定要存在，否则异常KeyError: 3

#discard，一个删除一个指定一个元素，如果指定元素不存在，不抛出异常
s.discard(500)
print(s)

#pop,一次只删除一个任意元素，不能自己添加参数
s.pop()
print(s)
#s.pop(34),TypeError: set.pop() takes no arguments (1 given)

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

集合间的关系

'''两个集合是否相等（元素相同就相等）'''

s={10,20,30,40}
s1={30,40,20,10}
print(s==s1)#集合是无序的，所以True
print(s!=s1)

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

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

'''两个集合是否不含有交集'''
print(s3.isdisjoint(s4))

集合的数据操作

'''交集'''
s1={10,20,30}
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)

集合生成式

1.用于生成集合的公式

2.将{}修改为【】就是列表生成式

3.没有元组生成式（不可变序列）

'''列表生成式'''
lst=[i*i for i in range(10)]
print(lst)


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

第八章总结