2w字Python列表,全了!

2w字Python列表,全了!

即使再小的帆也能远航~

一.目录

1. 序列
   1.1 索引
   1.2 切片
   1.3 序列相加
   1.4 乘法(Multiplying)
   1.5 检查某个元素是否是序列的成员(元素)
   1.6 计算序列的长度、最大值和最小值
2. 列表
   2.1 使用赋值运算符直接创建列表
   2.2 创建空列表
   2.3 创建数值列表
   2.4 删除列表
3. 访问列表元素
4. 遍历列表
   4.1 直接使用for循环实现
   4.2 使用for循环和enumerate()函数实现
5. 添加、修改和删除列表元素
   5.1 添加元素
   5.2 修改元素
   5.3 删除元素
   5.3.1 根据索引删除
   5.3.2 根据元素值删除
6. 对列表进行统计和计算
   6.1 获取指定元素出现的次数
   6.2 获取指定元素首次出现的下标
   6.3 统计数值列表的元素和
7. 对列表进行排序
   7.1 使用列表对象的sort()方法
   7.2 使用内置的sorted()函数实现
8. 列表推导式
   8.1 生成指定范围的数值列表
   8.2 根据列表生成指定需求的列表
   8.3 从列表中选择符合条件的元素组成新的列表
9. 二维列表的使用
   9.1 直接定义二维列表
   9.2 使用嵌套的for循环创建
   9.3 使用列表推导式创建

二.内容

序列

索引

序列中的每一个元素都有一个编号， 也称为索引。这个索引是从0开始递增的，即下标为0表示第一个元素，下标为1表示第二个元素，依此类推。

Python比较神奇，它的索引可以是负数。这个索引从右向左计数，也就是从最后一个元素开始计数，即最后一个元素的索引值是-1，倒数第二个元素的索引值为-2，依此类推。

song_list = ["骁", "此间亦是少年", "突然的自我", "挪威那的森林"]
print(song_list[2])  # 输出第3个元素
print(song_list[-1])  # 输出最后一个元素

切片

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。实现切片操作的语法格式如下:

s_name[start : end : step]

参数说明：

• s_name: 表示序列的名称。
• start: 表示切片的开始位置(包括该位置)，如果不指定，则默认为0。
• end: 表示切片的截止位置(不包括该位置)，如果不指定则默认为序列的长度。
• step: 表示切片的步长，表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素如果省略，则默认为1，当省略该步长时，最后一个冒号也可以省略。可取正负数，正数表示从左往右，负数表示从右往左

在进行切片操作时，如果指定了步长，那么将按照该步长遍历序列的元素，否则将一个一个遍历序列。例如：

name = "abcdefg"
print(name[2:5])  # cde

# 省略start_index，保留end_index，这样会从第一个元素开始，切到end_index - 1的元素为止
print(name[:5])  # abcde

# 保留start_index，但省略end_index，这样会从起始索引开始，切到最后一个元素为止
print(name[1:])  # bcdefg

# 省略start_index、end_index和step，这样就表示就表示切片整个序列，也就是复制出了一个新的字符串序列
print(name[:])  # abcdefg

# 省略start_index、end_index，但保留step，表示对整个序列，按照步长的规则取值
print(name[::2])  # aceg
print(name[:-1])  # abcdef
print(name[3:6])  # def
print(name[::-1])  # 步长为-1表示逆序 gfedcba

# 注意:步长和切片的方向要一致 否则切片失败

序列相加

在Python中，支持两种相同类型的序列相加操作。即将两个序列进行连接，使用加(+) 运算符实现。例如，将两个列表相加，可以使用下面的代码:

name_list1 = ["Amo", "Jerry", "Crystal"]
name_list2 = ["Paul", "Ben", "MoYa"]
print(name_list1 + name_list2)
#结果
['Amo', 'Jerry', 'Crystal', 10, 20, 30]

但是不能是列表和元组相加，或者列表和字符串相加。例如，下面的代码就是错误的:

name_list = ["Amo", "Jerry", "Crystal"]
print(name_list + "我是Amo")

乘法

在Python中，使用数字n乘以一个序列会生成新的序列。新序列的内容为原来序列被重复n次的结果。例如，下面的代码， 将实现将一个序列乘以3生成一个新的序列并输出，从而达到"重要事情说三遍"的效果。

