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

python tutorial

Question

En el caso de una sola tupla de elemento, se requiere la coma final.

a = (''foo'',)

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

a = (''foo1'', ''foo2'')
b = (''foo1'', ''foo2'',)

Answer 1

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 agrupaciones entre paréntesis. Para hacer que sean tuplas, necesitas agregar una coma final. es decir

>>> ((''x'',''y''),)*4 
((''x'', ''y''), (''x'', ''y''), (''x'', ''y''), (''x'', ''y''))

Answer 2

El estilo de codificación es tu gusto. Si crees que la norma de codificación importa, existe un PEP-8 que puede guiarte.

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

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

Sí, x es solo un número.

Answer 3

En todos los casos, excepto la tupla vacía, la coma es lo importante. Los paréntesis solo se requieren cuando sea necesario por otros motivos sintácticos: para distinguir una tupla de un conjunto de argumentos de funciones, la precedencia del operador o para permitir saltos de línea.

La coma final para tuplas, listas o argumentos de funciones es un buen estilo, especialmente cuando tiene una inicialización larga que se divide en varias líneas. Si siempre incluye una coma final, no agregará otra línea hasta el 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 ido mal de una manera quizás no inmediatamente obvia. Siempre incluya la coma final y evite esa trampa.

Answer 4

Es opcional: mira la wiki de Python .

Resumen: las tuplas de un solo elemento necesitan una coma final , pero es opcional para las tuplas de elementos múltiples.

Answer 5

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 un elemento de tupla, 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 puede concatenar objetos ''str'' y ''tuple''

Answer 6

Otra razón por la que esto existe es que hace que las funciones de generación de código y __repr__ más fáciles de escribir. Por ejemplo, si tiene algún objeto que está construido como obj(arg1, arg2, ..., argn) , entonces puede simplemente 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 hacer un caso especial en el último argumento. De hecho, puedes escribir lo anterior en una línea usando una lista de comprensión (la he escrito más tiempo para que sea más fácil de leer). No sería tan fácil hacer eso si tuviera que hacer un caso especial en el último trimestre.

Answer 7

Otra ventaja de las comillas finales es que hace que las diferencias se vean mejor. Si comenzaste con

a = [
    1,
    2,
    3
]

y lo cambié a

a = [
    1,
    2,
    3,
    4
]

La diferencia se vería como

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

Mientras que si hubiera comenzado con una coma final, como

a = [
    1,
    2,
    3,
]

Entonces la diferencia sería solo

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

Answer 8

Se requiere una coma final para tuplas de un solo elemento. Tener una coma final para tuplas más grandes es una cuestión de estilo y no es obligatorio. Su mayor ventaja es limpiar diff en archivos con múltiples tuplas de líneas múltiples que a menudo se modifican (por ejemplo, tuplas de configuración).

Answer 9

Solo es necesario para las tuplas de elementos individuales para eliminar la ambigüedad definiendo una tupla o una expresión rodeada de 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, la coma final puede hacer que sea más fácil definirlas utilizando múltiples 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 se aplica también a otras colecciones (p. Ej., Listas y diccionarios) y no solo a las tuplas.