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

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',)

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.

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.

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,
 ]

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.

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'))

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).

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'

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.

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,)

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.