Alles ist ein Objekt

1.1 Objekte und Klassen

Heute erfährst du, wie ein typisches Python-Programm aufgebaut ist. Und die Hauptnachricht ist: Jedes Programm in Python besteht aus Klassen und Objekten. Python ist eine objektorientierte Sprache und alles darin ist ein Objekt: Zahlen, Strings, Funktionen und sogar Klassen sind Objekte.

Was sind also Klassen?

Ich beginne mit einer Analogie. Stell dir vor, du möchtest ein kleines Schiff bauen. Zuerst musst du eine Zeichnung anfertigen, diese dann an die Fabrik geben, wo nach diesem Plan das Schiff gebaut wird. Oder ein Dutzend. Im Grunde beliebig viele Schiffe. Aus einem Plan werden dutzende identische Schiffe gebaut, das ist wichtig.

In der Programmierung mit Python ist es genau dasselbe.

Zeichnungen

Ein Programmierer ist wie ein Designer. Nur dass ein Designer Zeichnungen anfertigt, während ein Python-Programmierer Klassen schreibt. Dann werden basierend auf den Zeichnungen Teile erstellt und basierend auf den Klassen Objekte.

Zuerst schreiben wir Klassen (erstellen die Zeichnungen) und dann, während das Programm ausgeführt wird, erstellt Python basierend auf diesen Klassen Objekte. Genau wie Schiffe auf der Grundlage von Zeichnungen gebaut werden.

Es gibt eine Zeichnung, aber viele Schiffe. Die Schiffe sind unterschiedlich, sie haben unterschiedliche Namen, transportieren unterschiedliche Lasten. Aber sie sind sich sehr ähnlich: Sie sind allesamt Schiffe mit identischem Design und können ähnliche Aufgaben ausführen.

Oder hier ist eine andere Analogie...

Ameisenhügel

Ein Ameisenhügel ist ein schönes Beispiel für die Interaktion von Objekten. Im einfachsten Ameisenhügel gibt es drei Klassen von Ameisen: Königin, Krieger und Arbeiterameisen.

Die Anzahl der Ameisen jeder Klasse ist unterschiedlich. Eine Königin pro Ameisenhügel, Dutzende Krieger und Hunderte Arbeiterameisen. Drei Klassen und Hunderte von Objekten. Die Ameisen interagieren miteinander, mit gleichen Ameisen und Ameisen anderer Klassen nach streng festgelegten Regeln.

Dies ist einfach das perfekte Beispiel. In einem typischen Programm ist es genau dasselbe. Es gibt ein Hauptobjekt, das Objekte aller anderen Klassen erstellt. Diese Objekte beginnen miteinander und mit der "Außenwelt" des Programms zu interagieren. Innerhalb dieser Objekte ist ihr Verhalten streng programmiert.

Diese beiden Erklärungen sind zwei Seiten derselben Medaille. Die Wahrheit liegt in der Mitte. Das erste Beispiel (für Zeichnungen und Schiffe) zeigt die Verbindung zwischen der Klasse und den Objekten dieser Klasse. Die Analogie ist sehr stark. Das zweite Beispiel (für den Ameisenhügel) zeigt die Verbindung zwischen den Objekten, die während der Programmausführung existieren, und den geschriebenen Klassen.

Zuerst musst du Klassen für alle Objekte im Programm schreiben und dann auch deren Interaktion beschreiben. Es klingt kompliziert, aber es ist einfacher, als es scheint.

In Python sind während der Ausführung des Programms alle Entitäten Objekte, und das Schreiben eines Programms läuft auf die Beschreibung verschiedener Möglichkeiten der Interaktion von Objekten hinaus. Objekte rufen einfach die Methoden des anderen auf und geben die erforderlichen Daten an sie weiter.

Dokumentation

Aber woher weiß man, welche Daten in die Methoden übergeben werden sollen? Das wurde schon alles für dich ausgedacht.

Normalerweise hat jede Klasse eine Beschreibung, die angibt, wofür sie erstellt wurde. Normalerweise hat auch jede öffentliche Methode eine Beschreibung: was sie tut und welche Daten in sie übergeben werden müssen.

Um eine Klasse zu verwenden, muss man im Allgemeinen wissen, was sie tut. Und man muss genau wissen, was jede ihrer Methoden tut. Es ist überhaupt nicht notwendig zu wissen, wie sie es tut. Eine Art von Zauberstab.

