Python 课程学习笔记（7）元组() t & 集合{} s

最新推荐文章于 2024-04-22 01:28:39 发布

默默耕耘的lanjing

最新推荐文章于 2024-04-22 01:28:39 发布

阅读量258

点赞数 1

分类专栏： python 学习笔记小白的各种学习日记

本文链接：https://blog.csdn.net/Happy19981998/article/details/115971952

版权

python 元组集合

python 学习笔记同时被 2 个专栏收录

16 篇文章 5 订阅

订阅专栏

小白的各种学习日记

12 篇文章 4 订阅

订阅专栏

第八章元组 ( ) t & 集合 { } s

66. 什么是元组

（1）元组：Python内置的数据结构之一，是一个不可变序列

不可变 —— 没有生成式

（2）不可变序列与可变序列：

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

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

print('--------------------66.什么是元组------------------')
print('''
不可变序列与可变序列：
①不可变序列：字符串、元组
		没有增、删、改操作''')
s='hello world'
print(id(s))
s=s+' 2021.03.30 周二'
print(id(s))
print(s)
print('''②可变序列：列表、字典
		可以对序列执行增、删、改操作，对象地址不发生改变''')
lst=[10,20,30,45]
print(id(lst))
lst.append(300)
print(id(lst))

67. 元组的创建方式

（1）直接小括号 #元组的小括号可以省略不写

（2）使用内置函数tuple()

（3）只包含一个元组的元素需要使用逗号和小括号

（4）空元祖

print('--------------------67.元组的创建方式------------------')
print('（1）直接小括号')
t = ('Python', 'hello', 90)
print(t)
print(type(t))
q='Python', 'hello', 90  #元组的小括号可以省略不写
print(q)
print(type(q))
print('（2）使用内置函数tuple()')
p=tuple(('Python', 'hello', 90))
print(p)
print(type(p))

print('（3）只包含一个元组的元素需要使用逗号和小括号')
r1=('Python')
r2=('Python',)
print(type(r1),type(r2))

print('''（4）
--空元祖--''')
t1=()
t2=tuple()
print(t1,t2)

print('--空列表--')
lst1=[]
lst2=list()
print(lst1,lst2)

print('--空字典--')
d1={}
d2=dict()
print(d1,d2)

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

（1）为什么要将元组设计成不可变序列

· 不可变，避免修改数据导致错误

· 在多任务环境下，同时操作对象时不需要加锁

· 因此，在程序中尽量使用不可变序列

（2）注意事项：元组中存储的是对象的引用

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

b ）如果元组中的对象是可变对象则可变对象的引用不允许改变，但数据可以改变（元组不变，其中的列表值可修改，可以增、删、改、清空，但是无法删除列表本身。）


print('-------------------68.为什么要将元组设计成不可变序列------------------')
print('''
· 在多任务环境下，同时操作对象时不需要加锁
· 因此，在程序中尽量使用不可变序列
''')
g=(10,[20,30,40],500)
print(g)
print(type(g))
print(g[0],type(t[0]),id(g[0]))
print(g[1],type(t[1]),id(g[1]))
print(g[2],type(t[2]),id(g[2]))
'''尝试将t[1]修改为100'''
print(id(100))
# g[1]=100   元组不允许修改其中元素 TypeError:'tuple' object does not support item assignment
print('''由于[20,30,40]为列表，而列表为可变序列，可以向其中添加元素，而列表内存地址不发生改变''')
print('增加列表元素')
print(id(g[1]))
g[1].append(88)
print(g)
print(id(g[1]))
print('修改列表元素')
g[1][0]=66
print(g)
print(id(g[1]))
print('删除列表元素')
g[1].remove(40)
print(g)
print('清空列表元素')
g[1].clear()
print(g)
# del g[1] 不可以删除

69. 元组的遍历

（1）元组是可迭代对象，所以可以使用 for…in 进行遍历

print('-------------------69.元组的遍历------------------')
t=('Python','world',78)
print('① 使用索引')
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) IndexError: tuple index out of range 超出范围

print('② 遍历元组')
for item in t:
    print(item)  # item 代表元组中的每一个元素

70. 集合的概述与创建

（1）集合

· Python 语言提供的内置数据结构

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

· 集合是没有value 的字典

