3. Variablen und grundlegende Datentypen

In Kapitel 2 haben Sie gelernt, wie Sie einfache Programme schreiben, die Text ausgeben, Eingaben annehmen und grundlegende Operationen ausführen. Diese Programme hatten jedoch eine wesentliche Einschränkung: Sie konnten keine Informationen für die spätere Verwendung speichern oder mit verschiedenen Arten von Daten auf anspruchsvolle Weise arbeiten. In diesem Kapitel lernen Sie, wie Python Informationen mithilfe von Variablen und Datentypen speichert und verwaltet.

Stellen Sie sich Variablen als Behälter mit Etikett vor, die Informationen enthalten. So wie Sie möglicherweise beschriftete Kisten verwenden, um Gegenstände in Ihrem Zuhause zu organisieren, verwendet Python Variablen, um Daten in Ihren Programmen zu organisieren und zu verwalten. Aber nicht alle Daten sind gleich – eine Zahl unterscheidet sich deutlich von Text, und Python muss wissen, mit welcher Art von Daten es arbeitet. Hier kommen Datentypen ins Spiel.

Am Ende dieses Kapitels werden Sie verstehen:

• Wie Sie Variablen korrekt erstellen und benennen
• Was Datentypen sind und warum sie wichtig sind
• Wie Sie mit Zahlen, Text und logischen Werten arbeiten
• Wie Sie zwischen verschiedenen Datentypen umwandeln
• Wie Python Daten intern darstellt

Diese Konzepte bilden die Grundlage für alles Weitere, was Sie in Python tun werden, daher werden wir sie ausführlich behandeln und mit vielen praktischen Beispielen veranschaulichen.

3.1) Variablen benennen und erstellen

3.1.1) Was Variablen sind und warum sie wichtig sind

Eine Variable ist ein Name, der sich auf einen Wert bezieht, der im Speicher Ihres Computers gespeichert ist. Wenn Sie eine Variable erstellen, erzeugen Sie im Wesentlichen ein Etikett, das auf ein bestimmtes Datenstück zeigt. Das ermöglicht Ihnen:

1. Informationen zu speichern für die spätere Verwendung in Ihrem Programm
2. Mehrfach auf denselben Wert zuzugreifen, ohne ihn neu eintippen zu müssen
3. Werte zu aktualisieren, während Ihr Programm läuft
4. Ihren Code lesbar zu machen, indem Sie aussagekräftige Namen statt Rohwerten verwenden

Sehen wir uns ein konkretes Beispiel an. Ohne Variablen könnten Sie zur Berechnung der Fläche eines Rechtecks Folgendes schreiben:

# without_variables.py
print("Rectangle area:", 15 * 8)

Das funktioniert, aber was ist, wenn Sie diese Abmessungen mehrfach verwenden müssen? Und wofür stehen 15 und 8 überhaupt? Mit Variablen wird der Code klarer und flexibler:

# with_variables.py
length = 15
width = 8
area = length * width
print("Rectangle area:", area)  # Output: Rectangle area: 120

Jetzt ist der Code selbsterklärend – jede Person, die ihn liest, kann sofort verstehen, dass wir die Fläche eines Rechtecks mit bestimmten Abmessungen berechnen. Wenn wir die Abmessungen ändern müssen, passen wir nur die Variablenzuweisungen am Anfang an.

3.1.2) Variablen mit Zuweisung erstellen

In Python erstellen Sie eine Variable mit dem Zuweisungsoperator (=). Die grundlegende Syntax lautet:

variable_name = value

Das =-Zeichen bedeutet hier nicht „gleich“ im mathematischen Sinn. Stattdessen bedeutet es „weise den Wert rechts dem Namen links zu“. Das ist ein entscheidender Unterschied. Wenn Python diese Anweisung sieht, dann:

1. wertet es den Ausdruck auf der rechten Seite von = aus
2. erstellt oder aktualisiert es den Variablennamen auf der linken Seite
3. lässt diesen Namen auf den resultierenden Wert verweisen

Hier sind mehrere Beispiele zum Erstellen von Variablen:

# creating_variables.py
age = 25
temperature = 72.5
name = "Alice"
is_student = True
 
print(age)          # Output: 25
print(temperature)  # Output: 72.5
print(name)         # Output: Alice
print(is_student)   # Output: True

Beachten Sie, dass wir nicht angeben müssen, welchen Datentyp jede Variable haben wird – Python erkennt dies automatisch anhand des zugewiesenen Werts. Dies nennt man dynamische Typisierung, und sie macht Python sehr flexibel und einfach zu verwenden.

Sie können auch mehrere Variablen in einer einzigen Zeile mit Mehrfachzuweisung erstellen:

# multiple_assignment.py
x, y, z = 10, 20, 30
print(x)  # Output: 10
print(y)  # Output: 20
print(z)  # Output: 30
 
# You can even assign the same value to multiple variables
a = b = c = 100
print(a, b, c)  # Output: 100 100 100

Die erste Form (genannt Tuple-Unpacking – wir lernen Tupel in Kapitel 14 kennen) weist jeden Wert in der Reihenfolge der entsprechenden Variable zu. Die zweite Form weist allen drei Variablen denselben Wert zu.

3.1.3) Regeln und Konventionen zur Variablennamenvergabe

Python hat spezifische Regeln dafür, was einen gültigen Variablennamen ausmacht. Einige davon sind Pflichtregeln (Regeln, die Sie befolgen müssen), andere sind Konventionen (Richtlinien, die Ihren Code lesbarer machen und ihn mit anderem Python-Code konsistent halten).

Pflichtregeln (müssen befolgt werden):

1. Muss mit einem Buchstaben (a-z, A-Z) oder Unterstrich (_) beginnen: Variablennamen dürfen nicht mit einer Ziffer beginnen.
2. Darf Buchstaben, Ziffern und Unterstriche enthalten: Nach dem ersten Zeichen dürfen Sie beliebige Kombinationen aus Buchstaben, Ziffern und Unterstrichen verwenden.
3. Darf keine Leerzeichen oder Sonderzeichen enthalten: Leerzeichen, Bindestriche und die meisten Satzzeichen sind nicht erlaubt.
4. Darf kein Python-Schlüsselwort sein: Python reserviert bestimmte Wörter für die eigene Verwendung (wie if, for, while, def usw.).
5. Groß-/Kleinschreibung ist relevant: age, Age und AGE sind drei verschiedene Variablen.

Hier sind Beispiele für gültige und ungültige Variablennamen:

# valid_names.py
# Valid variable names
user_age = 30
firstName = "John"
total_2024 = 1000
_private = "hidden"
x = 5
MAX_SIZE = 100
 
# Invalid variable names (these will cause errors)
# 2nd_place = "silver"      # Error: starts with digit
# user-name = "alice"       # Error: contains hyphen
# total amount = 500        # Error: contains space
# class = "Python 101"      # Error: 'class' is a keyword

Konventionen (sollten zur besseren Lesbarkeit befolgt werden):

1. Verwenden Sie Kleinbuchstaben mit Unterstrichen für normale Variablen: Dieser Stil heißt snake_case und ist der Standard in Python.

   python

   user_age = 25
   total_price = 99.99
   is_valid = True

2. Verwenden Sie GROSSBUCHSTABEN für Konstanten: Werte, die sich während der Programmausführung nicht ändern sollen.

   python

   MAX_ATTEMPTS = 3
   PI = 3.14159
   DEFAULT_COLOR = "blue"

3. Verwenden Sie aussagekräftige Namen: Variablennamen sollten klar erkennen lassen, was sie darstellen.

   python

   # Good: clear and descriptive
   student_count = 30
   average_temperature = 72.5
    
   # Poor: unclear abbreviations
   sc = 30
   avg_tmp = 72.5
    
   # Poor: too generic
   x = 30
   data = 72.5

