Python Grundlagen: Eine Einführung in die Programmierung für Anfänger

Python ist eine vielseitige und weit verbreitete Programmiersprache, die für ihre klare Syntax und Lesbarkeit bekannt ist. Dies macht sie zu einer idealen Wahl für Anfänger, da sie in vielen Bereichen eingesetzt wird, von der Webentwicklung bis zur Datenwissenschaft, und somit viele Karrierewege eröffnet. Dieser Artikel führt Sie durch grundlegende Python-Konzepte mit einfachen, leicht verständlichen Code-Beispielen.

Ihr erstes Python-Programm: “Hallo, Welt!”

Beginnen wir mit dem traditionellen "Hallo, Welt!"-Programm. In Python ist dies außergewöhnlich einfach:

print("Hallo, Anfänger!")

Diese einzelne Zeile bewirkt Folgendes:

1. print(): Dies ist eine eingebaute Funktion. Funktionen sind wiederverwendbare Codeblöcke, die bestimmte Aufgaben ausführen. print() zeigt eine Ausgabe für den Benutzer an.
2. ("Hallo, Anfänger!"): Innerhalb der Klammern befindet sich ein String-Literal. Ein String ist eine Folge von Zeichen, die entweder in einfachen ('...') oder doppelten ("...") Anführungszeichen eingeschlossen ist.

Wenn Sie dies ausführen, führt der Python-Interpreter print() aus und zeigt “Hallo, Anfänger!” auf Ihrem Bildschirm an.

Variablen in Python

Variablen sind entscheidend für die Speicherung von Daten. Stellen Sie sich diese als beschriftete Behälter vor. Es ist ratsam, aussagekräftige Namen zu verwenden, mit Kleinbuchstaben zu beginnen und Unterstriche zu verwenden, um Wörter zu trennen (z. B. my_variable, user_age). Hier ist ein Beispiel:

# Werte Variablen zuweisen
message = "Willkommen bei Python!"
number = 10
pi = 3.14159

# Variablenwerte ausgeben
print(message)
print(number)
print(pi)

Erläuterung:

1. message = "Willkommen bei Python!": Eine Variable namens message wird erstellt, die den String “Willkommen bei Python!” speichert.
2. number = 10: Eine Variable namens number speichert die Ganzzahl 10.
3. pi = 3.14159: Eine Variable namens pi speichert die Gleitkommazahl 3.14159.

print() zeigt dann diese Werte an. Python ist dynamisch typisiert: Sie müssen den Typ der Variablen (String, Integer, Float) nicht explizit angeben. Python leitet ihn aus dem zugewiesenen Wert ab.

Benutzerinteraktion in Python

Interaktive Programme benötigen oft Benutzereingaben. So erhalten Sie diese:

# Benutzereingabe erhalten
name = input("Bitte geben Sie Ihren Namen ein: ")

# Personalisierte Begrüßung ausgeben
print("Hallo, " + name + "!")  # String-Verkettung

Erläuterung:

1. name = input("Bitte geben Sie Ihren Namen ein: "): input() pausiert das Programm, wartet darauf, dass der Benutzer etwas eingibt und die Eingabetaste drückt, und speichert die Eingabe als String in name.
2. print("Hallo, " + name + "!"): Dies gibt eine Begrüßung aus. Der +-Operator führt bei Strings eine String-Verkettung durch, d. h. er verbindet sie. Es ist ratsam, beim Verketten zur besseren Lesbarkeit Leerzeichen um das + zu setzen.

Bedingte Logik: if, else und elif

Bedingte Anweisungen ermöglichen es Ihrem Programm, Entscheidungen zu treffen und zu steuern, welche Codeblöcke ausgeführt werden, je nachdem, ob Bedingungen wahr oder falsch sind.

age = int(input("Geben Sie Ihr Alter ein: "))

if age >= 18:
    print("Sie sind wahlberechtigt.")
elif age < 0:
    print("Das ist ein falsches Alter.")
else:
    print("Sie sind noch nicht wahlberechtigt.")

Aufschlüsselung:

1. age = int(input("Geben Sie Ihr Alter ein: ")): Nimmt die Benutzereingabe für das Alter entgegen. int() konvertiert die Eingabe (standardmäßig ein String) in eine Ganzzahl.
2. if age >= 18:: Überprüft, ob age größer oder gleich 18 ist. Wenn dies zutrifft, wird die eingerückte print-Anweisung ausgeführt.
3. elif age < 0:: Wenn die vorherige if-Bedingung falsch ist, wird diese Bedingung geprüft. Wenn sie wahr ist, wird der entsprechende Block ausgeführt. elif steht für “else if” und ermöglicht es, mehrere Bedingungen nacheinander zu prüfen.
4. else:: Wenn keine der if- oder elif-Bedingungen wahr ist, wird der eingerückte Code unter else ausgeführt. Einrückung ist in Python entscheidend; sie definiert Codeblöcke, die mit if, elif und else verbunden sind. Eine konsistente Einrückung (normalerweise 4 Leerzeichen) ist entscheidend dafür, dass Python-Code korrekt funktioniert.

