Qual é a sintaxe idiomática para anexar uma pequena lista python?

list.append()é a escolha óbvia para adicionar ao final de uma lista. Aqui está uma explicação razoável para os desaparecidos list.prepend(). Supondo que minha lista seja curta e as preocupações com o desempenho sejam insignificantes, é

list.insert(0, x)

ou

list[0:0] = [x]

idiomático?

O s.insert(0, x)formulário é o mais comum.

Porém, sempre que você o vir, talvez seja hora de considerar o uso de um collections.deque em vez de uma lista.

Se você pode seguir o caminho funcional, o seguinte é bem claro

new_list = [x] + your_list

É claro que você não inseriu , xem your_listvez disso, criou uma nova lista com a xpré-prevista.

Qual é a sintaxe idiomática para anexar uma pequena lista python?

Geralmente, você não deseja anexar repetidamente uma lista em Python.

Se for curto e você não estiver fazendo muito ... então tudo bem.

list.insert

O list.insertpode ser usado dessa maneira.

list.insert(0, x)

Mas isso é ineficiente, porque, em Python, a listé uma matriz de ponteiros, e agora o Python deve pegar todos os ponteiros da lista e movê-lo para baixo em um para inserir o ponteiro no seu objeto no primeiro slot, portanto, isso é realmente apenas eficiente para listas bastante curtas, como você pede.

Aqui está um trecho da fonte CPython onde isso é implementado - e como você pode ver, começamos no final da matriz e movemos tudo para baixo em um para cada inserção:

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

Se você deseja um contêiner / lista eficiente na adição de elementos, deseja uma lista vinculada. O Python tem uma lista duplamente vinculada, que pode ser inserida no início e no final rapidamente - é chamada de a deque.

deque.appendleft

A collections.dequetem muitos dos métodos de uma lista. list.sorté uma exceção, tornando dequedefinitivamente não inteiramente Liskov substituível list.

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

O dequetambém possui um appendleftmétodo (assim como popleft). O dequeé um deque e uma lista duplamente vinculada - não importa o comprimento, ele sempre leva a mesma quantidade de tempo para preprend algo. Na notação O grande, O (1) versus o tempo O (n) das listas. Aqui está o 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

Também relevante é o extendleftmétodo de deque , que precede iterativamente:

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

Observe que cada elemento será anexado um de cada vez, revertendo efetivamente sua ordem.

Desempenho de listversusdeque

Primeiro, configuramos com alguns anexos 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

e desempenho:

>>> 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

O deque é muito mais rápido. À medida que as listas ficam mais longas, eu esperaria que um deque tivesse um desempenho ainda melhor. Se você pode usar o deque, extendleftprovavelmente obterá o melhor desempenho dessa maneira.

Se alguém encontrar essa pergunta como eu, aqui estão meus testes de desempenho dos métodos propostos:

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 você pode ver, a insertatribuição de fatias é quase duas vezes mais rápida que a adição explícita e os resultados são muito próximos. Como Raymond Hettinger notou, inserté uma opção mais comum e eu, pessoalmente, prefiro essa maneira de acrescentar à lista.