Funktionen

Eine Funktion im Kontext der Programmierung bezieht sich normalerweise auf eine Einheit einer Verrichtung (Routine). Dies mag verwirrend erscheinen, also betrachten wir ein paar konkrete Beispiele.

Während Sie programmieren, bemerken Sie oft, dass Sie ähnliche Aufgaben mehrmals ausführen müssen. Wenn Sie es jedes Mal schreiben, könnten Sie irgendwo einen Fehler machen, und das ganze Programm wird unübersichtlich.

Schauen wir uns ein einfaches Beispiel an.

summation = 1 + 2 + 3
print("Sum of 1 ... 3 is", summation)

Das ist in Ordnung, wenn diese Berechnung nur einmal durchgeführt wird, aber was ist, wenn sie viele Male vorkommt?

summation = 1 + 2 + 3
print("Sum of 3 numbers from 1 is", summation)

summation = 5 + 6 + 7
print("Sum of 3 numbers from 5 is", summation)

summation = 10012 + 10103 + 10014
print("Sum of 3 numbers from 10012 is", summation)

Das ist fast genau das Gleiche, dreimal geschrieben, aber nur mit unterschiedlichen Zahlen.

Das Problem ist, dass

• Es ist einfach zu viel Arbeit, also umständlich.

• Wenn es irgendwo einen Fehler gibt, müssen Sie ihn an drei Stellen beheben.

  • In diesem Beispiel ist es schwer zu übersehen, weil man das Ganze sehen kann, aber wenn diese Prozeduren über das ganze Programm verstreut ist, ist es ziemlich schwer, alles richtig zu korrigieren.

• Es ist fast dasselbe wie im zweiten Problem, aber es ist nicht einfach, alles zu korrigieren, wenn man es später besser umschreiben möchte.

Übrigens: Haben Sie einen Fehler in dem obigen Programm bemerkt? Sehen Sie das obigen Programm noch mal und versuchen Sie, es zu finden. Die Antwort steht am Ende dieser Seite.

Trotz des Fehlers funktioniert dieses Programm, und schlimmer noch, es gibt ein Ergebnis aus, das so aussieht. Solche Fehler sind sehr schwer zu finden.

Um solche Probleme zu vermeiden, sollten ähnliche Verarbeitungen an einer Stelle geschrieben werden. Dafür sollte diese Prozedur als eine einzige Verrichtung, also eine Funktion, implementiert werden.

def sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)
    print("Sum of 3 numbers from", num_from, "is", summation)


sum3(1)
sum3(5)
sum3(10012)

Hier wird eine Funktion namens sum3 definiert. Diese Funktion nimmt einen einzelnen Wert (num_from). Dies wird als Argument bezeichnet. Die Funktion berechnet num_from + (num_from + 1) + (num_from + 2) und gibt sie aus.

Wenn Sie es so schreiben, ist die Wahrscheinlichkeit, dass Sie einen Fehler machen, geringer. Wenn diese Funktion einen Fehler enthält, ist es wahrscheinlicher, dass der Fehler gefunden wird, da er an allen Stellen auftritt, an denen diese Funktion verwendet wird.

Oder: Wenn Sie z. B. den Text der Nachricht ändern möchten, müssen Sie im Originalprogramm drei Stellen ändern, im neuen Programm aber nur eine.

Wir werden später noch genauer darauf eingehen, aber spielen Sie zunächst mit einer Funktion.

Die (normalen) Funktionen, wie z. B. sin, im Zusammenhang mit der Programmierung oft als mathematische Funktionen bezeichnet werden. Darauf wird später auf dieser Seite eingegangen.

Jetzt zeige ich, wie man eine Funktion schreibt. Wie Sie vielleicht schon erraten haben, wird sie wie folgt geschrieben werden.

def functionname(arg1, arg2, ...):
    # Schreiben Sie hier den Vorgang.

def some_function_without_arguments():
    # Eine Funktion, die keine Argumente benötigt


def some_function_with_one_argument(arg):
    # Eine Funktion, die ein Argument benötigt


def some_function_with_two_arguments(arg1, arg2):
    # Eine Funktion mit zwei Argumenten

def sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)
    print("Sum of 3 numbers from", num_from, "is", summation)


sum3(1)
sum3(5)
sum3(10012)

def sum3(num_from):

summation = num_from + (num_from + 1) + (num_from + 2)

print("Sum of 3 numbers from", num_from, "is", summation)

sum3(1)

sum3(5)

