Statische und Klassenmethoden

Teil des Abschnitts Object Oriented Programming der Python-Journey von Coddy — Lektion 39 von 64.

Neben regulären Instanzmethoden können Klassen statische Methoden und Klassenmethoden haben, die unterschiedlichen Zwecken dienen.

Hier ist ein Beispiel für eine statische Methode:

class MathHelper:
    @staticmethod
    def add(a, b):
        return a + b
    
    @staticmethod
    def is_even(number):
        return number % 2 == 0

Statische Methoden benötigen kein self und funktionieren wie reguläre Funktionen. Rufen Sie sie direkt über die Klasse auf:

result = MathHelper.add(5, 3)
print(result)

check = MathHelper.is_even(10)
print(check)

Hier ist ein Beispiel für eine Klassenmethode:

class Person:
    count = 0  # Klassenvariable
    
    def __init__(self, name):
        self.name = name
        Person.count += 1
    
    @classmethod
    def get_count(cls):
        return cls.count
    
    @classmethod
    def create_anonymous(cls):
        return cls("Anonymous")

Klassenmethoden erhalten die Klasse selbst (cls) als ersten Parameter:

person1 = Person("Alice")
person2 = Person("Bob")
print(Person.get_count())  # 2

Verwenden Sie Klassenmethoden als alternative Konstruktoren:

anonymous = Person.create_anonymous()
print(anonymous.name)      # Anonym
print(Person.get_count())  # 3

Vergleichen Sie alle drei Methodentypen in einer Klasse:

class Calculator:
    brand = "Python Calc"
    
    def __init__(self, owner):
        self.owner = owner
    
    # Instanzmethode - benötigt self, greift auf Instanzdaten zu
    def show_owner(self):
        return f"Owned by {self.owner}"
    
    # Klassenmethode - benötigt cls, greift auf Klassendaten zu
    @classmethod
    def get_brand(cls):
        return cls.brand
    
    # Statische Methode - benötigt keines von beiden, nur eine Hilfsfunktion
    @staticmethod
    def multiply(x, y):
        return x * y

calc = Calculator("Alice")
print(calc.show_owner())        # Im Besitz von Alice
print(Calculator.get_brand())   # Python Calc
print(Calculator.multiply(4, 5)) # 20

Ausgabe:

8
True
2
Anonymous
3
Owned by Alice
Python Calc
20

Sie können Klassen- und statische Methoden auch von Instanzen aus aufrufen:

calc = Calculator("Bob")
print(calc.get_brand())      # Python Calc
print(calc.multiply(2, 3))   # 6

Wesentliche Unterschiede:

Instanzmethoden: benötigen self, greifen auf Instanzdaten zu
Klassenmethoden: benötigen cls, greifen auf Klassendaten zu, gut geeignet für alternative Konstruktoren
Statische Methoden: benötigen keines von beidem, lediglich Hilfsfunktionen, die mit der Klasse in Verbindung stehen

Wichtiger Punkt: Verwenden Sie @staticmethod für Hilfsfunktionen, die logisch zur Klasse gehören, aber keine Klassen- oder Instanzdaten benötigen. Verwenden Sie @classmethod, wenn Sie Zugriff auf die Klasse selbst benötigen, wie zum Beispiel für alternative Konstruktoren oder den Zugriff auf Klassenvariablen.

Aufgabe

Einfach

In dieser Herausforderung implementieren Sie eine Temperature-Klasse mit spezifischer Funktionalität und nutzen dabei ein umfassendes Test-Framework.

Sie müssen nur die Datei temperature.py bearbeiten und dabei den TODO-Kommentaren folgen, die Sie durch die Implementierung führen. Die Klasse sollte Folgendes enthalten:

Eine Klassenvariable zur Verfolgung von Temperaturmesswerten
Eine statische Methode zur Temperaturumrechnung
Klassenmethoden zum Hinzufügen von Messwerten und zur Berechnung von Durchschnittswerten

Spickzettel

Klassen können drei Arten von Methoden haben: Instanzmethoden, statische Methoden und Klassenmethoden.

Statische Methoden verwenden den @staticmethod-Dekorator, benötigen kein self und funktionieren wie reguläre Funktionen:

