Python 列表

列表定义

列表使用方括号 [] 定义，列表内的元素用逗号 , 分开
列表是可改变的有序元素序列
列表元素可以多种数据类型混合在一起

查找元素

索引的含义

元素的索引编号代表元素与列表开头的距离。第一个元素距离开头有 0 个元素，第二个元素有一个元素，依此类推

通过索引来查找列表中的各个元素。
第一个元素索引编号为 0，而不是 1（称为 「零索引」）
可从列表的末尾进行索引。要从列表的末尾索引需要使用负索引。索引 -1 是指列表的最后一个元素，-2 是倒数第二个，依此类推

索引错误

如果尝试索引列表中不存在的元素，将导致列表索引异常（List Index Exception），即导致 IndexError

提示

一般引起错误都是因为进行索引时编号差 1，可以使用 print 函数尝试打印列表查询结果以纠错

列表切片

使用切片操作 Slice 来访问列表的子序列。切片获得的元素遵循：下限索引包含在内，上限索引排除在外

前面的示例中，切片不包括右侧索引（即索引编号为 9 所对应的元素），但包括左侧索引（即索引编号为 6 所对应的元素）

简化方式

python

mothon = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']

# 获得一个从原始列表开头开始的子列表简化代码
first_half = months[:6]
print(first_half)

# 获取以列表的末尾结束的子列表
second_half = months[6:]
print(second_half)

说明

切片操作永远不会导致 IndexError，如果切片尝试提取字符串末尾之外的字符（即 index 超出了范围），将返回至多能获取的字符，即使什么也没有（得到一个空列表）

使用全切片返回的是一个列表的副本，如 word[:] 返回的将是一个 word 的副本

列表修改

结合 range() 函数和 len() 函数以及 for 循环语句，遍历列表元素作出相应的修改。

使用 len() 函数获取列表长度（元素个数）

使用 range(number) 函数可以基于数字 number 生成一个具有 number 个元素的列表，这些元素构成一个等差数列。其中第一个元素为 0，步长为 1

python

# 基于原列表 List_name 的长度，生成一个**索引列表**
# 即列表 indexes 中的每个值多对应于原列表 List_name 中的每个值的索引
indexes = range(len(List_name))

for 循环遍历修改列表元素

python

for index in indexes:
    print(List_name[index])

列表推导式/列表解释

python 特有的快捷创建列表方式

python

# 已有一个列表 cities
# 一般使用循环迭代对列表中的每一个元素进行处理
capitalized_cities = []
for city in cities:
    capitalized_cities.append(city.title())

简化方式

python

# 对 cities 中的每个元素 city 调用 city.title()
capitalized_cities = [city.title() for city in cities]

使用方括号 [] 创建列表推导式
第一部分包含要对可迭代对象中的每个元素进行评估/执行的操作
第二部分使用 for 循环遍历所有的元素

还可以包含判断条件，若插入 if 条件语句，需放在 for 循环后面

python

squares = [x**2 for x in range(9) if x % 2 == 0]

若同时还需要插入 else 语句，则将 if-else 组合语句放在第一部分和第二部分之间

python

squares = [x**2 if x % 2 == 0 else x + 3 for x in range(9)]

列表组合

使用 zip() 函数可将多个列表（或可迭代对象）组合，按照索引值从各个列表取出相应的元素构成元组，再将这些元素组合为一个迭代器（列表形式），相当于将多个可迭代对象压缩到一个里面。

提示

如果要显示/打印该迭代器的元素，需要先用方法 list() 将其转换为列表（类似于 range() 的情况）

python

items = ['bananas', 'mattresses', 'dog kennels', 'machine', 'chesses']
weights = [15, 34, 42, 120, 5]
#使用 list() 函数将迭代器转换为列表
print(list(zip(items, weights)))

# 输出结果
# [('bananas', 15), ('mattresses', 34), ('dog kennels', 42), ('machine', 120), ('chesses', 5)]
# 每一个元素都是一个元素，例如第一个元素 ('bananas', 15) 就是一个二维的元组
# 第一个元组是提取自原始列表的第一个元素组合而来的

提示

组合而得的迭代器，其中元素的个数是有限制的，与原列表或原可迭代对象之中含有最少元素的数量一致

这样保证了组合而得的迭代器中，每元组中含有相同数量的元素

拆分列表/迭代器

选择 for 循环拆分 每个元组

python

letters = ['a', 'b', 'c']
nums = [1, 2, 3]
for letter, num in zip(letters, nums):
    print("{}:{}".format(letter, num))

🔨 编译结果

shell

# 逐个取出元组
a:1
b:2
c:3

拆封列表/迭代器

使用字符星号 * 将组合为元组的列表拆封形成相应个数的「独立」元组（tuple）

python

some_list = [('a', 1),('b', 2),('c',3)]
letters, nums = zip(*some_list)

🔨 编译结果

shell

('a', 'b', 'c')
(1, 2, 3)

可变性 Mutability

