¿Cuál es la regla de sintaxis para tener comas finales en las definiciones de tuplas?

119

En el caso de una tupla de un solo elemento, se requiere la coma al final.

a = ('foo',)

¿Qué pasa con una tupla con varios elementos? Parece que si la coma final existe o no, ambos son válidos. ¿Es esto correcto? Tener una coma al final es más fácil de editar en mi opinión. ¿Es un mal estilo de codificación?

a = ('foo1', 'foo2')
b = ('foo1', 'foo2',)
Stan
fuente
Aquí está la regla de sintaxis: docs.python.org/reference/expressions.html#expression-lists
Kirill

Respuestas:

73

En todos los casos, excepto en la tupla vacía, la coma es lo importante. Los paréntesis solo se requieren cuando se requieren por otras razones sintácticas: para distinguir una tupla de un conjunto de argumentos de función, precedencia de operadores o para permitir saltos de línea.

La coma final para tuplas, listas o argumentos de función es de buen estilo, especialmente cuando tiene una inicialización larga que se divide en varias líneas. Si siempre incluye una coma al final, no agregará otra línea al final esperando agregar otro elemento y, en su lugar, solo creará una expresión válida:

a = [
   "a",
   "b"
   "c"
]

Suponiendo que comenzó como una lista de 2 elementos que luego se extendió, ha salido mal de una manera quizás no inmediatamente obvia. Incluya siempre la coma final y evitará esa trampa.

Duncan
fuente
3
Por las razones expuestas anteriormente, dejar la coma puede resultar ventajoso. Por otro lado, adoptar este hábito puede provocar dolores de cabeza si también está tratando con JavaScript o JSON en otra parte de su aplicación, ya que a algunos navegadores no les gusta allí.
Cito
7
Sí, pero nunca debería construir JSON a mano, así que eso no importa, y para Javascript siempre use jslint o equivalente para detectar ese tipo de error antes de que se acerque a un navegador.
Duncan
100

Solo es necesario que las tuplas de un solo elemento eliminen la ambigüedad definiendo una tupla o una expresión entre paréntesis.

(1)  # the number 1 (the parentheses are wrapping the expression `1`)
(1,) # a 1-tuple holding a number 1

Para más de un elemento, ya no es necesario ya que está perfectamente claro que es una tupla. Sin embargo, se permite la coma al final para facilitar su definición utilizando varias líneas. Puede agregar al final o reorganizar elementos sin romper la sintaxis porque omitió una coma por accidente.

p.ej,

someBigTuple = (
                   0,
                   1,
                   2,
                   3,
                   4,
                   5,
                   6,
                   7,
                   8,
                   9,
                   10,
                   #...
                   10000000000,
               )

Tenga en cuenta que esto también se aplica a otras colecciones (por ejemplo, listas y diccionarios) y no solo a las tuplas.

Jeff Mercado
fuente
5
+1 por señalar que esto también es válido para otras cosas que no sean tuplas. Esto es muy útil para tener uno key: value,por línea y no tener en cuenta la coma al agregar cosas nuevas.
Joël
46

Otra ventaja de las comas finales es que hace que las diferencias se vean mejor. Si empezaste con

a = [
    1,
    2,
    3
]

y lo cambió a

a = [
    1,
    2,
    3,
    4
]

La diferencia se vería así

 a = [
     1,
     2,
-    3
+    3,
+    4
 ]

Mientras que si hubiera comenzado con una coma al final, como

a = [
    1,
    2,
    3,
]

Entonces la diferencia sería

 a = [
     1,
     2,
     3,
+    4,
 ]
medidor
fuente
Esto es más un comentario que una respuesta a la pregunta original, pero realmente me gusta el argumento agregado a favor de las comas finales.
Mad Physicist
13

Es opcional: consulte la wiki de Python .

Resumen: las tuplas de un solo elemento necesitan una coma al final , pero es opcional para las tuplas de varios elementos.

Dave Everitt
fuente
8

Además, considere la situación en la que desea:

