Python-step-through-list-TypeError:'；int'；对象是不可编辑的

为了学习python，我正在尝试：

list0=['A','B'];
list1=['C','D'];
z=0
while z < 2:
    for q in list(z):
        print q
    z += 1

但我得到了以下错误：

Traceback (most recent call last):
  File "main.py", line 6, in 
    for q in list(z):
TypeError: 'int' object is not iterable

这在python中可能吗？我知道我用其他语言做过类似的事情

您可以将这两个列表收集为另一个列表，然后可以像这样对其进行索引

list0=['A','B']           # We don't need semicolons
list1=['C','D']
lists=[list0, list1]      # Create a list of lists
z=0
while z < 2:
    for q in lists[z]:    # We access list's index with [], not with ()
        print q
    z += 1

for current_list in [list0, list1]:
    for current_item in current_list:
        print current_item

import itertools
for current_item in itertools.chain(list0, list1):
    print current_item

这样也可以达到同样的效果

list0=['A','B']           # We don't need semicolons
list1=['C','D']
lists=[list0, list1]      # Create a list of lists
z=0
while z < 2:
    for q in lists[z]:    # We access list's index with [], not with ()
        print q
    z += 1

for current_list in [list0, list1]:
    for current_item in current_list:
        print current_item

import itertools
for current_item in itertools.chain(list0, list1):
    print current_item

有一个内置的python模块，它附带了一个方法，可以这样使用

list0=['A','B']           # We don't need semicolons
list1=['C','D']
lists=[list0, list1]      # Create a list of lists
z=0
while z < 2:
    for q in lists[z]:    # We access list's index with [], not with ()
        print q
    z += 1

for current_list in [list0, list1]:
    for current_item in current_list:
        print current_item

import itertools
for current_item in itertools.chain(list0, list1):
    print current_item

您可以将这两个列表收集为另一个列表，然后可以像这样对其进行索引

list0=['A','B']           # We don't need semicolons
list1=['C','D']
lists=[list0, list1]      # Create a list of lists
z=0
while z < 2:
    for q in lists[z]:    # We access list's index with [], not with ()
        print q
    z += 1

for current_list in [list0, list1]:
    for current_item in current_list:
        print current_item

import itertools
for current_item in itertools.chain(list0, list1):
    print current_item

这样也可以达到同样的效果

list0=['A','B']           # We don't need semicolons
list1=['C','D']
lists=[list0, list1]      # Create a list of lists
z=0
while z < 2:
    for q in lists[z]:    # We access list's index with [], not with ()
        print q
    z += 1

for current_list in [list0, list1]:
    for current_item in current_list:
        print current_item

import itertools
for current_item in itertools.chain(list0, list1):
    print current_item

有一个内置的python模块，它附带了一个方法，可以这样使用

list0=['A','B']           # We don't need semicolons
list1=['C','D']
lists=[list0, list1]      # Create a list of lists
z=0
while z < 2:
    for q in lists[z]:    # We access list's index with [], not with ()
        print q
    z += 1

for current_list in [list0, list1]:
    for current_item in current_list:
        print current_item

import itertools
for current_item in itertools.chain(list0, list1):
    print current_item

---

您尝试做的最相似的想法是创建一个由您拥有的两个列表组成的列表。因此，您可以通过

lists[index]

lists = [['A', 'B'], ['C', 'D']]
z = 0
while z < 2:
    for q in lists[z]:
        print q
    z += 1

lists=['A'，'B'，['C'，'D']]
z=0
当z<2时：
对于列表[z]中的q：
打印q
z+=1

---

请注意，

list

对于变量来说不是一个好名字，因为它对Python隐藏了

list

类型。

从您尝试做的事情来看，最类似的想法是创建一个由两个列表组成的列表。因此，您可以通过

lists[index]

lists = [['A', 'B'], ['C', 'D']]
z = 0
while z < 2:
    for q in lists[z]:
        print q
    z += 1

lists=['A'，'B'，['C'，'D']]
z=0
当z<2时：
对于列表[z]中的q：
打印q
z+=1

---

请注意，

list

不是变量的好名称，因为它对Python隐藏了

list

类型。

list需要一个iterable作为参数。您在integer上调用了它，list需要一个iterable作为参数。您在integer上调用了它，我想没有人提到过的一点是，

list

是Python中的内置方法。如果你做了

list（“abcdefg”）

，你会得到

['a'、'b'、'c'、'd'、'e'、'f'、'g']

——一个你传递到

list

的iterable中所有元素的列表。所以，当你对列表（z）中的q做

时，我知道你试图对列表1中的q做
，对列表2中的q做
，但是你对列表（1）中的q做
，
，它试图迭代数字1——这是不可能的，这就是为什么你会得到
类型错误

如果您对使用这个特定的实现毫无兴趣（相信我，您真的应该按照其他答案的建议列出一个列表），请改为：

