Python + SQLite para Iniciantes – Banco de Dados

Foto pequena do Leandro
  • Atualizado em: 14/12/2025
Tempo de leitura: 15 minutos
Logo do Python e o logo do SQLite com um sinal de mais entre eles

Se você está começando a aprender Python e quer dar os primeiros passos com banco de dados, o SQLite é a escolha perfeita. Ele já vem embutido no Python e não precisa de instalação extra. Neste guia completo, você vai descobrir como usar Python com SQLite de forma simples e prática.

O SQLite é um banco de dados que funciona sem servidor. Isso quer dizer que você não precisa instalar programas complexos para começar a guardar e organizar informações. Tudo acontece em um único arquivo no seu computador.

Para quem está aprendendo Python para iniciantes, trabalhar com SQLite é uma excelente forma de entender como aplicações armazenam dados de verdade. Você pode criar sistemas de cadastro, aplicativos pessoais e muito mais.

Para ajudar você a entender melhor, recomendo assistir este vídeo do canal Lan Code que explica de forma prática sobre o SQLite com Python:

YouTube player

O Que é SQLite e Por Que Usar com Python

O SQLite é uma biblioteca de software que oferece um sistema de gerenciamento de banco de dados relacional. A grande vantagem dele é ser extremamente leve e não precisar de configuração.

Diferente de bancos como MySQL ou PostgreSQL, o SQLite não precisa de um servidor rodando. Todo o banco fica guardado em um único arquivo. Isso torna tudo mais fácil para iniciantes.

O módulo sqlite3 já vem instalado com o Python desde a versão 2.5. Você não precisa baixar nada extra. Basta instalar Python e já pode começar a usar.

Vantagens do SQLite:

  • Não precisa de instalação separada
  • Banco de dados em um único arquivo
  • Rápido e eficiente para projetos pequenos e médios
  • Perfeito para aprender conceitos de banco de dados
  • Usado em aplicativos famosos como Firefox e WhatsApp

Para projetos pessoais ou de estudo, o SQLite é mais do que suficiente. Ele suporta a maioria dos comandos SQL que você vai precisar no dia a dia.

Preparando o Ambiente para Python e SQLite

Antes de começar a programar, você precisa verificar se o Python está instalado corretamente no seu computador. Abra o terminal ou prompt de comando e digite:

Bash
python --version

Se aparecer um número de versão como “Python 3.10” ou superior, você está pronto. Caso contrário, faça a instalação seguindo um tutorial de instalação adequado.

O SQLite já vem junto com o Python. Para testar se está funcionando, abra o IDLE do Python ou crie um arquivo teste.py e escreva:

Python
import sqlite3
print("SQLite funcionando!")

Se não aparecer erro, significa que está tudo certo. Agora você já pode começar a criar seus primeiros bancos de dados.

Para escrever seus códigos, você pode usar qualquer editor de texto. Porém, uma IDE para Python como VS Code ou PyCharm facilita muito o trabalho.

Criando Sua Primeira Conexão com SQLite

O primeiro passo para trabalhar com banco de dados é criar uma conexão. No SQLite, isso é muito simples. Você vai usar a função connect() do módulo sqlite3.

Veja um exemplo básico:

Python
import sqlite3

# Cria ou conecta a um banco de dados
conexao = sqlite3.connect('meu_banco.db')

print("Conexão criada com sucesso!")

# Fecha a conexão
conexao.close()

Quando você executa esse código, o Python cria um arquivo chamado meu_banco.db na mesma pasta do seu script. Se o arquivo já existir, ele apenas abre a conexão.

A conexão é como uma ponte entre seu programa Python e o banco de dados. Através dela você vai executar todos os comandos SQL.

Sempre que terminar de trabalhar com o banco, é importante fechar a conexão usando close(). Isso libera recursos do sistema e evita problemas.

Se você quiser criar um banco de dados apenas na memória RAM (que some quando o programa fecha), pode usar:

Python
conexao = sqlite3.connect(':memory:')

Isso é útil para testes rápidos onde você não quer salvar nada no disco.

Criando Tabelas no Banco de Dados

Depois de criar a conexão, você precisa de um cursor. O cursor é quem executa os comandos SQL no banco de dados.

Veja como criar uma tabela simples:

Python
import sqlite3

conexao = sqlite3.connect('escola.db')
cursor = conexao.cursor()

