Python的返回列表的函数

权威技术指南 · 实战案例解析 · 高效编程实践

⚡ 返回列表的函数概览

在Python编程中,返回列表的函数构成了数据处理与算法实现的基石。从基础内置函数到高级模块方法,开发者可通过多种方式构造、变换、过滤或组合数据为列表结构。这些函数不仅影响代码可读性与执行效率,更直接关联内存占用、迭代性能与异常处理能力。

本指南系统梳理所有可返回列表或可直接转为列表的函数与方法,结合真实场景、性能对比、典型陷阱与最佳实践,帮助开发者高效构建健壮、简洁的列表操作逻辑。

特别注意:部分函数返回迭代器(如map、filter、zip),需通过list()显式转换才成为列表;而list()本身作为构造函数,是构造空列表或复制序列的核心工具。

⚠️ 注意:在Python 3中,许多返回迭代器的函数(如map、filter、zip)不再返回列表,必须调用list()包装才能获得列表对象。

⚙️ 核心返回列表的函数分类

1. 直接返回列表的函数

  • list():构造函数,用于创建新列表或复制序列
  • list comprehension:语法糖,返回列表对象(非函数,但常被误认为函数)

例如:

>>> list((1, 2, 3))  # 元组转列表
[1, 2, 3]
>>> list({1, 2, 3})  # 集合转列表(顺序不固定)
[1, 2, 3]
>>> list('abc')  # 字符串转字符列表
['a', 'b', 'c']

2. 返回迭代器但可转为列表的函数

  • reversed(seq):返回反向迭代器
  • sorted(iterable):返回排序后的新列表
  • enumerate(iterable):返回枚举对象(可转为元组列表)
  • zip(*iterables):返回聚合迭代器(可转为元组列表)
  • map(func, *iterables):返回映射迭代器
  • filter(function, iterable):返回过滤迭代器

注意:上述函数需显式调用list()才能获得列表,否则仅返回迭代器对象。

3. itertools模块:高效迭代器工具集

itertools提供多种生成器与迭代器,部分可通过list()转为列表,常用于组合、排列、累积等场景:

  • itertools.combinations(iterable, r):返回r长度组合
  • itertools.permutations(iterable, r=None):返回排列
  • itertools.chain(*iterables):串联多个迭代器
  • itertools.islice(iterable, start, stop[, step]):切片迭代器
  • itertools.accumulate(iterable, func=operator.add):累积结果

示例:

>>> import itertools
>>> list(itertools.combinations([1,2,3], 2))
[(1, 2), (1, 3), (2, 3)]
>>> list(itertools.accumulate([1,2,3,4]))
[1, 3, 6, 10]

〔内置函数详解〕

1. list():万能列表构造器

语法:list([iterable])

  • 无参数:创建空列表 []
  • 有参数:将可迭代对象转为列表(浅拷贝)
  • 支持:字符串、元组、集合、range对象、字典(仅键)、其他迭代器
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list({'a':1, 'b':2})  # 仅键
['a', 'b']
>>> list({'a':1, 'b':2}.items())  # 键值对
[('a', 1), ('b', 2)]

⚠️ 注意:list()仅进行浅拷贝。若元素为可变对象(如嵌套列表),修改副本可能影响原对象。

2. sorted():稳定排序返回列表

语法:sorted(iterable, *, key=None, reverse=False)

与list.sort()区别:sorted()返回新列表,不修改原对象;list.sort()原地排序,返回None。

支持多级排序(key返回元组):

>>> data = [('Alice', 25), ('Bob', 20), ('Alice', 22)]
>>> sorted(data, key=lambda x: (x[0], x[1]))  # 先按名,再按年龄
[('Alice', 22), ('Alice', 25), ('Bob', 20)]

⚠️ 注意:key函数应避免副作用(如打印、修改全局变量),因其可能被多次调用。

3. reversed():反向迭代器包装

语法:reversed(seq)

仅接受序列类型(支持__len__与__getitem__),如list、tuple、str、range。不支持一般迭代器。

>>> list(reversed([1,2,3]))
[3, 2, 1]
>>> list(reversed('abc'))
['c', 'b', 'a']

替代方案:使用切片[::-1],但reversed()语义更清晰且支持任意序列类型。

4. enumerate():带索引的枚举

语法:enumerate(iterable, start=0)

返回(索引, 元素)元组迭代器。常用于遍历时需位置信息的场景。

>>> list(enumerate(['a','b','c'], start=1))
[(1, 'a'), (2, 'b'), (3, 'c')]
>>> for idx, val in enumerate(['x','y','z']):
...     print(f"{idx}: {val}")
0: x
1: y
2: z

5. zip():并行聚合

语法:zip(*iterables)

将多个可迭代对象的对应元素打包为元组,长度取最短迭代器。Python 3中返回迭代器,需list()转列表。

>>> list(zip([1,2,3], ['a','b']))
[(1, 'a'), (2, 'b')]
>>> list(zip([1,2], [3,4], [5,6]))
[(1, 3, 5), (2, 4, 6)]

解包技巧:zip(*list_of_tuples)可还原原始结构。

6. map():函数映射

语法:map(func, *iterables)

将func作用于每个iterable元素,返回迭代器。支持多参数函数(多个iterable)。

>>> list(map(str.upper, ['a','b','c']))
['A', 'B', 'C']
>>> list(map(lambda x,y: x+y, [1,2], [3,4]))
[4, 6]

⚠️ 注意:func应为纯函数(无副作用),否则可能导致不可预测行为。

