SQLite com Python: Um Tutorial para Iniciantes
Aprenda a usar o módulo sqlite3 do Python neste tutorial amigável para iniciantes. Crie bases de dados, tabelas, insira, atualize, selecione e apague dados
Se está a começar com Python e nunca trabalhou com bases de dados antes, não se preocupe. Este tutorial guia-o pelo SQLite passo a passo, com linguagem simples e exemplos pequenos e completos que pode executar você mesmo. No final, saberá criar uma base de dados, inserir dados, lê-los, atualizá-los e apagá-los, tudo a partir do Python.
O Que É o SQLite?
O SQLite é um motor de base de dados SQL pequeno, rápido e muito fiável, escrito em C. Ao contrário de outros sistemas de bases de dados, não precisa de um servidor separado. Não há nada para instalar ou configurar. A sua base de dados completa, incluindo todas as tabelas, índices, triggers e views, vive num único ficheiro no seu disco.
Isto traz algumas vantagens práticas:
Lê e escreve diretamente em ficheiros comuns.
O mesmo ficheiro de base de dados funciona em sistemas de 32 e 64 bits, e em diferentes arquiteturas de processador.
Está no domínio público, por isso pode usá-lo livremente em projetos comerciais ou privados.
É uma excelente escolha para aprender, para protótipos e para aplicações pequenas. Se o seu projeto crescer, pode migrar mais tarde para uma base de dados maior como PostgreSQL ou Oracle.
O Que É o Módulo sqlite3?
O Python já vem com um módulo incorporado chamado sqlite3. Não precisa de instalar nada com o pip. Este módulo foi desenvolvido por Gerhard Häring e segue a especificação DB-API 2.0 (PEP 249), o que significa que se comporta de forma padrão e consistente com outros módulos de bases de dados do Python.
Como faz parte da biblioteca padrão, pode começar a usá-lo imediatamente:
import sqlite3
Passo 1: Ligar a uma Base de Dados
A primeira coisa que faz com qualquer base de dados é ligar-se a ela.
import sqlite3 conn = sqlite3.connect('example.db')
Aqui podem acontecer duas coisas:
Se o ficheiro
example.dbnão existir, o SQLite cria-o automaticamente.Se o ficheiro já existir, o comando simplesmente abre uma ligação a ele.
Se preferir manter tudo em memória e evitar criar um ficheiro, use o nome especial :memory::
conn = sqlite3.connect(':memory:')
Uma base de dados em memória desaparece quando o programa termina. Isto é útil para experiências e testes.
Passo 2: Uma Função de Ligação Reutilizável
À medida que o seu projeto cresce, vai ligar-se à base de dados em vários sítios. É boa ideia escrever uma pequena função uma vez e reutilizá-la. Crie um ficheiro chamado create_con.py:
import sqlite3 from sqlite3 import Error def create_connection(db_file): """Cria uma ligação a uma base de dados SQLite.""" conn = None try: conn = sqlite3.connect(db_file) print(sqlite3.version) return conn except Error as e: print(f"Erro: {e}") return None if __name__ == '__main__': create_connection('sqlite.db')
Esta função tenta ligar-se à base de dados que passa como argumento. Se conseguir, imprime a versão do SQLite e devolve a ligação. Se algo correr mal, imprime o erro e devolve None.
Passo 3: Planear as Tabelas
Antes de escrever código, vamos decidir o que queremos guardar. O nosso exemplo é uma pequena biblioteca com duas tabelas:
authors guarda os autores:
id: uma chave primária única que identifica um autorname: o nome do autorborn_date: a data de nascimento do autor
books guarda os livros:
id: uma chave primária única que identifica um livrotitle: o título do livroauthor_id: o ID do autor (uma chave estrangeira que aponta paraauthors.id)
Aqui está a relação num diagrama simples:
┌─────────────┐ ┌─────────────┐ │ authors │ │ books │ ├─────────────┤ ├─────────────┤ │ id (PK) │◄────────│ id (PK) │ │ name │ │ title │ │ born_date │ │ author_id │ └─────────────┘ └─────────────┘
Esta é uma relação de um-para-muitos. Um autor pode ter muitos livros, mas cada livro pertence a apenas um autor.
Passo 4: Criar as Tabelas
Agora vamos criar as tabelas com SQL. As instruções SQL são:
-- tabela authors CREATE TABLE IF NOT EXISTS authors ( id integer PRIMARY KEY, name text NOT NULL, born_date text ); -- tabela books CREATE TABLE IF NOT EXISTS books ( id integer PRIMARY KEY, title text NOT NULL, author_id integer NOT NULL, FOREIGN KEY (author_id) REFERENCES authors (id) );
A parte IF NOT EXISTS significa que o comando não falha se a tabela já existir.
Coloque isto num ficheiro chamado create_tables.py:
import sqlite3 from sqlite3 import Error from create_con import create_connection DB = 'sqlite.db' conn = create_connection(DB) def create_table(conn, create_table_sql): try: c = conn.cursor() c.execute(create_table_sql) except Error as e: print(e) sql_create_authors_table = """ CREATE TABLE IF NOT EXISTS authors( id integer PRIMARY KEY, name text NOT NULL, born_date text ); """ sql_create_books_table = """ CREATE TABLE IF NOT EXISTS books( id integer PRIMARY KEY, title text NOT NULL, author_id integer NOT NULL, FOREIGN KEY (author_id) REFERENCES authors (id) ); """ if conn is not None: create_table(conn, sql_create_authors_table) create_table(conn, sql_create_books_table) else: print('Erro! Não é possível criar a base de dados!')
Uma nota rápida sobre o cursor que vê aqui: um cursor é um objeto que envia comandos SQL para a base de dados e permite ler os resultados. Pode pensar nele como um ponteiro que percorre as linhas dos resultados da sua consulta.
Passo 5: Inserir Dados
Para adicionar dados, usamos a instrução INSERT. O detalhe importante aqui é o uso de marcadores de posição (? ou marcadores nomeados como :title). Os marcadores protegem o seu código contra injeção de SQL e tornam as consultas mais limpas.
import sqlite3 from sqlite3 import Error from create_con import create_connection DB = 'sqlite.db' conn = create_connection(DB) cur = conn.cursor() def create_author(conn, author): sql = """INSERT INTO authors(name,born_date) VALUES(?,?)""" try: with conn: cur.execute(sql, author) except sqlite3.IntegrityError: print("não foi possível adicionar o autor") return cur.lastrowid def create_books(conn, books): sql = """INSERT INTO books(title,author_id) VALUES(:title,:author_id)""" try: with conn: cur.executemany(sql, books) except sqlite3.IntegrityError: print("não foi possível adicionar os livros") return cur.lastrowid with conn: author = ('Aldous Huxley', '1894-07-26') author_id = create_author(conn, author) books = [ ('Brave New World', author_id), ('The Perennial Philosophy', author_id), ('The Doors of Perception', author_id), ('The Art of Seeing', author_id), ('Update Field', 5) ] create_books(conn, books)
Vamos percorrer as ideias principais:
create_authorinsere um autor.create_booksinsere uma lista de livros usandoexecutemany, que é eficiente para muitas linhas de uma só vez.Ambas as funções devolvem
cur.lastrowid, o ID gerado para a última linha inserida. Usamo-lo comoauthor_idao inserir os livros.O bloco
with conn:é um gestor de contexto. Se tudo correr bem, a transação é confirmada automaticamente. Se ocorrer uma exceção, a transação é revertida. Esta é uma forma segura e limpa de trabalhar com transações.
Passo 6: Atualizar Dados
Para alterar linhas existentes, use a instrução UPDATE.
import sqlite3 from sqlite3 import Error from create_con import create_connection DB = 'sqlite.db' conn = create_connection(DB) def update_book(conn, book): sql = """UPDATE books SET title = ?, author_id = ? WHERE id = ?""" cur = conn.cursor() cur.execute(sql, book) conn.commit() book = ('Ape and Essence', 1, 5) with conn: update_book(conn, book)
O tuplo ('Ape and Essence', 1, 5) preenche os três marcadores por ordem: o novo título, o novo ID do autor e o ID do livro que queremos atualizar. Tenha sempre cuidado com a cláusula WHERE. Sem ela, todas as linhas da tabela seriam atualizadas.
Passo 7: Selecionar Dados
A instrução SELECT lê dados da base de dados. É o comando que vai usar com mais frequência.
import sqlite3 from sqlite3 import Error from create_con import create_connection DB = 'sqlite.db' conn = create_connection(DB) cur = conn.cursor() def select_book(conn, id): cur.execute('SELECT * from books WHERE id=:id', {'id': id}) row = cur.fetchone() print(row) def select_books(conn): cur.execute('SELECT * from books') rows = cur.fetchall() for row in rows: print(row) def select_author(conn, id): cur.execute('SELECT * from authors WHERE id=?', (id,)) row = cur.fetchone() print(row) def select_authors(conn): cur.execute('SELECT * from authors') rows = cur.fetchall() for row in rows: print(row) with conn: print('SELECT * from books;') select_books(conn) print('SELECT * from authors;') select_authors(conn) print('SELECT * from books where id = 3;') select_book(conn, 3) print('SELECT * from authors where id = 1;') select_author(conn, 1)
Aqui estão as quatro funções e o que fazem:
select_bookdevolve um único livro por ID usandofetchone.select_booksdevolve todos os livros usandofetchalle imprime cada um.select_authordevolve um único autor por ID.select_authorsdevolve todos os autores.
Note os dois estilos de marcadores mostrados aqui. ? é um marcador posicional, e :id é um marcador nomeado que passa como dicionário. Ambos funcionam bem. Ao passar um único valor com ?, lembre-se da vírgula final em (id,) para que o Python o trate como um tuplo.
Passo 8: Apagar Dados
A instrução DELETE remove linhas de uma tabela.
import sqlite3 from sqlite3 import Error from create_con import create_connection DB = 'sqlite.db' conn = create_connection(DB) def delete_book(conn, id): sql = f'DELETE FROM books where id = {id}' cur = conn.cursor() cur.execute(sql) conn.commit() def delete_all_authors(conn): sql = 'DELETE FROM authors' cur = conn.cursor() cur.execute(sql) conn.commit() with conn: delete_book(conn, 5) delete_all_authors(conn)
Dois avisos:
delete_all_authorsremove todas as linhas da tabela authors. Não há como desfazer. Execute-o apenas quando for realmente isso que quer.O exemplo
delete_bookusa uma f-string para construir o SQL. Isto funciona para um número, mas em código real prefira marcadores, como mostrado anteriormente, porque os marcadores o protegem contra injeção de SQL.
Passo 9: Métodos Abreviados
O módulo sqlite3 do Python também oferece métodos abreviados diretamente no objeto de ligação: execute, executemany e executescript. Estes criam o cursor por si e devolvem-no, por isso o seu código fica mais curto e fácil de ler.
import sqlite3 pokemons = [ ("Bulbasaur", "Grass"), ("Charmander", "Fire"), ("Squirtle", "Water"), ("Pikachu", "Electric") ] con = sqlite3.connect(":memory:") con.execute("create table pokemon(name, type)") con.executemany("insert into pokemon(name, type) values (?, ?)", pokemons) for row in con.execute("select name, type from pokemon"): print(row) con.close()
Neste exemplo nós:
Ligamo-nos a uma base de dados em memória.
Criamos uma tabela
pokemon.Inserimos várias linhas de uma só vez com
executemany.Iteramos sobre os resultados de um
selectdiretamente.
Repare que nunca criámos um cursor explicitamente. Os métodos abreviados trataram disso por nós. Este é o estilo que muitos programadores Python experientes preferem para pequenos scripts.
Algumas Dicas Práticas
Use sempre marcadores (
?ou:name) em vez de formatação de strings ao inserir valores. Isto mantém o seu código seguro.Use
with conn:à volta das operações de escrita. Confirma em caso de sucesso e reverte em caso de erro, o que o poupa a alterações a meio.Feche as ligações quando o programa terminar, especialmente com bases de dados em ficheiro. Pode chamar
conn.close().Mantenha o ficheiro da base de dados fora do controlo de versões se contiver dados reais. Adicione-o ao
.gitignore.Comece com
:memory:ao experimentar. Mantém o seu disco limpo e reinicia a cada execução.
Resumo
Já viu o ciclo completo de trabalhar com SQLite a partir do Python:
Ligar-se a um ficheiro de base de dados ou a
:memory:.Criar tabelas com
CREATE TABLE.Inserir linhas com
INSERTe marcadores.Atualizar linhas com
UPDATE.Ler linhas com
SELECTefetchoneoufetchall.Apagar linhas com
DELETE.Escrever código mais curto com os métodos abreviados da ligação.
Tudo aqui usa apenas a biblioteca padrão, por isso não há nada para instalar. Experimente cada exemplo num pequeno script, veja a saída impressa e experimente alterar valores. Essa é a forma mais rápida de ficar à vontade com o módulo sqlite3.
🎯 Teste o seu conhecimento
Responda ao quiz interativo sobre este tópico e veja a sua pontuação.
Fazer o Quiz