Kapitel 1: Was ist Python eigentlich?¶

Einleitung¶

Willkommen zum ersten Kapitel unseres Kurses über Python! In diesem Kapitel werden wir einen Überblick über diese moderne, weit verbreitete Programmiersprache geben, die für ihre Einfachheit und Vielseitigkeit bekannt ist. Wir werden uns damit befassen, warum Python eine Schlüsselkomponente in der heutigen Programmierlandschaft ist und welche Rolle es in verschiedenen Entwicklungsprojekten spielt.

Lernziele¶

Nach Abschluss dieses Kapitels wirst du:

  • Die Entstehungsgeschichte von Python verstehen und die Hauptziele seiner Entwicklung nachvollziehen können.
  • Verstehen, warum Python eine wichtige Programmiersprache ist und wie sie sich im Laufe der Zeit entwickelt hat.
  • Die wichtigsten Merkmale und Eigenschaften von Python kennenlernen und verstehen, wie sie sich von anderen Programmiersprachen unterscheiden.
  • Die verschiedenen Anwendungsbereiche von Python erkunden und verstehen, wie sie in verschiedenen Projekten eingesetzt werden kann.

Entstehungsgeschichte von Python¶

Die Entwicklung von Python begann Ende der 1980er Jahre bei Guido van Rossum, der die Sprache als ein Hobbyprojekt startete. Python wurde erstmals 1991 veröffentlicht. Die Sprache wurde mit dem Ziel entwickelt, eine einfache, leicht zu erlernende und mächtige Programmiersprache zu schaffen. Python ist bekannt für seine klare Syntax und Lesbarkeit, die es Entwicklern erleichtern, lesbaren und wartbaren Code zu schreiben.

Die Hauptziele bei der Entwicklung von Python waren:

  • Eine einfache und leicht verständliche Syntax zu bieten, die das Programmieren intuitiv macht.
  • Eine starke Unterstützung für verschiedene Programmierparadigmen, einschließlich objektorientierter, imperativer und funktionaler Programmierung.
  • Eine große Standardbibliothek zu integrieren, um eine breite Palette von Programmieranwendungen zu ermöglichen, ohne auf externe Bibliotheken angewiesen zu sein.

Die wichtigsten Merkmale und Eigenschaften von Python¶

Python kombiniert die Vorteile verschiedener Programmiersprachen und bietet gleichzeitig einzigartige Eigenschaften, die sie besonders für Anfänger und erfahrene Entwickler attraktiv machen. Zu den wichtigsten Merkmalen von Python gehören:

  • Einfachheit und Lesbarkeit: Python ist bekannt für seine klare und leicht verständliche Syntax, die es Entwicklern ermöglicht, Code schnell zu schreiben und zu lesen.

  • Interaktive Programmierung: Python bietet eine interaktive Konsole, die es Entwicklern ermöglicht, Code in Echtzeit auszuprobieren und sofortige Ergebnisse zu sehen.

  • Vielseitigkeit: Python unterstützt mehrere Programmierparadigmen, darunter objektorientierte, imperativ- und funktionale Programmierung.

  • Große Standardbibliothek: Python kommt mit einer umfangreichen Sammlung von Standardmodulen, die viele häufige Aufgaben abdecken, wie Dateiverarbeitung, Netzwerkkommunikation und Webentwicklung.

  • Plattformunabhängigkeit: Python-Code kann auf verschiedenen Betriebssystemen ausgeführt werden, einschließlich Windows, macOS und Linux.

  • Dynamische Typisierung: Python verwendet dynamische Typisierung, was bedeutet, dass Variablen keine festen Typen haben und zur Laufzeit überprüft werden.

Unterschiede zu anderen Programmiersprachen¶

  • Java: Im Vergleich zu Java bietet Python eine weniger komplexe Syntax und ist in der Regel einfacher zu erlernen und zu verwenden. Python ist jedoch interpretativ und daher oft langsamer als die kompilierte Java-Sprache.

  • C++: Python ist im Vergleich zu C++ weniger leistungsfähig in Bezug auf die Ausführungsgeschwindigkeit, bietet jedoch eine deutlich einfachere Syntax und geringeren Entwicklungsaufwand.

  • JavaScript: Python und JavaScript sind in vielen Bereichen ähnlich, aber Python wird häufig für serverseitige Anwendungen verwendet, während JavaScript hauptsächlich für clientseitige Webentwicklung genutzt wird.

Anwendungsbereiche von Python¶

Python findet in einer Vielzahl von Bereichen Anwendung, darunter:

  • Webentwicklung: Python wird häufig für die Entwicklung von Webanwendungen und Websites verwendet, insbesondere mit Frameworks wie Django und Flask.

  • Datenanalyse und Wissenschaft: Python ist ein beliebtes Werkzeug für Datenanalyse, maschinelles Lernen und wissenschaftliches Rechnen, unterstützt durch Bibliotheken wie NumPy, pandas und scikit-learn.

  • Automatisierung: Python wird oft für die Automatisierung von Aufgaben und Skripten verwendet, da es eine einfache Möglichkeit bietet, wiederkehrende Aufgaben zu automatisieren.

  • Softwareentwicklung: Python wird in der Entwicklung von Softwareanwendungen eingesetzt, einschließlich Desktop- und mobilen Anwendungen.

  • Bildbearbeitung und Spieleentwicklung: Python wird auch für die Entwicklung von Bildbearbeitungsanwendungen und Spielen verwendet, mit Bibliotheken wie Pillow und Pygame.

Zusammenfassung¶

Python ist eine leistungsstarke und vielseitige Programmiersprache, die für ihre Einfachheit und Flexibilität bekannt ist. Mit ihrer klaren Syntax, umfangreichen Standardbibliothek und Unterstützung für verschiedene Programmierparadigmen bietet Python eine solide Grundlage für die Entwicklung einer breiten Palette von Anwendungen. Durch kontinuierliche Verbesserungen und eine aktive Entwicklergemeinschaft bleibt Python eine führende Programmiersprache in der heutigen Zeit.

