我将解释如何使用列表，它是 Python 的内置类型之一。列表是一种可变的序列类型。可变意味着列表可以改变，列表创建后可以更改或删除元素。序列类型是多个元素按顺序排列的数据类型。
目录
10-1 创建一个列表
10-2 获取列表元素
10-3 使用切片从列表中获取包含指定范围元素的新列表
10-4 获取列表的长度（元素个数）
10-5 交换列表元素
10-6 将元素附加到列表并与另一个列表组合
10-7 在列表中的指定位置插入一个元素
10-8 从列表中删除元素
10-9 检查列表是否包含与指定值相同的元素
10-10 按升序或降序对列表元素进行排序
10-11 从字符串、元组、范围等创建列表
10-12 创建多维列表并获取元素
10-13 使用列表理解创建列表
10-14 使用多个循环创建列表的列表理解
10-1创建一个列表
我将解释如何创建新列表。列表包含多个元素，除了通过为元素指定值来创建列表之外，我们还可以指定变量或创建将相同元素重复指定次数的列表。
通过指定值创建列表
列表类型是通过在 [ ] 之间用逗号 (,) 分隔多个元素来定义的。格式如下。
[元素1, 元素2, ...]元素可以是 Python 可以处理的任何东西，例如数字和字符串。
[10, 20, 30, 40, 50]
["Blue", "Red", "Green"]可以为同一列表中的每个元素指定不同数据类型的对象。
[25, "Yuhua", True]我们可以为该元素指定另一个列表。
["Jiangming", [87, 54, 62], 78]我们可以创建一个包含空元素的列表。
[]生成的列表可以分配给数值或字符串等变量来使用。
colorlist = ["Blue", "Red", "Green"]指定分配给变量的值作为元素
通过指定值创建列表时，我们可以指定分配值的变量来创建列表，而不是直接输入值。
x = 10
y = 15
numlist = [x, y]
print(numlist)
>> [10, 15]如果为一个元素指定了一个变量名，它将以与创建列表时分配给变量的值相同的方式处理，而不是将变量引用设置为元素。所以前面的列表与您创建的列表完全相同：
numlist = [10, 15]
print(numlist)
>> [10, 15]创建列表之后，再次改变变量的值，不会影响列表的元素值。
x = 10
y = 15
numlist = [x, y]
print(numlist)
>> [10, 15]
x = 50
print(numlist)
>> [10, 15]创建一个重复指定数量元素的列表
例如，要创建一个包含指定数量的具有特定值的元素的列表，我们可以这样做：。
列表 = [元素] * 个数例如，要创建一个包含 10 个元素且数值为 0 的列表：
numlist = [0] * 10
print(numlist)
>> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]要创建一个包含 5 个引用字符串“undefined”的元素的列表：
namellist = ["undefined"] * 5
print(namellist)
>> ['undefined', 'undefined', 'undefined', 'undefined', 'undefined']当我们想要创建一个包含指定数量的元素并包含指定初始值的列表时，这很有用。
请注意，如果我们将另一个列表指定为重复元素，而不是创建一个包含指定数量的列表元素的新列表，而是创建一个重复列表中包含的指定数量的元素的新列表。
numlist = [10, 20, 30] * 3
print(numlist)
>> [10, 20, 30, 10, 20, 30, 10, 20, 30]10-2 获取列表元素
我们可以通过为创建的列表指定索引来获取元素。下面介绍如何获取列表的元素。
按索引获取元素
列表的每个元素都分配有一个索引。列表中的第一个元素的索引为 0，并向后分配 1、2、…。我们可以通过索引列表来获取元素。
列表 [索引]以下示例按顺序获取列表的每个元素并将其输出到屏幕。
colorlist = ["Red", "Blue", "Green"]
print(colorlist[0])
>> Red
print(colorlist[1])
>> Blue
print(colorlist[2])
>> Green索引也可以指定为负值。列表中的最后一个元素的索引为 -1，并被分配为 -2、-3、… 向前移动。
在以下示例中，通过指定负索引顺序检索列表的每个元素并将其打印到屏幕上。
colorlist = ["Red", "Blue", "Green"]
print(colorlist[-1])
>> Green
print(colorlist[-2])
>> Blue
print(colorlist[-3])
>> Red如果我们尝试通过指定元素不存在的索引来检索元素，则会发生 IndexError 错误。
colorlist = ["Red", "Blue", "Green"]
print(colorlist[3])
>> Traceback (most recent call last):
>> File "", line 1, in
>> IndexError: list index out of range查找列表中最后一个元素的索引
可以通过将列表指定为内置函数的 len 函数的参数来获取列表中的元素数。
len(["Red", "Blue", "Green"]) // 3列表中第一个元素的索引从 0 开始，因此最后一个元素的索引是元素个数 [-1]。所以最后一个元素的索引可以用 len(list) -1 获得。
print(colorlist[len(colorlist) - 1])
>> Green示例代码
请看下面的示例。
colorlist = ["Blue", "Red", "Green", "White", "Black"]
print("第一个元素是 " + colorlist[0] + " 。")
>> 第一个元素是 Blue。
print("最后一个元素是 " + colorlist[len(colorlist) - 1] + " です。")
>> 最后一个元素是 Black 。我们能够通过指定索引来获取列表的元素。
10-3 使用切片从列表中获取包含指定范围元素的新列表
可以对列表进行切片，得到一个包含从起始索引到结束索引的元素的新列表。本节介绍如何使用 slice 函数从列表中获取包含指定范围元素的新列表。
对列表使用切片功能
您可以在一个已经创建的列表上使用 slice 函数来获取一个新列表，该列表包含从开始位置到结束位置的指定范围内的元素。格式如下。
列表 [开始索引：结束索引]指定范围的方法，指定范围的第一个元素的索引作为起始索引，指定范围最后一个元素的索引加1得到的值作为结束索引。请参见下面的示例。
mylist = ["A", "B", "C", "D", "E"]
#从索引 1 到 3 获取元素
mylist[1:4]
--> ["B", "C", "D"]
#从索引 0 到 2 获取元素
mylist[0:3]
--> ["A", B", "C"]
#获取索引为3的元素
mylist[3:4]
--> ["D"]切片允许您获得包含一系列元素的新列表。请注意，即使只有一个元素，它也会作为列表检索。
示例代码
请看下面的示例。
colorlist = ["Blue", "Red", "Green", "White", "Black"]
print(colorlist[1:3])
>> ['Red', 'Green']
print(colorlist[2:3])
>> ['Green']我们能够使用切片从先前创建的列表中获取包含一些元素的新列表。
省略开始或结束索引
使用 slice 函数时可以省略开始或结束索引。
如果省略起始索引，则假定为 0。0 是列表中第一个元素的索引，因此如果省略起始索引，则范围是从列表的第一个元素到指定的结束索引。
mylist = ["A", "B", "C", "D", "E"]
#获取索引1到3的元素
mylist[:4]
--> ["A", B", "C", "D"]如果省略结束索引，则假定 len(list) 的值。如果将列表指定为 len 函数的参数，它会返回列表中元素的数量，因此如果省略结束索引，则范围将从指定的起始索引到列表的最后一个元素。
mylist = ["A", "B", "C", "D", "E"]
#获取索引2到末尾的元素
mylist[2:]
--> [C", "D", "E"]如果您同时省略起始索引和结束索引，则会得到一个包含原始列表所有元素的新列表，因为该列表从第一个元素跨越到最后一个元素。
mylist = ["A", "B", "C", "D", "E"]
#获取从第一个到最后一个索引的元素
mylist[:]
--> ["A", "B", "C", "D", "E"]示例代码
请看下面的示例
colorlist = ["Blue", "Red", "Green", "White", "Black"]
print(colorlist[:3])
>> ['Blue', 'Red', 'Green']
print(colorlist[2:])
>> ['Green', 'White', 'Black']
print(colorlist[:])
>> ['Blue', 'Red', 'Green', 'White', 'Black']这节课讲解了，我们在使用切片时通过省略开始或结束索引，来指定范围。
10-4 获取列表的长度（元素个数）
我将解释如何使用内置的 len 函数获取列表的长度（元素数）。
获取列表长度
内置的 len 函数可以获取作为参数指定的对象的长度和元素个数。如果将列表指定为参数，则可以获得列表中包含的元素数。格式如下。
len（列表）获取参数中指定的列表中的元素数。
len(["Red", "Green", "Blue"])
--> 3
len([1, 2, 3, 4, 5])
--> 5
len([10, 20, ["Sun", "Mon", "Fri"], 40])
--> 4示例代码
请看下面的示例。
colorlist = ["Blue", "Red", "Green", "White", "Black"]
print("元素个数为 " + str(len(colorlist)) + "个。")
>> 元素个数为5个。这样我么，就够使用 len 函数获取列表中的元素数。
10-5 交换列表元素
创建列表后，您可以用其他元素替换元素。在这里，我将解释如何从已经创建的列表的元素中借用具有不同值的元素。
交换某些元素
要用具有不同值的元素替换列表中的指定元素，请指定要替换的元素的索引并将新值分配给该元素，如下所示：
列表[索引] = 值以下示例将第二个元素的值（ 1 因为索引从 0 开始）更改为其他值。
mylist = ["Apple", "Peach", "Orange"]
print(mylist)
--> ['Apple', 'Peach', 'Orange']
# 用另一个值替换第二个元素
mylist[1] = "Grape"
print(mylist)
--> ['Apple', 'Grape', 'Orange']列表是可变对象，因此您可以在保留同一对象的同时用其他元素替换元素。因此，即使您将元素更改为具有不同值的元素，对象也将保持不变。
示例代码
请看下面的示例。
colorlist = ["Blue", "Red", "Green"]
print("objectid = " + str(id(colorlist)))
>> objectid = 3163508123904
colorlist[1] = "White"
print(colorlist)
>> ['Blue', 'White', 'Green']
print("objectid = " + str(id(colorlist)))
>> objectid = 3163508123904我们能够用具有不同值的元素替换指定的元素。
使用 slice 函数一次交换多个元素
通过使用 slice 函数，您可以一次替换多个元素。通过指定开始索引和结束索引来交换范围内的元素。
列表[起始索引：结束索引] = 列表等指定范围的方法，指定范围的第一个元素的索引作为起始索引，指定范围最后一个元素的索引加1得到的值作为结束索引。
替换现有元素的新元素指定可迭代对象，例如列表。可迭代对象是字符串、列表、元组、字典等。如果您指定一个字符串，例如“ABC”，它将被视为每个字符的元素，如[“A”，“B”，“C”]。
以下示例将第 2 到第 4 个元素（起始索引为 1，结束索引为 4）与另一个列表交换。
mylist = ["A", "B", "C", "D", "E", "F"]
print(mylist)
--> ["A", "B", "C", "D", "E", "F"]
# 交换第 2 到第 4 个元素
mylist[1:4] = ["1", "2", "3"]
print(mylist)
--> ["A", "1", "2", "3", "E", "F"]借用元素的数量和新元素的数量不必相同。或多或少都可以。例如，如果你减少它，列表中的元素数量就会减少。
mylist = ["A", "B", "C", "D", "E", "F"]
print(mylist)
--> ["A", "B", "C", "D", "E", "F"]
# 交换第 2 到第 4 个元素
mylist[1:4] = ["1", "2"]
print(mylist)
--> ["A", "1", "2", E", "F"]还可以通过省略开始索引和结束索引并指定步数来指定切片。注意，使用步数时，要替换的元素数必须与新元素数相同。
mylist = ["A", "B", "C", "D", "E", "F"]
print(mylist)
--> ["A", "B", "C", "D", "E", "F"]
#交换第 2 到第 6 的每两个元素
mylist[1:7:2] = ["1", "2", "3"]
print(mylist)
--> ["A", "1", "C", "2", "E", "3"]示例代码
请看下面的示例。
colorlist = ["Blue", "Red", "Green", "White"]
colorlist[1:3] = ["Yellow", "Pink", "Black"]
print(colorlist)
>> ['Blue', 'Yellow', 'Pink', 'Black', 'White']
colorlist[1:5:2] = ["Gold", "Silver"]
print(colorlist)
>> ['Blue', 'Gold', 'Pink', 'Silver', 'White']我们能够使用 slice 函数用另一个元素替换多个元素。
10-6 将元素附加到列表并与另一个列表组合
我将解释如何将新元素添加到已创建的列表以及如何加入（连接）另一个列表。使用 append 方法和 extend 方法添加元素。
向列表中添加一个元素
如何向列表中添加新元素。使用列表类型上可用的附加方法。
リスト.append(値)将具有指定值的元素添加到列表的末尾。
具体写如下。
mylist = ["A", "B", "C"]
mylist.append("D")
print(mylist)
--> ["A", "B", "C", "D"]示例代码
请看下面的示例。
mylist = ["Blue", "Red", "Green"]
# 添加"White"
mylist.append("White")
print(mylist)
>> ['Blue', 'Red', 'Green', 'White']
# 添加"Black"
mylist.append("Black")
print(mylist)
>> ['Blue', 'Red', 'Green', 'White', 'Black']我能够使用 append 方法将一个元素附加到列表的末尾。
使用 slice 函数添加元素
对于列表，可以指定切片函数的起始索引和结束索引，将列表的指定范围内的元素替换为另一个元素，但起始索引和结束索引都是紧邻列表最后一个元素的位置。您可以通过指定将元素添加到列表的末尾。列表的最后一个元素的索引可以使用内置的 len 函数作为 len(list) -1 获得，因此最后一个元素的位置可以由 len(list) 给出。
list[len(list):len(list)] = list 等将等于运算符右侧指定的列表添加到列表末尾。
具体写如下。
mylist = ["A", "B", "C"]
mylist[len(mylist):len(mylist)] = ["D", "E"]
print(mylist)
--> ["A", "B", "C", "D", "E"]示例代码
请看下面的示例。
citylist = ["Qingdao", "Yantai", "Weihai", "Jinan"]
addlist = ["Guanzhou", "Shanghai", "Yunnan"]
# 将 addlist 元素添加到 citylist
citylist [len(citylist ):len(citylist )] = addlist
print(citylist )
>> ['Qingdao', 'Yantai', 'Weihai', 'Jinan', 'Guanzhou', 'Shanghai', 'Yunnan']这样我们就能够使用 slice 函数将另一个列表的元素附加到列表的末尾。
向列表中添加另一个类似列表的元素
如何将另一个列表的元素添加到列表中。使用列表类型可用的扩展方法。
列表.extend（列表等）将参数中指定的列表的元素添加到列表的末尾。可以添加可迭代对象，例如列表。可迭代对象是字符串、列表、元组、字典等。
具体写如下。
mylist = ["A", "B", "C"]
mylist.extend(["D", "E"])
print(mylist)
--> ["A", "B", "C", "D", "E"]请注意，如果将另一个列表指定为 append 方法而不是 extend 方法的参数，则列表本身将作为一个元素添加，而不是添加另一个列表的元素。
mylist = ["A", "B", "C"]
mylist.append(["D", "E"])
print(mylist)
--> ["A", "B", "C", ["D", "E"]]示例代码
请看下面的示例。
eastlist = ["Qingdao", "Yantai", "Weihai", "Jinan"]
westlist = ["Guanzhou", "Shanghai", "Yunnan"]
# 将元素从westlist添加到eastlist
eastlist.extend(westlist)
print(eastlist)
>> ['Qingdao', 'Yantai', 'Weihai', 'Jinan', 'Guanzhou', 'Shanghai', 'Yunnan']这样我们就能够使用 extend 方法将另一个列表元素添加到列表的末尾。
将一个列表与另一个列表组合以创建一个新列表
您可以在列表上使用 + 运算符将其与另一个列表组合以创建新列表。
新列A + 新列B使用来自两个列表的元素创建一个新列表。
具体写如下。
list1 = ["A", "B"]
list2 = ["C", "D"]
list3 = list1 + list2
print(list3)
--> ["A", "B", "C", "D"]示例代码
请看下面的示例。
redlist = ["Orange", "Strawberry"]
yellowlist = ["Lemon", "Banana", "Grapefruit"]
# 结合红名单和黄名单
fruitlist = redlist + yellowlist
print(fruitlist)
>> ['Orange', 'Strawberry', 'Lemon', 'Banana', 'Grapefruit']这样我们就能够合并两个列表来创建一个新列表。
创建一个新列表，其中列表的元素重复指定次数
您可以在列表上使用 * 运算符来创建一个新列表，该列表将列表中的元素重复指定的次数。
列表 * 次数创建一个新列表，其中列表的元素重复指定的次数。
具体写如下。
list = ["A", "B"]
newlist = list * 3
print(newlist)
--> ["A", "B", "A", "B", "A", "B"]示例代码
请看下面的示例。
baselist = ["Yes", "No"]
datalist = baselist * 4
print(datalist)
>> ['Yes', 'No', 'Yes', 'No', 'Yes', 'No', 'Yes', 'No']这样我们就能够创建一个新列表，其中列表的元素重复指定的次数。
10-7 在列表中的指定位置插入一个元素
说明如何在已创建的列表中的指定位置插入新元素。使用 insert 方法插入元素。
向列表中插入一个元素
如何在列表中的指定位置插入新元素。使用可用于列表类型的插入方法。
列表.insert（索引，值）在列表中指定索引处的元素之前插入具有参数中指定值的元素。第一个元素的索引为 0，下一个元素的索引为 1，依此类推。
具体写如下。
mylist = ["A", "B", "C"]
mylist.insert(1, "Z")
print(mylist)
--> ["A", "Z", "B", "C"]示例代码
请看下面的示例。
mylist = ["Blue", "Red", "Green"]
# 在索引 2 之前插入“White”
mylist.insert(2, "White")
print(mylist)
>> ['Blue', 'Red', 'White', 'Green']
# 在开始插入"Black"
mylist.insert(0, "Black")
print(mylist)
>> ['Black', 'Blue', 'Red', 'White', 'Green']我能够使用 insert 方法在列表中的指定位置插入一个元素。
使用 slice 函数插入元素
对于列表，可以指定切片函数的起始索引和结束索引，将列表的指定范围的元素替换为另一个元素，但起始索引和结束索引都指定了要插入的元素的索引新元素。将在指定位置插入元素。
列表[index:index] = 列表等在列表中指定索引处的元素之前，将指定的列表插入等于运算符的右侧。
具体写如下。
mylist = ["A", "B", "C"]
mylist[1:1] = ["D", "E"]
print(mylist)
--> ["A", "D", "E", "B", "C"]示例代码
请看下面的示例。
mylist = ["Isu", "Uma", "Ashika"]
addlist = ["Ushi", "Inu"]
# 在索引 1 之前插入另一个列表
mylist[1:1] = addlist
print(mylist)
>> ['Isu', 'Ushi', 'Inu', 'Uma', 'Ashika']这样我们就能够使用 slice 函数在列表的指定位置插入另一个列表的元素。
10-8 从列表中删除元素
我将解释如何从已经创建的列表中删除指定位置的元素，以及如何删除与指定值具有相同值的元素。使用 del 语句、pop 方法和 remove 方法删除元素。还可以使用 clear 方法删除所有元素。
使用 del 语句删除一个元素
del 语句删除索引列表元素。像这样运行它：
del list[index]
del list[起始索引:结束索引]del 语句用于删除索引列表元素。您还可以使用切片一次删除指定范围的元素。
具体写如下。
mylist = ["A", "B", "C", "D", "E"]
del mylist[1]
print(mylist)
--> ["A", "C", "D", "E"]
del mylist[1:3]
print(mylist)
--> ["A", "E"]示例代码
请看下面的示例。
fruitslist = ["Orange", "Lemon", "Peach", "Grapes", "Apple"]
# 删除“Peach”
del fruitslist[2]
print(fruitslist)
>> ['Orange', 'Lemon', 'Grapes', 'Apple']
# 删除从“Lemon”到“Grapes”的所有元素。
del fruitslist[1:3]
print(fruitslist)
>> ['Orange', 'Apple']我们能够使用 del 语句删除列表的元素。
使用 slice 函数删除元素
在列表中，可以指定切片函数的起始索引和结束索引，并将列表指定范围内的元素替换为另一个元素，但如果指定一个空元素作为要替换的元素，则指定范围的元素将被删除。可以做。
列表[开始索引：结束索引] = []使用切片删除一系列元素。
具体写如下。
mylist = ["A", "B", "C", "D", "E"]
mylist[2:4] = []
print(mylist)
--> ["A", "B", "E"]示例代码
请参阅以下示例。
numlist = ["One", "Two", "Three", "Four", "Five"]
# 删除"Three"
numlist[2:3] = []
print(numlist)
>> ['One', 'Two', 'Four', 'Five']
# 删除从"Two"到"Four"的元素
numlist[1:3] = []
print(numlist)
>> ['One', 'Five']我们能够使用 slice 函数将另一个列表的元素附加到列表的末尾。
删除索引指定的元素
如何从列表中删除索引元素。使用列表类型上可用的 pop 方法。
リスト.pop()
リスト.pop(索引)pop 方法检索指定索引处的元素并将其从列表中删除。如果省略索引，则删除列表的最后一个元素。
具体写如下。
mylist = ["A", "B", "C", "D", "E"]
mylist.pop()
print(mylist)
--> ["A", "B", "C", "D"]
mylist.pop(1)
print(mylist)
--> ["A", "C", "D"]示例代码
请看下面的示例。
fruitslist = ["Orange", "Lemon", "Peach", "Grapes", "Apple"]
# 获取最后一个元素并删除它
print("Delete: " + fruitslist.pop())
>> Delete: Apple
print(fruitslist)
>> ['Orange', 'Lemon', 'Peach', 'Grapes']
# 获取最后一个元素并删除它
print("Delete: " + fruitslist.pop())
>> Delete: Grapes
print(fruitslist)
>> ['Orange', 'Lemon', 'Peach']
# 删除"Lemon"
print("Delete: " + fruitslist.pop(1))
>> Delete: Lemon
print(fruitslist)
>> ['Orange', 'Peach']我们能够使用索引获取指定的元素，然后将其删除。
移除与指定值具有相同值的元素
如何从列表中删除与指定值具有相同值的元素。使用可用于列表类型的 remove 方法。
list.remove(值)删除与参数中指定的值具有相同值的元素（对象可以不同）。如果第一个匹配元素与列表中的多个元素匹配，则将其移除。
具体写如下。
mylist = ["A", "B", "C", "D", "E"]
mylist.remove("C")
print(mylist)
--> ["A", "B", "D", "E"]
mylist.remove("B")
print(mylist)
--> ["A", "D", "E"]如果找不到与 remove 方法的参数中指定的值匹配的元素，则会发生 ValueError 错误。
示例代码
请看下面的示例。
animallist = ["Dog", "Cat", "Monkey", "Bear", "Rabbit"]
# 删除"Monkey"
animallist.remove("Monkey")
print(animallist)
>> ['Dog', 'Cat', 'Bear', 'Rabbit']
# 删除"Rabbit"
animallist.remove("Rabbit")
print(animallist)
>> ['Dog', 'Cat', 'Bear']我能够从列表中删除与指定值具有相同值的元素。
从列表中删除所有元素
如何从列表中删除所有元素。使用可用于列表类型的清除方法。
列表.clear()从列表中删除所有元素。
具体写如下。
mylist = ["A", "B", "C", "D", "E"]
mylist.clear()
print(mylist)
--> []我们还可以省略开始和结束索引：
列表 [:] = []示例代码
请看下面的示例。
colorlist = ["Blue", "Red", "Green"]
colorlist.clear()
print(colorlist)
>> []这样我们就能够从列表中删除所有元素。
10-9 检查列表是否包含与指定值相同的元素
这一节主要解释如何获取创建的列表是否包含与指定值相同的元素，如果有，如何获取元素的数量和元素的索引。使用 in 运算符检查是否包含元素，使用 count 方法检查元素数量，使用 index 方法检查索引。
检查是否包含与指定值具有相同值的元素
使用 in 运算符检查列表是否包含具有给定值的元素。
値 in 列表如果列表中的任何元素具有与指定值相同的值，则表达式为 True。否则为假。
具体写如下。
mylist = ["A", "B", "C", "D", "E"]
print("B" in mylist)
>> True
print("G" in mylist)
>> False请注意，如果您使用 not in 运算符而不是 in 运算符，则如果存在与指定值相同的值，它将返回 False，否则返回 True。
获取列表中有多少个元素包含相同的值
如何获取列表中与指定值具有相同值的元素的数量。使用列表类型可用的计数方法。
list.count(值)返回与指定参数具有相同值的元素数。如果找不到则返回 0。
具体写如下。
mylist = ["A", "B", "A", "A", "C"]
print(mylist.count("A"))
>> 3
print(mylist.count("B"))
>> 1
print(mylist.count("D"))
>> 0获取与指定值相同的元素的索引
如何获取列表中与指定值具有相同值的元素的索引。使用列表类型可用的索引方法。
list.index(值)返回找到的与参数中指定的值具有相同值的元素的索引。如果找到多个元素，则返回第一个元素的索引。
具体写如下。
mylist = ["A", "B", "A", "A", "C"]
print(mylist.index("A"))
>> 0
print(mylist.index("B"))
>> 1
print(mylist.index("C"))
>> 4请注意，如果找不到，将发生 ValueError 错误。
mylist = ["A", "B", "A", "A", "C"]
print(mylist.index("D"))
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> ValueError: 'D' is not in list10-10 按升序或降序对列表元素进行排序
这节课，我们主要讲解一下，如何使用元素值对已创建的列表中的元素进行升序或降序排序。要进行排序，请使用 sorted 函数或 sort 方法。它还解释了如何在排序前调用另一个指定的函数，并在排序前转换要比较的值。
对元素进行排序
要对元素进行排序，请使用内置的排序函数。格式如下。
newlist = sorted(iterable, *, key=None, reverse=False)除了第一个参数外，其他参数都可以省略，基本用法如下。
newlist = sorted(iterable)对指定为第一个参数的可迭代对象（字符串、列表、元组、字典等）的元素进行排序，并将其作为新对象返回。排序前的对象保持原样，排序后的结果作为新的列表类型对象返回。
排序是通过使用 < 运算符比较元素值来完成的。正如我稍后会尝试的那样，如果列表的元素与数字和字符串混合，则比较将失败并发生 TypeError 错误。
具体写如下。
mylist = ["C", "A", "B"]
newlist = sorted(mylist)
print(mylist)
--> ["C", "A", "B"]
print(newlist)
--> ["A", "B", "C"]此外，如果目标是列表，则提供排序方法。
List.sort(*, key=None, reverse=False)参数也是可选的。基本用法如下。
List.sort()在排序方面是一样的，但是在sort方法的情况下，元素在保持相同对象的情况下被排序。
具体写如下。
mylist = ["C", "A", "B"]
mylist.sort()
print(mylist)
--> ["A", "B", "C"]如果在排序前需要列表对象，请使用 sorted 函数。在此页面上，我们将尝试排序功能。
示例代码
请看以下两个示例。
numlist = [84, 75, 92, 90, 78]
newnumlist = sorted(numlist)
print("Before:", numlist)
>> Before: [84, 75, 92, 90, 78]
print("After: ", newnumlist)
>> After: [75, 78, 84, 90, 92]colorlist = ["Blue", "Red", "Green", "White", "Black"]
newcolorlist = sorted(colorlist)
print("Before:", colorlist)
>> Before: ['Blue', 'Red', 'Green', 'White', 'Black']
print("After: ", newcolorlist)
>> After: ['Black', 'Blue', 'Green', 'Red', 'White']我们可以使用 sorted 函数对列表元素进行排序。
当元素值的数据类型不同时
列表元素可以有不同的数据类型值，但是在排序的时候，元素值是用>运算符进行比较的，所以允许用>运算符进行比较。这取决于是否
比如即使元素值的数据类型不同，如果是整数和浮点数也可以排序。
numlist = [5, 3.14, 4.78, 4]
newnumlist = sorted(numlist)
print(newnumlist)
>> [3.14, 4, 4.78, 5]但是，如果元素值是数字和字符串的混合，排序会导致TypeError错误。
mylist = ["80", 75, 45, "68"]
newmylist = sorted(mylist)
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> TypeError: '<' not supported between instances of 'int' and 'str'排序时在升序和降序之间切换
默认情况下，sorted 函数和 sort 方法都按升序排序。要按降序排序，请执行以下操作：
newlist = sorted(iterable, reverse=True)以 reverse=True 作为参数运行排序函数。
具体写如下。
mylist = ["C", "A", "B"]
newlist = sorted(mylist, reverse=True)
print(mylist)
--> ["C", "A", "B"]
print(newlist)
--> ["C", "B", "A"]示例代码
请看下面的示例。
colorlist = ["Blue", "Red", "Green", "White", "Black"]
upcolorlist = sorted(colorlist)
downcolorlist = sorted(colorlist, reverse=True)
print("Orig:", colorlist)
>> Orig: ['Blue', 'Red', 'Green', 'White', 'Black']
print("ASC: ", upcolorlist)
>> ASC: ['Black', 'Blue', 'Green', 'Red', 'White']
print("DESC:", downcolorlist)
>> DESC: ['White', 'Red', 'Green', 'Blue', 'Black']这样我们就可以使用 sorted 函数分别按升序和降序对列表元素进行排序。
将元素值传递给另一个函数并使用返回值进行排序
排序时，不是原样使用元素值进行比较，而是将元素值传递给指定的函数，使用返回值进行比较，如下：
newlist = sorted(iterable, key=函数名)对于可以指定的函数，指定一个带一个参数的函数。
比如取绝对值后要排序，指定内置的abs函数。
mylist = [5, -4, -7, 6]
sorted(mylist)
--> [-7, -4, 5, 6]
sorted(mylist, key=abs)
--> [-4, 5, 6, -7]根据每个元素值的绝对值排序。
例如，如果要按字符串长度排序，请使用内置的 len 函数。
mylist = ["apple", "pen", "desk", "banana"]
sorted(mylist)
--> ['apple', 'banana', 'desk', 'pen']
sorted(mylist, key=len)
--> ['pen', 'desk', 'apple', 'banana']获取每个元素值的字符长度并按长度排序。
示例代码
请看下面的示例。
animallist = ["Cat", "monkey", "bear", "Sheep", "cow"]
sortlist = sorted(animallist)
lowersortlist = sorted(animallist, key=str.lower)
print(animallist)
>> ['Cat', 'monkey', 'bear', 'Sheep', 'cow']
print(sortlist)
>> ['Cat', 'Sheep', 'bear', 'cow', 'monkey']
print(lowersortlist)
>> ['bear', 'Cat', 'cow', 'monkey', 'Sheep']这次，我将字符串类型 str.lower() 方法指定为作为参数指定的函数。字符串全部转为小写，进行比较排序。
10-11 从字符串、元组、范围等创建列表
我们将解释如何从其他对象（例如字符串、元组和范围）创建列表。
从可迭代对象创建列表
一些列表类型构造函数通过将可迭代对象指定为参数来创建列表对象。
class list([iterable])可迭代对象是列表、元组、字符串、字典等。
从另一个列表创建一个列表
首先尝试使用另一个列表作为参数创建一个列表对象。
mylist = ["A", "B", "C"]
newlist = list(mylist);
print(newlist)
>> ['A', 'B', 'C']创建了一个与参数中指定的列表具有相同元素的列表。请注意，创建了列表的副本，因此这两个列表是单独的对象。
从字符串创建列表
接下来，让我们通过指定一个字符串作为参数来创建一个列表对象。
mylist = list("Hello Python")
print(mylist)
>> ['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']创建一个新列表，其中一个元素对应指定为参数的字符串中的每个字符。
从元组创建列表
接下来，让我们通过指定一个元组作为参数来创建一个列表对象。
mylist = list(("A", "B", "C"))
print(mylist)
>> ['A', 'B', 'C']通过复制指定为参数的元组的元素来创建新列表。
从一个Range创建一个列表
range类型是一个对象，它具有从构造函数中指定为自变量的起始编号到结束编号的连续编号。
class range(stop)
class range(start, stop[, step])它有从开始到结束的连续数值作为元素。如果省略 start，则 0 是起始编号。
让我们通过将range类型对象指定为参数来创建列表对象。
mylist = list(range(10))
print(mylist)
>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]我能够创建一个列表，其中包含从 0 到 9 的连续数字作为元素。
10-12 创建多维列表并获取元素
可以将一个列表分配给另一个列表作为元素。这种包含列表的列表称为多维列表（或多列表）。在这里，我们将解释如何创建多维列表以及如何获取元素。
创建多维列表
创建多维列表的过程与普通列表没有什么不同。只需将列表指定为元素的值。
[元素1, 元素2, ...]例如，第一个元素为 [“Yuhua”, 25]，第二个元素为 [“Jiangming”, 38]，第三个元素为 [“Lihong”, 28] 的列表将写为 .
[["Yuhua", 25], ["Jiangming", 38], ["Lihong", 28]]包含这样一个列表的列表称为多维列表或多列表。
从多维列表中获取元素
另一个列表被分配给列表的元素，所以如果你指定索引并获取元素，你将获得分配给每个元素的列表。
stafflist = [["Yuhua", 25], ["Jiangming", 38], ["Lihong", 28]]
print(stafflist[0])
--> ["Yuhua", 25]
print(stafflist[1])
--> ["Jiangming", 38]
print(stafflist[2])
--> ["Lihong", 28]]可以通过指定索引获取通过指定索引提取的列表中包含的每个元素。
具体写如下。具体的には次のように記述します。
stafflist = [["Yuhua", 25], ["Jiangming", 38], ["Lihong", 28]]
print(stafflist[0][0])
--> "Yuhua"
print(stafflist[0][1])
--> 25
print(stafflist[1][0])
--> "Jiangming"
print(stafflist[1][1])
--> 38
print(stafflist[2][0])
--> "Lihong"
print(stafflist[2][1])
--> 28列表可以像数组一样使用。多维列表可以像多维数组一样使用。
示例代码
请看下面的示例。
stafflist = [["Yuhua", 25], ["Jiangming", 38], ["Lihong", 28]]
for p in [0, 1, 2]:
for m in [0, 1]:
print("[" + str(p) + "][" + str(m) + "] = ", end='')
print(stafflist[p][m])
>> [0][0] = Yuhua
>> [0][1] = 25
>> [1][0] = Jiangming
>> [1][1] = 38
>> [2][0] = Lihong"
>> [2][1] = 28我们能够使用 for 语句从多维列表中按顺序检索和打印元素。
10-13 使用列表内涵标记创建列表
我将解释如何使用列表内涵标记，这是创建列表的方法之一。可以简洁地使用理解来编写程序。
使用列表内涵标记
内涵标记使用以下格式：
[表达式 for 变量 in 可迭代对象]该格式使得 for 语句嵌入在列表中。
例如，作为一个具体的用法，考虑创建一个列表，其元素是从1到5的连续值。有直接指定元素、创建一个空列表然后使用for语句添加元素、通过在列表构造函数中指定范围对象来创建列表等方法。
mylist = [1, 2, 3, 4, 5]max = 5
mylist = []
for i in range(1, max + 1):
mylist.append(i)max = 5
mylist = list(range(1, max + 1))使用内涵标记，我们可以写：
max = 5
mylist = [i for i in range(1, max + 1)]如果列表中包含的元素可以在程序中直接写，可以直接写，但是如果需要在程序中创建一个从1到max连续元素的列表，就需要使用另外一种方法了。据说使用列表理解的方法不仅使程序简洁，而且比其他方法运行速度更快。
列表理解从可迭代对象（例如范围对象）中提取元素并将它们分配给变量。然后添加使用该变量作为列表元素的表达式的值。表达式可以描述对变量值的操作等。
mylist = [i for i in range(1, 6)]
print(mylist)
>> [1, 2, 3, 4, 5]
mylist = [i * 10 for i in range(1, 6)]
print(mylist)
>> [10, 20, 30, 40, 50]在第一个列表中，可迭代对象的元素按原样成为列表的元素。在第二个列表中，我们从可迭代对象中取出元素并将它们乘以 10。这与编写相同：
mylist = []
for i in range(1, 6):
mylist.append(i * 10)
print(mylist)
>> [10, 20, 30, 40, 50]列表推导式是一种独特的写法，不习惯的话很难用，记住。
内涵标记与条件表达式
列表内涵标记允许您添加条件表达式，并且仅当条件表达式为真时才将其作为元素添加到列表中。格式如下。
[表达式 for 变量 in 可迭代对象 if 条件表达式]从可迭代对象中提取元素并将它们分配给变量后，如果条件表达式为真，则将表达式的值添加为列表的元素。
在下面的示例中，只有当从可迭代对象中提取的元素的值是 3 的倍数时，才会将元素添加到列表中。
mylist = [i for i in range(1, 20) if i % 3 == 0]
print(mylist)
>> [3, 6, 9, 12, 15, 18]这与下面的内容相同：
mylist = []
for i in range(1, 20):
if i % 3 == 0:
mylist.append(i)
print(mylist)
>> [3, 6, 9, 12, 15, 18]10-14 使用多个循环创建列表的内涵标记
我们将解释如何使用列表推导来创建使用双重和三重多重循环的列表，以及如何使用列表推导来创建类似于二维数组的列表。
如何使用列表内涵标记编写多个循环
列表内涵标记使用以下格式：
mylist = [i for i in range(1, 6)]
print(mylist)
>> [1, 2, 3, 4, 5]这与使用 for 语句的写法相同：
mylist = []
for i in range(1, 6):
mylist.append(i)
print(mylist)
>> [1, 2, 3, 4, 5]上面创建了一个带有单个循环的列表。现在假设你想使用这样的双循环创建一个列表：
mylist = []
for i in range(1, 4):
for j in range(1, 3):
mylist.append(i * 10 + j)
print(mylist)
>> [11, 12, 21, 22, 31, 32]如果您使用列表内涵标记来创建一个使用这样的双循环的列表，请按如下方式编写。
mylist = [i * 10 + j for i in range(1, 4) for j in range(1, 3)]
print(mylist)
>> [11, 12, 21, 22, 31, 32]在第一个 for 语句从可迭代对象中提取一个元素后，下一个 for 语句依次从可迭代对象中提取元素，将 i * 10 + j 指定为表达式赋值，并将元素添加为 . 在第二个 for 语句中从可迭代对象中检索所有元素后，返回到第一个 for 语句并检索下一个元素。然后下一个 for 语句按顺序从可迭代对象中检索元素。
类似地，可以使用列表推导式类似地编写具有三元组或更多元组的循环
mylist = [i * 100 + j * 10 + k for i in range(1, 4) \
for j in range(1, 3) for k in range(1, 3)]
print(mylist)
>> [111, 112, 121, 122, 211, 212, 221, 222, 311, 312, 321, 322]※ 列表理解部分很长，所以添加了换行符。
如何使用列表内涵标记编写二维数组
您还可以使用列表推导式来创建类似于二维数组的列表。例如，假设您想创建一个二维数组列表，如下所示：
mylist = []
for i in range(1, 4):
sublist = []
for j in range(1,3):
sublist.append(i * 10 + j)
mylist.append(sublist)
print(mylist)
>> [[11, 12], [21, 22], [31, 32]]要使用列表推导式创建类似于此二维数组的列表，请按如下方式编写。
mylist = [[i * 10 + j for j in range(1, 3)] for i in range(1, 4)]
print(mylist)
>> [[11, 12], [21, 22], [31, 32]]在这种情况下，使用内部列表内涵标记创建的列表对象将作为元素添加到外部列表理解中。
