Какое правило синтаксиса для использования запятых в определениях кортежей?

Question

В случае кортежа из одного элемента необходимо использовать запятую в конце.

a = ('foo',)

Как насчет кортежа с несколькими элементами?Кажется, что независимо от того, существует запятая или нет, они оба действительны.Это правильно?Заключительная запятая легче редактировать, по моему мнению.Это плохой стиль кодирования?

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

Answer 1

Требуется, чтобы одноэлементные кортежи однозначно определяли определение кортежа или выражения в круглых скобках.

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

Обратите внимание, что это относится и к другим коллекциям (например, спискам и словарям), а не только к кортежам.

Answer 2

Во всех случаях, кроме пустого кортежа, важна запятая. Круглые скобки требуются только в том случае, если это требуется по другим синтаксическим причинам: чтобы отличить кортеж от набора аргументов функции, приоритет оператора или разрешить разрыв строки.

Завершающая запятая для кортежей, списков или аргументов функций - это хороший стиль, особенно если у вас длинная инициализация, разделенная на несколько строк. Если вы всегда добавляете конечную запятую, вы не добавите в конец еще одну строку, ожидая добавления другого элемента, а просто создадите правильное выражение:

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

Предполагая, что этот список начинался как список из 2 элементов, который впоследствии был расширен, он ошибся, возможно, не сразу. Всегда включайте запятую, и вы избежите этой ловушки.

Answer 3

Еще одним преимуществом запятых является то, что они выглядят лучше.Если бы вы начали с

a = [
    1,
    2,
    3
]

и изменили его на

a = [
    1,
    2,
    3,
    4
]

Разница выглядела бы как

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

Принимая во внимание, что если бы вы начали с запятой,как

a = [
    1,
    2,
    3,
]

Тогда разница будет

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

Answer 4

Это необязательно: см. Python wiki .

Сводка: одноэлементные кортежи нуждаются в запятой , но необязательно для многоэлементных кортежей.

Answer 5

Также рассмотрим ситуацию, в которой вы хотите:

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

Answer 6

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

Answer 7

Это простой ответ.

a = ("s") - строка

, а

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

Python нуждается в дополнительной запятой в случае, если один кортеж элемента различает строку и кортеж.

Например, попробуйте это на консоли Python:

a = ("s")

a = a + (1,2,3)

Трассировка (последний последний вызов):

Файл stdin, строка 1, в модуле

TypeError: невозможно объединить объекты 'str' и 'tuple'

Answer 8

Другая причина, по которой это существует, заключается в том, что это облегчает написание кода и функции __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)

Если бы запятая не была разрешена, вам пришлось бы в особом случае использовать последний аргумент. Фактически, вы могли бы написать выше в одну строку, используя понимание списка (я написал это дольше, чтобы было легче читать). Это было бы не так легко сделать, если бы вам понадобился особый случай последнего термина.

Answer 9

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,)

Answer 10

Стиль кодирования на ваш вкус. Если вы считаете, что стандарт кодирования имеет значение, есть PEP-8 , который может вам помочь.

Что вы думаете о результате следующего выражения?

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

Да, х - это просто число.