Funktionen in Python verstehen

Question

Ich versuche, das Turtle-Modul in Python zu verwenden, um die amerikanische Flagge mit separaten Funktionen zu zeichnen. Zuerst habe ich draw_flag, das alle Abmessungen berechnet, und dann draw_rectangle, das tatsächlich die Flaggenform zeichnet, dann mache ich draw_stars usw., um die zu zeichnen Sterne und Linien.

Aber ich habe ein paar Probleme zu verstehen, wie Funktionen funktionieren. Hier ist mein bisheriger Code:

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)

Ich hatte gehofft, dass es durch das Zeichnen eines Rechtecks ​​zurückkehren würde, aber es wird immer wieder angezeigt, dass die Länge nicht definiert ist und ich nicht sicher bin, wo „Länge“ platziert werden soll, damit die Variable erkannt wird.

Ich verwende Python 3, danke.

Answer 1

Hier ist eine gute Möglichkeit, darüber nachzudenken.Eine Funktion ist eine „Black Box“, die eine bestimmte Anzahl von Werten aufnimmt Argumente, in einer bestimmten Reihenfolge und macht etwas mit ihnen, um einen anderen Wert zu erzeugen.Wenn ich „Black Box“ sage, meine ich, dass es Ihnen egal ist, ob Sie die Funktion verwenden Wie Es macht, was es tut, man gibt ihm einfach ein paar Werte und bekommt einen Wert zurück.

Betrachten wir eine sehr einfache Funktion, die lediglich die beiden angegebenen Zahlen subtrahiert:das erste minus das zweite.Mit anderen Worten, wir werden eine Funktion erstellen, die die Regel "Argument Nr. 1 - Argument #2" implementiert. Wenn Sie den Code für diese Funktion schreiben, benötigen Sie einen Weg, um dem Computer mitzuteilen, wann Sie das Argument Nr. 1 verwenden möchten und wann Sie Argument Nr. 2 verwenden möchten.In einigen anderen Programmiersprachen müssen Sie dazu explizit die Nummer des Arguments angeben, das Sie verwenden möchten (#1 oder #2), aber es ist viel einfacher, Code zu schreiben, wenn Sie diesen Werten Namen geben können.Daher können Sie in Python, wie in den meisten anderen Sprachen, mit Namen Ihrer Wahl auf die Argumente einer Funktion verweisen.Angenommen, Sie möchten, dass Argument Nr. 1 unter dem Namen steht x, und Argument Nr. 2, um unter dem Namen zu stehen y.Sie könnten dies zum Ausdruck bringen, indem Sie Folgendes schreiben:

def subtract(x, y):

Darauf folgt der Code, der die Funktion darstellt.Für das Subtraktionsbeispiel wäre es so

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

Wenn der Python -Compiler darauf trifft, übersetzt er den Code in seine interne Darstellung von "Wert Nr. 1 - Wert Nr. 2 berechnen und an meinen Anrufer zurücksendet". Dann packt es diesen Codeblock und speichert ihn unter dem Namen subtract (weil Sie ihm gesagt haben, dass Sie die Funktion so benennen möchten).

Hoffentlich macht es Sinn, dass es, sobald die Ausführung dieses Codeblocks abgeschlossen ist, keinen Sinn mehr macht, auf „Argument Nr. 1“ oder „Argument Nr. 2“ zu verweisen, da es ohne Funktion keine Argumente geben kann!Sobald die Funktion ihre Aufgabe erledigt hat, werden die Bezeichnungen, die Sie den Argumenten gegeben haben, ebenfalls geändert. x Und y, haben keine Bedeutung mehr.Die Beschriftungen existieren nur für die Dauer des Funktionscodes.Das nennt man Umfang:Beschränkung der Beschriftungen auf den Teil des Codes, in dem sie etwas bedeuten.

Wegen der Etiketten x Und y Sind lokal begrenzt, so könnte man sagen, es spielt in gewisser Weise keine Rolle, was sie sind.Zum Beispiel, wenn Sie diese Definition von hätten subtract In Ihrem Code könnten Sie willkürlich entscheiden, sie in zu ändern first Und second, und alles, was Sie ändern müssten, wäre der Code innerhalb dieser einen Funktion.Sie würden einfach die Definition in ändern

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

und das war’s – Ihr Code ist funktional genau derselbe.Irgendwo sonst im Programm x Und y auftreten, verweisen sie auf etwas anderes als die Argumente dieser Funktion, sodass Sie sie nicht ändern müssen, wenn Sie die Argumente umbenennen.

In Ihrem Fall haben Sie versucht, das Etikett zu verwenden length irgendwo außerhalb der Funktion, für die es definiert wurde (nämlich die Funktion, als die Sie gespeichert haben). draw_rectangle).Python weiß, dass Sie sich nicht auf das Argument einer Funktion beziehen können, in der Sie sich nicht befinden, und geht daher davon aus, dass Sie es bereits definiert haben length etwas anderes bedeuten.Aber das hast du nicht getan.Deshalb erhalten Sie eine Fehlermeldung.(Na ja, dieser eine Fehler jedenfalls)