Kapitel 2: Technologien für die Programmierung¶

Einleitung¶

Bei der Entwicklung von Anwendungen in Python ist die Wahl der richtigen Technologie entscheidend. In diesem Kapitel werden wir uns mit verschiedenen Typen von Python-Anwendungen befassen: Konsolenanwendungen, GUI-Anwendungen und Web-Anwendungen. Wir werden auch erklären, warum es für Anfänger wichtig ist, mit Konsolenanwendungen zu beginnen, um Python zu erlernen.

Lernziele¶

  • Verständnis für die verschiedenen Technologien zur Entwicklung von Anwendungen in Python entwickeln.
  • Erkennen, welche Technologie für welchen Anwendungsbereich am besten geeignet ist.
  • Einsicht in die Gründe bekommen, warum Konsolenanwendungen für Anfänger besonders wichtig sind.

1. Konsolenanwendungen¶

Konsolenanwendungen sind textbasierte Anwendungen, die über die Befehlszeile (Konsole) interagieren. Sie sind einfach und eignen sich hervorragend zum Erlernen der Grundlagen der Programmierung und Python. Konsolenanwendungen ermöglichen es dem Entwickler, grundlegende Konzepte wie Variablen, Schleifen, Bedingungen und Funktionen zu verstehen, ohne sich mit komplexen Benutzeroberflächen auseinandersetzen zu müssen. Die Ausgabe erfolgt meist in Form von Text, was den Fokus auf die Funktionalität und Logik der Anwendung lenkt.

Beispiele:¶

  • Einfaches Taschenrechner-Programm: Ein Konsolenanwendung, die grundlegende mathematische Operationen durchführt.
  • Textbasierte Spiele: Wie ein einfaches Ratespiel oder ein Hangman-Spiel.

2. GUI-Anwendungen¶

Für grafische Benutzeroberflächen (GUIs) gibt es in Python mehrere Technologien:

  • Tkinter: Tkinter ist das Standard-GUI-Toolkit für Python und wird häufig für einfache Desktop-Anwendungen verwendet. Es ist in der Standardbibliothek enthalten und einfach zu erlernen.

  • PyQt/PySide: Diese Bibliotheken bieten umfangreiche Funktionen für die Erstellung von modernen und leistungsfähigen GUI-Anwendungen. Sie sind umfangreicher als Tkinter und bieten viele zusätzliche Funktionen und Widgets.

  • Kivy: Kivy ist eine Open-Source-Bibliothek, die für die Entwicklung von Multi-Touch-Anwendungen geeignet ist und sowohl für Desktop- als auch für mobile Plattformen verwendet werden kann.

Beispiele:¶

  • Desktop-Anwendungen: Wie ein Notizbuch oder ein einfacher Dateimanager.
  • Echtzeit-Datenvisualisierungen: Mit interaktiven Grafiken und Diagrammen.

3. Web-Anwendungen¶

Für die Entwicklung von Web-Anwendungen in Python gibt es verschiedene Frameworks, die unterschiedliche Bedürfnisse abdecken:

  • Flask: Flask ist ein leichtgewichtiges Web-Framework, das sich gut für kleine bis mittelgroße Web-Anwendungen eignet. Es ist einfach zu erlernen und bietet eine große Flexibilität bei der Gestaltung der Anwendung.

  • Django: Django ist ein voll ausgestattetes Web-Framework, das viele Funktionen out-of-the-box bietet, wie ein ORM, Authentifizierung und ein Administrations-Dashboard. Es eignet sich gut für komplexere Web-Anwendungen.

  • FastAPI: FastAPI ist ein modernes, schnelles Web-Framework für den Aufbau von APIs mit Python. Es unterstützt asynchrone Programmierung und ist besonders leistungsfähig für den Aufbau von RESTful-APIs.

Beispiele:¶

  • Blog-Website: Erstellen von dynamischen Webseiten mit Flask oder Django.
  • API-Backend: Mit FastAPI ein Backend für mobile oder Web-Anwendungen bereitstellen.

Zusammenfassung¶

Die Wahl der Technologie hängt von den Anforderungen des Projekts ab. Für Anfänger ist der Start mit Konsolenanwendungen eine gute Wahl, da sie eine solide Grundlage für die Programmierung in Python bieten. Sobald die Grundlagen beherrscht werden, können Anfänger ihre Kenntnisse auf anspruchsvollere Technologien wie GUI- oder Web-Anwendungen ausweiten, um moderne und interaktive Anwendungen zu gestalten.

Kapitel 3: Die Anatomie von Konsolen- und GUI-Anwendungen in Python: Ein Vergleich mit dem Hausbau¶

Einleitung¶

Die Entwicklung von Python-Anwendungen kann durch einen Vergleich mit dem Bau eines Hauses verständlicher gemacht werden. Ähnlich wie beim Bau eines Hauses durchläuft man bei der Entwicklung einer Anwendung verschiedene Phasen und Komponenten. In diesem Kapitel betrachten wir die Struktur und die Entwicklungsschritte einer Python-Anwendung, indem wir sie mit einem Hausbau vergleichen.

Lernziele¶

  • Verständnis für die verschiedenen Phasen und Komponenten der Python-Anwendungsentwicklung entwickeln.
  • Vergleich der einzelnen Entwicklungsschritte einer Python-Anwendung mit den Bauphasen eines Hauses.
  • Einsicht in die Bedeutung jeder Phase für den Gesamterfolg des Projekts gewinnen.

Die Anatomie einer Python-Anwendung¶

Die Anatomie einer Python-Anwendung lässt sich am besten durch einen Vergleich mit einem Hausbau verstehen. Lassen Sie uns das Ganze Schritt für Schritt betrachten:

