Python之元祖（tuple）基础知识点

文章目录

• 一、创建元祖
• • [1.1 使用 () 创建元组](#1.1 使用 () 创建元组)
  • [1.2 使用 tuple()函数 创建元组](#1.2 使用 tuple()函数 创建元组)
  • [1.3 元组(单个元素)](#1.3 元组(单个元素))
  • [1.4 元组 VS 列表](#1.4 元组 VS 列表)
• 二、访问元组
• • [2.1 下标索引访问](#2.1 下标索引访问)
  • [2.2 切片访问](#2.2 切片访问)
  • [2.3 for 循环遍历元组](#2.3 for 循环遍历元组)
  • [2.4 检查项目是否存在](#2.4 检查项目是否存在)
  • [2.5 更改元组值](#2.5 更改元组值)
  • [2.6 元组连接(合并)/复制](#2.6 元组连接(合并)/复制)
  • [2.7 元组不可变性](#2.7 元组不可变性)
• 三、内置函数
• • [3.1 打印输出 print()](#3.1 打印输出 print())
  • [3.2 确定元组项目 len()](#3.2 确定元组项目 len())
  • [3.3 返回变量类型 type()](#3.3 返回变量类型 type())
• [四、其他类型转换为元组 tuple()](#四、其他类型转换为元组 tuple())
• • [4.1 str转tuple](#4.1 str转tuple)
  • [4.1 list转tuple](#4.1 list转tuple)
  • [4.3 set转tuple](#4.3 set转tuple)
  • [4.4 dict转tuple](#4.4 dict转tuple)
• [五、元组 tuple()转换为其他类型](#五、元组 tuple()转换为其他类型)
• • [5.1 tuple转str](#5.1 tuple转str)
  • [5.2 tuple转list](#5.2 tuple转list)
  • [5.3 tuple转set](#5.3 tuple转set)
  • [5.4 tuple转dict](#5.4 tuple转dict)
• 参考资料

tuple是一个 有序 的 不可变 序列，它的元素可以是任何类型，并且可以重复。tuple使用 小括号() 括起来，例如：(1, 2, 'a', 'b')。相比于list，tuple的操作比较受限，但它更加轻巧，因此可以提高代码的效率。

一、创建元祖

元组的创建很简单，使用圆括号 () 直接创建或者使用 tuple() 函数创建，只需要在圆括号中添加元素，并使用逗号隔开即可。

1.1 使用 () 创建元组

通过 () 创建元组后，使用 = 将它赋值给变量，格式如下：

tuple_name = (element_1, element_2, ..., element_n)

其中，tuple_name 表示变量名，element_1 ~ element_n 表示元组内的元素。

1.2 使用 tuple()函数 创建元组

我们除了可以使用 () 创建元组，还可以使用 tuple() 函数创建元组，但 tuple() 偏向于将某个类型转换为元组，具体用法见下述：

cre_tuple = tuple(('a', 'b', 'c'))  # 注意双括号
print(cre_tuple)
print(type(cre_tuple))

输出如下：

('a', 'b', 'c')
<class 'tuple'>

1.3 元组(单个元素)

当元组中只包含一个元素时，需要在元素后面添加逗号, ，否则括号会被当作运算符使用：

tuple_1 = (20)
print(type(tuple_1))  # <class 'int'>

tuple_2 = (20,)
print(type(tuple_2))  # <class 'tuple'>

当元组中只含一个元素未添加逗号时，使用 type() 打印其类型时，会输出 <class 'int'>。

当元组中只含一个元素并添加逗号时，使用type() 打印其类型时，会输出 <class 'tuple'>。

1.4 元组 VS 列表

在Python中，元组与列表相似，不同之处在于元组的元素不能修改 ，而列表的元素可以修改 。
元组使用 小括号() ，列表使用 中括号[]。

二、访问元组

和列表一样，我们既可以使用下标索引访问元组中的某个元素（得到一个元素的值），也可以使用切片访问元组中的一组元素（得到是子元组）。

2.1 下标索引访问

下标索引访问元组分为两大类，即正向索引和反向索引，格式为 tuple_name[i] ，其中，tuple_name 表示元组名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。

可以得知，tuple_name[0]表示元组内第一个元素，tuple_name[-1]则表示元组内最后一个元素。

tuple_name = ('wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw')
print(tuple_name[0])
print(tuple_name[-1])

输出如下：

wzq
hxw

正向索引：从第一个（下标0）开始、第二个（下标1）...

反向索引：从倒数第一个（下标-1）、倒数第二个（下标-2）...

2.2 切片访问

使用切片访问元组的格式为 tuple_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。

tuple_name = ('wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw')
print(tuple_name[1:5:2])
print(tuple_name[-6:-1:3])

输出如下：

('lgl', 'whl')
('wzq', 'whl')

在使用切片访问元组元素时，tuple_name[strat : end : step]，[start：end] 是左闭右开区间，即访问不了 end 代表的元素。

2.3 for 循环遍历元组

可以使用 for 循环遍历元组中的项目：

fruit_tuple = ('apple', 'pear', 'cherry')
for i in fruit_tuple:
    print(i)

输出如下：

apple
pear
cherry

2.4 检查项目是否存在

要确定元组中是否存在指定的项，我们可以使用 in 关键字：

# 检查元组中是否存在'apple'
fruit_tuple = ('apple', 'pear', 'cherry')
print('apple' in fruit_tuple)

输出如下：

True

使用 in 关键字检查元组中是否存在指定项时，如果存在，则返回 True ；反之，则返回 False 。

2.5 更改元组值

创建元组后，我们将无法更改其值。元组是不可变的，或者也被称为恒定的。

但是有一种解决方法：可以先将元组转换为列表，更改列表值，然后再将其转换回元组。

fruit_tuple = ('apple', 'pear', 'cherry')
fruit_list = list(fruit_tuple)
fruit_list[2] = 'banana'
fruit_tuple = tuple(fruit_list)
print(fruit_tuple)

输出如下：

('apple', 'pear', 'banana')

2.6 元组连接(合并)/复制

与字符串一样，元组之间可以使用 + 号和 * 号实现元组的连接和复制，这就意味着它们可以生成一个新的元组。

• 1、+连接

x = (1, 2, 3)
y = (4, 5, 6)
print(x + y)

输出如下：

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

• 2、*复制

x = ('Hello',)
print(x * 5)

输出如下：

('Hello', 'Hello', 'Hello', 'Hello', 'Hello')

2.7 元组不可变性

所谓元组的不可变性指的是元组所指向的内存中的内容不可变。

tup = ('A', 'B', 'C')
# tup[0] = 'a'

不支持修改元素，会报错 TypeError: 'tuple' object does not support item assignment 。

tup = ('A', 'B', 'C')
print(id(tup))

# 查看内存地址
tup = (1, 2, 3)
print(id(tup))

输出如下：

2671405067264
2671405072256

从以上实例可以看出，重新赋值的元组 tup ，绑定到了新的对象了，不是修改了原来的对象。三

三、内置函数

3.1 打印输出 print()

print() 函数的功能我们已经非常熟悉了，就是打印输出。

my_tuple = ('name', True, 21)
print(my_tuple)

输出如下：

('name', True, 21)

3.2 确定元组项目 len()

当我们要确定一个元组有多少项目（元素）时，可以使用len()函数。

fruit_tuple = ('apple', 'banana', 'cherry')
print(len(fruit_tuple))

输出如下：

3

3.3 返回变量类型 type()

使用 type() 函数可以确定变量是什么类型（字符串、列表、元组、字典或集合）。

当对tup_1 = (20)使用 type() 确定变量类型时，会返回<class 'int'>，表明这是一个整型。所以当一个元组只含有一个元素时，一定要加上逗号,。

当对tup_1 = (20,)使用 type() 确定变量类型时，会返回<class 'tuple'>，表明这是一个元组。

四、其他类型转换为元组 tuple()

tuple() 函数的功能是，将其他类型转换为元组类型，详细用法如下：

4.1 str转tuple

str1 = 'Hello Python'
print(tuple(str1))

输出如下：

('H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n')

4.1 list转tuple

list1 = ['Hello', 'Python']
print(tuple(list1))

输出如下：

('Hello', 'Python')

4.3 set转tuple

set1 = {'Hello', 'Python', 'name', 'pink'}
print(tuple(set1))

输出如下：

('Hello', 'name', 'Python', 'pink')

4.4 dict转tuple

dict1 = {'Hello': 'Python', 'name': 'pink'}
print(tuple(dict1))

输出如下：

('Hello', 'name')

五、元组 tuple()转换为其他类型

5.1 tuple转str

str是一个不可变的字符串序列，可以是单个字符，也可以是一个长字符串。str使用单引号或双引号括起来，例如：'hello world'。可以使用索引、切片以及一些字符串方法对其进行操作，例如查找、替换、拼接等。

1. 将tuple转换为字符串拼接

tup = (1, 2, 3, 4, 5)
str = ''
for i in tup:
    str += str(i)
print(str)

这个方法使用for循环遍历tuple，将每个元素转换成字符串，并将它们拼接起来。注意字符串的初始值必须为空，否则会将元组中的逗号也拼接进去。

2. 使用Python内置函数join()

tup = (1, 2, 3, 4, 5)
str = ''.join(str(i) for i in tup)
print(str)

使用Python内置的join()函数，将tuple中的元素连接起来，构成一个字符串。
这个方法比使用字符串拼接要快得多，因为这个函数只需要在每个元素之间插入一个字符串而不是在每次迭代中都创建一个新的字符串对象。 （推荐使用！）

3. 使用map()重新映射tuple

tup = (1, 2, 3, 4, 5)
str = ''.join(map(str, tup))
print(str)

使用map()函数对tuple中的每个元素调用string()函数，然后使用join()函数将它们连接在一起。这种方法比使用for循环和字符串连接要简洁。

5.2 tuple转list

tup = (1, 2, 3, 4, 5)
lst = list(tup)
print(lst)

可以使用list()函数将tuple转换为list，其中每个元素都与原始tuple相同。

5.3 tuple转set

tup = (1, 2, 3, 4, 5)
s = set(tup)
print(s)

可以使用set()函数将tuple转换为set，其中每个元素都是唯一的。

5.4 tuple转dict

tup = ((1, 'a'), (2, 'b'), (3, 'c'))
d = dict(tup)
print(d)

可以使用dict()函数将tuple转换为字典。在这种情况下，tuple中的每个元素都必须是一个包含两个元素的tuple，其中第一个元素是键，第二个元素是值。

参考资料

• Python 元组tuple详解（超详细）
• Python tuple转str指南