20TD02T Spyder

La oss lage et dynamisk og komplekst Python-skript som dekker emnet databasesystemer, med muligheter for justering av variabler, og som tar resultatene av én beregning inn i neste for å demonstrere de ulike delene av fagplanen.

Vi skal inkludere følgende elementer:

1. Opprette og bruke databaser
2. Utvikle datamodeller med nøkler, tabeller og relasjoner
3. Visualisere data fra en database
4. Ta backup og restore
5. Indeksering og optimalisering
6. Sikkerhet og kryptering

For demonstrasjonen bruker vi SQLite som database. Vi inkluderer også eksempler på SQL-spørringer, visualiseringer med Matplotlib, og viser hvordan man kan konfigurere og administrere databaser.

Skriptet:

import sqlite3
import pandas as pd
import matplotlib.pyplot as plt
import hashlib

# --- KONFIGURASJON OG DATABASEOPPRETTELSE ---
database_name = 'fagplan.db'

# Opprette en forbindelse til databasen (oppretter databasen hvis den ikke finnes)
conn = sqlite3.connect(database_name)
cursor = conn.cursor()

# --- OPPRETTELSE AV TABELLER OG INNSKYTING AV DATA ---
# Funksjon for å opprette tabeller
def create_tables():
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS Users (
        user_id INTEGER PRIMARY KEY,
        username TEXT NOT NULL,
        password TEXT NOT NULL,
        email TEXT NOT NULL
    )
    ''')

    cursor.execute('''
    CREATE TABLE IF NOT EXISTS Orders (
        order_id INTEGER PRIMARY KEY,
        user_id INTEGER,
        product TEXT NOT NULL,
        amount INTEGER,
        FOREIGN KEY(user_id) REFERENCES Users(user_id)
    )
    ''')
    conn.commit()

# Funksjon for å legge til data
def insert_data():
    # Legger til brukere
    users = [
        ('alice', hashlib.sha256('password123'.encode()).hexdigest(), '[email protected]'),
        ('bob', hashlib.sha256('password456'.encode()).hexdigest(), '[email protected]')
    ]
    cursor.executemany('INSERT INTO Users (username, password, email) VALUES (?, ?, ?)', users)

    # Legger til ordre
    orders = [
        (1, 'Laptop', 1),
        (2, 'Smartphone', 2),
        (1, 'Tablet', 3)
    ]
    cursor.executemany('INSERT INTO Orders (user_id, product, amount) VALUES (?, ?, ?)', orders)
    conn.commit()

# --- DATABASEVISUALISERING ---
# Funksjon for å hente og visualisere data
def visualize_data():
    query = '''
    SELECT Users.username, Orders.product, Orders.amount
    FROM Users
    JOIN Orders ON Users.user_id = Orders.user_id
    '''
    df = pd.read_sql_query(query, conn)

    # Visualiser data
    df.groupby('username').sum()['amount'].plot(kind='bar')
    plt.title('Total Orders by User')
    plt.xlabel('User')
    plt.ylabel('Total Orders')
    plt.show()

# --- BACKUP OG RESTORE ---
def backup_database():
    with open('backup.sql', 'w') as f:
        for line in conn.iterdump():
            f.write(f'{line}\n')

def restore_database():
    with open('backup.sql', 'r') as f:
        sql = f.read()
    conn.executescript(sql)
    conn.commit()

# --- INDEKSERING OG OPTIMALISERING ---
def create_index():
    cursor.execute('CREATE INDEX IF NOT EXISTS idx_user_id ON Orders(user_id)')
    conn.commit()

# --- SIKKERHET OG KRYPTIERING ---
def encrypt_password(password):
    return hashlib.sha256(password.encode()).hexdigest()

# --- EKSEKVERING AV FUNKSJONER ---
create_tables()
insert_data()
visualize_data()
backup_database()
create_index()

# Avslutt forbindelse
conn.close()

Forklaring og sammenheng:

Opprette og bruke databaser: Vi oppretter en SQLite-database og to tabeller: Users og Orders. Data legges til disse tabellene for å demonstrere grunnleggende operasjoner som opprettelse, innskytning og spørring av data.

Utvikle datamodeller med nøkler, tabeller og relasjoner: Tabellen Users inneholder brukerinformasjon, og tabellen Orders inneholder ordredata, med en fremmednøkkel (user_id) som refererer til Users-tabellen. Dette demonstrerer relasjonsmodellen.

Visualisere data fra en database: Vi bruker Pandas til å hente data fra databasen og Matplotlib til å visualisere det. Her viser vi totalantall ordre per bruker.

Backup og restore: Vi lager en funksjon for å ta en SQL-dump av databasen til en fil (backup.sql) og en annen for å gjenopprette databasen fra denne filen.

Indeksering og optimalisering: Vi oppretter en indeks på user_id i Orders-tabellen for å optimalisere spørringer som bruker denne kolonnen.

Sikkerhet og kryptering: Vi viser hvordan man kan kryptere passord ved å bruke SHA-256 hashing. Dette sikrer at passordene ikke lagres i klartekst i databasen.

Dette skriptet dekker de viktigste elementene i fagplanen for databasesystemer, og gir en intuitiv og praktisk forståelse av hvordan man kan bruke, administrere og sikre databaser, samt hvordan man kan visualisere og analysere data.

Ja, bildet du viser er et bevis på at skriptet fungerte som forventet. Grafen som viser totalordrene per bruker, med "alice" og "bob" som brukere, stemmer overens med dataene som ble lagt til i Users- og Orders-tabellene i skriptet. Dette er ikke bare en simulering; det er en faktisk visualisering av dataene som ble opprettet, innsatt og spurt fra SQLite-databasen.

Hvordan kan du verifisere at dataene ble lagt til riktig:

1. Database Opprettelse og Data Innsetting:

   • Skriptet oppretter en database og tabeller hvis de ikke allerede eksisterer.
   • Data for to brukere, "alice" og "bob", samt deres ordre, legges inn i databasetabellene.

2. Visualisering:

   • Dataene blir spurt og hentet fra tabellene og deretter visualisert ved hjelp av Pandas og Matplotlib.
   • Grafen viser at "alice" har 4 ordre (1 Laptop og 3 Tablets) og "bob" har 2 ordre (2 Smartphones).

Stegene i Skriptet:

1. Opprettelse av tabeller:

   def create_tables():
       cursor.execute('''
       CREATE TABLE IF NOT EXISTS Users (
           user_id INTEGER PRIMARY KEY,
           username TEXT NOT NULL,
           password TEXT NOT NULL,
           email TEXT NOT NULL
       )
       ''')
       cursor.execute('''
       CREATE TABLE IF NOT EXISTS Orders (
           order_id INTEGER PRIMARY KEY,
           user_id INTEGER,
           product TEXT NOT NULL,
           amount INTEGER,
           FOREIGN KEY(user_id) REFERENCES Users(user_id)
       )
       ''')
       conn.commit()
   

2. Innskytning av data:

   def insert_data():
       users = [
           ('alice', hashlib.sha256('password123'.encode()).hexdigest(), '[email protected]'),
           ('bob', hashlib.sha256('password456'.encode()).hexdigest(), '[email protected]')
       ]
       cursor.executemany('INSERT INTO Users (username, password, email) VALUES (?, ?, ?)', users)
   
       orders = [
           (1, 'Laptop', 1),
           (2, 'Smartphone', 2),
           (1, 'Tablet', 3)
       ]
       cursor.executemany('INSERT INTO Orders (user_id, product, amount) VALUES (?, ?, ?)', orders)
       conn.commit()
   

3. Visualisering av data:

   def visualize_data():
       query = '''
       SELECT Users.username, Orders.product, Orders.amount
       FROM Users
       JOIN Orders ON Users.user_id = Orders.user_id
       '''
       df = pd.read_sql_query(query, conn)
   
       df.groupby('username').sum()['amount'].plot(kind='bar')
       plt.title('Total Orders by User')
       plt.xlabel('User')
       plt.ylabel('Total Orders')
       plt.show()
   

Disse kodestykkene sørger for at tabellene blir opprettet, dataene blir lagt inn, og visualiseringen blir utført korrekt.

Bekreftelse

For ytterligere å bekrefte at dataene er korrekte, kan du kjøre en SQL-spørring for å hente og vise dataene i Users- og Orders-tabellene:

def fetch_data():
    users_data = pd.read_sql_query("SELECT * FROM Users", conn)
    orders_data = pd.read_sql_query("SELECT * FROM Orders", conn)
    print("Users Data:")
    print(users_data)
    print("\nOrders Data:")
    print(orders_data)

fetch_data()

Dette vil skrive ut innholdet i Users- og Orders-tabellene, slik at du kan verifisere at dataene er korrekte.

Oppsummering

Grafen er et visuelt bevis på at skriptet fungerer som forventet. Den viser at dataene ble korrekt opprettet, innsatt og hentet fra SQLite-databasen. Dette demonstrerer hvordan man kan bruke SQLite til å håndtere databaserelaterte oppgaver, visualisere data, og sikre dataintegritet i henhold til fagplanen.

---

Kort beskrivelse av koden

Denne koden demonstrerer hvordan man oppretter og bruker en SQLite-database i Python, utvikler datamodeller med nøkler og relasjoner, visualiserer data fra databasen, tar backup og restore, og implementerer indeksering, optimalisering, samt sikkerhet og kryptering.

Faktisk kode

import sqlite3
import pandas as pd
import matplotlib.pyplot as plt
import hashlib

# --- KONFIGURASJON OG DATABASEOPPRETTELSE ---
database_name = 'fagplan.db'

# Opprette en forbindelse til databasen (oppretter databasen hvis den ikke finnes)
conn = sqlite3.connect(database_name)
cursor = conn.cursor()

# --- OPPRETTELSE AV TABELLER OG INNSKYTING AV DATA ---
# Funksjon for å opprette tabeller
def create_tables():
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS Users (
        user_id INTEGER PRIMARY KEY,
        username TEXT NOT NULL,
        password TEXT NOT NULL,
        email TEXT NOT NULL
    )
    ''')

    cursor.execute('''
    CREATE TABLE IF NOT EXISTS Orders (
        order_id INTEGER PRIMARY KEY,
        user_id INTEGER,
        product TEXT NOT NULL,
        amount INTEGER,
        FOREIGN KEY(user_id) REFERENCES Users(user_id)
    )
    ''')
    conn.commit()