Alt-Text

  1. Das Grundstück (Konzept)

    • Hier beginnt die Idee für die Python-Anwendung. Es werden die Anforderungen und Ziele definiert. Wie soll die Anwendung aussehen, welche Funktionen soll sie haben und wer wird sie nutzen? Ähnlich wie bei einem Grundstück, auf dem das Haus entstehen soll, werden hier die Grundlagen für die Anwendung gelegt.

  2. Der Grundrissplan (Design)

    • Wie der Grundrissplan eines Hauses wird hier die Struktur der Python-Anwendung entworfen. Es werden die verschiedenen Module und Komponenten festgelegt, die zusammenarbeiten sollen, um die Funktionalität der Anwendung zu gewährleisten. Für GUI-Anwendungen könnte dies die Entscheidung für ein Framework wie Tkinter, PyQt oder Kivy umfassen.

  3. Das Erdgeschoss (Kernfunktionalität)

    • Das Erdgeschoss des Hauses ist der erste Teil, der gebaut wird. In der Python-Anwendung entspricht dies der Entwicklung der grundlegenden Funktionen. Hier werden die wichtigsten Aktionen und Prozesse implementiert, wie z.B. das Schreiben von Funktionen, Klassen und das Verarbeiten von Daten. Für GUI-Anwendungen bedeutet dies das Erstellen von Fenstern, Schaltflächen und anderen Steuerelementen.

  4. Die fehlenden Etagen (Erweiterungen)

    • Wie ein Haus mehrere Etagen haben kann, so kann auch die Python-Anwendung durch zusätzliche Funktionen und Features erweitert werden. Dies könnte die Integration von Datenbanken, externe APIs oder weitere Funktionsmodule umfassen, um die Anwendung leistungsfähiger zu machen.

  5. Die Garage (Datenspeicherung)

    • Die Garage im Haus dient zur Aufbewahrung von Fahrzeugen. In der Python-Anwendung ist dies der Bereich, in dem Daten gespeichert werden. Dies kann die Speicherung von Benutzerinformationen, Konfigurationen oder anderen wichtigen Daten umfassen. In Python könnte dies die Nutzung von Dateisystemen, SQLite-Datenbanken oder Cloud-Diensten umfassen.

  6. Der Garten (Benutzeroberfläche)

    • Der Garten ist der ästhetische Teil des Hauses. In der Anwendung entspricht dies der Benutzeroberfläche, die für die Interaktion mit dem Benutzer gestaltet wird. Eine intuitive und ansprechende Benutzeroberfläche erleichtert die Bedienung. Für GUI-Anwendungen bedeutet dies die Gestaltung und Implementierung von Fenstern, Dialogen und Layouts.

  7. Die Architekten und Baugenehmigungen (Entwicklungsteam und rechtliche Aspekte)

    • Wie ein Hausbau ein Team von Architekten, Bauarbeitern und Genehmigungsbehörden erfordert, benötigt auch die Entwicklung der Python-Anwendung ein Team von Entwicklern, Designern und möglicherweise auch rechtliche Überlegungen wie Datenschutz oder Lizenzen.

  8. Möbel und Strom (Daten und Ressourcen)

    • Ein Haus wird mit Möbeln und Strom ausgestattet, um es funktionsfähig zu machen. In der Python-Anwendung bezieht sich dies auf die notwendigen Ressourcen wie Serverkapazität, Internetverbindung und Datenbanken, um die Anwendung ordnungsgemäß auszuführen.

  9. Internetanschluss (Konnektivität)

    • Ein Haus kann von außen über eine Verbindung wie das Internet erreicht werden. In der Python-Anwendung ermöglicht der Internetanschluss die Kommunikation mit anderen Systemen, Diensten oder Benutzern, z.B. durch Web-APIs oder Netzwerkschnittstellen.

Zusammenfassung¶

Die Entwicklung einer Python-Anwendung kann als ein mehrschichtiger Prozess betrachtet werden, der ähnlich dem Bau eines Hauses Schritt für Schritt erfolgt. Jede Phase, angefangen vom Konzept bis zur Bereitstellung und Konnektivität, ist entscheidend für den Gesamterfolg des Projekts. Durch den Vergleich mit einem Hausbau können wir die Komplexität und die Bedeutung jeder Phase der Python-Anwendungsentwicklung besser verstehen.

Kapitel 4: Basis Grundlagen¶

Einleitung¶

Bevor wir uns in die Welt der Python-Programmierung stürzen, ist es entscheidend, die Grundlagen zu verstehen, die das Fundament unserer Code-Reise bilden. In diesem Kapitel werden wir uns mit den Basisgrundlagen vertraut machen, insbesondere mit den reservierten Schlüsselwörtern, den Bezeichnern und Literalen, die in der Python-Programmierung von zentraler Bedeutung sind.

Lernziele¶

  • Verständnis für die Bedeutung und Verwendung von reservierten Schlüsselwörtern in Python entwickeln.
  • Kenntnis über die Rolle und Bedeutung von Bezeichnern in der Programmierung erlangen.
  • Erlernen der Regeln und Konventionen für die Benennung von Bezeichnern in Python.
  • Fähigkeit entwickeln, sinnvolle und aussagekräftige Bezeichner für Variablen, Funktionen und andere programmatische Elemente auszuwählen.
  • Fähigkeit entwickeln, Literale in Python zu erkennen, zu verstehen und korrekt zu verwenden, einschließlich Zahlen, Zeichenketten und booleschen Werten.

Reservierte Schlüsselwörter¶

In Python gibt es eine Reihe von reservierten Schlüsselwörtern, die eine spezielle Bedeutung für den Interpreter haben. Diese Schlüsselwörter sind vordefiniert und können nicht für andere Zwecke verwendet werden, wie beispielsweise als Bezeichner für Variablen oder Funktionen. Das Vorhandensein reservierter Schlüsselwörter ermöglicht es der Sprache, syntaktische Strukturen zu definieren und bestimmte Funktionalitäten klar und eindeutig zu beschreiben.

Übersicht der reservierten Schlüsselwörter in Python¶

Übersicht der reservierten Schlüsselwörter in Python¶

False None True and as assert
break class continue def del elif
else except finally for from global
if import in is lambda match
nonlocal not or pass raise return
try while with yield

Hinweis¶

Einige Schlüsselwörter wie match sind erst ab Python 3.10 verfügbar. Ältere Versionen von Python unterstützen diese Schlüsselwörter nicht.

Diese Tabelle bietet eine alphabetische Übersicht der Schlüsselwörter in Python. Hier habe ich die Schlüsselwörter aufgelistet, denen wir in diesem Buch begegnen werden. Diese Schlüsselwörter sind in Python von zentraler Bedeutung und sollten nicht für andere Zwecke verwendet werden.

Hyperlink zu Python Schlüsselwörtern

Bezeichner¶

Ein Bezeichner (auch Identifier genannt) ist in der Programmierung ein Name, der verwendet wird, um Variablen, Funktionen, Klassen, Module oder andere Objekte eindeutig zu benennen und zu identifizieren. In der deutschen Sprache kann man den Begriff „Bezeichner“ auf verschiedene Weisen vergleichen:

  • Namensgebung in der Sprache: Ähnlich wie in der deutschen Sprache Namen verwendet werden, um Personen, Orte oder Dinge zu identifizieren, werden in der Programmierung Bezeichner verwendet, um verschiedene Programmteile zu benennen. Zum Beispiel:

    • „Peter“ ist ein Bezeichner für eine Person.
    • „Auto“ ist ein Bezeichner für ein Fahrzeug.

  • Regeln und Konventionen: Genau wie die deutsche Sprache Regeln und Konventionen für die Bildung von Wörtern und Namen hat, gibt es auch in der Programmierung spezifische Regeln für Bezeichner. Zum Beispiel:

    • Ein Name könnte aus einem Vornamen und einem Nachnamen bestehen (z.B. „Max Mustermann“).
    • Ein Bezeichner in Python könnte aus Buchstaben, Ziffern und Unterstrichen bestehen, darf aber nicht mit einer Ziffer beginnen (z.B. „my_variable“).

  • Eindeutigkeit: In der deutschen Sprache ist es wichtig, dass Namen eindeutig sind, um Verwechslungen zu vermeiden. In der Programmierung ist dies ebenfalls wichtig, um sicherzustellen, dass der Code klar und verständlich ist. Zum Beispiel:

    • In einer Klasse mit 30 Schülern sollte jeder Schüler einen eindeutigen Namen haben.
    • In einem Programm sollten Variablen eindeutige Bezeichner haben, um Verwirrung zu vermeiden (z.B. „counter1“, „counter2“).

  • Semantik und Bedeutung: In der deutschen Sprache haben Namen oft eine Bedeutung oder tragen eine bestimmte Assoziation. In der Programmierung sollte ein Bezeichner ebenfalls eine sinnvolle und beschreibende Bedeutung haben, um die Lesbarkeit und Wartbarkeit des Codes zu erhöhen. Zum Beispiel:

    • Der Name „Rose“ könnte eine Assoziation mit einer Blume hervorrufen.
    • Ein Bezeichner wie „total_price“ deutet auf den Gesamtpreis hin, was die Absicht des Codes klarer macht.

Regeln für Bezeichner in Python¶

  • Ein Bezeichner kann mit einem Buchstaben oder einem Unterstrich (_) beginnen, jedoch normalerweise nicht mit einer Zahl.
  • Der Bezeichner kann Buchstaben (a-z, A-Z), Zahlen (0-9) und den Unterstrich (_) enthalten.
  • Leerzeichen und die meisten Sonderzeichen (wie $, %, &, etc.) sind normalerweise nicht erlaubt.
  • Bezeichner sind in Python case-sensitive, das heißt, Groß- und Kleinschreibung werden unterschieden. "VariableName" und "variableName" werden als unterschiedliche Bezeichner betrachtet.
  • Bezeichner dürfen nicht mit reservierten Schlüsselwörtern der jeweiligen Programmiersprache identisch sein.

Wichtig¶

In Python dürfen Bezeichner nur aus Buchstaben, Ziffern und Unterstrichen bestehen. Alles andere wird automatisch durch _ ersetzt. Diese Regel stellt sicher, dass Bezeichner in Python korrekt interpretiert werden.

Literale in der Programmierung¶

Stell dir vor, du schreibst deinem Freund einen Brief. In diesem Brief schreibst du Sätze wie „Hallo, wie geht es dir?“ oder „Ich habe einen Hund.“ Diese Sätze und Wörter haben eine feste Bedeutung und du schreibst sie genau so, wie du sie meinst, ohne sie zu ändern. In der Programmierung haben wir etwas Ähnliches, das nennt sich Literale.

Literale sind feste Werte, die du direkt in deinen Quellcode schreibst. Das sind zum Beispiel Zahlen, Zeichenketten (also Texte), oder boolesche Werte (wie True und False). Hier sind ein paar Beispiele für Literale:

  • Zahlen: 123, 45.67
  • Zeichenketten: "Hallo, Welt!", "Python ist toll"
  • Boolesche Werte: True, False

Diese Literale schreibst du genauso in deinen Code, wie sie sind, weil sie feste Werte darstellen. Du brauchst sie nicht zu berechnen oder irgendwo anders zu definieren. Sie sind einfach da und bedeuten genau das, was du schreibst.

Wichtige Punkte zu Literalen in Python¶

  • Zahlen können ganze Zahlen (wie 100) oder Dezimalzahlen (wie 3.14) sein.
  • Zeichenketten (Strings) sind immer in Anführungszeichen, wie "Hallo" oder einfach Hochkommatas 'Hallo' .
  • Boolesche Werte sind immer True oder False.
  • Zeichen werden immer in Einzel-Anführungszeichen gesetzt, wie 'A' oder 'b'.

