python入门到精通第八章

什么是元组

元组是python内置的数据结构之一，是一个不可变序列

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

python
s="hello"
print(s,id(s)) # hello 2310315349424
s=s+"python"
print(s,id(s)) # hellopython 2310315349936

可变序列：列表、字典，可以对序列进行增、删、改操作，对象的地址不会改变

python
lst=[20,50,32]
print(lst,id(lst)) # [20, 50, 32] 2310314979712
lst.append(84)
print(lst,id(lst)) # [20, 50, 32, 84] 2310314979712

元组的创建方式

使用 () 和内置函数 tuple() 创建元组，只包含一个元组的元素需要使用逗号和小括号

python
t=('python','world',65) # 使用小括号创建元组
print(t,type(t))

t2='python','world',65 # 可以把小括号省略
print(t2,type(t2))
t3=('python',) # 只有一个元组需要在元素后面加上逗号
print(t3,type(t3))

t1=tuple(('python','world',65)) # 内置函数tuple()创建元组
print(t1,type(t1))

元组中存储的是对象的引用，元组中的对象是不可变对象，不能再引用其他对象，如果元组中的对象是可变对象，可变对象的引用不允许修改，但是数据可以改变

python
t=(10,[20,30],15)
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(89) # [20,30]是列表，列表是可以变对象，可以修改列表的数据，在列表中添加元素
print(t,id(t[1])) # t[1]的列表地址不变

元组的遍历

元组是可迭代对象，可以使用 for x in (1,2,3) 遍历。

python
t=('python','world',65)
for item in t:
    print(item)

集合的创建

集合是python的内置数据结构，是属于可变类型的序列，集合没有value的字典。集合创建方式如下：

python
s={1,2,3,3,4,5,5} # 集合的元素不允许重复，重复的元素会自动去掉
print(s)

s1=set(range(6)) # 第二种创建方式
print(s1,type(s1))

s2=set([2,3,3,5,6,6]) # 可以把列表中的元素转成集合的元素
print(s2,type(s2))

s3=set((3,2,90,35,23))
print(s3,type(s3))

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

s5=set({23,56,31,94,98})
print(s5,type(s5))

s6=set() # 定义空集合
print(s6,type(s6))

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

判断集合中是否存在指定的元素

python
s={10,52,73,6,85,35}
print(10 in s) # True
print(100 in s) # False
print(10 not in s) # False
print(100 not in s) # True

集合的新增操作

python
s={10,52,73,6,85,35}
s.add(152) # 一次添加一个元素
s.update({100,200,300}) # update 一次至少可以添加一个元素
s.update([39,94,58])
s.update((58,97))
print(s)

集合的删除操作

python
s={10,52,73,100,85,35}
s.remove(100) # 删除一个指定的元素，如果元素不存在会报错
print(s)
s.discard(500) # 如果删除一个不存在的元素，不会报错
print(s)
s.pop() # 随机任意一个元素，这个pop()方法不能添加参数
print(s)
s.clear() # 清空元素
print(s)

集合之间的关系

python
s={10,20,30,40,50,60}
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,70}
print(s==s1) # True 判断集合是否相等（元素相同就相等）
print(s!=s1) # False
print(s2.issubset(s1)) # True 判断s2是不是s1的子集
print(s3.issubset(s1)) # False
print(s1.issuperset(s2)) # True 判断s1是不是s2的超集
print(s1.issuperset(s3)) # False
print(s2.isdisjoint(s3)) # 判断元素是否没有交集，没有交集为True

集合的交集操作

python
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2) # intersection()与 & 是一样的效果，交集操作

集合的并集操作

python
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.union(s2))
print(s1 | s2) # union() 与 | 等价

集合的差集操作

python
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.difference(s2))
print(s1 - s2) # difference() 与 - 等价

集合的对称差集操作

python
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.symmetric_difference(s2))
print(s1 ^ s2) # symmetric_difference() 与 ^ 等价

集合推导式

集合生成式

python
s={i*i for i in range(6)}
print(s)