Hur man skapar en registreringsapp med Python och en databas

Python har utmärkt databasstöd inbyggt i sitt standardbibliotek, så att du kan skapa och interagera med en databas utan att förlita dig på externa ramverk som Django ORM.

Pythons integration med SQLite erbjuder en effektiv lösning för hantering av datalagring genom sin lättviktiga struktur, vilket gör den tillgänglig för utvecklare som vill förbättra sina applikationer. Genom att implementera en enkel användarregistreringsapplikation kan man få insikt i de grundläggande begreppen för databasprogrammering inom Python-ekosystemet.

Hur man skapar en databas i Python

Koden som används i denna handledning är tillgänglig på ett GitHub-arkiv, som du kan komma åt för att utforska och implementera de begrepp som diskuteras häri.

För att kunna kommunicera med en databas med Python är det viktigt att ha både ett anslutningsobjekt och ett markörobjekt. Det förstnämnda gör det möjligt att upprätta en länk mellan applikationen och databasen, medan det sistnämnda gör det möjligt att utföra SQL-satser i databasen.

För att upprätta en anslutning mellan din Python-applikation och en befintlig databas, eller alternativt skapa en ny med hjälp av SQLite, finns det specifika steg som måste följas. Processen för att skapa en databasanslutning i Python för SQLite omfattar flera viktiga komponenter, t.ex. att ange databasmotorn, tillhandahålla nödvändiga autentiseringsuppgifter, definiera anslutningsparametrarna och slutligen ansluta till den önskade databasinstansen. Genom att noggrant följa dessa steg är det möjligt att upprätta en säker och effektiv databasanslutning i Python-kodbasen med hjälp av SQLite.

 import sqlite3

# Connect to a (new) database
conn = sqlite3.connect('path/to/database.db')

# Close the connection
conn.close()

Metoden connect() accepterar en katalog som representerar en befintlig databasfil. Om den angivna sökvägen inte innehåller någon databas kommer den att skapa en. För effektiv resurshantering rekommenderas att databasanslutningen släpps när interaktionerna har slutförts.

För att underlätta interaktion med en ansluten databas i Python är det nödvändigt att använda en markör. En markör gör det möjligt att utföra SQL-frågor (Structured Query Language) inom ramen för ett Python-program. Följ dessa steg för att skapa en markör:

 cursor = conn.cursor()

# Close the cursor
cursor.close()

Ett öppet anslutningsobjekt kan användas för att generera en markör genom att anropa dess metod cursor() .

Hur man utför en databastransaktion i Python

Med hjälp av en markör kan man utföra SQL-satser, förfrågningar eller skriptsekvenser i syfte att hämta eller modifiera data eller justera konfigurationen av databasschemat.

Det finns tre huvudsakliga tillvägagångssätt som man kan använda för att utföra en databastransaktion, nämligen

⭐ Cursor.execute . Denna metod kör en enda SQL-sats. Så här använder du den:

 cursor.execute("""
    CREATE TABLE IF NOT EXISTS users (
        name TEXT,
        age INTEGER
    )
""")

Den här koden anropar execute-metoden på en markör och skickar en sträng som innehåller ett SQL-sats.

⭐ Cursor.executemany . Med den här metoden kan du köra samma SQL-sats mer än en gång, med olika parametrar varje gång. Den tar emot två argument: SQL-satsen och en iterabel. En bra användning är att infoga flera objekt i databasen på en gång:

 data = [
    ('Alice', 25),
    ('Bob', 30),
    ('Charlie', 22)
]

cursor.executemany("""INSERT INTO users (name, age) VALUES (?, ?)""", data)

I koden ovan används metoden executemany för att infoga värden i databasen flera gånger.

Lägg märke till de platshållare som finns i den angivna SQL-satsen. Metoden executemany ska därefter infoga respektive data för varje enskild artikel.

⭐ Cursor.executescript . Som namnet antyder kommer denna metod att exekvera ett SQL-skript åt dig. Du kan skriva dina SQL-satser i en annan fil och köra dem med executescript-metoden:

 with open("path/to/script.sql") as file:
 sql_script = file.read()

cursor.executescript(sql_script)

Hur man bygger en registreringsapplikation med Python och SQLite3

För att utveckla en effektiv registreringsapplikation måste man fånga slutanvändarens data med Python och sedan bevara dem i ett relationsdatabashanteringssystem som SQLite3. Denna serie riktlinjer kommer att illustrera processen för att bygga en rudimentär registreringsplattform med hjälp av Python och SQLite3.

Steg 1: Anslut till en befintlig databas eller skapa en ny

För att kunna börja använda din applikation är det nödvändigt att antingen skapa en ny databas eller att integrera med en befintlig.

 import sqlite3

conn = sqlite3.connect('database.db')

cursor = conn.cursor()

# your app's code goes here

cursor.close()

conn.close()

Koden upprättar en anslutning till databasen genom att skapa ett anslutningsobjekt, som underlättar kommunikationen mellan programmet och databasen. Dessutom genereras en markör som möjliggör effektiv hämtning av data från databasen som svar på SQL-frågor.

Steg 2: Skapa en tabell för användare

För att skapa ett datalager för användarregistreringar är det nödvändigt att generera en tabell med hjälp av muspekaren.Detta kan uppnås genom att använda följande steg:

 cursor.execute("""
    CREATE TABLE IF NOT EXISTS users (
        first_name TEXT,
        last_name TEXT,
        email TEXT UNIQUE,
        password TEXT
    )
""")

conn.commit()