name_list = ["Amo", "Jerry", "Crystal"]
print(name_list * 3)
#结果
['Amo', 'Jerry', 'Crystal', 'Amo', 'Jerry', 'Crystal', 'Amo', 'Jerry', 'Crystal']

在进行序列的乘法运算时，还可以实现初始化指定长度列表的功能。

例如下面的代码，将创建一个长度为5的列表，列表的每个元素都是None, 表示什么都没有。

empty_list = [None]
print(empty_list * 5)
# 结果
[None, None, None, None, None]

检查某个元素是否是序列的成员

在Python中，可以使用in关键字检查某个元素是否是序列的成员，即检查某个元素是否包含在该序列中。语法格式如下:

value in sequence

其中value表示要检查的元素，sequence表示指定的序列。
例如，要检查名称为name_list的序列中，是否包含元素"Amo"，可

以使用下面的代码:

name_list = ["Amo", "Jerry", "Crystal"]
print("Amo" in name_list)

运行，上面的代码，将显示True,表示在序列中存在指定的元素。

另外，在Python中，也可以使用not in关键字实现检查某个元素是否不包含在指定的序列中。例如下面的代码，将显示False。

name_list = ["Amo", "Jerry", "Crystal"]
print("Amo" not in name_list)

计算列表的长度,最值

在Python中，提供了内置函数计算序列的长度、最大值和最小值。

分别是:

• 使用len()函数计算序列的长度，即返回序列包含多少个元素;

• 使用max()函数返回序列中的最大元素;

• 使用min()函数返回序列中的最小元素。

例如，定义一个包括7个元素的列表，并通过len()函数计算列表的长度，可以使用下面的代码:

num_list = [10, 20, 30, 40, 50, 60, 70]
print(f"序列num_list的长度为:{len(num_list)}")  

运行上面的代码，将显示以下结果：

序列num_list的长度为:7

例如，定义一个包括7个元素的列表，并通过max()函数计算列表的最大元素，可以使用下面的代码:

num_list = [10, 20, 30, 40, 50, 60, 70]
print(f"序列{num_list}中最大的元素为:{max(num_list)}")

运行上面的代码，将显示以下结果：

序列[10, 20, 30, 40, 50, 60, 70]中最大的元素为:70

例如，定义一个包括7个元素的列表，并通过min()函数计算列表的最小元素，可以使用下面的代码:

num_list = [10, 20, 30, 40, 50, 60, 70]
print(f"序列{num_list}中最小的元素为:{min(num_list)}")

运行上面的代码，将显示以下结果：

序列[10, 20, 30, 40, 50, 60, 70]中最小的元素为:10

除了上面介绍的3个内置函数，Python 还提供了如表所示的内置函数。

函数	说明
list()	将序列转换为列表
str()	将序列转换为字符串
sum()	计算元素和
sorted()	对元素进行排序
reversed	反向序列中的元素
enumerate()	将序列组合为一个索引序列，多用在for循环中

列表

Python中的列表和歌曲列表类似，也是由一系列按特定顺序排列的元素组成的。它是Python中内置的可变序列。在形式上，列表的所有元素都放在一对中括号[]中，两个相邻元素间使用逗号分隔。在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放入到列表中，并且同一个列表中，元素的类型可以不同，因为它们之间没有任何关系。由此可见，Python中的列表是非常灵活的，这一点与其他语言是不同的，在其他语言中称为数组。

注意: 尽管列表中可以存储不同类型的数据，但是一般来说存储的都是相同类型的数据

使用赋值运算符直接创建列表

同其他类型的Python变量一样，创建列表时，也可以使用赋值运算符=直接将一个列表赋值给变量，语法格式如下：

list_name = [element1, element2, element3, …, elementn]

其中，list_name表示列表的名称，可以是任何符合Python命名规则的标识符；element1, element2, element3, …, elementn表示列表中的元素，个数没有限制，并且只要是Python支持的数据类型就可以。

例如，下面定义的列表都是合法的：

num_list = [1, 2, 3, 4, 5, 6]  # 为了遵循PEP8规范 在,的后面留一个空格
# verse: 诗句
verse_list = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
un_title = ['Python', 18, "人生苦短，我用Python", ["爬虫", "自动化运维", "云计算", "Web开发"]]
python = ['优雅', "明确", '''简单''']