# Comando SQL para criar tabela
cursor.execute('''
    CREATE TABLE alunos (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nome TEXT NOT NULL,
        idade INTEGER,
        nota REAL
    )
''')

print("Tabela criada!")

conexao.commit()
conexao.close()

Neste exemplo, criamos uma tabela chamada alunos com quatro colunas. O comando PRIMARY KEY AUTOINCREMENT faz o id aumentar automaticamente.

Tipos de dados no SQLite:

  • INTEGER: números inteiros
  • REAL: números decimais
  • TEXT: textos e strings
  • BLOB: dados binários como imagens
  • NULL: valores vazios

O método commit() é importante. Ele confirma as mudanças no banco de dados. Sem ele, suas alterações não são salvas.

Se você tentar criar uma tabela que já existe, vai dar erro. Para evitar isso, use IF NOT EXISTS:

Python
cursor.execute('''
    CREATE TABLE IF NOT EXISTS alunos (
        id INTEGER PRIMARY KEY,
        nome TEXT NOT NULL
    )
''')

Inserindo Dados nas Tabelas

Agora que você tem uma tabela, pode começar a adicionar dados. Use o comando SQL INSERT INTO para isso.

Veja um exemplo simples:

Python
import sqlite3

conexao = sqlite3.connect('escola.db')
cursor = conexao.cursor()

# Inserindo um registro
cursor.execute('''
    INSERT INTO alunos (nome, idade, nota)
    VALUES ('João Silva', 15, 8.5)
''')

conexao.commit()
print("Dados inseridos!")
conexao.close()

Mas existe uma forma mais segura de inserir dados, usando placeholders. Isso evita problemas de segurança como SQL injection:

Python
nome = "Maria Santos"
idade = 16
nota = 9.0

cursor.execute('''
    INSERT INTO alunos (nome, idade, nota)
    VALUES (?, ?, ?)
''', (nome, idade, nota))

conexao.commit()

Os sinais de ? são substituídos pelos valores da tupla. Esse é o jeito correto e seguro de fazer.

Para inserir vários registros de uma vez, use executemany():

Python
alunos = [
    ('Pedro Costa', 14, 7.5),
    ('Ana Lima', 15, 8.8),
    ('Lucas Souza', 16, 6.9)
]

cursor.executemany('''
    INSERT INTO alunos (nome, idade, nota)
    VALUES (?, ?, ?)
''', alunos)

conexao.commit()

Isso é muito mais eficiente do que fazer vários execute() separados. Quando você trabalha com listas em Python, essa técnica é perfeita.

Consultando Dados do Banco

Depois de inserir dados, você vai querer consultar eles. Use o comando SELECT para buscar informações.

Exemplo básico:

Python
import sqlite3

conexao = sqlite3.connect('escola.db')
cursor = conexao.cursor()

# Busca todos os alunos
cursor.execute('SELECT * FROM alunos')

# Pega todos os resultados
resultados = cursor.fetchall()

for aluno in resultados:
    print(f"ID: {aluno[0]}, Nome: {aluno[1]}, Idade: {aluno[2]}, Nota: {aluno[3]}")

conexao.close()

O método fetchall() retorna todos os registros encontrados como uma lista de tuplas.

Se você quer apenas um resultado, use fetchone():

Python
cursor.execute('SELECT * FROM alunos WHERE id = 1')
aluno = cursor.fetchone()
print(aluno)

Para buscar alguns resultados de cada vez, use fetchmany():

Python
cursor.execute('SELECT * FROM alunos')
primeiros_cinco = cursor.fetchmany(5)
print(primeiros_cinco)

Você pode filtrar resultados usando WHERE:

Python
cursor.execute('SELECT nome, nota FROM alunos WHERE nota >= 8.0')
aprovados = cursor.fetchall()

for aluno in aprovados:
    print(f"{aluno[0]} tirou {aluno[1]}")

Trabalhar com consultas é similar a usar dicionários em Python, onde você busca valores específicos.

Atualizando Registros no Banco

Para modificar dados que já estão no banco, use o comando UPDATE. Isso é útil quando você precisa corrigir ou atualizar informações.

Veja um exemplo:

Python
import sqlite3

conexao = sqlite3.connect('escola.db')
cursor = conexao.cursor()

