comprehension - set() python

[] y{} vs list() y dict(), ¿cuál es mejor?

Question

Entiendo que ambos son esencialmente lo mismo, pero en términos de estilo, ¿cuál es el mejor (más Pythonic) para usar para crear una lista vacía o dict?

Answer 1

[] y {} son mejores

list () es inherentemente más lento que [] y dict () es intrínsecamente más lento que {},

Porque

1. Hay búsqueda de símbolos (¡no hay manera de que python sepa de antemano si no solo redefiniste la lista para que sea otra cosa!),

2. Hay una invocación de función,

3. Luego tiene que verificar si se pasó un argumento iterable (para que pueda crear una lista con elementos de él)

En la mayoría de los casos, la diferencia de velocidad no hará ninguna diferencia práctica.

( source )

Answer 2

Como no se menciona en la Guía de estilo de Python , puede usar el estilo que desee, es una cuestión de gusto personal.

Answer 3

El dict literal puede ser un poco más rápido ya que su bytecode es más corto:

In [1]: import dis
In [2]: a = lambda: {}
In [3]: b = lambda: dict()

In [4]: dis.dis(a)
  1           0 BUILD_MAP                0
              3 RETURN_VALUE

In [5]: dis.dis(b)
  1           0 LOAD_GLOBAL              0 (dict)
              3 CALL_FUNCTION            0
              6 RETURN_VALUE

Lo mismo se aplica a la list frente a []

Answer 4

En el caso de la diferencia entre [] y list (), hay una trampa que no he visto que nadie más señale. Si usa un diccionario como miembro de la lista, los dos darán resultados completamente diferentes:

In [1]: foo_dict = {"1":"foo", "2":"bar"}

In [2]: [foo_dict]
Out [2]: [{''1'': ''foo'', ''2'': ''bar''}]

In [3]: list(foo_dict)
Out [3]: [''1'', ''2''] 

Answer 5

En mi humilde opinión, el uso de list() y dict() hace que tu Python se vea como C. Ugh.

Answer 6

En mi opinión, [] y {} son las formas más pitónicas y legibles de crear listas vacías / dicts.

Tenga cuidado con set() , por ejemplo:

this_set = {5}
some_other_set = {}

Puede ser confuso El primero crea un conjunto con un elemento, el segundo crea un dict vacío y no un conjunto.

Answer 7

En términos de velocidad, no es competencia para listas vacías / dicts:

>>> from timeit import timeit
>>> timeit("[]")
0.040084982867934334
>>> timeit("list()")
0.17704233359267718
>>> timeit("{}")
0.033620194745424214
>>> timeit("dict()")
0.1821558326547077

y para no-vacío:

>>> timeit("[1,2,3]")
0.24316302770330367
>>> timeit("list((1,2,3))")
0.44744206316727286
>>> timeit("list(foo)", setup="foo=(1,2,3)")
0.446036018543964
>>> timeit("{''a'':1, ''b'':2, ''c'':3}")
0.20868602015059423
>>> timeit("dict(a=1, b=2, c=3)")
0.47635635255323905
>>> timeit("dict(bar)", setup="bar=[(''a'', 1), (''b'', 2), (''c'', 3)]")
0.9028228448029267

Además, usando la notación de corchetes, use listas y comprensiones de diccionarios, lo cual puede ser una razón suficiente.

Answer 8

Es principalmente una cuestión de elección la mayor parte del tiempo. Es una cuestión de preferencia.

Sin embargo, tenga en cuenta que si tiene teclas numéricas, por ejemplo, no puede hacerlo:

mydict = dict(1="foo", 2="bar")

Tu tienes que hacer:

mydict = {"1":"foo", "2":"bar"}

Answer 9

hay una diferencia de comportamiento entre [] y list () como muestra el siguiente ejemplo. Necesitamos usar list () si queremos que se devuelva la lista de números, de lo contrario, obtenemos un objeto de mapa. Sin embargo, no estoy seguro de cómo explicarlo.

sth = [(1,2), (3,4),(5,6)]
sth2 = map(lambda x: x[1], sth) 
print(sth2) # print returns object <map object at 0x000001AB34C1D9B0>

sth2 = [map(lambda x: x[1], sth)]
print(sth2) # print returns object <map object at 0x000001AB34C1D9B0>
type(sth2) # list 
type(sth2[0]) # map

sth2 = list(map(lambda x: x[1], sth))
print(sth2) #[2, 4, 6]
type(sth2) # list
type(sth2[0]) # int

Answer 10

timeit no parece dar tiempo exacto. Según el benchmark timeit mencionado anteriormente para dict (), parece tomar ~ 200ms, que es mucho más lento que las llamadas http normales. Intenta ejecutar en shell, dict () y luego timeit ("dict ()"), verás una diferencia visible en la ejecución; timeit ("dict ()") lleva más tiempo. Copie y pegue la siguiente pieza de código y ejecute en shell, no verá mucha diferencia en {} y dict ().

    from datetime import datetime
    then = datetime.now()
    a = dict()
    now = datetime.now()
    print then
    print now

    then = datetime.now()
    b = {}
    now = datetime.now()
    print then
    print now