创建空列表

在Python中，也可以创建空列表，例如，分别创建名称为empty_list和empty_list2的空列表，可以使用下面的代码：

empty_list = []  # 1.字面值创建空列表
empty_list2 = list()  # 2.函数创建空列表
print(empty_list)  # []
print(empty_list2)  # []

创建数值列表

在Python中，数值列表很常用。例如，在考试系统中记录学生的成绩，或者在游戏中记录每个角色的位置、各个玩家的得分情况等都可应用数值列表。在Python中，可以使用list()函数直接将range()函数循环出来的结果转换为列表。

list()函数的基本语法如下：

list(data)

其中，data表示可以转换为列表的数据，其类型可以是range对象、字符串、元组或者其他可迭代类型的数据。

例如，创建一个10~20之间（不包括20）所有偶数的列表，可以使用下面的代码：

even_num_list = list(range(10, 20, 2))
print(even_num_list)  # [10, 12, 14, 16, 18]

说明：使用list()函数不仅能通过range对象创建列表，还可以通过其他对象创建列表。例如：

char_list = list("Amo")
print(char_list)  # ['A', 'm', 'o']

删除列表

对于已经创建的列表，不再使用时，可以使用del语句将其删除。语法格式如下：

del list_name  # 其中，listname为要删除列表的名称。

说明：del语句在实际开发时，并不常用。因为Python自带的垃圾回收机制会自动销毁不用的列表，所以即使我们不手动将其删除，Python也会自动将其回收。
例如，定义一个名称为song的列表，然后再应用del语句将其删除，可以使用下面的代码：

song_list = ["我要找到你", "爱拼才会赢", "突然的自我", "挪威那的森林"]
del song_list

常见错误：在删除列表前，一定要保证输入的列表名称是已经存在的，否则将出现如图所示的错误。

访问列表元素

在Python中，如果想将列表的内容输出也比较简单，可以直接使用**print()**函数即可。例如，创建一个名称为song_list的列表，并打印该列表，可以使用下面的代码：

song_list = ["我要找到你", "爱拼才会赢", "突然的自我", "挪威那的森林"]
print(song_list)

执行的结果如下：

从上面的执行结果中可以看出，在输出列表时，是包括左右两侧的中括号的。如果不想要输出全部的元素，也可以通过列表的下标获取指定的元素。下标 又叫 索引 ，就是编号，要注意程序中的编号是从0开始的。

例如，要获取song_list列表中索引为2的元素，可以使用下面的代码：

print(song_list[2])  

执行结果如下：

从上面的执行结果中可以看出，在输出单个列表元素时，不包括中括号，如果是字符串，还不包括左右的引号。

遍历列表

遍历列表中的所有元素是常用的一种操作，在遍历的过程中可以完成查询、处理等功能。在生活中，如果想要去商场买一件衣服，就需要在商场中逛一遍，看是否有想要的衣服，逛商场的过程就相当于列表的遍历操作。在Python中遍历列表的方法有多种，下面介绍两种常用的方法。

直接使用for循环实现

直接使用for循环遍历列表，只能输出元素的值，语法格式如下：

for item in list_name:
	print(item)

其中，item用于保存获取到的元素值，要输出元素内容时，直接输出该变量即可；listname为列表名称。
例如，定义一个保存2019~2020赛季NBA常规赛西部前八排名预测的列表，然后通过for循环遍历该列表，并输出各个球队的名称，

代码如下：

print("2019~2020赛季NBA常规赛西部前八排名预测: ")
team_list = ["洛杉矶湖人", "洛杉矶快船", "丹佛掘金", "犹他爵士",
             "404队", "俄克拉荷马雷霆", "达拉斯独行侠", "新奥尔良鹈鹕"]
for item in team_list:
    print(item)

执行上面的代码，将显示所示的结果。

使用for循环和enumerate()函数实现

使用for循环和enumerate()函数可以实现同时输出索引值和元素内容，语法格式如下：

for index, item in enumerate(list_name):
	print(index, item)

参数说明：

1. index：用于保存元素的索引。
2. item：用于保存获取到的元素值，要输出元素内容时，直接输出该变量即可。
3. list_name为列表名称。

例如，定义一个保存2019~2020赛季NBA常规赛西部前八排名预测的列表，然后通过for循环和enumerate()函数遍历该列表，并输出索引和球队名称，代码如下：

