Klasser: bättre exempel som visar syftet

[dbosk]

Vissa har svårt att se syftet med klasser.

Case study med Pythons fractions?

[mazen-mardini]

Så här kan man resonera kring varför klasser är användbara.

Man vill gärna gruppera data som hör ihop, till exempel personuppgifter (namn, ålder, kön, osv.)

Ett sätt att göra det på är att använda en lista för varje attribut (namn, åldrar, kön, osv.), därmed kan man för varje person lagra ett element i varje lista. Det som associerar värden med en viss person blir då personens index-nummer i varje lista.

namn = [”Kalle”, ”John”, ”Erika”]
åldrar = [20, 31, 50]
kön = [”man”, ”man”, ”kvinna”]

skriv_ut_index = 1
print(f”{namn[skriv_ut_index]}s ålder är {åldrar[skriv_ut_index]}.”)

Problemet med detta är att datan ligger utspritt, man behöver tre olika listor för att lagra information om personer. Det vill säga varje funktion som behöver arbeta med flera personers data behöver få tillgång till tre (eller fler) listor. Antalet attribut kan t.o.m. växa i framtiden vilket gör att dessa funktioner också måste anpassas.

Ett mer organiserat sätt hade varit att samla ihop datan. Man skulle kunna ha en lista med listor, där varje inre lista representerar en person.

personer = [
[”Kalle”, 20, ”man”],
[”John”, 31, ”man”],
[”Erika”, 50, ”kvinna”]
]

skriv_ut_index = 1
print(f”{personer[skriv_ut_index][0]}s ålder är {personer[skriv_ut_index][1]}.”)

Nu är varje person representerad som en lista, denna lista kan skickas runt till programmets funktioner oavsett hur många attribut det finns i den. Men problemet nu är att vi har förlorat attributens namn! Vi vill gärna på ett tydligt sätt referera till attributen, men nu kan vi bara använda index-nummer.

Detta kan lösas genom att man använder uppslagslistor.

personer = [
{”namn”: ”Kalle”, ”ålder”: 20, ”kön”: ”man”},
{”namn”: ”John”, ”ålder”:  31, ”kön”: ”man”},
{”namn”: ”Erika”, ”ålder”:  50, ”kön”: ”kvinna”}
]

skriv_ut_index = 1
print(f”{personer[skriv_ut_index][”namn”]}s ålder är {personer[skriv_ut_index][”ålder”]}.”)

Problemet här är att även om vi har lyckats gruppera våra attribut, och namnge dem så har vi förlorat prestanda genom att använda uppslagslistor. Tyvärr så presterar inte uppslagslistor lika bra som listor när det gäller att komma åt ett specifikt attribut. I allmänhet har dessa datastrukturer olika för- och nackdelar när det gäller prestanda, men för det syfte vi använder de till så blir det snabbare att använda listor.

Lösningen? Klasser! Det ger oss ett nytt sätt att lagra samma information på. Uppslagslistor är normalt sätt inte optimerade till att bli skapade i ett stort antal och samtidigt lagra väldigt lite information (3 element). Med klasser å andra sidan kan vi skapa objekt som innehåller våra namngivna attribut men samtidigt vara optimerade till detta syfte.

class Person:
    def __init__(self, namn, ålder, kön):
        self.namn = namn
        self.ålder = ålder
        self.kön = kön

personer = [
Person(”Kalle”, 20, ”man”),
Person(”John”, 31, ”man”),
Person(”Erika”, 50, ”kvinna”)
]

skriv_ut_index = 1
print(f”{personer[skriv_ut_index].namn}s ålder är {personer[skriv_ut_index].ålder}.”)

Sen kan man förklara syntaxen…

Jag tycker iaf att det är ett bra svar till när studenter använder listor för detta syfte, det understryker bristerna i den metodiken och samtidigt ger ett resonemang kring varför klasser är användbara.

Har ni feedback/kritik så är det uppskattat förstås! :)