Есть ли у кого-нибудь полезный код, который использует функцию reduce() в python? Есть ли какой-либо код, отличный от обычных + и *, которые мы видим в примерах?
Обратитесь Fate of reduce() в Python 3000 по GvR
Полезный код, который использует reduce()?
Ответ 1
Другие, которые я нашел для него, кроме + и *, были с и и/или, но теперь у нас есть any и all, чтобы заменить эти случаи.
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)
Ответ 2
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
Ответ 3
reduce() может использоваться для устранения точечных имен (где eval() слишком небезопасно для использования):
>>> import __main__
>>> reduce(getattr, "os.path.abspath".split('.'), __main__)
<function abspath at 0x009AB530>
Ответ 4
Найдите пересечение 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])
Ответ 5
Использование reduce, которое я нашел в моем коде, связано с ситуацией, когда у меня была некоторая структура класса для логического выражения, и мне нужно было преобразовать список этих объектов выражения в конъюнкцию выражений. У меня уже была функция make_and для создания конъюнкции, заданной двумя выражениями, поэтому я написал reduce(make_and,l). (Я знал, что список не пуст, иначе это было бы как reduce(make_and,l,make_true).)
Именно по этой причине (некоторым) функциональным программистам нравится reduce (или функции сгиба, поскольку такие функции обычно называются). Часто уже есть много двоичных функций, таких как +, *, min, max, конкатенация и, в моем случае, make_and и make_or. Наличие reduce делает тривиальным поднять эти операции на списки (или деревья или что-то еще, что у вас есть, для функций fold в целом).
Конечно, если некоторые экземпляры (например, sum) часто используются, вы не хотите писать reduce. Однако вместо определения sum с некоторым циклом for, вы можете так же легко определить его с помощью reduce.
Читаемость, как упоминалось другими, действительно является проблемой. Однако вы можете утверждать, что только причина, по которой люди находят reduce менее "понятную", состоит в том, что она не является функцией, которую многие знают и/или используют.
Ответ 6
Я думаю, что сокращение - глупая команда. Следовательно:
reduce(lambda hold,next:hold+chr(((ord(next.upper())-65)+13)%26+65),'znlorabggbbhfrshy','')
Ответ 7
@Blair Conrad: вы также можете реализовать свой glob/уменьшить с помощью суммы, например:
files = sum([glob.glob(f) for f in args], [])
Это менее подробный, чем любой из ваших двух примеров, отлично Pythonic и по-прежнему остается только одной строкой кода.
Итак, чтобы ответить на исходный вопрос, я лично стараюсь избегать использования сокращения, потому что он никогда не нужен, и я считаю его менее понятным, чем другие подходы. Тем не менее, некоторые люди привыкают к сокращению и предпочитают перечислить понимание (особенно программисты Haskell). Но если вы уже не думаете о проблеме с точки зрения сокращения, вам, вероятно, не нужно беспокоиться об использовании этого.
Ответ 8
Вы можете заменить value = json_obj['a']['b']['c']['d']['e'] на:
value = reduce(dict.__getitem__, 'abcde', json_obj)
Если у вас уже есть путь a/b/c/.. в качестве списка. Например, Измените значения в dict вложенных dicts, используя элементы в списке.
Ответ 9
reduce может использоваться для поддержки поиска цепочечных атрибутов:
reduce(getattr, ('request', 'user', 'email'), self)
Конечно, это эквивалентно
self.request.user.email
но полезно, когда ваш код должен принимать произвольный список атрибутов.
(Приобретенные атрибуты произвольной длины являются общими при работе с моделями Django.)
Ответ 10
Не уверен, что это то, что вам нужно, но вы можете искать исходный код в Google.
Следуйте ссылке для поиска по 'function: reduce() lang: python' в поиске кода Google
На первый взгляд следующие проекты используют reduce()
- MoinMoin
- Zope
- Числовые
- ScientificPython
и т.д.. и т.д., но тогда это не удивительно, поскольку они представляют собой огромные проекты.
Функциональность сокращения может быть выполнена с помощью рекурсии функций, которая, по моему мнению, была более явной.
Update:
Так как Google Code Search был прекращен 15 января 2012 года, помимо возврата к обычным поискам Google, там что-то называлось Code Snippets Collection, которое выглядит многообещающим. Ряд других ресурсов упоминается в ответах на этот (закрытый) вопрос Замена для поиска кода Google?.
Обновление 2 (29 мая-2017):
Хорошим источником для примеров Python (в открытом исходном коде) является Nullege search engine.
Ответ 11
После grepping моего кода, кажется, единственное, что я использовал, уменьшает для вычисления факториала:
reduce(operator.mul, xrange(1, x+1) or (1,))
Ответ 12
Сокращение не ограничивается скалярными операциями; его также можно использовать для сортировки предметов в ведрах. (Это то, что я чаще всего использую для сокращения).
Представьте случай, когда у вас есть список объектов, и вы хотите организовать его иерархическую иерархию на основе свойств, сохраненных в объекте. В следующем примере я создаю список объектов метаданных, связанных со статьями в XML-закодированной газете с функцией articles. 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, {})
Я предоставляю обе функции здесь, потому что я думаю, что это показывает, как карта и сокращение могут хорошо дополнять друг друга при работе с объектами. То же самое можно было бы сделать с помощью цикла for..., но проведение некоторого серьезного времени с функциональным языком, как правило, заставляло меня думать с точки зрения карты и уменьшать.
Кстати, если у кого-то есть лучший способ установить такие свойства, как я делаю в extract, где родители свойства, которое вы хотите установить, могут еще не существовать, сообщите мне.
Ответ 13
Состав функций. Если у вас уже есть список функций, которые вы хотите применить последовательно, например:
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)))).
Ответ 14
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.)
С другой стороны, если вы имеете дело с bool s, вы должны использовать any и all:
>>> any((True, False, True))
True
Ответ 15
Я пишу функцию компоновки для языка, поэтому я строю скомпонованную функцию, используя сокращение вместе с моим оператором apply.
В двух словах, 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(lambda x,y: Apply(y, x), reversed(args + [Symbol('x')]))
Чтобы выяснить, что делает сокращение, попробуйте их в REPL:
reduce(lambda x, y: (x, y), range(1, 11))
reduce(lambda x, y: (y, x), reversed(range(1, 11)))
Ответ 16
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']
# )},
# [])
#},
#[])
Ответ 17
def dump(fname,iterable):
with open(fname,'w') as f:
reduce(lambda x, y: f.write(unicode(y,'utf-8')), iterable)
Ответ 18
Я использовал reduce чтобы объединить список векторов поиска PostgreSQL с оператором || в sqlalchemy-searchable:
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)
Ответ 19
У меня есть старая реализация Python pipegrep, которая использует сокращение и модуль glob для создания списка обрабатываемых файлов:
files = []
files.extend(reduce(lambda x, y: x + y, map(glob.glob, args)))
В то время я нашел его удобным, но это действительно не нужно, поскольку что-то похожее так же хорошо, и, вероятно, более удобочитаемо
files = []
for f in args:
files.extend(glob.glob(f))
Ответ 20
уменьшить можно использовать для получения списка с максимальным 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], поскольку это список с максимальным третьим элементом +
Ответ 21
Скажем, что есть несколько годовых статистических данных, которые хранятся в списке счетчиков. Мы хотим найти значения 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
Ответ 22
У меня есть объекты, представляющие какие-то перекрывающиеся интервалы (геномные экзоны) и переопределяющие их пересечение с помощью __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)
Ответ 23
Я просто нашел полезное использование reduce: разделительная строка без удаления разделителя. Код полностью из блога Programatically Speaking. Здесь код:
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 нет. Для более подробного объяснения, я перенаправляю вас в оригинальное сообщение в блоге.
Ответ 24
Используя 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"