Hinweis¶

Es ist wichtig zu verstehen, warum es gefährlich sein kann, Literale direkt und überall im Code zu verwenden.

Stell dir vor, du schreibst ein Rezept für deinen Lieblingskuchen und in deinem Rezept schreibst du an mehreren Stellen „2 Tassen Zucker“. Wenn du dann entscheidest, dass der Kuchen weniger süß sein soll und du nur 1 Tasse Zucker verwenden möchtest, müsstest du das in deinem Rezept überall ändern, wo „2 Tassen Zucker“ steht. Das ist mühsam und es besteht die Gefahr, dass du eine Stelle übersiehst und der Kuchen dann nicht so schmeckt, wie du es möchtest.

In der Programmierung nennt man das "Hardcodieren" von Literalen. Hier sind einige Gründe, warum das gefährlich sein kann:

  • Wartungsfreundlichkeit: Wenn du überall im Code feste Werte (Literale) verwendest und du später diesen Wert ändern musst, musst du jede Stelle im Code finden und manuell ändern. Das kann sehr mühsam sein und es ist leicht, etwas zu übersehen.
  • Fehleranfälligkeit: Durch das mehrfache Vorkommen desselben Wertes kann es zu Fehlern kommen, wenn nicht alle Stellen korrekt aktualisiert werden. Das kann dazu führen, dass der Code inkonsistent wird und unerwartete Probleme auftreten.
  • Lesbarkeit und Verständlichkeit: Wenn jemand anderes deinen Code liest, ist es oft nicht sofort klar, warum ein bestimmter Wert verwendet wird. Ein fest codiertes Literal wie 365 ist weniger aussagekräftig als ein gut benannter Bezeichner wie DAYS_IN_A_YEAR.
  • Wiederverwendbarkeit: Wenn du denselben Wert an mehreren Stellen im Code benötigst, ist es effizienter, eine Konstante oder eine Variable zu verwenden. Das macht es einfacher, den Wert zentral zu verwalten und zu ändern.
  • Änderungen und Konfiguration: In vielen Programmen müssen bestimmte Werte anpassbar sein, ohne den Quellcode zu ändern. Durch die Verwendung von Literalen ist das schwieriger. Es ist besser, solche Werte in Konfigurationsdateien oder als Konstanten zu speichern.

Hinweis¶

Statt überall 365 für die Anzahl der Tage im Jahr zu verwenden, könntest du eine Konstante definieren, die diesen Wert speichert.

Zusammenfassung¶

Die Basisgrundlagen der Python-Programmierung, insbesondere die Kenntnis über reservierte Schlüsselwörter, Bezeichner und Literale, sind von entscheidender Bedeutung für das Verständnis und die Anwendung der Sprache. Durch das Beherrschen dieser Grundlagen können wir sauberen und strukturierten Code schreiben, der leicht zu verstehen, zu warten und zu erweitern ist. In diesem Kapitel haben wir einen ersten Einblick in diese Konzepte erhalten und sind nun bereit, unser Wissen weiter zu vertiefen.

Kapitel 5 Jeder fängt einmal an und das ist meistens Hello World¶

In [4]:
print("Hello World")

Hello World

Kapitel 6 Was sind Variablen¶

Alt-Text

Was ist eine Variable und warum sind diese Wichtig

Kapitel 3 Was sind Datentypen

Kapitel 7 Datentypen in Python¶

Datentypen kann man wesentlich in zwei wichtige Kategorien einteilen!

Die einen sind Wertetypen und die anderen sind Referenztypen.

Kapitel 8: Funktionen in Python¶

Einleitung¶

In Python sind Methoden ein grundlegendes Konzept der objektorientierten Programmierung und spielen eine wesentliche Rolle bei der Strukturierung und Organisation von Code. Sie ermöglichen es, wiederverwendbaren Code zu schreiben, der bestimmte Aufgaben oder Berechnungen durchführt. In diesem Kapitel werden wir die verschiedenen Aspekte von Methoden in Python detailliert behandeln, einschließlich ihrer Definition, Parameter, Rückgabewerte und Überladung.

Lernziele¶

  • Definition und Nutzen von Methoden: Verstehen, was Methoden sind und warum sie in der Programmierung wichtig sind.
  • Kategorien von Methoden: Methoden in verschiedene Kategorien einteilen, wie Instanzmethoden, Klassenmethoden und statische Methoden.
  • Aufbau einer Methode: Lernen, wie eine Methode aufgebaut ist, einschließlich des Methodenkopfs und des Methodenkörpers.
  • Methodenaufruf und Anwendung: Erfahren, wie man Methoden aufruft und in einem Programm verwendet.
  • Methodensignaturen: Verstehen, was eine Methodensignatur ist und wie sie zur Identifizierung von Methoden verwendet wird.

Definition und Nutzen¶

In Python sind Methoden zentrale Elemente der objektorientierten Programmierung. Sie dienen dazu, spezifische Aufgaben zu bewältigen und ermöglichen die Wiederverwendbarkeit und Modularisierung des Codes. Durch Methoden können Sie den Code in logische Einheiten unterteilen, die nach Bedarf aufgerufen werden können, was die Übersichtlichkeit und Wartbarkeit erhöht.

Aufbau und Funktionsweise¶

Eine Methode in Python besteht aus folgenden Komponenten:

  • Methodenname: Ein aussagekräftiger Name, der die Aufgabe der Methode beschreibt.
  • Parameter: Werte, die an die Methode übergeben werden können, um ihre Ausführung zu beeinflussen.
  • Rückgabewert: Das Ergebnis, das die Methode nach ihrer Ausführung zurückliefert. In Python ist dies optional, da Methoden auch None zurückgeben können.
  • Methodenkörper: Der Bereich, in dem die Anweisungen stehen, die die Methode ausführt.

