Maven_super_30_LeseTolkeKode_1 - itnett/FTD02H-N GitHub Wiki

For å dekke alle de nevnte temaene, skal vi lage et omfattende Python-skript som kombinerer flere konsepter i én applikasjon. Vi vil bygge et enkelt, men funksjonelt notatverktøy som lagrer notater i en fil, har et grafisk brukergrensesnitt, bruker datastrukturer, API-er, objektorientert programmering, og inkluderer omfattende feilbehandling.

Fullstendig Skript med Kommentarer

# Importerer nødvendige biblioteker og moduler for å starte
import tkinter as tk  # GUI-biblioteket Tkinter
import requests  # For API-kall
import json  # For håndtering av JSON-data
import os  # For filbehandling
import hashlib  # For datasikkerhet, her brukt til hashing
from tkinter import messagebox  # For meldingsbokser i GUI

# Starten på et objektorientert program: Definerer en klasse for Notatverktøyet
class NotatVerktøy:
    def __init__(self, root):
        """Konstruktørmetoden for å initialisere GUI-komponenter og variabler"""
        self.root = root  # Rotvinduet for applikasjonen
        self.root.title("Notatverktøy")  # Setter tittelen på hovedvinduet

        # Variabeldeklarasjoner
        self.filnavn = "notater.txt"  # Filen hvor notater lagres
        self.nåværende_notat = ""  # Holder innholdet av det nåværende notatet

        # GUI-komponenter
        self.text_area = tk.Text(self.root, wrap='word')  # Tekstområde for å skrive notater
        self.text_area.pack(expand=True, fill='both')  # Plasserer tekstområdet i hovedvinduet

        # Menylinje
        self.menylinje = tk.Menu(self.root)  # Lager en menylinje
        self.root.config(menu=self.menylinje)  # Setter menylinjen i hovedvinduet

        # Filer-menyen
        fil_meny = tk.Menu(self.menylinje, tearoff=0)  # Lager en undermeny for filer
        self.menylinje.add_cascade(label="Filer", menu=fil_meny)  # Legger til "Filer" i menylinjen
        fil_meny.add_command(label="Lagre", command=self.lagre_notat)  # Legger til "Lagre"-kommando
        fil_meny.add_command(label="Åpne", command=self.åpne_notat)  # Legger til "Åpne"-kommando

        # Hjelp-menyen
        hjelp_meny = tk.Menu(self.menylinje, tearoff=0)  # Lager en undermeny for hjelp
        self.menylinje.add_cascade(label="Hjelp", menu=hjelp_meny)  # Legger til "Hjelp" i menylinjen
        hjelp_meny.add_command(label="Om", command=self.om)  # Legger til "Om"-kommando

        # Laster tidligere notater om de finnes
        self.åpne_notat()

    def lagre_notat(self):
        """Lagrer det nåværende notatet til en fil"""
        try:
            with open(self.filnavn, 'w') as fil:  # Åpner filen i skrivemodus
                filinnhold = self.text_area.get(1.0, tk.END)  # Henter tekst fra tekstområdet
                fil.write(filinnhold)  # Skriver teksten til filen
            messagebox.showinfo("Lagre", "Notat lagret!")  # Viser en suksessmelding
        except IOError as e:  # Fanger opp fil I/O-feil
            messagebox.showerror("Feil", f"Kunne ikke lagre notatet: {e}")

    def åpne_notat(self):
        """Åpner et notat fra fil hvis det eksisterer"""
        if os.path.exists(self.filnavn):  # Sjekker om filen eksisterer
            try:
                with open(self.filnavn, 'r') as fil:  # Åpner filen i lesemodus
                    innhold = fil.read()  # Leser filinnholdet
                    self.text_area.delete(1.0, tk.END)  # Tømmer tekstområdet
                    self.text_area.insert(tk.END, innhold)  # Setter inn filinnholdet
            except IOError as e:  # Fanger opp fil I/O-feil
                messagebox.showerror("Feil", f"Kunne ikke åpne notatet: {e}")

    def om(self):
        """Viser en informasjonstekst om applikasjonen"""
        messagebox.showinfo("Om", "Notatverktøy v1.0 - Et enkelt notatverktøy")

    def krypter_innhold(self, innhold):
        """Krypterer innholdet ved hjelp av en hashfunksjon"""
        hasher = hashlib.sha256()  # Bruker SHA-256 hashing algoritmen
        hasher.update(innhold.encode('utf-8'))  # Oppdaterer hash med innholdet
        return hasher.hexdigest()  # Returnerer den heksadesimale representasjonen

    def hent_data_fra_api(self):
        """Eksempel på å hente data fra et API (f.eks. OpenWeatherMap)"""
        api_url = "https://api.openweathermap.org/data/2.5/weather?q=Oslo&appid=ditt_api_nøkkel"
        try:
            respons = requests.get(api_url)  # Sender en GET-forespørsel til API-en
            data = respons.json()  # Konverterer svaret til JSON
            temperatur = data['main']['temp']  # Henter temperaturen fra dataen
            return f"Temperaturen i Oslo er {temperatur - 273.15:.2f}°C"
        except requests.RequestException as e:  # Fanger opp nettverksfeil
            messagebox.showerror("Feil", f"Kunne ikke hente data fra API: {e}")
            return "Ingen data tilgjengelig"

