tuple vs list python




Qual è la regola della sintassi per avere virgole finali nelle definizioni di tuple? (6)

È necessario solo per le tuple a elemento singolo per disambiguare la definizione di una tupla o un'espressione circondata da parentesi.

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

Per più di un oggetto, non è più necessario poiché è perfettamente chiaro che è una tupla. Tuttavia, la virgola finale è consentita per rendere più semplice la loro definizione utilizzando più righe. È possibile aggiungere alla fine o riorganizzare gli elementi senza rompere la sintassi perché hai lasciato fuori una virgola in caso di incidente.

per esempio,

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

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

Nel caso di una singola tupla di elementi, è richiesta la virgola finale.

a = ('foo',)

Che ne dici di una tupla con più elementi? Sembra che se la virgola finale esiste o meno, sono entrambi validi. È corretto? Avere una virgola finale è più facile da modificare secondo me. È uno stile di programmazione sbagliato?

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

È opzionale: vedi il wiki di Python .

Riepilogo: le tuple a elemento singolo richiedono una virgola finale , ma è facoltativa per le tuple a elementi multipli.


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 le parentesi. Per renderli tuple è necessario aggiungere una virgola finale. vale a dire

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

La virgola finale è necessaria solo per le tuple di un elemento. Avere una virgola finale per le tuple più grandi è una questione di stile e non è richiesta. Il suo più grande vantaggio è la pulizia dei file con tuple di grandi dimensioni che vengono spesso modificate (es. Tuple di configurazione).


Questa è una risposta semplice.

a = ("s") è una stringa

e

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

Python richiede una virgola aggiuntiva in caso di una tupla di un elemento, distinguendo tra stringa e tupla.

Ad esempio prova su console python:

a = ("s")

a = a + (1,2,3)

Traceback (ultima chiamata più recente):

File stdin, riga 1, nel modulo

TypeError: impossibile concatenare oggetti 'str' e 'tuple'


Un altro motivo che esiste è che rende più semplice scrivere codice e funzioni __repr__ . Ad esempio, se si ha un oggetto costruito come obj(arg1, arg2, ..., argn) , allora si può semplicemente scrivere obj.__repr__ as

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 era consentita, dovresti scegliere 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 avessi un caso speciale nell'ultimo termine.





tuples