Methoden dienen dazu, bestimmte Aufgaben innerhalb eines Programms auszuführen, wie beispielsweise Berechnungen durchzuführen oder Daten zu verarbeiten. Ein praktisches Beispiel ist die Addition von Zahlen oder das Berechnen des Durchschnitts einer Liste von Werten.

Definition und Aufbau von Methoden¶

Eine Methode ist eine in sich geschlossene Codeeinheit, die eine bestimmte Aufgabe ausführt. Jede Methode in Python besteht aus einem Methodenkopf und einem Methodenkörper.

  • Methodenkopf: Der Methodenkopf enthält den Methodennamen und eine optionale Parameterliste.
  • Methodenkörper: Der Methodenkörper enthält die Anweisungen, die ausgeführt werden, wenn die Methode aufgerufen wird.

Beispiel¶

class Rechner:
    def addieren(self, a, b):
        """Addiert zwei Zahlen."""
        return a + b

Kapitel 10: Konvertierung von Datentypen in Python¶

Einleitung¶

In diesem Kapitel tauchen wir in die Welt der Datentypen und ihrer Konvertierung ein. Datentypen sind in jeder Programmiersprache von zentraler Bedeutung. Oft müssen Daten von einem Typ in einen anderen konvertiert werden. Dies kann notwendig sein, um Berechnungen durchzuführen, Daten aus externen Quellen zu verarbeiten oder die Datenstruktur in einem Programm zu ändern. Wir werden lernen, wie man diese Konvertierungen in Python durchführt, welche Methoden und Techniken es gibt, und worauf man dabei achten muss. Lass uns gemeinsam entdecken, wie vielseitig und nützlich die Konvertierung von Datentypen sein kann!

Lernziele¶

  • Grundlagen der Datentypen Auffrischen: Du wirst die verschiedenen Datentypen in Python besser verstehen und warum es wichtig ist, Daten richtig zu typisieren.
  • Implizite Konvertierung: Du wirst lernen, wie die implizite Konvertierung funktioniert und welche Datentypen automatisch konvertiert werden können, ohne dass du explizit eingreifen musst.
  • Explizite Konvertierung: Du wirst verstehen, wie die explizite Konvertierung funktioniert, welche Syntax verwendet wird und wann diese Art der Konvertierung notwendig ist.
  • Verwendung von Konvertierungsfunktionen: Du wirst lernen, welche eingebauten Funktionen Python für die Konvertierung zwischen verschiedenen Datentypen bereitstellt.
  • Einfache Fehlerbehandlung bei der Konvertierung: Du wirst lernen, wie man mit potenziellen Fehlern und Ausnahmen umgeht, die während der Konvertierung auftreten können, und wie man diese sicher handhabt.
  • Praktische Beispiele und Übungen: Du wirst durch praktische Beispiele und Übungen geführt, die dir helfen, das Gelernte anzuwenden und zu festigen.

Implizite Konvertierung¶

Implizite Konvertierung tritt auf, wenn Python automatisch eine Konvertierung zwischen Datentypen durchführt, ohne dass der Entwickler dies explizit angeben muss. Dabei handelt es sich in der Regel um Konvertierungen, bei denen kein Informationsverlust auftritt und die Zielgröße größer ist als die Quellgröße.

Beispiel¶

In Python wird die Konvertierung von Ganzzahlen (int) zu Fließkommazahlen (float) automatisch vorgenommen, da float einen größeren Wertebereich hat als int.

# Implizite Konvertierung von int zu float
zahl_int = 42
zahl_float = zahl_int + 0.5  # int wird automatisch zu float konvertiert
print(zahl_float)  # Ausgabe: 42.5
In [5]:
# Implizite Konvertierung von int zu float
zahl_int = 42
zahl_float = zahl_int + 0.5  # int wird automatisch zu float konvertiert
print(zahl_float)  # Ausgabe: 42.5

42.5
In [ ]:

Kapitel 11: Kontrollstrukturen in Python¶

Einleitung¶

Kontrollstrukturen sind ein grundlegendes Konzept in der Programmierung und spielen eine zentrale Rolle bei der Steuerung des Programmflusses. Sie ermöglichen es, Entscheidungen zu treffen und Schleifen zu wiederholen, basierend auf bestimmten Bedingungen. In diesem Kapitel werden wir die grundlegenden Kontrollstrukturen in Python kennenlernen, einschließlich Bedingungsanweisungen, Schleifen und Alternativen zur switch-Anweisung. Diese Konzepte sind essenziell, um die Logik und Struktur von Programmen zu steuern und die Programmierung zu meistern.

Lernziele¶

  • Verstehen der grundlegenden Kontrollstrukturen: Du wirst die verschiedenen Arten von Kontrollstrukturen in Python kennenlernen und verstehen, wie sie den Programmfluss steuern.
  • Bedingungsanweisungen: Du wirst lernen, wie man Bedingungen verwendet, um unterschiedliche Codeabschnitte basierend auf bestimmten Bedingungen auszuführen.
  • Schleifen: Du wirst lernen, wie man Schleifen verwendet, um wiederholte Aufgaben effizient auszuführen.
  • Alternativen zur switch-Anweisung: Du wirst erfahren, wie man in Python Alternativen zur switch-Anweisung umsetzt.
  • Praktische Beispiele: Du wirst einfache, praxisnahe Beispiele durchgehen, um die Anwendung der Kontrollstrukturen zu verstehen.

Bedingungsanweisungen¶

Bedingungsanweisungen in Python erlauben es deinem Programm, Entscheidungen zu treffen und unterschiedliche Codeabschnitte auszuführen, abhängig von bestimmten Bedingungen. Die grundlegende Form einer Bedingungsanweisung ist die if-Anweisung. Es können auch elif (else if) und else verwendet werden, um komplexere Bedingungen zu behandeln.

