Non capisco questo uso di ricorsione

Question

Stavo leggendo le risposte ottenendo un badge di "inversione" e ho trovato una domanda riguardante la ricorsione in cui l'OP non si prendeva la briga di svolgere gran parte dei compiti a casa in anticipo. A parte alcune risposte davvero divertenti, @machielo ha pubblicato an answer in python che ho dovuto eseguire sulla mia macchina per fare presa. Non lo capisco ancora.

def recursive(x): 
    if x > 10: 
     print recursive(x/10) 
    return x%10 

>>> recursive(2678) 
2 
6 
7 
8 

ho provato la mia prima ipotesi, ma so che è sbagliato

>>> 2678/10 
267 
>>> 267/10 
26 
>>> 26/10 
2 
>>> 2%10 
2 

Va bene ... questo è il due. Come valuta questo l'output degli altri numeri in x?

EDIT

E 'il print dichiarazione che non ottengo qui. Ho modificato il codice in quanto tale:

>>> def recursive(x): 
if x > 10: 
    print x 
    print recursive(x/10) 
return x%10 

>>> #I will comment the interpreter session here... 
>>> recursive(2345) 
2345 # first feed in...print the raw number `x` 
234 # 2345/10 does equal 234...the 5 is being held back somewhere... 
23 # and each pass through the recursive loop removes the last digit... 
2 # but where was it being stored at, so that each evaluation of 
3 # x > 10 finally started returning False 
4 # and returns the number, exiting the function 
5 # ... 

sto pensando che durante ogni attraversano, la chiamata a print recursive(x/10) crea un nuovo oggetto funzione, ciascuno con il proprio marchio nuovo caso base e ingresso ...

Un altro suggerimento, chiunque?

FINALMENTE

Grazie a tutti. Sento di aver capito questo ... il trucco non era tanto print come era x%10. 2345%10 == 5 ...

>>> def recursive(x): 
print "Raw `x`:", x 
if x > 10: 
    print "Recurse `x`:", x 
    print recursive(x/10) 
print "Last `x`:", x  
return x%10 

>>> recursive(2345) 
Raw `x`: 2345 
Recurse `x`: 2345 
Raw `x`: 234 
Recurse `x`: 234 
Raw `x`: 23 
Recurse `x`: 23 
Raw `x`: 2 
Last `x`: 2 
2 
Last `x`: 23 
3 
Last `x`: 234 
4 
Last `x`: 2345 
5 

Inoltre, il credito a chi è andato in e aggiornato la risposta iniziale che I previously linked to ... sto per upvote tuo commento:

>>> def recursive(x): 
if x >= 10: 
    print recursive(x/10)  
return x%10 

Answer 1

penso che l'aggiunta di un paio di print affermazioni è davvero utile:

def recursive(x): 
    print '[start] recursive({0})'.format(x) 
    if x > 10: 
    print recursive(x/10) 
    print '[return] recursive({0}) = {1}'.format(x, x%10) 
    return x%10 

print recursive(2678) 

l'output è:

[start] recursive(2678) 
[start] recursive(267) 
[start] recursive(26) 
[start] recursive(2) 
[return] recursive(2) = 2 
2 
[return] recursive(26) = 6 
6 
[return] recursive(267) = 7 
7 
[return] recursive(2678) = 8 
8 

Answer 2

Questa funzione consente di stampare le cifre del numero

funziona così:

def recursive(x): 
    if x > 10: 
    # Divide x by 10 and round down. This chops off the last decimal place. 
    # Now feed that new x without the last decimal place back into recursive() 

    # return x's last digit 

In sostanza, non si print nulla fino x è un numero a cifra singola.

La parte di cui sei confuso è probabilmente il motivo per cui stampa ogni cifra decimale in quell'ordine. Ciò accade perché mentre la funzione ricorre, la funzione genitore è ancora in esecuzione.

Basta provare a espandere il codice per quel singolo numero.

---

Edit: mi sto confondendo pure.

il codice chiama printprimareturn, il che significa che quando il livello ultima di finiture ricorsione, il secondo per durare stampa il prima cifra. Lo stesso vale per i livelli successivi.

Answer 3

Stepping attraverso il vostro esempio pseudocodice (numero di trattini indica la profondità di ricorsione):

-call recursive(2678) 
--2678 > 10, call recursive(267) 
---267 > 10, call recursive(26) 
----26 > 10, call recursive(2) 
-----return 2%10 (which is 2) 
----print 2, then return 26 % 10 (which is 6) 
---print 6, then return 267 % 10 (which is 7) 
--print 7, then return 2678 % 10 (which is 8) 
-return 8 

Answer 4

Tenere presente lo stack di chiamate quando si considera la ricorsione . La chiamata ricorsiva sta spingendo tutti recursive() chiamate di funzione nello stack prima di tutto viene stampato così che cosa si finisce con sullo stack è

recursive(2) # end condition is met so returns 2%10 
recursive(26) 
recursive(267) 
recursive(2678) # the initial call 

una volta che la condizione di fine viene raggiunto il 2% 10 (2) viene restituito al precedente l'istruzione di stampa della funzione e stampata, quindi quella funzione restituisce il 26% 10 (6) e continua fino a quando tutte le chiamate di funzioni ricorsive nello stack non sono state restituite. Il risultato è questa serie di chiamate di stampa:

print 2 
print 6 
print 7 
8 

8 non viene effettivamente stampato; è appena tornato, il che va bene all'interprete. Se volevi essere sicuro di aver stampato, ad esempio, uno script python che chiameresti print recursive(2678)