PythonPodcast 49 - itnett/FTD02H-N GitHub Wiki

Python Symboler og Konsepter forklart i detalj – Del 4 🌟

I denne delen av Python-opplæringen vil vi utforske filbehandling, moduler, testing, og grunnleggende prinsipper for sikkerhet i Python. Vi går videre til mer praktisk bruk av Python i reelle prosjekter!

🛠️ Symboler og konsepter i Python – Del 4

open() (Åpne filer)
➡️ Norsk: Brukes for å åpne en fil slik at du kan lese fra eller skrive til den.
➡️ Engelsk: Used to open a file so you can read from or write to it.
```
# Eksempel på å åpne og lese fra en fil:
fil = open("filnavn.txt", "r")
innhold = fil.read()
print(innhold)
fil.close()  # Husk å lukke filen etter bruk
```

Modus for filåpning
➡️ Norsk: Når du åpner en fil, kan du spesifisere en modus for å bestemme hvordan filen skal håndteres.
➡️ Engelsk: When opening a file, you can specify a mode to determine how the file is handled.

Modus	Beskrivelse
`"r"`	Lesemodus (read)
`"w"`	Skrivemodus (write), overskriver eksisterende fil
`"a"`	Legg til (append) til eksisterende innhold
`"x"`	Lag en ny fil, og feiler hvis filen allerede eksisterer
`"b"`	Binærmodus (for binære filer som bilder)

with (Sikker filhåndtering)
➡️ Norsk: with sørger for at en fil automatisk lukkes når operasjonene er ferdige.
➡️ Engelsk: with ensures a file is automatically closed after operations are completed.
```
# Eksempel:
with open("filnavn.txt", "r") as fil:
    innhold = fil.read()
    print(innhold)
# Filen lukkes automatisk når blokkeringen er ferdig
```
write() (Skrive til en fil)
➡️ Norsk: Brukes til å skrive data til en fil.
➡️ Engelsk: Used to write data to a file.
```
# Eksempel på å skrive til en fil:
with open("filnavn.txt", "w") as fil:
    fil.write("Dette er en tekstlinje.")
```
read() (Lese hele innholdet fra en fil)
➡️ Norsk: Leser alt innhold fra en fil og returnerer det som en streng.
➡️ Engelsk: Reads all content from a file and returns it as a string.
```
# Eksempel:
with open("filnavn.txt", "r") as fil:
    innhold = fil.read()
    print(innhold)
```
readline() (Les én linje om gangen fra en fil)
➡️ Norsk: Leser én linje fra filen hver gang den kalles.
➡️ Engelsk: Reads one line from the file each time it is called.
```
# Eksempel:
with open("filnavn.txt", "r") as fil:
    linje1 = fil.readline()
    linje2 = fil.readline()
    print(linje1, linje2)
```
os (Operativsystem-modul)
➡️ Norsk: os-modulen gir tilgang til funksjoner som lar deg samhandle med operativsystemet, som å manipulere filer og mapper.
➡️ Engelsk: The os module provides access to functions that allow you to interact with the operating system, such as manipulating files and directories.
```
import os
os.remove("filnavn.txt")  # Sletter en fil
```

🧩 Moduler og Pakker

import (Importere moduler)
➡️ Norsk: Brukes for å inkludere eksterne moduler og biblioteker i programmet ditt.
➡️ Engelsk: Used to include external modules and libraries into your program.
```
# Eksempel:
import math
print(math.sqrt(16))  # Output: 4.0
```
from ... import (Spesifikk importering fra en modul)
➡️ Norsk: Tillater deg å importere spesifikke funksjoner eller klasser fra en modul.
➡️ Engelsk: Allows you to import specific functions or classes from a module.
```
# Eksempel:
from math import sqrt
print(sqrt(25))  # Output: 5.0
```
Egendefinerte moduler
➡️ Norsk: Du kan lage dine egne moduler ved å definere funksjoner og lagre dem i en .py-fil.
➡️ Engelsk: You can create your own modules by defining functions and saving them in a .py file.
```
# Eksempel (filen minmodul.py):
def hilsen(navn):
    print(f"Hei, {navn}")
# Importere egendefinert modul:
import minmodul
minmodul.hilsen("Anna")  # Output: Hei, Anna
```
__name__ == "__main__" (Hovedprogramblokk)
➡️ Norsk: Brukes for å sikre at en kodeblokk kun kjøres når filen kjøres direkte, og ikke når den importeres som en modul.
➡️ Engelsk: Used to ensure a block of code only runs when the file is executed directly, not when it’s imported as a module.
```
# Eksempel:
if __name__ == "__main__":
    print("Denne koden kjører kun når filen kjøres direkte.")
```

🧪 Testing og debugging

assert (Påstander i testing)
➡️ Norsk: assert brukes for å teste om en betingelse er sann, og hvis den ikke er det, kaster den en feil.
➡️ Engelsk: assert is used to test if a condition is true, and if it’s not, it raises an error.
```
# Eksempel:
assert 4 + 4 == 8  # Ingen feil, fordi betingelsen er sann
assert 5 == 6  # Dette vil kaste en AssertionError
```
try / except (Feilhåndtering)
➡️ Norsk: Brukes for å håndtere feil uten at programmet krasjer.
➡️ Engelsk: Used to handle errors without crashing the program.
```
# Eksempel:
try:
    resultat = 10 / 0
except ZeroDivisionError:
    print("Feil: Kan ikke dele på null!")  # Output: Feil: Kan ikke dele på null!
```
Logging
➡️ Norsk: logging brukes for å legge til meldinger som hjelper deg med å feilsøke og forstå hva som skjer i programmet ditt.
➡️ Engelsk: logging is used to add messages that help you debug and understand what’s happening in your program.
```
import logging
logging.basicConfig(level=logging.DEBUG)
logging.debug("Dette er en debug-melding.")
```

🔐 Sikkerhet og filhåndtering

hashlib (Sikkerhet og hashing)
➡️ Norsk: hashlib brukes for å lage kryptografiske hashes, som kan brukes for å beskytte sensitive data som passord.
➡️ Engelsk: hashlib is used to create cryptographic hashes, which can be used to secure sensitive data such as passwords.
```
import hashlib
passord = "mitt_passord"
hash_passord = hashlib.sha256(passord.encode()).hexdigest()
print(hash_passord)  # En kryptert hash av passordet
```
os.path (Sikre filbaner)
➡️ Norsk: os.path gir funksjoner for å jobbe med og sikre filbaner.
➡️ Engelsk: os.path provides functions to work with and secure file paths.
```
import os
filbane = os.path.join("mapper", "fil.txt")
print(filbane)  # Output: mapper/fil.txt
```

🎯 Oppsummering Del 4:
I denne delen har vi gått gjennom filhåndtering, moduler, testing, og grunnleggende sikkerhet i Python. Du har nå et solid

fundament for å jobbe med eksterne filer og moduler, samt hvordan du kan teste og sikre Python-applikasjonene dine.

Neste del vil utforske avanserte emner som datastrukturer, API-integrasjon, og mer avansert filbehandling!🚀