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 en rekke tilfeller som datavitenskap, nettverk, IT-automatisering, penetrasjonstesting og mange flere. Den har også en enkel syntaks som gjør det mulig for utviklere som kjenner andre programmeringsspråk å tilpasse seg å bruke Python uten problemer.Data er overalt, og et bredt spekter av programvareapplikasjoner 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 relasjonell databasemotor 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 kjøre 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 å opprette en forbindelse til å opprette databaser, lese databaser, oppdatere og fjerne databaser.

La oss starte med å installere SQLite:

Installere SQLite og Python

Avhengig av Linux-distribusjon, kan du laste ned SQLite-arkivet fra https: // www.sqlite.org / nedlasting.html eller bruk pakkebehandling.

Slik installerer du det på Debian:

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

Deretter bør du ha den nyeste versjonen av Python3 installert. Python skal 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 innebygd eller en samling for å utføre funksjoner på databaser.

For å starte SQLite-skallet, bruk kommandoen:

$ sqlite

SQLite versjon 2.8.17 Skriv inn “.hjelp ”for instruksjoner

sqlite>

Dette skal starte SQLite-skallet med en melding som lar deg skrive inn kommandoer. Start med å skrive kommandoen .hjelp til å se skallhjelpen.

sqlite> .hjelp
.databaser Liste over navn og filer på vedlagte databaser
.dump ?BORD?… Dump databasen i et tekstformat
.echo ON | OFF Slå kommandoekko av eller på
.avslutte Avslutt dette programmet
.forklar PÅ | AV Slå utdatamodus som passer for EXPLAIN på eller av.
.topptekst (er) PÅ | AV Slå skjermen på topptekstene på eller av
.hjelp Vis denne meldingen
.indices TABLE Vis navn på alle indeksene på TABLE
.mode MODE Still modus til en av "linje (r)", "kolonne (r)",
"sett inn", "liste" eller "html"
----------------------------------------------------------------------

For å gå ut av SQLite-skallet, bruk .avslutte kommandoen.

sqlite> .slutte

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

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

Koble til en database

La oss nå bruke Python og SQLite3-moduler til å samhandle med SQLite-databaser. Det er godt å merke seg at det finnes andre Python-moduler du kan bruke til å samhandle med SQLite. SQLite3 er imidlertid enkelt og følger med Python.

Vurder skriptet nedenfor for å koble til SQLite-databasen.

Vi starter med å importere SQLite- og Error-modulene.
I linje 3 lager vi en connect_db () -funksjon som tar databasens bane som argument.
Den neste delen inkluderer en prøve / feilblokk. Den første delen tar databasestien som argument og oppretter en forbindelse. Merk at hvis spesifisert database ikke eksisterer i SQLite, blir den opprettet automatisk.
Feilblokken prøver å fange unntak og skriver dem ut til brukeren.
I sluttlinjen kaller vi connect_db-funksjonen og sender stien til databasen vi vil bruke eller opprette.

MERK: Hvis du vil opprette en minnedatabase i stedet for en disk, kan du spesifisere: minne i tilkoblingsobjektet.

sqlite3.koble til (“: minne”)

SQLite Create Table

I SQLite kan vi bruke SQL-skallet til å lage tabeller ved hjelp av CREATE TABLE Query. Den generelle syntaksen er som:

OPPRETT TABELL databasenavn.tabellnavn (
kolonnenavn datatype PRIMÆR NØKKEL (kolonne (r)),
kolonne2_navn datatype,
… KolonneN_navn datatype,
);

Jeg vil ikke dykke inn i å lage tabeller ved hjelp av SQLite shell, da vårt primære fokus er Python. Vurder SQL Lite-dokumentasjonen fra ressursen nedenfor for å lære mer. For å bruke Python- og sqlite3-modulene til å lage databasetabeller, må vi bruke markørobjektet og utføre SQL-spørres funksjoner. Tenk på koden nedenfor:

importere sqlite3 fra sqlite3 importfeil
def connect_db (db_path):
tilkobling = Ingen
prøve:
tilkobling = sqlite3.koble til (db_path)
skriv ut ("Database koblet til")
unntatt feil som e:
utskrift (f "Det har oppstått en feil: e")
returner tilkobling def run_query (tilkobling, sql_query):
markør = tilkobling.markør ()
prøve:
markøren.kjør (sql_query)
forbindelse.begå()
skriv ut ("SQL Query Run Successfully… [OK]")
unntatt feil som e:
skriv ut (f "Søket mislyktes ... e")
spørring = "" "
OPPRETT TABELL HVIS IKKE EKSISTER viser (
id INTEGER PRIMÆR NØKKEL AUTOINKREM,
navn TEKST IKKE NULL,
år INTGER,
sjanger TEKST,
land TEKST
);
"" "
run_query (connection = connect_db ("/ home / user / Desktop / sql.sqlite "), sql_query = spørring)

La oss nå diskutere hva koden ovenfor gjør - finner den første funksjonen som er forklart ovenfor (se). I den andre funksjonen, opprette, sender vi tilkoblingen og spørringen som skal utføres som parametere. Følgende linjer oppretter et markørobjekt som vi vil bruke til å kalle utføringsmetoden. Som nevnt ovenfor, kaller de neste linjene markørens objekt for å utføre metoden og ring pass spørringen som parameter. Blokken skriver også ut en melding om vellykket Query-kjøring. Når spørringen er utført vellykket, ber vi SQLite bruke kommittemetoden for å lagre endringene i databasen. Den unntatte 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 ned i funksjonen run_query () vi brukte til å opprette, da den kan kjøre ethvert SQLite-spørsmål vi sender til det. Imidlertid bruker vi INSERT INTO-spørringen for å legge til data i tabellen.

Tenk på blokken nedenfor:

add_shows = "" "
INSERT I
viser (id, navn, år, sjanger, land)
VERDIER
("101", "Brooklyn Nine-Nine", "2013", "komedie", "USA"),
("201", "Star-Trek: Discovery", "2017", "Sci-Fi", "USA"),
("301", "Star-Trek: Picard", "2020", "Sci-Fi", "USA");
"" "run_query (connection = connect_db (" / home / user / Desktop / sql.sqlite "), sql_query = add_shows)

Vi må nå ringe run_query-funksjonen og legge til passet spørringen add_shows for å sette inn data i showtabellen. Forsikre deg om at tabellen du setter inn data i eksisterer for å unngå å få feil.

SQLite Slett poster

Du kan også bruke funksjonen run_query () for å fjerne poster fra den angitte tabellen. Alt du trenger er å angi spørringen som SLETT FRA.

Vurder følgende underspørring:

remove = "SLETT FRA viser HVOR navn = 'Brooklyn Nine-Nine'" run_query (connection = connect_db ("/ home / user / Deskop / sql).sqlite "), sql_query = fjern)

Spørringen ovenfor fjerner showet "Brooklyn Nine-Nine" fra showtabellen.

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 fra denne veiledningen, 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 komme deg i gang med å lære andre teknologier som SQLAlchemy og slikt.