Buonasera,

sto studiando da poco i cicli while ed eventualmente quelli annidati ma non riesco a capirne bene la modalità.




se io ho questo codice(1):

n=1

while n<1000000:

          print(n)

          n=n+1

Svolgendo questo codice ci metto tantissimo ad arrivare al milione..

Ma se faccio un ciclo annidato per rallentare un timer:

codice(2)

n = 10
while n > 0 :
    print (n)
    a = 1
    while a < 1000000 :
        a = a + 1
    n = n - 1
print ("Si comincia!")

Proverò a dare l'interpretazione del codice (se sbaglio vi prego di correggermi ) In pratica parto con n=10, e finchè è maggiore di 0 mi stampa n-1. Quando arriva a 0 mi stampa ("Si comincia!") perché non è indentata nel ciclo e non ne rispetta le sue condizioni.

a invece aggiunge, arrivando fino al milione. A è indentata nel ciclo di n e dovrebbe partire per primo(a+1) poi tocca ad n (n=n-1). Però non capisco perché nel primo codice ci metto tantissimo a terminare il programma per arrivare al milione, mentre invece nel secondo che è indentato nel while di n invece impiega meno di 10 secondi.




Cosa succede? Essendo n=10 suddivide il milione di A in 10 unità sottraendone una n per ogni volta che A arriva ad un decimo del milione?




Mi scuso innanzitutto per l'ignoranza "evidente" e poi per l'ultima domanda un po' contorta.




Vi ringrazio in anticipo





--- Ultima modifica di harimau08 in data 2016-10-04 18:30:59 ---

Per cortesia, il codice va indentato anche sul forum altrimenti non si capisce cosa dove quando. Basta modificare il messaggio, selezionando la parte di codice e usare il pulsantino apposito "code" vicino ai colori.

Non lo sapevo, la ringrazio per l'osservazione.. Ho fatto quanto detto

Il problema è l'istruzione print (molto lenta), nel primo caso viene eseguita un milione di volte, nel secondo solo dieci. Con solo dieci print Il tutto dura molto meno benché l'istruzione più annidata nel secondo caso venga eseguita dieci milioni di volte.Si possono misuare i tempi con il modulo time:

import time
inizio = time.time()
n = 1
while n < 1000000:
    print(n)
    n = n + 1
trascorso = time.time() - inizio
print(trascorso)

Visto che i tempi di esecuzione variano parecchio da un PC all'altro, per creare un ritardo conviene usare la funzione sleep del modulo time:

time.sleep(1.5)  ### ritardo di circa un secondo e mezzo
print("Si comincia!")

Cosa succede? Essendo n=10 suddivide il milione di A in 10 unità
sottraendone una n per ogni volta che A arriva ad un decimo del milione?

No, esegue per dieci volte il milione di iterazioni interne (riportando A ad 1 ogni milione), usando valori più piccoli è più semplice seguirne lo svolgimento:

n = 3
while n > 0:
    print("n={}".format(n))
    a = 1
    while a < 4:
        print ("   a={}".format(a))
        a = a + 1
    n = n - 1
print("finito")

--- Ultima modifica di Claudio_F in data 2016-10-05 06:41:05 ---

Ah ecco, quindi (a) non è diviso per le 10 unità togliendone una ogni volta che arriva a 100.000, ma ripete per 10 volte il milione facendo quanto segue 10n(a1...a2...a3..fino al milione) 9n(a1...a2..a3..).




Ti ringrazio!