【Python基础】数据类型（元组、列表）

二. 数据类型

Python内置的数据类型远不止元组和列表，本篇介绍元组和列表。

Python中的内置数据类型有：

• 数字：int（整数）、float（浮点数）、complex（复数）
• 字符串：str（字符串）
• 列表：list（列表）
• 元组：tuple（元组）
• 集合：set（集合）、frozenset（不可变集合）
• 字典：dict（字典）
• 布尔值：bool（布尔值）
• None：None（空）

2.1 元组 tuple

2.1.1 定义特性

元组是一种固定长度、不可变的Python对象序列。

定义：最简单的方法是用逗号分隔，复杂的表达式需要通过括号将值包起来。

# 定义1：简单元组
tup = 4,5,6
# 定义2：生成元素是元组的元组
nested_tup = (4,5,6),(8,9)

转化：可以使用tuple将任意序列或迭代器转换为元组：

tup = tuple([4,0,2])
# tup => (4,0,2)
tup = tuple('str')
# tup => ('s','t','r')

获取：元组的元素可以通过中括号[]获取，从0开始。

tup[0] # 's'

不变特性：各位置上的对象是无法被修改的。

tup = tuple(['foo',[1,2],True])
tup[2] = False # TypeError: 'tuple' object does not support item assignment

可变特性：但是元组内的一个对象是可变的，则可以从内部修改：

tup[1].append(3)
tup # ('foo', [1, 2, 3], True)

2.1.2 拼接拷贝

拼接：可以使用 + 号拼接元组。

tup2 = 11,22,33
tup = tup + tup2 # ('foo', [1, 2, 3], True, 11, 22, 33)

拷贝：元组也可以通过乘一个整数，生成含有多份拷贝的元组。注意：对象自身未复制，只是复制引用。

tup = 1,2
tup = tup * 3
tup # (1, 2, 1, 2, 1, 2)

2.1.3 元组拆包

元组拆包：即便是嵌套元组也可以拆包。（Javascript里面的说法是 解构 ）

tup = (4,5,(6,7))
a,b,(c,d) = tup
b # 5
c # 6

拆包优势：更轻易地交换变量名。

# 常规方法
tmp = a
a = b
b = tmp
# 拆包方法
a,b = b,a

当然，还可以用于遍历元组或列表组成的序列：

seq = [(1,2,3),(4,5,6),(7,8,9)]
for a,b,c in seq: 
	//...

更高级的拆包：使用特殊语法 * ,从元组的起始位置采集一些元素。

values = 1,2,3,4,5,6
a,b,*rest = values
a,b # (1, 2)
rest # [3, 4, 5, 6]

2.1.4 元组方法 count

使用count计量某个数值在元组中出现的次数：

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

2.2 列表 list

2.2.1 基础定义

与元组不同，列表的长度是可变的，包含的内容也可以修改。

定义：可以使用[] ，list ， 类型函数来定义列表。

a_list = [2,3,4,None]

tup = ('foo','bar')
b_list = list(tup)
b_list[1] = 'boo'
b_list # ['foo','boo']

gen = range(10)
gen # range(0, 10)

2.2.2 增删操作

尾部增加：使用append方法可以将元素添加到列表的尾部。

b_list.append('cool')
b_list # ['foo', 'boo', 'cool']

指定位置增加：使用insert方法可以将元素插入到指定的列表位置。

b_list.insert(1,'red')
b_list # ['foo', 'red', 'boo', 'cool']

指定位置删除：使用pop操作移除特定位置的元素并返回。

b_list.pop(2) # 'boo'

指定元素删除：使用remove方法可以定位第一个符合要求的值并移除。

b_list.append('foo')
b_list # ['foo', 'red', 'cool', 'foo']
b_list.remove('foo')
b_list # ['red', 'cool', 'foo']

查询：可以使用in关键字检查值是否在列表中，前面加not关键字 表示”不在“。

'foo' in b_list # True
'foo' not in b_list # False

2.2.3 连接联合

同元组，可以使用+进行连接，如果存在一个列表，可以使用extend方法向该列表增加多个元素：

list1=["喷火龙","杰尼龟"]
list2=["妙蛙种子","皮卡丘"]
list1.extend(list2)
print(list1) # ['喷火龙', '杰尼龟', '妙蛙种子', '皮卡丘']

易错点：append

注意：如果list1拼接list2时使用了方法append()，最后得到的结果并不是一个线性扁平化的列表，而是将list2作为一个元素放入列表中。其形式如下：

list1.append(list2)
# ['喷火龙', '杰尼龟',['妙蛙种子', '皮卡丘']]

2.2.4 其他常规操作

列表还有其他常见的操作：

• index: 查找列表中第一个匹配的元素的索引
• count: 统计列表中指定元素出现的次数
• sort: 对列表进行排序
• reverse: 对列表进行反转

除此之外，元组所支持的切片，列表也支持。

2.2.5 列表推导式

列表还支持一些高级特性，如列表推导式和生成器表达式。列表推导式是一种简洁的方式来创建列表，而生成器表达式则可以在不创建完整的列表的情况下生成列表中的元素。

列表推导式(List Comprehension)是Python中一种简洁的创建列表的方法。它可以用来快速地创建一个新列表，并在创建过程中对元素进行过滤和转换。

列表推导式的语法如下:

new_list = [expression for item in old_list if condition]

其中，expression表示对item的转换，condition表示对item的过滤条件。

例如，下面的代码使用列表推导式创建一个新列表，其中包含原列表中所有奇数的平方:

old_list = [1, 2, 3, 4, 5]
new_list = [x**2 for x in old_list if x % 2 != 0]
print(new_list)  # 输出[1, 9, 25]

列表推导式非常简洁，可以简化很多常规代码，在处理数据时非常方便。除此之外还有字典推导式和集合推导式，都是用来简化创建字典和集合的代码的。

2.2.6 生成器表达式

生成器表达式(Generator Expression)是Python中一种可以在不创建完整的列表的情况下生成列表中元素的方法。它与列表推导式非常类似，但是使用小括号() 来代替方括号 []。

生成器表达式的语法如下:

gen = (expression for item in old_list if condition)

例如，下面的代码使用生成器表达式生成一个生成器，其中包含原列表中所有奇数的平方:

old_list = [1, 2, 3, 4, 5]
gen = (x**2 for x in old_list if x % 2 != 0)
print(next(gen))  # 输出 1
print(next(gen))  # 输出 9
print(next(gen))  # 输出 25

生成器表达式在创建时并不会立即生成整个列表，而是在迭代时才生成元素。因此它可以节省内存空间，对于处理大量数据时非常有用。生成器表达式还可以和其他迭代器结合使用，如与itertools库中的函数组合使用。

2.x 小结：何时使用元组或列表

元组和列表都是Python中的内置数据类型，用于存储一组元素。但是它们在语义和使用方面有很大的不同。

使用元组：当需要存储的数据是固定不变的，或者希望保证数据不会被意外修改时，使用元组。

• 元组中的元素是有序的，在遍历元组时，元素的顺序是固定不变的。
• 元组的语法更加简洁，代码更加整洁。
• 元组可以被用作字典的键或集合的元素，因为它们是不可变的。

使用列表：当需要经常添加、删除、修改数据时，使用列表。

• 列表中的元素是有序的，可以通过索引随意访问元素。
• 列表支持sort方法，可以很方便地对列表中的元素进行排序。
• 列表支持extend和append方法，可以方便地扩展列表。

总体来说，元组适用于存储不变的数据，列表适用于存储可变的数据。选择使用哪种数据结构，取决于你的需求。