Programmieren lernen mit Python und JavaScript

In diesem Kapitel beschäftigen wir uns damit, was Programmieren eigentlich ist und wozu wir Programmieren und Programmierer überhaupt benötigen. Wir werden sehen, dass es beim Programmieren um die Entwicklung bzw. Umsetzung von schrittweisen Problemlösungsstrategien, sogenannten Algorithmen, geht. Allerdings sind nicht alle Arten von Problemen, die Computer heutzutage lösen können, der Bearbeitung mit strikten Algorithmen zugänglich; im Bereich der Künstlichen Intelligenz (KI) kommen andere Herangehensweise zum Einsatz, die wir uns ebenfalls in diesem Kapitel anschauen werden.

Sie haben sich dazu entschieden, dieses Buch zu lesen, also müssen Sie offenbar nicht mehr davon überzeugt werden, sich mit dem Programmieren zu beschäftigen. Trotzdem lohnt es sich, sich in diesem Kapitel noch einmal klar zu vergegenwärtigen, warum es Sinn macht, Programmieren zu lernen.Auch, wenn (berufsmäßige) Programmierer in unserer modernen Welt manchmal wie die Superstars unter den Wissensarbeitern erscheinen mögen, schlagen ihnen doch häufig Vorurteile entgegen, die nicht selten von überzeichneten Klischees geprägt sind. Einige dieser Vorurteile begegnen Ihnen manchmal auch als Hobby-Programmierer. Mit solcherlei Vorurteilen und Klischees beschäftigen wir uns in diesem Kapitel ebenfalls.

Programmieren bedeutet letztlich, dem Computer Anweisungen zu erteilen. Das geschieht in einer speziellen Sprache, die sowohl wir als Programmierer als auch der Computer versteht: einer Programmiersprache. Programmiersprachen und natürliche Sprachen haben sehr viele Gemeinsamkeiten, weisen aber auch einige wichtige Unterschiede auf.In diesem Kapitel beschäftigen wir uns mit Programmiersprachen und damit mit der entscheidenden Frage, wie wir uns dem Computer gegenüber verständlich machen, und wie der Computer es schafft, uns zu verstehen und unsere Anweisungen auszuführen.

Es gibt buchstäblich hunderte unterschiedlicher Programmiersprachen und ständig werden neue Sprachen entwickelt. Warum ist das so? Würde es nicht genügen, eine einzige Programmiersprache zu haben, die alle Programmierer verstehen und mit der alle Computer programmiert werden können?In diesem Kapitel gehen wir der Frage nach, warum die Welt der Programmiersprachen so bunt, facettenreich, aber leider auch übersichtlich ist.

Im letzten Kapitel haben wir gesehen, warum es so viele unterschiedliche Programmiersprachen gibt. Diese Vielfalt stellt uns aber vor das Problem, zu entscheiden, welche Sprache(n) wir lernen sollten. In den Teilen 3 und 4 dieses Buches haben Sie die Möglichkeit, sich mit zwei äußerst populären Programmiersprachen vertraut zu machen, Python und JavaScript; insofern hat der Autor bereits eine Vorauswahl für Sie getroffen. Unabhängig davon wollen wir uns aber in diesem Kapitel mit der Frage beschäftigen, nach welchen Kriterien Sie Sprachen, die für Sie von Interesse sein könnten, auswählen können. Denn wenn Sie erst mit dem Programmieren anfangen, wird es langfristig mit Sicherheit nicht bei der ersten Sprache, mit der Sie in die Welt der Programmierung eingestiegen sind, bleiben.

Bevor wir im nächsten Teil des Buchs in die Grundkonzepte der Programmierung einsteigen, finden Sie in diesem Kapitel noch einige aufmunternde Tipps für den Einstieg in die faszinierende Welt der Programmierung.

In diesem Kapitel verschaffen wir uns einen Überblick über die 9 Fragen, anhand derer wir in diesem Teil des Buches die Grundkonzepte des Programmierens kennenlernen.Auf Basis dieser Grundkonzepte werden wir uns dann in den folgenden beiden Teilen des Buches die Programmiersprachen Python und JavaScript erarbeiten. Und auch darüber hinaus sind diese Grundkonzepte – zusammengefasst in Form der 9 Fragen – ein äußerst nützliches Denkschema, mit dem Sie sich jede beliebige Programmiersprache erschließen können, die Sie erlernen wollen.

