Svenska ElektronikForumet

Jag har börjat med python för första gången.
Har kommit så långt att jag kan skapa fina strukturer med data i dict som jag tycker verkar väldigt enkelt och praktiskt.
Men så rekommenderas det att jag borde lagra data i klasser istället. Så jag försöker, men för mig som nybörjare verkar det krångla till det mer än vad det gör nytta.
Tanken var väl att det skulle förenkla att använda klasser?

Mitt problem är att, trots att jag definierat en klass, ändå kan stoppa in vad som helst i den... som om den inte egentligen existerar utan bara är som info till mig själv om vad jag *borde* lägga in.

Exempel:
men jag kan lika väl skriva:
och jag får inte veta att det är fel förrän jag ska köra nån slags funktion som använder något av värdena.
kan jag lägga in en kontroll när jag skapar variabeln, skapa nån slags konstruktor-funktion i klassen Trans?
och kanske även när jag ska ändra innehåll , att det sker nån kotroll redan där och inte senare?

Finns det något LLM/ AI är bra på så är det Python...
Och eftersom forum ÄLSKAR AI genererade svar så kommer här ChatGPT svar på dina frågor

Bra fråga – och du tänker helt rätt
Det här är en klassisk “aha-upplevelse” när man går från `dict` till klasser i Python.

Kort svar:

**Typannoteringar i Python är inte typkontroller.**
De är bara metadata (för dig, IDE:n och externa verktyg). Python är dynamiskt typat, så den stoppar dig inte vid fel typ – förrän koden faktiskt kraschar.

---

## Varför klasser ändå rekommenderas

Skillnaden mellan:

{"konto": 6666, "belopp": -55.50, "text": "Min text"}


och


Trans(6666, -55.50, "Min text")


är inte bara struktur — det är:

* Bättre läsbarhet
* Samlad logik
* Möjlighet till validering
* Möjlighet till metoder
* Bättre stöd från IDE + typkontrollverktyg

Men ja — **utan extra kod är en dataclass nästan lika "lös" som en dict.**

---

# Lösning 1 – Lägg in validering med `__post_init__`

Eftersom du använder `@dataclass` kan du lägga in kontroller direkt när objektet skapas:


from dataclasses import dataclass

@dataclass
class Trans:
konto: int
belopp: float
text: str = ''

def __post_init__(self):
if not isinstance(self.konto, int):
raise TypeError("konto måste vara int")

if not isinstance(self.belopp, (int, float)):
raise TypeError("belopp måste vara float")

if not isinstance(self.text, str):
raise TypeError("text måste vara str")


Nu:


Trans(7777.55, '55.50', 5)


→ ger direkt TypeError

Nu får du felet vid skapandet.

---

# Lösning 2 – Hindra fel vid ändring av värden

Du märkte detta:


trans2.belopp = 'häst'


Ja, Python tillåter det.

För att stoppa det kan du använda @property.

Exempel:


@dataclass
class Trans:
konto: int
_belopp: float
text: str = ''

def __post_init__(self):
self.belopp = self._belopp # triggar setter

@property
def belopp(self):
return self._belopp

@belopp.setter
def belopp(self, value):
if not isinstance(value, (int, float)):
raise TypeError("belopp måste vara float")
self._belopp = float(value)


Nu:


trans = Trans(6666, -55.5)
trans.belopp = "häst"


→ ger TypeError

Nu skyddar klassen sig själv.

---

# Lösning 3 – Använd typkontrollverktyg (rekommenderas!)

Python är dynamiskt typat, men du kan använda:

* **mypy**
* Pyright
* VS Code type checking

Kör:


mypy ditt_program.py


Då får du fel som:


error: Argument 1 to "Trans" has incompatible type "float"; expected "int"


Det är så typannoteringar egentligen är tänkta att användas.

---

# Så… är klasser verkligen bättre?

Som nybörjare känns det krångligare. Helt normalt.

Men när projektet växer händer detta:

Med dict:

* stavfel i nycklar
* inkonsekvent struktur
* logik spridd överallt

Med klass:

* strukturen samlad
* validering på ett ställe
* metoder hör ihop med datan
* lättare att underhålla

Det är där vinsten finns.

---

# Viktig insikt

Python är:

> “We are all consenting adults here.”

Den stoppar dig inte – men den ger dig verktyg att stoppa dig själv.

Vill du att jag visar:

* Hur man gör en **”riktigt strikt” klass**
* Eller hur man gör detta mer Pythoniskt utan massa boilerplate?
* Eller skillnaden mellan dataclass och vanlig klass?

Du är precis i den fas där OOP börjar klicka

Det är ju bara synd att forumet och chatGPT pratar olika formateringsspråk..

Av någon anledning tolkar LaTex backticks som start av formel. Tog bort alla dessa.

Sedan kan man ju även göra 'manuell' kontroll:
value = 'Liten häst'

if type(value) not in (int, float):
# Typcheck fel, gör vad som ska göras
else:
# Allt bra, fortsätt.

Man kan införa Set/Get för varje värde, där kollar man sedan typen.
Detta är nog mest min stil, jag är ganska anal med att ha koll på input och liknande.

Det finns olika lösningar beroende på vad ditt problem är. Det finns inte en lösning som passar bäst till allt.

Dictionaries är alldeles utmärkta att spara data i.

Om du har problem med att det är fel typer osv så är ju följdfrågan varför då?
Är det för att du läser data utifrån som du inte har kontroll på? I så fall bör
du göra datakontrollen där, närmare parsningen. Det känns inte rätt att
skjuta på det beslutet tills datan sparas i en struktur.

Om du nu skall göra typkontroll, så rekommenderas "isinstance" och inget annat.

Jo, ChatGPT har säkert bra svar. För Python använder jag just nu Perplexity och Mistrals Le Chat om vartannat och de ger utmärkta svar (oftast).
Vad jag var ute efter lite var kanske om någon har personliga preferenser, t.ex. när använder du klasser och när finns det anledning att strunta i klasser och bara bygga en dict rakt av?

Men, jo. Full kontroll vid parsingen är ju rätt väg förstås.