Answer 2

Sie haben zwei Probleme.Zuerst definieren Sie die Funktion draw_flag aber du rufst es nie an.

Wenn Sie es jedoch aufrufen würden, würde es aufgrund Ihrer Funktion nicht funktionieren draw_flag macht eigentlich nichts.Es definiert lediglich einige Variablen in sich selbst und wirft sie dann weg, wenn es endet.Sie sollten die Länge und Höhe mit zurückgeben return length, height, dann mach length, height = draw_flag(A) und Ruf an draw_rectangle mit diesen Werten.(Oder du könntest es tun draw_rectangle(*draw_flag(A)).)

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

Funktionen kommunizieren nicht auf magische Weise miteinander.Eine Funktion nimmt Eingaben entgegen und erzeugt einen Rückgabewert.Wenn Sie diesen Rückgabewert an einer anderen Stelle verwenden möchten, müssen Sie die Funktion an der Stelle aufrufen, an der Sie den Wert verwenden möchten.

Answer 3

Sie rufen die Funktion auf draw_rectangle, das zwei Argumente erwartet – eine Länge und eine Höhe.Die Länge wird von der berechnet draw_flag Funktion;aber Sie geben den Wert nicht zurück.

Sie haben mehrere Möglichkeiten, dieses Problem zu lösen.Eine besteht darin, einfach die anzurufen draw_flag Funktion mit der vom Benutzer angegebenen Höhe, speichern Sie den Rückgabewert und rufen Sie ihn dann auf 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))

Die andere besteht darin, Sie zu bewegen input zum draw_flag Funktion und rufen Sie dann die auf draw_rectangle Funktion von innen draw_flag Funktion.Wenn Sie dies tun, dann wird die draw_flag Funktion benötigt überhaupt keine Argumente:

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()

Ich denke, Sie sollten auch den Abschnitt Ihres Python-Buches über variable Bereiche durchgehen.Dies wird später hilfreich sein, wenn Sie erwarten, dass einige Variablen gedruckt werden, aber seltsame Fehler auftreten – insbesondere, wenn Sie Funktionen verwenden.

Answer 4

Versuchen Sie das Folgende

generasacodicetagpre.

Answer 5

Okay, um Ihre allgemeinere Frage zu beantworten: Funktionen in Python akzeptieren Argumente, wenn Sie sie aufrufen. Diese werden als Referenz übergeben, was bedeutet, dass Sie am Ende dieselben Daten innerhalb der Funktion wie im aufrufenden Bereich erhalten.Dies ist wichtig für veränderliche Typen, denn wenn sie innerhalb der Funktion geändert werden, werden sie auch außerhalb der Funktion geändert.(str, int, float und tuple sind nicht veränderbar, dict und list jedoch).Wenn eine Funktion zurückkehrt, wird der Wert nach dem Rückgabetoken an den Aufrufer zurückgegeben, wenn Sie also sagen a=input('input? '), benötigt die Funktionseingabe ein Argument für die Eingabeaufforderung, das dem Benutzer angezeigt wird. Beachten Sie, dass dies als Referenz übergeben wird und keine Kopie der Zeichenfolge ist.Es gibt die vom Benutzer generierte Eingabe zurück, die in a gespeichert wird.Sie können mehrere Werte von einer Funktion zurückgeben. Diese werden automatisch in ein Tupel umgewandelt.Wenn Sie haben

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

Sie erhalten a=1 und b=2.Namen, die innerhalb einer Funktion verwendet werden, müssen definiert werden.Sie werden zunächst innerhalb der Funktion gesucht, dann in allen umschließenden Namespaces und schließlich in Builtins.In anderen Funktionen definierte Variablen können nicht verwendet werden, da sie sich weder im lokalen Namensraum noch in einem seiner übergeordneten Namen befinden.Um auf die Werte dieser Namen zuzugreifen, müssen Sie sie an die Funktion übergeben. Beachten Sie, dass die innerhalb der Funktion verwendeten Namen nicht mit den Namen außerhalb der Funktion übereinstimmen müssen.Halten:

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

Der Wert 5 wird im Speicher unter dem Namen b gespeichert, dann per Referenz an fun1 übergeben, dieses Mal unter dem Namen a, er wird verdoppelt und zurückgegeben (die Rückgabe erfolgt ebenfalls per Referenz), der Rückgabewert wird dann unter dem Namen gespeichert c, das dann gedruckt wird.

Answer 6

return gibt alles, was Sie ihm geben, an den Anrufer zurück.Es tut nicht Die lokalen Variablen innerhalb der Funktion automatisch außerhalb verfügbar machen (dies sind lokal aus einem Grund!).Beachten Sie auch das return Ohne Argumente wird der Sonderwert zurückgegeben None (also ist es äquivalent zu return None).

Wenn Sie also einige Werte zurückgeben möchten, verwenden Sie return height, length innerhalb der Funktion und height, length = draw_flag(A) draußen.