4. Vermeiden Sie Ein-Buchstaben-Namen, außer in speziellen Fällen: Ein-Buchstaben-Namen wie i, j, k sind für Zählervariablen in Schleifen (loops) akzeptabel (die wir in Kapitel 11 kennenlernen werden), und x, y, z sind für Koordinaten in Ordnung. Ansonsten sollten Sie beschreibende Namen verwenden.

5. Verwenden Sie keine Namen, die eingebaute Funktionen überdecken: Obwohl Python es erlaubt, sollten Sie Namen wie list, str, int, print usw. vermeiden, da dies eingebaute Funktionsnamen sind.

Sehen wir uns ein praktisches Beispiel an, das gute Benennungspraxis demonstriert:

# good_naming.py
# Constants at the top
SALES_TAX_RATE = 0.08
DISCOUNT_THRESHOLD = 100
 
# Descriptive variable names
item_price = 75.00
quantity = 3
subtotal = item_price * quantity
 
# Clear boolean variable
qualifies_for_discount = subtotal >= DISCOUNT_THRESHOLD
 
if qualifies_for_discount:
    discount = subtotal * 0.10
    subtotal = subtotal - discount
    print("Discount applied: $", discount)
 
tax = subtotal * SALES_TAX_RATE
total = subtotal + tax
 
print("Subtotal: $", subtotal)
print("Tax: $", tax)
print("Total: $", total)
# Output:
# Subtotal: $ 202.5
# Tax: $ 16.2
# Total: $ 218.7

Beachten Sie, wie die Variablennamen den Code selbsterklärend machen. Selbst ohne Kommentare können Sie verstehen, was das Programm berechnet.

3.1.4) Variablen in Ausdrücken verwenden

Sobald Sie eine Variable erstellt haben, können Sie sie überall dort verwenden, wo Sie auch den Wert selbst verwenden würden. Python ersetzt beim Auswerten von Ausdrücken automatisch den aktuellen Wert der Variable:

# using_variables.py
# Create some variables
hours_worked = 40
hourly_rate = 25.50
 
# Use variables in calculations
gross_pay = hours_worked * hourly_rate
print("Gross pay:", gross_pay)  # Output: Gross pay: 1020.0
 
# Use variables in other expressions
bonus = gross_pay * 0.10
total_pay = gross_pay + bonus
print("Total with bonus:", total_pay)  # Output: Total with bonus: 1122.0
 
# Use variables in strings (we'll learn more about this in Chapter 5)
message = "You worked " + str(hours_worked) + " hours"
print(message)  # Output: You worked 40 hours

Variablen können auch mit den Funktionen verwendet werden, die Sie in Kapitel 2 kennengelernt haben:

# variables_with_functions.py
name = input("What is your name? ")
age = input("What is your age? ")
 
greeting = "Hello, " + name + "!"
print(greeting)
 
age_next_year = int(age) + 1
print("Next year you will be", age_next_year, "years old.")
# If user enters "Alice" and "25":
# Output: Hello, Alice!
# Output: Next year you will be 26 years old.

Dieses Beispiel zeigt auch ein wichtiges Konzept: Die Funktion input() liefert immer Text (einen String) zurück. Wenn Sie also damit rechnen wollen, müssen Sie ihn zuerst in eine Zahl umwandeln. Diesen Umwandlungsprozess werden wir später in diesem Kapitel (Abschnitt 3.7) im Detail betrachten.

3.2) Zuweisung und erneute Zuweisung von Variablen

3.2.1) Die Zuweisung verstehen

Wenn Sie einer Variable einen Wert zuweisen, erzeugt Python eine Verbindung zwischen dem Variablennamen und dem Wert im Speicher. Es ist wichtig zu verstehen, dass die Variable den Wert nicht „enthält“ im physischen Sinn – vielmehr ist sie ein Name, der sich auf einen Wert bezieht bzw. auf einen im Speicher abgelegten Wert zeigt.

Stellen Sie es sich wie ein Klebeetikett mit einem Namen darauf vor, das an einer Box mit dem eigentlichen Wert klebt. Die Variable (das Klebeetikett) ist nicht der Wert selbst – sie zeigt nur darauf, wo der Wert gespeichert ist. Wenn Sie die Variable neu zuweisen, verschieben Sie das Klebeetikett, sodass es auf eine andere Box zeigt, statt den Inhalt der ursprünglichen Box zu verändern.

Dieser Unterschied wird wichtig, wenn wir über erneute Zuweisung sprechen. Sehen wir uns an, was beim Zuweisen und erneuten Zuweisen von Variablen passiert:

# assignment_basics.py
x = 10
print(x)  # Output: 10
 
# Reassign x to a new value
x = 20
print(x)  # Output: 20
 
# The old value (10) is gone; x now refers to 20

Schritt für Schritt geschieht Folgendes:

1. x = 10: Python erstellt den Ganzzahlwert 10 im Speicher und lässt den Namen x darauf verweisen
2. print(x): Python ermittelt, worauf x zeigt (10), und gibt es aus
3. x = 20: Python erstellt den Ganzzahlwert 20 im Speicher und lässt x stattdessen auf diesen neuen Wert verweisen
4. print(x): Python ermittelt, worauf x jetzt zeigt (20), und gibt es aus

Der ursprüngliche Wert 10 existiert vorübergehend noch im Speicher, aber da keine Variable mehr auf ihn verweist, wird Pythons automatische Speicherverwaltung (genannt Garbage Collection) ihn irgendwann aufräumen.

3.2.2) Erneute Zuweisung und Aktualisieren von Variablen

Eines der häufigsten Muster in der Programmierung ist das Aktualisieren einer Variable basierend auf ihrem aktuellen Wert. Beispielsweise möchten Sie vielleicht einen Zähler erhöhen, zu einer laufenden Summe addieren oder einen Wert basierend auf einer Berechnung verändern:

# updating_variables.py
score = 0
print("Initial score:", score)  # Output: Initial score: 0
 
# Add 10 points
score = score + 10
print("After first update:", score)  # Output: After first update: 10
 
# Add 5 more points
score = score + 5
print("After second update:", score)  # Output: After second update: 15
 
# Double the score
score = score * 2
print("After doubling:", score)  # Output: After doubling: 30

Betrachten wir im Detail, was bei score = score + 10 passiert:

1. Python wertet die rechte Seite aus: score + 10
2. Es ermittelt den aktuellen Wert von score (0)
3. Es berechnet 0 + 10 und erhält 10
4. Es weist diesen neuen Wert (10) score zu
5. Nun verweist score auf 10 statt auf 0

Dieses Muster kommt so häufig vor, dass Python dafür Kurzschreibweisen anbietet, die wir in Kapitel 4 (Abschnitt 4.3) kennenlernen werden. Für den Moment ist die ausführliche Form wichtig, weil sie die Reihenfolge der Operationen deutlich zeigt: zuerst die rechte Seite vollständig auswerten, dann der linken Seite zuweisen.

3.2.3) Variablen sind unabhängig

Wenn Sie einer Variable den Wert einer anderen zuweisen, kopiert Python bei einfachen Typen wie Zahlen und Strings die Referenz, nicht den Wert selbst. Für die grundlegenden Typen, die wir in diesem Kapitel kennenlernen, verhalten sich Variablen nach der Zuweisung jedoch unabhängig:

# independent_variables.py
a = 10
b = a  # b now refers to the same value as a (10)
print("a:", a)  # Output: a: 10
print("b:", b)  # Output: b: 10
 
# Change a
a = 20
print("After changing a:")
print("a:", a)  # Output: a: 20
print("b:", b)  # Output: b: 10 (unchanged!)

Als wir b = a zugewiesen haben, haben wir b auf denselben Wert verweisen lassen, auf den a in diesem Moment verwies (10). Als wir später a so geändert haben, dass es auf 20 verweist, blieb b unverändert – es verweist weiterhin auf 10.

Dieses Verhalten ist für Zahlen und Strings unkompliziert, wird aber bei Sammlungen wie Listen (lists) und Dictionaries komplexer. Wir werden dies in Kapitel 17 gründlich untersuchen, wenn wir Pythons Objektmodell und Referenzsemantik besprechen.

3.2.4) Variablen vor der Zuweisung verwenden

Ein häufiger Fehler von Einsteigern ist der Versuch, eine Variable zu verwenden, bevor ihr ein Wert zugewiesen wurde. Python wird in diesem Fall einen NameError auslösen:

# undefined_variable.py
print(total)  # Error: NameError: name 'total' is not defined

Dieser Fehler tritt auf, weil Python nicht weiß, worauf sich total bezieht – Sie haben es noch nicht erstellt. Die Lösung ist einfach: Weisen Sie der Variable vor der Verwendung einen Wert zu:

# defined_variable.py
total = 0  # Initialize the variable first
print(total)  # Output: 0
 
# Now we can update it
total = total + 10
print(total)  # Output: 10

Dieses Muster, eine Variable zu initialisieren (ihr zunächst einen Anfangswert zu geben), bevor sie verwendet wird, ist grundlegend in der Programmierung. Wir werden viele Beispiele dafür im gesamten Buch sehen, insbesondere bei Zählern und Akkumulatoren in Schleifen (Kapitel 10).

3.2.5) Werte von Variablen tauschen

Eine häufige Operation ist das Tauschen der Werte zweier Variablen. In vielen Programmiersprachen erfordert dies eine temporäre Variable:

# swap_with_temp.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap using a temporary variable
temp = x    # Save x's value
x = y       # Put y's value in x
y = temp    # Put saved value in y
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Python bietet jedoch eine elegantere Möglichkeit mit gleichzeitiger Zuweisung:

# swap_pythonic.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap in one line
x, y = y, x
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Das funktioniert, weil Python die gesamte rechte Seite (y, x) auswertet, bevor irgendeine Zuweisung erfolgt. Es erstellt also eine temporäre Struktur, die die Werte von y und x enthält, und packt diese Werte dann in x bzw. y aus. Dies ist ein schönes Beispiel für Pythons Philosophie, häufige Operationen einfach und lesbar zu gestalten.

3.3) Das Konzept der Datentypen und type()

3.3.1) Was sind Datentypen?

Ein Datentyp (oder kurz Typ) definiert, welche Art von Daten ein Wert darstellt und welche Operationen darauf ausgeführt werden können. Sie können sich Datentypen als Kategorien vorstellen, die Python mitteilen, wie verschiedene Arten von Informationen zu interpretieren und zu verarbeiten sind.

Zum Beispiel:

• Die Zahl 42 ist ein Integer (Ganzzahl)
• Die Zahl 3.14 ist eine Gleitkommazahl (Zahl mit Dezimalpunkt)
• Der Text "Hello" ist ein String (Sequenz von Zeichen)
• Der Wert True ist ein Boolean (logischer Wahr/Falsch-Wert)

Warum sind Datentypen wichtig? Weil unterschiedliche Typen unterschiedliche Operationen unterstützen:

# type_operations.py
# You can add numbers
result1 = 10 + 5
print(result1)  # Output: 15
 
# You can also "add" strings (concatenation)
result2 = "Hello" + " " + "World"
print(result2)  # Output: Hello World
 
# But you can't add a number and a string directly
# result3 = 10 + "5"  # Error: TypeError: unsupported operand type(s)

Der Fehler im letzten Beispiel tritt auf, weil Python nicht weiß, wie es eine Zahl und einen String addieren soll – es handelt sich um grundlegend verschiedene Arten von Daten. Soll es die Zahl in Text umwandeln und verketten? Soll es den Text in eine Zahl umwandeln und mathematisch addieren? Python verlangt von Ihnen, dass Sie explizit angeben, was Sie möchten, indem Sie einen Wert in den Typ des anderen konvertieren (wie in Abschnitt 3.7 besprochen).

3.3.2) type() verwenden, um Datentypen zu prüfen

Python stellt eine eingebaute Funktion type() zur Verfügung, die Ihnen sagt, welchen Typ ein Wert oder eine Variable hat. Das ist äußerst nützlich, um Ihre Daten zu verstehen und Probleme zu debuggen:

# checking_types.py
# Check types of literal values
print(type(42))        # Output: <class 'int'>
print(type(3.14))      # Output: <class 'float'>
print(type("Hello"))   # Output: <class 'str'>
print(type(True))      # Output: <class 'bool'>
 
# Check types of variables
age = 25
name = "Alice"
temperature = 98.6
is_valid = False
 
print(type(age))         # Output: <class 'int'>
print(type(name))        # Output: <class 'str'>
print(type(temperature)) # Output: <class 'float'>
print(type(is_valid))    # Output: <class 'bool'>

Die Ausgabe <class 'int'> bedeutet „dieser Wert gehört zur Klasse (Typ) int“. In Python sind Typen tatsächlich Klassen (wir werden Klassen in Teil VIII ausführlich behandeln), aber für den Moment können Sie diese Begriffe als austauschbar betrachten.

3.3.3) Dynamische Typisierung in Python

Python ist eine dynamisch typisierte Sprache, was bedeutet:

1. Variablen haben keinen festen Typ: Eine Variable kann sich zu verschiedenen Zeitpunkten auf Werte unterschiedlicher Typen beziehen
2. Typen werden zur Laufzeit bestimmt: Python erkennt die Typen, wenn das Programm ausgeführt wird, nicht, wenn Sie den Code schreiben
3. Sie deklarieren keine Typen explizit: Anders als in manchen anderen Sprachen müssen Sie nicht sagen „diese Variable wird eine Ganzzahl enthalten“

Hier ist ein Beispiel für dynamische Typisierung in Aktion:

# dynamic_typing.py
x = 42
print(x, "is of type", type(x))  # Output: 42 is of type <class 'int'>
 
x = "Hello"
print(x, "is of type", type(x))  # Output: Hello is of type <class 'str'>
 
x = 3.14
print(x, "is of type", type(x))  # Output: 3.14 is of type <class 'float'>

Beachten Sie, wie sich x zu verschiedenen Zeitpunkten im Programm auf Werte unterschiedlicher Typen beziehen kann. Python beschwert sich nicht – es aktualisiert einfach den Typ, auf den sich x gerade bezieht.

Während diese Flexibilität praktisch ist, bedeutet sie auch, dass Sie vorsichtig sein müssen. Wenn Sie erwarten, dass eine Variable eine Zahl enthält, sie aber tatsächlich einen String enthält, können unerwartete Fehler auftreten:

# type_confusion.py
value = "100"  # This is a string, not a number!
 
# Trying to do math with it will fail
# result = value + 50  # Error: TypeError: can only concatenate str to str
 
# You need to convert it first
result = int(value) + 50
print(result)  # Output: 150

Deshalb ist das Verständnis von Datentypen entscheidend – es hilft Ihnen vorherzusagen, welche Operationen funktionieren werden und Fehler früh zu erkennen.

3.3.4) Überblick über Pythons eingebaute Typen

Python hat mehrere eingebaute Datentypen. In diesem Kapitel konzentrieren wir uns auf die grundlegendsten:

In diesem Kapitel behandeln wir:

• int: Ganzzahlen (whole numbers)
• float: Gleitkommazahlen (Zahlen mit Dezimalpunkt)
• str: Strings (Text)
• bool: Boolesche Werte (True und False)
• NoneType: Den speziellen Wert None

Wir werden komplexe Zahlen (mit imaginären Anteilen) kurz erwähnen, aber sie werden im Alltag selten benötigt. Die Collection-Typen (wie Listen (lists), Tupel, Dictionaries und Mengen (sets)) sind so wichtig, dass wir ihnen in Teil IV eigene Kapitel gewidmet haben.

3.3.5) Typprüfung in der Praxis

Das Verständnis von Typen wird besonders wichtig, wenn Sie mit Benutzereingaben oder Daten aus externen Quellen arbeiten. Denken Sie daran, dass input() immer einen String zurückgibt, selbst wenn der Benutzer eine Zahl eingibt:

