Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.

...powered by haas.homelinux.net...

Inhaltsverzeichnis
1 Einleitung
2 Überblick über Python
3 Die Arbeit mit Python
4 Der interaktive Modus
5 Grundlegendes zu Python-Programmen
6 Kontrollstrukturen
7 Das Laufzeitmodell
8 Basisdatentypen
9 Benutzerinteraktion und Dateizugriff
10 Funktionen
11 Modularisierung
12 Objektorientierung
13 Weitere Spracheigenschaften
14 Mathematik
15 Strings
16 Datum und Zeit
17 Schnittstelle zum Betriebssystem
18 Parallele Programmierung
19 Datenspeicherung
20 Netzwerkkommunikation
21 Debugging
22 Distribution von Python-Projekten
23 Optimierung
24 Grafische Benutzeroberflächen
25 Python als serverseitige Programmiersprache im WWW mit Django
26 Anbindung an andere Programmiersprachen
27 Insiderwissen
28 Zukunft von Python
A Anhang
Stichwort

Download:
- ZIP, ca. 4,8 MB
Buch bestellen
Ihre Meinung?

Spacer
 <<   zurück
Python von Peter Kaiser, Johannes Ernesti
Das umfassende Handbuch - Aktuell zu Python 2.5
Buch: Python

Python
gebunden, mit CD
819 S., 39,90 Euro
Galileo Computing
ISBN 978-3-8362-1110-9
Pfeil 10 Funktionen
  Pfeil 10.1 Schreiben einer Funktion
  Pfeil 10.2 Funktionsparameter
    Pfeil 10.2.1 Optionale Parameter
    Pfeil 10.2.2 Schlüsselwortparameter
    Pfeil 10.2.3 Beliebige Anzahl von Parametern
    Pfeil 10.2.4 Seiteneffekte
  Pfeil 10.3 Zugriff auf globale Variablen
  Pfeil 10.4 Lokale Funktionen
  Pfeil 10.5 Anonyme Funktionen
  Pfeil 10.6 Rekursion
  Pfeil 10.7 Vordefinierte Funktionen

»Um Rekursion zu verstehen, muss man zunächst einmal Rekursion verstehen.« – Unbekannter Autor.

10 Funktionen

Wenn Sie mit dem Wissen, das wir Ihnen bisher über die Programmiersprache Python vermittelt haben, ein größeres Programm schreiben wollten, so wäre dies womöglich zum Scheitern verurteilt, da die Les- und Wartbarkeit unserer bisherigen Beispielquelltexte mit zunehmender Größe rapide abnehmen würde. Es ist daher ein erstrebenswertes Ziel, den Quelltext so übersichtlich und aufgeräumt zu gestalten, dass man sich selbst nach langen Programmierpausen problemlos wieder hineinlesen kann.

Ein zweites, viel gravierenderes Problem stellen Redundanzen im Code dar. In größeren Quelltexten gibt es eine Menge Operationen, die an unterschiedlichen Stellen genau so oder in ähnlicher Form immer wieder durchgeführt werden müssen. Aus Mangel an Alternativen würden Sie diese immer wieder genau da implementieren, wo sie gebraucht werden würden. Sie können sich sicherlich vorstellen, dass ein solcher Quelltext kein Paradebeispiel für sauberen Code darstellen würde.

Python ist, wie viele andere Programmiersprachen auch, eine funktionale Sprache. [Beachten Sie, dass es einen Unterschied zwischen funktionalen und rein funktionalen Programmiersprachen gibt. Als Vertreter rein funktionaler Programmiersprachen kann beispielsweise Haskell angesehen werden. ] Das bedeutet, dass Ihnen ein Hilfsmittel zur Seite gestellt wird, mit dem Sie Ihr Programm in Unterprogramme unterteilen können. Ein solches Unterprogramm wird Funktion genannt. Dadurch wird das Problem der dramatisch abnehmenden Übersichtlichkeit gelöst, denn Funktionen ermöglichen es Ihnen, gewisse Teile des Quellcodes zu kapseln, zu gruppieren oder von anderen Teilen abzugrenzen. Des Weiteren kann eine Funktion an beliebigen Stellen des Quellcodes beliebig oft aufgerufen werden, was es dem Programmierer in der Regel ermöglicht, Quellcode ohne Codedopplungen zu schreiben.

