一文搞懂Python中列表List和元组Tuple的使用

目录

• 列表 List
• 列表是有序的
• 列表可以包含任意对象
• 通过索引访问列表元素
• 列表嵌套
• 列表可变
• 元组 Tuple
• 定义和使用元组
• 元素对比列表的优点
• 元组分配、打包和解包
• List 与 Tuple 的区别

列表 List

列表是任意对象的集合，在 Python 中通过逗号分隔的对象序列括在方括号 ( [] ) 中

people_list = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

print(people_list)
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

people_list
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

列表是有序的

列表是对象的有序集合。定义列表时指定元素的顺序是该列表的固有特征，并在该列表的生命周期内保持不变

# 具有不同顺序的相同元素的列表是不相同的。
list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
list_b = [\'甄姫\', \'蔡文姫\', \'曹丕\', \'曹操\']

list_ == list_b
False

list_ is list_b
False

列表可以包含任意对象

列表的元素都可以是同一类型

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'甄姫\']
list_
[\'曹操\', \'曹丕\', \'甄姫\', \'甄姫\']

元素可以是不同的类型

list_ = [21.42, \'曹操\', 3, 4, \'曹丕\', False, 3.14159]
list_
[21.42, \'曹操\', 3, 4, \'曹丕\', False, 3.14159]

列表甚至可以包含复杂的对象（函数、类和模块）

int
<class \'int\'>

len
<built-in function len>

def Dynasty_Warriors():
	pass
Dynasty_Warriors
<function Dynasty_Warriors at 0x000002A96EAB1840>

import math
math
<module \'math\' (built-in)>

list_ = [int, len, Dynasty_Warriors, math]
list_
[<class \'int\'>, <built-in function len>, <function Dynasty_Warriors at 0x000002A96EAB1840>,<module \'math\' (built-in)>]

列表对象不必是唯一的。给定对象可以多次出现在列表中

list_ = [\'曹丕\', \'甄姫\', \'甄姫\', \'曹丕\', \'甄姫\', \'曹丕\']
list_
[\'曹丕\', \'甄姫\', \'甄姫\', \'曹丕\', \'甄姫\', \'曹丕\']

通过索引访问列表元素

像字符串一样列表索引可以使用方括号中的索引访问列表中的各个元素

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

list_[0],list_[2]
(\'曹操\', \'甄姫\')

list_[-1],list_[-2]
(\'蔡文姫\', \'甄姫\')

切片表达式 [m:n] 返回索引 m 到 n 包括索引 n 的元素。

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
list_[2:4]
[\'甄姫\', \'蔡文姫\']

字符串切片的其他特性也适用于列表切片

正索引和负索引

list_[-5:-2]
[\'曹操\', \'曹丕\']

list_[0:2]
[\'曹操\', \'曹丕\']

list_[-5:-2] == list_[0:2]
True

省略索引开头和结束索引

print(list_[:2], list_[0:2])
[\'曹操\', \'曹丕\'][\'曹操\', \'曹丕\']

print(list_[2:], list_[2:len(a)])
[\'甄姫\', \'蔡文姫\'][\'甄姫\', \'蔡文姫\'] 

list_[:4] + list_[4:]
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

list_[:4] + list_[4:] == list_
True

指定步幅的正负索引

list_[0:4:2]
[\'曹操\', \'甄姫\']

list_[1:4:2]
[\'曹丕\', \'蔡文姫\']

list_[4:0:-2]
[\'蔡文姫\', \'曹丕\']

反转列表

list_[::-1]
[\'蔡文姫\', \'甄姫\', \'曹丕\', \'曹操\']

运算符和内置函数处理列表

运算符 in 和 not in

list_
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

\'蔡文姫\' in list_
True
\'曹仁\' not in list_
True

连接( + )和复制( * )运算符

list_ = [\'曹操\', \'曹丕\']

list_ + [\'甄姫\', \'蔡文姫\']
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
list_ * 2
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\' \'曹操\', \'曹丕\', \'甄姫\',\'蔡文姫\']

函数 len()、min()、max()

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

len(a)
4

min(list_ )
\'曹丕\'

max(list_ )
\'蔡文姫\'

列表嵌套

列表中的元素可以是任何类型的对象，一个列表可以包含子列表，而子列表又可以包含子列表本身，依此类推。

常规嵌套列表操作

list_ = [\'a\', [\'bb\', [\'ccc\', \'ddd\'], \'ee\', \'ff\'], \'g\', [\'hh\', \'ii\'], \'j\']
[\'a\', [\'bb\', [\'ccc\', \'ddd\'], \'ee\', \'ff\'], \'g\', [\'hh\', \'ii\'], \'j\']


# list_[0], list_[2], 和list_[4]是字符串
print(list_[0], list_[2], list_[4])
a g j

# list_[1]和list_[3]是子列表
list_[1]
[\'bb\', [\'ccc\', \'ddd\'], \'ee\', \'ff\']

list_[3]
[\'hh\', \'ii\']


# 访问子列表中的元素需附加索引
list_[1]
[\'bb\', [\'ccc\', \'ddd\'], \'ee\', \'ff\']

list_[1][0]
\'bb\'

list_[1][1]
[\'ccc\', \'ddd\']

list_[1][2]
\'ee\'

list_[1][3]
\'ff\'

list_[3]
[\'hh\', \'ii\']

print(list_[3][0], list_[3][1])
hh ii


# list_[1][1]是另一个子列表，访问需要添加索引
list_[1][1]
[\'ccc\', \'ddd\']
print(list_[1][1][0], list_[1][1][1])
ccc ddd


# 索引和切片的常用语法也适用于子列表。
list_[1][1][-1]
\'ddd\'

list_[1][1:3]
[[\'ccc\', \'ddd\'], \'ee\']

list_[3][::-1]
[\'ii\', \'hh\']

# in 操作符使用。
\'ddd\' in x
False
\'ddd\' in x[1]
False
\'ddd\' in x[1][1]
True

列表可变

创建列表后，可以随意添加、删除、移动和移动元素。

修改单个列表值

列表中的值可以通过索引和简单赋值进行替换。

s = \'曹操，曹丕，甄姫\'
s[2] = \'蔡文姫\'
Traceback (most recent call last):
  File \"<stdin>\", line 1, in <module>
TypeError: \'str\' object does not support item assignment

使用 del 命令删除列表项

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

del list_[3]

list_
[\'曹操\', \'曹丕\', \'甄姫\']

修改多个列表值

切片实现 a[m:n] = <iterable> 序列迭代替换值

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

list_[1:4]
[\'曹丕\', \'甄姫\', \'蔡文姫\']

list_[1:4] = [1.1, 2.2, 3.3, 4.4, 5.5]

list_
[\'曹操\', 1.1, 2.2, 3.3, 4.4, 5.5]

多个元素来代替单个元素

list_ = [1, 2, 3]

list_[1:2] = [2.1, 2.2, 2.3]
list_
[1, 2.1, 2.2, 2.3, 3]

list_ = [1, 2, 3]
list_[1] = [2.1, 2.2, 2.3]
list_
[1, [2.1, 2.2, 2.3], 3]

list_ = [1, 2, 7, 8]
list_[2:2] = [3, 4, 5, 6]
list_
[1, 2, 3, 4, 5, 6, 7, 8]

切片分配空列表删除列表中间的多个元素

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
list_[1:4] = []
list_
[\'曹操\']

列表附加元素或元素附加到列表

list_ = [\'曹操\', \'曹丕\']

list_ += [ \'甄姫\', \'蔡文姫\']

list_
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

list_ = [10, 20] + list_
list_
[10, 20, \'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

列表拼接元素的方法不能直接添加

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

list_ += 20
Traceback (most recent call last):
  File \"<pyshell#58>\", line 1, in <module>
    list_ += 20
TypeError: \'int\' object is not iterable

list_ += [20]
list_
[\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\', 20]

append(<obj>) 将对象附加到列表中

list_ = [\'曹操\', \'曹丕\']

list_.append(123)
list_
[\'曹操\', \'曹丕\', 123]

x = list_.append(123)
print(x)
None

list.extend(<iterable>)，追加元素

list_ = [\'曹操\', \'曹丕\']

list_.extend([1, 2, 3])
list_
[\'曹操\', \'曹丕\', 1, 2, 3]

list.insert(<index>, <obj>)，插入元素

将对象插入列表

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
list_.insert(3, 3.14159)

list_[3]
3.14159

list_
[\'曹操\', \'曹丕\', \'甄姫\', 3.14159, \'蔡文姫\']

list.remove(<obj>)，按照元素删除元素

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
list_.remove(\'甄姫\')
list_
[\'曹操\', \'曹丕\', \'蔡文姫\']

# 如果<obj>不在中列表，则会引发异常。
list_.remove(\'曹丕k\')
Traceback (most recent call last):
  File \"<pyshell#13>\", line 1, in <module>
    list_.remove(\'曹丕k\')
ValueError: list.remove(x): x not in list

list.pop(index=-1)，按索引删除元素

从列表中删除一个元素，需要指定索引并返回被移除的项目的值，pop(-1) 等价于 pop()

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']

list_.pop()
\'蔡文姫\'

list_
[\'曹操\', \'曹丕\', \'甄姫\']

list_.pop()
\'甄姫\'

list_
[\'曹操\', \'曹丕\']

列表是动态的，随着项目数据的变化而变化

list_ = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
# 数据增加
list_ [2:2] = [1, 2, 3]
list_  += [3.14159]
list_ 
[\'曹操\', \'曹丕\', 1, 2, 3, \'甄姫\', \'蔡文姫\', 3.14159]

# 数据删除
a = [\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\']
a[2:3] = []
del a[0]
a
[\'曹丕\', \'蔡文姫\']

元组 Tuple

对象的有序集合，称为元组。与列表的区别在于元组是通过括号 ( () ) 而不是方括号 ( [] ) 中来定义的，以及元素不可变。

定义和使用元组

t = (\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\')

t
(\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\')

t[0]
\'曹操\'

t[-1]
\'蔡文姫\'

t[1::2]
(\'曹丕\', \'蔡文姫\')


# 可以进行倒序排列
t[::-1]
(\'蔡文姫\', \'甄姫\', \'曹丕\', \'曹操\')


# 元组不可修改
t = (\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\')
t[2] = \'曹丕k\'
Traceback (most recent call last):
  File \"<pyshell#65>\", line 1, in <module>
    t[2] = \'曹丕k\'
TypeError: \'tuple\' object does not support item assignment

元素对比列表的优点

• 处理速度更快
• 防止被意外修改
• 字典需要不可变更类型的值作为组件

# 元素用,分割
a = \'曹操\'
b = 42
a, 3.14159, b
(\'曹操\', 3.14159, 42)


# 定义一个空的元组
t = ()
type(t)
<class \'tuple\'>


# 定义项目的元组
t = (2,)

type(t)
<class \'tuple\'>

t[0]
2

t[-1]
2

# 元组单一元素会包含符号
print(t)
(2,)

元组分配、打包和解包

可以将包含多个项目的文字元组分配给单个对象。

t
(\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\')

t[0]
\'曹操\'

t[-1]
\'蔡文姫\'

被打包的对象直接被分配新的元组中，并解释到各个元组对象。

(s1, s2, s3, s4) = t

s1
\'曹操\'

s2
\'曹丕\'

s3
\'甄姫\'

s4
\'蔡文姫\'

解包时，左边的变量个数必须与元组中的值个数相匹配

(s1, s2, s3) = t
Traceback (most recent call last):
  File \"<pyshell#16>\", line 1, in <module>
    (s1, s2, s3) = t
ValueError: too many values to unpack (expected 3)

(s1, s2, s3, s4, s5) = t
Traceback (most recent call last):
  File \"<pyshell#17>\", line 1, in <module>
    (s1, s2, s3, s4, s5) = t
ValueError: not enough values to unpack (expected 5, got 4)

打包、解包一步操作

(s1, s2, s3, s4) = (\'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\')

s1, s2, s3, s4 = \'曹操\', \'曹丕\', \'甄姫\', \'蔡文姫\'

s1
\'曹操\'
s2
\'曹丕\'
s3
\'甄姫\'
s4
\'蔡文姫\'

元组互换进行互换赋值

a = \'曹操\'
b = \'曹丕\'

a, b
(\'曹操\', \'曹丕\')

a, b = b, a
a, b
(\'曹丕\', \'曹操\')

List 与 Tuple 的区别

功能说明	列表	元组
元素操作	可变	不可变
迭代耗时	耗时多	相对较快
操作修改	执行插入、删除、追加操作	仅限访问元素
内存消耗	消耗内存多	消耗内存少
内置方法	内置方法多	内置方法少
容错概率	易发生变化和错误	难发生