Sei sulla pagina 1di 34

GUIDA

SQLite con Python

SQLite Python: creazione di un nuovo


database

Riepilogo : in questo tutorial imparerai come creare un nuovo


database SQLite da un programma Python.

Quando ti connetti a un file di database SQLite che non esiste,


SQLite crea automaticamente il nuovo database per te.

Per creare un database, innanzitutto, devi creare un Connection


oggetto che rappresenti il database utilizzando la connect()
funzione del modulo sqlite3.
Ad esempio, il seguente programma Python crea un nuovo file di
database pythonsqlite.db nella c:\sqlite\dbcartella.
Notare che è necessario creare la cartella c: \ sqlite \ db prima di
eseguire il programma. Oppure puoi posizionare il file del database
in una cartella a tua scelta.

import sqlite3
from sqlite3 import Error

def create_connection(db_file):
""" create a database connection to a SQLite database """
conn = None
try:
conn = sqlite3.connect(db_file)
print(sqlite3.version)
except Error as e:
print(e)
finally:
if conn:
conn.close()

if __name__ == '__main__':
create_connection(r"C:\sqlite\db\pythonsqlite.db")

In questo codice:

Innanzitutto, definiamo una funzione chiamata create_connection()


che si connette a un database SQLite specificato dal file di
database db_file. All'interno della funzione, chiamiamo la connect()
funzione del modulo sqlite3.
La connect() funzione apre una connessione a un database SQLite.
Restituisce un Connection oggetto che rappresenta il database.
Utilizzando l' Connection oggetto, è possibile eseguire varie
operazioni sul database.
Nel caso si verifichi un errore, lo intercettiamo all'interno del try
except blocco e visualizziamo il messaggio di errore. Se tutto va
bene, viene visualizzata la versione del database SQLite.
È buona norma di programmazione chiudere sempre la
connessione al database una volta completata.

In secondo luogo, passiamo il percorso del file di database alla


create_connection() funzione per creare il database. Si noti che il
prefisso ’r’ in r"C:\sqlite\db\pythonsqlite.db" indica a Python che
stiamo passando una stringa non elaborata.
Eseguiamo il programma e controlliamo la c:\sqlite\dbcartella.
Se salti il percorso della cartella c:\sqlite\db, il programma creerà il
file di database nella directory di lavoro corrente (CWD).
Se si passa il nome del file :memory: alla connect() funzione del
modulo sqlite3, verrà creato un nuovo database che risiede nella
memoria (RAM) invece di un file di database su disco.

Il seguente programma crea un database SQLite nella memoria.

import sqlite3
from sqlite3 import Error

def create_connection():
""" create a database connection to a database that resides
in the memory
"""
conn = None;
try:
conn = sqlite3.connect(':memory:')
print(sqlite3.version)
except Error as e:
print(e)
finally:
if conn:
conn.close()

if __name__ == '__main__':
create_connection()
In questo tutorial, hai imparato come creare un database SQLite su
disco e in memoria da un programma Python utilizzando il modulo
sqlite3.
SQLite Python: creazione di tabelle

Riepilogo : in questo tutorial, ti mostreremo come creare tabelle nel


database SQLite dal programma Python utilizzando il modulo
sqlite3.

Per creare una nuova tabella in un database SQLite da un


programma Python, utilizzare i seguenti passaggi:

1. Innanzitutto, crea un Connection oggetto utilizzando la


connect() funzione del modulo sqlite3.
2. In secondo luogo, crea un Cursor oggetto chiamando il
cursor() metodo Connection dell'oggetto.
3. Terzo, passare la CREATE TABLE istruzione al execute()
metodo Cursor dell'oggetto ed eseguire questo metodo.

Per la dimostrazione, creeremo due tabelle: projects e tasks come


mostrato nel seguente diagramma del database:

Le seguenti CREATE TABLE istruzioni creano queste due tabelle:

-- projects table
CREATE TABLE IF NOT EXISTS projects (
id integer PRIMARY KEY,
name text NOT NULL,
begin_date text,
end_date text
);

-- tasks table
CREATE TABLE IF NOT EXISTS tasks (
id integer PRIMARY KEY,
name text NOT NULL,
priority integer,
project_id integer NOT NULL,
status_id integer NOT NULL,
begin_date text NOT NULL,
end_date text NOT NULL,
FOREIGN KEY (project_id) REFERENCES projects (id)
);

Vediamo come creare nuove tabelle in Python.

Innanzitutto, sviluppa una funzione chiamata create_connection()


che restituisca un Connection oggetto che rappresenta un database
SQLite specificato dal parametro del file di database db_file.

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
return conn
except Error as e:
print(e)
return conn

In secondo luogo, sviluppa una funzione denominata create_table()


che accetti un Connection oggetto e un'istruzione SQL. All'interno
della funzione, chiamiamo il execute() metodo Cursor dell'oggetto
per eseguire la CREATE TABLE istruzione.

def create_table(conn, create_table_sql):


""" create a table from the create_table_sql statement
:param conn: Connection object
:param create_table_sql: a CREATE TABLE statement
:return:
"""
try:
c = conn.cursor()
c.execute(create_table_sql)
except Error as e:
print(e)

Terzo, crea una main() funzione per creare le tabelle projectse e


tasks.

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

sql_create_projects_table = """ CREATE TABLE IF NOT EXISTS


projects (
id integer PRIMARY KEY,
name text NOT NULL,
begin_date text,
end_date text
); """

sql_create_tasks_table = """CREATE TABLE IF NOT EXISTS


tasks (
id integer PRIMARY KEY,
name text NOT NULL,
priority integer,
status_id integer NOT NULL,
project_id integer NOT NULL,
begin_date text NOT NULL,
end_date text NOT NULL,
FOREIGN KEY (project_id) REFERENCES
projects (id)
);"""

# create a database connection


conn = create_connection(database)

# create tables
if conn is not None:
# create projects table
create_table(conn, sql_create_projects_table)

# create tasks table


create_table(conn, sql_create_tasks_table)
else:
print("Error! cannot create the database connection.")

Quarto, esegui la main() funzione.

if __name__ == '__main__':
main()

Ecco il programma completo:

import sqlite3
from sqlite3 import Error
def create_connection(db_file):
""" create a database connection to the SQLite database
specified by db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
return conn
except Error as e:
print(e)

return conn

def create_table(conn, create_table_sql):


""" create a table from the create_table_sql statement
:param conn: Connection object
:param create_table_sql: a CREATE TABLE statement
:return:
"""
try:
c = conn.cursor()
c.execute(create_table_sql)
except Error as e:
print(e)

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

sql_create_projects_table = """ CREATE TABLE IF NOT EXISTS


projects (
id integer PRIMARY KEY,
name text NOT NULL,
begin_date text,
end_date text
); """

sql_create_tasks_table = """CREATE TABLE IF NOT EXISTS


