| Was werden wir behandeln? |
|---|
In jeder kreativen Tätigkeit benötigt man drei Grundzutaten: Werkzeuge, Materialien und Techniken. Zum Beispiel wenn ich male, sind meine Werkzeuge Pinsel, Stifte und Paletten. Die Techniken sind Dinge wie 'Verwaschen', Nass in Nass, Vermischen, Sprühen usw. Schließlich sind die Materialien Farben, Papier und Wasser. Ähnlich ist es, wenn ich programmiere, meine Werkzeuge sind die Programmiersprachen, Betriebssysteme und die Hardware. Die Techniken sind die Programmierkonstrukte, die wir in dem vorhegehenden Teil diskutiert haben, und das Material sind die Daten, die ich manipuliere. In diesem Kapitel betrachten wir die Materialien zum Programmieren.
Dies ist sicherlich ein langer Teil und von seiner Natur her wirst du ihn etwas trocken finden; die gute Nachricht ist jedoch, dass du nicht alles auf einmal lesen musst. Das Kapitel geht los mit den am meisten verwendeten Grund-Datentypen, dann gehen wir zur Behandlung von Sammlungen von Gegenständen über und betrachten abschließend ein etwas mehr fortgeschrittenes Material. Es ist durchaus möglich, von diesem Kapitel nach den Sammlungen abzuspringen, und sich mit einigen nachfolgenden Kapiteln zu beschäftigen, um dann an den Beginn des harten Bissens für Fortgeschrittene wieder aufzuspringen.
Daten ist einer derjenigen Begriffe, die jedermann verwendet,
aber nur wenige richtig verstehen. Mein Wörterbuch definiert sie
so:
"Tatsachen oder Zahlen, aus denen Schlussfolgerungen gezogen werden können; Information"
Das ist keine große Hilfe, aber es gibt uns dennoch einen Ansatzpunkt. Schauen wir einmal, ob wir die Sache klären können, indem wir nachschauen, wie Daten in der Begriffswelt des Programmierens verwendet werden. Daten sind der “Stoff”, die rohe Information, die unser Prgramm bearbeitet. Ohne Daten kann ein Programm keine sinnvolle Funktion ausführen. Programme manipulieren Daten auf viele Arten, oftmals abhängig vom Daten-Typ. Jeder Datentyp hat auch eine Anzahl von Operationen - Dinge die etwas tun können. Zum Beispiel haben wir gesehen, dass wir Zahlen zusammen addieren können. Die Addition ist eine Operation für den Datentyp Zahl. Daten erscheinen in vielen Typen und wir werden jeden der meisten allgemeinen Typen und die für diese Datentypen zuständigen Operationen betrachten:
Daten sind im Speicher deines Computers abgespeichert. Wenn du magst, stelle dir eine riesige Wand voll mit Briefkästen vor, wie sie in Posträumen verwendet werden, um die Post zu sortieren. Du kannst einen Brief in irgendeinen Kasten stecken, aber wenn die Briefkästen nicht mit einem Etikett mit Zustellanschrift beschriftet sind, ist dies ziemlich zwecklos. Variablen sind die Etiketten auf den Briefkästen des Speichers deines Computers.
Zu wissen, wie Daten aussehen, ist zwar eine feine Sache, doch um sie manipulieren zu können, müssen wir fähig sein, auf sie zugreifen zu können und das ist es, wozu Variablen benutzt werden. In der Ausdrucksweise des Programmierens können wir Instanzen von Datentypen erzeugen und diese Variablen zuordnen. Eine Variable ist eine Referenz für einen spezifischen Bereich im Speicher des Computers. Diese Bereich trägt die Daten. In einigen Computersprachen muss eine Variable genau auf den Datentyp passen, auf den sie verweist. Jeder Versuch einer falschen Datentypzuweisung wird einen Fehler verursachen. Einige Programmierer bevorzugen eine solche Art von Sytem, bekannt als statische Typisierung, weil es vor subtilen Bugs schützen kann, die schwierig zu detektieren sind.
In Python übernimmt eine Variable den Datentyp, der ihr zugewiesen wird. Sie wird diesen Typ beibehalten und du erhältst eine Warnung, wenn du die Daten auf unbekannte Art vermischen willst - so als wenn du versuchst, einen String zu einer Zahl zu addieren. (Erinnerst du dich an die Beispiel-Fehlermeldung? Sie war ein Beispiel für eine solche Art von Fehler.) Wir können den Datentyp ändern, auf die eine Variable zeigt, indem wir die Variable neu zuweisen.
>>> q = 7 # q ist jetzt eine Zahl >>> print q 7 >>> q = "Sieben" # Neuzuweisung von q auf einen String >>> print q Sieben
Beachte, daß q von Anfang an so gesetzt worden ist, dass es auf die Zahl 7 weist. Es unterstützt diesen Wert solange, bis wir veranlassen, dass es auf den Charakter-String "Sieben" verweist. Das bedeutet, Python-Variablen unterstützen immer den Typ, auf den sie verweisen, aber wir können einfach ändern, auf was sie verweisen, indem wir die Variable neu zuweisen. An diesem Punkt ist der ursprüngliche Wert 'verloren' und Python löscht es aus seinem Gedächtnis (außer eine ander Variable verweist auch darauf); dies ist bekannt als Garbage Collection.
Garbage Collection kann mit dem Postangestellten verglichen werden, der ab und zu vorbeischaut, und jedes Päckchen entfernt, das in Kästen ohne Beschriftung liegt. Wenn er keinen Besitzer oder eine Adresse auf dem Paket finden kann, dann wirft er es in den Müll. Werfen wir einen Blick auf einige Beispiele von Datentypen und schauen wir einmal, wie das alles zusammenpasst.
Primitive Datentypen werden so genannt, weil sie die grundlegendsten Datentypen sind, die wir beeinflussen können. Komplexere Datentypen sind in Wirklichkeit Kombinationen der primitiven Typen. Diese sind die Bausteine mit denen alle anderen Typen aufgebaut sind; sie sind das Fundament des Computerns. Sie umfassen Buchstaben, Zahlen und etwas, das der Bool'sche Typ genannt wird.
Wir haben diese schon gesehen. Sie sind wörtlich eine Kette oder Abfolge von Schriftzeichen, die auf dem Bildschirm ausgedruckt werden können. (Es gibt sogar auch nicht-ausdruckbare Kontroll-Character).
In Python können Strings auf verschieden Arten dargestellt werden:
Mit einfachen Anführungszeichen:
'Hier ist ein String'
Mit doppelten Anführungszeichen:
"Hier ist ein sehr ähnlicher String"
Mit dreifach doppelten Anführungszeichen:
""" Hier ist ein sehr langer String, der sich,
falls wir es wünschen, über mehrere Zeilen erstreckt und Python wird
die Zeilen vorsehen, die wir eingeben..."""
Ein spezieller Gebrauch der letzten Form ist das Einbauen von Dokumentation in Python-Funktionen, die wir selbst bilden - wir werden das später sehen.
Du kannst auf die individuellen Zeichen in einem String zugreifen, indem du sie als ein Feld (array) von Zeichen behandelst (mehr zu Arrays siehe unten). Es gibt gewöhnlicherweise auch einige Operatoren zum Manipulieren von Strings, mit denen die Programmiersprache ausgestattet ist - finden eines Unterstrings, verbinden zweier Strings, kopieren von einem zu einem anderen usw.
Es gibt eine Vielzahl an Operatoren, die auf Strings angewendet werden können. Einige von diesen sind in Python eingebaut, aber viele andere werden von Modulen unterstützt, die du importieren musst (so wie wir es mit sys im Abschnitt über einfache Sequenzen getan haben).
| Operator | Beschreibung |
|---|---|
| S1 + S2 | Verkettung von S1 und S2 |
| S1 * N | N Wiederholungen von S1 |
In den folgenden Beispielen können wir diese in Aktion sehen:
>>> print 'Wieder und ' + 'wieder' # String-Verkettung Wieder und wieder >>> print 'Wiederholung ' * 3 # String-Wiederholung Wiederholung Wiederholung Wiederholung >>> print 'Wieder ' + ('und wieder ' * 3) # Kombination von '+' und '*' Wieder und wieder und wieder und wieder
Wir können Zeichenstrings auch Variablen zuweisen:
>>> s1 = 'Wieder ' >>> s2 = 'und wieder ' >>> print s1 + (s2 * 3) Wiedr und wieder und wieder und wieder
Beachte, dass die letzten beiden Beispiele jeweils das Gleiche ausgeben.
Wenn in BASIC eine Variable eine Stringvariable ist, musst du ihren Namen mit einem $ abschliessen. Hast du das getan, so kannst du ihr nie eine Zahl zuweisen. Ähnlich ist es bei einer Integervariablen ( sie endet mit %), du kannst ihr keinen String zuweisen. BASIC erlaubt sog. 'anonyme Variable', die mit keinem speziellen Zeichen enden. Diese können nur Zahlen speichern, entweder Realzahlen oder Ganzzahlen, aber nur Zahlen. Hier ist ein Beispiel einer Stringvariable in BASIC:
DIM MeinString$ MeinString$ = "Hallo du da!" PRINT MeinString$
Tcl benutzt intern für alles Strings. Vom Blickwinkel des Benutzers ist dies nicht ganz ersichtlich. Um explizit mit einem String zu hantieren, hast du ihn mit doppelten Anführungszeichen zu umgeben. Um einen Wert einer Variablen zuzuweisen, benutzt man in Tcl den set-Befehl und zum Lesen einer Stringvariablen (oder auch einer jeden anderen Variablen in Tcl) setze ein '$' an den Namensbeginn, nämlich so:
% set Meinstring "Hallo Welt" % put $Meinstring
Anmerkung: Sowohl in Tcl als auch in BASIC sind nur doppelte Anführungszeichen erlaubt.
Integer sind Ganzzahlen von einem großen negativen Wert hin zu einem großen positiven Wert. Dies ist ein besonders zu beachtnder Punkt. Normalerweise denken wir bei Zahlen nicht daran, daß sie in ihre Größe eingeschränkt sind, aber im Computer gibt es obere und untere Grenzen. Die Größe der oberen Grenze ist bekannt als MAXINT und ist abhängig von der Anzahl der Bits, die dein Computer verwendet, um eine Zahl darzustellen. Auf den meisten heutigen Rechnern sind es 32 Bits, so dass MAXINT ungefähr um die 2 Billionen liegt.
Zahlen mit positiven und negativen Werten sind bekannt als Signed Integers. Du kannst auch unsigned Integers (vorzeichenlose Ganzzahlen) erhalten, die nur auf positive Zahlen, einschließlich der Null, beschränkt sind. Das bedeutet, daß es dabei einen größeren Maximalwert von ungefähr 2 * MAXINT oder 4 Billion auf einem 32 Bit-Rechner gibt, so dass wir den ursprünglich für negative Zahlen vorgesehenen Platz für größere positive Zahlen verwenden können.
Aufgrund der Einschränkung von Integer in ihrer Größe auf MAXINT, führt das Addieren zweier Integer zu einem falschen Ergebnis, wenn die Summe größer als MAXINT ist. In einigen Sytemen/Sprachen wird der falsche Wert geradeso ausgegeben, wie er ist (gewöhnlich mit einer Art geheimen Markierung (Flag), die du überprüfen kannst, wenn du denkst, dass sie gesetzt ist). Normalerweise wird ein Fehlerzustand angezeigt und entweder dein Programm kann den Fehler behandeln oder das Programm wird auf Exit gehen. Python verhält sich nach der letzten Möglichkeit, währen Tcl sich nach der vorhergehenden verhält. BASIC wirft einen Fehler aus, unterstützt aber keine Möglichkeit, diesen abzufangen (zumindest weiß ich nicht wie!).
Wir haben die meisten arithmetischen Operatoren, die du brauchen kannst, schon im Teil 'Einfache Sequenzen' aufgeführt, dennoch rekapitulieren wir:
| Operator mit Beispiel | Beschreibung |
|---|---|
| M + N | Addition von M und N |
| M - N | Subtraktion N von M |
| M * N | Multiplikation von M mit N |
| M / N | Division, entweder Ganzzahl oder Fließkommazahl als Ergebnis, abhängig vom Typ von M und N. Falls M oder N Realzahlen sind (s.u.), ist das Ergebnis real. |
| M % N | Modulo: findet den Rest von of M dividiert durch N |
| M**N | Exponentiation: M potenziert mit N |
Wir haben das Letzte vorher noch nicht gesehen, so dass wir uns jetzt ein Beispiel anschauen, bei dem wir einige Integervariablen erzeugen und den Exponential-Operator verwenden:
>>> i1 = 2 # erzeugt einen Integer und weist ihn i1 zu >>> i2 = 4 >>> i3 = 2**4 # weist das Ergebnis von 2 hoch 4 der Variablen i3 zu >>> print i3 16
BASIC hat einige Sonderregeln bezüglich Integern. Um in BASIC eine Integervariable zu deklarieren, kannst du entweder einen vollständig ungekennzeichneten Namen verwenden oder du kannst BASIC mitteilen, daß es sich um einen Integer handelt, den wir zu speichern wünschen (was etwas effektiver ist). Wir tun dies, indem wir den Namen mit '%' enden lassen:
FOO = 8 REM FOO kann jede Art von Zahl enthalten BAR% = 9 REM BAR kann nur Integer enthalten
Ein Gotcha zum Abschluß mit Integervariablen in BASIC:
i% = 7 PRINT 2 * i% i% = 4.5 PRINT 2 * i%
Beachte, dass die Zuweisung von 4.5 auf i% scheinbar funktioniert, aber tatsächlich wird nur der ganzzahlige Teil zugewiesen. Das erinnert an die Art, wie Python die Division von Integern behandelt. Alle Programmiersprachen haben ihre eigenen kleinen Eigenheiten wie diese!
Wie schon vorher angedeutet, speichert Tcl alles intern als Strings; dennoch macht dies keinen Unterschied für den Anwender, weil Tcl die Werte als Zahlen verdeckt hin und wieder zurück konvertiert, so wie sie waren. Alle anderen Einschränkungen der Zahlengrößen werden auch hier angewandt.
Der Gebrauch von Zahlen in Tcl ist etwas komplexer, als in den meisten anderen Sprachen, da du jedesmal wenn eine Berechnung durchzuführen ist, dem Interpreter signalisieren mußt, daß eine Berechnung erforderlich ist. Du tust das mit dem expr Kommando:
% put [expr 6 + 5] 11
Tcl sieht die eckigen Klammern und wertet diesen Teil zuerst aus, so als wäre dieser allein in die Befehlszeile eingetippt worden. Während dies geschieht, erkennt es den expr - Befehl und es macht die Berechnung. Das Ergebnis kommt dann durch put auf den Bildschirm. Beim Versuch mit put direkt die Summe einzugeben, wird Tcl nur "6 + 5" ausgeben:
% put 6 + 5 6 + 5
Diese sind gebrochen. Sie können sehr große Zahlen repräsentieren, viel größer als MAXINT, aber mit geringerer Genauigkeit. So kann man sagen, wenn 2 Realzahlen, die identisch sein sollten, dies nicht unbedingt sind, wenn sie vom Computer miteinader verglichen werden. Dies ist deshalb so, weil der Computer die kleinen Anteile nur annähert. So kann 4.0 durch den Computer als 3.9999999.... oder 4.0000001 dargestellt werden. Diese Annäherungen sind für die meisten Anwendungen ausreichend, aber in manchen Fällen werden sie bedeutend. Wenn du einmal ein unsinniges Ergebnis bei dem Gebrauch von Realzahlen erhältst, so behalte dies im Hinterkopf.
Fließkommazahlen haben die gleichen Operatoren, wie Integer mit der zusätzlichen Möglichkeit, die Zahl auf einen Integerwert zu runden.
Falls du einen wissenschaftlichen oder mathematischen Hintergrund hast, wirst du dann noch etwas über komplexe Zahlen wissen wollen ? Wenn nicht, so hast du noch nichts über komplexe Zahlen gehört! Irgendwie besitzt jede Programmiersprache, einschließlich Python, entweder eine eingebaute Unterstützung für den Komplex-Typ, während andere eine Funktionenbibliothek verwenden, die mit komplexen Zahlen operieren können. Und bevor du noch fragst, dasselbe gilt auch für Matrizen.
In Python wird eine komplexe Zahl representiert als:
(real+imaginaryj)
So sieht dann eine einfache Addition mit komplexen Zahlen aus:
>>> M = (2+4j) >>> N = (7+6j) >>> print M + N (9+10j)
Alle Integer-Operationen lassen sich auch auf komplexe Zahlen anwenden.
Wie die Überschrift sagt, hat dieser Typ nur 2 Werte - entweder wahr (true) oder falsch (false). Einige Sprachen unterstützen Bool'sche Werte direkt, andere verwenden eine Absprache, bei der numerische Werte (meistens 0) falsch repräsentieren und andere (meist 1 oder -1) wahr repräsentieren.
Boole'sche Werte sind manchmal bekannt als "Wahrheitswerte", weil sie verwendet werden, um zu überprüfen, ob etwas stimmt oder nicht. Zum Beispiel wenn du ein Programm schreibst, um Sicherheitskopien aller Dateien in einem Verzeichns zu erstellen, so wirst du jedes einzelne File abspeichern und das Betriebssystem nach dem Namen der nächsten Datei abfragen. Wenn keine Dateien mehr vorhanden sind, wird es einen leeren String zurückgeben. Um zu sehen, ob der Name ein leerer String ist, kannst du das Ergebnis als Boole'schen Wert abspeichern (wahr ist leer). Du wirst die Anwendung des Ergebnisses später in diesem Kurs sehen.
| Operator mit Beispiel | Beschreibung | Auswirkung |
|---|---|---|
| A and B | UND | Wahr, wenn A,B beide wahr sind, andernfalls falsch. |
| A or B | ODER | Wahr wenn entweder einer oder beide von A,B wahr sind. Falsch,wenn beide A und B falsch sind. |
| A == B | Gleichheit | Wahr, wenn A gleich B ist. |
| A != B or A <> B |
Ungleichheit | Wahr, wenn A NICHT gleich B ist. |
| not B | Negation | Wahr, wenn B nicht wahr ist. |
Anmerkung: Das Letzte wirkt nur auf einen einzelnen Wert, die anderen vergleichen immer zwei Werte.
Die Computerwissenschaft hat eine komplette Diziplin zum Studium von Sammlungen und ihr unterschiedliches Verhalten geschaffen. Manchmal werden Sammlungen auch als Container beteichnet. In diesem Abschnitt schauen wir uns zuerst alle von Python unterstützten Sammlungen an und werden dann mit einer kurzen Übersicht über Sammlungstypen, die dir bei anderen Programmiersprachen über den Weg laufen, abschließen.
Eine Liste ist eine Abfolge (Sequenz) von Bestandteilen. Was diese von einem Feld (Array) unterscheidet, ist, daß sie wachsen kann - du addierst nur ein anderes Teil. Aber eine Indexierung ist nicht üblich, so dass du, um das Teil zu finden, das du brauchst, durch die Liste von Anfang bis Ende durchgehen mußt, um jedes Teil zu testen, ob es dasjenige ist, das du brauchst. Python and Tcl haben beide Listen in die Sprache eingebaut. In BASIC ist es schwieriger und wir müssen trickreich programmieren, um sie zu simulieren. BASIC-Programmierer erschaffen üblicherweise sehr große Arrays an ihrer Stelle. Python erlaubt dir auch eine Liste zu indizieren. Wie wir sehen werden ist dies eine sehr nützliche Eigenschaft.
Python unterstützt viele Operationen für Sammlungen. Nahezu alle werden auf Listen angewendet, und nur ein geringer Teil auf andere Sammlungs-Typen, einschließlich Strings, die ja ein besonderer Typ von Zeichen-Liste ist. Um eine Liste zu erstellen und auf sie zugreifen zu können, benutzen wir in Python eckige Klammern. Du kannst eine leere Liste erzeugen, indem du zwei leere eckige klammern ohne Inhalt verwendest, oder eine gefüllte Liste, indem die Werte innerhalb der eckigen Klammer durch Kommata getrennt werden:
>>> eineListe = [] >>> eineandere = [1,2,3] >>> print eineandere [1, 2, 3]
Wir können auf die einzelnen Elemente zugreifen, indem wir eine Indexnummer innerhalb eckiger Klammern verwenden, wobei das erste Element 0 ist:
>>> print eineandere[2] 3
Wir können auf eine ähnliche Art auch den Wert von Elementen verändern:
>>> eineandere[2] = 7 >>> print eineandere [1, 2, 7]
Du kannst negative Indexzahlen verwenden um Bestandteile vom Ende der Liste aus aufzurufen. Dies wird allgemein durch die Verwendung von -1 , um das letzte Listenteil zu erhalten, durchgeführt:
>>> print eineandere[-1] 7
Wir können auch neue Elemente an das Ende der Liste hinzufügen, indem wir den append()-Operator verwenden:
>>> eineListe.append(42) >>> print eineListe [42]
Wir können sogar eine Liste innerhalb einer anderen aufbewahren, indem wir unsere zweite Liste an die erste anhängen:
>>> eineListe.append(eineandere) >>> print eineListe [42, [1, 2, 7]]
Beachte, dass das Ergebnis eine Liste aus zwei Elementen, aber das zweite Element nochmals selbst eine Liste ist (erkenntlich an den [] drumrum). Dies ist ganz nützlich, da es die Darstellung von Tafeln oder Tabellen mit Listen von Listen ermöglicht. Wir können dann auf das Element 7 unter Verwendung eines Doppelindex zugreifen:
>>> print eineListe[1][2] 7
Der erste Index, 1, zieht das zweite Element heraus, das eine Liste ist. Der zweite Index, 2, sondert das dritte Element der Unterliste aus.
Das Gegenteil des Addierens von Elementen, ist ihr Entfernen und um dies zu tun, benutzen wir den del Befehl:
>>> del eineListe[1] >>> print eineListe [42]
Wenn wir zwei Listen miteinander zu einer verbinden möchten, so können wir den gleichen Verkettungsoperator ‘+’ verwenden, den wir uns bei Strings angeschaut haben:
>>> neueListe = eineListe + eineandere >>> print neueListe [42, [1, 2, 7], 1, 2, 7]
In gleicher Weise können wir den Wiederholungsoperator anwenden, um eine Liste zu einem Vielfachen des gleichen Wertes zu vermehren:
>>> nullListe = [0] * 5 >>> print nullListe [0, 0, 0, 0, 0]
Zum Schluss können wir noch die Länge einer Liste begrenzen, indem wir die eingebaute Funktion len() verwenden:
>>> print len(eineListe) 2 >>> print len(nullListe) 5
Tcl hat ebenfalls einen eingebauten Listentyp und eine Vielzahl an Kommandos um mit diesen Listen zu operieren. Diese Befehle sind identifizierbar durch das 'l'-Präfix, zum Beispiel linsert, lappend, lindex, usw. Ein Beispiel zur Erzeugung einer einfachen Tcl-Liste und der Zugriff auf ein Bestandteil folgt:
% set L [list 1 2 3] % put [lindex $L 2] 3
Nicht jede Sprache unterstützt ein Tuple-Konstrukt, aber in denjenigen, die dies tun, ist das extrem nützlich. Ein Tupel ist eine willkürliche Sammlung von Werten, die als eine Einheit behandelt werden können. In vielen Fällen ist ein Tuple wie eine Liste, aber mit dem signifikanten Unterschied, dass Tuples unveränderlich sind; was bedeutet, dass du sie weder verändern noch erweitern kannst, sobald sie einmal erzeugt sind. In Python werden Tuples einfach durch runde Klammern dargestellt, die eine Liste mit durch Kommata getrennten Werten enthält, wie: