¿Cuál es la sintaxis idiomática para anteponer a una lista corta de Python?

list.append()es la opción obvia para agregar al final de una lista. Aquí hay una explicación razonable para los desaparecidos list.prepend(). Asumiendo que mi lista es corta y las preocupaciones de rendimiento son insignificantes, es

list.insert(0, x)

o

list[0:0] = [x]

¿idiomático?

La s.insert(0, x)forma es la más común.

Sin embargo, siempre que lo vea, puede ser el momento de considerar el uso de collections.deque en lugar de una lista.

Si puede seguir el camino funcional, lo siguiente es bastante claro

new_list = [x] + your_list

Por supuesto no se ha insertado xen your_list, en lugar de haber creado una nueva lista con xpreprended a ella.

¿Cuál es la sintaxis idiomática para anteponer a una lista corta de Python?

Por lo general, no desea anteponer repetidamente a una lista en Python.

Si es corto , y no lo estás haciendo mucho ... entonces está bien.

list.insert

El list.insertpuede ser usado de esta manera.

list.insert(0, x)

Pero esto es ineficiente, porque en Python, a listes una matriz de punteros, y Python ahora debe tomar cada puntero en la lista y moverlo hacia abajo para insertar el puntero en su objeto en la primera ranura, por lo que esto es realmente eficiente para listas más bien cortas, como preguntas.

Aquí hay un fragmento de la fuente CPython donde se implementa esto, y como puede ver, comenzamos al final de la matriz y movemos todo hacia abajo por uno para cada inserción:

for (i = n; --i >= where; )
    items[i+1] = items[i];

Si desea un contenedor / lista que sea eficiente para anteponer elementos, desea una lista vinculada. Python tiene una lista doblemente vinculada, que se puede insertar al principio y al final rápidamente, se llama a deque.

deque.appendleft

A collections.dequetiene muchos de los métodos de una lista. list.sortes una excepción, por lo que dequedefinitivamente no es completamente sustituible por Liskov list.

>>> set(dir(list)) - set(dir(deque))
{'sort'}

El dequetambién tiene un appendleftmétodo (así como popleft). El dequees una cola de doble extremo y una lista doblemente enlazada: no importa la longitud, siempre lleva la misma cantidad de tiempo pretender algo. En la notación O grande, O (1) versus el tiempo O (n) para las listas. Aquí está el uso:

>>> import collections
>>> d = collections.deque('1234')
>>> d
deque(['1', '2', '3', '4'])
>>> d.appendleft('0')
>>> d
deque(['0', '1', '2', '3', '4'])

deque.extendleft

También es relevante el extendleftmétodo de deque , que antecede iterativamente:

>>> from collections import deque
>>> d2 = deque('def')
>>> d2.extendleft('cba')
>>> d2
deque(['a', 'b', 'c', 'd', 'e', 'f'])

Tenga en cuenta que cada elemento se antepondrá uno a la vez, invirtiendo efectivamente su orden.

Rendimiento de listversusdeque

Primero configuramos con algunos pretendientes iterativos:

import timeit
from collections import deque

def list_insert_0():
    l = []
    for i in range(20):
        l.insert(0, i)

def list_slice_insert():
    l = []
    for i in range(20):
        l[:0] = [i]      # semantically same as list.insert(0, i)

def list_add():
    l = []
    for i in range(20):
        l = [i] + l      # caveat: new list each time

def deque_appendleft():
    d = deque()
    for i in range(20):
        d.appendleft(i)  # semantically same as list.insert(0, i)

def deque_extendleft():
    d = deque()
    d.extendleft(range(20)) # semantically same as deque_appendleft above

y rendimiento:

>>> min(timeit.repeat(list_insert_0))
2.8267281929729506
>>> min(timeit.repeat(list_slice_insert))
2.5210217320127413
>>> min(timeit.repeat(list_add))
2.0641671380144544
>>> min(timeit.repeat(deque_appendleft))
1.5863927800091915
>>> min(timeit.repeat(deque_extendleft))
0.5352169770048931

El deque es mucho más rápido. A medida que las listas se alarguen, esperaría que una deque funcione aún mejor. Si puede usar deque extendleftprobablemente obtendrá el mejor rendimiento de esa manera.

Si alguien encuentra esta pregunta como yo, aquí están mis pruebas de rendimiento de los métodos propuestos:

Python 2.7.8

In [1]: %timeit ([1]*1000000).insert(0, 0)
100 loops, best of 3: 4.62 ms per loop

In [2]: %timeit ([1]*1000000)[0:0] = [0]
100 loops, best of 3: 4.55 ms per loop

In [3]: %timeit [0] + [1]*1000000
100 loops, best of 3: 8.04 ms per loop

Como puede ver, la insertasignación de divisiones es casi el doble de rápida que la suma explícita y los resultados son muy parecidos. Como Raymond Hettinger señaló insertes una opción más común y yo personalmente prefiero esta forma de anteponer a la lista.