# Atualiza a nota de um aluno específico
cursor.execute('''
    UPDATE alunos
    SET nota = 9.5
    WHERE nome = 'João Silva'
''')

conexao.commit()
print(f"Registros atualizados: {cursor.rowcount}")
conexao.close()

O cursor.rowcount mostra quantos registros foram afetados pela operação. Isso ajuda a confirmar se a atualização funcionou.

Você pode atualizar vários campos de uma vez:

Python
cursor.execute('''
    UPDATE alunos
    SET idade = 16, nota = 8.0
    WHERE id = 2
''')

conexao.commit()

Cuidado: se você não usar o WHERE, todos os registros serão atualizados. Sempre confirme sua condição antes de executar.

Usando placeholders de forma segura:

Python
nova_nota = 7.8
id_aluno = 3

cursor.execute('''
    UPDATE alunos
    SET nota = ?
    WHERE id = ?
''', (nova_nota, id_aluno))

conexao.commit()

Entender como fazer updates é parecido com trabalhar com variáveis em Python, onde você modifica valores já existentes.

Deletando Dados do Banco

Para remover registros do banco de dados, use o comando DELETE. Tenha muito cuidado com essa operação porque ela não tem como desfazer.

Exemplo de como deletar um registro específico:

Python
import sqlite3

conexao = sqlite3.connect('escola.db')
cursor = conexao.cursor()

# Remove um aluno específico
cursor.execute('''
    DELETE FROM alunos
    WHERE id = 5
''')

conexao.commit()
print(f"Registros deletados: {cursor.rowcount}")
conexao.close()

Você pode deletar baseado em qualquer condição:

Python
# Remove alunos com nota menor que 5.0
cursor.execute('''
    DELETE FROM alunos
    WHERE nota < 5.0
''')

conexao.commit()

Atenção: se você esquecer o WHERE, todos os registros da tabela serão apagados:

Python
# ISSO APAGA TUDO!
cursor.execute('DELETE FROM alunos')
conexao.commit()

Por isso, sempre confira sua query antes de executar. Uma boa prática é fazer um SELECT primeiro para ver quais registros serão afetados.

Exemplo de verificação:

Python
# Primeiro verifica
cursor.execute('SELECT * FROM alunos WHERE nota < 5.0')
print(cursor.fetchall())

# Depois deleta se estiver correto
cursor.execute('DELETE FROM alunos WHERE nota < 5.0')
conexao.commit()

Tratamento de Erros e Boas Práticas

Quando você trabalha com banco de dados, erros podem acontecer. Pode ser uma tabela que não existe, um tipo de dado errado ou a conexão que falha.

Use try/except para lidar com esses problemas:

Python
import sqlite3

try:
    conexao = sqlite3.connect('escola.db')
    cursor = conexao.cursor()
    
    cursor.execute('SELECT * FROM tabela_que_nao_existe')
    
except sqlite3.Error as erro:
    print(f"Erro ao acessar banco de dados: {erro}")
    
finally:
    if conexao:
        conexao.close()

O bloco finally garante que a conexão seja fechada mesmo se houver erro. Isso evita problemas de conexões abertas.

Boas práticas importantes:

  • Sempre feche as conexões depois de usar
  • Use placeholders (?) ao invés de concatenar strings
  • Faça commit() após modificar dados
  • Use try/except para capturar erros
  • Não deixe conexões abertas sem necessidade

Uma técnica moderna é usar context managers com o comando with:

Python
import sqlite3

with sqlite3.connect('escola.db') as conexao:
    cursor = conexao.cursor()
    cursor.execute('SELECT * FROM alunos')
    print(cursor.fetchall())
    # A conexão fecha automaticamente

Isso é similar ao uso de try except em Python, onde você previne e trata erros de forma elegante.

Organizando o Código com Funções

Para tornar seu código mais organizado e reutilizável, crie funções em Python para operações comuns com o banco de dados.

Veja um exemplo de estrutura:

Python
import sqlite3

def conectar_banco():
    """Cria conexão com o banco de dados"""
    return sqlite3.connect('escola.db')