（2）集合的创建方式

print('-------------------70.集合的概述与创建------------------')
print('①直接{}')
s={2,3,4,5,5,6,7,7}
print(s)  #集合中的元素不允许重复
print('②使用内置函数 set()')
s1=set(range(6))
print(s1,type(s1))
s2=set([3,4,53,56,3])
print(s2,type(s2))           #列表转集合
s3=set((3,4,43,435))
print(s3,type(s3))           #元组转集合
s4=set('python')
print(s4,type(s4))           #字符串转集合
s5=set({124,3,4,4,5})
print(s5,type(s5))          #集合本身也可以再转
print(set())

71. 集合的相关操作

（1）集合元素的判断操作：in或not in

（2）集合元素的新增操作

①调用add() 方法，一次添加一个元素

②调用update() 方法，至少添加一个元素

（3）集合元素的删除操作

①调用remove() 方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError

②调用discard() 方法，一次删除一个指定元素，如果指定的元素不存在不抛异常

③调用pop() 方法，一次只删除一个任意元素 à 无法制定

④调用clear() 方法，清空集合

print('-------------------71.集合的相关操作------------------')
print('今天是 2020-03-31')
print('（1）集合元素的判断操作')
s={10,20,30,405,60}
print(10 in s)
print(8 in s)
print(10 not in s)
print(100 not in s)

print('（2）集合元素的新增操作')
s.add(66)     #一次添加一个
print(s)

A={12}
s.update(A)
print(s)

s.update({200,400,600})  #添加集合
print(s)

s.update([1314,99])     #添加列表
print(s)

s.update((000,111))     #添加元组
print(s)

print('（3）集合元素的删除操作')
s.remove(1314)
print(s)
#s.remove(500)  KeyError: 500 ---> 元素不存在

s.discard(500)    # ---> 元素不存在，也不报错
print(s)

s.pop()   #删除任意元素
print(s)

s.pop()
print(s)

#s.pop(400)  TypeError: pop() takes no arguments (1 given)   --> 不能指定

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

72. 集合间的关系

（1）两个集合是否相等：可以使用运算符 = = 或！= 进行判断

（2）一个集合是否是另一个集合的子集：可以调用方法issubset 进行判断

（3）一个集合是否是另一个集合的超集：可以调用方法issuperset 进行判断

（4）两个集合是否没有交集：可以调用方法isdisjoint 进行判断

print('-------------------72.集合间的关系------------------')
print('（1）两个集合是否相等')
s={10,20,30,40}
s2={30,40,20,10}  #集合不考虑顺序
print(s==s2)
print(s!=s2)
print('（2）一个集合是否是另一个集合的子集')
s1={10,20,30,40,50,60}
s2={10,20,30}
s3={10,20,90}
print(s2.issubset(s1))    #True
print(s3.issubset(s1))    #False
print('（3）一个集合是否是另一个集合的超集')
print(s1.issuperset(s2))   #True
print(s1.issuperset(s3))   #False
print('（4）两个集合是否没有交集')
print(s2.isdisjoint(s3))   #False -->有交集
s4={200,300}
print(s2.isdisjoint(s4))   #True  -->无交集

73. 集合的数学操作

（1）交集 —— .intersection() 与 & 等价

（2）并集 —— .union() 与 | 等价

（3）差集 —— .difference() 与 – 等价

（4）对称差集 —— .symmetric_difference() 与 ^ 等价

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

print('（1）交集')
print(s1.intersection(s2))
print(s1 & s2)                     #.intersection() 与 & 等价
print(s1)
print(s2)                          #集合本身未发生变化

print('（2）并集')
print(s1.union(s2))                #去掉重复元素
print(s1 | s2)                    #.union() 与 |  等价
print(s1)
print(s2)

print('（3）差集')
print(s1.difference(s2))         #s1 -  s2
print(s1-s2)
print(s1)
print(s2)

print('（4）对称差集')
print(s1.symmetric_difference(s2))
print(s1^s2)

74. 集合生成式

（1）用于生成集合的公式 { i*i for i in range(1,10) }

（2）将 { } 修改为 [ ] 就是列表生成式 ^_^

（3）没有元组生成式

print('-------------------74.集合生成式------------------')

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

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