Fler exempel

Exempel 1: klassen Rektangel

Låt oss ta en titt på en klass som modellerar en rektangel i ett tvådimensionellt rum:

class Rektangel:
    def __init__(self, vanster_ovre: tuple, hoger_nedre: tuple):
        self.vanster_ovre = vanster_ovre
        self.hoger_nedre = hoger_nedre
        self.bredd = hoger_nedre[0]-vanster_ovre[0]
        self.hojd = hoger_nedre[1]-vanster_ovre[1]

    def area(self):
        return self.bredd * self.hojd

    def omkrets(self):
        return self.bredd * 2 + self.hojd * 2

    def flytta(self, x_andring: int, y_andring: int):
        horn = self.vanster_ovre
        self.vanster_ovre = (horn[0]+x_andring, horn[1]+y_andring)
        horn = self.hoger_nedre
        self.hoger_nedre = (horn[0]+x_andring, horn[1]+y_andring)

En ny Rektangel skapas med två tuplar som argument. Dessa tuplar innehåller x- och y-koordinaterna för det övre vänstra hörnet och det nedre högra hörnet. Konstruktören beräknar rektangelns höjd och bredd baserat på dessa värden.

Metoderna area och omkrets beräknar rektangelns area och omkrets baserat på höjd och bredd. Metoden flytta flyttar rektangeln med de x- och y-värden som anges som argument.

Rektangeln representeras i ett koordinatsystem där x-koordinaterna ökar från vänster till höger och y-koordinaterna ökar från topp till botten. Detta är ett vanligt sätt att hantera koordinater i programmering eftersom det ofta är enklare och mer naturligt att betrakta datorskärmens övre vänstra hörn som den punkt där x och y är lika med noll.

Följande program testar klassen Rektangel:

rektangel = Rektangel((1, 1), (4, 3))
print(rektangel.vanster_ovre)
print(rektangel.hoger_nedre)
print(rektangel.bredd)
print(rektangel.hojd)
print(rektangel.omkrets())
print(rektangel.area())

rektangel.flytta(3, 3)
print(rektangel.vanster_ovre)
print(rektangel.hoger_nedre)

Skriva ut ett objekt

När du har ett objekt som skapats från en klass som du själv definierat, är standardreaktionen på att anropa instruktionen print med objektet som argument inte särskilt informativt:

rektangel = Rektangel((1, 1), (4, 3))
print(rektangel)

Utskriften borde se ut någorlunda så här:

Vi vill självklart ha mer kontroll över vad som skrivs ut. Det enklaste sättet att göra detta är att lägga till en speciell __str__-metod i klassdefinitionen. Dess syfte är att returnera en ögonblicksbild av objektets tillstånd i strängformat. Om klassdefinitionen innehåller en __str__-metod är det värde som returneras av metoden, det som skrivs ut när instruktionen print körs.

Så låt oss lägga till en __str__-metoddefinition i vår Rektangel-klass:

class Rektangel:

    # Resten av klassen kommer här såsom ovan

    # Metoden returnerar objektets tillstånd i strängformat
    def __str__(self):
        return f"rektangel {self.vanster_ovre} ... {self.hoger_nedre}"

Nu borde print instruktionen producera nånting mer användarvänligt:

rektangel = Rektangel((1, 1), (4, 3))
print(rektangel)

Metoden __str__ används kanske oftare för att formulera en strängrepresentation av objektet med str-funktionen, som i följande program:

rektangel = Rektangel((1, 1), (4, 3))
beskrivning = str(rektangel)
print(beskrivning)

Det finns många fler speciella understrukna metoder som kan definieras för klasser. En metod som liknar __str__-metoden är __repr__-metoden. Dess syfte är att ge en teknisk representation av objektets tillstånd. Vi kommer att stöta på denna metod senare.

Exempel 2: Uppgiftslista

Följande klass Uppgiftslista modellerar en lista med uppgifter:

class Uppgiftslista:
    def __init__(self):
        self.uppgifter = []

    def tillsatt(self, namn: str, prioritet: int):
        self.uppgifter.append((prioritet, namn))

    def hamta_nasta(self):
        self.uppgifter.sort()
        # Metoden pop tar bort och returnerar sista föremålet på listan
        uppgift = self.uppgifter.pop()
        # Returnerar det andra föremålet i tupeln, alltså uppgiftens namn
        return uppgift[1]

    def sammanlagt(self):
        return len(self.uppgifter)

    def rensa_uppgifter(self):
        self.uppgifter = []

Metoden tillagg_uppgift lägger till en ny uppgift på listan. Varje uppgift har också en prioritet, som används för att sortera uppgifterna. Metoden hamta_nasta tar bort och returnerar den uppgift som har högst prioritet i listan. Metoden sammanlagt finns också, som returnerar antalet uppgifter i listan, och slutligen metoden rensa_uppgifter, som rensar uppgiftslistan.

Inom objektet lagras uppgifterna i en lista. Varje uppgift består av en tupel som innehåller uppgiftens prioritet och dess namn. Prioritetsvärdet lagras först, så att den uppgift som har högst prioritet hamnar sist i listan då den sorteras. Därför kan vi sedan helt enkelt använda pop-metoden för att hämta och ta bort det högst prioriterade objektet.

Ta en titt på följande program med uppgiftslistan i handling:

lista = Uppgiftslista()
lista.tillsatt("studier", 50)
lista.tillsatt("motion", 60)
lista.tillsatt("städning", 10)
print(lista.sammanlagt())
print(lista.hamta_nasta())
print(lista.sammanlagt())
lista.tillsatt("dejt", 100)
print(lista.sammanlagt())
print(lista.hamta_nasta())
print(lista.hamta_nasta())
print(lista.sammanlagt())
lista.rensa_uppgifter()
print(lista.sammanlagt())

Vänligen svara på en snabb enkät om veckans material:

Se dina poäng genom att klicka på cirkeln nere till höger av sidan.