sum3(10012)

# Falsche Schreibweise
# (Einzugsbreite nicht konstant)
def sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)
      print("Sum of 3 numbers from", num_from, "is", summation)

# Falsche Schreibweise
# (keine Einzüge)
def sum3(num_from):
summation = num_from + (num_from + 1) + (num_from + 2)
print("Sum of 3 numbers from", num_from, "is", summation)

# Richtig, aber sollte vermieden werden
# (Einzugsbreite nicht 4)
def sum3(num_from):
  summation = num_from + (num_from + 1) + (num_from + 2)
  print("Sum of 3 numbers from", num_from, "is", summation)

# Richtig, aber sollte vermieden werden
# (Einzugsbreite nicht 4)
def sum3(num_from):
        summation = num_from + (num_from + 1) + (num_from + 2)
        print("Sum of 3 numbers from", num_from, "is", summation)

# Richtig
# (Leere Zeilen können eingefügt werden)
def sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)

    print("Sum of 3 numbers from", num_from, "is", summation)

def calc_sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)
    return summation

def calc_sum3(num_from):
    return num_from + (num_from + 1) + (num_from + 2)

def say_hello():
    print("Hello, world")

def sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)
    print("Sum of 3 numbers from", num_from, "is", summation)

def sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)
    print("Sum of 3 numbers from", num_from, "is", summation)

Die Definition einer Funktion allein bewirkt noch nichts (so wie a = 10 offensichtlich nichts bewirkt). Daher müssen Sie die Funktion irgendwo verwenden (aufrufen).

Aber das sollte eigentlich selbsterklärend sein. Wenn Sie das oben definierte say_hello() verwenden wollen, müssen Sie nur folgendes schreiben.

say_hello()

Um den Rückgabewert zu verwenden, können Sie ihn entweder direkt nutzen oder in eine Variable einfügen.

sum3 = calc_sum3(10)
print(sum3)

In diesem Fall können Sie auch wie folgt schreiben:

print(calc_sum3(10))

Wenn es als komplettes Programm geschrieben werden, würde es beispielsweise wie folgt aussehen:

def calc_sum3(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2)
    return summation


sum3 = calc_sum3(10)
print(sum3)

In Python müssen Funktionsdefinitionen geschrieben werden, bevor sie zum ersten Mal verwendet (ausgeführt) werden. Das heißt,

def say_hello():
    print("Hello, world")


say_hello()

ist ein richtiges Programm, aber

say_hello()    # Fehler! (Python weiß noch nicht, was say_hello() ist)


def say_hello():
    print("Hello, world")

ist falsch.

# Wird dies richtig funktionieren?

def say_hello_and_name(name):
    say_hello()    # Noch nicht definiert, aber...
    print("Hello,", name)

def say_hello():
    print("Hello, world")


say_hello_and_name("Einstein")

Einer der Vorteile des Schreibens einer Reihe von Anweisungen als eine Funktion besteht darin, dass es einfach ist, die Funktion zu verbessern.

Nehmen wir zum Beispiel an, dass eine Funktion namens sum10() wie folgt geschrieben wurde. (\ am Ende einer Zeile bedeutet, dass die Zeile in der nächsten Zeile fortgesetzt wird.)

def sum10(num_from):
    summation = num_from + (num_from + 1) + (num_from + 2) \
              + (num_from + 3) + (num_from + 4) + (num_from + 5) \
              + (num_from + 6) + (num_from + 7) + (num_from + 8) \
              + (num_from + 9)

    return summation


print(sum10(10))
print(sum10(100))

Bei genauerem Hinsehen werden Sie jedoch feststellen, dass sie sich wie folgt formulieren lässt:

def sum10(num_from):
    summation = 10 * num_from + 45
    return summation


print(sum10(10))
print(sum10(100))

Der wichtigste Punkt ist, dass sum10() verbessert wurde, ohne einen anderen Teil des Programms zu ändern. Das obige Beispiel mag nicht sehr aussagekräftig erscheinen, da es nur als Beispiel diente, aber es ist eine häufige Situation.

Um sie jedoch zu verbessern, ohne etwas anderes als die Funktion zu ändern, müssen das Argument und der Rückgabewert gleich bleiben. Darauf folgt:

Dies ist jedoch nur ein Ideal. Die Entscheidung, welche Argumente und Rückgabewert zu verwenden sind, ist weitgehend eine Frage der Erfahrung. Wenn Sie eine Funktion verbessern, werden Sie oft auch die Argumente ändern wollen. Am Anfang sollten Sie nicht zu viel darüber nachdenken, sondern sie einfach unbeschwert ändern und sich allmählich daran gewöhnen.

