Hvordan få tilgang til SQLite fra Python

Python er et populært og robust programmeringsspråk rikt på funksjoner som gjør det brukbart i et bredt spekter av tilfeller som datavitenskap, nettverk, IT -automatisering, penetrasjonstesting og mange flere. Den har også en enkel syntaks som lar utviklere som kjenner andre programmeringsspråk å tilpasse seg å bruke Python med letthet.Data er overalt, og et bredt spekter av programvare -applikasjoner samhandler med data ved hjelp av et databasestyringssystem. SQLite er et av de mest populære databasestyringssystemene i Python.

SQLite er en enkel, kraftig, åpen kildekode- og relasjonsdatabasemotor som støtter store programvareapplikasjoner og innebygde systemer. SQLite er frittstående og krever minimal konfigurasjon, noe som gjør det ekstra enkelt å sette opp og løpe med minimal tid. Som standard kommer Python innebygd med en SQLite-modul (SQLite3), en veldig intuitiv modul for å jobbe med SQLite-databaser i Python.

I denne opplæringen vil vi se på hvordan du bruker Python til å jobbe med SQLite -databaser. Fra å etablere en forbindelse til å lage databaser, lese databaser, oppdatere og fjerne databaser.

La oss starte med å installere SQLite:

Installere sqlite og python

Avhengig av Linux -distribusjonen din, kan du laste ned SQLite -arkivet fra https: // www.sqlite.org/nedlasting.HTML eller bruk pakkebehandleren.

For å installere den på Debian:

sudo apt-get oppdatering
sudo apt -get install sqlite -y

Deretter bør du ha den siste versjonen av Python3 installert. Python bør allerede være forhåndsinstallert i distribusjonen din som standard.

Sqlite Shell

Standardmetoden for å samhandle med SQLite -databaser er å bruke skallet. Skallet lar deg utføre SQL -kommandoer inline eller en samling for å utføre funksjoner på databaser.

For å starte SQLite -skallet, bruk kommandoen:

$ sqlite

SQLite versjon 2.8.17 Enter “.hjelp ”for instruksjoner

SQLite>

Dette bør lansere SQLite -skallet med en ledetekst som lar deg legge inn kommandoer. Start med å skrive kommandoen .Hjelp til å se skallhjelpen.

SQLite> .hjelp
.Databaser viser navn og filer med vedlagte databaser
.dump ?BORD?... dump databasen i et tekstformat
.ekko på | av Turn Command Echo av eller på
.Avslutt exit dette programmet
.Forklar på | Off Turn Output -modus egnet for å forklare av eller på.
.header (er) på | av sving visning av overskrifter av eller på
.Hjelp med å vise denne meldingen
.Indekser Tabell viser navn på alle indekser på tabellen
.Modus Mode Set Mode til en av "Linje (er)", "Kolonne (er)",
"Sett inn", "liste" eller "html"
----------------------------------------------------------------------

For å gå ut fra sqlite -skallet, bruk .Slutt kommandoen.

SQLite> .slutte

Det er andre funksjoner og operasjoner du kan bruke i SQLite -skallet. For å se alle databasene, kan du for eksempel bruke .Databasekommando.

Jeg anbefaler på det sterkeste at du eksperimenterer med SQLite -skallet og blir kjent, da det vil tillate deg å forstå hvordan du bruker SQLite3 -modulen i Python.

Koble til en database

La oss nå bruke Python- og Sqlite3 -moduler for å samhandle med SQLite -databaser. Det er godt å merke seg at det er andre Python -moduler du kan bruke til å samhandle med SQLite. SQLite3 er imidlertid enkel og leveres med python.

Tenk på skriptet nedenfor for å koble til SQLite -databasen.

Importer SQLite3 fra SQLite3 Importfeil
def connect_db (db_path):
tilkobling = ingen prøv:
Tilkobling = SQLite3.Connect (db_path)
print ("Database tilkoblet vellykket")
Bortsett fra feil som e:
Print (F "Det har oppstått en feil: e")
returforbindelse
Connect_DB ("/Home/User/Desktop/Demo.sqlite ")

Vi starter med å importere SQLite- og feilmodulene.
På linje 3 lager vi en Connect_DB () -funksjon som tar databasens vei som argument.
Neste del inkluderer en prøve/feilblokk. Den første delen tar databasestien som argumentasjonen og etablerer en forbindelse. Merk, i SQLite, hvis den spesifiserte databasen ikke eksisterer, blir den opprettet automatisk.
Feilblokken prøver å fange unntak og skriver dem ut til brukeren.
I den endelige linjen kaller vi Connect_DB -funksjonen og gir banen til databasen vi ønsker å bruke eller opprette.

