Qual è la regola di sintassi per avere virgole finali nelle definizioni di tupla?

Nel caso di una tupla a singolo elemento, è richiesta la virgola finale.

a = ('foo',)

Che ne dici di una tupla con più elementi? Sembra che se la virgola finale esista o meno, sono entrambe valide. È corretto? Avere una virgola finale è più facile da modificare secondo me. È un cattivo stile di codifica?

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

In tutti i casi, tranne la tupla vuota, la virgola è la cosa importante. Le parentesi sono richieste solo quando richieste per altri motivi sintattici: per distinguere una tupla da un insieme di argomenti di funzione, precedenza di operatori o per consentire interruzioni di riga.

La virgola finale per tuple, elenchi o argomenti di funzioni è di buon gusto soprattutto quando si dispone di una lunga inizializzazione divisa su più righe. Se includi sempre una virgola finale, non aggiungerai un'altra riga alla fine aspettandoti di aggiungere un altro elemento e creando invece un'espressione valida:

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

Supponendo che sia iniziato come un elenco di 2 elementi che è stato successivamente esteso, è andato storto in un modo forse non immediatamente ovvio. Includere sempre la virgola finale e si evita quella trappola.

È richiesto solo per le tuple di un singolo elemento per disambiguare la definizione di una tupla o di un'espressione racchiusa tra parentesi.

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

Per più di un elemento, non è più necessario poiché è perfettamente chiaro che si tratta di una tupla. Tuttavia, la virgola finale è consentita per semplificare la definizione utilizzando più righe. Puoi aggiungere alla fine o riorganizzare gli elementi senza interrompere la sintassi perché hai tralasciato una virgola per sbaglio.

per esempio,

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

Nota che questo vale anche per altre raccolte (ad esempio elenchi e dizionari) e non solo per le tuple.

Un altro vantaggio delle virgole finali è che rende le differenze più gradevoli. Se hai iniziato con

a = [
    1,
    2,
    3
]

e lo ha cambiato in

a = [
    1,
    2,
    3,
    4
]

Il diff sarebbe simile

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

Considerando che se avessi iniziato con una virgola finale, come

a = [
    1,
    2,
    3,
]

Quindi il diff sarebbe solo

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

È opzionale: vedi il wiki di Python .

Riepilogo: le tuple a un elemento richiedono una virgola finale , ma è facoltativo per le tuple a più elementi.

Inoltre, considera la situazione in cui desideri:

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

Quindi in questo caso le parentesi esterne non sono altro che raggruppare parentesi. Per renderli tupla è necessario aggiungere una virgola finale. vale a dire

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

La virgola finale è richiesta solo per le tuple di un elemento. La presenza di una virgola finale per tuple più grandi è una questione di stile e non è richiesta. Il suo più grande vantaggio è la differenza pulita sui file con tuple di grandi dimensioni su più righe che vengono spesso modificate (ad esempio le tuple di configurazione).

È una risposta semplice.

a = ("s") è una stringa

e

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

Python necessita di una virgola aggiuntiva in caso di una tupla di un elemento, distinguere tra stringa e tupla.

Ad esempio, prova questo sulla console python:

a = ("s")

a = a + (1,2,3)

Traceback (la chiamata più recente per ultima):

File stdin, riga 1, nel modulo

TypeError: impossibile concatenare gli oggetti "str" ​​e "tuple"

Un altro motivo per cui questo esiste è che rende la generazione di codice e le __repr__funzioni più facili da scrivere. Ad esempio, se hai un oggetto costruito come obj(arg1, arg2, ..., argn), puoi semplicemente scrivere obj.__repr__come

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)

Se una virgola finale non è consentita, dovresti inserire in un caso speciale l'ultimo argomento. In effetti, potresti scrivere quanto sopra in una riga usando una lista di comprensione (l'ho scritto più a lungo per renderlo più facile da leggere). Non sarebbe così facile farlo se dovessi fare un caso speciale nell'ultimo trimestre.

PEP 8 - Guida allo stile per il codice Python - Quando utilizzare le virgole finali

Le virgole finali sono solitamente opzionali, tranne per il fatto che sono obbligatorie quando si crea una tupla di un elemento (e in Python 2 hanno la semantica per l'istruzione print). Per chiarezza, si consiglia di racchiudere quest'ultimo tra parentesi (tecnicamente ridondanti).

Sì:

FILES = ('setup.cfg',)

OK, ma confuso:

FILES = 'setup.cfg',

Quando le virgole finali sono ridondanti, sono spesso utili quando viene utilizzato un sistema di controllo della versione, quando ci si aspetta che un elenco di valori, argomenti o elementi importati venga esteso nel tempo. Lo schema consiste nel mettere ogni valore (ecc.) Su una riga da solo, aggiungendo sempre una virgola finale, e aggiungere la parentesi chiusa / parentesi / parentesi graffa sulla riga successiva. Tuttavia non ha senso avere una virgola finale sulla stessa riga del delimitatore di chiusura (tranne nel caso precedente di tuple singleton).

Sì:

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

No:

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

Lo stile di codifica è il tuo gusto, se pensi che lo standard di codifica sia importante, c'è un PEP-8 che può guidarti.

Cosa ne pensi del risultato della seguente espressione?

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

Sì, x è solo un numero.