Um deutlich zu machen, dass es sich um eine Funktion (und nicht um eine Variable) handelt, wird sie manchmal als func() mit Klammern nach dem Funktionsnamen geschrieben.

Anstatt beispielsweise zu sagen Im obigen Beispiel haben wir eine Funktion namens sum10 erstellt , könnten wir einfach sagen Im obigen Beispiel haben wir sum10() erstellt . Beachten Sie, dass dies die Argumente auslässt, es bedeutet nicht, dass es sich um eine Funktion handelt, die keine Argumente benötigt.

Bisher haben wir besprochen, wie Sie selbst neue Funktionen erstellen können. In diesem Abschnitt werden einige der Funktionen vorgestellt, die in Python von Anfang an zur Verfügung stehen.

Die print(), die Sie schon verwendet haben, ist eine der Funktionen, die von Anfang an in Python enthalten sind. Es gibt noch viele weitere, aber wir werden hier nur auf mathematische Funktionen eingehen.

Python bietet eine Vielzahl von mathematischen Funktionen. Wie bei den mathematischen Konstanten muss jedoch import math am Anfang des Programms geschrieben werden. Sobald diese geschrieben ist, können die folgenden Funktionen (und die unter mathematischen Konstanten beschriebenen Konstanten) verwendet werden.

Für e-Funktion verwenden Sie math.exp(x). Vergessen Sie nicht, math. hinzuzufügen.

import math

a = math.exp(0.5)
print(a)

wird $\mathrm{e}^{1/2}$ berechnen und anzeigen.

Analog dazu verwenden Sie math.sin(x) für Sinus-Funktion. Beachten Sie, dass die Argumente der trigonometrischen Funktionen im Bogenmaß (Radian) angegeben werden. Wie bereits erwähnt, können Sie für $\pi$ die vordefinierte Konstante math.pi verwenden.

import math

a = math.sin(math.pi / 3)    # sin 60°
print(a)

Die Quadratwurzel ist math.sqrt(x). Der Logarithmus zur Basis e ist math.log(), und der Logarithmus zur Basis 10 ist math.log10().

Der Betrag von $x$ kann mit abs(x) (ohne math. !) oder math.fabs(x) ermittelt werden (f steht für float). Normalerweise spielt es keine Rolle, welche Methode verwendet wird².

Eine vollständige Liste der mathematischen Funktionen finden Sie in math — Mathematical functions (Python Documentation).

summation = 10012 + 10103 + 10014

sollte

summation = 10012 + 10013 + 10014

geschrieben werden (die zweite Zahl ist 10013, nicht 10103). Natürlich ist an beidem mathematisch nichts auszusetzen, aber es ist nicht das, was der/die Programmierer/in beabsichtigt hat.

Auch diese Art von funktioniert und sieht richtig aus, ist aber falsch -Fehler ist sehr schwer zu finden. Es ist sehr wichtig, solcher Fehler möglichst zu vermeiden (und so zu schreiben, dass es schwer ist, Fehler zu machen, bzw. dass sie leicht zu finden sind, wenn man sie doch macht).

In diesem Abschnitt haben Sie etwas über Funktionen gelernt.

• Die Definition einer Funktion wird wie folgt geschrieben.

  def functionname(arg1, arg2, ...):
      # Schreiben Sie hier den Prozess

  • arg1, arg2, … werden als Argumente bezeichnet und können nur innerhalb dieser Funktion verwendet werden. (Sie können sie nennen, wie Sie wollen.)

  • Der Inhalt der Funktion wird mit Indent (Einzug) geschrieben.

  • Mit return können Sie den Rückgabewert zurückgeben.

  • Variablen, die innerhalb einer Funktion definiert sind, können nur innerhalb dieser Funktion verwendet werden.

• Außerdem gibt es eine Reihe von Funktionen, die von Python bereitgestellt werden.

• Es gibt viele Dinge, die man beim Schreiben von Funktionen beachten muss, und ich habe schon viel darüber geschrieben, aber schreiben und probieren Sie Programme, ohne zu viel nachzudenken, bis Sie sich daran gewöhnt haben. Wenn Sie sich etwas wohler fühlen, sollten Sie diese Seite noch einmal lesen und darüber nachdenken, was Sie beim Schreiben einer Funktion beachten müssen.