tasks (
id integer PRIMARY KEY,
name text NOT NULL,
priority integer,
status_id integer NOT NULL,
project_id integer NOT NULL,
begin_date text NOT NULL,
end_date text NOT NULL,
FOREIGN KEY (project_id) REFERENCES
projects (id)
);"""

# create a database connection


conn = create_connection(database)

# create tables
if conn is not None:
# create projects table
create_table(conn, sql_create_projects_table)

# create tasks table


create_table(conn, sql_create_tasks_table)
else:
print("Error! cannot create the database connection.")

if __name__ == '__main__':
main()

Verifichiamo se il programma ha creato correttamente quelle tabelle


nel pythonsqlite.db database.
Innanzitutto, avvia la riga di comando e connettiti al pythonsqlite.db
database:
> sqlite3 c: \ sqlite \ db \ pythonsqlite.db

Quindi, utilizzare il tables comando per visualizzare le tabelle nel


database.

sqlite> .tables
projects tasks

Come puoi vedere chiaramente dall'output, abbiamo le tabelle


projectse e tasks nel pythonsqlite.db database. E il programma
funziona come previsto.

In questo tutorial, hai imparato come creare nuove tabelle nel


database SQLite utilizzando il execute() metodo Cursor
dell'oggetto.
SQLite Python: inserimento di dati

Riepilogo : in questo tutorial imparerai come inserire righe in una


tabella nel database SQLite da un programma Python utilizzando il
modulo sqlite3.

Per inserire righe in una tabella nel database SQLite, utilizzare i


seguenti passaggi:

1. Innanzitutto, connettiti al database SQLite creando un oggetto


Connection.
2. In secondo luogo, crea un Cursor oggetto chiamando il
metodo del cursore Connection dell'oggetto.
3. Terzo, eseguire un'istruzione INSERT. Se vuoi passare
argomenti INSERT all'istruzione, usa il punto interrogativo (?)
Come segnaposto per ogni argomento.

SQLite Python - esempio di inserimento di righe

Inseriamo un nuovo progetto nella projects tabella e alcune attività


nella tasks tabella che abbiamo creato.

Innanzitutto, crea una nuova funzione per stabilire una connessione


al database a un database SQLitte specificato dal file del database.

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)

return conn

Successivamente, sviluppa una funzione per inserire un nuovo


progetto nella projects tabella.

def create_project(conn, project):


"""
Create a new project into the projects table
:param conn:
:param project:
:return: project id
"""
sql = ''' INSERT INTO projects(name,begin_date,end_date)
VALUES(?,?,?) '''
cur = conn.cursor()
cur.execute(sql, project)
conn.commit()
return cur.lastrowid

In questa funzione, abbiamo utilizzato l'   lastrowid attributo Cursor


dell'oggetto per recuperare l'id generato.

Quindi, sviluppa un'altra funzione per inserire righe nella tasks


tabella.

def create_task(conn, task):


"""
Create a new task
:param conn:
:param task:
:return:
"""
sql = ''' INSERT INTO
tasks(name,priority,status_id,project_id,begin_date,end_date)
VALUES(?,?,?,?,?,?) '''
cur = conn.cursor()
cur.execute(sql, task)
conn.commit()

return cur.lastrowid

Successivamente, sviluppa la main() funzione che crea un nuovo


progetto e due attività associate al progetto.

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
# create a new project
project = ('Cool App with SQLite & Python', '2015-01-01',
'2015-01-30');
project_id = create_project(conn, project)

# tasks
task_1 = ('Analyze the requirements of the app', 1, 1,
project_id, '2015-01-01', '2015-01-02')
task_2 = ('Confirm with user about the top requirements', 1, 1,
project_id, '2015-01-03', '2015-01-05')

# create tasks
create_task(conn, task_1)
create_task(conn, task_2)
E chiama la main()funzione:

if __name__ == '__main__':
main()

Ecco il programma completo:

import sqlite3
from sqlite3 import Error

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)

return conn

def create_project(conn, project):


"""
Create a new project into the projects table
:param conn:
:param project:
:return: project id
"""
sql = ''' INSERT INTO projects(name,begin_date,end_date)
VALUES(?,?,?) '''
cur = conn.cursor()
cur.execute(sql, project)
conn.commit()
return cur.lastrowid

def create_task(conn, task):


"""
Create a new task
:param conn:
:param task:
:return:
"""

sql = ''' INSERT INTO


tasks(name,priority,status_id,project_id,begin_date,end_date)
VALUES(?,?,?,?,?,?) '''
cur = conn.cursor()
cur.execute(sql, task)
conn.commit()
return cur.lastrowid

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
# create a new project
project = ('Cool App with SQLite & Python', '2015-01-01',
'2015-01-30');
project_id = create_project(conn, project)

# tasks
task_1 = ('Analyze the requirements of the app', 1, 1,
project_id, '2015-01-01', '2015-01-02')
task_2 = ('Confirm with user about the top requirements', 1, 1,
project_id, '2015-01-03', '2015-01-05')

# create tasks
create_task(conn, task_1)
create_task(conn, task_2)

if __name__ == '__main__':
main()

Infine, connettiti al database tramite la shell sqlite3 e interroga i dati


dalle tabelle projects e tasks per verificare se i dati sono stati inseriti
correttamente.

Usa questi comandi per formattare l'output:

sqlite> .header on
sqlite> .mode column

E usa questa SELECT istruzione per interrogare i dati dalla projects


tabella:

SELECT * FROM projects;


E usa la seguente SELECT dichiarazione per interrogare i dati dalla
tasks tabella:

SELECT * FROM tasks;

In questo tutorial, hai imparato come inserire righe nelle tabelle nel
database SQLite da un programma Python.
SQLite Python: modifica dei dati

Riepilogo : in questo tutorial, ti mostreremo come aggiornare i dati


nel database SQLite da un programma Python utilizzando il modulo
sqlite3.

Per aggiornare i dati in una tabella da un programma Python, segui


questi passaggi:

1. Innanzitutto, crea una connessione al database al database


SQLite utilizzando la connect() funzione. Una volta creata la
connessione al database, è possibile accedere al database
utilizzando l' Connection oggetto.
2. In secondo luogo, crea un Cursor oggetto chiamando il
cursor() metodo Connection dell'oggetto.
3. Terzo, eseguire l' UPDATE istruzione chiamando il execute()
metodo Cursor dell'oggetto.

In questo esempio aggiorneremo la priorità, la data di inizio e la


data di fine di un'attività specifica nella tasks tabella.

Per creare una connessione al database, si utilizza la seguente


create_connection() funzione:

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by the db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)

return conn

Questa update_task() funzione aggiorna un'attività specifica:

def update_task(conn, task):


"""
update priority, begin_date, and end date of a task
:param conn:
:param task:
:return: project id
"""
sql = ''' UPDATE tasks
SET priority = ? ,
begin_date = ? ,
end_date = ?
WHERE id = ?'''
cur = conn.cursor()
cur.execute(sql, task)
conn.commit()

La seguente main() funzione crea una connessione al database


situato nella cartella C: \ sqlite \ db \ pythonsqlite.db e chiama la
update_task() funzione per aggiornare un'attività con ID 2:

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
update_task(conn, (2, '2015-01-04', '2015-01-06', 2))

if __name__ == '__main__':
main()
Ecco il programma completo:

import sqlite3
from sqlite3 import Error

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by the db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)

return conn

def update_task(conn, task):


"""
update priority, begin_date, and end date of a task
:param conn:
:param task:
:return: project id
"""
sql = ''' UPDATE tasks
SET priority = ? ,
begin_date = ? ,
end_date = ?
WHERE id = ?'''
cur = conn.cursor()
cur.execute(sql, task)
conn.commit()

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
update_task(conn, (2, '2015-01-04', '2015-01-06', 2))

if __name__ == '__main__':
main()

Dopo aver eseguito il programma, puoi connetterti al database


tramite la shell dei comandi sqlite3:

Usa questi comandi per formattare l'output:

sqlite> .header on
sqlite> .mode column

E usa la seguente dichiarazione per ottenere l'attività con id 2:

SELECT * FROM tasks WHERE id = 2;


Come mostrato chiaramente dallo screenshot, l'attività con ID 2 è
stata aggiornata correttamente.

In questo tutorial, hai imparato come aggiornare i dati in una tabella


da un programma Python.
SQLite Python: query sui dati

Riepilogo : in questo tutorial, ti mostreremo passo dopo passo


come interrogare i dati in SQLite da Python.

Per eseguire query sui dati in un database SQLite da Python,


utilizzare questi passaggi:

1. Innanzitutto, stabilisci una connessione al database SQLite


creando un Connection oggetto.
2. Successivamente, crea un Cursor oggetto utilizzando il
metodo del cursore Connection dell'oggetto.
3. Quindi, esegui una SELECT istruzione.
4. Successivamente, chiama il fetchall() metodo dell'oggetto
cursore per recuperare i dati.
5. Infine, fai scorrere il cursore ed elabora ogni riga
individualmente.

Nel seguente esempio, useremo la tasks tabella creata nel tutorial


sulla creazione di tabelle.

Innanzitutto, crea una connessione a un database SQLite


specificato da un file:
def create_connection(db_file):
""" create a database connection to the SQLite database
specified by the db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)

