Funktionen definieren und aufrufen

Einem Codeblock einen Namen geben

Eine Funktion ist ein benannter Codeblock, den Sie immer wieder ausführen können. Sie definieren sie einmal mit def, einem Namen, Klammern und einem Doppelpunkt; der eingerückte Block darunter ist der Rumpf. return schickt einen Wert an den zurück, der die Funktion aufgerufen hat. Aufrufen heißt, ihren Namen mit Klammern und den zu verarbeitenden Werten zu schreiben.

def gross_value(price, quantity):
    return price * quantity

print(gross_value(184.25, 200))  # 36850.0

Parameter und Argumente

Die Namen in den Klammern von def sind die Parameter: Platzhalter für die Eingaben. Die Werte, die Sie beim Aufruf übergeben, sind die Argumente, und sie füllen die Parameter der Reihe nach. Vertauschen Sie sie, ändert sich das Ergebnis. Eine falsche Anzahl von Argumenten ist ein Fehler. Jeder Aufruf bekommt seine eigene frische Kopie der Parameter.

# Arguments fill the parameters in order
def spread(bid, ask):
    return ask - bid

print(spread(184.25, 184.5))  # 0.25
print(spread(184.5, 184.25))  # -0.25

return ist nicht print

print zeigt einem Menschen etwas auf dem Bildschirm. return übergibt einen Wert an den aufrufenden Code, damit er damit weiterarbeiten kann. Eine Funktion ohne return liefert None, also „nichts“. Funktionen, die rechnen, sollten zurückgeben; der aufrufende Code entscheidet, ob ausgegeben wird.

# A function with no return gives back None
def show(price):
    print("price", price)

result = show(184.25)   # price 184.25
print(result)           # None

Kleine Funktionen, die aufeinander aufbauen

Eine Funktion kann andere Funktionen aufrufen, sodass Sie großes Verhalten aus kleinen, testbaren Teilen bauen. Geben Sie jeder Funktion eine Aufgabe und einen Namen, der sie sagt. Der Docstring, ein String direkt unter def, erklärt sie dem nächsten Leser. Definieren Sie eine Funktion, bevor die Zeile läuft, die sie aufruft.

# Small functions build bigger ones
def gross_value(price, quantity):
    """Value of a position before costs."""
    return price * quantity


def commission(gross):
    """0.1% of the value, but never less than 1.0."""
    return max(1.0, gross * 0.001)


def net_cost(price, quantity):
    """What the position really costs: value plus commission."""
    gross = gross_value(price, quantity)
    return gross + commission(gross)


print(net_cost(184.25, 200))  # 36886.85

Mehrere Werte zurückgeben

return a, b gibt beide Werte auf einmal als Tupel zurück: ein geordnetes Paar, mit Kommas geschrieben (Tupel bekommen bald ein eigenes Thema). Der Aufrufer kann die Teile sofort benennen. Eine Order über 1.000 Aktien mit // und % in 3 Teile zu zerlegen, liefert die Größe jedes Teils und den Rest.

# return several values as a tuple
def split_fill(quantity, slices):
    return quantity // slices, quantity % slices

size, leftover = split_fill(1000, 3)
print(size, leftover)  # 333 1

• Eine Aufgabe pro Funktion und ein Name, der sagt, was sie zurückgibt.
• Rechnen und return; das Ausgeben dem Aufrufer überlassen.
• Einen Docstring ergänzen, der sagt, was hineingeht und was herauskommt.

Als Nächstes: Funktionsargumente und Standardwerte, um Funktionen mit Namen, optionalen Werten und beliebig vielen Argumenten aufzurufen.

Lab: Was bewertet wird

• Mit gross_value eine Funktion definieren, die eine Position bewertet25 Pkt.
• Mit commission eine Provision mit Mindestbetrag berechnen25 Pkt.
• Mit net_cost die echten Kosten aus zwei Funktionen aufbauen25 Pkt.
• Mit split_fill zwei Werte auf einmal zurückgeben25 Pkt.