В python есть более простой способ написать 6 вложенных циклов?

Question

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

for y in range(3): 
    for x in range(3): 
     do_something() 
     for y1 in range(3): 
     for x1 in range(3): 
      do_something_else() 

будет ли более простой способ сделать это? Я знаю, что этот код работает, но когда вы отступаете вместо использования 2 пробелов, таких как я, это может стать проблемой.

О, в примере было всего 4 вложенных петли for, чтобы упростить задачу.

Answer 1

Если вы часто повторяя декартово произведение, как в вашем примере, вы можете изучить Python 2.6's itertools.product - или написать свой собственный, если вы находитесь в более раннем Python.

from itertools import product 
for y, x in product(range(3), repeat=2): 
    do_something() 
    for y1, x1 in product(range(3), repeat=2): 
    do_something_else() 

Answer 2

Когда вы сталкиваетесь с такой программной логикой, я бы, вероятно, разбил последовательность циклов на две или более отдельных функций.

Другая техника в Python заключается в использовании list comprehensions, где это возможно, вместо цикла.

Answer 3

Мой личный аргумент будет то, что вы, вероятно, делать что-то неправильно, если у вас есть 6 вложенных циклов ...

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

Answer 4

Предположим, что каждый цикл имеет какое-то самостоятельное значение, разбить их на именованные функции:

def do_tigers(): 
    for x in range(3): 
     print something 

def do_lions(): 
    do_lionesses() 
    for x in range(3): 
     do_tigers() 

def do_penguins(): 
    for x in range(3): 
     do_lions() 

..etc. 

я мог бы, возможно, выбрали лучшие имена. 8-)

Answer 5

Вы смотрели в List Comprehensions?

Что-то вроде:

Answer 6

Таким образом, выглядит довольно простым и легким. Вы говорите, что хотите обобщить на несколько слоев циклов .... можете ли вы привести пример в реальной жизни?

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

def generate_params(n): 
    return itertools.product(range(n), range(n)) 

for x,y in generate_params(3): 
    do_something() 

Answer 7

вы можете также использовать map()function

Answer 8

Технически, вы могли бы использовать itertools.product получить декартово произведение N последовательностей и перебирать, что:

for y, x, y1, x1 in itertools.product(range(3), repeat=4): 
    do_something_else() 

Но я не думаю, что на самом деле выигрывает вам что-нибудь читаемость-накрест.

Answer 9

Это довольно часто встречается при переходе по многомерным пространствам.Мое решение:

xy_grid = [(x, y) for x in range(3) for y in range(3)] 

for x, y in xy_grid: 
    # do something 
    for x1, y1 in xy_grid: 
     # do something else 

Answer 10

Из вашего кода он выглядит, как вы хотите, чтобы выполнить операцию с каждой возможной парой точек, где х и у находятся в диапазоне 0..2.

Чтобы сделать это:

for x1,y1,x2,y2 in itertools.product(range(3), repeat=4): 
    do_something_with_two_points(x1,y1,2,y2) 

Операция do_something_with_two_points будет называться 81 раз - один раз для каждой возможной комбинации точек.

Answer 11

Итераторы и генераторы Python, в частности, существуют, чтобы обеспечить хороший рефакторинг в противном случае сложных циклов. Конечно, трудно получить абстракцию из простого примера, но предполагая, что параметр 3 должен быть параметром (может быть, весь range(3) должен быть?), А две функции, которые вы вызываете, нуждаются в некоторых параметрах, которые являются переменными цикла, вы могли бы реорганизовать код:

for y in range(3): 
    for x in range(3): 
     do_something(x, y) 
     for y1 in range(3): 
     for x1 in range(3): 
      do_something_else(x, y, x1, y1) 

в, например:

def nestloop(n, *funcs): 
    head = funcs[0] 
    tail = funcs[1:] 
    for y in range(n): 
    for x in range(n): 
     yield head, x, y 
     if tail: 
     for subtup in nestloop(n, *tail): 
      yield subtup[:1] + (x, y) + subtup[1:] 

for funcandargs in nestloop(3, do_something, do_something_else): 
    funcandargs[0](*funcandargs[1:]) 

точный вид рефакторинга, без сомнения, должны быть переделаны для точных целей, но и общую точку, что итераторы (и, как правило на самом деле просто простые генераторы) дают очень приятные рефакторинги остатков петель - все петлевые логи c входит в генератор, а код уровня приложения оставлен с простыми петлями for и фактической обработкой приложений, полученными в циклах for.