Magic Methods (__str__, __repr__, osv.)

Magiske metoder, også kaldet metoder med dobbelt understregning, er særlige metoder i Python, som gør det muligt for dig at definere, hvordan objekter opfører sig i bestemte situationer.

I denne lektion lærer du at bruge almindelige magiske metoder som __str__, __repr__ og andre.

Magiske metoder er foruddefinerede metoder i Python, som automatisk kaldes, når bestemte handlinger udføres på objekter. De kendes på deres to understregninger, f.eks. __init__ eller __str__.

Metoden __init__ er en konstruktør, der initialiserer et nyt objekt. Den kaldes automatisk, når et objekt oprettes:

# Using the __init__ method to initialize attributes
class Person:
    def __init__(self, name, age):
        self.name = name  # Initialize the name attribute
        self.age = age  # Initialize the age attribute

# Creating an instance of Person
person = Person("Alice", 30)
print(person.name, person.age)  # Outputs: Alice 30

Metoden __str__ definerer et objekts strengrepræsentation, når print() kaldes:

# Defining the __str__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"  # String representation

person = Person("Alice", 30)
print(person)  # Outputs: Name: Alice, Age: 30

Metoden __repr__ angiver en officiel strengrepræsentation af et objekt, som ofte bruges til fejlfinding:

# Defining the __repr__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"  # Debug-friendly representation

person = Person("Alice", 30)
print(repr(person))  # Outputs: Person('Alice', 30)

Du kan bruge magiske metoder til at tilpasse funktionsmåden for operatorer som + eller ==:

# Overloading the + operator with __add__
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)  # Adding two points

    def __str__(self):
        return f"({self.x}, {self.y})"

point1 = Point(1, 2)
point2 = Point(3, 4)
result = point1 + point2  # Calls __add__
print(result)  # Outputs: (4, 6)

Her er nogle almindeligt anvendte magiske metoder:

• __len__: Definerer, hvordan funktionen len() fungerer.
• __getitem__: Gør det muligt at bruge indeksering som med en liste eller ordbog.
• __eq__: Tilpasser lighedssammenligningen ved hjælp af ==.

Du kan bruge __len__ til at definere længden på et brugerdefineret objekt og __getitem__ til at gøre det muligt at indeksere objektet:

# Using __len__ and __getitem__ in a custom class
class CustomList:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)  # Defines the behavior of len()

    def __getitem__(self, index):
        return self.items[index]  # Enables indexing

custom_list = CustomList([1, 2, 3])
print(len(custom_list))  # Outputs: 3
print(custom_list[1])  # Outputs: 2

Her er nogle fejl, du bør undgå:

• At definere en magisk metode uden at følge dens tilsigtede funktionsmåde.
• At overbelaste operatorer unødvendigt.
• At glemme at implementere de nødvendige magiske metoder i brugerdefinerede datatyper.

I denne lektion har du lært:

• Hvad magiske metoder er, og hvorfor de er nyttige.
• Hvordan du bruger almindelige magiske metoder som __init__, __str__ og __repr__.
• Hvordan du overbelaster operatorer ved hjælp af magiske metoder.

Godt klaret! Lad os gå videre til det næste emne.