return conn

Questa funzione seleziona tutte le righe dalla tabella delle attività e


visualizza i dati:

def select_all_tasks(conn):
"""
Query all rows in the tasks table
:param conn: the Connection object
:return:
"""
cur = conn.cursor()
cur.execute("SELECT * FROM tasks")

rows = cur.fetchall()

for row in rows:


print(row)

Nella select_all_tasks() funzione, abbiamo creato un cursore,


eseguito l' SELECT istruzione e chiamato fetchall() per recuperare
tutte le attività dalla tasks tabella.
Questa funzione interroga le attività per priorità:

def select_task_by_priority(conn, priority):


"""
Query tasks by priority
:param conn: the Connection object
:param priority:
:return:
"""
cur = conn.cursor()
cur.execute("SELECT * FROM tasks WHERE priority=?",
(priority,))

rows = cur.fetchall()

for row in rows:


print(row)

Nella select_task_by_priority() funzione, abbiamo selezionato le


attività in base a una particolare priorità. Il punto interrogativo (?)
nella query è il segnaposto. Quando il cursore ha eseguito la
SELECT istruzione, ha sostituito il punto interrogativo (?) con l'
priority argomento. Il fetchall() metodo ha recuperato tutte le attività
corrispondenti in base alla priorità.

Questa funzione main () crea una connessione al database


C:\sqlite\db\pythonsqlite.db e chiama le funzioni per interrogare
tutte le righe della tasks tabella e selezionare le attività con priorità
1:

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
print("1. Query task by priority:")
select_task_by_priority(conn, 1)

