Python入门(二) part2 元组

目录

一、元组的创建

1.小括号创建

2.tuple()方法转换

3.元组生成器

4.序列解包

二、访问元组

三、元组的更新和删除

四、元组相关的操作符

五、内置方法

六、解压元组

1.解压一维

2.解压二维

3.取指定元素

---

定义：语法为(元素1, 元素2, ..., 元素n)，用小括号把所有元素绑在一起，逗号将每个元素一一分开

特征：

• 元组内元素不能修改
• 但元组内元素的元素可以修改
• 元组可以使代码更安全
• 元组的访问速度比列表更快，开销更小
• 如果要定义一系列常量值，只需要对他们进行遍历等操作，通常用元组不用列表
• 元组可用作字典的键(key)，也可许作为集合的元素，而列表不可以

一、元组的创建

1.小括号创建

• 创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

a = ()
b = (1,2,3)
c = ([0,1,2],3,4)
d = ({1,2},3,4)

print(type(a),type(b),type(c),type(d))
print(a,b,c,d)
print('='*40)

f = (1)    #单个元素不加逗号，会被python当成运算符
g = (1,)
print(f,type(f))    
print(g,type(g))

'''
<class 'tuple'> <class 'tuple'> <class 'tuple'> <class 'tuple'>
() (1, 2, 3) ([0, 1, 2], 3, 4) ({1, 2}, 3, 4)
========================================
1 <class 'int'>
(1,) <class 'tuple'>
'''

2.tuple()方法转换

tup_1 = '12345'        #字符串
tup_2 = [1,2,3,4]      #列表
tup_3 = {1,2,3,4}      #集合
tup_4 = {1:2,3:'hhh'}  #字典

print(tuple(tup_1),tuple(tup_2),tuple(tup_3),tuple(tup_4))  #tuple()和list方法类似

'''
('1', '2', '3', '4', '5') (1, 2, 3, 4) (1, 2, 3, 4) (1, 3)
'''

3.元组生成器

生成器表达式的语法与列表推导式十分相似，但本质不同。形式上，生成器表达式使用小括号作为定界符，其结果是一个生成器对象而并非元组

a = [2**i for i in range(0,10)]     #创建列表
b = (2**i for i in range(0,10))     #创建生成器对象

print(a)
print(b)
print("="*35)

print(tuple(b))                     #tuple()方法转换，用完了生成器中的对象
print("="*35)

b = (2**i for i in range(0,10))     #重新创建生成器对象
print(next(b))                      #next()方法访问迭代对象的下一个
print(next(b)) 

'''
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
<generator object <genexpr> at 0x000001E8F817F3C0>
===================================
(1, 2, 4, 8, 16, 32, 64, 128, 256, 512)
===================================
1
2
'''

4.序列解包

序列解包的本质是对多个变量同时进行赋值，也就是把一个序列或可迭代对象中的多个元素的值同时赋值给多个变量，要求等号左侧变量的数量和等号右侧值的数量必须一致

x,y,z = 1,2,3             # 多个变量同时赋值
print(x,y,z)

x,y,z = ('abc',4.6,True)  # 元组支持序列解包
print(x,y,z)
 
x,y,z = [1,2,'3']         # 列表支持序列解包
x,y = y,x                 # 交换两个变量的值
x,y,z = map(int,'345')    # map对象支持序列解包
 
data = {1:'2','3':4}      
x_1,y_1 = data.keys()     # 对字典的"键"进行序列解包
x_2,y_2 = data.values()   # 对字典的"值"进行序列解包
print(x_1,y_1,x_2,y_2)

'''
1 2 3
abc 4.6 True
1 3 2 4
'''

二、访问元组

元组的访问和列表类似，也可以对元组进行索引tuple.index()和切片

'''tuple.index()'''
a = (1,2,3,'4',[5,6])
print(a.index(3))
print('='*30)

'''切片'''
b = (1,2,3,4,'5',6,[7,8],9)
print(b[1])  
print(b[5:])  
print(b[:5])  

c = b[:]
print(c)  

'''
2
==============================
2
(6, [7, 8], 9)
(1, 2, 3, 4, '5')
(1, 2, 3, 4, '5', 6, [7, 8], 9)
'''

三、元组的更新和删除

元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，如列表、集合、字典等，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

a = ([0,1,2],2,2,3)
a[1] =  3    #报错
a[0][1] = 3    #([0, 3, 2], 2, 2, 3)

对于元组元素不可变的特点来说，只能通过切片的方式更新元组的元素

#更新
a = (1,2,'3',[4,5,6],7)
a[3][0] = 5
print(a)

a = a[0:2] + a[3:4]
print(a)

'''
(1, 2, '3', [5, 5, 6], 7)
(1, 2, [5, 5, 6])
'''

同样的，只能删除整个元组，不能单独删除一个元素，不过可以通过切片的方式间接去除元素

a = (1,2,3)
del a

a = (1,2,3,4,5)
a = a[0:2] + a[3:5]
print(a)

'''
(1, 2, 4, 5)
'''

四、元组相关的操作符

• 等号操作符：==
• 连接操作符 +
• 重复操作符 *
• 成员关系操作符 in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)

print(t1 == t2)  # False
print(t1 == t3)  # True

t4 = t1 + t2
print(t4)  # (123, 456, 456, 123)

t5 = t3 * 3
print(t5)  # (123, 456, 123, 456, 123, 456)

t3 *= 3
print(t3)  # (123, 456, 123, 456, 123, 456)

print(123 in t3)  # True
print(456 not in t3)  # False

五、内置方法

tuple.count()和tuple.index()

a = (1,2,2,3,3,4,4,4)
a.count(3)   #2

a = (1,2,3,'4',[5,6])
a.index([5,6])     #4

六、解压元组

1.解压一维

解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t = (1,1.2,'345',[5,6,7])
(a,b,c,d) = t
print(a,b,c,d)

'''
1 1.2 345 [5, 6, 7]
'''

2.解压二维

解压二维元组（按照元组里的元组结构来定义变量）

t = (2,2.3,(3,4,5),[6,7,8])
(a,b,c,d) = t
print(a,b,c,d)
print('='*20)

(a,b,(c,d,e),f) = t
print(a,b,c,d,e,f)
print('='*20)

(a,b,c,[d,e,f]) = t
print(a,b,c,d,e,f)

'''
2 2.3 (3, 4, 5) [6, 7, 8]
====================
2 2.3 3 4 5 [6, 7, 8]
====================
2 2.3 (3, 4, 5) 6 7 8
'''

3.取指定元素

如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。

t = (2,2.3,(3,4,5),[6,7,8])
a,b,*rest_1 = t         #取前两个，其余的用*rest_1代替
*rest_2,d = t           #取最后一个，其余的用*rest_2代替
print(a,b,d)                    
print(*rest_1,' | ',*rest_2)

'''
2 2.3 [6, 7, 8]
(3, 4, 5) [6, 7, 8]  |  2 2.3 (3, 4, 5)
''' 

如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」（*_依旧能打印出来，但比*rest好写一点）

t = (2,2.3,(3,4,5),[6,7,8])
a,b,*_ = t         #取前两个，其余的用*_代替
*_,d = t           #取最后一个，其余的用*_代替
print(a,b,d)                    

'''
2 2.3 [6, 7, 8]
'''