print("2019~2020赛季NBA常规赛西部前八排名预测: ")
team_list = ["洛杉矶湖人", "洛杉矶快船", "丹佛掘金", "犹他爵士",
             "404队", "俄克拉荷马雷霆", "达拉斯独行侠", "新奥尔良鹈鹕"]
for index, item in enumerate(team_list):
    print(index + 1, item)

执行上面的代码，将显示下面的结果：

添加、修改和删除列表元素

添加元素

列表对象的**append()**方法用于在列表的末尾追加元素，语法格式如下：

list_name.append(obj)

参数说明：

1. list_name为要添加元素的列表名称
2. obj为要添加到列表末尾的对象

例如，定义一个包括4个元素的列表，然后应用append()方法向该列表的末尾添加一个元素，可以使用下面的代码：

phone_list = ["华为", "苹果", "小米", "三星"]
print(len(phone_list))  # 获取列表的长度
phone_list.append("诺基亚")
print(len(phone_list))  # 获取列表的长度
print(phone_list)

运行结果如下：

如果想要向列表的指定位置插入元素，可以使用列表对象的**insert()**方法实现。其语法格式如下：

list_name.insert(index, obj)

参数说明：

1. list_name：表示原列表。
2. index：表示对象obj需要插入的索引值。
3. obj：表示要插入列表中的对象。

定义一个包括5个元素的列表，然后应用insert()方法向该列表的第2个位置处添加一个元素，示例代码如下：

area_list = ["渝北区", "沙坪坝区", "南岸区", "江北区", "九龙坡区"]  # 定义原列表
print("原列表:", area_list)
area_list.insert(1, "铜梁区")  # 向原列表的第2个位置处添加元素
print("新列表:", area_list)

运行结果如下：

insert()方法的执行效率没有append()方法高，所以不推荐这种方法*。
上面介绍的是向列表中添加一个元素，如果想要将一个列表中的全部元素添加到另一个列表中，可以使用列表对象的**extend()**方法实现。extend()方法的语法如下：

list_name.extend(seq)

参数说明：

1. listname为原列表
2. seq为要添加的序列(列表，字符串等都可以)
3. 语句执行后，seq的内容将追加到list_name的后面。

场景模拟：布塔学院差不多每年都有新增加的合作院校。2020年又新增了三个，现编程实现将他们添加到合作院校列表

# 布塔学院原有合作院校
old_list = ["重庆师范大学"]
# 新增加院校列表
new_list = ["山东大学", "重庆大学", "四川大学"]
old_list.extend(new_list)  # 追加新院校
print(old_list)

程序运行结果如图所示：

修改元素

修改列表中的元素只需要通过索引获取该元素，然后再为其重新赋值即可。例如，定义一个保存3个元素的列表，然后修改索引值为2的元素，代码如下：

verse_list = ["长亭外", "古道边", "芳草碧连天"]
print(verse_list)
verse_list[2] = "一行白鹭上青天"  # 修改列表的第3个元素
print(verse_list)

程序运行结果如图所示:

删除元素

删除元素主要有两种情况，一种是根据索引删除，另一种是根据元素值进行删除。

根据索引删除

除列表中的指定元素和删除列表类似，也可以使用del语句实现。所不同的就是在指定列表名称时，换为列表元素。例如，定义一个保存3个元素的列表，删除最后一个元素，可以使用下面的代码：

verse_list = ["长亭外", "古道边", "芳草碧连天"]
print(verse_list)
del verse_list[-1]
print(verse_list)

运行结果如图所示：

根据元素值删除

如果想要删除一个不确定其位置的元素（即根据元素值删除），可以使用列表对象的**remove()**方法实现。例如，要删除列表中内容为"公牛"的元素，可以使用下面的代码：

team_list = ["火箭", "勇士", "开拓者", "爵士", "鹈鹕", "马刺", "雷霆", "森林狼"]
print(team_list)
team_list.remove("公牛")
print(team_list)

使用列表对象的remove()方法删除元素时，如果指定的元素不存在，将出现如图所示的异常信息。

所以在使用remove()方法删除元素前，最好先判断该元素是否存在，改进后的代码如下：