Damit eine Funktion korrekt arbeiten kann, müssen bei ihrem Aufruf möglicherweise Informationen übertragen werden. So sollte eine Funktion, die beispielsweise die Fakultät einer ganzen Zahl berechnet, wissen, von welcher Zahl die Fakultät zu berechnen ist. Dazu können beim Aufruf sogenannte Parameter übergeben werden. Zudem sollte eine Funktion dem aufrufenden, übergeordneten Programm das Ergebnis der Berechnung mitteilen können. Dazu verfügt jede Funktion über einen sogenannten Rückgabewert.

Sie haben, möglicherweise ohne das zu bemerken, bereits mit Funktionen gearbeitet: bei der Verwendung von len und range zum Beispiel. Im Folgenden möchten wir die Handhabung einer bestehenden Funktion am Beispiel von range erläutern.

Die eingebaute Funktion range wurde in Abschnitt 6.2.4 zum Steuern einer for-Schleife eingesetzt. Dort wurde sie in ihrer Bedeutung jedoch sehr reduziert dargestellt, denn eigentlich erzeugt range eine Liste mit einer begrenzten Anzahl von fortlaufenden, numerischen Elementen. Sie kann also durchaus ohne korrespondierende for-Schleife verwendet werden:

>>> range(0, 10, 1) 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Im obigen Beispiel wurde range aufgerufen, man nennt dies den Funktionsaufruf. Dazu wird hinter den Namen der Funktion ein (möglicherweise leeres) Klammernpaar geschrieben. Innerhalb dieser Klammern stehen, durch Kommata getrennt, die Parameter der Funktion. Wie viele es sind und welche Art von Parametern eine Funktion erwartet, hängt von ihrer Definition ab und ist sehr verschieden. In diesem Fall benötigt range drei Parameter, um ausreichend Informationen zu erlangen. Die Gesamtheit der Parameter wird Funktionsschnittstelle genannt. Konkrete, über eine Schnittstelle übergebene Instanzen werden Argumente genannt. Ein Parameter hingegen bezeichnet einen Platzhalter für Argumente.

Nachdem die Funktion abgearbeitet wurde, wird ihr Ergebnis, im Falle von range die erzeugte Liste, als Rückgabewert zurückgegeben. Sie können sich bildlich vorstellen, dass der Funktionsaufruf, wie er im Quelltext steht, durch den Rückgabewert ersetzt wird. Im obigen Beispiel wurde der Rückgabewert automatisch vom Interpreter ausgegeben. Es ist aber auch möglich, das Ergebnis zu referenzieren und weiterzuverwenden:

>>> liste = range(0, 10, 1) 
>>> liste 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> liste[5] 
5

So viel vorerst zur Verwendung von vordefinierten Funktionen. Python erlaubt es Ihnen, eigene Funktionen zu schreiben, die nach demselben Schema verwendet werden können, wie es hier beschrieben wurde. Im nächsten Abschnitt werden wir uns ausführlich damit befassen, wie eine eigene Funktion erstellt werden kann.


Galileo Computing - Zum Seitenanfang

10.1 Schreiben einer Funktion  topZur vorigen Überschrift

Bevor wir uns an konkreten Quelltext wagen, möchten wir rekapitulieren, was eine Funktion ausmacht, was also bei der Definition einer Funktion anzugeben wäre:

  • Eine Funktion muss einen Namen haben, über den sie in anderen Teilen des Programms aufgerufen werden kann. Die Zusammensetzung des Funktionsnamens erfolgt nach denselben Regeln wie die Namensgebung einer Referenz.
  • Eine Funktion muss eine Schnittstelle haben, über die Informationen vom aufrufenden Programmteil in den Kontext der Funktion übertragen werden können. Eine Schnittstelle kann aus beliebig vielen (unter Umständen auch keinen) Parametern bestehen. Funktionsintern wird jedem dieser Parameter ein Name gegeben. Sie lassen sich dann wie Referenzen im Funktionskörper verwenden.
  • Eine Funktion muss einen Wert zurückgeben. Jede Funktion gibt automatisch None zurück, wenn der Rückgabewert nicht ausdrücklich angegeben wurde.