def criar_tabela():
    """Cria a tabela de alunos se não existir"""
    conexao = conectar_banco()
    cursor = conexao.cursor()
    
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS alunos (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            nome TEXT NOT NULL,
            idade INTEGER,
            nota REAL
        )
    ''')
    
    conexao.commit()
    conexao.close()

def inserir_aluno(nome, idade, nota):
    """Insere um novo aluno no banco"""
    conexao = conectar_banco()
    cursor = conexao.cursor()
    
    cursor.execute('''
        INSERT INTO alunos (nome, idade, nota)
        VALUES (?, ?, ?)
    ''', (nome, idade, nota))
    
    conexao.commit()
    conexao.close()
    return cursor.lastrowid

def buscar_todos_alunos():
    """Retorna todos os alunos cadastrados"""
    conexao = conectar_banco()
    cursor = conexao.cursor()
    
    cursor.execute('SELECT * FROM alunos')
    alunos = cursor.fetchall()
    
    conexao.close()
    return alunos

# Usando as funções
criar_tabela()
inserir_aluno('Carlos Mendes', 15, 8.5)
print(buscar_todos_alunos())

Essa organização torna o código muito mais limpo e fácil de manter. Cada função tem uma responsabilidade específica.

Você pode também criar uma classe para gerenciar o banco:

Python
class BancoDados:
    def __init__(self, nome_banco):
        self.conexao = sqlite3.connect(nome_banco)
        self.cursor = self.conexao.cursor()
    
    def inserir(self, nome, idade, nota):
        self.cursor.execute('''
            INSERT INTO alunos (nome, idade, nota)
            VALUES (?, ?, ?)
        ''', (nome, idade, nota))
        self.conexao.commit()
    
    def buscar_todos(self):
        self.cursor.execute('SELECT * FROM alunos')
        return self.cursor.fetchall()
    
    def fechar(self):
        self.conexao.close()

# Usando a classe
db = BancoDados('escola.db')
db.inserir('Julia Silva', 14, 9.2)
print(db.buscar_todos())
db.fechar()

Trabalhar com classes facilita muito quando seus projetos crescem. É uma forma profissional de estruturar código.

Projeto Prático: Sistema de Cadastro

Vamos criar um pequeno sistema de cadastro de contatos para praticar tudo que aprendemos. Esse projeto usa conceitos básicos de lógica de programação com Python.

Python
import sqlite3

def criar_banco():
    """Cria o banco e a tabela de contatos"""
    conexao = sqlite3.connect('contatos.db')
    cursor = conexao.cursor()
    
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS contatos (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            nome TEXT NOT NULL,
            telefone TEXT,
            email TEXT
        )
    ''')
    
    conexao.commit()
    conexao.close()

def adicionar_contato():
    """Adiciona um novo contato"""
    nome = input("Nome: ")
    telefone = input("Telefone: ")
    email = input("Email: ")
    
    conexao = sqlite3.connect('contatos.db')
    cursor = conexao.cursor()
    
    cursor.execute('''
        INSERT INTO contatos (nome, telefone, email)
        VALUES (?, ?, ?)
    ''', (nome, telefone, email))
    
    conexao.commit()
    conexao.close()
    print("Contato adicionado com sucesso!")

def listar_contatos():
    """Lista todos os contatos"""
    conexao = sqlite3.connect('contatos.db')
    cursor = conexao.cursor()
    
    cursor.execute('SELECT * FROM contatos')
    contatos = cursor.fetchall()
    
    print("\n--- LISTA DE CONTATOS ---")
    for contato in contatos:
        print(f"ID: {contato[0]} | Nome: {contato[1]} | Tel: {contato[2]} | Email: {contato[3]}")
    
    conexao.close()

def menu():
    """Menu principal do sistema"""
    criar_banco()
    
    while True:
        print("\n=== SISTEMA DE CONTATOS ===")
        print("1. Adicionar contato")
        print("2. Listar contatos")
        print("3. Sair")
        
        opcao = input("Escolha uma opção: ")
        
        if opcao == '1':
            adicionar_contato()
        elif opcao == '2':
            listar_contatos()
        elif opcao == '3':
            print("Saindo...")
            break
        else:
            print("Opção inválida!")

# Executa o programa
if __name__ == "__main__":
    menu()

Este projeto simples mostra como você pode criar aplicações reais usando Python e SQLite. Você pode expandir ele adicionando mais funcionalidades como editar e deletar contatos.

Esse tipo de projeto ajuda muito a fixar os conceitos. Pratique modificando o código e adicionando suas próprias ideias.

Dicas Avançadas e Próximos Passos