team_list = ["火箭", "勇士", "开拓者", "爵士", "鹈鹕", "马刺", "雷霆", "森林狼"]
value = "勇士"  # 指定要移除的元素
print(team_list)
if team_list.count(value) > 0:  # 判断要删除的元素是否存在
    team_list.remove(value)
print(team_list)

列表对象的**count()**方法用于判断指定元素出现的次数，**返回结果为0时，表示不存在该元素。运行结果如图所示：

对列表进行统计和计算

Python的列表提供了内置的一些函数来实现统计、计算的功能

获取指定元素出现的次数

使用列表对象的**count()**方法可以获取指定元素在列表中的出现次数。基本语法格式如下：

list_name.count(obj)

参数说明：

1. list_name：表示列表的名称。
2. obj：表示要判断是否存在的对象，这里只能进行精确匹配，即不能是元素值的一部分。
3. 返回值：元素在列表中出现的次数。

例如，创建一个列表，内容为听众点播的歌曲列表，然后应用列表对象的count()方法判断元素"天涯"出现的次数，代码如下：

song_list = ["处处吻", "天涯", "一个人挺好", "最近", "天涯", "下山"]
num = song_list.count("天涯")
print(num)

上面的代码运行后，结果将显示为2，表示"天涯"在song_list列表中出现了两次。

获取指定元素首次出现的下标

使用列表对象的**index()**方法可以获取指定元素在列表中首次出现的位置（即索引）。基本语法格式如下：

list_name.index(obj)

参数说明:

1. list_name：表示列表的名称。
2. obj：表示要查找的对象，这里只能进行精确匹配。如果指定的对象不存在时，则抛出如图所示的异常。
3. 返回值：首次出现的索引值。

例如，创建一个列表，内容为听众点播的歌曲列表，然后应用列表对象的index()方法判断元素"天涯"首次出现的位置，代码如下：

song_list = ["处处吻", "天涯", "一个人挺好", "最近", "天涯", "下山"]
position = song_list.index("天涯")
print(position)

上面的代码运行后，，将显示1，表示"天涯"在列表song_list中首次出现的索引位置是1。

统计数值列表的元素和

在Python中，提供了**sum()**函数用于统计数值列表中各元素的和。语法格式如下：

sum(iterable[,start])

参数说明：

1. iterable：表示要统计的列表。
2. start：表示统计结果是从哪个数开始（即将统计结果加上start所指定的数），是可选参数，如果没有指定，默认值为0。

例如，定义一个保存10名学生语文成绩的列表，然后应用sum()函数统计列表中元素的和，即统计总成绩，然后输出，代码如下：

# 10名学生的语文成绩列表
grade = [98, 99, 97, 100, 100, 96, 94, 89, 95, 100]
total = sum(grade)  # 计算总成绩
print("语文总成绩为: ", total)  # 968

对列表进行排序

在实际开发时，经常需要对列表进行排序。Python中提供了两种常用的对列表进行排序的方法：

1. 使用列表对象的sort()方法
2. 使用内置的sorted()函数。

使用列表对象的sort()方法

列表对象提供了**sort()**方法用于对原列表中的元素进行排序。排序后原列表中的元素顺序将发生改变。列表对象的sort()方法的语法格式如下：

list_name.sort(key=None, reverse=False)

参数说明:

1. list_name：表示要进行排序的列表。
2. key：表示指定从每个元素中提取一个用于比较的键
3. reverse：可选参数，如果将其值指定为True，则表示降序排列；如果为False，则表示升序排列，默认为升序排列

例如，定义一个保存10名学生语文成绩的列表，然后应用sort()方法对其进行排序，代码如下：

# 10名学生语文成绩列表
grade_list = [98, 99, 97, 100, 100, 96, 94, 89, 95, 100]  
print("原列表: ", grade_list)
grade_list.sort()  # 进行升序排列
print("升  序: ", grade_list)
grade_list.sort(reverse=True)  # 进行降序排列
print("降  序: ", grade_list)

运行结果如图所示：

使用sort()方法进行数值列表的排序比较简单，但是使用sort()方法对字符串列表进行排序时，采用的规则是先对大写字母排序，然后再对小写字母排序。如果想要对字符串列表进行排序（不区分大小写时），需要指定其key参数。例如，定义一个保存英文字符串的列表，然后应用sort()方法对其进行升序排列，可以使用下面的代码：