class MathHelper:
    @staticmethod
    def add(a, b):
        return a + b

# Direkt von der Klasse aufrufen
result = MathHelper.add(5, 3)

Klassenmethoden verwenden den @classmethod-Dekorator und erhalten die Klasse (cls) als ersten Parameter:

class Person:
    count = 0
    
    def __init__(self, name):
        self.name = name
        Person.count += 1
    
    @classmethod
    def get_count(cls):
        return cls.count
    
    @classmethod
    def create_anonymous(cls):
        return cls("Anonymous")

# Verwendung
print(Person.get_count())
anonymous = Person.create_anonymous()

Wesentliche Unterschiede:

Instanzmethoden: Benötigen self, greifen auf Instanzdaten zu
Klassenmethoden: Benötigen cls, greifen auf Klassendaten zu, gut für alternative Konstruktoren
Statische Methoden: Benötigen beides nicht, nur Hilfsfunktionen, die mit der Klasse in Verbindung stehen

Sowohl Klassen- als auch statische Methoden können von der Klasse oder von Instanzen aufgerufen werden:

Calculator.multiply(4, 5)  # Von der Klasse
calc.multiply(4, 5)        # Von der Instanz

Probier es selbst

from temperature import Temperature

# Testfall-Handler für umfassende Tests
test_case = input()

if test_case == "default_test":
    # Grundlegende Funktionalität testen
    Temperature.celsius_readings = []
    Temperature.add_reading(25)
    Temperature.add_reading(30)
    Temperature.add_reading(27)
    
    print(f"Average reading: {Temperature.average_reading()}")
    print(f"22°C is {Temperature.celsius_to_fahrenheit(22)}°F")

elif test_case == "empty_readings":
    # average_reading ohne Messwerte testen
    Temperature.celsius_readings = []
    print(f"Average reading: {Temperature.average_reading()}")

elif test_case == "single_reading":
    # Mit einem einzelnen Messwert testen
    Temperature.celsius_readings = []
    Temperature.add_reading(100)
    print(f"Average reading: {Temperature.average_reading()}")

elif test_case == "negative_values":
    # Mit negativen Temperaturwerten testen
    Temperature.celsius_readings = []
    Temperature.add_reading(-10)
    Temperature.add_reading(-20)
    Temperature.add_reading(-30)
    print(f"Average reading: {Temperature.average_reading()}")
    print(f"-15°C is {Temperature.celsius_to_fahrenheit(-15)}°F")

elif test_case == "zero_value":
    # Mit einem Messwert von 0°C testen
    print(f"0°C is {Temperature.celsius_to_fahrenheit(0)}°F")

elif test_case == "extreme_values":
    # Mit extremen Temperaturwerten testen
    absolute_zero = -273.15  # Absoluter Nullpunkt in Celsius
    sun_surface = 5500  # Ungefähre Sonnenoberflächentemperatur in Celsius
    
    print(f"{absolute_zero}°C is {Temperature.celsius_to_fahrenheit(absolute_zero)}°F")
    print(f"{sun_surface}°C is {Temperature.celsius_to_fahrenheit(sun_surface)}°F")

elif test_case == "reset_readings":
    # Zurücksetzen der Messwerte testen
    Temperature.celsius_readings = []
    Temperature.add_reading(10)
    Temperature.add_reading(20)
    Temperature.add_reading(30)
    print(f"Average reading before reset: {Temperature.average_reading()}")
    
    Temperature.celsius_readings = []
    print(f"Average reading after reset: {Temperature.average_reading()}")

elif test_case == "decimal_values":
    # Mit Dezimalwerten testen
    Temperature.celsius_readings = []
    Temperature.add_reading(36.5)  # Normale Körpertemperatur
    Temperature.add_reading(37.2)  # Leichtes Fieber
    Temperature.add_reading(36.9)  # Normale Variation
    print(f"Average reading: {Temperature.average_reading()}")

elif test_case == "many_readings":
    # Mit vielen Messwerten testen
    Temperature.celsius_readings = []
    for i in range(1, 101):
        Temperature.add_reading(i)
    print(f"Average reading with 100 values: {Temperature.average_reading()}")