python学习_元组
一、什么是元组？
元组也是python内置的数据结构，是一个不可变的序列，他也可以存放不同数据类型的元素
不可变序列有：就是不可以改变的序列，没有增、删、改的操作，如元组、字符串就是不可变序列
可变序列：可以对序列进行增、删、改操作，对象地址不发生改变，如列表、字典等
'''不可变序列与可变序列 可变序列：列表、字典 不可变序列：字符串、元组 ''' lst=[10,20,30] print(lst,id(lst)) #id=2813843628680 lst.append(60) print(lst,id(lst)) #id=2813843628680，列表是可变序列,对列表进行增加操作，列表的内存地址不变 s='hello' print(id(s)) #id:2392792986544 s=s+'world' print(id(s)) #id:2392793796848，字符串为不可变序列，如果对字符串进行修改，字符串对象的内存地址发生了改变，变成了一个新的对象
二、元组的创建
元组的创建和列表类似，只不过列表用的是中括号[ ],元组用的是小括号( ),主要由以下几种情况：
- 方式1：使用小括号( )创建元组
t=('hello',98,'python') print(t) #('hello', 98, 'python')
- 方式2：使用内置函数tuple()创建元组，参数必须是可迭代对象
t=tuple(('hello',98,'python')) print(t) #('hello', 98, 'python')
- 方式3：:创建只有一个元素的元组
#创建只有一个元素的元组 t=('hello',) print(t,type(t)) #('hello',) <class 'tuple'>
- 方式 4：创建空元组
#创建空元组 t=() print(t,type(t)) #() <class 'tuple'>
'''元组的创建方式''' '''方式一：()''' t=('python','world',98) print(t,type(t)) #('python','world',98) <class 'tuple'> t2='python','world',98 #元组也是可以省略了小括号()的 print(t2,type(t2))
#当元组只有一个元素时 t3=('python') print(t3,type(t3)) #python <class 'str'> t4=('python',) print(t4,type(t4)) #('python',) <class 'tuple'> #通过t3和t4可知，元组只有一个元素时后面的逗号必须加上 '''方式二：内置函数tuple()''' t1=tuple(('world','hahah',55)) print(t1,type(t1)) '''空元组的创建''' tt=() tt1=tuple() print(tt) print(tt1)
三、为什么要将元组设计成不可变序列
将元组设计成不可变序列是因为在多任务环境下，同时操作对象时不需要加锁，因此，在程序中尽量使用不可变序列
元组中存储的是对象的引用,他的内存示意图如下：
注意：
1）如果元素中对象本身是不可变对象，则不能在引用其他对象，如下内存示意图显示
t[0]存放的是不可变对象10，所以不能再修改为其他数据
2）如果元组中元素本身是可变对象，则可变对象的引用不允许改变，但是数据可以改变，如下内存示意图显示：
t[1]存放的是列表，是可变对象，所以可变对象的引用不允许改变，也就是t[1]=100是不可以的，但是可变对象列表中可以添加数据t[1].append(100)是可以的
t=(10,[20,30],9) print(t,type(t)) print(t[0],type(t[0]),id(t[0])) print(t[1],type(t[1]),id(t[1])) #id：2541314269768 print(t[2],type(t[2]),id(t[2])) '''尝试修改t[1]'''#t[1]=100 #TypeError,因为元组中的元素是不允许修改的 '''但是因为t[1]是一个列表，列表是可变的序列，所以我们可以往列表中添加内容，列表的内存地址不会发生改变''' t[1].append(100) print(t) #(10, [20, 30, 100], 9) print(id(t[1])) #修改完数据后t[1]的内存地址应该是不变的，id：2541314269768
四、元组的操作
- 查询操作
t=(98,'hello',20,'python','FishC',100,20,300) #获取元组单个元素 print(t[0]) #98 print(t[-1]) #300，逆序索引获取最后一个元素 #获取元组多个元素 print(t[::]) #(98, 'hello', 20, 'python', 'FishC', 100, 20, 300) print(t[1::]) #('hello', 20, 'python', 'FishC', 100, 20, 300) print(t[:4:]) #(98, 'hello', 20, 'python') print(t[1:4:1]) #('hello', 20, 'python') print(t[1:6:2]) #('hello', 'python', 100) print(t[::-1]) #(300, 20, 100, 'FishC', 'python', 20, 'hello', 98) print(t[6:1:-2]) #(20, 'FishC', 20) #统计元素出现次数 print(t.count(20)) #2 print(t.count('python')) #1 #获取元素索引值 print(t.index('FishC')) #4 print(t.index(20)) #20 print(t.index(20,3,7)) #6
- 运算符操作
s=(1,2,3) t=(4,5,6) print(s+t) #(1, 2, 3, 4, 5, 6) print(s*3) #(1, 2, 3, 1, 2, 3, 1, 2, 3) print(t*2) #(4, 5, 6, 4, 5, 6)
- 元组的嵌套：
#元组的嵌套 s=(1,2,3) t=(4,5,6) new_t=(s,t) print(new_t) #((1, 2, 3), (4, 5, 6))
- 元组的遍历：
元组是一个可迭代对象，所以他也是可以用for...in循环进行遍历
'''元组的遍历''' #单元组的遍历 t=('hello','world',98) for item in t: print(item) #嵌套元组的遍历 s=((1,2,3),(4,5,6)) for i in s: for each in i: print(each)
- 利用列表推导式将元组转成列表
#利用列表推导式将元组转成列表 t=[1,2,3] lst=[each*2 for each in t] print(lst) #[2, 4, 6]
- 元组的打包和解包
#将一组数据组成一个元组就叫打包 t1=(123,'hello',3.14) #打包 print(t1) #将元组一次性赋值给多个变量的行为叫解包 x,y,z=t1 #解包 print(x) #123 print(y) #hello print(z) #3.14
注意：任何的序列类型的数据都适用这种打包和解包，同时解包时赋值号左边的变量数量必须和右边的元素个数一样
#列表的解包 lst=[123,'python',3.14] x,y,z=lst print(x) #123 print(y) #python print(z) #3.14 #字符串的解包 s='world' a,b,c,d,e=s print(a) #w print(b) #o print(c) #r print(d) #l print(e) #d
也可以使用下面这种形式
s='world' a,b,*c=s print(a) #w print(b) #o print(c) #rld