char_list = ['cat', 'Tom', 'Angela', 'pet']
char_list.sort()  # 默认区分字母大小写
print("区分字母大小写: ", char_list)
char_list.sort(key=str.lower)  # 不区分字母大小写
print("不区分字母大小写: ", char_list)

运行结果如图所示：

采用sort()方法对列表进行排序时，对中文支持不好。排序的结果与我们常用的音序排序法或者笔画排序法都不一致。如果需要实现对中文内容的列表排序，还需要重新编写相应的方法进行处理，不能直接使用sort()方法

使用内置的sorted()函数实现

在Python中，提供了一个内置的sorted()函数，用于对列表进行排序。使用该函数进行排序后，原列表的元素顺序不变。sorted()函数的语法格式如下：

sorted(iterable, key=None, reverse=False)

参数说明:

1. iterable：表示要进行排序的列表名称。
2. key：表示指定从每个元素中提取一个用于比较的键(简单理解就是比较的规则 一般是写函数名或者是方法名)
3. reverse：可选参数，如果将其值指定为True，则表示降序排列；如果为False，则表示升序排列，默认为升序排列。

例如，定义一个保存10名学生语文成绩的列表，然后应用sorted()函数对其进行排序，代码如下：

# 10名学生语文成绩列表
grade_list = [98, 99, 97, 100, 100, 96, 94, 89, 95, 100]
grade_as = sorted(grade_list)  # 进行升序排列
print("升序: ", grade_as)
grade_des = sorted(grade_list, reverse=True)  # 进行降序排列
print("降序: ", grade_des)
print("原序列: ", grade_list)

运行结果如图所示：

列表对象的sort()方法和内置sorted()函数的作用基本相同；不同点是在使用sort()方法时，会改变原列表的元素排列顺序，而使用sorted()函数时，会建立一个原列表的副本，该副本为排序后的列表。

列表推导式

生成指定范围的数值列表

语法格式如下：

list = [Expression for var in range]

参数说明：

1. list：表示生成的列表名称。
2. Expression：表达式，用于计算新列表的元素。
3. var：循环变量。
4. range：采用range()函数生成的range对象。

例如，要生成一个包括10个随机数的列表，要求数的范围在10~100（包括）之间，具体代码如下：

import random  # 导入random标准库

num_list = [random.randint(10, 100) for i in range(10)]
print("生成的随机数为:", num_list)

执行结果如图所示：

根据列表生成指定需求的列表

语法格式如下：

newlist = [Expression for var in list]

参数说明：

1. newlist：表示新生成的列表名称。
2. Expression：表达式，用于计算新列表的元素。
3. var：变量，值为后面列表的每个元素值。
4. list：用于生成新列表的原列表。

例如，定义一个记录商品价格的列表，然后应用列表推导式生成一个将全部商品价格打五折的列表，具体代码如下：

price = [1200, 5330, 2988, 6200, 1998, 8888]
sale = [int(x * 0.5) for x in price]
print("原价格: ", price)
print("打五折的价格: ", sale)

运行结果如图所示：

从列表中选择符合条件的元素组成新的列表

语法格式如下：

newlist = [Expression for var in list if condition]

参数说明：

1. newlist：表示新生成的列表名称。
2. Expression：表达式，用于计算新列表的元素。
3. var：变量，值为后面列表的每个元素值。
4. list：用于生成新列表的原列表。
5. condition：条件表达式，用于指定筛选条件

例如，定义一个记录商品价格的列表，然后应用列表推导式生成一个商品价格高于5000元的列表，具体代码如下：

price = [1200, 5330, 2988, 6200, 1998, 8888]
sale = [x for x in price if x > 5000]
print("原列表: ", price)
print("价格高于5000的: ", sale)

运行结果

二维列表的使用

在Python中，由于列表元素还可以是列表，所以它也支持二维列表的概念。那么什么是二维列表？酒店有很多房间，这些房间都可以构成一个列表，如果这个酒店有500个房间，那么拿到499号房钥匙的旅客可能就不高兴了，从1号房走到499号房要花好长时间，因此酒店设置了很多楼层，每一个楼层都会有很多房间，形成一个立体的结构，把大量的房间均摊到每个楼层，这种结构就是二维列表结构。使用二维列表结构表示酒店每个楼层的房间号的效果如图所示。