Schauen wir uns den Code zum Kopieren einer Datei an:

src = open('source.txt', 'r')
dst = open('destination.txt', 'w')
            
for line in src:
    dst.write(line)
            
src.close()
dst.close()
        

Wenn du diesen Code Zeile für Zeile liest, kannst du ungefähr erraten, was er tut. Hier sind jedoch Erfahrung und Übung erforderlich. So wird dir dieser Code nach einer Weile vertraut und verständlich erscheinen.

1.2. Programmgestaltung

Programmgestaltung ist eine Kunst. Es ist sowohl einfach als auch schwierig zugleich. Einfach, weil es keine strengen Gesetze gibt: alles, was nicht verboten ist, ist erlaubt. Und schwierig aus demselben Grund: Es gibt viele Wege, etwas zu tun, und es ist nicht einfach, den besten zu finden.

Ein Programm zu entwerfen ist wie ein Buch zu schreiben. Einerseits schreibst du einfach Buchstaben, Wörter, Sätze. Andererseits sind Handlung, Charaktere, interne Widersprüche, Konflikte, Erzählstil, Intrigen usw. wichtig.

Das Wichtigste ist zu verstehen, für wen du den Code schreibst. Denke daran, dass dein Code für andere Programmierer bestimmt ist.

Die Entwicklung eines Produkts bedeutet, Änderungen vorzunehmen: hierhin etwas hinzugefügt, dort etwas entfernt, hier etwas umgestaltet. Und so, in kleinen Iterationen, entstehen große, riesige und gigantische Projekte.

Die Hauptanforderung an den Code ist, er muss für andere Programmierer verständlich sein. Falscher, aber verständlicher Code kann behoben werden. Richtiger und unverständlicher Code kann nicht verbessert werden. Er bleibt nur zum Wegwerfen.

Wie schreibt man also guten und verständlichen Code?

Dafür musst du drei Dinge tun:

• Guten und verständlichen Code innerhalb der Methoden schreiben – das Einfachste.
• Entscheiden, welche Entitäten im Programm sein sollen.
• Das Programm richtig in logische Teile aufteilen.

Was steht hinter diesen Begriffen?

Guten Code innerhalb der Methoden schreiben

Wenn du zumindest grundlegende Englischkenntnisse hast, hast du vielleicht bemerkt, wie leicht sich manchmal Code liest: wie Sätze auf Englisch:

• class Cat(Pet) – die Klasse Cat erweitert die Klasse Pet.
• while stream: – solange der Stream nicht leer ist ...
• a if a < b else b – wenn a kleiner als b ist, dann a zurückgeben, sonst b zurückgeben.

Das ist absichtlich so gemacht. Python ist eine der wenigen Sprachen, in denen es leicht ist, selbstdokumentierten Code zu schreiben: Code, der ohne Kommentare verständlich ist. In gutem Python-Code lesen sich viele Methoden einfach wie Sätze in Englisch.

Deine Aufgabe beim Schreiben von Code ist es auch, ihn so einfach und prägnant wie möglich zu machen. Denk einfach darüber nach, wie leicht dein Code zu lesen sein wird, und du beginnst, dich in die richtige Richtung zu bewegen.

In Python ist es üblich, leicht zu lesenden Code zu schreiben. Idealerweise sollte jede Methode vollständig auf den Bildschirm passen (Methodenlänge – 20-30 Zeilen). Das ist die Norm für die gesamte Python-Community. Wenn man den Code verbessern kann, sollte man ihn verbessern.

Der beste Weg, um zu lernen, guten Code zu schreiben, ist kontinuierliche Praxis. Schreibe viel Code, studiere fremden Code, bitte erfahrenere Kollegen, deinen Code zu bewerten. Und denk daran, dass in dem Moment, in dem du dir sagst „Das reicht so“, deine Entwicklung stoppt.

Entscheiden, welche Entitäten im Programm sein sollen

Du musst Code schreiben, der für andere Programmierer verständlich ist. Wenn 9 von 10 Programmierern beim Entwerfen eines Programms darin die Klassen A, B und C erstellen würden, dann solltest auch du in deinem Programm die Klassen A, B und C erstellen. Du musst Code schreiben, der für andere verständlich ist.

