今天我们就一起来学习一下 Python 内置的一些 序列函数。这些用以操作序列的常用函数对我们熟悉和使用 Python 分析数据非常有益。

下面我们就来介绍第一个函数 ————

01 枚举 enumerate

使用 Python 分析数据时常常要用到迭代的思路。当我们在迭代序列时，通常需要跟踪当前项的索引。如下所示:

index = 0for value in collection:   # do something with value   index += 1对此，Python 内置了 enumerate 应对此类场景，enumerate 会返回一个 (index, value) 的元组序列：

for index, value in enumerate(collection):   # do something with value如：

In [1]: collection = [7, 1, 2, 6, 0, 3, 2]

In [2]: enumerate(collection)Out[2]: <enumerate at 0x10a9200e0>

In [3]: list(enumerate(collection))Out[3]: [(0, 7), (1, 1), (2, 2), (3, 6), (4, 0), (5, 3), (6, 2)]02 排序 sorted‍‍

很多分析中我们需要对序列进行排序，这时候，我们就可以使用 sorted  函数。‍‍‍‍

输入任何序列，sorted 都会返回一个排序后的 新 序列：

In [145]: sorted([7, 1, 2, 6, 0, 3, 2])Out[145]: [0, 1, 2, 2, 3, 6, 7]

In [146]: sorted("horse race")Out[146]: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']

sorted 函数接受与 列表 上应用的的 sort 方法相同的参数。

03 压缩 zip

zip 是一个很特别的函数，它可以将 多个可迭代对象（例如列表、元组、字符串等）逐个配对，将其元素打包成一个个 元组，并返回一个 zip 对象（该zip对象可以通过 list() 或 tuple() 转换为列表或元组）。‍‍

其基本用法如：

In [147]: seq1 = ["foo", "bar", "baz"]

In [148]: seq2 = ["one", "two", "three"]

In [149]: zipped = zip(seq1, seq2)

In [150]: list(zipped)Out[150]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zip 可以接受 任意数量 的序列，将它们按位置逐一配对：

In [5]: list1 = [1, 2, 3]

In [6]: list2 = ['a', 'b', 'c']

In [7]: list3 = [True, False, True]

In [8]: zipped = zip(list1, list2, list3)

In [9]: print(list(zipped))Out [9]: [(1, 'a', True), (2, 'b', False), (3, 'c', True)]

并且它生成的元素的数量由 最短 的序列决定:

In [151]: seq3 = [False, True]

In [152]: list(zip(seq1, seq2, seq3))Out[152]: [('foo', 'one', False), ('bar', 'two', True)]

此外，如果输入的序列长度不一致，zip 会在 最短的序列 结束时停止配对。这意味着 多出来的元素会被忽略：

In [11]: list1 = [1, 2, 3, 4]

In [12]: list2 = ['a', 'b', 'c']

In [13]: zipped = zip(list1, list2)

In [14]: print(list(zipped))[(1, 'a'), (2, 'b'), (3, 'c')]

想要对 zip 对象解压缩，只需要 zip(*zipped)  就可以将打包的内容解压出来：

In [16]: pairs = [(1, 'a'), (2, 'b'), (3, 'c')]

In [17]: list1, list2 = zip(*pairs)

In [18]: print(list1)(1, 2, 3)

In [19]: print(list2)('a', 'b', 'c')

zip 的一个常见用法是 同时 对 多个序列 进行迭代，也可能与 enumerate 相结合:

In [153]: for index, (a, b) in enumerate(zip(seq1, seq2)):   .....:     print(f"{index}: {a}, {b}")   .....:0: foo, one1: bar, two2: baz, three

此外，这种关系对有没有让你联想到 Python 中的一个数据类型？是的，字典。

我们可以用 zip 来两个列表组合成一个字典：

In [20]: keys = ['name', 'age', 'city']    ...: values = ['Alice', 30, 'New York']    ...:     ...: dictionary = dict(zip(keys, values))

In [21]: dictionaryOut[21]: {'name': 'Alice', 'age': 30, 'city': 'New York'}

04 翻转 reversed

还记得我们可以用 [::-1] 来翻转序列吗？Python 中提供了一个函数可以完成此功能，即 reversed ：

In [154]: list(reversed(range(10)))Out[154]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

05 推导式Comprehensions

推导式（Comprehensions）是简洁、易读的表达式，用于创建列表（List）、集合（Set）、和字典（Dictionary）这些数据结构。它们可以在 一行代码 中生成新的列表、集合或字典，尤其在需要从其他可迭代对象进行过滤、变换时，非常方便。

列表推导式

用于创建一个新的列表，它的基本语法是：[expression  for  value  in  collection  if  condition]

其中：

    expression 是对每个元素的操作，生成新列表中的元素。

    item 是当前迭代的元素。

    collection 是你要迭代的对象（如 list、string、range等）。

    condition 是一个可选的过滤条件，仅满足条件的元素会被加入新列表。

它等于如下所示的 for 循环：

result = []for value in collection:    if condition:        result.append(expression)筛选条件可以省略，只留下表达式。例如，给定一个字符串列表，我们可以过滤出长度为2或更短的字符串，并将它们转换为大写，如下所示:

In [155]: strings = ["a", "as", "bat", "car", "dove", "python"]

In [156]: [x.upper() for x in strings if len(x) > 2]Out[156]: ['BAT', 'CAR', 'DOVE', 'PYTHON']或者如下应用：

# 创建一个包含 0 到 9 的平方的列表squares = [x**2 for x in range(10)]print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 创建一个只包含偶数平方的列表even_squares = [x**2 for x in range(10) if x % 2 == 0]print(even_squares)  # 输出: [0, 4, 16, 36, 64]

集合 和 字典 的推导式与 列表 相似。

集合推导式

使用花括号{}，并且生成的结果会自动去重，因为集合不允许重复的元素：

{expression for value in colection if condition}

示例：

# 创建一个包含 0 到 9 的平方的集合squares_set = {x**2 for x in range(10)}print(squares_set)  # 输出: {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# 创建一个只包含偶数平方的集合even_squares_set = {x**2 for x in range(10) if x % 2 == 0}print(even_squares_set)  # 输出: {0, 4, 16, 36, 64}

字典推导式 也使用花括号{}，语法如下：

{key_expression: value_expression for item in colection if condition}示例：

# 创建一个字典，其中键是数字，值是它们的平方squares_dict = {x: x**2 for x in range(10)}print(squares_dict)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, ..., 9: 81}

# 创建一个字典，只包含偶数键及其平方值even_squares_dict = {x: x**2 for x in range(10) if x % 2 == 0}print(even_squares_dict)  # 输出: {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

这些推导式不仅简洁，而且在 Python 中运行效率较高，尤其适合快速生成和处理简单的数据结构。