Articles
Introduktion till Python
Magiska metoder i Python

Magiska metoder i Python

Den här artikeln förklarar magiska metoder i Python.

YouTube Video

Magiska metoder i Python

Magiska metoder (specialmetoder) i Python är särskilt namngivna metoder som används för att ge klasser unika beteenden. Till exempel kännetecknas de av att vara omslutna av dubbla understreck (”dunders”), såsom __init__ och __str__. Därför kallas de också för dunder-metoder.

Genom att definiera magiska metoder kan du anpassa standardbeteendet hos klasser. Till exempel kan du genom att definiera __add__ ändra beteendet hos +-operatorn.

Magiska metoder för initiering och strängrepresentation

__init__: Initieringsmetod

__init__-metoden är en konstruktor som automatiskt anropas när en instans skapas.

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__: Mänskligt läsbar strängrepresentation

__str__-metoden returnerar en mänskligt läsbar strängrepresentation. Den anropas av print() och 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-orienterad strängrepresentation

__repr__-metoden returnerar en strängrepresentation för felsökningssyften. Den används av repr() och när den visas 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')

Överlagring av aritmetiska operatorer

__add__: +-operatorn

Genom att använda magiska metoder kan aritmetiska operatorer överlagras. Till exempel möjliggör __add__-metoden överlagring av +-operatorn.

 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)

Andra aritmetiska magiska metoder inkluderar följande:.

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

Anpassning av jämförelseoperatorer

Du kan också överlagra jämförelseoperatorer. Till exempel överlagrar __eq__-metoden likhetsoperatorn.

 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 finns också följande magiska metoder:. Dessa magiska metoder definierar jämförelser såsom likhet och ordning mellan objekt.

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

Magiska metoder för behållartyper

Du kan skapa klasser som beter sig som listor eller ordböcker.

__len__: Returnera antal element

__len__-metoden är en magisk metod som returnerar antalet element.

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__: Indexåtkomst

__getitem__-metoden anropas vid indexåtkomst.

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__ och __delitem__: Skrivning och borttagning

__setitem__ och __delitem__-metoderna anropas när objekt skrivs eller tas bort.

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

Magiska metoder för iteration

För att göra ett objekt itererbart i en for-loop, implementera följande:.

__iter__ och __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-sats)

Genom att definiera __enter__ och __exit__-metoder kan du implementera för- och efterbehandling för with-satsen.

 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)

Anropsbara objekt: __call__

Genom att definiera __call__-metoden kan du göra en instans anropsbar som 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!

Sammanfattning

Magiska metoder i Python är ett kraftfullt sätt att lägga till naturligt och intuitivt beteende i klasser. Varje metod har ett tydligt syfte, och om du implementerar dem korrekt kan du skriva mer flexibel och Pythonisk kod.

Magiska metoder fungerar som ett 'osynligt gränssnitt' som stödjer hur Python-objekt samverkar och beter sig i bakgrunden.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video

Generatorer i Python