Comprensione delle funzioni in Python

Question

Sto cercando di usare il modulo tartaruga in Python per disegnare la bandiera americana utilizzando funzioni separate, per prima cosa ho draw_flag che calcola tutte le dimensioni, e poi draw_rectrle che disegna effettivamente la forma del bandiera, quindi malato rendono drasty_stars, ecc.disegnare le stelle e le linee.

Ma, sto avendo un po 'di difficoltà a capire su come funziona le funzioni ...Hhere è il mio codice fino ad ora:

import turtle
import time
import random

def draw_rectangle(length, height):
    turtle.up()
    x = length
    y = height

    turtle.begin_fill()
    turtle.setpos(x,y)
    turtle.down()
    turtle.forward(418)
    turtle.right(90)
    turtle.forward(220)
    turtle.right(90)
    turtle.forward(418)
    turtle.right(90)
    turtle.forward(220)
    turtle.end_fill()

    turtle.sleep(2)
    turtle.bye

def draw_flag(A):
    height = int(A)
##    length = height*1.9
##    union_height = height*(7/13)
##    union_length = length*(2/5)
##    E = F = union_height/10
##    G = H = union_length/12
##    stripe_width = height/13
##    diameter_star = stripe_width*(4/5)
    length = height*1.9
    return

A = input("Please enter the height of the flag: ")

draw_rectangle(length, height)

.

Speravo che sarebbe tornato disegnando un rettangolo, ma continua a dire che la lunghezza non è definita, non è sicuro di dove posizionare "lunghezza" dove riconoscerà la variabile.

Sto usando Python 3, grazie.

Answer 1

Ecco un buon modo per pensarci. Una funzione è una "scatola nera" che assume un certo numero di valori, chiamato argomenti , in un ordine specifico e fa qualcosa con loro per produrre un altro valore. Quando dico "Black Box", intendo che quando usi la funzione, non devi preoccuparti come fa quello che fa, dai un valori e hai un valore indietro .

Consideriamo una funzione molto semplice che sottrae solo i due numeri che è dato: il primo meno il secondo. In altre parole, faremo una funzione che implementa la regola "argomento n. 1 - argomento n. 2". Ora, quando scrivi il codice per questa funzione, hai bisogno di un modo per dirlo al computer quando si desidera utilizzare l'argomento n. 1 e quando si desidera utilizzare l'argomento n. 2. In alcuni altri linguaggi di programmazione, devi farlo esplicitamente specificando il numero dell'argomento che si desidera utilizzare (# 1 o # 2), ma è molto più facile scrivere il codice se è possibile fornire questi nomi di valori. Quindi Python, come la maggior parte delle altre lingue, ti consente di fare riferimento agli argomenti di una funzione usando i nomi della tua scelta. Ad esempio, supponiamo di volere l'argomento n. 1 per andare sotto il nome x e l'argomento n. 2 per andare sotto il nome y. Potresti indicare che scrivendo questo:

def subtract(x, y):

.

Questo sarebbe seguito dal codice che costituisce la funzione. Per l'esempio della sottrazione, sarebbe

def subtract(x, y):
    return x - y

.

Quando il compilatore Python incontra questo, traduce il codice nella sua rappresentazione interna di "Calcola valore # 1 - Valore # 2 e invialo indietro al mio chiamante." Quindi fa parte quel blocco del codice e lo salva sotto il nome subtract (perché è quello che hai detto che volevi nominare la funzione).

Speriamo che abbia senso che una volta che questo blocco del codice finisca l'esecuzione, non ha più senso fare riferimento a "Argument # 1" o "Argument # 2", perché non puoi avere argomenti senza una funzione! Allo stesso modo, una volta che la funzione ha fatto la sua cosa, le etichette che hai dato agli argomenti, x e y, non hanno più alcun significato. Le etichette esistono solo per la durata del codice della funzione. Questo è chiamato scoping : limitando le etichette alla parte del codice in cui significano qualcosa.

Poiché le etichette x e y sono localmente scoped , come si potrebbe dire, in un modo che non importa nemmeno quello che sono. Ad esempio, se hai avuto quella definizione di subtract nel tuo codice, è possibile decidere arbitrariamente di cambiarli su first e second, e tutto ciò che dovresti cambiare sarebbe il codice all'interno di tale funzione. Avresti solo modificare la definizione su

def subtract(first, second):
    return first - second

.

E questo è: il tuo codice è funzionalmente esattamente lo stesso. In qualsiasi altro luogo nel programma che x e y si verificano, si riferiscono a qualcosa di diverso dagli argomenti di questa funzione, quindi non devi cambiarli quando si rinomina gli argomenti.

Cosa sta succedendo nel tuo caso è che hai provato a utilizzare l'etichetta length da qualche parte al di fuori della funzione è stato definito per (cioè, la funzione che hai memorizzato come draw_rectangle). Python sa che non si può fare riferimento all'argomento di una funzione che non ti piacciono, quindi si aspetta che tu abbia già definito length per significare qualcos'altro. Ma non l'hai fatto. Ecco perché stai ricevendo un errore. (Bene, questo errore, comunque)

Answer 2

Hai due problemi.Innanzitutto, definisci la funzione draw_flag ma non la chiami mai.

