Python基础学习笔记（七）—

一、一维元组的介绍、创建与修改

元组（tuple），一种不可变、有序、可重复的数据结构，属于不可变序列，由小括号()内、用逗号分隔的一组元素组成。

与同为序列的列表一样，元组的元素可以是任意数据类型的对象的引用，并通过索引来访问元素；但区别于可变序列，元组作为不可变序列，我们无法在不改变原序列id的情况下，直接对元组进行增删改操作。

准确的说，应该是元组对对象的引用，也就是元素id，不能改变。如果元素指向不可变对象，那么改变它通常指的是改变id；但如果元素指向可变对象，则可以修改值而内存地址不变。

# 修改元组
t = (1, [2])
t[1][0] = 1

print(t)

(1, [1])

在实际应用中，不可变序列有一定优势。为了防止多端同时操作发生混乱，通常会在某一端操作时，对数据结构上锁。在多任务环境下，同时操作多个可变对象需要加锁，而不可变对象则不用。这是因为，它们只能被浏览或取出数据，而不能被修改，所以在程序中尽量使用不可变序列。

与列表同理，元组同样有赋值创建和引用创建，对应类似的函数tuple()。我们可以通过tuple()和list()实现元组的间接修改，即：使用list()函数把元组转化成列表，然后在列表上进行修改，最后使用tuple()转化回元组。

# 空元组
t = ()
t = tuple()

# 赋值创建
t = (1,)  # 单元素元组的创建格式
t = (1, 2, 3)
t = 1, 2, 3  # 省略写法

# 引用创建
t = tuple([1, 2, 3])
print(t)

# 间接修改
lst = list(t)
lst[0] = 0
t = tuple(lst)
print(t)

(1, 2, 3)
(0, 2, 3)

二、组合的基本操作

元组属于序列，适用于序列的所有基本操作，这部分内容在Python基础学习笔记（六）——列表中，这里不再重复。

以下操作适用于所有组合，包括列表、元组、字符串、集合、字典，下面主要以元组为例。

1. 遍历

t = 1, 2, 3
for i in t:
    print(i)

1
2
3

2. 取长度

len()函数：返回组合内的元素个数。

t = 1, 2, 3
print(len(t))

3. 取最值

max()函数：返回可迭代对象内元素的最大值。
min()函数：返回可迭代对象内元素的最小值。

t = 1, 2, 3
print(max(t), min(t))

3 1

4. 打包

zip()函数：将一个或多个可迭代对象的对应元素依次打包成元组，并返回由这些元组组成的zip对象迭代器。若输入的可迭代对象的长度不同，打包的元组数量取最短可迭代对象的长度。

d = {'a': 1}                           
t = 1, 2                               
s = {'a', 'b', 'c'}   
                 
# 打包单个可迭代对象                          
for i in zip(d):                       
    print(i)          
                     
# 打包多个不同长度的可迭代对象        
print(list(zip(t, s)))

('a',)
[(1, 'c'), (2, 'a')]

5. 批处理

5.1 map()函数

map(function, iterable)函数：对可迭代对象中的每一个元素调用指定函数，返回一个map对象迭代器。

t = 1, 2

for i in map(float, t):
    print(i)

1.0
2.0

5.2 lambda 表达式

lambda表达式是一种匿名函数，可在非正式定义函数的情况下使用。它由关键字lambda开头，后接参数列表，然后用冒号分隔，最后是一个表达式。
它们通常作为临时函数，用于执行简单操作或为其他函数传递参数。

add = lambda x, y: x + y
print(add(2, 3))

5.3 lambda 表达式 + map()函数

该模式允许我们更灵活地进行多个可迭代对象之间的自定义运算。

t1 = 1, 2, 3
t2 = 11, 22, 33
t3 = 10, 20, 30
# 参数列表与iterable依次对应
print(list(map(lambda x, y, z: x*y-z, t1, t2, t3)))

[1, 24, 69]

Python基础学习笔记（七）——元组

目录