Wie kann ich in Python eine For-Loop-Pyramide prägnanter gestalten?

Question

In der Festkörpermechanik, verwende ich Python oft und schreiben Code, der wie folgt aussieht:

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

ich dies oft wirklich tun, dass ich beginnen sich zu fragen, ob es eine prägnante Art und Weise, dies zu tun. Der Nachteil des aktuellen Codes ist: wenn ich PEP8 erfülle, dann kann ich die 79-Zeichen-Grenze pro Zeile nicht überschreiten, und es ist nicht zu viel Platz übrig, besonders wenn dies wieder in Abhängigkeit von einer Klasse ist.

Answer 1

Nach dem, was Sie tun möchten, können Sie das itertools Modul verwenden, um die for Schleifen (oder zip) .In diesem Fall itertools.product schaffen würde, was man mit den vier Schleifen getan haben, zu minimieren:

>>> 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)] 

und in Ihrem Code können Sie tun:

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

Diese Funktion wie dem folgenden Code entspricht, mit der Ausnahme, dass die tatsächliche Implementierung nicht bui tut ld up Zwischenergebnisse im Speicher:

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) 

bearbeiten: Wie @ PeterE in Kommentar sagt product() kann auch verwendet werden, wenn die Bereiche unterschiedlicher Länge haben:

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

Answer 2

Dies entspricht:

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) 

Wenn Sie dies die ganze Zeit tun, sollten Sie ein Gen verwenden ral Generator für sie:

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) 

Answer 3

Es ist nicht mehr prägnant sein wird, wie es Ihnen eine Generatorfunktion kostet, aber zumindest werden Sie nicht von PEP8 belästigt werden:

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 

(in Python 2.x Sie xrange statt range in der Generatorfunktion)

EDIT verwenden sollte:

obige Verfahren sollte in Ordnung sein, wenn die Tiefe der Pyramide ist kno wn. Sie können aber auch einen generischen Generator ohne externe Modul auf diese Weise machen:

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 

(I verwendet (l, k, j, i) da oben Generator, erster Index zuerst variiert)

Answer 4

Die Idee zu verwenden itertools.product gut ist. Hier ist ein allgemeinerer Ansatz, der Bereiche unterschiedlicher Größe unterstützt.

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