list0 = ["A","B"]
list1 = ["C","D"]
for i in range(2): #which is a generator that yields 0 and 1
    for q in vars()["list{}".format(i)]:
        print(q)

vars（）
是一个内置函数，它返回一个字典，字典的键是所有本地可用的字符串变量，其值是存储在这些变量中的值。现在，您不用对一个数字调用内置方法
list
，而是使用它来构建一个与您正在使用的列表相对应的字符串

也就是说，任何时候当您试图使用变量名来包含数据时，您实际上只是在拼凑代码。尝试更优雅地编织它，而不是依赖您的代码生成要迭代的变量名：）

为了完整起见，以下是您应该做的事情

a_list = ["A","B"]
b_list = ["C","D"]
lists = a_list+b_list #lists == ["A","B","C","D"]
# could also do lists = [element for element in list_ for list_ in [a_list,b_list]]
# but why in the heck should we complicate things?? May be useful if you need to
# filter elements for whatever reason. Maybe only uppercase letters make it through?
# so something like:
# c_list = ["e","F"]
# lists = [e for e in list_ for list_ in [a_list,b_list,c_list] if e.isupper()]
# I dunno, just throwing it out there for your bag of tricks!
for item in lists:
    print(item)

或者，如果您有大量iterable项，而不一定只是支持串联运算符的列表

list0 = ["A","B"]
...
list99 = ["Y","Z"]

lists = [list0, ... , list99]
for iterable in list:
    for element in iterable:
        print(element)

我认为没有人提到的一点是，
list
是Python中的内置方法。如果你做了
list（“abcdefg”）
，你会得到
['a'、'b'、'c'、'd'、'e'、'f'、'g']
——一个你传递到
list
的iterable中所有元素的列表。所以，当你对列表（z）中的q做
时，我知道你试图对列表1中的q做
，对列表2中的q做
，但是你对列表（1）中的q做
，
，它试图迭代数字1——这是不可能的，这就是为什么你会得到
类型错误

如果您对使用这个特定的实现毫无兴趣（相信我，您真的应该按照其他答案的建议列出一个列表），请改为：

list0 = ["A","B"]
list1 = ["C","D"]
for i in range(2): #which is a generator that yields 0 and 1
    for q in vars()["list{}".format(i)]:
        print(q)

vars（）
是一个内置函数，它返回一个字典，字典的键是所有本地可用的字符串变量，其值是存储在这些变量中的值。现在，您不用对一个数字调用内置方法
list
，而是使用它来构建一个与您正在使用的列表相对应的字符串

也就是说，任何时候当您试图使用变量名来包含数据时，您实际上只是在拼凑代码。尝试更优雅地编织它，而不是依赖您的代码生成要迭代的变量名：）

为了完整起见，以下是您应该做的事情

a_list = ["A","B"]
b_list = ["C","D"]
lists = a_list+b_list #lists == ["A","B","C","D"]
# could also do lists = [element for element in list_ for list_ in [a_list,b_list]]
# but why in the heck should we complicate things?? May be useful if you need to
# filter elements for whatever reason. Maybe only uppercase letters make it through?
# so something like:
# c_list = ["e","F"]
# lists = [e for e in list_ for list_ in [a_list,b_list,c_list] if e.isupper()]
# I dunno, just throwing it out there for your bag of tricks!
for item in lists:
    print(item)

或者，如果您有大量iterable项，而不一定只是支持串联运算符的列表

list0 = ["A","B"]
...
list99 = ["Y","Z"]

lists = [list0, ... , list99]
for iterable in list:
    for element in iterable:
        print(element)

首先，如果每行只有一条语句，那么在Python中不需要使用分号。因此，在您的代码示例中：

list0=['A','B'];
list1=['C','D'];

应该是：

list0=['A','B']
list1=['C','D']

请注意，您的语法是正确的，但不需要这两个尾随分号。如果要在同一行上声明两个列表，则应使用分号：

list0=['A','B']; list1=['C','D']

但是，不建议这样做

其次，在您的代码中，不需要有单独的计数器，
z
，您可以简单地将列表粘在一起，然后只打印它们：

for letter in list0 + list1:
    print letter

作为示范：

>>> list0=['A','B']; list1=['C','D']
>>> for letter in list0 + list1:
>>>     print letter
...     
A
B
C
D

现在，让我解释一下您得到的错误：

'int' object is not iterable

当你想在python中创建一个
列表时，你需要给构造函数一个iterable对象（一个你可以循环的对象，比如数组），当你给它一个简单的数字时，它会给你一个错误，所以你可以这样创建一个列表：

>>> var = list([1,2,3,4])
>>> type(var)
<type 'list'>

首先，如果每行只有一条语句，那么在Python中不需要使用分号。因此，在您的代码示例中：

list0=['A','B'];
list1=['C','D'];

应该是：

list0=['A','B']
list1=['C','D']

注意，您的语法是