# input_types.py
user_input = input("Enter a number: ")
print("You entered:", user_input)
print("Type:", type(user_input))  # Output: Type: <class 'str'>
 
# Even if user types "42", it's still a string!
# To use it as a number, convert it:
number = int(user_input)
print("As a number:", number)
print("Type:", type(number))  # Output: Type: <class 'int'>
 
# Now we can do math with it
doubled = number * 2
print("Doubled:", doubled)

Wenn Sie dieses Programm ausführen und 42 eingeben, sehen Sie:

Enter a number: 42
You entered: 42
Type: <class 'str'>
As a number: 42
Type: <class 'int'>
Doubled: 84

Das zeigt einen entscheidenden Punkt: Der String "42" und der Integer 42 sind in Python verschiedene Dinge, auch wenn sie bei der Ausgabe ähnlich aussehen. Der String ist eine Sequenz aus zwei Zeichen ('4' und '2'), während der Integer ein Zahlenwert ist, der in mathematischen Operationen verwendet werden kann.

3.4) Ganzzahlen und Gleitkommazahlen

3.4.1) Integers (int)

Ein Integer (Typ int) ist eine Ganzzahl ohne Dezimalpunkt. Integers können positiv, negativ oder null sein, und in Python 3 können sie beliebig groß werden – nur begrenzt durch den verfügbaren Speicher Ihres Computers.

# integers.py
# Positive integers
age = 25
year = 2024
population = 8000000000
 
# Negative integers
temperature = -15
debt = -5000
 
# Zero
balance = 0
 
# Very large integers (Python handles these easily)
huge_number = 123456789012345678901234567890
print(huge_number)  # Output: 123456789012345678901234567890
print(type(huge_number))  # Output: <class 'int'>

Python erlaubt es Ihnen, große Zahlen mit Unterstrichen zur besseren Lesbarkeit zu schreiben. Die Unterstriche werden von Python ignoriert, machen die Zahlen aber für Menschen leichter lesbar:

# readable_numbers.py
# These are all the same number
million = 1000000
million = 1_000_000  # Much easier to read!
 
# Works with any size
population = 8_000_000_000
national_debt = 31_000_000_000_000
 
print(million)      # Output: 1000000 (underscores not shown in output)
print(population)   # Output: 8000000000

Sie können Integers auch in verschiedenen Zahlensystemen mit speziellen Präfixen schreiben:

# number_bases.py
# Binary (base 2) - prefix 0b
binary = 0b1010  # This is 10 in decimal
print(binary)  # Output: 10
 
# Octal (base 8) - prefix 0o
octal = 0o12  # This is 10 in decimal
print(octal)  # Output: 10
 
# Hexadecimal (base 16) - prefix 0x
hexadecimal = 0xFF  # This is 255 in decimal
print(hexadecimal)  # Output: 255

Diese alternativen Zahlensysteme sind in bestimmten Kontexten nützlich (z. B. bei der Arbeit mit Farben im Webdesign oder in der Systemprogrammierung), aber für die meisten alltäglichen Anwendungen verwenden Sie gewöhnliche Dezimalzahlen.

3.4.2) Gleitkommazahlen (float)

Eine Gleitkommazahl (Typ float) ist eine Zahl mit Dezimalpunkt. Floats werden verwendet, um reelle Zahlen darzustellen – Werte, die nicht unbedingt ganze Zahlen sind:

# floats.py
# Numbers with decimal points
price = 19.99
temperature = 98.6
pi = 3.14159
 
# Very small numbers
electron_mass = 0.00000000000000000000000000000091093837
 
# Very large numbers
speed_of_light = 299792458.0
 
print(price)           # Output: 19.99
print(temperature)     # Output: 98.6
print(electron_mass)   # Output: 9.1093837e-31 (scientific notation)
print(speed_of_light)  # Output: 299792458.0

Beachten Sie, dass sehr kleine oder sehr große Floats in wissenschaftlicher Notation (auch Exponentialschreibweise genannt) angezeigt werden. Die Notation 9.1093837e-31 bedeutet „9.1093837 × 10⁻³¹“ oder „9.1093837 geteilt durch 10 hoch 31“.

Sie können Floats auch direkt in wissenschaftlicher Notation schreiben:

# scientific_notation.py
# These are equivalent
avogadro = 602214076000000000000000.0
avogadro = 6.02214076e23  # Much more readable!
 
# Small numbers
planck = 0.000000000000000000000000000000000662607015
planck = 6.62607015e-34  # Much more readable!
 
print(avogadro)  # Output: 6.02214076e+23
print(planck)    # Output: 6.62607015e-34

Das e (oder E) steht für „Exponent“. Die Zahl nach e gibt an, um wie viele Stellen der Dezimalpunkt verschoben wird (positiv nach rechts, negativ nach links).

3.4.3) Integer vs Float: Wichtige Unterschiede

Obwohl Integers und Floats beide Zahlen darstellen, gibt es wichtige Unterschiede:

1. Genauigkeit und Darstellung:

Integers sind exakt – der Wert 42 ist genau 42, ohne Näherung. Floats hingegen sind Approximationen, bedingt durch die Art und Weise, wie Computer Dezimalzahlen binär speichern:

# float_precision.py
# This might surprise you!
result = 0.1 + 0.2
print(result)  # Output: 0.30000000000000004
 
# The result isn't exactly 0.3 due to floating-point representation
print(result == 0.3)  # Output: False

Das ist kein Fehler im eigentlichen Sinn, sondern eine grundlegende Einschränkung der Gleitkommadarstellung in Computern. Wir werden dies in Kapitel 4 (Abschnitt 4.10) genauer besprechen, aber fürs Erste sollten Sie wissen, dass Berechnungen mit Floats nicht immer vollkommen präzise sind.

2. Operationen und Ergebnisse:

Wenn Sie mit Integers und Floats rechnen, befolgt Python bestimmte Regeln:

# int_float_operations.py
# Integer operations
int_result = 10 + 5
print(int_result, type(int_result))  # Output: 15 <class 'int'>
 
# Float operations
float_result = 10.0 + 5.0
print(float_result, type(float_result))  # Output: 15.0 <class 'float'>
 
# Mixed operations: result is always float
mixed_result = 10 + 5.0
print(mixed_result, type(mixed_result))  # Output: 15.0 <class 'float'>
 
# Division always returns float, even with integers
division_result = 10 / 5
print(division_result, type(division_result))  # Output: 2.0 <class 'float'>

Die wichtigste Regel: Jede Operation, an der mindestens ein Float beteiligt ist, liefert ein Float-Ergebnis. Das ist sinnvoll, weil Floats einen größeren Wertebereich abdecken (einschließlich nicht-ganzzahliger Werte), daher „befördert“ Python das Ergebnis zum allgemeineren Typ.

3. Speicher und Performance:

Integers benötigen weniger Speicher und sind in Berechnungen schneller als Floats. Für die meisten Programme ist dieser Unterschied vernachlässigbar, kann aber in performanzkritischen Anwendungen oder bei sehr großen Datenmengen eine Rolle spielen.

3.4.4) Wann int und wann float verwenden

Hier sind praktische Richtlinien, wann Sie Integers bzw. Floats verwenden sollten:

Verwenden Sie Integers, wenn:

• Sie abzählbare Dinge zählen (Personen, Objekte, Iterationen)
• Sie exakte Größen darstellen, die nicht gebrochen sein können (Anzahl Studierender, Anzahl Klicks)
• Sie mit Indizes oder Positionen in Sequenzen arbeiten
• Exakte Arithmetik erforderlich ist

# use_integers.py
student_count = 30  # Can't have 30.5 students
page_number = 42    # Can't be on page 42.7
loop_counter = 0    # Counting iterations

Verwenden Sie Floats, wenn:

• Sie Messwerte darstellen (Temperatur, Entfernung, Gewicht)
• Sie mit Geld arbeiten (achten Sie aber auf Genauigkeit – dazu mehr in Kapitel 4)
• Sie Verhältnisse, Prozentsätze oder Durchschnitte berechnen
• Näherungswerte akzeptabel sind

# use_floats.py
temperature = 72.5     # Temperature can be fractional
price = 19.99          # Money amounts have cents
average_score = 87.3   # Averages are often fractional
percentage = 0.15      # 15% as a decimal

3.5) String- und Boolean-Literale (ein kurzer Überblick)

In diesem Abschnitt führen wir kurz zwei weitere fundamentale Datentypen ein: Strings und Booleans. Strings werden wir in den Kapiteln 5 und 6 ausführlich behandeln, Booleans in Kapitel 7, aber Sie benötigen ein Grundverständnis davon, um auch nur einfache Programme schreiben zu können.

3.5.1) String-Grundlagen

Ein String (Typ str) ist eine Sequenz von Zeichen – im Wesentlichen Text. Sie erstellen Strings, indem Sie Text in Anführungszeichen setzen. Python akzeptiert sowohl einfache (') als auch doppelte (") Anführungszeichen:

# string_basics.py
# Single quotes
name = 'Alice'
message = 'Hello, World!'
 
# Double quotes (exactly equivalent)
name = "Alice"
message = "Hello, World!"
 
# Print them
print(name)     # Output: Alice
print(message)  # Output: Hello, World!
print(type(name))  # Output: <class 'str'>

Beide Varianten funktionieren identisch – wählen Sie, was Sie bevorzugen, bleiben Sie aber innerhalb Ihres Codes konsistent. Viele Python-Programmierer bevorzugen doppelte Anführungszeichen, weil sie in anderen Sprachen häufiger sind, aber einfache Anführungszeichen sind ebenso gültig.

Warum gibt es beide? Der Hauptgrund ist Bequemlichkeit, wenn Ihr String Anführungszeichen enthält:

# quotes_in_strings.py
# Use double quotes when string contains single quotes
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# Use single quotes when string contains double quotes
speech = 'She said, "Hello!"'
print(speech)  # Output: She said, "Hello!"
 
# Or use escape sequences (we'll learn more in Chapter 5)
sentence = 'It\'s a beautiful day!'  # \' means a literal single quote
speech = "She said, \"Hello!\""     # \" means a literal double quote

Strings können leer sein (keine Zeichen enthalten):

# empty_string.py
empty = ""
also_empty = ''
 
print(empty)            # Output: (nothing—it's empty!)
print(len(empty))       # Output: 0 (we'll learn about len() later)
print(type(empty))      # Output: <class 'str'>

Sie können Strings mit dem +-Operator kombinieren (das nennt man Konkatenation):

# string_concatenation.py
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(full_name)  # Output: John Doe
 
# Be careful: you can't concatenate strings and numbers directly
age = 25
# message = "I am " + age + " years old"  # Error: TypeError
 
# Convert the number to a string first
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Wir werden Strings in den Kapiteln 5 und 6 viel genauer untersuchen, einschließlich Escape-Sequenzen, String-Methoden, Formatierung und Textverarbeitung. Für den Moment sollten Sie sich merken, dass Strings Text darstellen und mit Anführungszeichen erstellt werden.

3.5.2) Boolean-Grundlagen

Ein Boolean (Typ bool) ist ein logischer Wert, der entweder True oder False sein kann. Dies sind die einzigen beiden booleschen Werte in Python und werden verwendet, um Wahrheit und Falschheit in logischen Operationen darzustellen:

# boolean_basics.py
# Boolean literals
is_sunny = True
is_raining = False
 
print(is_sunny)         # Output: True
print(is_raining)       # Output: False
print(type(is_sunny))   # Output: <class 'bool'>

Wichtig: Die booleschen Werte True und False müssen genau so großgeschrieben werden wie gezeigt. Python unterscheidet Groß- und Kleinschreibung, daher funktionieren true, TRUE, false und FALSE nicht:

# boolean_case.py
correct = True    # Correct
# wrong = true    # Error: NameError: name 'true' is not defined
# wrong = TRUE    # Error: NameError: name 'TRUE' is not defined

Booleans entstehen typischerweise durch Vergleiche oder logische Operationen:

# boolean_from_comparisons.py
age = 25
 
# Comparison operators produce boolean results
is_adult = age >= 18
print(is_adult)  # Output: True
 
is_senior = age >= 65
print(is_senior)  # Output: False
 
# You can use booleans in conditions (we'll learn more in Chapter 8)
if is_adult:
    print("You can vote!")  # Output: You can vote!
 
if is_senior:
    print("You get a senior discount!")  # (no output—condition is False)

Häufige Vergleichsoperatoren, die Booleans erzeugen:

• == : gleich
• != : ungleich
• < : kleiner als
• > : größer als
• <= : kleiner oder gleich
• >= : größer oder gleich

# comparison_operators.py
x = 10
y = 20
 
print(x == y)   # Output: False (10 is not equal to 20)
print(x != y)   # Output: True (10 is not equal to 20)
print(x < y)    # Output: True (10 is less than 20)
print(x > y)    # Output: False (10 is not greater than 20)
print(x <= 10)  # Output: True (10 is less than or equal to 10)
print(y >= 20)  # Output: True (20 is greater than or equal to 20)

Wichtige Anmerkung: Verwechseln Sie nicht = (Zuweisung) mit == (Vergleich):

• x = 10 bedeutet „weise x den Wert 10 zu“
• x == 10 bedeutet „prüfe, ob x gleich 10 ist“ (liefert True oder False)

# assignment_vs_comparison.py
x = 10        # Assignment: x now refers to 10
result = (x == 10)  # Comparison: is x equal to 10?
print(result)  # Output: True
 
# This is a common mistake for beginners:
# if x = 10:  # Error: SyntaxError (can't use assignment in if condition)
if x == 10:   # Correct: comparison
    print("x is 10")  # Output: x is 10

Wir werden Booleans in Kapitel 7 viel detaillierter untersuchen, einschließlich logischer Operatoren (and, or, not), Truthiness und Falsiness und wie Python Booleans in Bedingungen verwendet. Für den Moment sollten Sie sich merken, dass Booleans True/False-Werte darstellen und typischerweise aus Vergleichen stammen.

3.5.3) Strings und Booleans im Kontext

Sehen wir uns an, wie Strings und Booleans in einem einfachen praktischen Beispiel zusammenarbeiten:

# strings_booleans_example.py
# Get user input
name = input("What is your name? ")
age_input = input("What is your age? ")
 
# Convert age to integer
age = int(age_input)
 
# Create boolean conditions
is_adult = age >= 18
is_child = age < 13
 
# Build messages using strings
if is_adult:
    status = "adult"
else:
    status = "minor"
 
# Combine everything in output
print("Hello, " + name + "!")
print("You are an " + status + ".")
 
if is_child:
    print("You are a child.")
 
# When user enters "Alice" and "16":
# Output: Hello, Alice!
# Output: You are a minor.

Dieses Beispiel zeigt, wie verschiedene Datentypen zusammenarbeiten: Strings für Text, Integers für Zahlen und Booleans für logische Entscheidungen. Dieses Zusammenspiel zwischen Typen ist grundlegend für alle Programmierung.

3.6) Der Wert None und seine Verwendung

3.6.1) Was ist None?

Python hat einen speziellen Wert namens None (Typ NoneType), der das Fehlen eines Werts darstellt. Es ist Pythons Art zu sagen: „Hier ist nichts“ oder „dies hat noch keinen Wert“.

# none_basics.py
result = None
print(result)        # Output: None
print(type(result))  # Output: <class 'NoneType'>

None ist nicht dasselbe wie Null, ein leerer String oder False – es ist ein eigener, spezieller Wert, der ausdrücklich „kein Wert“ bedeutet:

# none_vs_others.py
x = None
y = 0
z = ""
w = False
 
print(x)  # Output: None
print(y)  # Output: 0
print(z)  # Output: (empty—nothing prints)
print(w)  # Output: False
 
# They're all different types
print(type(x))  # Output: <class 'NoneType'>
print(type(y))  # Output: <class 'int'>
print(type(z))  # Output: <class 'str'>
print(type(w))  # Output: <class 'bool'>

3.6.2) Wann None verwendet wird

None taucht in mehreren typischen Situationen auf:

1. Als Platzhalter für Werte, die Sie später zuweisen:

# none_placeholder.py
# Initialize variables that will be assigned later
user_name = None
user_age = None
 
# Later in the program, after getting user input:
user_name = input("Enter your name: ")
user_age = int(input("Enter your age: "))
 
print("Name:", user_name)
print("Age:", user_age)

2. Als Standardrückgabewert von Funktionen, die nichts explizit zurückgeben:

Funktionen, die wir in Kapitel 19 kennenlernen, können Werte zurückgeben. Wenn eine Funktion nichts explizit zurückgibt, liefert Python automatisch None:

# none_from_function.py
# The print() function returns None
result = print("Hello!")  # Output: Hello!
print(result)             # Output: None
print(type(result))       # Output: <class 'NoneType'>

Das mag seltsam erscheinen, ist aber nützlich. Es bedeutet, dass jede Funktion etwas zurückgibt, selbst wenn dieses „etwas“ kein sinnvoller Wert ist.

3. Zur Darstellung optionaler oder fehlender Daten:

# none_optional.py
# Representing optional middle name
first_name = "John"
middle_name = None  # No middle name
last_name = "Doe"
 
if middle_name is None:
    full_name = first_name + " " + last_name
else:
    full_name = first_name + " " + middle_name + " " + last_name
 
print(full_name)  # Output: John Doe

3.6.3) Auf None prüfen

Um zu prüfen, ob ein Wert None ist, verwenden Sie den Operator is (nicht ==):

# checking_none.py
value = None
 
# Correct way: use 'is'
if value is None:
    print("Value is None")  # Output: Value is None
 
# Also correct: use 'is not'
if value is not None:
    print("Value has a value")
else:
    print("Value is None")  # Output: Value is None
 
# While == works, 'is' is preferred for None
if value == None:  # This works but is not idiomatic Python
    print("Value is None")  # Output: Value is None

Warum is statt == verwenden? Der Operator is prüft, ob zwei Namen auf dasselbe Objekt im Speicher verweisen (wir werden dies in Kapitel 17 genauer betrachten). Da es in Python nur genau ein None-Objekt gibt, ist is sowohl effizienter als auch präziser für diese Prüfung. Die Verwendung von is None ist die übliche Python-Schreibweise.

3.6.4) None in der praktischen Verwendung

Hier ein praktisches Beispiel, das zeigt, wie nützlich None in realen Programmen ist:

# none_practical.py
# Simulate looking up a user's age
# (In real programs, we'd use functions and dictionaries from later chapters)
 
user_name = input("Enter a name (Alice, Bob, or Charlie): ")
 
# Check each name and assign age or None
if user_name == "Alice":
    user_age = 25
elif user_name == "Bob":
    user_age = 30
elif user_name == "Charlie":
    user_age = 35
else:
    user_age = None  # User not found
 
# Check if we found the user
if user_age is not None:
    print(user_name, "is", user_age, "years old")
else:
    print(user_name, "not found")
 
# When user enters "Alice":
# Output: Alice is 25 years old
# When user enters "David":
# Output: David not found

In diesem Beispiel zeigt None klar „Benutzer nicht gefunden“ an, was sich davon unterscheidet, dass ein Benutzer mit dem Alter 0 gefunden würde (was ein gültiges Alter für ein Neugeborenes wäre).

3.6.5) None vs. leere Werte

Es ist wichtig, None von leeren Werten zu unterscheiden:

# none_vs_empty.py
# These are all different
nothing = None
zero = 0
empty_string = ""
# Note: We'll learn about lists in Chapter 13
# empty_list = []
 
print(nothing is None)       # Output: True
print(zero is None)          # Output: False
print(empty_string is None)  # Output: False
 
# None means "no value"
# 0 means "the number zero"
# "" means "text with no characters"

Jeder dieser Werte repräsentiert ein anderes Konzept:

• None: das Fehlen eines Werts
• 0: einen konkreten numerischen Wert (Null)
• "": einen String, der existiert, aber keine Zeichen enthält

Dieses Verständnis hilft Ihnen, klarere und korrektere Programme zu schreiben.

3.7) Grundlegende Typumwandlung mit int(), float() und str()

3.7.1) Warum Typumwandlung notwendig ist

Wie wir gesehen haben, hat Python strenge Regeln dafür, welche Operationen mit welchen Typen funktionieren. Sie können keine Zahl und einen String addieren, keinen String mit einem Float multiplizieren oder mathematische Operationen auf Text anwenden. Wenn Sie einen Wert als anderen Typ verwenden möchten, müssen Sie ihn explizit umwandeln.

Typumwandlung (auch Type Casting genannt) ist der Prozess, einen Wert von einem Typ in einen anderen zu ändern. Python stellt für die gängigsten Umwandlungen eingebaute Funktionen bereit:

• int(): Umwandlung in Integer
• float(): Umwandlung in Gleitkommazahl
• str(): Umwandlung in String

Sehen wir uns jede dieser Funktionen genauer an.

3.7.2) Umwandlung in Integer mit int()

Die Funktion int() wandelt einen Wert in einen Integer um. Hier sind die wichtigsten Anwendungsfälle:

Floats in Integers umwandeln:

# float_to_int.py
# int() truncates (cuts off) the decimal part
x = int(3.14)
y = int(3.99)
z = int(-2.7)
 
print(x)  # Output: 3 (not 4—it doesn't round!)
print(y)  # Output: 3 (not 4—it truncates!)
print(z)  # Output: -2 (truncates toward zero)

Wichtig: int() rundet nicht – es entfernt einfach den Dezimalteil (schneidet in Richtung Null ab). Das führt bei Einsteigern oft zu Verwirrung, die erwarten, dass int(3.9) den Wert 4 liefert.

Strings in Integers umwandeln:

Dies ist extrem häufig, wenn Sie mit Benutzereingaben arbeiten:

# string_to_int.py
# Convert string containing a number
age_str = "25"
age_int = int(age_str)
 
print(age_str, type(age_str))  # Output: 25 <class 'str'>
print(age_int, type(age_int))  # Output: 25 <class 'int'>
 
# Now we can do math with it
next_year = age_int + 1
print("Next year:", next_year)  # Output: Next year: 26
 
# Practical example with input()
user_age = int(input("Enter your age: "))
print("In 10 years, you'll be", user_age + 10)

Was passiert bei ungültigen Umwandlungen?

Wenn Sie versuchen, einen String zu konvertieren, der keinen gültigen Integer darstellt, wirft Python einen ValueError:

# invalid_int_conversion.py
# These work
print(int("123"))    # Output: 123
print(int("-456"))   # Output: -456
print(int("  789 ")) # Output: 789 (whitespace is ignored)
 
# These don't work
# print(int("12.5"))   # Error: ValueError: invalid literal for int()
# print(int("hello"))  # Error: ValueError: invalid literal for int()
# print(int("12 34"))  # Error: ValueError: invalid literal for int()

Wir werden in Kapitel 27 lernen, wie man solche Fehler elegant behandelt, wenn wir die Ausnahmebehandlung besprechen. Für den Moment sollten Sie wissen, dass Strings einen gültigen Integer darstellen müssen, bevor Sie sie konvertieren.

Booleans in Integers umwandeln:

Booleans können in Integers umgewandelt werden, wobei True zu 1 und False zu 0 wird:

# bool_to_int.py
print(int(True))   # Output: 1
print(int(False))  # Output: 0
 
# This is sometimes useful in calculations
is_premium = True
is_student = False
 
# Calculate discount (10% for premium, 5% for students)
discount = int(is_premium) * 0.10 + int(is_student) * 0.05
print("Discount:", discount)  # Output: Discount: 0.1

Die direkte Verwendung von Booleans in Berechnungen wird jedoch im Allgemeinen nicht empfohlen, weil sie den Code weniger lesbar macht. Wir werden dies in Kapitel 7 genauer diskutieren.

3.7.3) Umwandlung in Float mit float()

Die Funktion float() wandelt einen Wert in eine Gleitkommazahl um:

Integers in Floats umwandeln:

# int_to_float.py
x = float(42)
y = float(-17)
z = float(0)
 
print(x, type(x))  # Output: 42.0 <class 'float'>
print(y, type(y))  # Output: -17.0 <class 'float'>
print(z, type(z))  # Output: 0.0 <class 'float'>

Strings in Floats umwandeln:

# string_to_float.py
# Convert string containing decimal number
price_str = "19.99"
price_float = float(price_str)
 
print(price_str, type(price_str))    # Output: 19.99 <class 'str'>
print(price_float, type(price_float))  # Output: 19.99 <class 'float'>
 
# Strings without decimal points work too
x = float("42")
print(x, type(x))  # Output: 42.0 <class 'float'>
 
# Scientific notation strings work
big = float("1.5e10")
print(big)  # Output: 15000000000.0

Ungültige Umwandlungen:

Wie int() löst auch float() bei ungültigen Strings einen ValueError aus:

# invalid_float_conversion.py
# These work
print(float("3.14"))      # Output: 3.14
print(float("  2.5  "))   # Output: 2.5 (whitespace ignored)
print(float("-0.5"))      # Output: -0.5
print(float("inf"))       # Output: inf (infinity)
 
# These don't work
# print(float("hello"))   # Error: ValueError
# print(float("1.2.3"))   # Error: ValueError

Booleans in Floats umwandeln:

# bool_to_float.py
print(float(True))   # Output: 1.0
print(float(False))  # Output: 0.0

3.7.4) Umwandlung in String mit str()

Die Funktion str() wandelt jeden Wert in seine String-Darstellung um:

Zahlen in Strings umwandeln:

# number_to_string.py
# Convert integer
age = 25
age_str = str(age)
print(age_str, type(age_str))  # Output: 25 <class 'str'>
 
# Convert float
price = 19.99
price_str = str(price)
print(price_str, type(price_str))  # Output: 19.99 <class 'str'>
 
# Now we can concatenate with other strings
message = "The price is $" + price_str
print(message)  # Output: The price is $19.99

Dies ist besonders nützlich, wenn Sie Meldungen zusammenbauen:

# building_messages.py
name = "Alice"
age = 25
height = 5.6
 
# Without str(), this would cause an error
# message = "Name: " + name + ", Age: " + age  # Error!
 
# With str(), it works
message = "Name: " + name + ", Age: " + str(age) + ", Height: " + str(height)
print(message)  # Output: Name: Alice, Age: 25, Height: 5.6

Booleans in Strings umwandeln:

# bool_to_string.py
is_valid = True
is_error = False
 
print(str(is_valid))  # Output: True
print(str(is_error))  # Output: False
 
# Useful in messages
status = "Status: " + str(is_valid)
print(status)  # Output: Status: True

None in String umwandeln:

# none_to_string.py
value = None
value_str = str(value)
print(value_str)        # Output: None
print(type(value_str))  # Output: <class 'str'>
 
# The string "None" is different from the value None
print(value is None)      # Output: True
print(value_str is None)  # Output: False
print(value_str == "None")  # Output: True

3.7.5) Umwandlungsmuster in der Praxis

Hier ein umfassendes Beispiel, das gängige Umwandlungsmuster zeigt:

# conversion_patterns.py
# Get user input (always strings)
name = input("Enter your name: ")
age_str = input("Enter your age: ")
height_str = input("Enter your height in feet: ")
 
# Convert to appropriate types
age = int(age_str)
height = float(height_str)
 
# Perform calculations
age_in_months = age * 12
height_in_inches = height * 12
 
# Convert back to strings for output
print("Hello, " + name + "!")
print("You are " + str(age_in_months) + " months old.")
print("Your height is " + str(height_in_inches) + " inches.")
 
# Alternative: use multiple arguments to print() (no conversion needed)
print("Hello,", name + "!")
print("You are", age_in_months, "months old.")
print("Your height is", height_in_inches, "inches.")
 
# When user enters "Alice", "25", and "5.5":
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.

Beachten Sie, dass print() mit mehreren Argumenten (durch Kommata getrennt) Werte automatisch in Strings umwandelt und Leerzeichen dazwischen einfügt. Das ist oft bequemer als manuelle Typumwandlung und Konkatenation.

3.7.6) Diagramm der Umwandlungswege

Hier eine visuelle Darstellung gängiger Typumwandlungen:

Wichtige Punkte zu Umwandlungen:

• int → float: Immer sicher, fügt .0 hinzu
• float → int: Schneidet den Dezimalteil ab (rundet nicht)
• Beliebiger Typ → str: Immer sicher, erzeugt eine Textdarstellung
• str → int/float: Funktioniert nur, wenn der String eine gültige Zahl darstellt
• bool → int/float: True wird zu 1/1.0, False zu 0/0.0

3.7.7) Häufige Fehler bei der Typumwandlung

Hier einige typische Fehler, die Einsteiger bei der Typumwandlung machen:

Fehler 1: Vergessen, Benutzereingaben zu konvertieren

# conversion_mistake1.py
# Wrong: trying to do math with string
age = input("Enter your age: ")
# next_year = age + 1  # Error: TypeError
 
# Right: convert first
age = int(input("Enter your age: "))
next_year = age + 1
print("Next year:", next_year)

Fehler 2: Umwandeln, wenn es nicht nötig ist

# conversion_mistake2.py
# Unnecessary: print() handles conversion automatically
age = 25
print("Age:", age)  # This works fine
 
# No need for:
print("Age:", str(age))  # Unnecessary str() conversion

Fehler 3: Versuch, ungültige Strings zu konvertieren

# conversion_mistake3.py
# This will crash if user enters non-numeric input
# age = int(input("Enter your age: "))  # Crashes on "twenty"
 
# We'll learn to handle this safely in Chapter 27

Fehler 4: Erwarten, dass int() rundet

# conversion_mistake4.py
# Wrong expectation: int() truncates, doesn't round
x = int(3.7)
print(x)  # Output: 3 (not 4!)
 
# If you want rounding, use round()
x = round(3.7)
print(x)  # Output: 4

3.8) String-Darstellungen mit str() und repr() erhalten

3.8.1) Der Unterschied zwischen str() und repr()

Python bietet zwei Möglichkeiten, eine String-Darstellung eines Objekts zu erhalten: str() und repr(). Auch wenn sie ähnlich erscheinen, haben sie unterschiedliche Zwecke:

• str(): Erzeugt eine „schöne“, für Menschen gut lesbare Darstellung
• repr(): Erzeugt eine „offizielle“, eindeutige Darstellung für Entwickler

Für einfache Typen wie Zahlen sind beide oft identisch, für andere Typen können sie sich deutlich unterscheiden:

# str_vs_repr.py
# For numbers, they're usually the same
x = 42
print(str(x))   # Output: 42
print(repr(x))  # Output: 42
 
# For strings, they differ
text = "Hello"
print(str(text))   # Output: Hello
print(repr(text))  # Output: 'Hello' (includes quotes!)
 
# For strings with special characters, repr() shows escape sequences
message = "Hello\nWorld"
print(str(message))   # Output: Hello
                      #         World (newline is interpreted)
print(repr(message))  # Output: 'Hello\nWorld' (shows the \n literally)

3.8.2) Wann str() verwenden?

Verwenden Sie str(), wenn Sie eine lesbare Darstellung für Endbenutzer erzeugen möchten:

# using_str.py
price = 19.99
quantity = 3
 
# Create user-friendly messages
message = "Total: $" + str(price * quantity)
print(message)  # Output: Total: $59.97
 
# str() is what print() uses automatically
print("Total: $", price * quantity)  # Output: Total: $ 59.97

Die Funktion str() ist darauf ausgelegt, Ausgaben zu erzeugen, die für Menschen sinnvoll erscheinen, auch wenn dabei technische Präzision verloren gehen kann. Wenn Sie print() aufrufen, verwendet Python intern automatisch str() auf den übergebenen Werten.

3.8.3) Wann repr() verwenden?

Verwenden Sie repr(), wenn Sie eine eindeutige Darstellung benötigen, typischerweise zum Debuggen:

# using_repr.py
# Debugging: see exactly what's in a variable
text = "Hello\nWorld"
print("Debug info:", repr(text))  # Output: Debug info: 'Hello\nWorld'
 
# Compare two similar-looking strings
str1 = "42"
str2 = "42 "  # Has trailing space
 
print(str1)       # Output: 42
print(str2)       # Output: 42  (space not obvious)
print(repr(str1)) # Output: '42'
print(repr(str2)) # Output: '42 ' (space is visible!)

Die Funktion repr() ist so konzipiert, dass sie Ihnen genau zeigt, was Python „sieht“, einschließlich Details, die in normaler Ausgabe nicht sichtbar sind. Das macht sie beim Debuggen sehr wertvoll.

3.8.4) Das Ziel von repr(): rekonstruierbare Darstellungen

Idealerweise sollte repr() einen String erzeugen, der – wenn Sie ihn an den Python-Interpreter übergeben – das ursprüngliche Objekt wiederherstellen könnte. Für Basistypen funktioniert das:

# repr_recreate.py
# For numbers
x = 42
x_repr = repr(x)
print(x_repr)  # Output: 42
 
# You could use this to recreate x
x_recreated = eval(x_repr)  # eval() evaluates a string as Python code
print(x_recreated)  # Output: 42
 
# For strings
text = "Hello"
text_repr = repr(text)
print(text_repr)  # Output: 'Hello'
 
# This could recreate the string
text_recreated = eval(text_repr)
print(text_recreated)  # Output: Hello

Wichtige Anmerkung: Die Funktion eval() wertet einen String als Python-Code aus. Wir erwähnen sie hier, um den Zweck von repr() zu erklären, aber verwenden Sie eval() niemals mit untrusted input – es ist ein Sicherheitsrisiko. Wir werden sicherere Alternativen in späteren Kapiteln besprechen.

3.8.5) Praktische Beispiele für str() und repr()

Beispiel 1: Debuggen von String-Problemen

# debugging_strings.py
# User input might have unexpected whitespace
user_input = "  Alice  "
 
print("User entered:", user_input)         # Output: User entered:   Alice  
print("Debug view:", repr(user_input))     # Output: Debug view: '  Alice  '
 
# Now the extra spaces are obvious!
cleaned = user_input.strip()  # Remove leading/trailing whitespace
print("Cleaned:", repr(cleaned))  # Output: Cleaned: 'Alice'

Beispiel 2: Unterschiedliche Typen vergleichen

# comparing_types.py
# These look similar but are different
num = 42
text = "42"
 
print("Number:", num)       # Output: Number: 42
print("Text:", text)        # Output: Text: 42
 
print("Number repr:", repr(num))   # Output: Number repr: 42
print("Text repr:", repr(text))    # Output: Text repr: '42'
 
# repr() makes the difference clear
print("Are they equal?", num == text)  # Output: Are they equal? False

3.8.6) str() und repr() mit anderen Typen

Sehen wir uns an, wie str() und repr() mit den in diesem Kapitel behandelten Typen funktionieren:

# str_repr_types.py
# Integers
x = 42
print("int str:", str(x))    # Output: int str: 42
print("int repr:", repr(x))  # Output: int repr: 42
 
# Floats
y = 3.14159
print("float str:", str(y))   # Output: float str: 3.14159
print("float repr:", repr(y)) # Output: float repr: 3.14159
 
# Booleans
b = True
print("bool str:", str(b))   # Output: bool str: True
print("bool repr:", repr(b)) # Output: bool repr: True
 
# None
n = None
print("None str:", str(n))   # Output: None str: None
print("None repr:", repr(n)) # Output: None repr: None
 
# Strings (where they differ most)
s = "Hello\nWorld"
print("string str:", str(s))   # Output: string str: Hello
                                #                     World
print("string repr:", repr(s)) # Output: string repr: 'Hello\nWorld'

3.8.7) Wichtige Erkenntnisse

Verwenden Sie str(), wenn:

• Sie Ausgaben für Endbenutzer erzeugen
• Sie benutzerfreundliche Meldungen aufbauen
• Sie Daten für die Anzeige formatieren
• Sie eine lesbare, freundliche Darstellung wünschen

Verwenden Sie repr(), wenn:

• Sie Code debuggen
• Sie technische Informationen loggen
• Sie genau sehen wollen, was in einer Variable steckt
• Sie eine eindeutige Darstellung benötigen

Merken Sie sich:

• print() verwendet intern automatisch str() für seine Argumente
• Für die meisten Basistypen liefern str() und repr() ähnliche Ergebnisse
• Bei Strings zeigt repr() Anführungszeichen und Escape-Sequenzen
• repr() ist darauf ausgelegt, eindeutig und (idealerweise) rekonstruierbar zu sein

Kapitelzusammenfassung

In diesem Kapitel haben Sie die grundlegenden Konzepte von Variablen und Datentypen in Python kennengelernt. Fassen wir die wichtigsten Punkte zusammen:

Variablen:

• Variablen sind Namen, die sich auf Werte im Speicher beziehen
• Sie werden mit einer Zuweisung erstellt: variable_name = value
• Sie können jederzeit neuen Werten zugewiesen werden
• Sie müssen Benennungsregeln folgen und sollten Konventionen einhalten
• Verwenden Sie aussagekräftige Namen, um Code selbsterklärend zu machen

Datentypen:

• Jeder Wert in Python hat einen Typ
• Verwenden Sie type(), um den Typ eines Werts zu prüfen
• Python ist dynamisch typisiert – Variablen können sich auf unterschiedliche Typen beziehen
• Verschiedene Typen unterstützen unterschiedliche Operationen

Die grundlegenden Typen:

• int: Ganzzahlen (positiv, negativ oder null), beliebige Größe
• float: Zahlen mit Dezimalpunkt, können Genauigkeitsgrenzen haben
• str: Text in Anführungszeichen (einfach oder doppelt)
• bool: Logische Werte True oder False
• None: Spezieller Wert, der das Fehlen eines Werts darstellt

Typumwandlung:

• int(): Umwandlung in Integer (schneidet Floats ab, parst Strings)
• float(): Umwandlung in Gleitkommazahl
• str(): Umwandlung in String (funktioniert immer)
• Umwandlungen können bei ungültigen Eingaben fehlschlagen (ValueError)

String-Darstellungen:

• str(): Menschlich lesbare Darstellung für Endbenutzer
• repr(): Eindeutige Darstellung für Entwickler/Debugging
• print() verwendet automatisch str()

Diese Konzepte bilden die Grundlage für alles Weitere in Python. Jedes Programm, das Sie schreiben, wird Variablen zum Speichern von Daten verwenden, und das Verständnis von Datentypen hilft Ihnen vorherzusagen, welche Operationen funktionieren und welche Fehler auftreten könnten.

Im nächsten Kapitel bauen wir auf dieser Grundlage auf und untersuchen, wie man im Detail mit Zahlen arbeitet, einschließlich arithmetischer Operationen, Operatorrangfolge und gängiger numerischer Muster. Sie lernen, wie Sie Berechnungen durchführen, mit mathematischen Funktionen arbeiten und die Besonderheiten der Gleitkommaarithmetik handhaben.