Как избежать множественных вызовов в понимании python. [Дубликат]

Как насчет определения:

def truths(L):
    """Return the elements of L that test true"""
    return [x for x in L if x]

Так, например,

> [wife.children for wife in henry8.wives]
[[Mary1], [Elizabeth1], [Edward6], [], [], []]

> truths(wife.children for wife in henry8.wives) 
[[Mary1], [Elizabeth1], [Edward6]]

Вот мое решение:

filter(None, [f(x) for x in l])

Вы можете использовать memoization . Это метод, который используется для того, чтобы избежать выполнения одного и того же вычисления дважды, сохраняя где-то результат для каждого рассчитанного значения. Я видел, что уже есть ответ, который использует memoization, но я хотел бы предложить общую реализацию, используя декораторы python:

def memoize(func):
    def wrapper(*args):
        if args in wrapper.d:
            return wrapper.d[args]
        ret_val = func(*args)
        wrapper.d[args] = ret_val
        return ret_val
    wrapper.d = {}
    return wrapper

@memoize
def f(x):
...

Теперь f - это сама memoized версия. С этой реализацией вы можете memoize любую функцию, используя декоратор @memoize.

Было много ответов на memoizing. Стандартная библиотека Python 3 теперь имеет lru_cache, который является последним использованным кэшем . Таким образом, вы можете:

from functools import lru_cache

@lru_cache()
def f(x):
    # function body here

Таким образом, ваша функция будет вызываться только один раз. Вы также можете указать размер lru_cache, по умолчанию это 128. Проблема с декораторами memoize, показанная выше, заключается в том, что размер списков может значительно увеличиться.

Использовать map() !!

comp = [x for x in map(f, l) if x]

f - это функция f(X), l - список

map() вернет результат f(x) для каждого x в списке.

Вы должны использовать декоратор memoize. Вот интересная ссылка .

Использование memoization из ссылки и вашего «кода»:

def memoize(f):
    """ Memoization decorator for functions taking one or more arguments. """
    class memodict(dict):
        def __init__(self, f):
            self.f = f
        def __call__(self, *args):
            return self[args]
        def __missing__(self, key):
            ret = self[key] = self.f(*key)
            return ret
    return memodict(f)

@memoize
def f(x):
    # your code

[f(x) for x in l if f(x)]

Нет. Для этого нет ( clean ). Нет ничего плохого в хорошем старомодном цикле:

output = []
for x in l:
    result = f(x)
    if result: 
        output.append(result)

Если вы считаете, что трудно читать, вы всегда можете обернуть его в функцию.

[y for y in [f(x) for x in l] if y]

Для вашей обновленной проблемы это может быть полезно:

[g(x,y) for x in l for y in [f(x)] if y]