Depois de dominar o básico, você pode explorar recursos mais avançados. Uma funcionalidade útil são as transações, que permitem agrupar várias operações.

Exemplo de transação:

Python
import sqlite3

conexao = sqlite3.connect('escola.db')
cursor = conexao.cursor()

try:
    # Inicia uma transação
    cursor.execute('BEGIN')
    
    cursor.execute('INSERT INTO alunos (nome, idade, nota) VALUES (?, ?, ?)', 
                   ('Paulo', 15, 7.0))
    cursor.execute('INSERT INTO alunos (nome, idade, nota) VALUES (?, ?, ?)', 
                   ('Rita', 16, 8.5))
    
    # Confirma todas as operações
    conexao.commit()
    print("Transação concluída!")
    
except sqlite3.Error as erro:
    # Desfaz tudo se houver erro
    conexao.rollback()
    print(f"Erro na transação: {erro}")
    
finally:
    conexao.close()

Você também pode trabalhar com índices para tornar as consultas mais rápidas:

Python
cursor.execute('''
    CREATE INDEX IF NOT EXISTS idx_nome
    ON alunos (nome)
''')

Para projetos maiores, considere usar ORMs como SQLAlchemy ou Django ORM. Eles facilitam muito o trabalho com bancos de dados.

Próximos passos no aprendizado:

  • Aprenda sobre relacionamentos entre tabelas (chaves estrangeiras)
  • Estude consultas mais complexas com JOINs
  • Explore outros bancos de dados como MySQL com Python
  • Pratique com exercícios Python para iniciantes
  • Crie projetos maiores integrando banco de dados

O SQLite é apenas o começo. Depois de dominar ele, você pode partir para bancos mais robustos quando seus projetos crescerem.

Perguntas Frequentes (FAQ)

1. Preciso instalar o SQLite separadamente no Python?

Não. O módulo sqlite3 já vem incluído com o Python desde a versão 2.5. Você não precisa instalar nada extra.

2. Qual a diferença entre SQLite e MySQL?

SQLite não precisa de servidor e salva tudo em um arquivo. MySQL precisa de servidor rodando e é melhor para aplicações grandes com múltiplos usuários.

3. Como vejo os dados do meu banco SQLite visualmente?

Você pode usar o DB Browser for SQLite, que é gratuito. Também existe extensão no VS Code que mostra o banco de forma visual.

4. O que é cursor no SQLite?

O cursor é um objeto que permite executar comandos SQL no banco. Você cria ele a partir da conexão usando o método cursor().

5. Por que devo usar placeholders (?) nas queries?

Placeholders protegem contra SQL injection e tornam o código mais seguro. Nunca concatene strings diretamente nas queries SQL.

6. Posso usar SQLite em aplicações profissionais?

Sim. Muitos apps famosos usam SQLite, incluindo WhatsApp e Firefox. É perfeito para apps móveis e sistemas pequenos e médios.

7. Como faço backup do meu banco SQLite?

Basta copiar o arquivo .db para outro local. Todo o banco está em um único arquivo, facilitando backups e compartilhamento.

8. Qual a diferença entre commit() e close()?

O commit() salva as mudanças no banco. O close() fecha a conexão. Você deve fazer commit antes de fechar a conexão.

9. Posso ter vários bancos SQLite no mesmo projeto?

Sim. Cada banco é um arquivo separado. Você pode criar conexões diferentes para bancos diferentes no mesmo programa.

10. Como adiciono uma nova coluna em uma tabela existente?

Use o comando ALTER TABLE. Exemplo: ALTER TABLE alunos ADD COLUMN endereco TEXT.

Compartilhe:

Facebook
WhatsApp
Twitter
LinkedIn
Banner do minicurso gratuito de Python da Academify com o texto 'Assista agora e aprenda Python'.

Conteúdo do artigo

    Artigos relacionados

    Logo do Python e do MySQL com um símbolo de '+' entre as logos
    Banco de DadosBibliotecas
    Foto do Leandro Hirt

    Como Conectar Python ao MySQL de Forma Fácil

    Aprenda como conectar Python ao MySQL passo a passo. Tutorial completo com MySQL Connector, SQLAlchemy, exemplos de código para inserir,

    Ler mais

    Tempo de leitura: 19 minutos
    07/12/2025

    Minicurso de Python

    Insira seu e-mail e para receber acesso às aulas agora mesmo