7. filter():条件过滤

语法:filter(function, iterable)

保留function(item)为True的元素。若function为None,则保留真值元素。

>>> list(filter(lambda x: x>2, [1,2,3,4]))
[3, 4]
>>> list(filter(None, [0,1,False,'',[],None,'ok']))
[1, 'ok']

⚠️ 注意:filter()不改变元素本身,仅过滤。如需变换,应与map()组合使用。

〔itertools模块高级用法〕

1. itertools.combinations():组合

返回所有长度为r的组合(无重复、无顺序)。

>>> list(itertools.combinations([1,2,3,4], 2))
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

2. itertools.permutations():排列

返回所有长度为r的排列(有顺序、无重复)。

>>> list(itertools.permutations([1,2,3], 2))
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

3. itertools.chain():串联

将多个迭代器串联为单一迭代器,避免中间列表创建。

>>> list(itertools.chain([1,2], [3,4], [5]))
[1, 2, 3, 4, 5]

4. itertools.islice():切片

对迭代器进行切片操作,避免转列表的内存开销。

>>> list(itertools.islice(range(1000000), 0, 10, 2))
[0, 2, 4, 6, 8]

5. itertools.accumulate():累积

默认累积求和,可指定二元函数。

>>> list(itertools.accumulate([1,2,3,4,5]))
[1, 3, 6, 10, 15]
>>> import operator
>>> list(itertools.accumulate([1,2,3], operator.mul))
[1, 2, 6]

〔典型应用场景与最佳实践〕

1. 数据清洗:过滤+映射

场景:清洗用户输入数据(去除空值、统一大小写)

>>> raw = [' Alice ', '', 'bob ', None, '  CHARLIE']
>>> cleaned = list(map(str.strip, filter(None, map(str.strip, raw))))
['Alice', 'bob', 'CHARLIE']
>>> # 更优方案:列表推导式(更Pythonic)
>>> cleaned = [name.strip() for name in raw if name and name.strip()]
['Alice', 'bob', 'CHARLIE']

2. 分页处理:enumerate + islice

场景:处理大数据集时按页提取

>>> data = list(range(100))
>>> page_size = 10
>>> page_num = 2  # 第3页(0-indexed)
>>> page = list(itertools.islice(data, page_num*page_size, (page_num+1)*page_size))
[20, 21, ..., 29]

3. 高级排序:sorted + key组合

场景:对字典列表按嵌套字段排序

>>> users = [
...   {'name': 'Alice', 'age': 25, 'score': {'math': 90, 'eng': 88}},
...   {'name': 'Bob', 'age': 22, 'score': {'math': 95, 'eng': 85}},
...   {'name': 'Alice', 'age': 23, 'score': {'math': 88, 'eng': 92}}
... ]
>>> sorted(users, key=lambda u: (u['name'], -u['age'], -u['score']['math']))
[{'name': 'Alice', 'age': 25, 'score': {'math': 90, 'eng': 88}},
 {'name': 'Alice', 'age': 23, 'score': {'math': 88, 'eng': 92}},
 {'name': 'Bob', 'age': 22, 'score': {'math': 95, 'eng': 85}}]

4. 组合生成:itertools.product

场景:生成所有坐标点组合

>>> list(itertools.product([0,1,2], ['a','b']))
[(0, 'a'), (0, 'b'), (1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]

〔常见误区与避坑指南〕

1. 误以为map/filter返回列表

在Python 3中,map()和filter()返回迭代器,直接打印会显示而非列表内容。

>>> map_obj = map(str, [1,2,3])
>>> print(map_obj)

>>> list(map_obj)  # 需显式转换
['1', '2', '3']

2. list.copy()与list()浅拷贝差异

两者均执行浅拷贝,但list()更通用(适用于任意可迭代对象),而.copy()仅适用于列表。

>>> a = [1,2,3]
>>> b = list(a)
>>> c = a.copy()
>>> a.append(4)
>>> b, c
([1, 2, 3], [1, 2, 3])  # 均不受影响

3. reversed()仅支持序列

不能对set、dict、生成器等非序列类型使用reversed()。

>>> reversed({1,2,3})
TypeError: argument to reversed() must be a sequence

替代方案:先转为list,再[::-1]切片。

4. zip()长度陷阱

zip()以最短迭代器为准,长迭代器尾部元素会被丢弃。

>>> list(zip([1,2,3,4], ['a','b']))
[(1, 'a'), (2, 'b')]  # 3,4被忽略

解决方案:使用itertools.zip_longest()填充缺失值。

〔高频问答〕

A:直接返回列表的函数仅list()和sorted()。其他如map/filter/zip/reversed均返回迭代器,需list()包装。可通过type()验证:

>>> type(list([1,2]))

>>> type(sorted([1,2]))

>>> type(map(str, [1]))

A:sorted()设计为返回新列表以保持原对象不变;reversed()仅提供反向迭代能力,返回迭代器更节省内存。若需列表,调用list(reversed(seq))即可。

A:根据场景选择:

  • 小列表:a + b 或 a.extend(b)
  • 大列表/多列表:itertools.chain(*lists)(惰性求值)或list(chain(*lists))
  • 数值计算:np.concatenate([a,b])

A:不能。列表推导式适合简单映射/过滤;复杂逻辑(如多条件、嵌套、外部状态)更适合用map/filter/itertools组合。例如:

>>> # 推导式:[f(x) for x in data if cond(x)]
>>> # map+filter:list(map(f, filter(cond, data)))
>>> # 更复杂时:itertools组合更清晰