在本文中，我们展示了如何使用Python列表集合。
Python列表定义
列表是有序的值集合。它可以包含各种类型的值。列表是一个可变的容器。这意味着我们可以添加值、删除值或修改现有值。
Python列表表示有限序列的数学概念。列表的值称为列表的项目或元素。一个列表可以多次包含相同的值。每次出现都被视为一个不同的项目。
Python简单列表
可以通过索引访问列表元素。第一个元素的索引为0，最后一个元素的索引为-1。
#!/usr/bin/python # simple.py nums = [1, 2, 3, 4, 5] print(nums[0]) print(nums[-1]) print(nums)
这是一个包含五个元素的简单列表。该列表由方括号[]分隔。列表的元素由逗号分隔。列表的内容打印到控制台。
nums = [1, 2, 3, 4, 5]
赋值的右侧是Python列表文字。它创建一个包含五个元素的列表。
$ ./simple.py 1 5 [1, 2, 3, 4, 5]
列表可以包含各种数据类型的元素。
#!/usr/bin/python
# various_types.py
class Being:
pass
objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)
在示例中，我们创建了一个对象列表。它包含数字、一个布尔值、另一个列表、一个字符串、一个元组、一个自定义对象和一个字典。
$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
<__main__.Being instance at 0x7f653577f6c8>, {}]
Python列表初始化
有时我们需要提前初始化一个列表以拥有特定数量的元素。
#!/usr/bin/python n1 = [0 for i in range(15)] n2 = [0] * 15 print(n1) print(n2) n1[0:10] = [10] * 10 print(n1)
在此示例中，我们使用列表理解和*运算符初始化两个列表。
n1 = [0 for i in range(15)] n2 = [0] * 15
这两个列表被初始化为十五个零。
n1[0:10] = [10] * 10
前十个值替换为10s。
$ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]
Python列表函数
list函数从可迭代对象创建一个列表。Aniterable可以是一个序列，一个支持迭代的容器，或者一个迭代器对象。如果没有指定参数，则创建一个新的空列表。
#!/usr/bin/python
# list_fun.py
a = []
b = list()
print(a == b)
print(list((1, 2, 3)))
print(list("ZetCode"))
print(list(['Ruby', 'Python', 'Perl']))
在示例中，我们创建了一个空列表、一个元组列表、一个字符串和另一个列表。
a = [] b = list()
这是创建空列表的两种方法。
print(a == b)
该行打印True。这证实了a和b是相等的。
print(list((1, 2, 3)))
我们从Python元组创建一个列表。
print(list("ZetCode"))
这一行从一个字符串生成一个列表。
print(list(['Ruby', 'Python', 'Perl']))
最后，我们创建一个字符串列表的副本。
$ ./list_fun.py True [1, 2, 3] ['Z', 'e', 't', 'C', 'o', 'd', 'e'] ['Ruby', 'Python', 'Perl']
Python列表操作
下面的代码展示了一些基本的列表操作。
#!/usr/bin/python # list_oper.py n1 = [1, 2, 3, 4, 5] n2 = [3, 4, 5, 6, 7] print(n1 == n2) print(n1 + n2) print(n1 * 3) print(2 in n1) print(2 in n2)
我们定义了两个整数列表。我们在这些列表中使用了一些运算符。
print(n1 == n2)
列表的内容与==运算符进行比较。由于元素不同，该行打印False。
print(n1 + n2)
添加n1和n2列表以形成一个新列表。新列表包含两个列表的所有元素。
print(n1 * 3)
我们使用列表上的乘法运算符。它重复元素n次；在我们的案例中是三次。
print(2 in n1)
我们使用in运算符来查明该值是否存在于列表中。它返回一个布尔值True或False。
$ ./lists.py False [1, 2, 3, 4, 5, 3, 4, 5, 6, 7] [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5] True False
Python序列函数
序列函数可用于任何序列类型，包括列表。
#!/usr/bin/python
# sequence_funs.py
n = [1, 2, 3, 4, 5, 6, 7, 8]
print("There are {0} items".format(len(n)))
print("Maximum is {0}".format(max(n)))
print("Minimum is {0}".format(min(n)))
print("The sum of values is {0}".format(sum(n)))
在上面的示例中，我们有四个函数：len、max、min和sum。
print("There are {0} items".format(len(n)))
len函数返回列表的大小。列表的元素数。
print("Maximum is {0}".format(max(n)))
print("Minimum is {0}".format(min(n)))
max和min函数返回列表的最大值和最小值。
print("The sum of values is {0}".format(sum(n)))
sum函数计算n列表中数字的总和。
$ ./sequence_funs.py There are 8 items Maximum is 8 Minimum is 1 The sum of values is 36
Python添加列表元素
本节将展示如何将元素添加到Python列表中。
#!/usr/bin/python
# adding.py
langs = []
langs.append("Python")
langs.append("Perl")
print(langs)
langs.insert(0, "PHP")
langs.insert(2, "Lua")
print(langs)
langs.extend(("JavaScript", "ActionScript"))
print(langs)
我们可以通过三种方法向列表中添加新元素：append、insert和extend。
langs = []
创建了一个空列表。
langs.append("Python")
langs.append("Perl")
append方法在列表末尾添加一个项目；我们追加两个字符串。
langs.insert(0, "PHP") langs.insert(2, "Lua")
insert方法将元素放置在由索引号指示的特定位置。"PHP"字符串插入第一个位置，"Lua"字符串插入第三个位置。请注意，列表索引号从零开始。
langs.extend(("JavaScript", "ActionScript"))
extend方法将一系列值添加到列表的末尾。在我们的例子中，Python元组的两个字符串附加在列表的末尾。
$ ./adding.py ['Python', 'Perl'] ['PHP', 'Python', 'Lua', 'Perl'] ['PHP', 'Python', 'Lua', 'Perl', 'JavaScript', 'ActionScript']
Python列表索引错误
当列表下标超出范围时引发IndexError。
#!/usr/bin/python
# index_error.py
n = [1, 2, 3, 4, 5]
try:
n[0] = 10
n[6] = 60
except IndexError as e:
print(e)
在脚本中我们定义了一个包含五个整数的列表。这些元素的索引为0、1、2、3和4。使用更大的索引会导致错误。
n[6] = 60
索引6超出了我们列表的范围。抛出一个IndexError。
except IndexError as e:
print(e)
我们使用except子句捕获错误。在子句的主体中，我们打印错误消息。
$ ./index_error.py list assignment index out of range
Python列表类型错误
如果元组的索引不是普通整数，则会抛出TypeError。
#!/usr/bin/python
# type_error.py
n = [1, 2, 3, 4, 5]
try:
print(n[1])
print(n['2'])
except TypeError as e:
print("Error in file {0}".format( __file__))
print("Message: {0}".format(e))
这个例子抛出一个TypeError。
print(n['2'])
列表索引必须是整数。其他类型以错误结束。
except TypeError as e:
print("Error in file {0}".format( __file__))
print("Message: {0}".format(e))
在except块中，我们打印发生异常的文件名和消息字符串。
$ ./typeerror.py 2 Error in file ./typeerror.py Message: list indices must be integers, not str
Python列表删除元素
之前我们已经将项目添加到列表中。现在我们将它们从列表中删除。
#!/usr/bin/python
# removing.py
langs = ["Python", "Ruby", "Perl", "Lua", "JavaScript"]
print(langs)
lang = langs.pop(3)
print("{0} was removed".format(lang))
lang = langs.pop()
print("{0} was removed".format(lang))
print(langs)
langs.remove("Ruby")
print(langs)
pop方法删除并返回具有指定索引的元素，如果没有给出索引号，则返回最后一个元素。remove方法从列表中删除特定项目。
lang = langs.pop(3)
print("{0} was removed".format(lang))
我们移除索引为3的元素。pop方法返回移除元素的名称；它被打印到控制台。
lang = langs.pop()
print("{0} was removed".format(lang))
列表中的最后一个元素，即"JavaScript"字符串，已从列表中删除。
langs.remove("Ruby")
此行从langs列表中删除一个"Ruby"字符串。
['Python', 'Ruby', 'Perl', 'Lua', 'JavaScript'] Lua was removed JavaScript was removed ['Python', 'Ruby', 'Perl'] ['Python', 'Perl']
从脚本的输出我们可以看到所描述方法的效果。
del关键字也可用于删除列表元素。
#!/usr/bin/python # removing2.py langs = ["Python", "Ruby", "Perl", "Lua", "JavaScript"] print(langs) del langs[1] print(langs) #del langs[15] del langs[:] print(langs)
我们有一个字符串列表。我们使用del关键字来删除列表元素。
del langs[1]
我们从列表中删除第二个字符串。它是"Ruby"字符串。
#del langs[15]
我们只能删除现有元素。如果我们取消注释代码行，我们会收到一条IndexError消息。
del langs[:]
这里我们从列表中删除所有剩余的元素。[:]字符指的是列表中的所有项目。
$ ./removing2.py ['Python', 'Ruby', 'Perl', 'Lua', 'JavaScript'] ['Python', 'Perl', 'Lua', 'JavaScript'] []
Python修改列表元素
在下一个示例中，我们将修改列表元素。
#!/usr/bin/python # modifying.py langs = ["Python", "Ruby", "Perl"] langs.pop(2) langs.insert(2, "PHP") print(langs) langs[2] = "Perl" print(langs)
在示例中，我们将langs列表的第三个元素修改了两次。
langs.pop(2) langs.insert(2, "PHP")
修改元素的一种方法是删除它并在同一位置放置不同的元素。
langs[2] = "Perl"
另一种方法更直接。我们在给定位置分配一个新元素。现在第三个位置又出现了"Perl"字符串。
$ ./modifying.py ['Python', 'Ruby', 'PHP'] ['Python', 'Ruby', 'Perl']
Python复制列表
我们可以通过多种方式在Python中复制列表。我们将提及其中的一些。
#!/usr/bin/python
# copying.py
import copy
w = ["Python", "Ruby", "Perl"]
c1 = w[:]
c2 = list(w)
c3 = copy.copy(w)
c4 = copy.deepcopy(w)
c5 = [e for e in w]
c6 = []
for e in w:
c6.append(e)
c7 = []
c7.extend(w)
print(c1, c2, c3, c4, c5, c6, c7)
我们有一个包含三个字符串的列表。我们将列表复制七次。
import copy
我们导入了copy模块，它有两种复制方法。
c1 = w[:]
使用切片语法复制列表。
c2 = list(w)
list函数在将列表作为参数时创建列表的副本。
c3 = copy.copy(w) c4 = copy.deepcopy(w)
copy方法生成列表的浅表副本。deepcopy生成列表的深层副本。
c5 = [e for e in w]
字符串的副本是使用列表理解创建的。
c6 = []
for e in w:
c6.append(e)
由for循环创建的副本。
c7 = [] c7.extend(w)
extend方法也可用于创建副本。
$ ./copying.py ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl']
使用不同的技术创建了字符串列表的七个副本。
Python索引列表元素
Python列表中的元素可以通过它们的索引来访问。索引号为整数；他们从零开始。索引可以是负数；负索引引用列表末尾的元素。列表中的第一项索引为0，最后一项索引为-1。
#!/usr/bin/python # indexing.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[0]) print(n[-1]) print(n[-2]) print(n[3]) print(n[5])
我们可以通过索引访问列表中的元素。索引位于列表名称后方括号[]之间。
print(n[0]) print(n[-1]) print(n[-2])
这三行打印了列表的第一项、最后一项和最后一项。
print(n[3]) print(n[5])
这两行打印列表的第四和第六个元素。
$ ./indexing.py 1 8 7 4 6
index(e,start,end)方法查找特定元素并返回其最低索引。开始和结束是可选参数，用于将搜索限制在给定边界内。
#!/usr/bin/python # indexing2.py n = [1, 2, 3, 4, 1, 2, 3, 1, 2] print(n.index(1)) print(n.index(2)) print(n.index(1, 1)) print(n.index(2, 2)) print(n.index(1, 2, 5)) print(n.index(3, 4, 8))
index方法的代码示例。
print(n.index(1)) print(n.index(2))
这两行打印n列表最左边的1、2个值的索引。
print(n.index(1, 1)) print(n.index(2, 2))
这里我们在指定的索引之后搜索值1和2。
print(n.index(1, 2, 5))
这里我们在索引为2和5的值之间搜索值1。
$ ./indexing2.py 0 1 4 5 4 6
Python切片列表
列表切片是一种从列表中提取某些元素并将它们组成另一个列表的操作。可能具有不同数量的索引和不同的索引范围。
列表切片的语法如下：
[start:end:step]
语法的开始、结束、步骤部分是整数。它们中的每一个都是可选的。它们可以是正的也可以是负的。具有结束索引的值不包含在切片中。
#!/usr/bin/python # slice.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[1:5]) print(n[:5]) print(n[1:]) print(n[:])
我们从八个整数的列表中创建四个切片。
print(n[1:5])
第一个切片的值的索引为1、2、3和4。新形成的列表是[2、3、4、5]。
print(n[:5])
如果省略起始索引，则采用默认值，即0。切片为[1,2,3,4,5]。
print(n[1:])
如果省略结束索引，则采用-1默认值。在这种情况下，aslice会将所有值带到列表的末尾。
print(n[:])
甚至两个索引都可以省略。此语法创建列表的副本。
$ ./slice.py [2, 3, 4, 5] [1, 2, 3, 4, 5] [2, 3, 4, 5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8]
切片语法中的第三个索引是步骤。它允许我们从列表中获取每一个值。
#!/usr/bin/python # slice2.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[1:9:2]) print(n[::2]) print(n[::1]) print(n[1::3])
我们使用步长值形成四个新列表。
print(n[1:9:2])
这里我们创建一个切片，每隔一个元素来自n列表，从第二个元素开始，到第八个元素结束。新列表包含以下元素：[2,4,6,8]。
print(n[::2])
在这里，我们通过从列表的开头到结尾每隔一个值来构建一个切片。
print(n[::1])
这会创建一个列表的副本。
print(n[1::3])
从第二个元素到列表末尾，切片每三个元素都有一个。
$ ./slice2.py [2, 4, 6, 8] [1, 3, 5, 7] [1, 2, 3, 4, 5, 6, 7, 8] [2, 5, 8]
索引可以是负数。负索引指的是列表末尾的值。最后一个元素的索引为-1，最后一个元素的索引为-2等。负数较小的索引必须在语法中排在第一位。这意味着我们写[-6,-2]而不是[-2,-6]。后者返回一个空列表。
#!/usr/bin/python # slice3.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[-4:-1]) print(n[-1:-4]) print(n[-5:]) print(n[-6:-2:2]) print(n[::-1])
在这个脚本中，我们形成了五个列表。我们还使用负索引号。
print(n[-4:-1]) print(n[-1:-4])
第一行返回[5,6,7]，第二行返回一个空列表。较低的索引必须在较高的索引之前。
print(n[::-1])
这会创建一个反向列表。
$ ./slice3.py [5, 6, 7] [] [4, 5, 6, 7, 8] [3, 5] [8, 7, 6, 5, 4, 3, 2, 1]
上述语法可用于赋值。赋值的右边必须有一个可迭代的。
#!/usr/bin/python # slice4.py n = [1, 2, 3, 4, 5, 6, 7, 8] n[0] = 10 n[1:3] = 20, 30 n[3::1] = 40, 50, 60, 70, 80 print(n)
我们有一个包含八个整数的列表。我们使用切片语法用新值替换元素。
Python循环列表
本节将指出在Python中遍历列表的三种基本方法。
#!/usr/bin/python
# traverse.py
n = [1, 2, 3, 4, 5]
for e in n:
print(e, end=" ")
print()
第一种是遍历列表最直接的方法。
n = [1, 2, 3, 4, 5]
我们有一个数字列表。列表中有五个整数。
for e in n:
print(e, end=" ")
使用for循环，我们逐一遍历列表并将当前元素打印到控制台。
$ ./traverse.py 1 2 3 4 5
这是脚本的输出。整数被打印到终端。
第二个例子有点冗长。
#!/usr/bin/python
# traverse2.py
n = [1, 2, 3, 4, 5]
i = 0
s = len(n)
while i < s:
print(n[i], end=" ")
i = i + 1
print()
我们正在使用while循环遍历列表。
i = 0 l = len(n)
首先，我们需要定义一个计数器并找出列表的大小。
while i < s:
print(n[i], end=" ")
i = i + 1
在这两个数字的帮助下，我们遍历列表并将每个元素打印到终端。
enumerate内置函数在循环中为我们提供列表的索引和值。
#!/usr/bin/python
# traverse3.py
n = [1, 2, 3, 4, 5]
print(list(enumerate(n)))
for e, i in enumerate(n):
print("n[{0}] = {1}".format(e, i))
在示例中，我们打印值和值的索引。
$ ./traverse3.py [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)] n[0] = 1 n[1] = 2 n[2] = 3 n[3] = 4 n[4] = 5
Python计数列表元素
有时统计列表元素很重要。为此，Python有count方法。
#!/usr/bin/python # counting.py n = [1, 1, 2, 3, 4, 4, 4, 5] print(n.count(4)) print(n.count(1)) print(n.count(2)) print(n.count(6))
在这个例子中，我们统计了n列表中一些数字出现的次数。
n = [1, 1, 2, 3, 4, 4, 4, 5]
我们有一个整数列表。整数1和4出现多次。
print(n.count(4)) print(n.count(1)) print(n.count(2)) print(n.count(6))
使用count方法，我们找出数字4、1、2和6的出现情况。
$ ./counting.py 3 2 1 0
4出现了3次，1出现了两次，2出现了一次，6没有出现在列表中。
Python嵌套列表
可以将列表嵌套到另一个列表中。使用嵌套列表会创建一个新维度。要访问嵌套列表，需要额外的方括号[]。
#!/usr/bin/python # nested.py nums = [[1, 2], [3, 4], [5, 6]] print(nums[0]) print(nums[1]) print(nums[2]) print(nums[0][0]) print(nums[0][1]) print(nums[1][0]) print(nums[2][1]) print(len(nums))
在示例中，我们有三个嵌套列表，每个列表都有两个元素。
print(nums[0]) print(nums[1]) print(nums[2])
nums列表的三个嵌套列表被打印到控制台。
print(nums[0][0]) print(nums[0][1])
这里我们打印第一个嵌套列表的两个元素。nums[0]指的是第一个嵌套列表；nums[0][0]指的是第一个嵌套列表的第一个元素，即1。
print(len(nums))
该行打印3。每个嵌套列表都算作一个元素。不考虑其内部元素。
$ ./nested.py [1, 2] [3, 4] [5, 6] 1 2 3 6 3
第二个例子有额外的维度。
#!/usr/bin/python # nested2.py nums = [[1, 2, [3, 4, [5, 6]]]] print(nums[0]) print(nums[0][2]) print(nums[0][2][2]) print(nums[0][0]) print(nums[0][2][1]) print(nums[0][2][2][0])
在示例中，[5,6]列表嵌套到[3,4,…]列表中，[3,4,[4,6]]嵌套到[1,2,…]列表，它最终是nums列表的一个元素。
print(nums[0]) print(nums[0][2]) print(nums[0][2][2])
这三行将嵌套列表打印到控制台。
print(nums[0][0]) print(nums[0][2][1]) print(nums[0][2][2][0])
这里访问了三个元素。引用内部列表时需要额外的方括号[]。
$ ./nested2.py [1, 2, [3, 4, [5, 6]]] [3, 4, [5, 6]] [5, 6] 1 4 5
Python排序列表
在本节中，我们对列表元素进行排序。Python有一个内置的列表方法sort和sorted函数来进行排序。
#!/usr/bin/python # sorting.py n = [3, 4, 7, 1, 2, 8, 9, 5, 6] print(n) n.sort() print(n) n.sort(reverse=True) print(n)
在代码示例中，我们有一个未排序的整数列表。我们使用sort方法对元素进行排序。该方法就地对元素进行排序；原列表已修改。
n.sort()
sort方法按升序对元素进行排序。
n.sort(reverse=True)
将reverse参数设置为True，列表按降序排列。
$ ./sorting.py [3, 4, 7, 1, 2, 8, 9, 5, 6] [1, 2, 3, 4, 5, 6, 7, 8, 9] [9, 8, 7, 6, 5, 4, 3, 2, 1]
在输出中我们可以看到原始列表，按升序和降序排序的列表。
如果我们不想改变原来的列表，我们可以使用sorted函数。此函数创建一个新的排序列表。
#!/usr/bin/python # sorting2.py n = [3, 4, 1, 7, 2, 5, 8, 6] print(n) print(sorted(n)) print(n)
在示例中，我们使用sorted函数对列表的元素进行排序。
$ ./sorting2.py [3, 4, 1, 7, 2, 5, 8, 6] [1, 2, 3, 4, 5, 6, 7, 8] [3, 4, 1, 7, 2, 5, 8, 6]
从脚本的输出我们可以看到原始列表没有被修改。
sort方法有一个可选的key参数。该参数指定在进行比较之前要在每个列表元素上调用的函数。
#!/usr/bin/python
# sorting3.py
words = ["big", "Blue", "seven", "glass",
"Green", "after", "Anctartica"]
words.sort()
print(words)
words.sort(key=str.lower)
print(words)
该示例生成区分大小写和不区分大小写的字符串比较。
words.sort(key=str.lower)
要创建不区分大小写的比较，我们将str.lower函数添加到key参数。
$ ./sorting3.py ['Anctartica', 'Blue', 'Green', 'after', 'big', 'glass', 'seven'] ['after', 'Anctartica', 'big', 'Blue', 'glass', 'Green', 'seven']
如果我们想对Unicode字符串进行排序，我们需要做额外的工作。
#!/usr/bin/python
import locale
from functools import cmp_to_key
w = [u'zem', u'Å¡tebot', u'rum', u'železo', u'prameÅ', u"sob"]
locale.setlocale(locale.LC_COLLATE, ('sk_SK', 'UTF8'))
w.sort(key=cmp_to_key(locale.strcoll))
for e in w:
print(e)
我们有一个包含六个unicode字符串的列表。我们更改区域设置以根据当前语言选项对字符串进行排序。
import locale from functools import cmp_to_key
我们导入locale模块和cmp_to_key转换函数。
w = [u'zem', u'Å¡tebot', u'rum', u'železo', u'prameÅ', u"sob"]
这是一个包含六个字符串的列表。这些字符串使用斯洛伐克语并带有一些变音符号。它们在正确排序字符方面发挥作用。
locale.setlocale(locale.LC_COLLATE, ('sk_SK', 'UTF8'))
我们为斯洛伐克语设置了区域设置。
w.sort(key=cmp_to_key(locale.strcoll))
我们对列表进行排序。locale.strcoll根据当前的LC_COLLATE设置比较两个字符串。cmp_to_key函数将旧式比较函数转换为键函数。
for e in w:
print(e)
我们将排序后的单词打印到控制台。
$ ./sorting_locale.py prameŠrum sob štebot zem železo
元素已正确排序。斯洛伐克字母表的细节被考虑在内。
Python反向列表元素
我们可以在Python中通过几种方式反转列表中的元素。反转元素不应与反向排序相混淆。
#!/usr/bin/python
# reversing.py
a1 = ["bear", "lion", "tiger", "eagle"]
a2 = ["bear", "lion", "tiger", "eagle"]
a3 = ["bear", "lion", "tiger", "eagle"]
a1.reverse()
print(a1)
it = reversed(a2)
r = list()
for e in it:
r.append(e)
print(r)
print(a3[::-1])
在示例中，我们有三个相同的字符串列表。我们以三种不同的方式反转元素。
a1.reverse()
第一种方式是使用reverse方法。
it = reversed(a2)
r = list()
for e in it:
r.append(e)
reversed函数返回一个反向迭代器。我们在for循环中使用迭代器并创建一个新的反向列表。
print(a3[::-1])
第三种方式是使用切片语法反转列表，其中step参数设置为-1。
$ ./reversing.py ['eagle', 'tiger', 'lion', 'bear'] ['eagle', 'tiger', 'lion', 'bear'] ['eagle', 'tiger', 'lion', 'bear']
三个列表都颠倒了OK。
Python列表理解
列表理解是一种句法构造，它基于现有列表创建列表。语法受到数学符号偏移的影响。Python语法的灵感来自Haskell编程语言。
L = [expression for variable in sequence [if condition]]
上面的伪代码显示了列表理解的语法。listcomprehension创建一个新列表。它基于现有列表。for循环遍历序列。对于每个循环，如果满足条件，就会对表达式求值。如果计算了该值，它将附加到新列表中。条件是可选的。
列表理解提供了一种更简洁的方法来在可以使用map和filter和/或嵌套循环的情况下创建列表。
#!/usr/bin/python # list_comprehension.py a = [1, 2, 3, 4, 5, 6, 7, 8, 9] b = [e for e in a if e % 2] print(b)
在示例中，我们定义了一个数字列表。在列表推导的帮助下，我们创建了一个新的列表，其中包含不能被2除而没有余数的数字。
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
b = [e for e in a if e % 2]
这里我们有列表理解。在foreina循环中，获取列表的每个元素。然后测试ife%2条件。如果满足条件，则计算表达式。在我们的例子中，表达式是一个纯e，它按原样获取元素。最后，该元素被附加到列表中。
$ ./list_comprehension.py [1, 3, 5, 7, 9]
列表中的数字不能除以2，没有余数。
在第二个示例中，我们将列表理解与传统的for循环进行比较。
#!/usr/bin/python
# list_comprehension2.py
lang = "Python"
a = []
for e in lang:
a.append(ord(e))
b = [ord(e) for e in lang]
print(a)
print(b)
在示例中我们有一个字符串。我们要创建字符串字母的ASCII整数代码列表。
a = []
for e in lang:
a.append(ord(e))
我们使用for循环创建这样一个列表。
b = [ord(e) for e in lang]
这里同样是使用列表理解产生的。请注意，省略了if条件。这是可选的。
$ ./list_comprehension2.py [80, 121, 116, 104, 111, 110] [80, 121, 116, 104, 111, 110]
检查Python列表理解以获取更多详细信息。
Python映射和过滤函数
map和filter函数是作用于所有列表项的大量函数。它们是Python语言中内置的函数式编程的一部分。
今天，建议尽可能使用列表理解而不是这些函数。
#!/usr/bin/python
# map_fun.py
def to_upper(s):
return s.upper()
words = ["stone", "cloud", "dream", "sky"]
words2 = list(map(to_upper, words))
print(words2)
map函数将特定函数应用于列表的每个元素。
def to_upper(s):
return s.upper()
这是将应用于每个列表元素的函数的定义。它在给定字符串上调用upper字符串方法。
words = ["stone", "cloud", "dream", "sky"]
words2 = map(to_upper, words) print(words2)
map函数将to_upper函数应用于单词列表的每个字符串元素。形成一个新列表并返回。我们将其打印到控制台。
$ ./map_fun.py ['STONE', 'CLOUD', 'DREAM', 'SKY']
列表中的每一项都是大写字母。
filter函数根据列表中函数返回true的那些元素构造一个列表。
#!/usr/bin/python
# filter_fun.py
def positive(x):
return x > 0
n = [-2, 0, 1, 2, -3, 4, 4, -1]
print(list(filter(positive, n)))
一个演示filter函数的例子。它将创建一个只有正值的新列表。它将过滤掉所有负值和0。
def positive(x):
return x > 0
这是filter函数使用的函数定义。它返回True或False。返回布尔值的函数称为谓词。
$ ./filter_fun.py [1, 2, 4, 4]
在本文中，我们介绍了Python列表集合。
列出所有Python教程。