Tuttavia, se l'hai chiamato, non funzionerebbe, perché la tua funzione draw_flag non fa davvero nulla.Definisce solo alcune variabili dentro di sé e poi le getta via quando finisce.Dovresti restituire la lunghezza e l'altezza con return length, height, quindi eseguire length, height = draw_flag(A) e chiamare draw_rectangle con tali valori.(Oppure puoi fare draw_rectangle(*draw_flag(A)).)

length, height = draw_flag(A)
draw_rectangle(length, height)

.

Le funzioni non comunicano magicamente l'una con l'altra.Una funzione prende input e produce un valore di ritorno.Se si desidera utilizzare quel valore di ritorno da qualche altra parte, è necessario chiamare la funzione nel luogo in cui si desidera utilizzare il valore.

Answer 3

Stai chiamando la funzione draw_rectangle, che si aspetta due argomenti - una lunghezza e un'altezza.La lunghezza viene calcolata dalla funzione draw_flag;Ma non restituisci il valore.

Hai qualche modo per risolvere questo.Uno deve semplicemente chiamare la funzione draw_flag con l'altezza fornita dall'utente, salvare il valore di ritorno e quindi chiamare draw_rectangle:

def draw_flag(A):
    height = int(A)
##    length = height*1.9
##    union_height = height*(7/13)
##    union_length = length*(2/5)
##    E = F = union_height/10
##    G = H = union_length/12
##    stripe_width = height/13
##    diameter_star = stripe_width*(4/5)
    return height*1.9

A = input("Please enter the height of the flag: ")
length = draw_flag(A)
draw_rectangle(length, int(A))

.

L'altro è spostare il input nella funzione draw_flag, quindi chiamare la funzione draw_rectangle dall'interno della funzione draw_flag.Se lo fai, la funzione draw_flag non ha bisogno di argomenti:

def draw_flag():
    A = input("Please enter the height of the flag: ")
    height = int(A)
##    length = height*1.9
##    union_height = height*(7/13)
##    union_length = length*(2/5)
##    E = F = union_height/10
##    G = H = union_length/12
##    stripe_width = height/13
##    diameter_star = stripe_width*(4/5)
    draw_rectangle(height*1.9, height)

draw_flag()

.

Penso che dovresti anche passare attraverso la sezione del tuo libro di Python su ambiti variabili.Aiuterà più tardi quando ti aspetti che alcune variabili da stampare, ma ottieni strani errori, specialmente se si utilizzano funzioni.

Answer 4

Prova il seguente

import turtle
import time
import random

def draw_rectangle(length, height):
   turtle.up()
   x = length
   y = height

   turtle.begin_fill()
   turtle.setpos(x,y)
   turtle.down()
   turtle.forward(418)
   turtle.right(90)
   turtle.forward(220)
   turtle.right(90)
   turtle.forward(418)
   turtle.right(90)
   turtle.forward(220)
   turtle.end_fill()

   turtle.sleep(2)
   turtle.bye

 def draw_flag(A):
   height = int(A)
   length = height*1.9
   draw_rectangle(length,height)
   return

A = input("Please enter the height of the flag: ")

draw_flag(A)

.

Answer 5

Okay, quindi per rispondere alla tua domanda più generale, le funzioni in Python accettano argomenti Quando li chiami, questi sono passati per riferimento, il che significa che si finisce con gli stessi dati all'interno della funzione come nello spazio chiamante. Questo è importante per i tipi mutabili, poiché se vengono modificati all'interno della funzione, vengono modificati anche al di fuori della funzione. (STR, INT, Float e Tuple non sono mutabili, dict ed elenco sono). Quando una funzione ritorna, il valore dopo il ritorno del token viene passato al chiamante, quindi se si dice a=input('input? '), l'ingresso funzione prende un argomento per il prompt da visualizzare all'utente, Nota Questo è passato in riferimento, non è una copia della stringa. Restituisce l'ingresso generato dall'utente, che viene memorizzato in a. È possibile restituire più valori da una funzione, vengono convertiti automaticamente in una tupla; Se hai

def test():
    return 1,2
a,b = test()

.

Otterrai A= 1 e B= 2. I nomi utilizzati all'interno di una funzione devono essere definiti. Vengono prima ricercati all'interno della funzione, quindi in tutti gli spazi dei nomi racchiudenti, infine in entrata. Le variabili definite in altre funzioni non possono essere utilizzate, perché non sono nello spazio dei nomi locali né nessuno dei suoi genitori. Per accedere ai valori di questi nomi, è necessario passarli nella funzione, si noti che i nomi utilizzati all'interno della funzione non devono corrispondere ai nomi al di fuori della funzione. Considera:

def fun1(a):
    return a * 2
def fun2():
    b = 5
    c = fun1(b)
    print c
fun2()

.

Il valore 5 è memorizzato in memoria sotto il nome B, quindi è passato con riferimento in FUN1, questa volta sotto il nome A, è raddoppiato e restituito, (il ritorno è anche per riferimento), il valore di ritorno viene quindi memorizzato sotto il nome c, che viene quindi stampato.

Answer 6

return restituisce tutto ciò che ritorni al chiamante. non apporta automaticamente le variabili locali all'interno della funzione disponibile all'esterno (queste sono locali per un motivo!).Nota anche che return senza alcun argomento restituirà il valore speciale None (quindi è equivalente a return None).

Quindi, se si desidera restituire alcuni valori, utilizzare return height, length all'interno della funzione e height, length = draw_flag(A) all'esterno.