同时声明多个变量的更优雅的方式

要在“相同时间”声明多个变量，我会这样做：

a, b = True, False

但是，如果我不得不声明更多的变量，它将变得越来越不优雅：

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True

有没有更好/优雅/方便的方法来做到这一点？

这必须是非常基本的，但是如果我确实使用列表或元组来存储变量，那么我将不得不如何处理，因为这样会有所帮助：

aList = [a,b]

无效，我必须这样做：

a, b = True, True

还是我想念什么？

正如其他人所建议的那样，不太可能将10个不同的局部变量与布尔值一起使用是编写例程的最佳方法（尤其是如果它们确实具有一个字母的名称时：）

根据您正在执行的操作，可以改用词典。例如，如果要为一组单字母标志设置布尔值预设值，则可以执行以下操作：

>>> flags = dict.fromkeys(["a", "b", "c"], True)
>>> flags.update(dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

如果您愿意，也可以使用一个赋值语句来做到这一点：

>>> flags = dict(dict.fromkeys(["a", "b", "c"], True),
...              **dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

第二个参数dict并非完全为此目的而设计的：它的真正含义是允许您使用关键字参数（如）来覆盖字典中的各个元素d=False。上面的代码将表达式的结果**分解为一组关键字参数，这些参数传递给调用的函数。这无疑是创建字典的可靠方法，人们似乎至少接受了这种习语，但我怀疑有人可能认为它是非Python的。 </disclaimer>

另一种方法，这是最直观的，如果你会经常使用这种模式，是定义你的数据作为标志值（列表True，False映射到标志名（单字符串））。然后，您可以将此数据定义转换为反向字典，该字典将标志名称映射到标志值。使用嵌套列表理解可以很简洁地完成此操作，但是这是一个非常易读的实现：

>>> def invert_dict(inverted_dict):
...     elements = inverted_dict.iteritems()
...     for flag_value, flag_names in elements:
...         for flag_name in flag_names:
...             yield flag_name, flag_value
... 
>>> flags = {True: ["a", "b", "c"], False: ["d", "e"]}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

该函数invert_dict是一个生成器函数。它生成或产生 -意味着它反复返回 -键值对的值。这些键值对与初始flags字典的两个元素的内容相反。它们被送入dict构造函数。在这种情况下，dict构造函数的工作方式与上面的有所不同，因为构造函数被作为迭代器而非字典作为参数。

借鉴@Chris Lutz的评论：如果您真的将其用于单字符值，则实际上可以

>>> flags = {True: 'abc', False: 'de'}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

这是可行的，因为Python字符串是可迭代的，这意味着它们可以逐值移动。对于字符串，值是字符串中的各个字符。因此，当它们被解释为可迭代时，例如在这种情况下，它们在for循环中使用，['a', 'b', 'c']并且'abc'等效。另一个示例是将它们传递给需要迭代的函数时，例如tuple。

我个人不会这样做，因为它不能直观地理解：当我看到一个字符串时，我希望它可以用作单个值而不是列表。因此，我看第一行并认为：“好的，所以有一个True标志和一个False标志。” 因此，尽管有可能，但我不认为这是可行的方法。从好的方面来说，这可能有助于更清楚地解释可迭代和迭代器的概念。

定义函数invert_dict以使其实际上返回字典也不是坏主意。我大多只是不这样做，因为它并不能真正帮助解释例程的工作原理。

显然，Python 2.7具有字典理解功能，这将为实现该功能提供一种极为简洁的方法。这留给读者练习，因为我没有安装Python 2.7 :)

您还可以结合功能广泛的itertools模块中的某些功能。正如他们所说的，有不止一种方法可以做到。等等，Python人士不这么说。好吧，在某些情况下还是如此。我猜想Guido已经给了我们字典理解能力，所以会有一种明显的方式来做到这一点。

a, b, c, d, e, g, h, i, j = (True,)*9
f = False

使用列表/字典或定义自己的类来封装您要定义的内容，但是如果需要所有这些变量，则可以执行以下操作：

a = b = c = d = e = g = h = i = j = True
f = False

这是@Jeff M和我的评论的详细说明。

执行此操作时：

a, b = c, d

它适用于元组打包和拆包。您可以分开包装和拆箱步骤：

_ = c, d
a, b = _

第一行创建一个称为的元组_，其中包含两个元素，第一个元素的值为，c第二个元素的值为d。第二行将_元组解压缩到变量a和中b。这打破了您的一句话：

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True, True, True, True

分成两行：

_ = True, True, True, True, True, False, True, True, True, True
a, b, c, d, e, f, g, h, i, j = _

它会为您提供与第一行完全相同的结果（如果将值或变量添加到一个部分而忘记更新另一个部分，则包括相同的例外）。但是，在这种特定情况下，yan的答案也许是最好的。

如果您有值列表，则仍然可以解压它们。您只需要先将其转换为元组即可。例如，以下代码将分别为a到分配一个介于0和9之间的值j：

a, b, c, d, e, f, g, h, i, j = tuple(range(10))

编辑：巧妙地把所有元素都分配为true，元素5（变量f）除外：

a, b, c, d, e, f, g, h, i, j = tuple(x != 5 for x in range(10))

当人们建议“使用列表，元组或其他数据结构”时，他们的意思是，当您关心许多不同的值时，将它们分别命名为局部变量可能不是最好的方法做事情。

取而代之的是，您可能希望将它们收集到一个更大的数据结构中，该结构可以存储在单个局部变量中。

直观的演示了如何使用字典来实现此目的，克里斯·卢茨（Chris Lutz）演示了在拆分成单独的变量之前如何使用元组进行临时存储，但是要考虑的另一种选择是使用collections.namedtuple更永久地捆绑值。

因此，您可以执行以下操作：

# Define the attributes of our named tuple
from collections import namedtuple
DataHolder = namedtuple("DataHolder", "a b c d e f g")

# Store our data
data = DataHolder(True, True, True, True, True, False, True)

# Retrieve our data
print(data)
print(data.a, data.f)

当然，实际代码希望使用比“ DataHolder”和字母更大的有意义的名称。

实际上是什么问题？

如果您确实需要或想要10 a，b，c，d，e，f，g，h，i，j，则一次或一次别无其他可能写a并写b并写c。 ....

如果所有值都不相同，则您将不得不写出示例

a = 12
b= 'sun'
c = A() #(where A is a class)
d = range(1,102,5)
e = (line in filehandler if line.rstrip())
f = 0,12358
g = True
h = random.choice
i = re.compile('^(!=  ab).+?<span>')
j = [78,89,90,0]

也就是说，分别定义“变量”。

或者，使用另一种文字，无需使用_：

a,b,c,d,e,f,g,h,i,j =\
12,'sun',A(),range(1,102,5),\
(line for line in filehandler if line.rstrip()),\
0.12358,True,random.choice,\
re.compile('^(!=  ab).+?<span>'),[78,89,90,0]

要么

a,b,c,d,e,f,g,h,i,j =\
(12,'sun',A(),range(1,102,5),
 (line for line in filehandler if line.rstrip()),
 0.12358,True,random.choice,
 re.compile('^(!=  ab).+?<span>'),[78,89,90,0])

。

如果其中一些必须具有相同的值，那就是写的时间太长的问题

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True 

？

然后您可以编写：

a=b=c=d=e=g=h=i=k=j=True
f = False

。

我不明白您到底是什么问题。如果要编写代码，则必须使用编写说明和定义所需的字符。还有什么 ？

我想知道您的问题是否不是您误解了某些东西的迹象。

当一个人写的时候a = 10，不要以“其值可以改变的内存块”的意义创建一个变量。该指令：

• 要么触发类型integer和值10 的对象的创建，要么触发名称“ a”与此对象在当前名称空间中的绑定

• 或将名称空间中的名称“ a”重新分配给对象10（因为先前已将“ a”绑定到了另一个对象）

我说这是因为我看不到该实用程序定义10个标识符a，b，c ...指向False或True。如果在执行过程中这些值未更改，为什么要使用10个标识符？如果更改了，为什么要先定义标识符？如果没有事先定义，则会在需要时创建它们

你的问题对我来说很奇怪

听起来您正以错误的方式对待我。

重写您的代码以使用元组或编写一个类来存储所有数据。

我喜欢投票最多的答案；但是，它存在清单所示的问题。

  >> a, b = ([0]*5,)*2
  >> print b
  [0, 0, 0, 0, 0]
  >> a[0] = 1
  >> print b
  [1, 0, 0, 0, 0]

对此进行了详细的讨论（在此），但要点是a和b都是相同的，并且带有a is breturn True（与相同id(a) == id(b)）。因此，如果您更改索引，你正在改变两者的指数a和b，因为它们是联系在一起的。为了解决这个问题，你可以做（源）

>> a, b = ([0]*5 for i in range(2))
>> print b
[0, 0, 0, 0, 0]
>> a[0] = 1
>> print b
[0, 0, 0, 0, 0]

然后可以将其用作最佳答案的变体，其具有“所需的”直观结果

>> a, b, c, d, e, g, h, i = (True for i in range(9))
>> f = (False for i in range(1)) #to be pedantic

在您的情况下，我将使用YAML。

这是处理多个参数的一种优雅而专业的标准。这些值是从单独的文件加载的。您可以在此链接中看到一些信息：

https://keleshev.com/yaml-quick-introduction

但是，对于Google来说，它比较容易，因为它是一种标准，因此有成百上千的信息，您可以找到最适合您的理解的信息。;）

最好的祝福。

像JavaScript一样，您也可以在python的一行上使用多个语句a = 1; b = "Hello World"; c += 3