使用多个嵌套for循环时，如何绕过python中的静态嵌套块？ [复制]答案

【问题标题】：How do I get around statically nested blocks in python when using multiple nested for loops? [duplicate]使用多个嵌套for循环时，如何绕过python中的静态嵌套块？ [复制]
【发布时间】：2017-06-23 19:22:51
【问题描述】：

好的，我正在开发一个以二进制计数最多 3 个字节的程序。我这样做是为了找出 3 个字节的组合总数，只是为了个人知识。目前，我有

def test(): #nested forloop binary counter;
input1 = 2
counter = 1
for a in range(input1):
    for b in range(input1):
        for c in range(input1):
            for d in range(input1):
                for e in range(input1):
                    for f in range(input1):
                        for g in range(input1):
                            for h in range(input1): #H = 8, 1 Byte
                                for i in range(input1):
                                    for j in range(input1):
                                        for k in range(input1):
                                            for l in range(input1):
                                                for m in range(input1):
                                                    for n in range(input1):
                                                        for o in range(input1):
                                                            for p in range(input1): #P = 16, 2 Bytes
                                                                for q in range(input1):
                                                                    for r in range(input1):
                                                                        for s in range(input1):
                                                                            for t in range(input1):
                                                                                for u in range(input1):
                                                                                    for v in range(input1):
                                                                                        for w in range(input1):
                                                                                            for x in range(input1): #X = 24, 3 Bytes
                                                                                                print(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,'    ',counter)
                                                                                                counter = counter + 1

当我尝试运行它时，它给了我一个错误：“静态嵌套块太多”。那么有没有办法以相同的效果解决这个问题，但没有所有嵌套的 for 循环？

【问题讨论】：

尽管看起来很骇人听闻，但很明显他手动切换了 24 个单独的位。
无论看起来多么糟糕，它的功能都很好！
这是我在一个完全合法的问题上看到的最糟糕的代码，实际上显示了我在一段时间内看到的 OP 方面付出了很多努力。
如果您要查找的只是可能组合的数量，您可以使用2^N 来计算，其中N 是位数。但从 Python 编码的功能角度来看，这实际上是一个有趣的问题。
拜托，不要再这样做了，但你让我笑了

标签： python for-loop nested

【解决方案1】：

使用itertools.product:

>>> from itertools import product
>>> for comb in product('01', repeat=24):
...     print(''.join(comb))
...
000000000000000000000000
000000000000000000000001
000000000000000000000010
000000000000000000000011
000000000000000000000100
...

甚至更好，二进制转换：

>>> for i in range(2**24):
...     print(bin(i)[2:].zfill(24))
...
000000000000000000000000
000000000000000000000001
000000000000000000000010
000000000000000000000011
000000000000000000000100
...

【讨论】：

'{:024b}'.format(number)