为了同时声明多个变量，我会这样做：
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
那我缺少了什么吗？
a, b, c, d, e, g, h, i, j = (True,)*9
f = False
a, b, c = ([],)*3 不会创建 3 个列表实例，而是使 a、b 和 c 指向同一个实例。 - Zaca, b, c = ([] for i in range(3))。来源。为了保持一致性，您还可以在这个答案中使用它的变体，即a,b,c,d,e,g,h,i,j = (True for i in range(9))，f=(False i in range(1))。 - Novice C使用列表/字典或定义自己的类来封装您要定义的内容，但如果您需要所有这些变量，可以这样做：
a = b = c = d = e = g = h = i = j = True
f = False
>>a=b=[1,2] > >>a[0]=3 > >>print b > [3,2]。自 >>a=b 以来，b[0] 的值也发生了变化。然而，这似乎是安全的（直观的）：>>a=b=2 > >>a=3 > >>print b > 2。 - Novice C正如其他人所建议的那样，使用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）来覆盖字典的单个元素。上面的代码将跟随**的表达式结果扩展为一组关键字参数，这些参数将传递给被调用的函数。这肯定是创建字典的可靠方法，人们似乎至少接受这种习惯用法，但我怀疑有些人可能认为这种写法不符合Pythonic风格。</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}
['a'，'b'，'c']和'abc'是等效的。另一个例子是当它们被传递给需要可迭代对象（如tuple）的函数时。invert_dict以返回一个字典也不是一个坏主意；我之前没有这样做的主要原因是它并不能真正帮助解释这个例程的工作原理。
['a', 'b', 'c'] 可以缩写为 list('abc')，这启发了 def truth_values(trues, falses): d = dict.from_keys(list(trues), True); d.update(dict.from_keys(list(falses), False)); return d 的使用方式，如 values = truth_values("abc", "de")。 - Chris Lutza, 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 = _
a到j中的每个变量分配0到9之间的值：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))
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"和字母更有意义的名称。
DataHolder 的定义只是变得更加冗长。 - ncoghlan实际上，问题是什么？
如果你真的需要或想要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
?
Then you can write:
a=b=c=d=e=g=h=i=k=j=True
f = False
我不理解你的问题是什么。如果你想编写代码，就必须使用指令和定义所需的字符。还有什么？
我想知道你的问题是否表明你对某些事情有误解。
当一个人写下 a = 10 时，并不是创建一个变量，意思是“一块内存区域，其值可以改变”。这个指令:
要么触发类型为整数，值为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 b返回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
与 JavaScript 类似，您也可以在 Python 中一行上使用多个语句 a = 1; b = "Hello World"; c += 3。
https://keleshev.com/yaml-quick-introduction
不过用谷歌搜索会更容易些，因为这是一个标准，有数百条相关信息，你可以找到最适合你理解的部分。 ;)
此致敬礼。
a=b=True。 - Oliver Ni