Jaka jest reguła składni dotycząca umieszczania końcowych przecinków w definicjach krotek?

W przypadku krotki jednoelementowej wymagany jest końcowy przecinek.

a = ('foo',)

A co z krotką z wieloma elementami? Wydaje się, że niezależnie od tego, czy końcowy przecinek istnieje, czy nie, oba są ważne. Czy to jest poprawne? Moim zdaniem końcowy przecinek jest łatwiejszy do edycji. Czy to zły styl kodowania?

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

We wszystkich przypadkach z wyjątkiem pustej krotki przecinek jest ważny. Nawiasy są wymagane tylko wtedy, gdy są wymagane z innych powodów składniowych: aby odróżnić krotkę od zestawu argumentów funkcji, pierwszeństwo operatorów lub aby umożliwić podziały wierszy.

Końcowy przecinek dla krotek, list lub argumentów funkcji jest dobrym stylem, zwłaszcza gdy masz długą inicjalizację, która jest podzielona na wiele wierszy. Jeśli zawsze umieszczasz końcowy przecinek, nie dodasz kolejnej linii na końcu oczekując dodania kolejnego elementu, a zamiast tego po prostu utworzysz prawidłowe wyrażenie:

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

Zakładając, że zaczęło się to jako lista 2-elementowa, która została później rozszerzona, poszła źle w być może nie od razu oczywisty sposób. Zawsze dołączaj przecinek na końcu i unikaj tej pułapki.

Tylko w przypadku krotek jednoelementowych wymagane jest ujednoznacznienie definicji krotki lub wyrażenia otoczonego nawiasami.

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

W przypadku więcej niż jednej pozycji nie jest to już konieczne, ponieważ jest całkowicie jasne, że jest to krotka. Jednak końcowy przecinek może ułatwić ich definiowanie za pomocą wielu wierszy. Możesz dodać na końcu lub zmienić kolejność elementów bez łamania składni, ponieważ przez przypadek pominięto przecinek.

na przykład,

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

Zwróć uwagę, że dotyczy to również innych kolekcji (np. List i słowników), a nie tylko krotek.

Kolejną zaletą końcowych przecinków jest to, że sprawiają, że różnice wyglądają ładniej. Jeśli zacząłeś z

a = [
    1,
    2,
    3
]

i zmieniłem to na

a = [
    1,
    2,
    3,
    4
]

Różnica wyglądałaby tak

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

Natomiast gdybyś zaczął od końcowego przecinka, np

a = [
    1,
    2,
    3,
]

Wtedy różnica byłaby po prostu

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

Jest to opcjonalne: zobacz wiki Pythona .

Podsumowanie: krotki jednoelementowe wymagają końcowego przecinka , ale w przypadku krotek wieloelementowych jest to opcjonalne .

Weź również pod uwagę sytuację, w której chcesz:

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

Zatem w tym przypadku zewnętrzne nawiasy są niczym innym jak nawiasami grupującymi. Aby uczynić je krotką, musisz dodać na końcu przecinek. to znaczy

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

Końcowy przecinek jest wymagany tylko w przypadku krotek jednoelementowych. Umieszczenie końcowego przecinka dla większych krotek jest kwestią stylu i nie jest wymagane. Jego największą zaletą jest czyste różnice w plikach z wieloliniowymi dużymi krotkami, które są często modyfikowane (np. Krotki konfiguracyjne).

To prosta odpowiedź.

a = („s”) to ciąg

i

a = ("s",) to krotka z jednym elementem.

Python potrzebuje dodatkowego przecinka w przypadku krotki jednego elementu, aby rozróżnić ciąg i krotkę.

Na przykład spróbuj tego na konsoli Pythona:

a = („s”)

a = a + (1, 2, 3)

Traceback (ostatnie ostatnie połączenie):

Plik stdin, wiersz 1, w module

TypeError: nie można łączyć obiektów „str” i „tuple”

Innym powodem, dla którego istnieje, jest to, że ułatwia generowanie kodu i __repr__funkcje. Na przykład, jeśli masz jakiś obiekt, który jest tak zbudowany obj(arg1, arg2, ..., argn), możesz po prostu napisać obj.__repr__jako

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)

Jeśli końcowy przecinek nie był dozwolony, ostatni argument musiałby być oznaczony wielkością liter. W rzeczywistości możesz napisać powyższe w jednym wierszu, używając funkcji list (napisałem to dłużej, aby ułatwić czytanie). Nie byłoby to takie łatwe, gdybyś musiał zająć się specjalną sprawą w ostatnim semestrze.

PEP 8 - Przewodnik po stylu dla kodu w Pythonie - Kiedy używać końcowych przecinków

Końcowe przecinki są zwykle opcjonalne, z wyjątkiem tego, że są obowiązkowe podczas tworzenia krotki jednego elementu (aw Pythonie 2 mają semantykę dla instrukcji print). Dla jasności zaleca się ujęcie tego ostatniego w (technicznie zbędne) nawiasy.

Tak:

FILES = ('setup.cfg',)

OK, ale mylące:

FILES = 'setup.cfg',

Gdy końcowe przecinki są zbędne, często są pomocne, gdy używany jest system kontroli wersji, gdy lista wartości, argumentów lub importowanych elementów ma zostać rozszerzona w czasie. Wzorzec polega na umieszczeniu każdej wartości (itp.) W osobnym wierszu, zawsze dodając końcowy przecinek i dodając nawias zamykający / nawias klamrowy / nawias w następnej linii. Jednak nie ma sensu umieszczanie końcowego przecinka w tym samym wierszu co ogranicznik zamykający (z wyjątkiem powyższego przypadku krotek pojedynczych).

Tak:

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

Nie:

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

Styl kodowania to Twój gust. Jeśli uważasz, że standard kodowania ma znaczenie, istnieje PEP-8, który może Cię poprowadzić.

Co myślisz o wyniku następującego wyrażenia?

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

Tak, x to tylko liczba.