列表与字符串相似，但是它们有不同的可变性

说明

表示对象是否可以修改的术语是可变性 mutability

相同点

列表与字符串相似，均支持

索引
切片
len 函数
in 运算符

python

# 索引，均为零索引
>>> sample_string = "And Now For Something Completely Different"
>>> sample_list = ['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']
>>> sample_string[4]
'N'
>>> sample_list[4]
'Terry'

# 切片
>>> sample_string[12:21]
'Something'
>>> sample_list[2:4]
['Terry', 'Eric']

# len()函数
>>> len(sample_string)
42
>>> len(sample_list)
6

# in 运算符
>>> 'thing' in sample_string
True
>>> 'Rowan' in sample_list
False

不同点

字符串的数据类型为 str，列表的元素可以是任何类型的数据组合
列表可以被修改，但字符串不能，即：
- 列表是可变对象
- 字符串是不可变对象（元组、整数等也是不可变对象）

python

>>> sample_list[3] = 'Eric'
>>> print(sample_list)
['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']
>>> sample_string[8] = 'f'
TypeError: 'str' object does not support item assignment

存储原理

可变 mutable 和不可变 immutable 对象的变量运行方式非常不同。

python

# 通过引用赋值产生的不可变对象存储在内存中，变量名指向不同的对象，相互独立
name = 'Jim'
student = name
name = 'Tim'

print(name)
print(student)

# 通过引用赋值产生的可变对象，变量名指向同一个对象，互通
scores = ['excellent', 'good', 'not bad', 'should work hard']
grades = scores
score[2] = 'normal'

print("scores:" + scores)
print("grades:" + grades)

🔨 编译结果

shell

Jim
Tim

scores: ['excellent', 'good', 'normal', 'should work hard']
grades: ['excellent', 'good', 'normal', 'should work hard']

当创建一个具有不可变对象实例时，该变量的值即被保存在内存中，通过变量名引用赋值给新对象，会为新的变量绑定新的内存（即变量与内存地址是捆绑在一起的，赋值产生的变量值相同，但是绑定的内存地址不同）
字符串作为不可变对象赋值，即使变量具有相同的值，但是也是不一样的对象，更新其中一个变量的值并不影响另一个变量（而对于指向可变对象的变量刚好相反）
列表是可变对象，通过引用赋值的新变量其实指向同一个「底层」列表，可以使用任一变量名来访问或更改该列表

使用列表

len 函数

返回列表的元素个数

max 函数

返回列表中的最大元素
「最大元素」的确定取决于列表中的对象类型
- 数字列表最大元素是最大数字
- 字符串列表按首字母顺序排序，最大元素是首字母在字母表中排在最后一个元素
当一个列表中包含不同类型的元素，并且这些类型无法进行比较时，max 函数也将无法使用

min 函数

返回列表中的最小元素。

min 与 max 的作用相反。

sorted 函数

按从小到大的顺序返回 list 的副本，同时保持原 list 不变。使用 reverse = True 参数按从大到小的顺序排序。

sort 方法

直接返回按从小到大排序后的列表

join 函数

连接列表元素，返回一个 由指定的连接字符（一般是字符串字面量） 依此拼接列表元素，组成一个字符串。

使用方式 "linkChar".join(list_name)

使用连字符 - 作为连接字符

python

>>> names = ["García", "O'Kelly", "Davis"]
>>> "-".join(names)
"García-O'Kelly-Davis"

使用换行符 \n 作为连接字符
连接列表

🔨 编译结果

shell

fore
aft
starboard
port

append 方法

追加元素（作为函数的参数输入）到列表末尾。

python

>>> python_varieties.append('Blood Python')
>>> print(python_varieties)
['Burmese Python', 'African Rock Python', 'Ball Python', 'Reticulated Python', 'Angolan Python', 'Blood Python']

extend 方法

扩展元素，接受一个列表输入，并将该列表的元素添加到目标列表的末尾。

python

>>> words.extend(["kangaroo", "wallaby"])
>>> words
['echidna', 'dingo', 'crocodile', 'bunyip', 'platypus', 'a', 'b', 'c', 'kangaroo', 'wallaby']

提示

如果输入的是一个字符串，则将该字符串的每个字符依次添加到目标列表末尾，扩展列表。

python

>>> words.extend("abc")
>>> words
['echidna', 'dingo', 'crocodile', 'bunyip', 'platypus', 'a', 'b', 'c']

in 运算符与 not in 运算符

查看某个元素是否存在于列表中，返回一个布尔值（也适用于字符串）

python

>>> 5 not in [1, 2, 3, 4, 6]
True

enumerate 函数

enumerate() 函数是一个将列表返回为元组迭代器的内置函数，该元组包含列表的索引和对应的元素的值。

如果要显示/打印该迭代器的元素，需要先用方法 list() 将这个迭代器转换为列表

python

letters = ['a', 'b', 'c', 'd', 'e']
print(list(enumerate(letters)))

🔨 编译结果

shell

[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]