Python 列表

Python 列表

本文展示了如何使用 Python 列表集合。

Python 列表定义

列表是一组有序的值。它可以包含各种 价值类型。列表是一个可变的容器。这意味着我们可以添加 值、删除值或修改现有值。

Python 列表代表有限序列的数学概念。a的值 列表被称为项目或列表元素。列表可以包含相同的值 多次。每次出现都被视为独立的项目。

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

前十个数值被10分替换。

$ ./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

#!/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``ab

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)

将 和 列表相加形成 新名单。新列表包含了这两个列表的所有元素。n1n2

print(n1 * 3)

我们用列表上的乘法算子。它重复了这些元素 n次;我们这边是三次。

print(2 in n1)

我们使用算符来判断该值是否存在 在名单上。它返回一个布尔值或 。in``TrueFalse

$ ./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)))

在上述例子中，我们有四个函数：、、 和 。

print("There are {0} items".format(len(n)))

该函数返回列表大小。的数量 清单中的元素。len

print("Maximum is {0}".format(max(n)))
print("Minimum is {0}".format(min(n)))

和函数返回最大值以及列表的最小值。

print("The sum of values is {0}".format(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``insertextend

langs = []

创建一个空列表。

langs.append("Python")
langs.append("Perl")

该方法在列表末尾添加一个项; 我们会加上两串弦。

langs.insert(0, "PHP")
langs.insert(2, "Lua")

该方法将元素放置在特定位置 以索引编号表示。字符串插入于 第一位置，第三位置的弦。注意 列表索引编号从零开始。insert``"PHP""Lua"

langs.extend(("JavaScript", "ActionScript"))

该方法在列表末尾添加一串数值。 在我们的例子中，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超出我们名单的范围。An被抛出IndexError错误。

except IndexError as e:

    print(e)

我们通过从句来发现错误。在 我们打印错误信息。

$ ./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)

该方法移除并返回具有指定元素的元素 索引或最后一个元素（如果未给出索引号）。该方法从列表中移除特定项目。

lang = langs.pop(3)
print("{0} was removed".format(lang))

我们去掉索引为3的元素。该方法返回 被移除元素的名称;它印在控制台上。

lang = langs.pop()
print("{0} was removed".format(lang))

列表中的最后一个元素，即字符串，是 已从列表中移除。"JavaScript"

langs.remove("Ruby")

这行会从列表中移除字符串。"Ruby"langs

['Python', 'Ruby', 'Perl', 'Lua', 'JavaScript']
Lua was removed
JavaScript was removed
['Python', 'Ruby', 'Perl']
['Python', 'Perl']

从脚本的表面可以看到上述方法的效果。

关键词也可以用来删除列表元素。

#!/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 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)

该方法生成的列表是个浅表副本。他们会生成一份深度列表副本。copydeepcopy

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])

这两行分别打印列表中的第四和第六个元素。

该方法寻找特定元素 和 返回其最低指数。起始和结束是限制 搜索到给定的边界。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))

这两行打印最左边的1,2的索引值 N名单。

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 切片列表

列表切片是一种从列表和 把它们整理成另一个列表。可能有不同的索引数量和 不同的指数范围。

列表切片的语法如下：

语法的起始、结束、步数部分是整数。每一个都是可选的。 它们既可以是积极的，也可以是消极的。具有端索引的值不是 包含在切片中。

#!/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 的默认值。在这种情况下，a 切片将所有值带到列表的末尾。

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]

切片语法中的第三个索引是步骤。它让我们能够获得所有 列表中的第n个值。

#!/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))

利用该方法，我们发现4、1、2和6的数字的出现情况。count

$ ./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])

三个嵌套的数字列表会打印到控制台上。

print(nums[0][0])
print(nums[0][1])

这里我们打印第一个嵌套列表的两个元素。该表示第一个嵌套列表;表示第一个嵌套列表的第一个元素，即1。nums[0]``nums[0][0]

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 内置了列表方法和排序函数。sortsorted
sorting.py

#!/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)

当反向参数设置为 时，列表被排序为 按降序排列。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
sorting2.py

#!/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]

从脚本输出中可以看到，原文 列表未被修改。

该方法有一个可选参数。该 参数指定在创建前调用每个列表元素的函数 比较。sortkey

#!/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_keyold-style

for e in w:
    print(e)

我们把排序好的单词打印到控制台上。

$ ./sorting_locale.py
prameň
rum
sob
štebot
zem
železo

元素被正确排序。斯洛伐克字母的具体细节被考虑在内。

Python 反向列表元素

我们可以用 Python 反转列表中的元素。反转元件 不应与反向排序混淆。
reversing.py

#!/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)

该函数返回一个反迭代器。我们使用 在for循环中迭代子，并创建一个新的反向列表。reversed

print(a3[::-1])

第三种方法是使用切片语法反转列表，其中步骤为 参数设置为-1。

$ ./reversing.py
['eagle', 'tiger', 'lion', 'bear']
['eagle', 'tiger', 'lion', 'bear']
['eagle', 'tiger', 'lion', 'bear']

这三个列表都被调换了，没问题。

Python 列表理解

列表理解是一种句法结构，用于创建列表 基于现有列表。其语法受到了数学符号 套装。Python 的语法灵感来自 Haskell 编程语言。

L = [expression for variable in sequence [if condition]]

上述伪代码展示了列表理解的语法。一份清单 理解会创建一个新的列表。它是基于现有的列表。一个for循环 讲述了这一序列。对于每个循环，如果满足 条件已达成。如果计算出该值，则附加到新列表中。该 条件为可选。

列表理解为在特定情境中创建列表提供了更简洁的方法 其中可以使用和/或嵌套环。mapfilter

#!/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]

这里是列表理解。在圈中 列表中的每个元素都被取用。然后 一个条件 经过考验。如果满足条件，则计算表达式。在我们的 当表达式为纯粹时，元素为 是的。最后，将元素附加到列表上。for e in a``if e % 2e

$ ./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 映射与滤波函数

和函数是质量函数，满足 对所有清单项目进行处理。它们是内置函数式编程的一部分 Python语言。mapfilter

如今，建议使用列表理解而非这些 尽可能地发挥作用。

#!/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)

该函数将该函数应用于单词列表中的每个字符串元素。形成一个新的列表， 回来了。我们打印到控制台上。mapto_upper

$ ./map_fun.py
['STONE', 'CLOUD', 'DREAM', 'SKY']

清单上的每一项都是大写字母。

该函数从这些元素构造一个列表 函数返回为真的列表。filter

#!/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)))

演示该功能的示例。它将创建一个只有正值的新列表。它将过滤掉所有负值和0。

def positive(x):
    return x > 0

这是函数所使用的函数的定义。它返回或。返回布尔值的函数称为谓词。

$ ./filter_fun.py
[1, 2, 4, 4]

资料来源

Python 数据结构 - 语言参考

本文介绍了 Python 列表集合。