Python Crash Course

Kapitel 9

Klassen

Objektorientierte Programmierung

Was sind Klassen?

• Blaupausen für Objekte
• Bündeln Daten (Attribute) und Verhalten (Methoden)
• Ermöglichen Wiederverwendung und Organisation
• Grundlage der objektorientierten Programmierung

class Dog:
    """A simple attempt to model a dog."""
    
    def __init__(self, name, age):
        """Initialize name and age attributes."""
        self.name = name
        self.age = age
    
    def sit(self):
        """Simulate a dog sitting in response to a command."""
        print(f"{self.name} is now sitting.")
    
    def roll_over(self):
        """Simulate rolling over in response to a command."""
        print(f"{self.name} rolled over!")

Instanzen erstellen und verwenden

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def sit(self):
        print(f"{self.name} is now sitting.")
    
    def roll_over(self):
        print(f"{self.name} rolled over!")

# Instanzen erstellen
my_dog = Dog('Willie', 6)
your_dog = Dog('Lucy', 3)

# Attribute zugreifen
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")

# Methoden aufrufen
my_dog.sit()
your_dog.roll_over()

Attribute ändern

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    
    def get_descriptive_name(self):
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    
    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")
    
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")
    
    def increment_odometer(self, miles):
        self.odometer_reading += miles

my_car = Car('audi', 'a4', 2019)
print(my_car.get_descriptive_name())

# Attribut direkt ändern
my_car.odometer_reading = 23
my_car.read_odometer()

# Attribut über Methode ändern
my_car.update_odometer(23500)
my_car.read_odometer()

Vererbung

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    
    def get_descriptive_name(self):
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    
    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")

class ElectricCar(Car):
    """Represent aspects of a car, specific to electric vehicles."""
    
    def __init__(self, make, model, year):
        """Initialize attributes of the parent class."""
        super().__init__(make, model, year)
        self.battery_size = 75
    
    def describe_battery(self):
        """Print a statement describing the battery size."""
        print(f"This car has a {self.battery_size}-kWh battery.")

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

Instanzen als Attribute (Teil 1)

class Battery:
    """A simple attempt to model a battery for an electric car."""
    
    def __init__(self, battery_size=75):
        """Initialize the battery's attributes."""
        self.battery_size = battery_size
    
    def describe_battery(self):
        """Print a statement describing the battery size."""
        print(f"This car has a {self.battery_size}-kWh battery.")
    
    def get_range(self):
        """Print a statement about the range this battery provides."""
        if self.battery_size == 75:
            range = 260
        elif self.battery_size == 100:
            range = 315
        
        print(f"This car can go about {range} miles on a full charge.")

Instanzen als Attribute (Teil 2)

class ElectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery = Battery()

# Verwendung
my_tesla = ElectricCar('tesla', 'model s', 2019)
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

Klassen aus Modulen importieren

# car.py
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    
    def get_descriptive_name(self):
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

# my_car.py
from car import Car

my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())

# Alternative Import-Methoden:
from car import Car, ElectricCar
import car
from car import Car as C
from car import *

Python-Standardbibliothek

from random import randint, choice

class Die:
    """A class representing a single die."""
    
    def __init__(self, num_sides=6):
        """Assume a six-sided die."""
        self.num_sides = num_sides
    
    def roll(self):
        """Return a random value between 1 and number of sides."""
        return randint(1, self.num_sides)

# Würfel verwenden
die = Die()
results = []
for roll_num in range(10):
    result = die.roll()
    results.append(result)
print(results)

# Lotterie
possibilities = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd', 'e']
winning_ticket = []
for i in range(4):
    pulled_item = choice(possibilities)
    winning_ticket.append(pulled_item)

print(f"Winning ticket: {winning_ticket}")

Zusammenfassung Kapitel 9

• Klassen: Blaupausen für Objekte
• __init__(): Konstruktor-Methode
• Vererbung: Klassen erweitern
• super(): Parent-Klasse aufrufen
• Komposition: Instanzen als Attribute
• Module: Klassen organisieren

Praktische Tipps

• Klassennamen: PascalCase verwenden
• Methodennamen: snake_case verwenden
• Docstrings: Klassen und Methoden dokumentieren
• Vererbung: Nur bei "ist-ein" Beziehungen

# Gute Klassennamen
class ElectricCar:  # PascalCase
    def get_range(self):  # snake_case
        """Calculate the range of the car."""  # Docstring
        pass

# Vererbung richtig verwenden
class Dog(Animal):  # Dog "ist ein" Animal
    pass