MERK: Hvis du vil opprette en minnedatabase i stedet for en disk, kan du spesifisere: Memory in the Connect OBJ.

SQLite3.Connect (“: Memory”)

SQLite Create Table

I SQLite kan vi bruke SQL -skallet til å lage tabeller ved hjelp av Create Table -spørringen. Den generelle syntaksen er som:

Opprett tabelldatabase_navn.tabell_navn (
Kolonne_navn Datatype Primærnøkkel (kolonne (er),
Column2_Name DataType,
… Columnn_name DataType,
);

Jeg vil ikke dykke ned i å lage tabeller ved hjelp av SQLite Shell, da vårt hovedfokus er Python. Vurder SQL Lite -dokumentasjonen fra ressursen nedenfor for å lære mer. For å bruke Python- og Sqlite3 -modulene for å lage databasetabeller, må vi bruke markørobjektet og utføre SQL Queries 'funksjoner. Tenk på koden nedenfor:

Importer SQLite3 fra SQLite3 Importfeil
def connect_db (db_path):
Tilkobling = ingen
prøve:
Tilkobling = SQLite3.Connect (db_path)
print ("Database tilkoblet vellykket")
Bortsett fra feil som e:
Print (F "Det har oppstått en feil: e")
Return Connection def run_query (tilkobling, sql_query):
Markør = tilkobling.markør ()
prøve:
markør.Utfør (SQL_QUERY)
forbindelse.begå()
Print ("SQL Query Run vellykket ... [OK]")
Bortsett fra feil som e:
print (f "spørring mislyktes ... e")
spørring = "" "
Lag tabell hvis ikke eksisterer show (
id heltall primær nøkkel autoincrement,
Navn tekst ikke null,
År intger,
Sjangertekst,
Landstekst
);
"" "
run_query (tilkobling = connect_db ("/home/user/desktop/sql.sqlite "), sql_query = spørring)

La oss nå diskutere hva koden ovenfor finner den første funksjonen som er forklart ovenfor (se). I den andre funksjonen, opprette, passerer vi forbindelsen og spørringen for å utføre som parametere. Følgende linjer lager et markørobjekt som vi vil bruke til å kalle utførelsesmetoden. Som nevnt ovenfor, kaller de neste linjene markørens objekt for å utføre metoden og ringe passere spørringen som parameter. Blokken skriver også ut en melding om vellykket utførelse. Når spørringen er utført vellykket, ber vi SQLite om å bruke Commit -metoden for å lagre endringene i databasen. Unntak av blokken fanger unntak og skriver ut feilmeldingen til brukeren. Til slutt oppretter vi spørringen for å utføre ved hjelp av enkel SQLite -syntaks.

SQLite Sett inn poster

For å legge til data i SQLite -databasen, kan vi dykke inn i Run_Query () -funksjonen vi brukte til å lage, da den kan kjøre hvilken. Vi bruker imidlertid innsatsen i spørring for å legge til data i tabellen.

Tenk på blokken nedenfor:

add_shows = "" "
Sett inn i
show (id, navn, år, sjanger, land)
Verdier
("101", "Brooklyn Nine-Nine", "2013", "Comedy", "USA"),
("201", "Star-Trek: Discovery", "2017", "Sci-Fi", "USA"),
("301", "Star-Trek: Picard", "2020", "Sci-Fi", "USA");
"" "run_query (tilkobling = connect_db ("/home/user/desktop/sql.sqlite "), sql_query = add_shows)

Vi må nå ringe RUN_QUERY -funksjonen og legge til PASS SPØRSMÅLEN. Forsikre deg om at tabellen du setter inn data i eksisterer for å unngå å få en feil.

SQLite sletter poster

Du kan også bruke funksjonen Run_Query () for å fjerne poster fra den spesifiserte tabellen. Alt du trenger er å angi spørringen som sletting fra.

Tenk på følgende underforespørsel:

Fjern = "Slett fra show Where Name = 'Brooklyn Nine-Nine'" Run_Query (Connection = Connect_DB ("/Home/User/Deskop/SQL.sqlite "), sql_query = fjerne)

Ovennevnte spørring fjerner showet “Brooklyn Nine-Nine” fra show-tabellen.

Konklusjon

Denne opplæringen har lært deg hvordan du bruker Python for å få tilgang til og samhandle med SQLite -databaser. Fra det du har lært av denne opplæringen, kan du nå opprette funksjoner, koble til SQLite -databaser, opprette tabeller, sette inn data og slette dem. Selv om dette er en startguide for å jobbe med SQLite i Python, bør det få deg til å lære andre teknologier som Sqlalchemy og slikt.