Beispiel¶

# Bedingungsanweisung Beispiel
zahl = 10

if zahl > 0:
    print("Die Zahl ist positiv.")
elif zahl == 0:
    print("Die Zahl ist null.")
else:
    print("Die Zahl ist negativ.")

Kapitel 12 Operatoren in Python¶

Die folgende Tabelle zeigt die Operatoren in Python, gruppiert nach ihrer Priorität und Abarbeitungsreihenfolge:

| Gruppe | Operatoren | Beschreibung | |------------|-------------------------|-----------------------------------------------------| | 1 | a.b, a[x], x++, x--, new, type() | Attributzugriff, Indexzugriff, Typbestimmung | | 2 | +, -, not, ~, ++x, --x | Unäre Operatoren: Addition, Subtraktion, Negation, Bitkomplement, Inkrement, Dekrement | | 3 | *, /, % | Arithmetische Operatoren: Multiplikation, Division, Modulo | | 4 | +, - | Additive Operatoren: Addition, Subtraktion | | 5 | <<, >> | Bitverschiebungsoperatoren: Linksverschiebung, Rechtsverschiebung | | 6 | <, >, <=, >=, is, is not, in, not in | Vergleichsoperatoren und Identitätsoperatoren | | 7 | ==, != | Vergleichsoperatoren: Gleichheit, Ungleichheit | | 8 | & | Bitweises UND | | 9 | ^ | Bitweises XOR | | 10 | | | Bitweises ODER | | 11 | and | Logisches UND | | 12 | or | Logisches ODER | | 13 | if ... else | Bedingte Ausdrücke (ternärer Operator) | | 14 | =, +=, -=, *=, /=, %= , &=, |=, ^=, <<=, >>= | Zuweisungsoperatoren: einfache und zusammengesetzte Zuweisungen |

Abbildung 1: Abarbeitungsreihenfolge der Operatoren in Python

Kapitel 13: Arrays in Python¶

Einleitung¶

Arrays sind grundlegende Datenstrukturen, die in vielen Programmiersprachen verwendet werden, um eine Sammlung von Elementen des gleichen Datentyps zu speichern. In Python verwenden wir häufig Listen, um ähnliche Aufgaben zu erfüllen. Für Anfänger, die eine einfachere und typisierte Variante von Arrays suchen, bietet das array-Modul in Python eine geeignete Alternative. In diesem Kapitel werden wir uns mit der Verwendung des array-Moduls in Python befassen.

Lernziele¶

  • Verstehen, wie Arrays mit dem array-Modul deklariert und initialisiert werden.
  • Verstehen, warum Arrays im array-Modul typisiert sind.
  • Verstehen, wie auf Elemente in einem Array zugegriffen wird.
  • Verstehen, warum Arrays veränderbar (mutable) sind.
  • Hinzufügen und Entfernen von Elementen in einem Array.
  • Die Länge eines Arrays abfragen.
  • Verwendung von Schleifen zur Iteration über die Elemente eines Arrays.

Vorraussetzungen¶

Grundkenntnisse in Python, insbesondere in Bezug auf Variablen, Datentypen und Schleifen, werden vorausgesetzt.

Deklaration und Initialisierung von Arrays¶

Das array-Modul in Python ermöglicht die Erstellung von Arrays mit einem festen Datentyp. Dies ist besonders nützlich, wenn du sicherstellen möchtest, dass alle Elemente im Array denselben Typ haben.

Beispiel: Deklaration und Initialisierung¶

import array

# Erstellen eines Arrays von Ganzzahlen
zahlen = array.array('i', [1, 2, 3, 4, 5])

# Erstellen eines Arrays von Fließkommazahlen
fließkommazahlen = array.array('d', [1.1, 2.2, 3.3])

Praxiskapitel - Einfache Taschenrechner-Aufgabe¶

Beschreibung für das Jupyter Notebook - Einfache Taschenrechner-Aufgabe¶

Einleitung¶

In diesem Jupyter Notebook werden wir einen einfachen Taschenrechner in Python erstellen, der die grundlegenden Rechenoperationen wie Addition, Subtraktion, Multiplikation und Division unterstützt. Unser Ziel ist es, ein funktionales Programm zu entwickeln, das nur Ganzzahlen (int) akzeptiert, um die Benutzerfreundlichkeit und die korrekte Handhabung der Eingaben zu gewährleisten. Wir werden durch den gesamten Prozess der Programmierung eines solchen Taschenrechners gehen, einschließlich der Implementierung der mathematischen Funktionen, der Eingabeverarbeitung und der Fehlerbehandlung.

Lernziele¶

Nach Abschluss dieser Aufgabe werden Sie in der Lage sein:

  1. Grundlegende Python-Funktionen zu erstellen: Sie lernen, wie Sie Funktionen für mathematische Operationen wie Addition, Subtraktion, Multiplikation und Division implementieren.
  2. Benutzereingaben zu verarbeiten: Sie verstehen, wie Sie Benutzereingaben einlesen und in Ganzzahlen konvertieren, um sicherzustellen, dass nur gültige Eingaben verarbeitet werden.
  3. Fehlerbehandlung zu implementieren: Sie erfahren, wie Sie Fehlerbehandlung in Ihr Programm einbauen, um ungültige Eingaben abzufangen und den Benutzer entsprechend zu informieren.
  4. Ein einfaches Textmenü zu erstellen: Sie lernen, wie Sie ein Menü zur Auswahl der gewünschten Rechenoperation anzeigen und die entsprechende Funktion basierend auf der Benutzereingabe ausführen.
  5. Grundlegende mathematische Operationen durchzuführen: Sie werden die grundlegenden mathematischen Operationen auf Ganzzahlen anwenden und die Ergebnisse korrekt ausgeben.

Beispiel für den Taschenrechner-Code¶

Hier ist der vollständige Python-Code für den einfachen Taschenrechner:

