enum - python reverse list

Legibilidad de las tuplas:[0,0] vs(0,0)

Question

Estoy usando Python desde algunas veces y estoy descubriendo la forma "pirónica" de codificar. Estoy usando muchas tuplas en mi código, la mayoría de ellas son posiciones polares o cartesianas.

Me encontré escribiendo esto:

window.set_pos([18,8])

en lugar de esto :

window.set_pos((18,8))

para deshacerme del doble paréntesis me resultó difícil de leer.

Parece que Python está haciendo automáticamente la conversión de tipo de lista a tupla, ya que mi código funciona correctamente.

¿Pero es una buena manera de codificar? ¿Tiene algún consejo de presentación que pueda usar para escribir código legible?

Gracias de antemano por sus respuestas seguramente esclarecedoras.

Answer 1

Dudo seriamente que las tuplas vs. listas hagan una diferencia notable en el rendimiento en su caso. No hagas microoptimizaciones a menos que tu perfilador lo diga. La legibilidad es una prioridad.

list y tuple son ambos tipos de secuencia .

Semánticamente las tuplas pueden ser preferibles (ver Tuplas tienen estructura, las listas tienen orden ). La posición es un objeto único que tiene atributos x, y.

Las listas visuales pueden ser más fáciles de leer en este caso.

Lo que sea que elijas solo sé consistente .

Compruebe si la window admite lo siguiente:

window.pos = 18, 8

Una posible forma de implementarlo es hacer que la pos una property y vincular set_pos() como un configurador.

Answer 2

En mi opinión, la única ventaja de usar (18,8) sobre [18,8] es que un objeto de tupla es inmutable y puede estar seguro de que no se cambiará dentro de la función que se le ha pasado, mientras que [18,8] puede ser cambiado facilmente

Answer 3

Python no está realizando ninguna conversión automática de lista a tupla, a menos que el método set_pos lo haga explícitamente. La tupla y la lista tienen protocolos muy similares, por lo que tienden a ser intercambiables dentro de ese protocolo. Aún puede romper cosas, en particular porque la tupla es un elemento inmutable que se puede romper y una lista no.

Para responder a su pregunta, simplemente escriba

window.set_pos( (18,18) )

Los espacios propios hacen milagros con estilo de codificación.

Answer 4

Si desea enfatizar el hecho de que su parámetro es una tupla, puede convertirlo explícitamente:

window.set_pot(tuple([18, 18]))

Answer 5

Tendré cuidado de evitar las tuplas a favor de las listas en todas partes. ¿Alguna vez has usado el módulo dis ? Observe lo que Python está haciendo a nivel de bytecode cuando hace una lista de versos haciendo una tupla:

>>> def f():
...     x = [1,2,3,4,5,6,7]
...     return x
... 
>>> def g():
...     x = (1,2,3,4,5,6,7)
...     return x
... 
>>> import dis
>>> dis.dis(f)
  2           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 LOAD_CONST               4 (4)
             12 LOAD_CONST               5 (5)
             15 LOAD_CONST               6 (6)
             18 LOAD_CONST               7 (7)
             21 BUILD_LIST               7
             24 STORE_FAST               0 (x)

  3          27 LOAD_FAST                0 (x)
             30 RETURN_VALUE     
>>>
>>>   
>>> dis.dis(g)
  2           0 LOAD_CONST               8 ((1, 2, 3, 4, 5, 6, 7))
              3 STORE_FAST               0 (x)

  3           6 LOAD_FAST                0 (x)
              9 RETURN_VALUE   

Aunque probablemente nunca será un problema en una aplicación GUI (como parece ser su ejemplo), por razones de rendimiento, es posible que desee tener cuidado al hacerlo en cualquier parte del código.

Answer 6

Tu dices

Parece que Python está haciendo automáticamente la conversión de tipo de lista a tupla

Eso es dudoso. Dado que las listas y las tuplas son tipos de secuencia , ambos implementan muchos de los mismos comportamientos, y cualquier biblioteca de GUI que esté utilizando no debe necesitar ninguno de los comportamientos de solo listas.

Probablemente esté bien hacer esto en muchos casos, pero tenga en cuenta que las listas ocupan un poco más de espacio que las tuplas:

>>> sys.getsizeof((1, 2))
72
>>> sys.getsizeof([1, 2])
88

Y puede ser más lento que las tuplas en algunas cosas:

>>> lst, tup = [1, 2], (1, 2)
>>> def unpack(x):
...     a, b = x
...     
>>> %timeit unpack(tup)
10000000 loops, best of 3: 163 ns per loop
>>> %timeit unpack(lst)
10000000 loops, best of 3: 172 ns per loop

Estas son diferencias muy pequeñas que no importarán hasta que alcance escalas mucho más grandes, como en miles de millones de llamadas, por lo que la compensación podría valer la pena.

Sin embargo, no veo que la gente haga esto muy a menudo. Parece un buen truco de legibilidad, pero podría tener consecuencias inesperadas en algunas circunstancias. Por ejemplo, si pasa una lista que pretende usar más tarde, debe tener cuidado de no modificarla dentro de la función. Finalmente, como JF Sebastian señala acertadamente, las tuplas y las listas tienden a significar cosas ligeramente diferentes; usarlos de manera no convencional podría anular el aumento de la legibilidad que busca.