¿Cómo puedo particionar (dividir, dividir) una lista en función de una condición?

Tengo un código como:

good = [x for x in mylist if x in goodvals]
bad = [x for x in mylist if x not in goodvals]

El objetivo es dividir el contenido de mylist en otras dos listas, en función de si cumplen o no una condición.

¿Cómo puedo hacer esto con más elegancia? ¿Puedo evitar hacer dos iteraciones separadas sobre mylist? ¿Puedo mejorar el rendimiento al hacerlo?

good = [x for x in mylist if x in goodvals]
bad  = [x for x in mylist if x not in goodvals]

¿Cómo puedo hacer esto con más elegancia?

Ese código ya es perfectamente elegante.

Puede haber ligeras mejoras de rendimiento al usar sets, pero la diferencia es trivial. set los enfoques basados ​​también descartarán los duplicados y no preservarán el orden de los elementos. También encuentro que la lista de comprensión es mucho más fácil de leer.

De hecho, podríamos incluso más simplemente usar un for bucle:

good, bad = [], []

for x in mylist:
    if x in goodvals:
        good.append(f)
    else:
        bad.append(f)

Este enfoque facilita la adición de lógica adicional. Por ejemplo, el código se modifica fácilmente para descartar None valores:

good, bad = [], []

for x in mylist:
    if x is None:
        continue
    if x in goodvals:
        good.append(f)
    else:
        bad.append(f)

El problema con todas las soluciones propuestas es que escaneará y aplicará la función de filtrado dos veces. Haría una pequeña función simple como esta:

def split_into_two_lists(lst, f):
    a = []
    b = []
    for elem in lst:
        if f(elem):
            a.append(elem)
        else:
            b.append(elem)
    return a, b

De esa manera, no está procesando nada dos veces y tampoco está repitiendo el código.

Mi opinión al respecto. Propongo un perezoso, de un solo paso, partition función, que conserva el orden relativo en las subsecuencias de salida.

1. Requisitos

Supongo que los requisitos son:

• mantener el orden relativo de los elementos (por lo tanto, sin conjuntos ni diccionarios)
• evaluar la condición solo una vez para cada elemento (por lo tanto, no usar (i)filter o groupby)
• permitir el consumo perezoso de cualquiera de las secuencias (si podemos permitirnos calcularlas previamente, es probable que la implementación ingenua también sea aceptable)

2. split biblioteca

Mi partition función (presentada a continuación) y otras funciones similares se han convertido en una pequeña biblioteca:

• python-split

Es instalable normalmente a través de PyPI:

pip install --user split

Para dividir una lista basada en condiciones, use partition función:

>>> from split import partition
>>> files = [ ('file1.jpg', 33L, '.jpg'), ('file2.avi', 999L, '.avi') ]
>>> image_types = ('.jpg','.jpeg','.gif','.bmp','.png')
>>> images, other = partition(lambda f: f[-1] in image_types, files)
>>> list(images)
[('file1.jpg', 33L, '.jpg')]
>>> list(other)
[('file2.avi', 999L, '.avi')]

3. partition función explicada

Internamente, necesitamos construir dos subsecuencias a la vez, por lo que consumir solo una secuencia de salida obligará a calcular la otra también. Y necesitamos mantener el estado entre las solicitudes de los usuarios (almacenar elementos procesados ​​pero aún no solicitados). Para mantener el estado, uso dos colas de dos extremos (deques):

from collections import deque

SplitSeq la clase se encarga de la limpieza:

class SplitSeq:
    def __init__(self, condition, sequence):
        self.cond = condition
        self.goods = deque([])
        self.bads = deque([])
        self.seq = iter(sequence)

La magia sucede en su .getNext() método. es casi como .next()
de los iteradores, pero permite especificar qué tipo de elemento queremos esta vez. Detrás de escena, no descarta los elementos rechazados, sino que los coloca en una de las dos colas:

    def getNext(self, getGood=True):
        if getGood:
            these, those, cond = self.goods, self.bads, self.cond
        else:
            these, those, cond = self.bads, self.goods, lambda x: not self.cond(x)
        if these:
            return these.popleft()
        else:
            while 1: # exit on StopIteration
                n = self.seq.next()
                if cond(n):
                    return n
                else:
                    those.append(n)

Se supone que el usuario final debe usar partition función. Se necesita una función de condición y una secuencia (al igual que map o filter), y devuelve dos generadores. El primer generador construye una subsecuencia de elementos para los que se cumple la condición, el segundo construye la subsecuencia complementaria. Los iteradores y generadores permiten la división diferida incluso de secuencias largas o infinitas.

def partition(condition, sequence):
    cond = condition if condition else bool  # evaluate as bool if condition == None
    ss = SplitSeq(cond, sequence)
    def goods():
        while 1:
            yield ss.getNext(getGood=True)
    def bads():
        while 1:
            yield ss.getNext(getGood=False)
    return goods(), bads()

Elegí la función de prueba como el primer argumento para facilitar la aplicación parcial en el futuro (similar a cómo map y filter
tener la función de prueba como primer argumento).

Básicamente, me gusta el enfoque de Anders, ya que es muy general. Aquí hay una versión que pone el categorizador primero (para que coincida con la sintaxis del filtro) y usa un dictado predeterminado (se supone que es importado).

def categorize(func, seq):
    """Return mapping from categories to lists
    of categorized items.
    """
    d = defaultdict(list)
    for item in seq:
        d[func(item)].append(item)
    return d