Articles
Introduksjon til Python
Magiske metoder i Python

Magiske metoder i Python

Denne artikkelen forklarer magiske metoder i Python.

YouTube Video

Magiske metoder i Python

Magiske metoder (spesielle metoder) i Python er spesielt navngitte metoder som brukes for å gi klasser unike egenskaper. For eksempel er de kjennetegnet ved at de er omsluttet av doble understreker (dunders), slik som __init__ og __str__. Derfor kalles de også dunder-metoder.

Ved å definere magiske metoder kan du tilpasse standardoppførselen til klasser. For eksempel gjør det å definere __add__ det mulig å endre oppførselen til +-operatoren.

Magiske metoder for initialisering og strengrepresentasjon

__init__: Initialiseringsmetode

__init__-metoden er en konstruktør som automatisk kalles når en instans opprettes.

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__: Lesbar strengrepresentasjon for mennesker

__str__-metoden returnerer en menneskelesbar strengrepresentasjon. Den kalles av 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__: Strengrepresentasjon for debugging

__repr__-metoden returnerer en strengrepresentasjon for feilsøkingsformål. Den brukes av repr() og når objektet vises i tolken.

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')

Overlasting av aritmetiske operatorer

__add__: +-operator

Ved å bruke magiske metoder kan aritmetiske operatorer overlastes. For eksempel gjør __add__-metoden det mulig å 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 inkluderer følgende:.

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

Tilpassing av sammenligningsoperatorer

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

 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

Det finnes også følgende magiske metoder:. Disse magiske metodene definerer sammenligninger som likhet og rekkefølge mellom objekter.

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

Magiske metoder for konteiner-typer

Du kan lage klasser som oppfører seg som lister eller ordbøker.

__len__: Hente antall elementer

__len__-metoden er en magisk metode som returnerer antall 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__: Tilgang via indeks

__getitem__-metoden kalles ved bruk av indekstilgang.

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__: Skriving og sletting

__setitem__- og __delitem__-metodene kalles når du skriver eller fjerner 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 for iterasjon

For å gjøre et objekt itererbart i en for-løkke, implementer 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

Kontekstbehandler (with-setning)

Ved å definere __enter__- og __exit__-metoder kan du implementere for- og etterbehandling for with-setningen.

 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)

Kallbare objekter: __call__

Ved å definere __call__-metoden kan du gjøre en instans kallbar som en funksjon.

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 kraftig måte å legge til naturlig og intuitiv oppførsel til klasser på. Hver metode har et tydelig formål, og riktig implementasjon gjør det mulig å skrive mer fleksibel og pythonisk kode.

Magiske metoder fungerer som et 'usynlig grensesnitt' som støtter hvordan Python-objekter interagerer og oppfører seg i bakgrunnen.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video

Generatorer i Python