¿Cómo establecer la variable local en la lista de comprensión?

Question 1

Tengo un método que toma una lista y devuelve un objeto:

# input a list, returns an object
def map_to_obj(lst):
    a_list = f(lst)
    return a_list[0] if a_list else None

Quiero obtener una lista que contenga todos los elementos mapeados que no están None.

Como esto:

v_list = [v1, v2, v3, v4]

[map_to_obj(v) for v in v_list if map_to_obj(v)]

Pero no me parece bien llamar a la map_to_obj método dos veces en la lista de comprensión.

¿Hay alguna manera de tener variables locales en las listas de comprensión para que pueda tener un mejor rendimiento?

¿O el compilador lo optimiza automáticamente?

Esto es lo que quiero:

(sml like)
[let mapped = map_to_obj(v) in for v in v_list if mapped end]

Question 2

Utilice la comprensión de listas anidadas:

[x for x in [map_to_obj(v) for v in v_list] if x]

o mejor aún, una lista de comprensión en torno a una expresión generadora:

[x for x in (map_to_obj(v) for v in v_list) if x]

Question 3

A partir de Python 3.8y la introducción de expresiones de asignación (PEP 572) (:= operador), es posible usar una variable local dentro de una lista de comprensión para evitar llamar a la misma función dos veces.

En nuestro caso, podemos nombrar la evaluación de map_to_obj(v) como variable o mientras usa el resultado de la expresión para filtrar la lista; y así usar o como el valor mapeado:

[o for v in [v1, v2, v3, v4] if (o := map_to_obj(v))]

Question 4

Una asignación de variable es solo un enlace singular:

[x   for v in l   for x in [v]]

Esta es una respuesta más general y también más cercana a lo que propusiste. Así que para tu problema puedes escribir:

[x   for v in v_list   for x in [map_to_obj(v)]   if x]

Question 5

Puede evitar el recálculo utilizando python incorporado filter:

list(filter(lambda t: t is not None, map(map_to_obj, v_list)))

Question 6

Una variable local se puede establecer dentro de una comprensión haciendo un poco de trampa y usando un ‘para’ adicional que “itera” a través de una tupla de 1 elemento que contiene el valor deseado para la variable local. Aquí hay una solución al problema del OP usando este enfoque:

[o for v in v_list for o in (map_to_obj(v),) if o]

Aquí, o es la variable local siendo igual a map_to_obj(v) para cada v.

En mis pruebas, esto es un poco más rápido que la expresión del generador anidado de Lying Dog (y también más rápido que la doble llamada del OP a map_to_obj(v)que, sorprendentemente, puede ser más rápido que la expresión del generador anidado si el map_to_obj la función no es demasiado lenta).

Question 7

Las comprensiones de lista están bien para los casos simples, pero a veces un simple viejo for loop es la solución más simple:

other_list = []
for v in v_list:
    obj = map_to_obj(v)
    if obj:
        other_list.append(obj)

Ahora, si realmente desea una compilación de lista y no desea crear una lista tmp, puede usar las versiones iteradoras de filter y map:

import itertools as it
result = list(it.ifilter(None, it.imap(map_to_obj, v_list)))

o más simplemente:

import itertools as it
result = filter(None, it.imap(map_to_obj, v_list)))

Las versiones del iterador no crean una lista temporal, usan una evaluación diferida.

Question 8

He descubierto una forma de usar reduce:

def map_and_append(lst, v):
    mapped = map_to_obj(v)
    if mapped is not None:
        lst.append(mapped)
    return lst

reduce(map_and_append, v_list, [])

¿Qué tal el rendimiento de esto?

¿Ha sido útil esta solución?