Was ist die syntax-Regel für die abschließende Kommas im Tupel Definitionen?

In dem Fall von einem einzigen element-Tupel, das nachgestellte Komma ist erforderlich.

a = ('foo',)

Was ist ein Tupel mit mehreren Elementen? Es scheint, als ob das nachgestellte Komma vorhanden ist oder nicht, Sie sind beide gültig. Ist das richtig? Mit einem abschließenden Komma ist einfacher für die Bearbeitung meiner Meinung nach. Ist das eine schlechte coding-Stil?

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

Hier ist die syntax-Regel: docs.python.org/reference/expressions.html#expression-lists

InformationsquelleAutor Stan | 2011-11-03

66

In allen Fällen, außer dem leeren Tupel, das Komma ist wichtig. Klammern sind nur erforderlich, wenn dies für andere syntaktische Gründe: zu unterscheiden sind ein Tupel aus einer Menge von Funktionsargumente, operator-Vorrang, oder Zeilenumbrüche.

Das nachgestellte Komma für Tupel, Listen oder Funktion Argumente ist guter Stil, vor allem, wenn Sie haben eine lange Initialisierung, aufgeteilt über mehrere Zeilen. Wenn Sie immer eine nachgestellte Komma, dann werden Sie nicht fügen Sie eine weitere Zeile an das Ende erwartet, zum hinzufügen von einem anderen element, und stattdessen nur die Erstellung einer gültigen Ausdruck:
```
a = [
   "a",
   "b"
   "c"
]
```
Unter der Annahme, dass begann als eine 2-element-Liste, wurde später erweitert und es schief gegangen ist, in einem vielleicht nicht sofort offensichtliche Art und Weise. Immer auch das nachgestellte Komma und vermeiden Sie diese Falle.

Aus den oben genannten Gründen, verlassen das Komma kann von Vorteil sein. Auf der anderen Seite, die Annahme dieser Gewohnheit kann zu Kopfschmerzen führen, wenn Sie auch den Umgang mit JavaScript oder JSON an anderer Stelle in Ihrer Anwendung, da Sie von einigen Browsern nicht wie es dort ist.
Ja aber, Sie sollten nie zu konstruieren JSON von hand, so dass spielt keine Rolle, und für Javascript verwenden Sie immer jslint oder gleichwertig zu fangen, die Art von Fehler, bevor es in der Nähe einen browser.

InformationsquelleAutor Duncan
71

Ist es nur erforderlich, für Einzel-item Tupel eindeutig machen Definition ein Tupel oder einen Ausdruck umgeben von Klammern.
```
(1)  # the number 1 (the parentheses are wrapping the expression `1`)
(1,) # a 1-tuple holding a number 1
```
Für mehr als ein Element, ist es nicht mehr nötig, da ist es vollkommen klar, es ist ein Tupel. Allerdings, das nachgestellte Komma ist erlaubt, um die Definition über mehrere Zeilen einfacher. Man könnte hinzufügen, um das Ende oder die Elemente neu anordnen, ohne die syntax, da Sie Links ein Komma auf dem Unfall.

z.B.,
```
someBigTuple = (
                   0,
                   1,
                   2,
                   3,
                   4,
                   5,
                   6,
                   7,
                   8,
                   9,
                   10,
                   #...
                   10000000000,
               )
```
Beachten Sie, dass dies gilt auch für andere Sammlungen (z.B., Listen und Wörterbücher) zu und nicht nur-Tupeln.

+1 für den Hinweis hin, dass dies gilt auch für andere Sachen als Tupel. Das ist sooo nützlich, da man key: value, pro Zeile, und nicht Komma, wenn Sie neue Sachen.

InformationsquelleAutor Jeff Mercado
44

Ein weiterer Vorteil des nachgestellten Kommas ist, dass es macht diffs schöner Aussehen. Wenn Sie begann mit
```
a = [
    1,
    2,
    3
]
```
verändert und es zu
```
a = [
    1,
    2,
    3,
    4
]
```
Diff Aussehen würde
```
 a = [
     1,
     2,
-    3
+    3,
+    4
 ]
```
In der Erwägung, dass, wenn Sie begonnen hatte, mit einem abschließenden Komma, wie
```
a = [
    1,
    2,
    3,
]
```
Dann das diff wäre nur
```
 a = [
     1,
     2,
     3,
+    4,
 ]
```
Dies ist eigentlich mehr ein Kommentar als eine Antwort auf die ursprüngliche Frage, aber ich mag den zusätzlichen argument zugunsten des nachgestellten Kommas.

InformationsquelleAutor asmeurer
12

