这里有没有人有任何有用的代码在 python 中使用 reduce() 函数？除了我们在示例中看到的通常的 + 和 * 之外，还有其他代码吗？
cnu
问问题
87027 次
24 回答
66
除了 + 和 * 之外，我发现它的其他用途是与 and 和 or，但现在我们有anyandall来替换这些情况。
foldl并且foldr确实在Scheme中出现了很多......
这里有一些可爱的用法：
展平列表
目标：[[1, 2, 3], [4, 5], [6, 7, 8]]变成[1, 2, 3, 4, 5, 6, 7, 8].
reduce(list.__add__, [[1, 2, 3], [4, 5], [6, 7, 8]], [])
数字列表
目标：[1, 2, 3, 4, 5, 6, 7, 8]变成12345678.
丑陋，缓慢的方式：
int("".join(map(str, [1,2,3,4,5,6,7,8])))
漂亮reduce的方式：
reduce(lambda a,d: 10*a+d, [1,2,3,4,5,6,7,8], 0)
于 2008-11-11T07:29:36.197 回答
50
reduce()可用于查找3 个或更多数字的最小公倍数：
#!/usr/bin/env python
from fractions import gcd
from functools import reduce
def lcm(*args):
return reduce(lambda a,b: a * b // gcd(a, b), args)
例子：
>>> lcm(100, 23, 98)
112700
>>> lcm(*range(1, 20))
232792560
于 2008-11-11T21:33:49.907 回答
41
reduce()可用于解析带点的名称（eval()使用起来太不安全了）：
>>> import __main__
>>> reduce(getattr, "os.path.abspath".split('.'), __main__)
<function abspath at 0x009AB530>
于 2008-11-12T01:02:23.230 回答
23
求 N 个给定列表的交集：
input_list = [[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7]]
result = reduce(set.intersection, map(set, input_list))
返回：
result = set([3, 4, 5])
于 2010-07-17T17:05:38.560 回答
13
我认为 reduce 是一个愚蠢的命令。因此：
reduce(lambda hold,next:hold+chr(((ord(next.upper())-65)+13)%26+65),'znlorabggbbhfrshy','')
于 2012-08-29T05:34:17.537 回答
11
我在我的代码中发现的这种用法reduce涉及我有一些用于逻辑表达式的类结构并且我需要将这些表达式对象的列表转换为表达式的结合的情况。我已经有一个函数make_and可以在给定两个表达式的情况下创建一个连词，所以我写了reduce(make_and,l). （我知道这个列表不是空的；否则它会是这样的reduce(make_and,l,make_true)。）
这正是（某些）函数式程序员喜欢reduce（或折叠函数，因为这些函数通常被称为）的原因。通常已经有许多二进制函数，如+, *, min, max, 连接，在我的例子中，make_and和make_or. 拥有 areduce使得将这些操作提升到列表（或树或任何你得到的东西，对于一般的折叠函数）变得微不足道。
当然，如果某些实例化（例如sum）经常使用，那么您不想继续编写reduce. 但是，sum您可以使用reduce.
正如其他人所提到的，可读性确实是一个问题。但是，您可能会争辩说，人们发现不太“清楚”的唯一原因reduce是因为它不是许多人知道和/或使用的功能。
于 2008-09-03T13:27:47.477 回答
10
函数组合：如果你已经有了想要连续应用的函数列表，比如：
color = lambda x: x.replace('brown', 'blue')
speed = lambda x: x.replace('quick', 'slow')
work = lambda x: x.replace('lazy', 'industrious')
fs = [str.lower, color, speed, work, str.title]
然后，您可以通过以下方式连续应用它们：
>>> call = lambda s, func: func(s)
>>> s = "The Quick Brown Fox Jumps Over the Lazy Dog"
>>> reduce(call, fs, s)
'The Slow Blue Fox Jumps Over The Industrious Dog'
在这种情况下，方法链接可能更具可读性。但有时这是不可能的，而且这种组合可能比f1(f2(f3(f4(x))))一种语法更具可读性和可维护性。
于 2014-01-15T17:55:26.513 回答
9
您可以替换value = json_obj['a']['b']['c']['d']['e']为：
value = reduce(dict.__getitem__, 'abcde', json_obj)
如果您已经将路径a/b/c/..作为列表。例如，使用列表中的项目更改嵌套字典的字典中的值。
于 2012-08-19T11:15:45.610 回答
7
@Blair Conrad：您还可以使用 sum 实现 glob/reduce，如下所示：
files = sum([glob.glob(f) for f in args], [])
这比您的两个示例中的任何一个都不那么冗长，完全是 Pythonic，并且仍然只有一行代码。
因此，为了回答最初的问题，我个人尽量避免使用 reduce，因为它从来都不是真正必要的，而且我发现它比其他方法不太清楚。然而，有些人习惯于减少并更喜欢它而不是列表推导（尤其是 Haskell 程序员）。但是，如果您还没有考虑到 reduce 方面的问题，您可能不需要担心使用它。
于 2008-08-19T13:57:22.133 回答
6
reduce可用于支持链式属性查找：
reduce(getattr, ('request', 'user', 'email'), self)
当然，这相当于
self.request.user.email
但当您的代码需要接受任意属性列表时，它很有用。
（在处理 Django 模型时，任意长度的链式属性很常见。）
于 2014-06-20T07:07:29.210 回答
4
reduce当您需要查找一系列类似set对象的并集或交集时很有用。
>>> reduce(operator.or_, ({1}, {1, 2}, {1, 3})) # union
{1, 2, 3}
>>> reduce(operator.and_, ({1}, {1, 2}, {1, 3})) # intersection
{1}
（除了实际set的 s，其中的一个例子是Django 的 Q 对象。）
另一方面，如果你正在处理bools，你应该使用anyand all：
>>> any((True, False, True))
True
于 2014-06-20T07:37:15.650 回答
3
不确定这是否是您所追求的，但您可以在 Google 上搜索源代码。
按照链接在 Google 代码搜索中搜索“function:reduce() lang:python”
乍一看以下项目使用reduce()
- 莫因莫因
- 佐佩
- 数字
- 科学蟒蛇
等等等等，但这些都不足为奇，因为它们是巨大的项目。
reduce 的功能可以使用函数递归来完成，我猜 Guido 认为这更明确。
更新：
由于 Google 的代码搜索已于 2012 年 1 月 15 日停止，除了恢复到常规的 Google 搜索之外，还有一个名为Code Snippets Collection的东西看起来很有希望。在回答此（已关闭）问题Replacement for Google Code Search？中提到了许多其他资源？.
更新 2（2017 年 5 月 29 日）：
Python 示例（在开源代码中）的一个很好的来源是Nullege 搜索引擎。
于 2008-08-19T12:16:01.030 回答
3
在 grepping 我的代码之后，似乎我唯一使用 reduce 的就是计算阶乘：
reduce(operator.mul, xrange(1, x+1) or (1,))
于 2008-08-21T21:40:46.117 回答
3
Reduce 不限于标量操作；它也可以用来将东西分类到桶中。（这是我最常使用的 reduce）。
想象一下这样一种情况，您有一个对象列表，并且您希望根据对象中平坦存储的属性分层地重新组织它。articles在以下示例中，我使用该函数生成与 XML 编码报纸中的文章相关的元数据对象列表。articles生成一个 XML 元素列表，然后逐个映射它们，生成包含有关它们的一些有趣信息的对象。在前端，我想让用户按部分/子部分/标题浏览文章。因此，我使用reduce获取文章列表并返回反映节/小节/文章层次结构的单个字典。
from lxml import etree
from Reader import Reader
class IssueReader(Reader):
def articles(self):
arts = self.q('//div3') # inherited ... runs an xpath query against the issue
subsection = etree.XPath('./ancestor::div2/@type')
section = etree.XPath('./ancestor::div1/@type')
header_text = etree.XPath('./head//text()')
return map(lambda art: {
'text_id': self.id,
'path': self.getpath(art)[0],
'subsection': (subsection(art)[0] or '[none]'),
'section': (section(art)[0] or '[none]'),
'headline': (''.join(header_text(art)) or '[none]')
}, arts)
def by_section(self):
arts = self.articles()
def extract(acc, art): # acc for accumulator
section = acc.get(art['section'], False)
if section:
subsection = acc.get(art['subsection'], False)
if subsection:
subsection.append(art)
else:
section[art['subsection']] = [art]
else:
acc[art['section']] = {art['subsection']: [art]}
return acc
return reduce(extract, arts, {})
我在这里给出这两个函数是因为我认为它展示了 map 和 reduce 在处理对象时如何很好地相互补充。同样的事情也可以用一个 for 循环来完成，......但是花一些时间使用函数式语言往往会让我从 map 和 reduce 的角度思考。
顺便说一句，如果有人有更好的方法来设置属性，就像我正在做的那样extract，您要设置的属性的父级可能还不存在，请告诉我。
于 2012-09-07T02:23:24.910 回答
3
reduce 可用于获取具有最大第 n 个元素的列表
reduce(lambda x,y: x if x[2] > y[2] else y,[[1,2,3,4],[5,2,5,7],[1,6,0,2]])
将返回 [5, 2, 5, 7] 因为它是具有最大第 3 个元素的列表 +
于 2013-03-21T07:06:14.260 回答
3
我正在为一种语言编写一个组合函数，所以我使用 reduce 和我的应用运算符构造组合函数。
简而言之，compose 将一个函数列表组合成一个函数。如果我有一个分阶段应用的复杂操作，我想将它们放在一起，如下所示：
complexop = compose(stage4, stage3, stage2, stage1)
这样，我就可以将其应用于如下表达式：
complexop(expression)
我希望它相当于：
stage4(stage3(stage2(stage1(expression))))
现在，为了构建我的内部对象，我想说：
Lambda([Symbol('x')], Apply(stage4, Apply(stage3, Apply(stage2, Apply(stage1, Symbol('x'))))))
（Lambda 类构建用户定义函数，Apply 构建函数应用程序。）
现在，不幸的是，reduce 以错误的方式折叠，所以我大致使用了：
reduce(lambda x,y: Apply(y, x), reversed(args + [Symbol('x')]))
要弄清楚 reduce 产生了什么，请在 REPL 中尝试这些：
reduce(lambda x, y: (x, y), range(1, 11))
reduce(lambda x, y: (y, x), reversed(range(1, 11)))
于 2010-04-23T20:34:50.440 回答
2
import os
files = [
# full filenames
"var/log/apache/errors.log",
"home/kane/images/avatars/crusader.png",
"home/jane/documents/diary.txt",
"home/kane/images/selfie.jpg",
"var/log/abc.txt",
"home/kane/.vimrc",
"home/kane/images/avatars/paladin.png",
]
# unfolding of plain filiname list to file-tree
fs_tree = ({}, # dict of folders
[]) # list of files
for full_name in files:
path, fn = os.path.split(full_name)
reduce(
# this fucction walks deep into path
# and creates placeholders for subfolders
lambda d, k: d[0].setdefault(k, # walk deep
({}, [])), # or create subfolder storage
path.split(os.path.sep),
fs_tree
)[1].append(fn)
print fs_tree
#({'home': (
# {'jane': (
# {'documents': (
# {},
# ['diary.txt']
# )},
# []
# ),
# 'kane': (
# {'images': (
# {'avatars': (
# {},
# ['crusader.png',
# 'paladin.png']
# )},
# ['selfie.jpg']
# )},
# ['.vimrc']
# )},
# []
# ),
# 'var': (
# {'log': (
# {'apache': (
# {},
# ['errors.log']
# )},
# ['abc.txt']
# )},
# [])
#},
#[])
于 2014-05-20T16:08:21.963 回答
2
我曾经用sqlalchemy-searchable 中的运算符reduce 连接 PostgreSQL 搜索向量列表：||
vectors = (self.column_vector(getattr(self.table.c, column_name))
for column_name in self.indexed_columns)
concatenated = reduce(lambda x, y: x.op('||')(y), vectors)
compiled = concatenated.compile(self.conn)
于 2016-01-06T04:10:35.707 回答
1
我有一个pipegrep的旧 Python 实现，它使用 reduce 和 glob 模块来构建要处理的文件列表：
files = []
files.extend(reduce(lambda x, y: x + y, map(glob.glob, args)))
当时我发现它很方便，但实际上没有必要，因为类似的东西同样好，而且可能更具可读性
files = []
for f in args:
files.extend(glob.glob(f))
于 2008-08-19T12:43:36.497 回答
1
假设有一些年度统计数据存储了计数器列表。我们希望找到不同年份每个月的 MIN/MAX 值。例如，对于一月份，它将是 10。对于二月，它将是 15。我们需要将结果存储在一个新的计数器中。
from collections import Counter
stat2011 = Counter({"January": 12, "February": 20, "March": 50, "April": 70, "May": 15,
"June": 35, "July": 30, "August": 15, "September": 20, "October": 60,
"November": 13, "December": 50})
stat2012 = Counter({"January": 36, "February": 15, "March": 50, "April": 10, "May": 90,
"June": 25, "July": 35, "August": 15, "September": 20, "October": 30,
"November": 10, "December": 25})
stat2013 = Counter({"January": 10, "February": 60, "March": 90, "April": 10, "May": 80,
"June": 50, "July": 30, "August": 15, "September": 20, "October": 75,
"November": 60, "December": 15})
stat_list = [stat2011, stat2012, stat2013]
print reduce(lambda x, y: x & y, stat_list) # MIN
print reduce(lambda x, y: x | y, stat_list) # MAX
于 2014-02-22T15:18:17.800 回答
1
我有代表某种重叠间隔（基因组外显子）的对象，并使用以下方法重新定义它们的交集__and__：
class Exon:
def __init__(self):
...
def __and__(self,other):
...
length = self.length + other.length # (e.g.)
return self.__class__(...length,...)
然后当我收集它们（例如，在同一个基因中）时，我使用
intersection = reduce(lambda x,y: x&y, exons)
于 2014-06-05T13:40:37.070 回答
1
我刚刚发现有用的用法reduce：在不删除分隔符的情况下拆分字符串。代码完全来自 Programatically speak 博客。这是代码：
reduce(lambda acc, elem: acc[:-1] + [acc[-1] + elem] if elem == "\n" else acc + [elem], re.split("(\n)", "a\nb\nc\n"), [])
结果如下：
['a\n', 'b\n', 'c\n', '']
请注意，它可以处理 SO 中流行的答案没有处理的边缘情况。如需更深入的解释，我将您重定向到原始博客文章。
于 2015-11-24T13:31:11.853 回答
1
def dump(fname,iterable):
with open(fname,'w') as f:
reduce(lambda x, y: f.write(unicode(y,'utf-8')), iterable)
于 2015-09-16T14:43:41.550 回答
0
使用 reduce() 找出日期列表是否连续：
from datetime import date, timedelta
def checked(d1, d2):
"""
We assume the date list is sorted.
If d2 & d1 are different by 1, everything up to d2 is consecutive, so d2
can advance to the next reduction.
If d2 & d1 are not different by 1, returning d1 - 1 for the next reduction
will guarantee the result produced by reduce() to be something other than
the last date in the sorted date list.
Definition 1: 1/1/14, 1/2/14, 1/2/14, 1/3/14 is consider consecutive
Definition 2: 1/1/14, 1/2/14, 1/2/14, 1/3/14 is consider not consecutive
"""
#if (d2 - d1).days == 1 or (d2 - d1).days == 0: # for Definition 1
if (d2 - d1).days == 1: # for Definition 2
return d2
else:
return d1 + timedelta(days=-1)
# datelist = [date(2014, 1, 1), date(2014, 1, 3),
# date(2013, 12, 31), date(2013, 12, 30)]
# datelist = [date(2014, 2, 19), date(2014, 2, 19), date(2014, 2, 20),
# date(2014, 2, 21), date(2014, 2, 22)]
datelist = [date(2014, 2, 19), date(2014, 2, 21),
date(2014, 2, 22), date(2014, 2, 20)]
datelist.sort()
if datelist[-1] == reduce(checked, datelist):
print "dates are consecutive"
else:
print "dates are not consecutive"
于 2014-02-22T15:16:42.010 回答