Как я могу сделать пирамиду for-loop более краткой в Python? [дубликат]


этот вопрос уже есть ответ здесь:

в механике твердого тела, я часто использую Python и написать код, который выглядит следующим образом:

for i in range(3):
    for j in range(3):
        for k in range(3):
            for l in range(3):
                # do stuff

Я делаю это очень часто, что я начинаю задумываться, есть ли более лаконичный способ сделать это. Недостаток текущий код: если я соблюдаю PEP8, то я не могу превысить 79-символьный предел на строку, и там не слишком много места осталось, особенно если это снова в функции класса.

4   60  

4 ответа:

основываясь на том, что вы хотите сделать, вы можете использовать itertools модуль для минимизации for петли (или zip).в данном случае itertools.product создать то, что вы сделали с 4 петель:

>>> list(product(range(3),repeat=4))
[(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 1, 0), (0, 0, 1, 1),
 (0, 0, 1, 2), (0, 0, 2, 0), (0, 0, 2, 1), (0, 0, 2, 2), (0, 1, 0, 0),
 (0, 1, 0, 1), (0, 1, 0, 2), (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 1, 2),
 (0, 1, 2, 0), (0, 1, 2, 1), (0, 1, 2, 2), (0, 2, 0, 0), (0, 2, 0, 1),
 (0, 2, 0, 2), (0, 2, 1, 0), (0, 2, 1, 1), (0, 2, 1, 2), (0, 2, 2, 0),
 (0, 2, 2, 1), (0, 2, 2, 2), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 0, 2),
 (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 1, 2), (1, 0, 2, 0), (1, 0, 2, 1),
 (1, 0, 2, 2), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 0, 2), (1, 1, 1, 0),
 (1, 1, 1, 1), (1, 1, 1, 2), (1, 1, 2, 0), (1, 1, 2, 1), (1, 1, 2, 2),
 (1, 2, 0, 0), (1, 2, 0, 1), (1, 2, 0, 2), (1, 2, 1, 0), (1, 2, 1, 1),
 (1, 2, 1, 2), (1, 2, 2, 0), (1, 2, 2, 1), (1, 2, 2, 2), (2, 0, 0, 0),
 (2, 0, 0, 1), (2, 0, 0, 2), (2, 0, 1, 0), (2, 0, 1, 1), (2, 0, 1, 2),
 (2, 0, 2, 0), (2, 0, 2, 1), (2, 0, 2, 2), (2, 1, 0, 0), (2, 1, 0, 1),
 (2, 1, 0, 2), (2, 1, 1, 0), (2, 1, 1, 1), (2, 1, 1, 2), (2, 1, 2, 0),
 (2, 1, 2, 1), (2, 1, 2, 2), (2, 2, 0, 0), (2, 2, 0, 1), (2, 2, 0, 2),
 (2, 2, 1, 0), (2, 2, 1, 1), (2, 2, 1, 2), (2, 2, 2, 0), (2, 2, 2, 1),
 (2, 2, 2, 2)]

и в вашем коде вы можете сделать:

for i,j,k,l in product(range(3),repeat=4):
    #do stuff

эта функция эквивалентна следующему коду, за исключением того, что фактическая реализация не строить промежуточных результатов в память:

def product(*args, **kwds):
    # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
    pools = map(tuple, args) * kwds.get('repeat', 1)
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)

Edit:как @ PeterE говорит в комментарии product() может использоваться, даже если диапазоны имеют различную длину:

product(range(3),range(4),['a','b','c'] ,some_other_iterable)

идея использовать itertools.product - это хорошо. Вот более общий подход, который будет поддерживать диапазоны различных размеров.

from itertools import product

def product_of_ranges(*ns):
    for t in product(*map(range, ns)):
        yield t

for i, j, k in product_of_ranges(4, 2, 3):
    # do stuff

это не будет более кратким, поскольку это будет стоить вам функции генератора, но, по крайней мере, вы не будете беспокоить PEP8 :

def tup4(n):
    for i in range(n):
        for j in range(n):
            for k in range(n):
                for l in range(n):
                    yield (i, j, k, l)

for (i, j, k, l) in tup4(3):
    # do your stuff

(в python 2.X вы должны использовать xrange вместо range в функции генератора)

EDIT:

выше метод должен быть прекрасным, когда глубина пирамиды известна. Но вы также можете сделать общий генератор таким образом без какого-либо внешнего модуля :

def tup(n, m):
    """ Generate all different tuples of size n consisting of integers < m """
    l = [ 0 for i in range(n)]
    def step(i):
        if i == n : raise StopIteration()
        l[i] += 1
        if l[i] == m:
            l[i] = 0
            step(i+ 1)
    while True:
        yield tuple(l)
        step(0)

for (l, k, j, i) in tup(4, 3):
    # do your stuff

(я использовал (l, k, j, i) потому что в выше генератора, первый индекс меняется первым)

Это эквивалентно:

for c in range(3**4):
    i = c // 3**3 % 3
    j = c // 3**2 % 3
    k = c // 3**1 % 3
    l = c // 3**0 % 3
    print(i,j,k,l)

Если вы делаете это все время, рассмотрите возможность использования для этого общего генератора:

def nestedLoop(n, l):
    return ((tuple((c//l**x%l for x in range(n-1,-1,-1)))) for c in range(l**n))

for (a,b,c,d) in nestedLoop(4,3):
    print(a,b,c,d)