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