Bevor wir damit beginnen können, Programme zu schreiben, müssen wir uns zunächst die richtigen (Software-)Werkzeugen bereitlegen.Dazu gehören neben dem Compiler bzw. Interpreter, die den in der Programmiersprache verfassten Programmquelltext in Maschinensprache übersetzen und so für den Computer ausführbar machen, auch Code-Editoren, mit denen der Quelltext des Programms überhaupt erst geschrieben wird. Sogenannte integrierte Entwicklungsumgebungen fassen diese und weitere Werkzeuge unter dem Dach einer gemeinsamen Benutzeroberfläche zusammen.Neben solchen eher „technischen“ Werkzeugen werden Sie aber von Zeit zu Zeit auch inhaltlich Hilfe beim Programmieren benötigen. Deshalb beschäftigen wir uns in diesem Kapitel auch damit, wie und wo Sie Informationen und Unterstützung rund um Ihre Programmiersprache finden können.

Nachdem Sie die notwendigen Werkzeuge beschafft sowie Hilfe- und Informationsquellen eruiert haben, wird es Zeit, herauszufinden, wie genau Sie eigentlich ein Programm zum Laufen bringen. Nichts ist frustrierender, als zwar hervorragend mit umfangreichem theoretischem Wissen über Ihre Programmiersprache präpariert zu sein, aber letztlich daran zu scheitern, Ihr erstes kleines Programm überhaupt zu starten.Um dieses unangenehme Erlebnis zu vermeiden, sollten Sie möglichst zeitig bereits ein erstes, richtiges Programm zu schreiben, selbst, wenn Sie noch fast gar nichts über Ihre Programmiersprache wissen.

Dass man auf eine Art und Weise programmieren sollte, die es einem erlaubt, später noch zu verstehen, wie man genau vorgegangen ist, und wie die Lösungen, die man entwickelt hat, funktionieren, ist ein triviale Forderung, die unmittelbar einleuchtet. Doch tatsächlich tun sehr viele Programmierer, durchaus auch berufsmäßige, viel zu wenig dafür, diese Forderung auch in die Tat umsetzen.Deshalb beschäftigen wir uns als nächstes damit, wie Sie ihren Programmcode so gestalten können, dass er Ihnen und anderen, die damit arbeiten müssen, später noch zugänglich ist.

Programme wären langweilig und wenig nützlich, wenn sie nicht in der Lage wären, Eingaben vom Benutzer entgegenzunehmen. Manche Daten gibt er direkt ein, andere werden aus Dateien ausgelesen oder aus einer Datenbank abgefragt. Sogar der Klick auf einen Button ist eine Form der Dateneingabe.Wo auch immer die Daten herkommen, die ein Programm verarbeiten soll, sie müssen im Speicher des Computers auf eine Weise abgelegt werden, die es dem Programm erlaubt, jederzeit schnell darauf zuzugreifen. Dies geschieht aus Sicht des Programmierers in Form von Variablen. Auch wenn diese Variablen durchaus einiges mit ihren Namensvettern aus der Mathematik zu tun haben, brauchen Sie keine Angst zu haben: Um dieses Kapitel verstehen zu können, müssen Sie sich nicht an die Kettenregeln beim Ableiten von Funktionen aus dem Mathematikunterricht erinnern!

Nachdem wir im letzten Kapitel der Frage nachgegangen sind, wie Daten mit Hilfe von Variablen so vorgehalten werden können, dass wir im Programm mit ihnen arbeiten können, wenden wir uns nun der Frage zu, wie wir überhaupt Daten von außen in das Programm hineinbringen (wir sprechen in diesem Zusammenhang in einem weiteren Sinne von „Dateneingabe“) und auch wieder aus dem Programm herausbekommen können (im weiteren Sinne „Datenausgabe“). Dabei geht es sowohl um Dateneingabe und Datenausgabe direkt vom/an den Benutzer, als auch um Eingabe und Ausgabe im Kontext von Dateien. In diesem Kapitel beschäftigen wir uns also damit, wie ein Programm mit seiner „Außenwelt“ kommuniziert.

