¿Por qué se permiten las comas finales en una lista?

135

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

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

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

— Burhan Khalid
fuente

stackoverflow.com/questions/7992559/…

— Ciro Santilli 郝海东冠状病六四事件法轮功

77

También se permite una coma final en las listas en C, C ++, Java, JavaScript, etc.

— Nayuki

223

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

Cambiando:

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

a:

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

implica solo un cambio de una línea en el diff:

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

Esto supera la diferencia de varias líneas más confusa cuando se omite la coma final:

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

La ú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 en s = ['manny', 'mo', 'jackroger']lugar del resultado deseado.

— Raymond Hettinger
fuente

66

Esto tiene mucho sentido, pero realmente me sorprendería si el analizador del lenguaje fue diseñado para facilitar las diferencias.

— Burhan Khalid

94

@BurhanKhalid: los diseñadores de idiomas son programadores, y los programadores hacen muchas cosas para facilitarles la vida.

— Greg Hewgill

10

@Burhan Si no crees esa explicación, ¿qué tal si también es más simple definir la gramática de esa manera? ;) Comparar List = "[" {Item ","} "]".vs.List = "[" ({Item","}Item|)"]".

— Voo

23

Esto también facilita que otros programas generen automáticamente el código: es mucho más fácil imprimir solo "\"item\","para cada elemento que imprimir "\"item\""para cada elemento seguido ","de todos menos el último elemento.

— Adam Rosenfield

9

@Voo También pensé lo mismo, pero la última gramática debe definirse de todos modos porque todavía es una lista válida de Python.

— Alexander Suraphel

34

Es una convención sintáctica común permitir las comas finales en una matriz, los lenguajes como C y Java lo permiten, y Python parece haber adoptado esta convención para su estructura de datos de lista. Es particularmente útil cuando se genera código para llenar una lista: solo genera una secuencia de elementos y comas, no es necesario considerar el último como un caso especial que no debería tener una coma al final.

— Óscar López
fuente

30

Ayuda a eliminar cierto tipo de error. A veces es más claro escribir listas en varias 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 las comas finales y las usa, puede reorganizar fácilmente las líneas sin introducir un error.

— Keith
fuente

1

Esto es ordenado, pero puede evitarlo pre-pendiente de la coma. Lo hago todo el tiempo cuando escribo SQL

— Burhan Khalid

38

Incluso si antepone la coma a cada elemento, aún debe omitir la coma en el primero.

— Greg Hewgill

Un linter debería poder atrapar esto, ¿no?

— viki.omega9

6

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

Tu ejemplo original hubiera sido tuple('a')

— richo
fuente

('a'),es una cadena; pero mi punto era que las comas finales en las tuplas son significativas, pero en las listas todavía no parecen ser aceptadas por Python.

— Burhan Khalid

1

Se descartan silenciosamente en ambos casos, es solo que en una tupla se necesita diferenciarlo de una cuerda en el soporte.

— richo

tuple('a')Es probablemente un mal ejemplo, porque en general tuple(x)ya (x,)no son lo mismo. tuple('ab') != ('ab',). tuple('a') == ('a',)solo porque 'a'es una cadena de longitud 1.

— chepner

Del REPL: >>> ("a",) == ("a") False >>> ("ab",) == ("ab") Falso >>> ("ab", "bc",) == ("ab", "bc") Verdadero

— Seraphya

1

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.

Por lo tanto, python permite el rastreo ',' en el último elemento de la lista, para evitar diferencias adicionales que pueden causar confusión.

— Nitish Chauhan
fuente