Zur Definition einer Funktion wird in Python das Schlüsselwort def verwendet. Syntaktisch sieht die Definition folgendermaßen aus:

Abbildung 10.1  Definition einer Funktion

Nach dem Schlüsselwort def steht der gewählte Funktionsname. Hinter diesem werden in einem Klammernpaar die Namen aller Parameter aufgelistet. Nach der Definition der Schnittstelle folgen ein Doppelpunkt und, eine Stufe weiter eingerückt, der Funktionskörper. Bei dem Funktionskörper handelt es sich um einen beliebigen Codeblock, in dem die Parameternamen als Referenzen verwendet werden dürfen. Im Funktionskörper dürfen auch wieder Funktionen aufgerufen werden.

Betrachten wir einmal die konkrete Implementierung einer Funktion, die die Fakultät einer ganzen Zahl berechnet und das Ergebnis auf dem Bildschirm ausgibt:

def fak(zahl): 
    ergebnis = 1 
    for i in range(2, zahl+1): 
        ergebnis *= i 
    print ergebnis

Anhand dieses Beispiels können Sie sehr gut nachvollziehen, wie der Parameter zahl im Funktionskörper verarbeitet wird. Nachdem die Berechnung vollzogen ist, wird ergebnis mittels print ausgegeben. Beachten Sie, dass die Referenz zahl nur innerhalb des Funktionskörpers definiert ist und nichts mit anderen Referenzen außerhalb der Funktion zu tun hat.

Wenn Sie das obige Beispiel jetzt speichern und ausführen, werden Sie feststellen, dass zwar keine Fehlermeldung angezeigt wird, aber auch sonst nichts passiert. Nun, das liegt daran, dass wir bisher nur eine Funktion definiert haben. Um sie konkret im Einsatz zu sehen, müssen wir sie mindestens einmal aufrufen. Folgendes Programm liest in einer Schleife Zahlen vom Benutzer ein und berechnet deren Fakultät:

def fak(zahl): 
    ergebnis = 1 
    for i in range(2, zahl+1): 
        ergebnis *= i 
    print ergebnis 
 
while True: 
    eingabe = int(raw_input("Geben Sie eine Zahl ein: ")) 
    fak(eingabe)

Sie sehen, dass der Quellcode sehr schön in zwei Komponenten aufgeteilt wurde: zum einen in die Funktionsdefinition oben und zum anderen in das auszuführende Hauptprogramm unten. Das Hauptprogramm besteht aus einer Endlosschleife, in der im Wesentlichen die Funktion fak mit der eingegebenen Zahl als Parameter aufgerufen wird.

Betrachten Sie noch einmal die beiden Komponenten des Programms. Es wäre erstrebenswert, das Programm so zu ändern, dass sich das Hauptprogramm allein um die Interaktion mit dem Benutzer und das Anstoßen der Berechnung kümmert, während das Unterprogramm fak die Berechnung tatsächlich durchführt. Das Ziel dieses Ansatzes ist es vor allem, dass die Funktion fak auch in anderen Programmteilen zur Berechnung einer weiteren Fakultät aufgerufen werden kann. Dazu ist es unerlässlich, dass fak sich ausschließlich um die Berechnung kümmert. Es passt nicht wirklich in dieses Konzept, dass fak das Ergebnis der Berechnung selbst ausgibt.

Idealerweise sollte unsere Funktion fak die Berechnung abschließen und das Ergebnis an das Hauptprogramm zurückgeben, sodass die Ausgabe dort erfolgen kann. Dies kann durch das Schlüsselwort return erreicht werden, das die Ausführung der Funktion sofort beendet und einen eventuell angegebenen Rückgabewert zurückgibt.

