Яке правило синтаксису для наявності знаків, що знаходяться в кодах, у корінних визначеннях?

У випадку кортежу з одним елементом потрібна кома в кінці.

a = ('foo',)

А що з кортежем з кількома елементами? Здається, що незалежно від того, існують чи ні, то вони є дійсними. Це правильно? На мою думку, трелінг із комою простіше для редагування. Це поганий стиль кодування?

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

У всіх випадках, крім порожнього кортежу, важлива річ. Дужки потрібні лише тоді, коли це потрібно з інших синтаксичних причин: щоб відрізнити кортеж від набору аргументів функції, пріоритету оператора або дозволити розриви рядків.

Концева кома для кортежів, списків або аргументів функції є гарним стилем, особливо коли у вас є тривала ініціалізація, яка розділена на кілька рядків. Якщо ви завжди включаєте коду в кінці, ви не додасте інший рядок до кінця, очікуючи додати ще один елемент, а натомість просто створіть дійсний вираз:

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

Якщо припустити, що почався як список двох елементів, який згодом було розширено, він помилився, мабуть, не відразу очевидним чином. Завжди включайте коду в кінці, і ви уникаєте цієї пастки.

Потрібно лише, щоб однорядкові кортежі розмежовували, визначаючи кортеж або вираз, оточений дужками.

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

Для більш ніж одного предмета це більше не потрібно, оскільки цілком зрозуміло, що це кортеж. Однак, кома в кінці може полегшувати їх визначення за допомогою декількох рядків. Ви можете додати до кінця або переставити елементи, не порушуючи синтаксис, оскільки випадково випустили кому.

наприклад,

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

Зауважте, що це стосується й інших колекцій (наприклад, списків та словників), а не лише кортежів.

Ще одна перевага зачіпних коми - це те, що вони виглядають приємніше. Якщо ви почали з

a = [
    1,
    2,
    3
]

і змінив його на

a = [
    1,
    2,
    3,
    4
]

Різниця виглядала б так

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

Тоді якби ви починали з кінцевої коми, наприклад

a = [
    1,
    2,
    3,
]

Тоді різниця була б просто

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

Це необов'язково: див. Вікі Python .

Короткий зміст: одноелементним кортежам потрібна кодова коска , але для кортенів з декількома елементами це необов'язково .

Також врахуйте ситуацію, коли вам потрібно:

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

Тож у цьому випадку зовнішні дужки є не що інше, як групування дужок. Щоб зробити їх кортежем, вам потрібно додати кінцеву кому. тобто

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

Послідовна кома потрібна лише для одноелементних кортежів. Наявність тремової коми через більші кортежі - це питання стилю і не потрібно. Найбільша його перевага - чистий розріз у файлах із багаторядковими великими кортежами, які часто змінюються (наприклад, кортежі конфігурації).

Це проста відповідь.

a = ("s") - рядок

і

a = ("s",) - кортеж з одним елементом.

Python потребує додаткової коми у випадку, якщо один елемент кортежить, щоб розрізняти рядок і кортеж.

Наприклад, спробуйте це на консолі python:

a = ("s")

a = a + (1,2,3)

Traceback (останній останній дзвінок):

Файл stdin, рядок 1, в модулі

TypeError: не може об'єднати об'єкти 'str' та 'tuple'

Ще одна причина, що це існує, полягає в тому, що це спрощує створення коду та __repr__функції простішого запису. Наприклад, якщо у вас є якийсь об'єкт, який побудований як obj(arg1, arg2, ..., argn), ви можете просто написати obj.__repr__як

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)

Якщо кінцева кома не була дозволена, вам доведеться окремим випадком останнього аргументу. Насправді, ви можете написати вищезазначене в одному рядку, використовуючи розуміння списку (я написав це довше, щоб полегшити читання). Зробити це було б не так просто, якби вам довелося окремим випадком провести останній термін.

PEP 8 - Посібник зі стилю коду Python - Коли використовувати кінцеві коми

Зворотні коми зазвичай не є обов'язковими, за винятком того, що вони є обов'язковими при складанні кортежу з одного елемента (а в Python 2 вони мають семантику для оператора друку). Для наочності рекомендується оточити останніх у (технічно зайвих) дужках.

Так:

FILES = ('setup.cfg',)

Гаразд, але заплутано:

FILES = 'setup.cfg',

Коли пропуски коми надмірні, вони часто корисні, коли використовується система контролю версій, коли очікується, що список значень, аргументів або імпортованих елементів буде з часом розширений. Шаблон полягає в тому, щоб поставити кожне значення (тощо) на рядок самостійно, завжди додаючи коду в кінці, а в наступному рядку додати близьку дужку / дужку / дужку. Однак не має сенсу мати кінцеву кому на тій самій лінії, що і розділовий замикач (за винятком вищезазначеного випадку кортежів одномісних).

Так:

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

Немає:

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

Стиль кодування - це ваш смак. Якщо ви думаєте, що стандарт кодування має значення PEP-8, який може вас керувати.

Що ви думаєте про результат наступного вираження?

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

Так, x - це просто число.