Funktionen sind das wichtigste Werkzeug, mit dem in den meisten Programmiersprachen die eigentliche Arbeit erledigt wird, sei es das Entgegennehmen von Daten vom Benutzer, die Bearbeitung von Daten, die Darstellung von Informationen, die Steuerung des Verhaltens von Benutzeroberflächen, das Lesen aus bzw. Schreiben in Dateien und Datenbanken, oder vieles andere mehr. Deshalb müssen Sie sich, wenn Sie eine Programmiersprache lernen, damit beschäftigen, wie Sie mit Funktionen arbeiten. Genau darum geht es in diesem Kapitel.

Programme müssen flexibel auf neue Situationen reagieren können, zum Beispiel, wenn der Benutzer eine Eingabe macht oder auf einen Button klickt. Je nachdem, welche Eingabe er macht oder auf welchen Button er klickt, werden dann im Programm unterschiedliche Programmanweisungen ausgeführt, das Programm verzweigt also in unterschiedliche Pfade/Äste. Mit dieser Form der Ablaufsteuerung, die Programme überhaupt erst dynamisch macht, werden wir uns nun eingehender beschäftigen.

Oft müssen wir in Programmen eine oder mehrere gleichartige Anweisungen wiederholen. Dazu könnten wir die Anweisungen einfach mehrere Male hintereinanderschreiben. Das allerdings ist nicht nur mühsam und fehleranfällig, sondern stellt uns auch immer dann vor ein Problem, wenn zu dem Zeitpunkt, als wir das Programm schreiben, noch gar nicht klar ist, wie oft genau die Anweisungen hintereinander ausgeführt werden sollen.Deshalb kennen alle modernen Programmiersprachen sogenannte Schleifen, mit deren Hilfe sich die Wiederholung von Programmanweisungen elegant umsetzen lässt.

Fehler sind der ärgste Feind des Programmierers. So sorgfältig man auch arbeitet, Fehler schleichen sich immer ein. Das Testen des Programms, also das Aufspüren und die Beseitigung von Fehlern sind deshalb essentielle Bestandteile des Programmierens.Fehler äußern sich entweder dadurch, dass das Programm gar nicht erst ausgeführt werden kann, dass es bei der Ausführung abstürzt, oder dadurch, dass es, selbst wenn es bis zum Ende durchläuft, trotzdem nicht das tut, was es soll.Unterschieden werden können dabei Fehler, die bereits zur Entwicklungszeit geschehen, also während das Programm geschrieben wird, und solche, die erst zur Laufzeit entstehen, dann also, wenn das Programm ausgeführt wird.Zum Glück gibt es einige Ansätze und Werkzeuge, die beim Verstehen von Fehlerursachen, dem sogenannten Debugging, helfen können.

Jetzt geht es richtig los!In diesem Teil des Buches starten wir mit unserer ersten Programmiersprache, nämlich Python. Wie werden uns dabei an den 9 Fragen orientieren, anhand derer wir im vorangegangenen Teil die Grundkonzepte des Programmierens kennengelernt haben.Zunächst beginnen wir aber mit einem kompakten Überblick über die Sprache, ihre Entwicklung, Verbreitung und Verwendung.

Als erstes werden wir uns damit beschäftigen, was Sie zum Programmieren mit Python alles brauchen. Das ist zum Glück gar nicht viel, so dass wir schnell mit der eigentlichen Arbeit beginnen können.

Jetzt geht es endlich mit dem Programmieren los: Wir schreiben unser erstes kleines Python-Programm und nutzen zugleich die Gelegenheit, uns mit PyCharm, der mächtigen Python-IDE, die wir im letzten Kapitel installiert haben, vertraut zu machen.

Bevor wir richtig in die Python-Programmierung einsteigen, werden wir uns in diesem Kapitel zunächst damit beschäftigen, wie Python-Code und seine wichtigsten Grundelemente eigentlich aussehen und welche fundamentalen Konventionen es bei der Code-Gestaltung einzuhalten gilt. Python weist im Vergleich zu vielen anderen Programmiersprachen eine Besonderheit in der Code-Gestaltung auf, die uns als Programmierern zwar auf den ersten Blick etwas Gestaltungsfreiheit wegzunehmen scheint, aber unser Leben zugleich auch einfacher macht.

Mit diesem Kapitel wenden wir uns nun den Variablen in Python zu. Python ist eine objektorientierte Sprache und alle Variablen sind zugleich Objekte mit Attributen und Methoden. Deshalb beschäftigen wir uns hier nicht nur mit den Datentypen von Variablen und was man jeweils mit ihnen machen kann, sondern auch damit, wie Objektorientierung in Python umgesetzt ist.

