Integratie met databases (SQL)
Leer hoe u uw scr scripts met SQL-databases (bijvoorbeeld SQLite en PostgreSQL) verbindt voor gestructureerde gegevensopslag.
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 INTOals een unieke beperking (zoals onzeurl TEXT UNIQUE) zou worden geschonden. - Bestaande gegevens bijwerken: gebruik de SQL-instructie
UPDATEom 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...finallyom 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 INTOenexecutemany(). - Beste werkwijzen, zoals
commit()enclose().
Deze kennis is essentieel voor het bouwen van betrouwbare en schaalbare oplossingen voor gegevensextractie!
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
- Gegevens opslaan in CSV/JSON
- Integratie met databases (SQL)
- Cloudopslagoplossingen
- Gegevens opslaan in NoSQL-databases