In [6]:
def addieren(x, y):
    return x + y

def subtrahieren(x, y):
    return x - y

def multiplizieren(x, y):
    return x * y

def dividieren(x, y):
    if y == 0:
        return "Fehler: Division durch Null ist nicht erlaubt."
    else:
        return x // y  # Ganzzahlige Division

def taschenrechner():
    print("Willkommen beim einfachen Taschenrechner!")
    print("Nur Ganzzahlen sind zulässig.")
    print("Wählen Sie eine Operation aus:")
    print("1. Addition (+)")
    print("2. Subtraktion (-)")
    print("3. Multiplikation (*)")
    print("4. Division (/)")

    operation = input("Geben Sie die Nummer der Operation ein (1/2/3/4): ")

    if operation in ['1', '2', '3', '4']:
        try:
            num1 = int(input("Geben Sie die erste Ganzzahl ein: "))
            num2 = int(input("Geben Sie die zweite Ganzzahl ein: "))

            if operation == '1':
                print(f"{num1} + {num2} = {addieren(num1, num2)}")

            elif operation == '2':
                print(f"{num1} - {num2} = {subtrahieren(num1, num2)}")

            elif operation == '3':
                print(f"{num1} * {num2} = {multiplizieren(num1, num2)}")

            elif operation == '4':
                print(f"{num1} // {num2} = {dividieren(num1, num2)}")

        except ValueError:
            print("Fehler: Bitte geben Sie nur Ganzzahlen ein.")
    else:
        print("Ungültige Eingabe. Bitte wählen Sie eine gültige Operation.")

# Hauptfunktion ausführen
taschenrechner()

Willkommen beim einfachen Taschenrechner!
Nur Ganzzahlen sind zulässig.
Wählen Sie eine Operation aus:
1. Addition (+)
2. Subtraktion (-)
3. Multiplikation (*)
4. Division (/)

22 + 33 = 55

Kapitel 14: Datetime und Timedelta in Python¶

Einführung¶

In Python ist das Arbeiten mit Datum und Uhrzeit eine häufige Anforderung in vielen Anwendungen. Python bietet dafür das datetime-Modul, das die Klassen datetime, date, time und timedelta umfasst. Diese Klassen ermöglichen es Entwicklern, auf einfache Weise mit Datums- und Zeitwerten zu arbeiten, sie zu vergleichen, zu formatieren und zu manipulieren. In diesem Kapitel werden wir uns eingehend mit diesen Klassen befassen und ihre wichtigsten Funktionen und Eigenschaften kennenlernen.

  • datetime: Eine Klasse, die sowohl Datum als auch Uhrzeit darstellt.
  • date: Eine Klasse, die nur das Datum darstellt.
  • time: Eine Klasse, die nur die Uhrzeit darstellt.
  • timedelta: Eine Klasse, die eine Zeitspanne oder einen Zeitraum darstellt, z.B. die Differenz zwischen zwei datetime-Werten.

Durch das Verständnis und die Anwendung dieser Klassen können Entwickler präzisere und effizientere Programme erstellen, die mit Datums- und Zeitinformationen arbeiten.

Lernziele¶

Nach Abschluss dieses Kapitels wirst du:

  • Die Klassen im datetime-Modul verstehen und wissen, wie man sie verwendet, um Datum und Zeit zu repräsentieren.
  • Verschiedene Methoden und Operationen auf datetime-Objekten anwenden können, wie das Hinzufügen von Tagen oder das Vergleichen von Datum und Zeit.
  • Datums- und Zeitformatierungen verstehen und anwenden.
  • Mit Zeitspannen (timedelta) arbeiten, um Zeitdifferenzen zu berechnen.

Voraussetzungen¶

Bevor du dieses Kapitel beginnst, solltest du die folgenden Konzepte bereits verstanden haben:

  • Variablen und Datentypen
  • Einfache Wertedatentypen (int, float, str)
  • Kontrollstrukturen (if, else, for, while)

Die datetime-Klassen verstehen¶

Importieren des datetime-Moduls¶

Um die Klassen des datetime-Moduls nutzen zu können, musst du das Modul zuerst importieren:

import datetime

Kapitel 15: Die fantastischen Zufälle erkunden mit random¶

Einleitung¶

In diesem Kapitel werden wir uns mit der random-Bibliothek in Python beschäftigen. Diese Bibliothek ermöglicht es uns, Zufallszahlen zu generieren, was in vielen Anwendungen und Spielen nützlich sein kann. Wir werden die Grundlagen der random-Bibliothek kennenlernen, wie man sie verwendet und einige praktische Anwendungsbeispiele durchgehen. Am Ende des Kapitels wirst du in der Lage sein, eigene Programme zu schreiben, die Zufallszahlen nutzen.

Lernziele¶

Nach Abschluss dieses Kapitels wirst du:

  • Die random-Bibliothek in Python verstehen und wissen, wie man sie importiert und verwendet.
  • Verschiedene Methoden der random-Bibliothek anwenden können, um Zufallszahlen zu generieren.
  • Praktische Anwendungsbeispiele der random-Bibliothek kennen und in eigenen Projekten einsetzen können.

Voraussetzungen¶

Bevor du dieses Kapitel beginnst, solltest du die folgenden Konzepte bereits verstanden haben:

  • Variablen und Datentypen
  • Einfache Wertedatentypen (int, float, str)
  • Kontrollstrukturen (if, else, for, while)

Die random-Bibliothek verstehen¶

Importieren der random-Bibliothek¶

Um die Funktionen der random-Bibliothek nutzen zu können, musst du sie zuerst importieren:

import random
In [ ]:
 

Willkommen beim 'Guess My Number'-Spiel!
Ich habe eine Zahl zwischen 1 und 100 gewählt. Kannst du sie erraten?

Zu niedrig! Versuch es noch einmal.

Zu hoch! Versuch es noch einmal.
In [ ]: