Python 元组定义中有尾随逗号的语法规则是什么？

对于单个元素元组，后面的逗号是必需的

a = ('foo',)

有多个元素的元组呢？不管后面的逗号是否存在，它们都是有效的。这是正确的吗？在我看来，后面加逗号更容易编辑。这是一种糟糕的编码风格吗

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

---

只有一个元素元组需要尾随逗号。对于较大的元组，尾随逗号是一个样式问题，不是必需的。它最大的优点是在具有经常修改的多行大型元组（例如，配置元组）的文件上具有清晰的差异。

只需要单个项元组就可以消除定义元组或由括号包围的表达式的歧义

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

对于不止一个项，它不再是必需的，因为很明显它是一个元组。但是，允许使用尾随逗号，以便更轻松地使用多行定义它们。您可以在不破坏语法的情况下添加到末尾或重新排列项目，因为您在意外事件中漏掉了逗号

e、 g

---

请注意，这也适用于其他集合（例如列表和字典），而不仅仅是元组。

在除空元组以外的所有情况下，逗号都很重要。只有在出于其他语法原因需要时才需要括号：将元组与一组函数参数区分开来、运算符优先级或允许换行

元组、列表或函数参数的尾随逗号是一种很好的样式，特别是当您有一个长的初始化，并拆分为多行时。如果始终包含一个尾随逗号，则不会在末尾添加另一行，希望添加另一个元素，而只是创建一个有效的表达式：

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

假设一开始是一个2元素的列表，后来又扩展了它，那么它可能会以一种不太明显的方式出错。始终包含尾随逗号，这样可以避免该陷阱。

这是可选的：请参阅

---

摘要：单元素元组需要一个尾随逗号，但对于多元素元组，它是可选的。

如果您认为编码标准很重要，那么编码风格就是您的喜好，有一个标准可以指导您

你觉得下面这个表达式的结果如何

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

---

是的，x只是一个数字。

存在这种情况的另一个原因是它使代码生成和

\uuuu repr\uuu

函数更容易编写。例如，如果您有一个像

obj（arg1，arg2，…，argn）

那样构建的对象，那么您可以将

obj.\uu repr\uu

作为

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)

---

如果不允许使用尾随逗号，则必须对最后一个参数使用特殊情况。事实上，您可以使用列表理解将上述内容写在一行中（为了便于阅读，我将其写得更长）。如果在上一学期中必须使用特殊情况，那么要做到这一点就不那么容易了。

尾随逗号的另一个优点是它使差异看起来更好。如果你从

a = [
    1,
    2,
    3
]

改成

a = [
    1,
    2,
    3,
    4
]

这个差别看起来像

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

而如果你是以逗号开头的，比如

a = [
    1,
    2,
    3,
]

那么差别就只是

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

---

这是一个简单的答案

a=（“s”）

是一个字符串

及

a=（“s”），是一个包含一个元素的元组

Python在一个元素元组的情况下需要额外的逗号来区分字符串和元组

例如，在python控制台上尝试以下操作：

a = ("s")

a  = a + (1,2,3)

Traceback (most recent call last):

File stdin, line 1, in module

TypeError: cannot concatenate 'str' and 'tuple' objects

也要考虑你想要的情况：
>>> (('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'))

所以在这种情况下，外括号只不过是分组括号。
要使它们成为元组，您需要添加一个尾随逗号。i、 e

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


尾随逗号通常是可选的，除非它们在生成一个元素的元组时是必需的（在Python 2中，它们具有print语句的语义）。为清楚起见，建议将后者用括号括起来（技术上多余）

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

是的：

好吧，但令人困惑的是：

FILES = 'setup.cfg',

当尾随逗号是冗余的时，当使用版本控制系统时，当值、参数或导入项的列表预计会随着时间的推移而扩展时，尾随逗号通常很有用。模式是将每个值（等）单独放在一行上，始终添加一个尾随逗号，并在下一行添加右括号/方括号/大括号。但是，在结束分隔符的同一行上有一个尾随逗号是没有意义的（上述单元组的情况除外）

是的：

否:

以下是语法规则：出于上述原因，保留逗号可能是有利的。另一方面，如果你在应用程序的其他地方处理JavaScript或JSON，那么采用这种习惯可能会带来麻烦，因为有些浏览器不喜欢在那里使用。是的，但是，你永远不应该手工构建JSON，所以这不重要，对于Javascript，在它接近浏览器之前，总是使用jslint或类似的工具来捕捉这种错误。+1指出这对于元组以外的其他东西也是有效的。这对于每行有一个
key:value，
非常有用，并且在添加新内容时不需要考虑逗号。在最后一个参数中不需要特殊情况，可以只使用
join
在这种情况下：
def_uurepr_uuu（self）：'obj（'+'，'。join（[repr（arg）表示obj.args中的arg]）+）“
。它也有助于代码生成，即使是从不是用Python编写的工具生成代码，并且没有像
join
这样的好功能。这是一种解释思路的糟糕方法。显式比隐式好。这实际上更像是一个注释，而不是对原始问题的回答，但我真的很喜欢添加的支持尾随逗号的参数。不要认为这个答案与问题相关，而不是滥用元组。如果我们期望重复的元素是元组类型，那么我们显式地将这个单元的类型声明为一个元素元组。与列表相同，请尝试
['x'，y']*4
，
[['x'，y']]]*4
，
（['x'，y']）*4
FILES = 'setup.cfg',

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

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