# Funksjon for å legge til data
def insert_data():
    # Legger til brukere
    users = [
        ('alice', hashlib.sha256('password123'.encode()).hexdigest(), '[email protected]'),
        ('bob', hashlib.sha256('password456'.encode()).hexdigest(), '[email protected]')
    ]
    cursor.executemany('INSERT INTO Users (username, password, email) VALUES (?, ?, ?)', users)

    # Legger til ordre
    orders = [
        (1, 'Laptop', 1),
        (2, 'Smartphone', 2),
        (1, 'Tablet', 3)
    ]
    cursor.executemany('INSERT INTO Orders (user_id, product, amount) VALUES (?, ?, ?)', orders)
    conn.commit()

# --- DATABASEVISUALISERING ---
# Funksjon for å hente og visualisere data
def visualize_data():
    query = '''
    SELECT Users.username, Orders.product, Orders.amount
    FROM Users
    JOIN Orders ON Users.user_id = Orders.user_id
    '''
    df = pd.read_sql_query(query, conn)

    # Visualiser data
    df.groupby('username').sum()['amount'].plot(kind='bar')
    plt.title('Total Orders by User')
    plt.xlabel('User')
    plt.ylabel('Total Orders')
    plt.show()

# --- BACKUP OG RESTORE ---
def backup_database():
    with open('backup.sql', 'w') as f:
        for line in conn.iterdump():
            f.write(f'{line}\n')

def restore_database():
    with open('backup.sql', 'r') as f:
        sql = f.read()
    conn.executescript(sql)
    conn.commit()

# --- INDEKSERING OG OPTIMALISERING ---
def create_index():
    cursor.execute('CREATE INDEX IF NOT EXISTS idx_user_id ON Orders(user_id)')
    conn.commit()

# --- SIKKERHET OG KRYPTIERING ---
def encrypt_password(password):
    return hashlib.sha256(password.encode()).hexdigest()

# --- EKSEKVERING AV FUNKSJONER ---
create_tables()
insert_data()
visualize_data()
backup_database()
create_index()

# Avslutt forbindelse
conn.close()

Struktur og flyt

1. Konfigurasjon og databaseopprettelse

   • Oppretter en SQLite-database og en tilkobling til den.

2. Opprettelse av tabeller og innskyting av data

   • create_tables: Oppretter Users- og Orders-tabellene hvis de ikke allerede eksisterer.
   • insert_data: Legger til eksempeldataklienter og deres bestillinger i databasetabellene.

3. Databasevisualisering

   • visualize_data: Henter data fra databasetabellene og visualiserer det ved hjelp av Pandas og Matplotlib.

4. Backup og restore

   • backup_database: Oppretter en SQL-dump av databasen til en fil.
   • restore_database: Leser SQL-dumpfilen og gjenoppretter databasen.

5. Indeksering og optimalisering

   • create_index: Oppretter en indeks på user_id-kolonnen i Orders-tabellen for å optimalisere spørringer.

6. Sikkerhet og kryptering

   • encrypt_password: Krypterer passord ved hjelp av SHA-256 hashing.

Mermaid-diagram

graph TD
  A[Start] --> B[Konfigurasjon og databaseopprettelse]
  B --> C[Opprettelse av tabeller]
  C --> D[Innskyting av data]
  D --> E[Databasevisualisering]
  E --> F[Backup]
  F --> G[Restore]
  G --> H[Indeksering og optimalisering]
  H --> I[Sikkerhet og kryptering]
  I --> J[Avslutt forbindelse]

Dette diagrammet viser en høy-nivå oversikt over koden, fra start til slutt, inkludert alle de viktigste funksjonene og operasjonene.