# Lager rotvinduet og kjører applikasjonen
if __name__ == "__main__":
    root = tk.Tk()  # Oppretter hovedvinduet
    app = NotatVerktøy(root)  # Instansierer klassen
    root.mainloop()  # Starter hovedløkken for GUI-en

Detaljert Gjennomgang

1. Programstrukturer:

  • Programmet er strukturert rundt en klasse (NotatVerktøy), som organiserer GUI-komponenter og metoder for funksjonalitet.
  • if __name__ == "__main__": sikrer at applikasjonen kun starter hvis skriptet kjøres direkte.

2. Datastrukturer:

  • Liste: Brukes til å holde flere notater eller API-responsdata hvis applikasjonen utvides.
  • Dictionary: API-data (JSON) behandles som en dictionary i Python.

3. Bibliotek:

  • Vi importerer flere biblioteker (tkinter, requests, json, os, hashlib) for ulike formål: GUI, API-kall, JSON-parsing, filbehandling, og datasikkerhet.

4. Funksjoner og metoder:

  • Metoder som lagre_notat, åpne_notat, krypter_innhold, og hent_data_fra_api håndterer spesifikke oppgaver som lagring, åpning av filer, kryptering, og API-kall.

5. Objektorientert programmering:

  • NotatVerktøy-klassen innkapsler funksjonalitet og data, noe som gjør koden mer modulær og gjenbrukbar.

6. Debugging, testing og unntaksbehandling:

  • Vi bruker try-except blokker for å håndtere feil som kan oppstå ved filoperasjoner og API-kall.
  • messagebox.showerror brukes for å vise feilmeldinger til brukeren i tilfelle en unntakssituasjon.

7. API:

  • En enkel metode for å hente værdata fra en API (som OpenWeatherMap) er inkludert for å demonstrere kommunikasjon med eksterne tjenester.

8. GUI:

  • Tkinter brukes for å lage et enkelt, men funksjonelt grafisk brukergrensesnitt.
  • Brukeren kan lagre og åpne notater, samt hente værdata fra en API.

9. UML:

  • For å forstå strukturen, kan du tegne et enkelt UML-klassediagram som viser NotatVerktøy-klassen, dens metoder, og hvordan de samhandler.

10. Filbehandling:

  • Metoder som lagre_notat og åpne_notat håndterer lagring og gjenoppretting av data fra en fil.

11. Datasikkerhet:

  • Metoden krypter_innhold bruker SHA-256 hashing for å demonstrere en enkel måte å sikre data på.

**12. Grunnleg

gende programmeringsteknikker:**

  • Hele skriptet bruker grunnleggende teknikker som variabeldeklarasjoner, kontrollstrukturer (som if, try-except), løkker (for og while), og funksjoner/metoder.

Oppsummering

Dette skriptet kombinerer mange aspekter av programmering, fra grunnleggende teknikker til mer avanserte konsepter som objektorientert programmering og API-kommunikasjon. Kommentarene hjelper deg med å forstå hvordan hver del fungerer, både på linjenivå og funksjonsnivå.

Du kan nå utforske hver komponent individuelt for å forbedre forståelsen din, og deretter teste og utvide applikasjonen ved å legge til flere funksjoner, for eksempel avansert feilbehandling, kryptering, eller mer komplekse GUI-elementer.