Nachdem wir uns ausgiebig mit der Organisation von Daten im Programm, nämlich den verwendeten Variablen/Objekten, befasst haben, ist es nun an der Zeit, darüber zu sprechen, wie eigentlich Daten vom Benutzer entgegengenommen und wieder an ihn ausgegeben werden können. Dazu beschäftigen wir uns in diesem Kapitel zunächst mit dem einfachsten Weg der Ein- und Ausgabe, nämlich dem über die Konsole. Danach werden wir unseren Programmen mit grafischen Benutzeroberflächen (GUIs) ein deutlich ansprechenderes Äußeres verleihen. Dabei schauen wir uns die Arbeit mit GUIs nicht nur an einem vollständigen Anwendungsbeispiel genauer an, sondern Sie werden die Gelegenheit haben, im Rahmen einer Übung Ihre eigene erste GUI-Anwendung zu programmieren. Abschließend wenden wir uns der in der Praxis natürlich äußerst wichtigen Arbeit mit Dateien zu.

Bislang haben wir uns damit beschäftigt, wie man Python-Programme zum Laufen bringt, wie man mit Variablen/Objekten arbeitet, und wie man Daten ein- und ausgibt. In diesem Kapitel konzentrieren wir uns auf das, was dazwischen passiert, nämlich die Bearbeitung der Daten. Wenn die Ein- und Ausgabe von Daten die Brötchenhälften unseres „Programm-Burgers“ sind, dann geht es jetzt vor allem um das Fleisch in der Mitte (obwohl es natürlich auch Funktionen zur Ein- und Ausgabe gibt).Die wichtigste Art, in Programmen Daten zu bearbeiten ist, Funktionen aufzurufen, die die Daten verändern oder andere Aktionen auslösen.Funktionen sind so wichtig, weil wir mit ihnen bestimmte Aufgaben ausführen können, sogar ohne genau zu wissen, wie das eigentlich im Detail funktioniert. Wir rufen einfach die Funktion auf, und die Funktion tut, was sie tun soll, ohne dass wir diese Funktionalität selbst programmieren müssten und ohne, dass wir verstehen müssen, wie die Funktion arbeitet. Natürlich können wir aber eine Funktion auch selbst definieren. Die Funktion erlaubt es, eine bestimmte Funktionalität zu kapseln und diese von außen zugänglich zu machen. Mit Funktionen lagern wir letztlich Code-Teile aus dem normalen Programmcode aus und machen sie von überall her aufrufbar.

Als nächstes werden wir uns damit beschäftigen, wie man in Python-Programm verzweigen und – je nach Situation – mal den einen, mal den anderen Code-Teil ausführen kann. Erst dadurch wird unser Programmablauf richtig interessant und ist nicht einfach nur die immer gleiche Ausführung derselben Folge von Python-Anweisungen.

Als nächstes wenden wir uns dem Wiederholen von Programmanweisungen zu. Damit lassen sich viele aufwendige Aufgaben elegant lösen.Wie die meisten Programmiersprachen kennt Python dazu sowohl abgezählte (for-) als auch bedingte (while-) Schleifen. Eine Python-Besonderheit sind die auf den for-Schleifen basierenden Listenkomprehensionsausdrücke, mit denen man die Erzeugung von Listen auf sehr kompakte Weisen schreiben kann.

Fehler gehören zum Programmieralltag, eine unangenehme aber leider unumstößliche Wahrheit. Deshalb beschäftigen wir uns zum Abschluss unserer Tour durch die Grundlagen von Python damit, wie Fehler gefunden, analysiert und behandelt werden können.

In diesem Teil wenden wir uns nun mit JavaScript der zweiten Programmiersprache zu, mit der wir in diesem Buch beschäftigen werden. Auch diese werden wir uns nach dem 9-Fragen-Schema erschließen, ebenso wie wir es mit Python getan haben.In diesem ersten Kapitel des Teils verschaffen wir uns einen kurzen Überblick über Anwendungsgebiete, Bedeutung und Herkunft von JavaScript.

In diesem Kapitel werden wir uns mit der Frage beschäftigen, wie JavaScript ausgeführt wird, welche Entwicklungswerkzeuge zur Verfügung stehen und wo man weiterführende Informationen zu JavaScript findet.Wie Sie sehen werden, benötigen Sie nicht viel, um mit dem Programmieren JavaScript loslegen zu können. Wir werden uns deshalb auch nur mit der „Grundausstattung“ an Werkzeugen begnügen und nicht mit einer richtigen Integrierten Entwicklungsumgebung arbeiten, wie wir es bei Python getan haben.