Schleifen: Code wiederholen mit for

Schleifen wiederholen Codeblöcke. Die for-Schleife iteriert über eine Sequenz (z. B. eine Liste oder einen Zahlenbereich).

# Zahlen von 0-4 ausgeben
for i in range(5):
    print(i)

# Listenelemente ausgeben
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

Erläuterung:

1. for i in range(5):: range(5) erzeugt Zahlen von 0 bis (aber nicht einschließlich) 5. Die Schleife iteriert durch diese Sequenz; in jeder Iteration wird die aktuelle Zahl i zugewiesen.
2. for fruit in fruits:: Diese Schleife iteriert durch die fruits-Liste. In jeder Iteration wird das aktuelle Listenelement fruit zugewiesen.

Schleifen: Code wiederholen mit while

Die while-Schleife wird fortgesetzt, solange eine Bedingung wahr ist.

count = 0
while count < 5:
    print(count)
    count += 1  # count inkrementieren

Erläuterung:

1. count = 0: Initialisiert count auf 0.
2. while count < 5:: Die Schleife wird fortgesetzt, solange count kleiner als 5 ist.
3. count += 1: Innerhalb der Schleife wird count in jeder Iteration um 1 erhöht. Dies verhindert eine Endlosschleife (bei der die Bedingung immer wahr bleiben würde).

Funktionen: Wiederverwendbare Codeblöcke

Funktionen sind unerlässlich für die Wiederverwendung von Code, die Organisation und die Lesbarkeit. Anstatt denselben Code mehrmals zu wiederholen, können Sie eine Funktion einmal definieren und sie immer dann aufrufen, wenn Sie diese spezifische Funktionalität benötigen. Definieren Sie Ihre eigenen Funktionen mit def.

# Funktion definieren
def greet(name):
    print("Hallo, " + name + "!")

# Funktion aufrufen
greet("Alice")
greet("Bob")

Kernpunkte:

1. def greet(name):: Definiert eine Funktion namens greet, die einen Parameter namens name entgegennimmt.
2. print("Hallo, " + name + "!"): Der Körper der Funktion – der Code, der ausgeführt wird, wenn die Funktion aufgerufen wird.
3. greet("Alice"): Ruft die greet-Funktion auf und übergibt “Alice” als Argument.

Konzepte kombinieren: Ein einfacher Flächenrechner

Lassen Sie uns Konzepte zu einem etwas komplexeren Programm kombinieren:

def calculate_area(length, width):
    """Berechnet die Fläche eines Rechtecks."""  # Docstring
    area = length * width
    return area

# Dimensionen abrufen
length = float(input("Länge eingeben: "))
width = float(input("Breite eingeben: "))

# Fläche berechnen
rectangle_area = calculate_area(length, width)

# Ergebnis ausgeben
print("Fläche:", rectangle_area)

Erläuterung:

1. def calculate_area(length, width):: Definiert eine Funktion zur Berechnung der Rechteckfläche, die length und width als Parameter entgegennimmt. Der """...""" ist ein Docstring, der die Funktion beschreibt. Docstrings werden für die Dokumentation verwendet und können mit der Funktion help() abgerufen werden.
2. return area: Die Funktion gibt die berechnete Fläche zurück. Die return-Anweisung beendet die Funktion und sendet den Wert zurück an die Stelle, an der die Funktion aufgerufen wurde.
3. Das Programm fragt die Benutzereingabe für Länge und Breite ab und konvertiert sie mit float() in Gleitkommazahlen. Die Verwendung von float() ermöglicht Dezimalwerte, wodurch der Rechner vielseitiger wird.
4. Es ruft calculate_area auf, übergibt die Dimensionen und speichert den zurückgegebenen Wert in rectangle_area.
5. Schließlich wird die Fläche ausgegeben.

Weitere Werkzeuge zur Ablaufsteuerung

Python bietet weitere Werkzeuge zur Steuerung des Programmablaufs.

break, continue und else in Schleifen

