Articles
Introduktion til Python
Magiske metoder i Python

Magiske metoder i Python

Denne artikel forklarer magiske metoder i Python.

YouTube Video

Magiske metoder i Python

Magiske metoder (specielle metoder) i Python er særligt navngivne metoder, der bruges til at give klasser unikke egenskaber. De kendetegnes f.eks. ved at være omsluttet af dobbelte underscores (dunders), som __init__ og __str__. Derfor kaldes de også dunder-metoder.

Ved at definere magiske metoder kan du tilpasse klassers standardadfærd. For eksempel tillader definitionen af __add__, at du kan ændre opførslen af +-operatoren.

Magiske metoder til initialisering og strengrepræsentation

__init__: Initialiseringsmetode

__init__-metoden er en konstruktør, der automatisk kaldes, når en instans oprettes.

1class Person:
2    def __init__(self, name, age):
3        self.name = name
4        self.age = age
5
6person = Person("Alice", 30)
7print(person.name)  # Alice

__str__: Menneskeligt læsbar strengrepræsentation

__str__-metoden returnerer en menneskeligt læsbar strengrepræsentation. Den kaldes af print() og str().

1class Person:
2    def __init__(self, name):
3        self.name = name
4
5    def __str__(self):
6        return f"Person: {self.name}"
7
8person = Person("Bob")
9print(person)  # Person: Bob

__repr__: Debug-orienteret strengrepræsentation

__repr__-metoden returnerer en strengrepræsentation til debugging-formål. Den bruges af repr() og når der vises i fortolkeren.

1class Person:
2    def __init__(self, name):
3        self.name = name
4
5    def __repr__(self):
6        return f"Person(name={self.name!r})"
7
8person = Person("Eve")
9print(repr(person))  # Person(name='Eve')

Overbelastning af aritmetiske operatorer

__add__: +-operatoren

Ved at bruge magiske metoder kan aritmetiske operatorer overbelastes. For eksempel kan __add__-metoden overbelaste +-operatoren.

 1class Vector:
 2    def __init__(self, x, y):
 3        self.x = x
 4        self.y = y
 5
 6    def __add__(self, other):
 7        return Vector(self.x + other.x, self.y + other.y)
 8
 9    def __repr__(self):
10        return f"Vector({self.x}, {self.y})"
11
12    # Other arithmetic magic methods:
13    # def __sub__(self, other):       # Subtraction (-)
14    # def __mul__(self, other):       # Multiplication (*)
15    # def __truediv__(self, other):   # True division (/)
16    # def __floordiv__(self, other):  # Floor division (//)
17    # def __mod__(self, other):       # Modulo (%)
18    # def __pow__(self, other):       # Exponentiation (**)
19
20v1 = Vector(1, 2)
21v2 = Vector(3, 4)
22print(v1 + v2)  # Vector(4, 6)

Andre aritmetiske magiske metoder omfatter følgende:.

Metode Operator
__add__ +
__sub__ -
__mul__ *
__truediv__ /
__floordiv__ //
__mod__ %
__pow__ **

Tilpasning af sammenligningsoperatorer

Du kan også overbelaste sammenligningsoperatorer. For eksempel overbelaster __eq__-metoden lighedsoperatoren.

 1class Box:
 2    def __init__(self, volume):
 3        self.volume = volume
 4
 5    def __eq__(self, other):
 6        return self.volume == other.volume
 7
 8    def __lt__(self, other):
 9        return self.volume < other.volume
10
11    # Comparison magic methods:
12    # def __eq__(self, other):  # Equal to (==)
13    # def __ne__(self, other):  # Not equal to (!=)
14    # def __lt__(self, other):  # Less than (<)
15    # def __le__(self, other):  # Less than or equal to (<=)
16    # def __gt__(self, other):  # Greater than (>)
17    # def __ge__(self, other):  # Greater than or equal to (>=)
18
19b1 = Box(100)
20b2 = Box(200)
21
22print(b1 == b2)  # False
23print(b1 < b2)   # True

Der er også følgende magiske metoder:. Disse magiske metoder definerer sammenligninger som lighed og rækkefølge mellem objekter.

Operator Magisk metode
== __eq__
!= __ne__
< __lt__
<= __le__
> __gt__
>= __ge__

Magiske metoder for containertyper

Du kan oprette klasser, der opfører sig som lister eller ordbøger.

__len__: Hentning af antal elementer

__len__-metoden er en magisk metode, der returnerer antallet af elementer.

1class Basket:
2    def __init__(self, items):
3        self.items = items
4
5    def __len__(self):
6        return len(self.items)
7
8basket = Basket(["apple", "banana"])
9print(len(basket))  # 2

__getitem__: Indeksadgang

__getitem__-metoden kaldes ved indeksadgang.

1class Basket:
2    def __init__(self, items):
3        self.items = items
4
5    def __getitem__(self, index):
6        return self.items[index]
7
8basket = Basket(["apple", "banana"])
9print(basket[1])  # banana

__setitem__ og __delitem__: Skrivning og sletning

__setitem__- og __delitem__-metoderne kaldes ved skrivning eller sletning af elementer.

 1class Basket:
 2    def __init__(self, items):
 3        self.items = items
 4
 5    def __setitem__(self, index, value):
 6        self.items[index] = value
 7
 8    def __delitem__(self, index):
 9        del self.items[index]
10
11basket = Basket(["apple", "banana"])
12basket[1] = "grape"
13del basket[0]
14print(basket.items)  # ['grape']

Magiske metoder til iteration

For at gøre et objekt itererbart i en for-løkke, skal du implementere følgende:.

__iter__ og __next__ 

 1class Counter:
 2    def __init__(self, limit):
 3        self.limit = limit
 4        self.current = 0
 5
 6    def __iter__(self):
 7        return self
 8
 9    def __next__(self):
10        if self.current >= self.limit:
11            raise StopIteration
12        self.current += 1
13        return self.current
14
15for num in Counter(3):
16    print(num)
17# Output:
18# 1
19# 2
20# 3

Kontextmanager (with-sætning)

Ved at definere metoderne __enter__ og __exit__ kan du implementere for- og efterbehandling til with-sætningen.

 1class FileOpener:
 2    def __init__(self, filename):
 3        self.filename = filename
 4
 5    def __enter__(self):
 6        self.file = open(self.filename, 'r')
 7        return self.file
 8
 9    def __exit__(self, exc_type, exc_val, exc_tb):
10        self.file.close()
11
12with FileOpener("example.txt") as f:
13    content = f.read()
14    print(content)

Kald-bare objekter: __call__

Ved at definere __call__-metoden, kan du gøre en instans kald-bar ligesom en funktion.

1class Greeter:
2    def __init__(self, greeting):
3        self.greeting = greeting
4
5    def __call__(self, name):
6        return f"{self.greeting}, {name}!"
7
8hello = Greeter("Hello")
9print(hello("Alice"))  # Hello, Alice!

Sammendrag

Magiske metoder i Python er en kraftfuld måde at tilføje naturlig og intuitiv adfærd til klasser. Hver metode har et klart formål, og korrekt implementering gør det muligt at skrive mere fleksibel og pythonisk kode.

Magiske metoder fungerer som et 'usynligt interface', der understøtter, hvordan Python-objekter interagerer og opfører sig bag kulisserne.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video

Generatorer i Python