JavaScript-Programme sind typischerweise Bestandteil von Webseiten. Um also ein Programm zum Laufen zu bringen, müssen wir uns als erstes damit beschäftigen, wie wir es in eine Webseite einbinden können. Darum geht es in diesem Kapitel.

Bevor wir nun richtig in die Programmierung mit JavaScript einsteigen, wollen wir uns vorbereitend noch mit einigen wichtigen Fragen der Gestaltung des Programm-Codes und – Sie werden es schon geahnt haben – der Kommentierung des Codes beschäftigen.

Nun ist es an der Zeit, dass wir uns damit beschäftigen, wie wir in JavaScript mit Variablen und Objekten arbeiten, um Daten zur Verarbeitung temporär speichern zu können. Darum geht es in diesem Kapitel.

JavaScript ist die Sprache des Web. Kein Wunder also, dass sich auch bei der Ein- und Ausgabe von Daten fast alles um die Interaktion mit der Webseite dreht, innerhalb derer Ihr JavaScript-Programm läuft.JavaScript bietet viele Möglichkeiten, Informationen vom Benutzer der Webseite entgegenzunehmen und die Webseite zur Ausgabe von Informationen zu verändern. Die Interaktion mit der umgebenden Webseite wird dadurch möglich, dass JavaScript über das sogenannte Document Object Model (DOM) der Webseite einen Zugriff auf deren einzelne Elemente erlaubt.Bevor wir uns aber der Nutzung des DOM zuwenden, wollen wir noch einen kurzen Blick auf die Ausgabe mit der JavaScript-Konsole, die wir bereits häufig verwendet haben, werfen, und uns die Arbeit mit Dialogboxen ansehen.

Als nächstes werden wir uns mit Funktionen befassen, die in JavaScript – wie in vielen anderen Programmiersprachen auch – das wichtigste Arbeitstier des Programmierers sind. Schließlich arbeiten Sie nicht nur ständig mit vordefinierten Funktionen, die Ihnen JavaScript von Haus aus anbietet, oder die Sie aus Erweiterungsbibliotheken beziehen, sondern Sie schreiben regelmäßig auch eigene Funktionen; insbesondere natürlich die Event Handler, die in den ereignisgesteuerten JavaScript-Applikationen eine zentrale Rolle einnehmen. Kein Wunder also, dass die intensive Beschäftigung mit Funktionen ein Kernbestandteil unserer Tour durch JavaScript ist.

Wir haben bereits mit zwei verschiedenen Arten, im Programmablauf zu verzweigen, gearbeitet; linear mit if-else-Konstrukten und ereignis-gesteuert mit Event Handlern. Beide werden wir uns jetzt noch etwas genauer ansehen.

Wie die meisten anderen Programmiersprachen bietet auch JavaScript Schleifen-Konstrukte, die es erlauben, gleichartige Anweisungen zu wiederholen. In der Praxis werden solche Schleifen gerne und häufig eingesetzt, erlauben sie doch eine übersichtliche und elegante Formulierung von Wiederholungen, deren Durchführungszahl zumindest zu dem Zeitpunkt, da der Code geschrieben wird, noch nicht bekannt ist. Im folgenden werden wir uns die wesentlichen Schleifentypen in JavaScript genauer anschauen und an einem größeren Beispiel in Aktion sehen.

Zum Abschluss unserer Einführung in JavaScript wenden wir uns dem ungeliebten, aber wichtigen Thema der Fehlersuche und -behandlung zu. JavaScript ist insgesamt etwas robuster als andere Programmiersprachen, wenn es um Laufzeitfehler geht. Dort also, wo Ihr Programm in anderen Sprachen mit einer Fehlermeldung abbrechen würde, läuft es bei JavaScript einfach weiter. Das macht die Behandlung von Laufzeitfehlern aber nur scheinbar einfacher; besondere, ungewöhnliche Situationen müssen von Ihnen als Programmierer trotzdem vorhergesehen und bearbeitet werden.Für die Fehlersuche bereits während der Entwicklung bringen die Entwicklertools der modernen Browser einige sehr nützliche Werkzeuge mit, von denen Sie ausgiebig Gebrauch machen sollten.