5. Funktionen#
Funktionen im mathematischen Sinne sind uns in den Natur- und Ingenieurwissenschaften wohlbekannt. Dass solche Funktionen auch von Programmiersprachen zur Verfügung gestellt werden, hatten wir unter anderem im Kapitel 3.3 gesehen. Allerdings ist der Begriff der Funktionen in Programmiersprachen wesentlich weiter gefasst. So muss eine Funktion nicht unbedingt ein Argument besitzen, und sie muss auch nicht unbedingt ein Ergebnis zurückgeben. In manchen Programmiersprachen wird nach diesem letzten Kriterium unterschieden. So kennt Fortran functions, die ein Resultat zurückgeben, und subroutines, bei denen dies nicht der Fall ist.
Wozu sind Funktionen gut, wenn man davon absieht, dass sie uns aus der Mathematik vertraut sind? Zunächst einmal können Funktionen wesentlich dabei helfen, ein Programm zu strukturieren. Lagert man eine bestimmte Funktionalität in eine Funktion mit einem gut gewählten Namen aus, so kann man die Komplexität im Innern der Funktion verstecken. Bei der Suche nach Fehlern kann dies ein entscheidender Vorteil sein, da man sich entweder nur mit dem Innern der Funktion beschäftigt und untersucht, ob diese korrekt implementiert ist, oder aber sich auf deren Korrektheit verlässt und die Details bei der Untersuchung des restlichen Programms nicht im Blick haben muss.
Funktionen eignen sich auch sehr gut dazu, Programmcode, der an mehreren Stellen im Programm auftreten würde, an einer einzigen Stelle unterzubringen. Auch dieser Aspekt trägt, zusammen mit einem gut gewählten Funktionsnamen, dazu bei, ein Programm lesbarer zu machen. Zum anderen verbessert sich die Wartbarkeit des Codes erheblich, da Korrekturen nur an einer Stelle vorgenommen werden müssen. Ohne die Verwendung von Funktionen müssten man darauf achten, Korrekturen zum Code an verschiedenen Stellen der Programms in konsistenter Weise vorzunehmen.
Stellt man beim Programmieren fest, dass sich Code wiederholt, so sollte man sich also überlegen, ob es nicht sinnvoll wäre, für die betreffende Aufgabe eine Funktion zu definieren. Auch dann wenn Code nicht identisch wiederholt wird, sondern nur in ähnlicher Weise, ist eine Auslagerung in eine Funktion denkbar, wenn man geeignete Funktionsargumente einführt. Grundsätzlich sollte man beim Programmieren daran denken, sich nicht unnötig zu wiederholen und stattdessen entweder eine der in Kapitel 4.1 und Kapitel 4.2 besprochenen Schleifenvarianten zu verwenden oder aber eine Funktion zu implementieren.
Schließlich ist die Verwendung von Funktionen auch dann angebracht, wenn man die gleiche
Funktionalität in verschiedenen Programmen benötigt. Man kann solche Funktionen in einem
Modul sammeln und dann bei Bedarf importieren, wie wir es schon mit dem math-Modul
und den darin enthaltenen Funktionen getan haben.
5.1. Funktionsdefinitionen#
Betrachten wir zunächst eine Funktion, die keine Argumente besitzt. Was die Funktion tut, ist also festgelegt und kann nicht durch Parameter verändert werden.
def f():
print("Hallo!")
print("** Anfang")
f()
print("** Ende")
** Anfang
Hallo!
** Ende
In diesem einfachen Beispiel ist die Funktion durch die ersten beiden Zeilen definiert. Dabei
besitzt die erste Zeile eine Struktur wie wir sie ähnlich von Schleifen und Verzweigungen kennen.
Die Zeile beginnt nämlich ebenfalls mit einem Schlüsselwort, das in diesem Fall def heißt und andeutet,
dass hier eine Funktion definiert wird. Des Weiteren wird die erste Zeile mit einem Doppelpunkt
beendet. Der Funktionsname ist hier f, wobei hier im Allgemeinen eine Name gewählt werden sollte,
der besser beschreibt, was die Funktion tut. Wichtig ist das Klammerpaar, das auch dann nicht
weggelassen werden darf, wenn die Funktion überhaupt keine Argumente besitzt.
Der Funktionscode ist wie üblich in Python durch eine Einrückung kenntlich zu machen. Die dritte,
leere Zeile dient hier nur zur optischen Absetzung und ist für den Python-Interpreter völlig
irrelevant. Durch die Beendung der Einrückung sind die letzten drei Zeilen nicht mehr Bestandteil
der Funktion. Funktionsdefinitionen benötigen genauso wie Schleifen und Verzweigungen zwingend
einen eingerückten Codeblock. Wie schon bei den for-Schleifen in Kapitel 4.1 kann auch hier
bei Bedarf der Befehl pass eingerückt verwendet werden.
Wenn der Python-Interpreter den Code des obigen Beispiels verarbeitet, wird zunächst die Funktion
f definiert. Sie wird zu diesem Zeitpunkt jedoch nicht ausgeführt. Es erfolgt als insbesondere
zu diesem Zeitpunkt nicht die Ausgabe des Textes Hallo!. Die Anweisung in Zeile 4 führt nun dazu,
dass der Text ** Anfang ausgegeben wird. Anschließend wird die Funktion f ohne Argumente aufgerufen.
An dieser Stelle ein Argument anzugeben, das in der Funktionsdefinition nicht vorgesehen ist, würde
zu einem Fehler führen.
def f():
print("Hallo!")
print("** Anfang")
f(1)
print("** Ende")
** Anfang
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[2], line 5
2 print("Hallo!")
4 print("** Anfang")
----> 5 f(1)
6 print("** Ende")
TypeError: f() takes 0 positional arguments but 1 was given
Rufen wir dagegen unsere Funktion f korrekt ohne ein Argument auf, so wird diese ausgeführt und
in diesem Fall Hallo! ausgegeben. Nachdem die Funktion ausgeführt wurde, wird die Programmausführung
direkt nach dem Funktionsaufruf fortgesetzt. Im Beispiel wird somit abschließend der Text ** Ende
ausgegeben.
In den meisten Fällen wird man die Funktion flexibler gestalten wollen und zu diesem Zweck ein oder mehrere Argument übergeben wollen. Um den ursprünglichen Autor von Python, Guido von Rossum, zu grüßen, können wir den Namen der zu grüßenden Person als Argument übergeben.
def f(name):
print(f"Hallo, {name}!")
f("Guido")
Hallo, Guido!
Will man zusätzlich die Sprache zwischen Deutsch (de) und Englisch (en) wählen, so könnte man ein weiteres Argument vorsehen.
def f(name, lang):
if lang == "en":
print(f"Hello, {name}!")
elif lang == "de":
print(f"Hallo, {name}!")
else:
print(f"{name}!")
f("Guido", "en")
Hello, Guido!
Das gewählte Beispiel ist insofern untypisch als die Funktion anscheinend keinen Rückgabewert zurückliefert. Normalerweise würde man die sich ergebende Zeichenkette an den aufrufenden Programmteil übergeben, wo dann entschieden werden kann, was mit dem Ergebnis zu tun ist. Eine alternative Variante unserer Funktion mit einem Argument würde dann folgendermaßen aussehen.
def f(name):
s = f"Hallo, {name}!"
return s
print(f("Guido"))
Hallo, Guido!
Das Ergebnis wird mit Hilfe der return-Anweisung zurückgegeben, wobei hier keine Klammern zu setzen sind.
Alternativ wäre es möglich, auf die Variable s zu verzichten und die sich ergebene Zeichenkette direkt
in die return-Anweisung zu schreiben.
Auch wenn man den Eindruck haben könnte, dass das Fehlen einer return-Anweisung dazu führt, dass überhaupt
kein Ergebnis zurückgibt, ist dies nicht ganz richtig.
def f(name):
print(f"Hallo, {name}!")
x = f("Guido")
print(f"Rückgabewert: {x}")
Hallo, Guido!
Rückgabewert: None
Die erste Ausgabezeile ergibt sich aus der print-Anweisung in der Funktion f. Der Rückgabewert aufgrund
des Funktionsaufrufs wird in der Variable x gespeichert, die anschließend ausgegeben wird. Wie wir sehen,
wird in diesem Fall als Ergebnis None zurückgegeben. Das gleiche Result hätten wir erhalten, wenn wir als
letzte Zeile explizit return None geschrieben hätten.
def f(name):
print(f"Hallo, {name}!")
return None
x = f("Guido")
print(f"Rückgabewert: {x}")
Hallo, Guido!
Rückgabewert: None
Tipp
Eine vergessene return-Anweisung und der sich daraus ergebende Rückgabewert None können gelegentlich
zu überraschenden Fehlermeldung führen. Es lohnt sich daher bei Fehlern in Zusammenhang mit Funktionen zu
überprüfen, ob die return-Anweisung vorhanden ist.
Eine Funktion kann auch mehrere return-Anweisungen enthalten, wobei die Ausführung der Funktion beendet
wird, sobald sie bei einer return-Anweisung ankommt. Das folgende Beispiel illustriert dies an einem
sehr simplen Primzahltest.
def is_prime(n):
for divisor in range(2, n):
if n % divisor == 0:
return False
return True
for n in range(2, 100):
if is_prime(n):
print(n, end=' ')
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
Sobald n ohne Rest durch divisor teilbar ist, wird die Funktion mit der return-Anweisung beendet und
der Wert False zurückgegeben. Wird kein Teiler gefunden, so wird der Wert True zurückgegeben. Abhängig
vom Ergebnis der Funktion is_prime wird die betreffende Zahl ausgegeben oder nicht und auf diese Weise
eine Liste von Primzahlen erzeugt.
Eine Funktion kann auch mehr als einen Wert zurückgeben. Dazu werden die einzelnen Variablen durch Kommas
getrennt in der return-Anweisung aufgelistet.
from math import cos, radians, sin
def spherical2cartesian(r, theta, phi):
theta = radians(theta)
phi = radians(phi)
x = r*sin(theta)*cos(phi)
y = r*sin(theta)*sin(phi)
z = r*cos(theta)
return x, y, z
pt1_r = 10
pt1_theta = 45
pt1_phi = 30
pt1_x, pt1_y, pt1_z = spherical2cartesian(pt1_r, pt1_theta, pt1_phi)
print(f"({pt1_x:5.3f}, {pt1_y:5.3f}, {pt1_z:5.3f})")
(6.124, 3.536, 7.071)
Vergleicht man in diesem Beispiel die Namen sowohl der Argumente als auch der Rückgabewerte in der Funktionsdefinition mit den Namen, die im Funktionsaufruf in der vorletzten Zeile verwendet werden, so stellt man fest, dass diese nicht identisch sein müssen. Dies ist schon deswegen nicht der Fall, weil man statt der drei Variablen im Funktionsaufruf auch direkt numerische Werte angeben könnte. Zudem wäre es sonst erforderlich, die Variablennamen in Funktionen zu kennen, die man aus einem Modul importiert. In unserem Beispiel erfolgt die Zuordnung der Argumente und der Rückgabewerte einfach nach der Position. Die Möglichkeit, mit Hilfe von Schlüsselworten eine Zuordnung der Funktionsargumente vorzunehmen, werden wir in Kapitel 5.7 besprechen.
5.2. Dokumentation von Funktionen#
Wie generell beim Programmieren ist es auch in Funktionen sinnvoll, an eine
ausreichende Dokumentation zu denken. Dies könnte mit Hilfe von Kommentaren
erfolgen, die in Python mit einem # eingeleitet werden. Andere
Programmiersprachen verwenden hierfür häufig auch andere Markierungen. In
Python gibt es für Funktionen jedoch eine geeignetere Art der Dokumentation,
nämlich einen Dokumentationstext, den so genannten docstring, der direkt auf
die erste Zeile der Funktionsdefinition folgt.
from math import sqrt
def mitternacht(a, b, c):
"""Berechne die beiden Lösungen einer quadratischen Gleichung ax²+bx+c=0
Es wird die Mitternachtsformel verwendet.
Achtung: Es wird stillschweigend vorausgesetzt, dass b^2-4ac>0.
"""
diskriminante = sqrt(b**2-4*a*c)
root1 = (-b+diskriminante)/(2*a)
root2 = (-b-diskriminante)/(2*a)
return root1, root2
Der docstring wird hier nicht nur mit einem, sondern mit drei Anführungszeichen begrenzt,
da auf diese Weise ein mehrzeiliger Text möglich ist. Der Vorteil dieser Dokumentationsweise
im Vergleich zu einfachen Kommentaren besteht bei Python darin, dass der docstring mit Hilfe
der help()-Funktion ausgegeben werden kann, ähnlich wie wir dies im Kapitel 3.3
kennengelernt hatten, wo help(math) die Dokumentation für das math-Modul ausgab.
help(mitternacht)
Help on function mitternacht in module __main__:
mitternacht(a, b, c)
Berechne die beiden Lösungen einer quadratischen Gleichung ax²+bx+c=0
Es wird die Mitternachtsformel verwendet.
Achtung: Es wird stillschweigend vorausgesetzt, dass b^2-4ac>0.
Hier wird man also in Python belohnt, wenn man sich einer guten Dokumentationspraxis bedient.
Weitere Hinweis zu docstrings sind in PEP 257 zu finden.
5.3. Lokale und globale Variable#
Nicht selten kommt es vor, dass Variablen inner- und außerhalb einer Funktion den gleichen Namen haben. Insbesondere bei Funktionen, die aus fremden Modulen, zum Beispiel aus der Python-Standardbibliothek, importiert werden, lassen sich solche Namensdoppelungen auch kaum vermeiden. Daher stellt sich die Frage, auf welche Variable sich unter welchen Umständen ein mehrfach verwendeter Variablenname bezieht.
In dem folgenden Beispiel sind außerhalb der Funktion f() die Variablen
x und y definiert. Innerhalb der Funktion f() gibt es eine Variable
x, die innerhalb der Funktion verändert wird. Außerdem geht der Wert der
Variable y in die Rechnung ein. Aus der Sicht der Funktion f() muss man
nun zwischen lokalen und globalen Variablen unterscheiden. Lokale Variablen sind
nur innerhalb der Funktion sichtbar, jedoch nicht von außerhalb der Funktion. Gibt
es keine lokale Variable mit dem vorgegebenen Namen, dafür aber eine passende globale
Variable, so wird deren Wert verwendet. Sollte es auch keine passende globale Variable
geben, so sucht Python schließlich auch noch in den eingebauten Python-Funktionen.
Tipp
Grundsätzlich sollte man den Bezug auf globale Variablen nach Möglichkeit vermeiden, da hier eine große Gefahr für Fehler lauert. Meistens ist es besser, den Wert der globalen Variable explizit über ein Funktionsargument zu übergeben. Unter Umständen kann auch objektorientiertes Programmieren nützlich sein, auf das wir in Kapitel 9 eingehen werden.
Betrachten wir die Unterscheidung zwischen lokalen und globalen Variablen in einem konkreten Beispiel.
def f(x):
x = x+1
print(f"lokal: x = {locals()['x']}")
print(f"global: x = {globals()['x']}")
print(f"global: y = {globals()['y']}")
return x*y
x = 5
y = 2
print(f"{f(3) = }")
print(f"{x = }")
lokal: x = 4
global: x = 5
global: y = 2
f(3) = 8
x = 5
Außerhalb der Funktion f() sind die globalen Variablen x und y mit ihren Werten
5 und 2 definiert. In der vorletzten Zeile wird dann die Funktion f() mit dem Argument
3 aufgerufen. Damit hat die lokale Variable x im Innern der Funktion diesen Wert. In der
ersten Zeile des Funktionskörpers wird x dann auf den Wert 4 inkrementiert. Dabei nehmen
sowohl die linke als auch die rechte Seite Bezug auf die lokale Variable x, deren Wert
über das Funktionsargument gesetzt wurde. Die globale Variable x mit ihrem Wert 5 spielt
für die Rechnung keine Rolle, da die lokale Variable Vorrang hat.
Nach der Inkrementierung der Variablen x sehen wir uns die innerhalb der Funktion bekannten
lokalen und globalen Variablen an. Die lokale Variable x hat den Wert 4 und ein Bezug auf eine
Variable mit dem Namen x wird innerhalb der Funktion diesen Wert liefern, sofern nicht im
weiteren Verlauf ein anderer Wert zugewiesen wird. Ferner ist eine globale Variable x mit
dem Wert 5 bekannt, auf die aber nicht unter dem Namen x direkt zugegriffen werden kann.
Schließlich gibt es noch die globale Variable y, die den Wert 2 besitzt.
Hinweis
Die meisten globale Objekte können innerhalb einer Funktion nicht verändert werden. Eine Ausnahme sind Listen, so dass bei deren Modifikation innerhalb einer Funktion besondere Vorsicht geboten ist. Auf die Besonderheiten von Listen werden in Kapitel 6 genauer eingehen.
Der Rückgabewert der Funktion ergibt sich nun aus dem Produkt der lokalen Variable x und
der globalen Variable y zu 4 mal 2, also 8. Außerhalb der Funktion hat die Variable x
weiterhin den Wert 5. Dieser wurde durch die Inkrementierung der lokalen Variable x innerhalb
der Funktion also nicht berührt.
Betrachten wir abschließend noch eine abgewandelte Form des vorigen Beispiels, in der neben der
Variablen x auch die Variable y inkrementiert wird. Durch diesen Umstand wird y zu einer
lokalen Variablen, und zwar in der gesamten Funktion. Dies hat insbesondere zur Folge, dass
auf der rechten Seite der zweiten Zeile des Funktionskörpers der Wert der lokalen Variablen y
benötigt wird. Da diese aber nicht existiert, kommt es hierzu zu einem UnboundLocalError.
def f(x):
x = x+1
y = y+1
return x*y
x = 5
y = 2
print(f"{f(3) = }")
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
Cell In[13], line 8
6 x = 5
7 y = 2
----> 8 print(f"{f(3) = }")
Cell In[13], line 3, in f(x)
1 def f(x):
2 x = x+1
----> 3 y = y+1
4 return x*y
UnboundLocalError: cannot access local variable 'y' where it is not associated with a value
5.4. Rekursive Funktionen#
Darf man in einer Funktion die Funktion selbst wieder aufrufen? In Sprachen wie Python, C und modernen Versionen von Fortran ist dies möglich. In Fortran 77 musste man dafür noch in die Trickkiste greifen. Eine Funktion, die in sich selbst wieder aufgerufen wird, wenn auch mit anderen Werten für die Argumente, nennt man eine rekursive Funktion. Zur Erläuterung betrachten wir zunächst ein mathematisches Beispiel.
Die Fakultät \(n!\) einer ganzen Zahl \(n\) ist definiert als das Produkt der ganzen Zahlen von \(1\) bis \(n\), also
Alternativ kann man die Fakultät auch rekursiv definieren als
Hierbei wird die Auswertung der Fakultät auf die Auswertung der Fakultät für eine um Eins kleinere Zahl reduziert. So lässt sich sukzessive das Argument der auszuwertenden Fakultät reduzieren, was natürlich nur etwas nützt, wenn diese Folge irgendwann abbricht. In unserem Fall geschieht dies dadurch, dass die Fakultät von \(1\) zu \(1\) definiert wird.
Wir setzen diese mathematischen Formeln nun in Programmcode um und beginnen mit der expliziten Produktdarstellung.
def fakultaet(n):
produkt = 1
for k in range(2, n+1):
produkt = produkt*k
return produkt
for n in range(1, 10):
print(n, fakultaet(n))
1 1
2 2
3 6
4 24
5 120
6 720
7 5040
8 40320
9 362880
Alternativ kann man die Fakultät rekursiv implementieren.
def fakultaet_rekursiv(n):
if n > 1:
return n*fakultaet_rekursiv(n-1)
elif n == 1:
return 1
else:
raise ValueError("Das Argument muss größer als null sein.")
for n in range(1, 10):
print(n, fakultaet_rekursiv(n))
1 1
2 2
3 6
4 24
5 120
6 720
7 5040
8 40320
9 362880
Sehen wir uns diese Implementierung etwas genauer an. So lange das Argument n größer als Eins ist,
wird einfach die Rekursionsformel implementiert. Es wird als Ergebnis also einfach n mal die Fakultät
von n-1 zurückgegeben. Dabei muss aber zunächst diese Fakultät berechnet werden. Auf diese Weise
arbeitet man sich sukzessive zu immer kleineren Argumenten bis n den Wert 1 erreicht. In diesem Fall
bricht die Rekursion ab, und es wird direkt das Resultat 1 zurückgegeben. Nachdem dieser Wert erhalten
wurde, können sukzessive die Resultate der einzelnen Funktionsaufrufe bestimmt werden bis am Ende das
gewünschte Ergebnis erhalten wird. Diesen Vorgang werden wir gleich noch etwas genauer veranschaulichen.
Zuvor wollen wir aber noch darauf hinweisen, dass unsere Funktion noch eine Fehlerbehandlung
durchführt, die verhindert, dass die Rekursion nie zu Ende kommt. Sollte das Argument n nämlich
kleiner gleich null sein oder keine ganze Zahl sein, würde man nie die Abbruchbedingung erreichen,
bei der n gleich Eins ist. Damit wären wir in einer Endlosschleife gefangen. Bei rekursiven
Funktionen ist es also immer essentiell wichtig, darauf zu achten, dass die Abbruchbedingung korrekt
implementiert ist.
Maximale Rekursionstiefe in Python
In Python ist die Rekursionstiefe standardmäßig auf 1000 begrenzt, wie sich mit Hilfe von
sys.getrecursionlimit() verifizieren lässt. Damit ist einerseits die Gefahr von Endlosschleifen
etwas entschärft. In unserem Beispiel wäre aber die Größe des Arguments n dadurch begrenzt. Bei
Bedarf lässt sich die maximale Rekursionstiefe mit sys.setrecursionlimit() anpassen. Zuvor
sollte man aber sicherstellen, dass die Abbruchbedingung für die Rekursion tatsächlich korrekt
funktioniert.
Um den Ablauf der Rekursion zu veranschaulichen, modifizieren wir unser Programm noch ein klein wenig.
def fakultaet_rekursiv(n):
print(f"** Aufruf mit Argument {n = }")
if n > 1:
ergebnis = n*fakultaet_rekursiv(n-1)
print(f"-> {n}! = {ergebnis}")
return ergebnis
elif n == 1:
ergebnis = 1
print(f"-> {n}! = {ergebnis}")
return ergebnis
else:
raise ValueError("Das Argument muss größer gleich Eins sein.")
fakultaet_rekursiv(5)
** Aufruf mit Argument n = 5
** Aufruf mit Argument n = 4
** Aufruf mit Argument n = 3
** Aufruf mit Argument n = 2
** Aufruf mit Argument n = 1
-> 1! = 1
-> 2! = 2
-> 3! = 6
-> 4! = 24
-> 5! = 120
120
Hier wird deutlich, wie zunächst nacheinander die Funktion mit fallenden Argumenten aufgerufen wird und dann sukzessive die Resultate aufgebaut werden, nachdem das Ende der Rekursion erreicht wurde.
5.5. Funktionen als Bürger erster Klasse#
In diesem Kapitel haben wir bis jetzt Funktionen definiert und diese aufgerufen. Die Funktion wurde dann ausgeführt, und wir haben ein Ergebnis erhalten. Diese Möglichkeiten, mit Funktionen zu arbeiten, kann man für alle Programmiersprachen erwarten. Es gibt jedoch Programmiersprachen, zu denen auch Python gehört, in denen mit Funktionen genauso wie mit anderen Objekten, also zum Beispiel Variablen umgegangen werden kann. Man spricht dann davon, dass Funktionen first class citizens, also Bürger erster Klasse, sind, die im Vergleich zu anderen Objekten nicht in ihren Möglichkeiten eingeschränkt sind.
Was sind also die zusätzlichen Möglichkeiten, die sich daraus ergeben, dass Funktionen first class objects oder first class citizens sind? Funktionen können dann Variablen zugewiesen werden, sie können als Argumente an Funktionen übergeben werden oder beispielsweise auch als Elemente in Listen auftreten. Wir wollen dies an Beispielen illustrieren.
from math import sin
funktion = sin
print(funktion(1), sin(1))
print(funktion)
print(sin)
0.8414709848078965 0.8414709848078965
<built-in function sin>
<built-in function sin>
Hier wird der Variablen funktion die Sinusfunktion sin aus dem math-Modul zugewiesen.
Wichtig ist an dieser Stelle, dass keine Klammer gesetzt werden, wie man es bei einem
Funktionsaufruf tun müsste. Nur dann bezieht man sich auf das Funktionsobjekt. Die Variable
funktion kann nun mit Argumenten genauso aufgerufen werden, wie das für sin möglich ist, und
wir stellen fest, dass sich erwartungsgemäß auch das gleiche Ergebnis ergibt. Übergibt man das
Funktionsobjekt, also nicht das Ergebnis einer Funktionsauswertung, an die print()-Funktion,
so wird ein beschreibender Text ausgegeben, der zeigt, dass funktion tatsächlich auf die
eingebaute Funktion sin verweist.
Wie schon erwähnt, können Funktionsobjekte auch als Elemente einer Liste auftreten. Dabei spielt es keine Rolle, ob die betreffenden Funktionen importiert oder selbst definiert wurden.
from math import cos, sin
def myfunc(x):
return x**2 - 4*x + 4
for f in [cos, sin, myfunc]:
print(f"{f.__name__:6s}: {f(1):8.6f}")
cos : 0.540302
sin : 0.841471
myfunc: 1.000000
Für die Ausgabe des Funktionsnamens haben wir uns dabei des Attributs __name__ bedient, wobei hier
vor und nach dem Text name jeweils zwei Unterstriche stehen.
Funktionen als Argumente an andere Funktionen übergeben zu können, eröffnet interessante Möglichkeiten. Wir wollen dies an einem Beispiel demonstrieren, das numerisch näherungsweise die Ableitung einer Funktion an einer vorgegebenen Stelle bestimmen soll.
from math import cos, sin
def ableitung(f, x):
h = 1e-7
df = (f(x+h)-f(x-h))/(2*h)
return df
print(f"{ableitung(sin, 0) = }")
print(f"{ableitung(cos, 0) = }")
ableitung(sin, 0) = 0.9999999999999983
ableitung(cos, 0) = 0.0
Hier wird der Differenzenquotient für eine kleine, aber fest vorgegebene Schrittweite ausgewertet. Als Argumente werden sowohl die Funktion, hier Sinus und Kosinus, sowie die Stelle, an der die Ableitung auszuwerten ist, übergeben. Es sei noch einmal betont, dass bei der Übergabe des Funktionsobjekts keine Klammern gesetzt werden dürfen.
Natürlich kann der Code für die Ableitung noch verbessert werden, zum Beispiel weil die Wahl einer festen Schrittweite nicht unbedingt ideal ist. Immerhin kommen alle Verbesserung des Codes der Auswertung der Ableitung von im Prinzip beliebigen Funktionen zugute. Im Kapitel 5.7 werden wir dieses Beispiel noch weiter entwickeln.
5.6. Lambda-Funktionen#
Im Kapitel 5.1 hatten wir Beispiele für Funktionen kennengelernt, bei denen die Bestimmung der
Ergebnisses in einer einzelnen Codezeile erfolgte. Bei machen Gelegenheiten erscheint dann die
vollständige Definition einer Funktion als unnötig aufwändig. Tatsächlich erlauben es die
sogenannten Lambda-Funktionen, eine Funktion in einer einzigen Zeile zu definieren. Der Name dieser
Funktionen stammt aus dem Lambda-Kalkül, in dem die Lambda-Funktionen einen wichtige Rolle spielen.
Dies erklärt auch, warum lambda zu den reservierten Schlüsselwörtern in Python gehört und nicht
als Variablenname verwendet werden kann. Ein Beispiel soll die Definition einer Lambda-Funktion
illustrieren.
quadrat = lambda x: x**2
potenz = lambda x, y: x**y
print(quadrat(9), potenz(3, 4))
81 81
Nach dem Schlüsselwort lambda folgt ein oder mehrere Argumente gefolgt von einem Doppelpunkt.
Der letzte Ausdruck gibt an, wie der Rückgabewert zu bestimmen ist.
Lambda-Funktionen werden auch als anonyme Funktionen bezeichnet, da sie nicht unbedingt einen
Namen tragen müssen. Dies kann zum Beispiel dann nützlich sein, wenn das Ergebnis einer Funktion
wiederum eine Funktion sein soll. Die Funktion potenz() gibt in Abhängigkeit von dem
übergebenen Argument eine Funktion zurück, die die entsprechende Potenz eines Arguments berechnet.
So werden hier das Quadrat (square) und die dritte Potenz (cubic) mit Hilfe der einen Funktion
potenz definiert.
def potenz(exponent):
return lambda x: x**exponent
square = potenz(2)
cubic = potenz(3)
print(square(5), cubic(5))
25 125
Auch bei Anwendungen der im Kapitel 5.5 definierten Ableitungsfunktion können anonyme Funktionen nützlich sein, wenn man die Ableitung einer selbst definierten Funktion numerisch berechnen möchte. In dem folgenden Beispiel soll die Ableitung von \(f(x)=x^3\) berechnet werden.
def ableitung(f, x):
h = 1e-7
df = (f(x+h)-f(x-h))/(2*h)
return df
print(ableitung(lambda x: x**3, 1))
3.000000000086267
Die ersten vier Zeilen enthalten die bereits zuvor verwendete Ableitungsfunktion. Beim Aufruf dieser Funktion kann das erste Argument einfach in Form einer anonymen Funktion oder Lambda-Funktion angegeben werden, ohne dass eine separate Funktion in der üblichen Weise definiert werden müsste. Auf diese Weise erhalten wir hier eine numerische Näherung für die Ableitung der dritten Potenz an der Stelle \(1\).
5.7. Schlüsselworte und Defaultwerte#
Am Ende von Kapitel 5.1 hatten wir gezeigt, dass bei Funktionsaufrufen mit mehreren Argumenten die Zuordnung nicht nach dem Namen erfolgt, sondern zunächst einmal nach der Position der jeweiligen Argumente. Dies ist jedoch insbesondere in Fällen, in denen die Argumentliste sehr lange wird, nicht praktisch und daher gibt es auch andere Möglichkeiten, Argumente zu übergeben. Zur Illustration dieser Problematik stellen wir uns eine Funktion vor, die es ermöglicht, vorgegebene Daten graphisch darzustellen. Eine solche Funktion wird typischerweise relativ viele Argumente haben, da man beispielsweise die Strichfarbe, die Strichdicke und die Strichart festlegen möchte. Andererseits möchte man nicht unbedingt alle Argumente explizit angeben müssen, wenn man nur eine schwarze durchgezogene Linie mittlerer Dicke darstellen möchte. Es sollte auch nicht so sein, dass man, nur weil man die Stichart anpassen möchte, alle anderen Argumente, die vor dem betreffenden Argument stehen, zwingend angeben muss.
In einem solchen Fall ist es sinnvoll, Argumente per Schlüsselwort zu übergeben. Um das Vorgehen zu verdeutlichen, greifen wir auf die Funktion zurück, die wir am Ende des letzten Abschnitts zur numerischen Berechnung von Ableitungen eingeführt hatten.
def ableitung(f, x):
h = 1e-7
df = (f(x+h)-f(x-h))/(2*h)
return df
In dem zuvor beschriebenen Funktionsaufruf
ableitung(lambda x: x**3, 1)
3.000000000086267
wird das erste Argument der Variable f und das zweite Argument der Variable x in der Funktion
zugeordnet. Alternativ kann man die Argumente mit den in der Funktion verwendeten Namen bezeichnen.
Ein mögliche Form des Funktionsaufrufs wäre dann
ableitung(f=lambda x: x**3, x=1)
3.000000000086267
Hier stehen die Argumente zwar immer noch in der gleichen Reihenfolge, aber die Zuordnung erfolgt nun über die angegebenen Bezeichner. Daher könnte man genauso gut die Reihenfolge der beiden Argumente vertauschen.
ableitung(x=1, f=lambda x: x**3)
3.000000000086267
Hinweis zur Formatierung
PEP 8 empfiehlt, um Gleichheitszeichen in Zuweisungen Leerzeichen zu setzen. Anders ist dies bei Schlüsselwortargumenten. Hier sollen um das Gleichheitszeichen keine Leerzeichen gesetzt.
Beim den letzten beiden Funktionsaufrufen ist es wichtig, die verschiedenen x voneinander zu
unterscheiden. Die beiden x in der Lambdafunktion haben dabei nichts mit dem Schlüsselwort x
zu tun. Noch sorgfältiger muss man in dem folgenden Funktionsaufruf die verschiedenen x
unterscheiden.
x = 1
ableitung(x=x, f=lambda x: x**3)
3.000000000086267
Im Funktionsaufruf bezeichnet das erste x ein Schlüsselwort, das mit einem Argumentbezeichner in
der Funktionsdefinition übereinstimmen muss. Das zweite x verweist auf die Variable x, die nach
der Zuweisung in der ersten Zeile den Wert 1 besitzt. Die x im zweiten Argument bezeichnen eine
lokale Variable in der Lambdafunktion und haben nichts mit dem beiden x im ersten Argument zu tun.
Gerade bei längeren Argumentlisten kann es sinnvoll sein, einen Teil der Argumente über ihre Position in der Liste zuzuordnen und andere Argumente über das zugehörige Schlüsselwort. In einem solchen Fall müssen die Argumente mit Schlüsselwort zwingend hinter den Argumenten kommen, die über ihre Position zugeordnet werden. Andernfalls könnten die Argumente im Allgemeinen nicht zweifelsfrei zugeordnet werden.
Ein Nachteil unserer Ableitungsfunktion, wie sie momentan implementiert ist, besteht darin, dass die
Schrittweite h in der Funktion fest vorgegeben ist. Der Wert von \(10^{-7}\) mag zwar vernünftig
gewählt sein, aber es wäre sinnvoll, wenn man diesen Wert bei Bedarf anpassen könnte. In einem
solchen Fall ist es möglich, einen so genannten Defaultwert zu definieren, der dann zum Tragen
kommt, wenn nichts anderes gesagt wird. Ein verbesserte Variante der Ableitungsfunktion könnte also
wie folgt aussehen.
def ableitung(f, x, h=1e-7):
df = (f(x+h)-f(x-h))/(2*h)
return df
Diese Funktion kann nun in verschiedener Weise aufgerufen werden. Zum einen können wir die früheren
Aufrufe übernehmen, wobei dann der Wert für h gleich dem angegebenen Defaultwert ist. Python wird
sich also nicht darüber beschweren, dass h nicht definiert sei.
ableitung(lambda x: x**3, 1)
3.000000000086267
Man kann aber auch den Wert von h vorgeben.
for n in range(1, 8):
print(ableitung(lambda x: x**3, 1, 10**-n))
3.0100000000000016
3.0001000000000055
3.0000009999998634
3.0000000099994484
3.000000000097369
2.9999999999197335
3.000000000086267
In diesem Fall werden die Argumente über ihre Position übergeben. Natürlich könnte man stattdessen auch Schlüsselwortargumente verwenden, zum Beispiel in der Form
for n in range(1, 8):
print(ableitung(lambda x: x**3, h=10**-n, x=1))
3.0100000000000016
3.0001000000000055
3.0000009999998634
3.0000000099994484
3.000000000097369
2.9999999999197335
3.000000000086267
Es sei noch einmal betont, dass in diesem Fall das Schlüsselwort x im letzten Argument nicht
entfallen kann, da sonst die Zuordnung nicht eindeutig ist.
ableitung(lambda x: x**3, h=10**-n, 1)
Cell In[32], line 1
ableitung(lambda x: x**3, h=10**-n, 1)
^
SyntaxError: positional argument follows keyword argument
Abschließend sehen wir uns zur Illustration noch ein Beispiel aus der Scipy-Bibliothek an, auf die wir im Kapitel 8 einen Blick werfen werden. Diese Bibliothek stellt neben vielem anderem eine Funktion zur numerischen Integration zur Verfügung, die 14 Argumente besitzt. Die ersten drei Argumente werden typischerweise über ihre Position übergeben, was sich unter anderem daraus ergibt, dass es sich hierbei um essentielle Argumente wie den Integranden und die Integrationsgrenzen handelt. Für diese Argumente gibt es keine sinnvollen Defaultwerte. Anders ist dies bei den restlichen elf Argumenten, für die Defaultwerte definiert sind, die bei Bedarf abgeändert werden können. Da diese Argumente mit Hilfe der Namen übergeben werden können, ist es problemlos möglich, nur eines der Argumente zu modifizieren ohne die in der Argumentliste davor stehenden Argumente angeben zu müssen.
from scipy import integrate
help(integrate.quad)
Help on function quad in module scipy.integrate._quadpack_py:
quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50, complex_func=False)
Compute a definite integral.
Integrate func from `a` to `b` (possibly infinite interval) using a
technique from the Fortran library QUADPACK.
Parameters
----------
func : {function, scipy.LowLevelCallable}
A Python function or method to integrate. If `func` takes many
arguments, it is integrated along the axis corresponding to the
first argument.
If the user desires improved integration performance, then `f` may
be a `scipy.LowLevelCallable` with one of the signatures::
double func(double x)
double func(double x, void *user_data)
double func(int n, double *xx)
double func(int n, double *xx, void *user_data)
The ``user_data`` is the data contained in the `scipy.LowLevelCallable`.
In the call forms with ``xx``, ``n`` is the length of the ``xx``
array which contains ``xx[0] == x`` and the rest of the items are
numbers contained in the ``args`` argument of quad.
In addition, certain ctypes call signatures are supported for
backward compatibility, but those should not be used in new code.
a : float
Lower limit of integration (use -numpy.inf for -infinity).
b : float
Upper limit of integration (use numpy.inf for +infinity).
args : tuple, optional
Extra arguments to pass to `func`.
full_output : int, optional
Non-zero to return a dictionary of integration information.
If non-zero, warning messages are also suppressed and the
message is appended to the output tuple.
complex_func : bool, optional
Indicate if the function's (`func`) return type is real
(``complex_func=False``: default) or complex (``complex_func=True``).
In both cases, the function's argument is real.
If full_output is also non-zero, the `infodict`, `message`, and
`explain` for the real and complex components are returned in
a dictionary with keys "real output" and "imag output".
Returns
-------
y : float
The integral of func from `a` to `b`.
abserr : float
An estimate of the absolute error in the result.
infodict : dict
A dictionary containing additional information.
message
A convergence message.
explain
Appended only with 'cos' or 'sin' weighting and infinite
integration limits, it contains an explanation of the codes in
infodict['ierlst']
Other Parameters
----------------
epsabs : float or int, optional
Absolute error tolerance. Default is 1.49e-8. `quad` tries to obtain
an accuracy of ``abs(i-result) <= max(epsabs, epsrel*abs(i))``
where ``i`` = integral of `func` from `a` to `b`, and ``result`` is the
numerical approximation. See `epsrel` below.
epsrel : float or int, optional
Relative error tolerance. Default is 1.49e-8.
If ``epsabs <= 0``, `epsrel` must be greater than both 5e-29
and ``50 * (machine epsilon)``. See `epsabs` above.
limit : float or int, optional
An upper bound on the number of subintervals used in the adaptive
algorithm.
points : (sequence of floats,ints), optional
A sequence of break points in the bounded integration interval
where local difficulties of the integrand may occur (e.g.,
singularities, discontinuities). The sequence does not have
to be sorted. Note that this option cannot be used in conjunction
with ``weight``.
weight : float or int, optional
String indicating weighting function. Full explanation for this
and the remaining arguments can be found below.
wvar : optional
Variables for use with weighting functions.
wopts : optional
Optional input for reusing Chebyshev moments.
maxp1 : float or int, optional
An upper bound on the number of Chebyshev moments.
limlst : int, optional
Upper bound on the number of cycles (>=3) for use with a sinusoidal
weighting and an infinite end-point.
See Also
--------
dblquad : double integral
tplquad : triple integral
nquad : n-dimensional integrals (uses `quad` recursively)
fixed_quad : fixed-order Gaussian quadrature
simpson : integrator for sampled data
romb : integrator for sampled data
scipy.special : for coefficients and roots of orthogonal polynomials
Notes
-----
For valid results, the integral must converge; behavior for divergent
integrals is not guaranteed.
**Extra information for quad() inputs and outputs**
If full_output is non-zero, then the third output argument
(infodict) is a dictionary with entries as tabulated below. For
infinite limits, the range is transformed to (0,1) and the
optional outputs are given with respect to this transformed range.
Let M be the input argument limit and let K be infodict['last'].
The entries are:
'neval'
The number of function evaluations.
'last'
The number, K, of subintervals produced in the subdivision process.
'alist'
A rank-1 array of length M, the first K elements of which are the
left end points of the subintervals in the partition of the
integration range.
'blist'
A rank-1 array of length M, the first K elements of which are the
right end points of the subintervals.
'rlist'
A rank-1 array of length M, the first K elements of which are the
integral approximations on the subintervals.
'elist'
A rank-1 array of length M, the first K elements of which are the
moduli of the absolute error estimates on the subintervals.
'iord'
A rank-1 integer array of length M, the first L elements of
which are pointers to the error estimates over the subintervals
with ``L=K`` if ``K<=M/2+2`` or ``L=M+1-K`` otherwise. Let I be the
sequence ``infodict['iord']`` and let E be the sequence
``infodict['elist']``. Then ``E[I[1]], ..., E[I[L]]`` forms a
decreasing sequence.
If the input argument points is provided (i.e., it is not None),
the following additional outputs are placed in the output
dictionary. Assume the points sequence is of length P.
'pts'
A rank-1 array of length P+2 containing the integration limits
and the break points of the intervals in ascending order.
This is an array giving the subintervals over which integration
will occur.
'level'
A rank-1 integer array of length M (=limit), containing the
subdivision levels of the subintervals, i.e., if (aa,bb) is a
subinterval of ``(pts[1], pts[2])`` where ``pts[0]`` and ``pts[2]``
are adjacent elements of ``infodict['pts']``, then (aa,bb) has level l
if ``|bb-aa| = |pts[2]-pts[1]| * 2**(-l)``.
'ndin'
A rank-1 integer array of length P+2. After the first integration
over the intervals (pts[1], pts[2]), the error estimates over some
of the intervals may have been increased artificially in order to
put their subdivision forward. This array has ones in slots
corresponding to the subintervals for which this happens.
**Weighting the integrand**
The input variables, *weight* and *wvar*, are used to weight the
integrand by a select list of functions. Different integration
methods are used to compute the integral with these weighting
functions, and these do not support specifying break points. The
possible values of weight and the corresponding weighting functions are.
========== =================================== =====================
``weight`` Weight function used ``wvar``
========== =================================== =====================
'cos' cos(w*x) wvar = w
'sin' sin(w*x) wvar = w
'alg' g(x) = ((x-a)**alpha)*((b-x)**beta) wvar = (alpha, beta)
'alg-loga' g(x)*log(x-a) wvar = (alpha, beta)
'alg-logb' g(x)*log(b-x) wvar = (alpha, beta)
'alg-log' g(x)*log(x-a)*log(b-x) wvar = (alpha, beta)
'cauchy' 1/(x-c) wvar = c
========== =================================== =====================
wvar holds the parameter w, (alpha, beta), or c depending on the weight
selected. In these expressions, a and b are the integration limits.
For the 'cos' and 'sin' weighting, additional inputs and outputs are
available.
For finite integration limits, the integration is performed using a
Clenshaw-Curtis method which uses Chebyshev moments. For repeated
calculations, these moments are saved in the output dictionary:
'momcom'
The maximum level of Chebyshev moments that have been computed,
i.e., if ``M_c`` is ``infodict['momcom']`` then the moments have been
computed for intervals of length ``|b-a| * 2**(-l)``,
``l=0,1,...,M_c``.
'nnlog'
A rank-1 integer array of length M(=limit), containing the
subdivision levels of the subintervals, i.e., an element of this
array is equal to l if the corresponding subinterval is
``|b-a|* 2**(-l)``.
'chebmo'
A rank-2 array of shape (25, maxp1) containing the computed
Chebyshev moments. These can be passed on to an integration
over the same interval by passing this array as the second
element of the sequence wopts and passing infodict['momcom'] as
the first element.
If one of the integration limits is infinite, then a Fourier integral is
computed (assuming w neq 0). If full_output is 1 and a numerical error
is encountered, besides the error message attached to the output tuple,
a dictionary is also appended to the output tuple which translates the
error codes in the array ``info['ierlst']`` to English messages. The
output information dictionary contains the following entries instead of
'last', 'alist', 'blist', 'rlist', and 'elist':
'lst'
The number of subintervals needed for the integration (call it ``K_f``).
'rslst'
A rank-1 array of length M_f=limlst, whose first ``K_f`` elements
contain the integral contribution over the interval
``(a+(k-1)c, a+kc)`` where ``c = (2*floor(|w|) + 1) * pi / |w|``
and ``k=1,2,...,K_f``.
'erlst'
A rank-1 array of length ``M_f`` containing the error estimate
corresponding to the interval in the same position in
``infodict['rslist']``.
'ierlst'
A rank-1 integer array of length ``M_f`` containing an error flag
corresponding to the interval in the same position in
``infodict['rslist']``. See the explanation dictionary (last entry
in the output tuple) for the meaning of the codes.
**Details of QUADPACK level routines**
`quad` calls routines from the FORTRAN library QUADPACK. This section
provides details on the conditions for each routine to be called and a
short description of each routine. The routine called depends on
`weight`, `points` and the integration limits `a` and `b`.
================ ============== ========== =====================
QUADPACK routine `weight` `points` infinite bounds
================ ============== ========== =====================
qagse None No No
qagie None No Yes
qagpe None Yes No
qawoe 'sin', 'cos' No No
qawfe 'sin', 'cos' No either `a` or `b`
qawse 'alg*' No No
qawce 'cauchy' No No
================ ============== ========== =====================
The following provides a short description from [1]_ for each
routine.
qagse
is an integrator based on globally adaptive interval
subdivision in connection with extrapolation, which will
eliminate the effects of integrand singularities of
several types.
qagie
handles integration over infinite intervals. The infinite range is
mapped onto a finite interval and subsequently the same strategy as
in ``QAGS`` is applied.
qagpe
serves the same purposes as QAGS, but also allows the
user to provide explicit information about the location
and type of trouble-spots i.e. the abscissae of internal
singularities, discontinuities and other difficulties of
the integrand function.
qawoe
is an integrator for the evaluation of
:math:`\int^b_a \cos(\omega x)f(x)dx` or
:math:`\int^b_a \sin(\omega x)f(x)dx`
over a finite interval [a,b], where :math:`\omega` and :math:`f`
are specified by the user. The rule evaluation component is based
on the modified Clenshaw-Curtis technique
An adaptive subdivision scheme is used in connection
with an extrapolation procedure, which is a modification
of that in ``QAGS`` and allows the algorithm to deal with
singularities in :math:`f(x)`.
qawfe
calculates the Fourier transform
:math:`\int^\infty_a \cos(\omega x)f(x)dx` or
:math:`\int^\infty_a \sin(\omega x)f(x)dx`
for user-provided :math:`\omega` and :math:`f`. The procedure of
``QAWO`` is applied on successive finite intervals, and convergence
acceleration by means of the :math:`\varepsilon`-algorithm is applied
to the series of integral approximations.
qawse
approximate :math:`\int^b_a w(x)f(x)dx`, with :math:`a < b` where
:math:`w(x) = (x-a)^{\alpha}(b-x)^{\beta}v(x)` with
:math:`\alpha,\beta > -1`, where :math:`v(x)` may be one of the
following functions: :math:`1`, :math:`\log(x-a)`, :math:`\log(b-x)`,
:math:`\log(x-a)\log(b-x)`.
The user specifies :math:`\alpha`, :math:`\beta` and the type of the
function :math:`v`. A globally adaptive subdivision strategy is
applied, with modified Clenshaw-Curtis integration on those
subintervals which contain `a` or `b`.
qawce
compute :math:`\int^b_a f(x) / (x-c)dx` where the integral must be
interpreted as a Cauchy principal value integral, for user specified
:math:`c` and :math:`f`. The strategy is globally adaptive. Modified
Clenshaw-Curtis integration is used on those intervals containing the
point :math:`x = c`.
**Integration of Complex Function of a Real Variable**
A complex valued function, :math:`f`, of a real variable can be written as
:math:`f = g + ih`. Similarly, the integral of :math:`f` can be
written as
.. math::
\int_a^b f(x) dx = \int_a^b g(x) dx + i\int_a^b h(x) dx
assuming that the integrals of :math:`g` and :math:`h` exist
over the interval :math:`[a,b]` [2]_. Therefore, ``quad`` integrates
complex-valued functions by integrating the real and imaginary components
separately.
References
----------
.. [1] Piessens, Robert; de Doncker-Kapenga, Elise;
Überhuber, Christoph W.; Kahaner, David (1983).
QUADPACK: A subroutine package for automatic integration.
Springer-Verlag.
ISBN 978-3-540-12553-2.
.. [2] McCullough, Thomas; Phillips, Keith (1973).
Foundations of Analysis in the Complex Plane.
Holt Rinehart Winston.
ISBN 0-03-086370-8
Examples
--------
Calculate :math:`\int^4_0 x^2 dx` and compare with an analytic result
>>> from scipy import integrate
>>> import numpy as np
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.) # analytical result
21.3333333333
Calculate :math:`\int^\infty_0 e^{-x} dx`
>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)
Calculate :math:`\int^1_0 a x \,dx` for :math:`a = 1, 3`
>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5
Calculate :math:`\int^1_0 x^2 + y^2 dx` with ctypes, holding
y parameter as 1::
testlib.c =>
double func(int n, double args[n]){
return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*
::
from scipy import integrate
import ctypes
lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
lib.func.restype = ctypes.c_double
lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
integrate.quad(lib.func,0,1,(1))
#(1.3333333333333333, 1.4802973661668752e-14)
print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
# 1.3333333333333333
Be aware that pulse shapes and other sharp features as compared to the
size of the integration interval may not be integrated correctly using
this method. A simplified example of this limitation is integrating a
y-axis reflected step function with many zero values within the integrals
bounds.
>>> y = lambda x: 1 if x<=0 else 0
>>> integrate.quad(y, -1, 1)
(1.0, 1.1102230246251565e-14)
>>> integrate.quad(y, -1, 100)
(1.0000000002199108, 1.0189464580163188e-08)
>>> integrate.quad(y, -1, 10000)
(0.0, 0.0)