print("2. Query all tasks")


select_all_tasks(conn)

Ecco il programma completo:

import sqlite3
from sqlite3 import Error

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by the db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)

return conn

def select_all_tasks(conn):
"""
Query all rows in the tasks table
:param conn: the Connection object
:return:
"""
cur = conn.cursor()
cur.execute("SELECT * FROM tasks")

rows = cur.fetchall()

for row in rows:


print(row)

def select_task_by_priority(conn, priority):


"""
Query tasks by priority
:param conn: the Connection object
:param priority:
:return:
"""
cur = conn.cursor()
cur.execute("SELECT * FROM tasks WHERE priority=?",
(priority,))

rows = cur.fetchall()

for row in rows:


print(row)

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
print("1. Query task by priority:")
select_task_by_priority(conn, 1)

print("2. Query all tasks")


select_all_tasks(conn)
if __name__ == '__main__':
main()

In questo tutorial, hai imparato come sviluppare un programma


Python per eseguire query sui dati dalle tabelle in un database
SQLite.
SQLite Python: eliminazione (delete)
di dati

Riepilogo : questo tutorial mostra come eliminare i dati nel


database SQLite da un programma Python utilizzando il modulo
sqlite3.

Per eliminare i dati nel database SQLite da un programma Python,


utilizzare i seguenti passaggi:

1. Innanzitutto, stabilire una connessione al database SQLite


creando un Connection oggetto utilizzando la connect() funzione.
2. Secondo, per eseguire DELETE un'istruzione, è necessario
creare un Cursor oggetto utilizzando il cursor() metodo
Connection dell'oggetto.
3. Terzo, eseguire l' DELETE istruzione utilizzando il execute()
metodo Cursor dell'oggetto. Nel caso in cui desideri passare gli
argomenti all'istruzione, utilizza un punto interrogativo (?) per
ogni argomento.

La seguente create_connection() funzione stabilisce una


connessione al database a un database SQLite specificato da un
nome file di database:

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by the db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)

return conn

La seguente delete_task() funzione elimina un'attività nella tasks


tabella per id.

def delete_task(conn, id):


"""
Delete a task by task id
:param conn: Connection to the SQLite database
:param id: id of the task
:return:
"""
sql = 'DELETE FROM tasks WHERE id=?'
cur = conn.cursor()
cur.execute(sql, (id,))
conn.commit()

La delete_all_tasks() funzione seguente elimina tutte le righe nella


tasks tabella.

def delete_all_tasks(conn):
"""
Delete all rows in the tasks table
:param conn: Connection to the SQLite database
:return:
"""
sql = 'DELETE FROM tasks'
cur = conn.cursor()
cur.execute(sql)
conn.commit()
Questa main() funzione chiama la create_connection() funzione e la
delete_task() funzione per eliminare l'attività con ID 2 dalla tasks
tabella:

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
delete_task(conn, 2);
# delete_all_tasks(conn);

if __name__ == '__main__':
main()

Ecco il programma completo:

import sqlite3
from sqlite3 import Error

def create_connection(db_file):
""" create a database connection to the SQLite database
specified by the db_file
:param db_file: database file
:return: Connection object or None
"""
conn = None
try:
conn = sqlite3.connect(db_file)
except Error as e:
print(e)
return conn

def delete_task(conn, id):


"""
Delete a task by task id
:param conn: Connection to the SQLite database
:param id: id of the task
:return:
"""
sql = 'DELETE FROM tasks WHERE id=?'
cur = conn.cursor()
cur.execute(sql, (id,))
conn.commit()

def delete_all_tasks(conn):
"""
Delete all rows in the tasks table
:param conn: Connection to the SQLite database
:return:
"""
sql = 'DELETE FROM tasks'
cur = conn.cursor()
cur.execute(sql)
conn.commit()

def main():
database = r"C:\sqlite\db\pythonsqlite.db"

# create a database connection


conn = create_connection(database)
with conn:
delete_task(conn, 2);
# delete_all_tasks(conn);
if __name__ == '__main__':
main()

Si noti che è possibile commentare / annullare il commento alla


chiamata di funzione nella main() funzione per testare
singolarmente ciascuna funzione di eliminazione.

In questo tutorial, hai imparato come eliminare i dati nel database


SQLite da un programma Python utilizzando il modulo sqlite3.

Potrebbero piacerti anche