Hervorragender, funktionaler, schneller, unkonventioneller Code ist schlechter Code.

Du musst fremde Projekte studieren: Das ist der beste, schnellste und einfachste Weg, die gesamte Weisheit zu übernehmen, die sich jahrzehntelang in der IT-Branche angesammelt hat.

Und übrigens, du hast bereits ein ausgezeichnetes, beliebtes, gut dokumentiertes Projekt zur Hand – Python SDK. Fang damit an.

Untersuche die Klassen und die Struktur der Klassen. Denke darüber nach, warum einige Methoden statisch sind und andere nicht. Warum haben die Methoden genau diese Parameter und keine anderen. Warum genau diese Methoden, warum heißen die Klassen so und befinden sich genau in diesen Paketen.

Wenn du beginnst, die Antworten auf all diese Fragen zu verstehen, wirst du in der Lage sein, Code zu schreiben, der für andere verständlich ist.

Allerdings möchte ich dich davor warnen, den Code in den Methoden des Python SDK zu analysieren. Der Code vieler Methoden wurde komplett überarbeitet, um die Ausführungsgeschwindigkeit zu maximieren – seine Lesbarkeit ist äußerst fraglich.

Das Programm in logische Teile richtig aufteilen

Jedes Programm wird normalerweise in Teile oder Module unterteilt. Jeder Teil ist für einen bestimmten Aspekt des Programms verantwortlich.

Hier hat der Computer ein Systemgehäuse, einen Monitor, eine Tastatur, und das sind alles separate, weitgehend unabhängige Teile. Außerdem ist ihre Interaktion standardisiert: USB, HDMI usw. Und wenn du Kaffee auf die Tastatur verschüttest, kannst du sie einfach unter den Wasserhahn halten, trocknen und weiter benutzen.

Ein Laptop hingegen ist ein Beispiel für eine monolithische Architektur: Logische Teile sind vorhanden, aber viel stärker integriert. Beim MacBook Pro musst du, um die Tastatur zu reinigen, das halbe Notebook zerlegen. Auf einen Laptop verschütteter Kaffee ist ein guter Grund, einen neuen zu bestellen. Aber keinen Kaffee.

1.3 Eigene Klassen erstellen

Wenn du anfängst zu programmieren, ist es wichtig, klein anzufangen – lerne, deine eigenen Klassen zu erstellen.

Natürlich hast du schon welche erstellt, aber du musst lernen zu verstehen, welche Klassen im Programm sein sollten, wie sie heißen sollten, welche Methoden sie haben sollten und wie sie miteinander interagieren sollten.

Liste der Entitäten

Wenn du nicht weißt, wo du anfangen sollst, fang am Anfang an.

Zu Beginn der Programmgestaltung kannst du einfach eine Liste der Entitäten (Objekte), die im Programm sein sollten, auf Papier notieren. Und programmiere sie dann nach dem Prinzip: Jede Entität ist eine eigene Klasse.

Beispiel

Angenommen, du möchtest ein Schachspiel programmieren. Du benötigst Entitäten wie ein Schachbrett und 6 Figurentypen. Figuren bewegen sich unterschiedlich, haben unterschiedliche Werte – es ist logisch, dass dies separate Klassen sind. Und generell gilt: Je mehr Klassen am Anfang, desto besser.

Es ist eine Seltenheit, einem Anfänger zu begegnen, der anstelle von zwei Klassen zehn geschrieben hat. Aber anstelle von zehn nur zwei, oder sogar nur eine – das machen Anfänger gerne. Also mehr Klassen, liebe Programmierer. Und dein Code wird für alle verständlicher, außer vielleicht für dich selbst 😛

Schach

Angenommen, wir entscheiden uns, Klassen für Schach zu schreiben: Wie würden diese Klassen aussehen?

Ist ein Schachbrett einfach ein 8x8-Array? Besser, du machst eine separate Klasse dafür, die intern einen Verweis auf ein Array speichert. Dann kannst du viele nützliche Methoden hinzufügen, die beispielsweise überprüfen, ob ein Feld leer oder besetzt ist.

Im Grunde kann man sich am Anfang immer an dem Prinzip orientieren: Ein Programm hat verschiedene Entitäten, und eine Entität hat einen Typ. Dieser Typ ist die Klasse.