PythonPodcast 48 - itnett/FTD02H-N GitHub Wiki

Python Symboler og Konsepter forklart i detalj – Del 3 🌟

Vi går nå videre til mer avanserte symboler og konsepter i Python. I denne delen skal vi utforske flere datastrukturer, kontrollflyt, og dykke dypere inn i metoder og objektorientert programmering.

🛠️ Symboler og konsepter i Python – Del 3

[] (Lister)
➡️ Norsk: Lister brukes til å lagre flere elementer i en variabel, og kan inneholde ulike datatyper.
➡️ Engelsk: Lists are used to store multiple items in a variable and can contain different data types.
```
# Eksempel:
liste = [1, 2, 3, "tekst"]
print(liste)  # Output: [1, 2, 3, "tekst"]
```
{} (Ordbøker/Dictionaries)
➡️ Norsk: Ordbøker brukes til å lagre verdier i nøkkel-verdi par.
➡️ Engelsk: Dictionaries are used to store values in key-value pairs.
```
# Eksempel:
ordbok = {"navn": "Max", "alder": 30}
print(ordbok["navn"])  # Output: Max
```
() (Tupler)
➡️ Norsk: Tupler er lik lister, men de kan ikke endres etter at de er opprettet (immutable).
➡️ Engelsk: Tuples are like lists, but they cannot be changed after creation (immutable).
```
# Eksempel:
tuple = (1, 2, 3)
print(tuple)  # Output: (1, 2, 3)
```
.append() (Legg til element i liste)
➡️ Norsk: Legger til et nytt element på slutten av en liste.
➡️ Engelsk: Adds a new element to the end of a list.
```
# Eksempel:
liste = [1, 2, 3]
liste.append(4)
print(liste)  # Output: [1, 2, 3, 4]
```
.remove() (Fjern element fra liste)
➡️ Norsk: Fjerner det første elementet som matcher verdien som gis som argument.
➡️ Engelsk: Removes the first element that matches the value given as an argument.
```
# Eksempel:
liste = [1, 2, 3, 4]
liste.remove(2)
print(liste)  # Output: [1, 3, 4]
```
.pop() (Fjern og returner element fra liste)
➡️ Norsk: Fjerner og returnerer det siste elementet fra en liste (eller elementet på en spesifisert indeks).
➡️ Engelsk: Removes and returns the last element from a list (or the element at a specified index).
```
# Eksempel:
liste = [1, 2, 3]
element = liste.pop()
print(element)  # Output: 3
print(liste)  # Output: [1, 2]
```
set() (Mengder/Sets)
➡️ Norsk: Mengder brukes til å lagre flere unike elementer uten rekkefølge.
➡️ Engelsk: Sets are used to store multiple unique items without order.
```
# Eksempel:
mengde = {1, 2, 3, 3}  # Duplicates vil bli fjernet
print(mengde)  # Output: {1, 2, 3}
```
try, except (Unntaksbehandling)
➡️ Norsk: Brukes til å håndtere feil uten at programmet krasjer.
➡️ Engelsk: Used to handle errors without crashing the program.
```
# Eksempel:
try:
    resultat = 10 / 0
except ZeroDivisionError:
    print("Kan ikke dele på null!")  # Output: Kan ikke dele på null!
```
finally (Kjør alltid etter try/except)
➡️ Norsk: Koden i en finally blokk kjører uansett om det oppstår en feil eller ikke.
➡️ Engelsk: The code in a finally block runs whether an error occurs or not.
```
# Eksempel:
try:
    print("Gjør noe viktig...")
finally:
    print("Dette kjøres alltid.")  # Output: Dette kjøres alltid.
```

raise (Kast en feil)
➡️ Norsk: Brukes til å utløse en spesifikk unntakstype manuelt.
➡️ Engelsk: Used to manually trigger a specific type of exception.

# Eksempel:
def sjekk_verdi(x):
    if x < 0:
        raise ValueError("x må være positivt.")

sjekk_verdi(-1)  # Vil utløse ValueError med meldingen: x må være positivt.

👨‍💻 Objektorientert Programmering (OOP)

Klasser og objekter
➡️ Norsk: Python er et objektorientert språk, hvor vi definerer klasser for å lage objekter som representerer virkelige ting eller konsepter.
➡️ Engelsk: Python is an object-oriented language where we define classes to create objects that represent real-world things or concepts.

# Eksempel på en enkel klasse:
class Person:
    def __init__(self, navn, alder):
        self.navn = navn
        self.alder = alder
    
    def introduser(self):
        print(f"Hei, jeg heter {self.navn} og er {self.alder} år gammel.")

person1 = Person("Max", 30)
person1.introduser()  # Output: Hei, jeg heter Max og er 30 år gammel.

self (Referanse til objektet selv)
➡️ Norsk: Brukes i metoder i en klasse for å referere til objektet selv.
➡️ Engelsk: Used in methods within a class to refer to the object itself.

# Eksempel:
class Bil:
    def __init__(self, merke):
        self.merke = merke

    def beskrivelse(self):
        return f"Bilen er av merket {self.merke}"

bil1 = Bil("Tesla")
print(bil1.beskrivelse())  # Output: Bilen er av merket Tesla

Arv (Inheritance)
➡️ Norsk: Tillater en klasse å arve attributter og metoder fra en annen klasse.
➡️ Engelsk: Allows a class to inherit attributes and methods from another class.

# Eksempel:
class Dyr:
    def __init__(self, navn):
        self.navn = navn

    def lyd(self):
        pass

class Hund(Dyr):
    def lyd(self):
        return "Bjeff"

hund = Hund("Buster")
print(hund.lyd())  # Output: Bjeff

super() (Kall til overklasse)
➡️ Norsk: Brukes for å kalle metoder fra en overklasse i en underklasse.
➡️ Engelsk: Used to call methods from a superclass in a subclass.

# Eksempel:
class Forelder:
    def __init__(self, navn):
        self.navn = navn

class Barn(Forelder):
    def __init__(self, navn, alder):
        super().__init__(navn)
        self.alder = alder

barn = Barn("Max", 12)
print(barn.navn, barn.alder)  # Output: Max 12

📝 Avanserte funksjoner og konsepter

@property (Dekorator for egenskaper)
➡️ Norsk: Brukes for å definere en metode som kan brukes som en attributt.
➡️ Engelsk: Used to define a method that can be accessed as an attribute.

# Eksempel:
class Temperatur:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return (self._celsius * 9/5) + 32

temp = Temperatur(25)
print(temp.fahrenheit)  # Output: 77.0

@staticmethod (Statisk metode)
➡️ Norsk: En metode som ikke trenger tilgang til objektets instanser, og som kan kalles uten self.
➡️ Eng

elsk: A method that doesn't need access to the instance and can be called without self.
```python # Eksempel: class Matematikk: @staticmethod def addisjon(x, y): return x + y

print(Matematikk.addisjon(3, 5))  # Output: 8
```

🎯 Oppsummering Del 3:
Denne delen dekket avanserte datastrukturer som lister, ordbøker, og mengder, i tillegg til viktige konsepter innen objektorientert programmering som klasser, objekter, arv, og metoder. Videre ble unntaksbehandling og dekoratorer introdusert for å vise hvordan vi kan administrere feil og kontrollere programflyten.

Neste del vil fokusere på filbehandling, moduler, sikkerhet og testing i Python! Vi nærmer oss å mestre alle viktige aspekter av språket! 🎉