Webscraping en bots · Les

Integratie met databases (SQL)

Leer hoe u uw scr scripts met SQL-databases (bijvoorbeeld SQLite en PostgreSQL) verbindt voor gestructureerde gegevensopslag.

Les 2 van 411 stappen

Integratie met databases (SQL) is een gratis Webscraping en bots-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Webscraping en bots. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Webscraping en bots bevat in totaal 4 lessen.

SQL voor opslag van geëxtraheerde gegevens

Welkom! Nadat je gegevens van het web hebt verzameld, heb je een betrouwbare manier nodig om die op te slaan. Hoewel CSV- of JSON-bestanden geschikt zijn voor kleine taken, bieden databases krachtige voordelen voor grotere en complexere projecten voor gegevensextractie.

In deze les leer je hoe je je Python-scripts voor gegevensextractie koppelt aan SQL-databases zoals SQLite, een lichtgewicht database op basis van bestanden die ideaal is voor lokale ontwikkeling.

Waarom SQL-databases gebruiken?

Het opslaan van geëxtraheerde gegevens in een SQL-database biedt aanzienlijke voordelen ten opzichte van eenvoudige bestandsopslag:

  • Gestructureerde opslag: gegevens worden georganiseerd in tabellen met vastgelegde kolommen, wat voor consistentie zorgt.
  • Doorzoekbaarheid: zoek, filter en analyseer je gegevens eenvoudig met SQL-query's.
  • Schaalbaarheid: verwerk grote hoeveelheden gegevens efficiënter dan met platte bestanden.
  • Gegevensintegriteit: dwing regels af om ongeldige of dubbele gegevensinvoer te voorkomen.

SQL-basis: tabellen, rijen en kolommen

Zie een SQL-database als een verzameling spreadsheets. Elke 'spreadsheet' heet een tabel. Elke rij in een spreadsheet is een rij (of record) in een tabel en elke kolom is een kolom (of veld).

Een tabel products kan bijvoorbeeld kolommen hebben voor name, price en url.

Verbinding maken met SQLite in Python

Python heeft een ingebouwde module, sqlite3, waarmee je met SQLite-databases kunt werken. Eerst moet je een verbinding tot stand brengen.

Voer deze code uit om te zien hoe je verbinding maakt met een databasebestand met de naam scraped_data.db en het daarna sluit.

import sqlite3

def connect_to_db(db_name="scraped_data.db"):
    conn = None
    try:
        # Connects to the database file. If it doesn't exist, it creates it.
        conn = sqlite3.connect(db_name)
        print(f"Successfully connected to {db_name}")
    except sqlite3.Error as e:
        print(f"Database connection error: {e}")
    finally:
        if conn:
            # Always close the connection when done
            conn.close()
            print("Connection closed.")

if __name__ == "__main__":
    connect_to_db()

Je eerste tabel maken

Nadat je verbinding hebt gemaakt, moet je de structuur van je gegevens definiëren. Dat doe je door een tabel te maken met een SQL-instructie CREATE TABLE. We gebruiken een object cursor om SQL-opdrachten uit te voeren.

In dit voorbeeld wordt een tabel products gemaakt met kolommen voor een ID, naam, prijs en URL.

import sqlite3

def create_products_table(db_name="scraped_data.db"):
    conn = None
    try:
        conn = sqlite3.connect(db_name)
        cursor = conn.cursor()
        # SQL command to create a table if it doesn't already exist
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS products (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                price REAL,
                url TEXT UNIQUE
            )
        """)
        conn.commit() # Save the changes to the database
        print("Table 'products' created or already exists.")
    except sqlite3.Error as e:
        print(f"Database error: {e}")
    finally:
        if conn:
            conn.close()

if __name__ == "__main__":
    create_products_table()

Geëxtraheerde gegevens invoegen

Nadat je je tabel hebt gemaakt, kun je de gegevens die je hebt geëxtraheerd gaan toevoegen. Hiervoor gebruik je de SQL-instructie INSERT INTO. Het is belangrijk om geparameteriseerde query's te gebruiken (met ?-plaatshouders) om kwetsbaarheden door SQL-injectie te voorkomen.

We voegen één product toe aan onze tabel.

import sqlite3

def insert_product(db_name="scraped_data.db", name="Sample Product", price=99.99, url="http://example.com/sample"):
    conn = None
    try:
        conn = sqlite3.connect(db_name)
        cursor = conn.cursor()
        # SQL to insert a single row
        cursor.execute("INSERT INTO products (name, price, url) VALUES (?, ?, ?)",
                       (name, price, url))
        conn.commit()
        print(f"Inserted product: {name}")
    except sqlite3.Error as e:
        print(f"Database error: {e}")
    finally:
        if conn:
            conn.close()

if __name__ == "__main__":
    # Ensure table exists before inserting
    conn_temp = sqlite3.connect("scraped_data.db")
    cursor_temp = conn_temp.cursor()
    cursor_temp.execute("""
        CREATE TABLE IF NOT EXISTS products (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            price REAL,
            url TEXT UNIQUE
        )
    """)
    conn_temp.commit()
    conn_temp.close()

    insert_product(name="Python Book", price=35.50, url="http://bookstore.com/python")

Meerdere records efficiënt invoegen

Wanneer je veel geëxtraheerde items moet opslaan, kan het langzaam zijn om ze één voor één in te voegen. Met de methode cursor.executemany() kun je meerdere rijen met één opdracht invoegen, waardoor het proces veel sneller verloopt.

Geef een lijst met tuples op, waarbij elke tuple een in te voegen rij vertegenwoordigt.

import sqlite3

def insert_multiple_products(db_name="scraped_data.db", products_data=None):
    if products_data is None:
        products_data = [
            ("Mechanical Keyboard", 120.00, "http://shop.com/mech-kb"),
            ("Gaming Mouse", 65.99, "http://shop.com/gaming-mouse"),
            ("Webcam HD", 49.99, "http://shop.com/webcam")
        ]

    conn = None
    try:
        conn = sqlite3.connect(db_name)
        cursor = conn.cursor()
        # Use executemany for bulk inserts
        cursor.executemany("INSERT INTO products (name, price, url) VALUES (?, ?, ?)",
                           products_data)
        conn.commit()
        print(f"Inserted {len(products_data)} products.")
    except sqlite3.Error as e:
        print(f"Database error: {e}")
    finally:
        if conn:
            conn.close()

if __name__ == "__main__":
    # Ensure table exists before inserting
    conn_temp = sqlite3.connect("scraped_data.db")
    cursor_temp = conn_temp.cursor()
    cursor_temp.execute("""
        CREATE TABLE IF NOT EXISTS products (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            price REAL,
            url TEXT UNIQUE
        )
    """)
    conn_temp.commit()
    conn_temp.close()

    insert_multiple_products()

Bestaande gegevens verwerken (bijwerken/negeren)

Wat doe je als je gegevens extraheert die misschien al in je database staan? Over het algemeen heb je twee opties:

  • Duplicaten negeren: gebruik de SQL-syntaxis INSERT OR IGNORE INTO als een unieke beperking (zoals onze url TEXT UNIQUE) zou worden geschonden.
  • Bestaande gegevens bijwerken: gebruik de SQL-instructie UPDATE om een bestaand record aan te passen in plaats van een nieuw record in te voegen wanneer er een overeenkomst wordt gevonden.

De juiste strategie hangt ervan af of nieuwe gegevens oude gegevens moeten overschrijven of dat de oude gegevens gewoon behouden moeten blijven.

Betrouwbare interacties: vastleggen en sluiten

Onthoud altijd het volgende:

  • conn.commit(): hiermee sla je je wijzigingen (zoals invoegingen of updates) op in het databasebestand. Zonder deze aanroep blijven je wijzigingen mogelijk niet bewaard!
  • conn.close(): sluit de databaseverbinding wanneer je klaar bent. Zo maak je resources vrij en zorg je voor gegevensintegriteit.
  • Foutafhandeling: plaats je databasebewerkingen in blokken met try...except...finally om fouten op te vangen en ervoor te zorgen dat de verbinding altijd wordt gesloten, ook als er een fout optreedt.

Snelle controle: gegevens invoegen met SQL

Je hebt geleerd hoe je verbinding maakt met een database en gegevens invoegt. Welke Python-methode is het meest geschikt om in één keer veel gegevensrijen in een SQL-tabel in te voegen?

Herhaling: SQL voor blijvende opslag

Goed gedaan! Je begrijpt nu de basisprincipes van het koppelen van je scripts voor gegevensextractie aan SQL-databases.

We hebben het volgende behandeld:

  • De voordelen van databases voor geëxtraheerde gegevens.
  • Verbinding maken met SQLite met behulp van Python's sqlite3.
  • Tabellen maken met CREATE TABLE.
  • Eén of meerdere records invoegen met INSERT INTO en executemany().
  • Beste werkwijzen, zoals commit() en close().

Deze kennis is essentieel voor het bouwen van betrouwbare en schaalbare oplossingen voor gegevensextractie!

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
12
Lessen
48

Veelgestelde vragen

Is de les “Integratie met databases (SQL)” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Webscraping en bots, waaronder “Integratie met databases (SQL)”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Webscraping en bots bevat in totaal 4 lessen.

Wat leer ik in “Integratie met databases (SQL)”?

Leer hoe u uw scr scripts met SQL-databases (bijvoorbeeld SQLite en PostgreSQL) verbindt voor gestructureerde gegevensopslag. Je oefent met Webscraping en bots door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Webscraping en bots te beginnen?

Ervaring vooraf is niet nodig. Webscraping en bots op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Integratie met databases (SQL)”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Webscraping en bots?

Ja. Elke les over Webscraping en bots bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Gegevens opslaan in CSV/JSON
  2. Integratie met databases (SQL)
  3. Cloudopslagoplossingen
  4. Gegevens opslaan in NoSQL-databases
← Terug naar Webscraping en bots