def fak(zahl): 
    ergebnis = 1 
    for i in range(2, zahl+1): 
        ergebnis *= i 
    return ergebnis 
 
while True: 
    eingabe = int(raw_input("Geben Sie eine Zahl ein: ")) 
    print fak(eingabe)

Das Beenden einer Funktion mit return kann zu jeder Zeit im Funktionsablauf geschehen. Folgende Version der Funktion prüft vor der Berechnung, ob es sich bei dem übergebenen Parameter um eine negative Zahl handelt. Ist das der Fall, so wird die Abhandlung der Funktion sofort abgebrochen:

def fak(zahl): 
    if zahl < 0: 
        return None 
    ergebnis = 1 
    for i in range(2, zahl+1): 
        ergebnis *= i 
    return ergebnis 
 
while True: 
    eingabe = int(raw_input("Geben Sie eine Zahl ein: ")) 
    ergebnis = fak(eingabe) 
    if ergebnis is None: 
        print "Fehler bei der Berechnung" 
    else: 
        print ergebnis

In der zweiten Zeile des Funktionskörpers wurde mit return None explizit der Wert None zurückgegeben. Das ist nicht unbedingt nötig; folgender Code wäre äquivalent:

if zahl < 0: 
    return

Vom Programmablauf her ist es egal, ob Sie None explizit oder implizit zurückgeben. Aus Gründen der Lesbarkeit ist return None in diesem Fall trotzdem sinnvoll, denn es handelt sich um einen ausdrücklich gewünschten Rückgabewert. Er ist Teil der Funktionslogik und nicht bloß ein Nebenprodukt, das beim Funktionsabbruch entsteht.

Die Funktion fak, wie sie in diesem Beispiel zu sehen ist, kann zu jeder Zeit zur Berechnung einer Fakultät aufgerufen werden, unabhängig davon, in welchem Kontext diese Fakultät benötigt wird.

Selbstverständlich können Sie in Ihrem Quelltext mehrere eigene Funktionen definieren und aufrufen. Das folgende Beispiel soll bei Eingabe einer negativen Zahl keine Fehlermeldung, sondern die Fakultät des Betrages dieser Zahl ausgeben:

def betrag(zahl): 
    if zahl < 0: 
        return -zahl 
    else: 
        return zahl 
 
def fak(zahl): 
    ergebnis = 1 
    for i in range(2, zahl+1): 
        ergebnis *= i 
    return ergebnis 
 
while True: 
    eingabe = int(raw_input("Geben Sie eine Zahl ein: ")) 
    print fak(betrag(eingabe))

Für die Berechnung des Betrags einer Zahl gibt es in Python auch die Built-in Function abs. Diese werden wir noch in diesem Kapitel besprechen.

Ein Begriff soll noch eingeführt werden, bevor wir uns den Funktionsparametern widmen. Eine Funktion kann über ihren Namen nicht nur aufgerufen, sondern auch wie eine Instanz behandelt werden. So ist es beispielsweise möglich, den Typ einer Funktion abzufragen. Die folgenden Beispiele nehmen an, dass die Funktion fak im interaktiven Modus verfügbar ist:

>>> type(fak) 
<type 'function'> 
>>> p = fak 
>>> p(5) 
120 
>>> fak(5) 
120

Der Name der Funktion, in diesem Fall fak, wird aufgrund dieser Eigenschaften auch Funktionsobjekt genannt.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






 <<   zurück
  
  Zum Katalog
Zum Katalog: Python






Python
bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Linux






 Linux


Zum Katalog: Ubuntu GNU/Linux






 Ubuntu GNU/Linux


Zum Katalog: Praxisbuch Web 2.0






 Praxisbuch Web 2.0


Zum Katalog: UML 2.0






 UML 2.0


Zum Katalog: Praxisbuch Objektorientierung






 Praxisbuch Objektorientierung


Zum Katalog: Einstieg in SQL






 Einstieg in SQL


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für Fachinformatiker


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo