Funktion mit unterschiedlicher Anzahl von For-Loops (Python)

Mein problem ist schwer zu erklären.

Möchte ich eine Funktion erstellen, enthält geschachtelte for-Schleifen
die Menge, die proportional zu einem argument an die Funktion übergeben.

Hier ist ein hypothetisches Beispiel:

Function(2)

...würde bedeuten...

for x in range (y):
    for x in range (y):
        do_whatever()

Anderes Beispiel...

  Function(6)

...würde bedeuten...

for x in range (y):
    for x in range (y):
        for x in range (y):
            for x in range (y):
                for x in range (y):
                    for x in range (y):
                        whatever()

Den Variablen der for-Schleife (y) sind, NICHT verwendet in der verschachtelten code.

Ihr Erster Gedanke könnte sein, erstellen Sie EINE for-Schleife, mit einem Bereich, der der macht das number-argument...
DAS KANN NICHT FUNKTIONIEREN, weil das Produkt wäre RIESIG. Ich habe Instanzen erforderlich, wo gibt es 8 verschachtelte for-Schleifen.
Das Produkt ist zu groß für einen Bereich in einer for-Schleife.

Gibt es andere Argumente brauchte, um an die Funktion übergeben werden, aber ich kann damit umgehen, dass mich.

Hier ist der code
(es schafft die Schneeflocke Fraktale)

from turtle import *
length = 800
speed(0)

def Mini(length):
    for x in range (3):
        forward(length)
        right(60)

penup()
setpos(-500, 0)
pendown()   

choice = input("Enter Complexity:")

if choice == 1:
    for x in range (3):
        forward(length)
        left(120)

elif choice == 2:
    for x in range (3):
        Mini(length/3)
        left(120)

if choice == 3:
    for x in range (6):
        Mini(length/9)
        right(60)
        Mini(length/9)
        left(120)

if choice == 4:
    for y in range (6):
        for x in range (2):
            Mini(length/27)
            right(60)
            Mini(length/27)
            left(120)
        right(180)
        for x in range (2):
            Mini(length/27)
            right(60)
            Mini(length/27)
            left(120)

if choice == 5:
    for a in range (6):
        for z in range (2):
            for y in range (2):
                for x in range (2):
                    Mini(length/81)
                    right(60)
                    Mini(length/81)
                    left(120)
                right(180)
                for x in range (2):
                    Mini(length/81)
                    right(60)
                    Mini(length/81)
                    left(120)
            right(180)
        right(180)

if choice == 6:
    for c in range (6):
        for b in range (2):
            for a in range (2):
                for z in range (2):
                    for y in range (2):
                        for x in range (2):
                            Mini(length/243)
                            right(60)
                            Mini(length/243)
                            left(120)
                        right(180)
                        for x in range (2):
                            Mini(length/243)
                            right(60)
                            Mini(length/243)
                            left(120)
                    right(180)
                right(180)
            right(180)
        right(180)

if choice == 7:
    for a in range (6):
        for b in range(2):
            for c in range (2):
                for d in range (2):
                    for e in range (2):
                        for f in range (2):
                            for y in range (2):
                                for x in range (2):
                                    Mini(length/729)
                                    right(60)
                                    Mini(length/729)
                                    left(120)
                                right(180)
                                for x in range (2):
                                    Mini(length/729)
                                    right(60)
                                    Mini(length/729)
                                    left(120)
                            right(180)
                        right(180)
                    right(180)
                right(180)
            right(180)
        right(180)

Ich würde schätzen jede Hilfe, die Sie mir geben können überhaupt
obwohl, wenn Sie eine andere Methode vorschlagen (z.B. Rekursion),
bitte nicht nur den code einzufügen; stattdessen schlägt einige Ideen, könnte mich in die richtige Richtung.

(Der Algorithmus ist für ein Spezialist Mathematik Zuordnung)

Spezifikationen:
Python 2.7.1
Turtle
Im LEERLAUF
Windows7

InformationsquelleAutor der Frage Anti Earth | 2011-08-25

18

Dieses problem kann gelöst werden, indem die Rekursion. Ich bin gerade beim schreiben eines Algorithmus hier, da ich glaube, dies kann ein Allgemeines problem.
```
function Recurse (y, number) 
   if (number > 1)
      Recurse ( y, number - 1 )
   else
      for x in range (y)
      whatever()
```
InformationsquelleAutor der Antwort Ozair Kafray
21

Ich bin mir nicht klar, warum Sie nicht verwenden können, das Produkt an die Grenzen-und tun
```
for x in range(y exp n)
```
wobei n die Anzahl der Schleifen..... Sie sagen y exp n wird riesig sein, aber ich bin mir sicher, dass python damit umgehen kann.

Jedoch, dass gesagt wird, was über eine Art rekursiven Algorithmus?
```
def loop_rec(y, n):
    if n >= 1:
        for x in range(y):
            loop_rec(y, n - 1)
    else:
       whatever()
```
InformationsquelleAutor der Antwort Robert Martin

diese kann getan werden, ohne Rekursion mit itertools.product

import itertools
def function(n):
    for x in itertools.product(range(n),repeat=n):
        whatever()

InformationsquelleAutor der Antwort Dan D.

5

Rekursion wird Ihre beste Wette. Überlegen Sie, was es tun sollte, im base-case und im rekursiven Fall.

Code ausgelassen, wie pro Anforderung.

InformationsquelleAutor der Antwort outis

Hier gehen Sie. Lassen Sie reicht Ihr reicht, arbeiten nach Ergebnis, wenn Sie müssen.

ranges=((1,4),(0,3),(3,6))
from operator import mul
operations=reduce(mul,(p[1]-p[0] for p in ranges))-1
result=[i[0] for i in ranges]
pos=len(ranges)-1
increments=0
print result
while increments < operations:
    if result[pos]==ranges[pos][1]-1:
        result[pos]=ranges[pos][0]
        pos-=1
    else:
        result[pos]+=1
        increments+=1
        pos=len(ranges)-1 #increment the innermost loop
        print result

[1, 0, 3]
[1, 0, 4]
[1, 0, 5]
[1, 1, 3]
[1, 1, 4]
[1, 1, 5]
[1, 2, 3]
[1, 2, 4]
[1, 2, 5]
[2, 0, 3]
[2, 0, 4]
[2, 0, 5]
[2, 1, 3]
[2, 1, 4]
[2, 1, 5]
[2, 2, 3]
[2, 2, 4]
[2, 2, 5]
[3, 0, 3]
[3, 0, 4]
[3, 0, 5]
[3, 1, 3]
[3, 1, 4]
[3, 1, 5]
[3, 2, 3]
[3, 2, 4]
[3, 2, 5]
[1, 0, 4]

Testen mit dem folgenden würde das gleiche Ergebnis:

for x in range(*ranges[0]):
    for y in range(*ranges[1]):
        for z in range(*ranges[2]):
            print [x,y,z]

InformationsquelleAutor der Antwort robert king

1

Haben Sie als xrange ?
```
for x in xrange(y ** n):
    whatever()
```
Und wenn Sie übers Ziel hinausschießen, auch xrange limit, die Sie verwenden können, itertool
```
import itertools
for x in itertools.product(xrange(y), repeat=n):
   whatever()
```
(Vorherige itertool Antwort falsch verwendet werden n für den Bereich anstelle von y)

InformationsquelleAutor der Antwort MatthieuW

Meine Antwort ist spät, aber angenommen, Sie wollen mehrere loops, z.B. print-Bereich einige mehrere Male. Dann die richtige version dieser Rekursion ist:

def loop_rec(y, number):
   if (number > 1):
      loop_rec( y, number - 1 )
      for i in range(y): 
         print(i, end=' ')        
   else:      
      for i in range(y):
         print(i, end=' ')

loop_rec(4,3)

Diese werden drei for-Schleifen mit der Palette(4)

Wenn Sie wollen spielen, um mit den dynamischen Bereich, sind hier einige Varianten:

def loop_rec(y, number):
if (number > 1):
    loop_rec( y+1, number - 1 )
    for i in range(y): 
        print(i, end=' ')
    print(' ;')
else:      
    for i in range(y):
        print(i, end=' ')
    print(';')

loop_rec(6,4)

dem heraus gedruckt wird:

0 1 2 3 4 5 6 7 8 ;
0 1 2 3 4 5 6 7  ;
0 1 2 3 4 5 6  ;
0 1 2 3 4 5  ;

oder

def loop_rec(y, number):
if (number > 1):
    loop_rec( y-1, number - 1 )
    for i in range(y): 
        print(i, end=' ')
    print(' ;')
else:      
    for i in range(y):
        print(i, end=' ')
    print(';')
loop_rec(6,4)

die Ausgabe:

0 1 2 ;
0 1 2 3  ;
0 1 2 3 4  ;
0 1 2 3 4 5  ;

Einer besseren Variante, die mit nur einer for-Schleife (weniger Tippen), ist die folgende:

def loop_rec(y, number):
    if (number >= 1):
        loop_rec( y+1, number - 1 )
        for i in range(y): 
            print(i, end=' ')
        print('')
    else:      
        return

loop_rec(1,5)

Ausgabe:

InformationsquelleAutor der Antwort youth4ever

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.