>>> (('x','y'))*4                         # same as ('x','y')*4
('x', 'y', 'x', 'y', 'x', 'y', 'x', 'y')
#Expected = (('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))

Entonces, en este caso, los paréntesis externos no son más que agrupar paréntesis. Para convertirlos en tuplas, debe agregar una coma al final. es decir

>>> (('x','y'),)*4 
(('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))
MaPy
fuente
6

La coma final es necesaria solo para tuplas de un elemento. Tener una coma al final para tuplas más grandes es una cuestión de estilo y no es obligatorio. Su mayor ventaja es limpiar archivos de diferencias con tuplas grandes de varias líneas que a menudo se modifican (por ejemplo, tuplas de configuración).

Adam Zalcman
fuente
6

Esa es una respuesta simple.

a = ("s") es una cadena

y

a = ("s",) es una tupla con un elemento.

Python necesita una coma adicional en el caso de una tupla de elemento para diferenciar entre cadena y tupla.

Por ejemplo, intente esto en la consola de Python:

a = ("s")

a = a + (1,2,3)

Rastreo (llamadas recientes más última):

Archivo stdin, línea 1, en módulo

TypeError: no se pueden concatenar objetos 'str' y 'tupla'

rajni kant
fuente
4

Otra razón por la que esto existe es que hace que la generación de código y las __repr__funciones sean más fáciles de escribir. Por ejemplo, si tiene algún objeto que está construido como obj(arg1, arg2, ..., argn), entonces puede escribir obj.__repr__como

def __repr__(self):
    l = ['obj(']
    for arg in obj.args: # Suppose obj.args == (arg1, arg2, ..., argn)
        l.append(repr(arg))
        l.append(', ')
    l.append(')')
    return ''.join(l)

Si no se permitiera una coma al final, tendría que aplicar un caso especial al último argumento. De hecho, podría escribir lo anterior en una línea usando una lista de comprensión (lo he escrito más tiempo para que sea más fácil de leer). No sería tan fácil hacerlo si tuvieras un caso especial el último trimestre.

medidor
fuente
2
No habría necesidad de especial caso de que el último argumento, se podría utilizar sólo joinen ese caso: def __repr__(self): 'obj(' + ', '.join([repr(arg) for arg in obj.args]) + ')'.
Suzanne Dupéron
También ayuda con la generación de código, incluso a partir de herramientas que no están escritas en Python y no tienen funciones agradables como join.
asmeurer
2

PEP 8 - Guía de estilo para código Python - Cuándo usar comas finales

Las comas finales suelen ser opcionales, excepto que son obligatorias al hacer una tupla de un elemento (y en Python 2 tienen semántica para la declaración de impresión). Para mayor claridad, se recomienda rodear este último entre paréntesis (técnicamente redundante).

Si:

FILES = ('setup.cfg',)

OK, pero confuso:

FILES = 'setup.cfg',

Cuando las comas finales son redundantes, a menudo son útiles cuando se utiliza un sistema de control de versiones, cuando se espera que una lista de valores, argumentos o elementos importados se amplíe con el tiempo. El patrón es poner cada valor (etc.) en una línea por sí mismo, siempre agregando una coma al final, y agregar el paréntesis / corchete / llave de cierre en la siguiente línea. Sin embargo, no tiene sentido tener una coma al final en la misma línea que el delimitador de cierre (excepto en el caso anterior de tuplas singleton).

Si:

FILES = [
    'setup.cfg',
    'tox.ini',
    ]
initialize(FILES,
           error=True,
           )

No:

FILES = ['setup.cfg', 'tox.ini',]
initialize(FILES, error=True,)
Partido rápido
fuente
-5

El estilo de codificación es su gusto. Si cree que el estándar de codificación es importante, hay un PEP-8 que puede guiarlo.

¿Qué opinas del resultado de la siguiente expresión?

x = (3)
x = (3+2)
x = 2*(3+2)

Sí, x es solo un número.

Melug
fuente
1
esa es una mala manera de explicar su línea de pensamiento. Explícito es mejor que implícito.
Guilherme David da Costa