python - print - ¿Por qué se permiten las comillas finales en una lista?

print en python

Question

Tengo curiosidad por saber por qué en Python una coma al final de una lista es una sintaxis válida, y parece que Python simplemente la ignora:

>>> [''a'',''b'',]
[''a'', ''b'']

Tiene sentido cuando es una tupla ya que (''a'') y (''a'',) son dos cosas diferentes, ¿pero en listas?

Answer 1

Ayuda a eliminar un cierto tipo de error. A veces es más claro escribir listas en múltiples líneas. Pero en el mantenimiento posterior, es posible que desee reorganizar los elementos.

l1 = [
        1,
        2,
        3,
        4,
        5
]

# Now you want to rearrange

l1 = [
        1,
        2,
        3,
        5
        4,
]

# Now you have an error

Pero si permite comas finales y las usa, puede reorganizar las líneas fácilmente sin introducir un error.

Answer 2

Es una convención sintáctica común permitir comillas finales en una matriz, idiomas como C y Java lo permiten, y Python parece haber adoptado esta convención para su estructura de datos de lista. Es particularmente útil al generar código para rellenar una lista: simplemente genere una secuencia de elementos y comas, sin necesidad de considerar la última como un caso especial que no debería tener una coma al final.

Answer 3

La razón principal es hacer que diff sea menos complicado. Por ejemplo, tienes una lista:

list = [
    ''a'',
    ''b'',
    ''c''
]

y quieres agregarle otro elemento. Entonces terminarás haciendo esto:

list = [
    ''a'',
    ''b'',
    ''c'',
    ''d''
]

por lo tanto, diff mostrará que se han cambiado dos líneas, primero agregando '','' en línea con ''c'' y agregando ''d'' en la última línea.

Entonces, python permite rastrear '','' en el último elemento de la lista, para evitar diferencias adicionales que pueden causar confusión.

Answer 4

Las principales ventajas son que hace que las listas de líneas múltiples sean más fáciles de editar y que reduce el desorden en los diffs.

Cambiando:

s = [''manny'',
     ''mo'',
     ''jack'',
]

a:

s = [''manny'',
     ''mo'',
     ''jack'',
     ''roger'',
]

implica solo un cambio de una línea en la diferencia:

  s = [''manny'',
       ''mo'',
       ''jack'',
+      ''roger'',
  ]

Esto supera la diferencia de línea múltiple más confusa cuando se omite la coma final:

  s = [''manny'',
       ''mo'',
-      ''jack''
+      ''jack'',
+      ''roger''
  ]

Esta última diferencia hace que sea más difícil ver que solo se agregó una línea y que la otra línea no cambió el contenido.

También reduce el riesgo de hacer esto:

s = [''manny'',
     ''mo'',
     ''jack''
     ''roger''  # Added this line, but forgot to add a comma on the previous line
]

y desencadenando una concatenación literal de cadena implícita , produciendo s = [''manny'', ''mo'', ''jackroger''] lugar del resultado deseado.

Answer 5

Una tupla es diferente porque (''a'') se expande usando la continuación implícita y () s como operador de precedencia, mientras que (''a'',) refiere a una longitud de 1 tupla.

Tu ejemplo original habría sido tuple(''a'')