Den här implementeringen gör det möjligt att skapa en tabell med namnet “users” i en befintlig databas, om den inte redan är etablerad. Med hjälp av denna process konstrueras fyra olika kolumner för att rymma data som rör enskilda användare. Tillhandahållandet av ett singulärt “email”-fält fungerar som en mekanism för att hindra användare från att upprätta flera registreringar under identiska elektroniska e-postadresser och därigenom säkerställa att varje konto förblir unikt identifierbart och särskiljande.

Utförandet av conn.commit är avgörande för att förbinda frågan till databasen, utan vilken inga ändringar skulle återspeglas i databasen.

Metoden executescript ger ett alternativt tillvägagångssätt genom att inkorporera COMMIT direkt i SQL-skriptet, vilket eliminerar behovet av att explicit anropa conn.commit .

Steg 3: Samla in användardata

Python-funktioner underlättar återanvändning av kod, vilket gör det klokt att skapa en funktion som hanterar registreringsaspekten. Denna funktion samlar in användarens förnamn, efternamn, e-postadress och lösenord.

 def register_user():
    first_name = input("Enter your first name: ")
    last_name = input("Enter your last name: ")
    email = input("Enter your email: ")
    password1 = input("Enter your password: ")
    password2 = input("Confirm your password: ")

Steg 4: Kontrollera att lösenordet är korrekt

Här är ett exempel på hur du kan ändra funktionen register_user i Python så att användarna måste ange sina lösenord två gånger och uppmanas att ange dem igen om de inte matchar:pythondef register_user(username, email, password):# Kontrollera om användarnamn redan finnsexisting_user = User.objects.filter(username=username).first()if existing_user:raise ValueError(“Username already taken”)# Skapa nytt användarobjektuser = User.objects.create_user(username, email, password)# Spara användarobjektet i databasenuser.save()return f"{username}, {email} - {password}"

 def register_user():
    first_name = input("Enter your first name: ")
    last_name = input("Enter your last name: ")
    email = input("Enter your email: ")

    while True:
        password1 = input("Enter your password: ")
        password2 = input("Confirm your password: ")

        # Check password correctness
        if password1 == password2:
            print("You have successfully registered!")
            break
        else:
            print("Your passwords must match")

För att säkerställa att konton skapas korrekt måste användare nu kontrollera att deras angivna lösenord är identiskt vid registreringen. Denna åtgärd eliminerar potentiella avvikelser i kombinationer av användarnamn och lösenord och förbättrar därmed den övergripande systemintegriteten.

Steg 5: Kontrollera att e-postadressen är unik

I SQL-satsen som skapar användartabellen anges att e-postfältet måste vara unikt. Följaktligen, om en användare försöker registrera sig genom att använda en e-postadress som tidigare har registrerats, kommer databashanteringssystemet att generera ett undantag.För att din applikation ska kunna reagera effektivt och smidigt på denna situation, är det nödvändigt att implementera lämpliga hanteringsmekanismer i din Python-kod för att hantera och bearbeta det genererade undantaget.

 def register_user():
    first_name = input("Enter your first name: ")
    last_name = input("Enter your last name: ")

    while True:
        email = input("Enter your email: ")
        password1 = input("Enter your password: ")
        password2 = input("Confirm your password: ")

        # Check password correctness
        if password1 == password2:
            try:
                print("You have successfully created an account.")
                break
            except sqlite3.IntegrityError:
                print("Error: This email is already registered.")
        else:
            print("Your passwords must match.")

Den aktuella implementeringen använder en try-except-klausul för att hantera eventuella fel som uppstår på grund av duplicerade e-postadresser under databasoperationer. Om ett IntegrityError påträffas under den iterativa processen, riktas kontrollflödet tillbaka till den inmatade begäran om en distinkt e-postadress från användaren.

I denna specifika tillämpning är det rimligt att anta att alla fall av IntegrityError som uppstår när ett nytt användarkonto skapas orsakas av att det finns en duplicerad e-postadress. I en praktisk miljö kan man dock använda en mer omfattande metod för att hantera fel, som kan omfatta ytterligare problem utöver enbart dubbletter inom e-postdomänen.

Steg 6: Infoga användarens data i databasen

För att infoga den insamlade informationen från en användare i en databas krävs att en SQL-sats (Structured Query Language) körs. För att utföra denna uppgift kan man använda en SQL-fråga i sitt program. Genom att justera try-except-blocket i enlighet med detta kan programmet framgångsrikt lagra användarens uppgifter i databasen.

 try:
    cursor.execute("""
        INSERT INTO users (first_name, last_name, email, password)
        VALUES (?, ?, ?, ?)
    """, (first_name, last_name, email, password2))

    conn.commit()
    print("You have successfully created an account.")
    break
except sqlite3.IntegrityError:
    print("Error: This email is already registered.")

I den uppdaterade try-except-satsen utför markören en SQL-insättningsåtgärd. Därefter påbörjar metoden conn.commit SQL-operationen i databasen.

Om du har följt alla stegen ovan bör du ha ett program som registrerar användare och sparar dem i databasen. Du kan använda en app som DB Browser for SQLite för att visa innehållet i din databas:

Använda databaser istället för samlingstyper

För småskaliga applikationer med relativt enkla datastrukturer kan det vara praktiskt att skapa anpassade SQL-frågor eller använda ett lättviktigt ORM-bibliotek (Object Relational Mapping) som t.ex. SQLAlchemy. När man utvecklar större, mer komplicerade system där datarelationerna blir alltmer detaljerade, kan dock ett etablerat ramverk som Djangos ORM erbjuda betydande fördelar när det gäller effektivitet, underhåll och utbyggnadsmöjligheter.

För att ytterligare förbättra dina kunskaper om databasoperationer på låg nivå kan du överväga att implementera en inloggningsmekanism som kompletterar den befintliga användarregistreringsprocessen.