二维列表中的信息以行和列的形式表示，第一个下标代表元素所在的行，第二个下标代表元素所在的列。在Python中，创建二维列表有以下三种常用的方法。

直接定义二维列表

在Python中，二维列表是包含列表的列表，即一个列表的每一个元素又都是一个列表。例如，下面就是一个二维列表：

[['千', '山', '鸟', '飞', '绝'],
 ['万', '径', '人', '踪', '灭'],
 ['孤', '舟', '蓑', '笠', '翁'],
 ['独', '钓', '寒', '江', '雪']]

在创建二维列表时，可以直接使用下面的语法格式进行定义：

list_name = [[元素11, 元素12, 元素13, …, 元素1n],
 [元素21, 元素22, 元素23, …, 元素2n],
 …,
 [元素n1, 元素n2, 元素n3, …, 元素nn]]

参数说明：

1. listname：表示生成的列表名称。
2. [元素11, 元素12, 元素13, …, 元素1n]：表示二维列表的第一行，也是一个列表。其中"元素11,元素12,…元素1n"代表第一行中的列。
3. [元素21, 元素22, 元素23, …, 元素2n]：表示二维列表的第二行。
4. [元素n1, 元素n2, 元素n3, …, 元素nn]：表示二维列表的第n行。

例如，定义一个包含4行5列的二维列表，可以使用下面的代码：

verse_list = [['千', '山', '鸟', '飞', '绝'], ['万', '径', '人', '踪', '灭'],
              ['孤', '舟', '蓑', '笠', '翁'], ['独', '钓', '寒', '江', '雪']]
print(verse_list)

执行结果如图所示：

使用嵌套的for循环创建

创建二维列表，可以使用嵌套的for循环实现。例如，创建一个包含4行5列的二维列表，可以使用下面的代码：

arr = []  # 创建一个空列表
for i in range(4):
    arr.append([])  # 在空列表中再添加一个空列表
    for j in range(5):
        arr[i].append(j)  # 为内层列表添加元素
print(arr)

运行结果如图所示：

使用列表推导式创建

使用列表推导式也可以创建二维列表，因为这种方法比较简洁，所以建议使用这种方法创建二维列表。例如，使用列表推导式创建一个包含4行5列的二维列表可以使用下面的代码：

arr = [[j for j in range(5)] for i in range(4)]

创建二维数组后，可以通过以下语法格式访问列表中的元素：

list_name[下标1][下标2]

参数说明：

1. list_name：列表名称。
2. 下标1：表示列表中第几行，下标值从0开始，即第一行的下标为0。
3. 下标2：表示列表中第几列，下标值从0开始，即第一列的下标为0。

例如，要访问二维列表中的第2行，第4列，可以使用下面的代码：

verse_list[1][3]

下面通过一个具体实例演示二维列表的应用

在PyCharm中创建一个名称为print_verse.py的文件，然后在该文件中首先定义4个字符串，内容为柳宗元的《江雪》中的诗句，并定义一个二维列表，然后应用嵌套的for循环将古诗以横版方式输出，再将二维列表进行逆序排列，最后应用嵌套的for循环将古诗以竖版方式输出，代码如下

str1 = "千山鸟飞绝"
str2 = "万径人踪灭"
str3 = "孤舟蓑笠翁"
str4 = "独钓寒江雪"
verse = [list(str1), list(str2), list(str3), list(str4)]  # 定义一个二维列表
print("\n-- 横版 --\n")
for i in range(4):  # 循环古诗的每一行
    for j in range(5):  # 循环每一行的每个字（列）
        if j == 4:  # 如果是一行中的最后一个字
            print(verse[i][j])  # 换行输出
        else:
            print(verse[i][j], end="")  # 不换行输出
verse.reverse()  # 对列表进行逆序排列
print("\n-- 竖版 --\n")
for i in range(5):  # 循环每一行的每个字（列）
    for j in range(4):  # 循环新逆序排列后的第一行
        if j == 3:  # 如果是最后一行
            print(verse[j][i])  # 换行输出
        else:
            print(verse[j][i], end="")  # 不换行输出

说明：在上面的代码中，list()函数用于将字符串转换为列表；列表对象的reverse()方法用于对列表进行逆序排列，即将列表的最后一个元素移到第一个，倒数第二个元素移到第二个，以此类推。
运行结果如图所示：