Es ist optional: siehe Python wiki.

Zusammenfassung: einelementige Tupel brauchen eine nachgestellte Komma, aber es ist optional für multiple-element-Tupel.

InformationsquelleAutor Dave Everitt

Bedenken Sie außerdem, die situation, wo Sie wollen:

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

So, in diesem Fall die äußeren Klammern sind nichts anderes als die Gruppierung mit Klammern.
Um diese Tupel müssen Sie eine nachgestellte Komma. also

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

InformationsquelleAutor MaPy

6

Nachgestellte Komma ist erforderlich für die ein-element-Tupel nur. Mit einem abschließenden Komma für größere Tupel ist eine Frage des Stils und ist nicht erforderlich. Seine größte Vorteil ist die saubere diff auf Dateien mit multi-line-große Tupel, die Häufig modifiziert werden (z.B. Konfiguration Tupel).

InformationsquelleAutor Adam Zalcman
5

Das ist eine einfache Antwort.

a = ("s") ist eine Zeichenfolge, die

und

a = ("s") ist ein Tupel mit einem element.

Python benötigt ein zusätzliches Komma im Falle einer element-Tupel auf, die Unterscheidung zwischen Strings und Tupel.

Zum Beispiel versuchen, diese auf python-Konsole:

a = ("s")

a = a + (1,2,3)

Traceback (most recent call last):

Datei "stdin", line 1, in-Modul

TypeError: cannot concatenate 'str' und 'Tupel' Objekte

InformationsquelleAutor rajni kant
4

Einen anderen Grund, dass dieser existiert, ist, dass es macht die code-Generierung und __repr__ Funktionen einfacher zu schreiben. Zum Beispiel, wenn Sie einige Objekt, das gebaut ist wie obj(arg1, arg2, ..., argn), dann kann man nur schreiben obj.__repr__ als
```
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)
```
Wenn eine nachgestellte Komma war nicht erlaubt, hätte Sie speziellen Fall ist das Letzte argument. In der Tat, könnten Sie schreiben, der oben in eine Linie mit Hilfe einer list comprehension (ich habe es geschrieben, aus länger, um es einfacher zu Lesen). Wäre es nicht so einfach zu tun, wenn Sie hatte zu besonderen Fall der letzten Legislaturperiode.

Gäbe es keine Notwendigkeit besonderer Fall ist das Letzte argument, man konnte einfach join in diesem Fall: def __repr__(self): 'obj(' + ', '.join([repr(arg) for arg in obj.args]) + ')'.
Es hilft auch bei der code-Generierung, auch von tools, die nicht in Python geschrieben und nicht die netten Funktionen wie join.

InformationsquelleAutor asmeurer
1

PEP 8 -- Style Guide for Python Code - Wann Trailing Kommas

Trailing Kommas sind in der Regel optional, außer Sie sind zwingend, wenn ein Tupel aus einem element (und in Python 2 haben Sie die Semantik für die print-Anweisung). Für Klarheit, es ist empfohlen zu umgeben, die letztere in (technisch redundant) Klammern.

Ja:
```
FILES = ('setup.cfg',)
```
OK, aber verwirrend:
```
FILES = 'setup.cfg',
```
Wenn trailing Kommas sind überflüssig, Sie sind oft hilfreich, wenn ein versions-Kontroll-system wird verwendet, wenn eine Liste von Werten, Argumenten oder importierten Elemente wird erwartet, dass im Laufe der Zeit erweitert. Das Muster ist, jedem Wert (etc.) auf einer Linie von selbst, immer zusätzlich eine nachgestellte Komma, und fügen Sie die schließende Klammer/Klammer/Klammer auf die nächste Zeile. Allerdings ist es nicht sinnvoll, eine nachgestellte Komma auf die gleiche Zeile wie die schließende Trennzeichen (außer im oben genannten Fall der singleton-Tupel).

Ja:
```
FILES = [
    'setup.cfg',
    'tox.ini',
    ]
initialize(FILES,
           error=True,
           )
```
No:
```
FILES = ['setup.cfg', 'tox.ini',]
initialize(FILES, error=True,)
```
InformationsquelleAutor Uri
-4

Coding style ist Ihr Geschmack, Wenn Sie denken, coding standard Fragen gibt es eine PEP-8 , kann guide Sie.

Was haltet Ihr von dem Ergebnis des folgenden Ausdrucks?
```
x = (3)
x = (3+2)
x = 2*(3+2)
```
Jau, x ist nur eine Zahl.

das ist eine schlechte Art zu erklären, Ihre Linie des Denkens. Explizit ist besser als implizit.

InformationsquelleAutor Melug

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.