• break: Beendet die innerste umschließende for- oder while-Schleife.
• continue: Fährt mit der nächsten Iteration der Schleife fort.
• Schleifen-else-Klausel: Wird in for nach Beendigung der Schleife ausgeführt (es sei denn, break wurde ausgeführt). Wird in while ausgeführt, nachdem die Bedingung falsch geworden ist (es sei denn, break wurde ausgeführt).

#Beispiel für break
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        break  # Schleife beenden, wenn number gleich 3 ist
    print(number)  # Ausgabe: 1 2

#Beispiel für continue
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        continue  # Zur nächsten Iteration springen, wenn number gleich 3 ist
    print(number)  # Ausgabe: 1 2 4 5

#Beispiel für else
for i in range(5):
    print(i)
else:
    print("Schleife beendet") #Wird ausgeführt

for i in range(5):
    if i==3:
        break
    print(i)
else:
    print("Schleife beendet") #Wird nicht ausgeführt

Die match-Anweisung

match vergleicht einen Wert mit Mustern. Es ähnelt Switch-Anweisungen in anderen Sprachen, verfügt aber über eine leistungsfähigere Mustererkennung. Dies ist ab Python 3.10 verfügbar.

def http_error(status):
    match status:
        case 400:
            return "Bad Request"
        case 401 | 403 | 404:  # Mehrere Fälle
            return "Nicht erlaubt"
        case 418:
            return "I'm a teapot"
        case _:  # Standard
            return "Etwas stimmt nicht"

print(http_error(404))
print(http_error(500))

_ ist ein Platzhalter, der alles abgleicht, wenn kein anderer Fall zutrifft.

Datenstrukturen

Python verfügt über integrierte Datenstrukturen zur Organisation von Daten.

• Listen: Geordnete, veränderbare Sequenzen.

my_list = [1, 2, 3, "apple"]
my_list.append("cherry")  # Ein Element am Ende hinzufügen
print(my_list[0])       # Auf ein Element per Index zugreifen (beginnend bei 0)
my_list.remove(2)        # Ein Element anhand des Wertes entfernen
print(my_list)

• Tupel: Geordnete, unveränderliche Sequenzen.

my_tuple = (1, 2, 3, "apple")
# my_tuple[0] = 5  # Fehler (unveränderlich) - Tupel können nach der Erstellung nicht mehr geändert werden
print(my_tuple[1])

• Mengen: Ungeordnete Sammlungen eindeutiger Elemente.

my_set = {1, 2, 3, 3, 4, 5}  # Duplikate werden automatisch entfernt
print(my_set)  # Ausgabe: {1, 2, 3, 4, 5}

• Dictionaries: Schlüssel-Wert-Paare. Schlüssel müssen unveränderlich sein (wie Strings, Zahlen oder Tupel).

my_dict = {"name": "Alice", "age": 30}
print(my_dict["name"])  # Auf einen Wert per Schlüssel zugreifen
my_dict["age"] = 31      # Einen Wert ändern
print(my_dict)

• Listen-Abstraktionen: Prägnante Syntax zum Erstellen von Listen.

squares = [x**2 for x in range(10)]      # Liste der Quadrate
even = [x for x in range(20) if x % 2 == 0]  # Gerade Zahlen
print(squares)
print(even)

Module

Module organisieren Code in wiederverwendbaren Dateien. Verwenden Sie import, um auf Funktionen aus anderen Modulen zuzugreifen.

import math

print(math.sqrt(16))  # Auf die Funktion sqrt aus dem Modul math zugreifen
print(math.pi)        # Auf die Konstante pi zugreifen

from math import sqrt  # Bestimmte Funktion importieren

print(sqrt(25))

from math import *  # Alles importieren (im Allgemeinen vermeiden)

print(pi)

Dies demonstriert die Verwendung des math-Moduls (das mathematische Funktionen bereitstellt). Das Importieren bestimmter Funktionen oder Konstanten kann die Lesbarkeit des Codes verbessern und Namenskonflikte vermeiden. Das Importieren von allem mit * wird in größeren Projekten im Allgemeinen nicht empfohlen.

Funktionen definieren: Fortgeschrittene Techniken

Standardargumentwerte

Funktionen können Standardwerte für Argumente haben.

def greet(name, greeting="Hallo"):
    print(greeting + ", " + name + "!")

greet("Bob")           # Verwendet Standardbegrüßung
greet("Alice", "Hi")  # Überschreibt den Standard

Schlüsselwortargumente

Rufen Sie Funktionen mit der Syntax keyword=value auf.

def describe_pet(animal_type, pet_name):
    print("Ich habe ein(e) " + animal_type + " namens " + pet_name + ".")

describe_pet(pet_name="Harry", animal_type="Hamster")  # Reihenfolge spielt keine Rolle

Beliebige Argumentlisten

Funktionen können eine beliebige Anzahl von Positionsargumenten mit *args akzeptieren.

def make_pizza(*toppings):
    print("Eine Pizza mit:")
    for topping in toppings:
        print("- " + topping)

make_pizza("Pepperoni")
make_pizza("Pilzen", "Käse", "Paprika")

*toppings sammelt alle Positionsargumente in einem Tupel namens toppings.

Beliebige Schlüsselwortargumente

Funktionen können eine beliebige Anzahl von Schlüsselwortargumenten mit **kwargs akzeptieren.

def build_profile(first, last, **kwargs):
    #Kombiniert feste und beliebige Schlüsselwortargumente, um ein Benutzerprofil zu erstellen.
    profile = {'first_name': first, 'last_name': last}
    profile.update(kwargs)  # Aktualisiert das Profil mit Schlüssel-Wert-Paaren aus kwargs.
    return profile

user = build_profile("Albert", "Einstein", location="Princeton", field="physics")
print(user) # Ausgabe: {'first_name': 'Albert', 'last_name': 'Einstein', 'location': 'Princeton', 'field': 'physics'}

**kwargs steht für “keyword arguments” (Schlüsselwortargumente) und ist eine übliche Namenskonvention zum Sammeln zusätzlicher benannter Argumente in einem Dictionary. Dies ermöglicht es Funktionen, flexible Eingaben zu verarbeiten.

Lambda-Ausdrücke

Kleine, anonyme Funktionen, die mit lambda erstellt wurden.

add = lambda x, y: x + y
print(add(5, 3))  # Ausgabe: 8

pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
pairs.sort(key=lambda pair: pair[1]) #sortieren nach dem zweiten Element des Tupels
print(pairs)

Lambda-Funktionen werden oft als Argumente für Funktionen höherer Ordnung verwendet (Funktionen, die andere Funktionen als Argumente entgegennehmen), wie sort in diesem Beispiel.

Klassen

Klassen bieten eine Möglichkeit, Daten (Attribute) und Funktionalität (Methoden), die mit diesen Daten arbeiten, zu bündeln. Es ist eines der Hauptmerkmale der objektorientierten Programmierung, das es Ihnen ermöglicht, Baupläne für Objekte zu erstellen.

class Dog:
    def __init__(self, name, age): #Konstruktor
        self.name = name
        self.age = age

    def bark(self):
        print("Wau!")

my_dog = Dog("Buddy", 3) #Instanz der Klasse
print(my_dog.name)
my_dog.bark()

Erläuterung:

• class Dog:: Definiert eine Klasse namens Dog.
• def __init__(self, name, age):: Dies ist der Konstruktor (oder Initialisierer). Er wird automatisch aufgerufen, wenn Sie ein neues Dog-Objekt erstellen.
  • self: Bezieht sich auf die Instanz der Klasse (das spezifische Dog-Objekt, mit dem Sie arbeiten). Es ist der erste Parameter in allen Methoden innerhalb einer Klasse.
• def bark(self):: Dies ist eine Methode – eine Funktion, die zur Dog-Klasse gehört. Sie kann auf die Daten des Hundes zugreifen (wie self.name, obwohl dies in diesem einfachen Beispiel nicht der Fall ist).
• my_dog = Dog("Buddy", 3) Erstellt eine Instanz der Dog-Klasse mit dem Namen my_dog.

Iteratoren

Ein Iterator ist ein Objekt, das es ermöglicht, alle Elemente einer Sammlung zu durchlaufen, unabhängig von ihrer spezifischen Implementierung.

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))

Generatoren

Generatoren sind eine Art von Iterable, wie Listen oder Tupel. Im Gegensatz zu Listen speichern sie ihren Inhalt nicht im Speicher, sondern generieren Werte bei Bedarf mit dem Schlüsselwort yield. Dies macht sie speichereffizient für große Sequenzen. Dies unterscheidet sie auch von Listenabstraktionen, die die gesamte Liste im Speicher erstellen.

def my_generator():
  yield 1
  yield 2
  yield 3

for value in my_generator():
  print(value)

#Generatorausdruck
squares = (x*x for x in range(10))
print(list(squares))

Diese Grundlagen bieten eine solide Basis für Ihre Python-Reise. Indem Sie mit diesen Konzepten experimentieren und sie kombinieren, können Sie immer anspruchsvollere Programme erstellen. Denken Sie daran, dass Übung und Erkundung der Schlüssel zum Erlernen jeder Programmiersprache sind.