Como Criar Banco de Dados em Python – SQLAlchemy

Quer aprender a criar um banco de dados em Python da melhor forma? Aprenda a fazer isso com o SQLAlchemy, sem precisar escrever comandos SQL.

O SQLAlchemy é a forma mais prática de criar um banco de dados em Python: instale a biblioteca com pip install SQLAlchemy e conecte-se com create_engine a um banco SQLite. Em seguida, abra uma sessão com sessionmaker, defina as tabelas como classes que herdam de declarative_base e rode Base.metadata.create_all. Depois, faça as operações CRUD com objetos Python, sem escrever SQL.

Como Criar Banco de Dados em Python – SQLAlchemy

O SQLAlchemy é uma das melhores opções para integrar Python com bancos de dados SQL! É uma biblioteca extremamente útil e prática para quem precisa criar um banco de dados em Python de forma rápida e eficiente.

Nesta postagem você encontrará informações detalhadas sobre o que é o SQLAlchemy, como configurá-lo e utilizá-lo para criar bancos de dados, tabelas e realizar as operações CRUD (Criação, Leitura, Atualização e Exclusão de dados).

Quer aprender como fazer tudo isso de forma simples, sem precisar dominar comandos SQL? Então faça o download do material disponível e vem comigo!

Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

O que é o SQLAlchemy?

O SQLAlchemy é uma biblioteca de mapeamento objeto-relacional (ORM - Object Relational Mapper) para Python que permite a interação com bancos de dados SQL de forma simplificada e eficiente.

Com o SQLAlchemy, você pode criar, editar e manipular bancos de dados utilizando objetos Python, o que facilita a integração e o gerenciamento de dados sem a necessidade de escrever comandos SQL diretamente.

Saiba mais: Documentação do SQLAlchemy

Instalação do SQLAlchemy

O primeiro passo para usar o SQLAlchemy é instalá-lo. Para isso, execute o seguinte comando no terminal do seu editor de código: pip install SQLAlchemy

Após a instalação, a biblioteca estará disponível para você criar e manipular bancos de dados SQL, sejam eles locais ou remotos.

Criando o Banco de Dados

O SQLAlchemy utiliza o conceito de engine para se conectar a um banco de dados, seja para criá-lo ou para se conectar a um banco existente. Para isso, usaremos a função create_engine.

Vamos criar uma variável chamada db para representar o nosso banco de dados. Esta variável armazenará a instância do banco de dados criado pela função create_engine, que, neste exemplo, será um banco de dados SQLite chamado meubanco.db.

from sqlalchemy import create_engine

db = create_engine("sqlite:///meubanco.db")

O SQLAlchemy suporta diferentes tipos de bancos de dados, como PostgreSQL, MySQL, entre outros. Para utilizá-los, é necessário ter os drivers apropriados instalados e adaptar a string de conexão ao formato correspondente.

Caso esteja lidando com um banco de dados online, a string de conexão deve incluir todas as informações necessárias para o login, proporcionando acesso direto.

Criando Sessões no Banco de Dados

Para interagir com o banco de dados, é necessário criar uma sessão. A sessão serve para enviar e confirmar as mudanças realizadas, como criação, leitura, atualização e exclusão de dados. Para criar uma sessão, utilizamos a função sessionmaker.

O processo é simples e requer apenas duas etapas: primeiro, instanciamos o sessionmaker, passando a conexão com o banco de dados para o parâmetro bind; depois, carregamos a sessão criada em uma variável, que chamaremos de session.

Esse é o formato padrão para a criação de sessões no SQLAlchemy, permitindo que todas as operações no banco de dados sejam gerenciadas de forma eficiente e segura.

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()

Definindo as Tabelas

No SQLAlchemy, as tabelas são definidas como classes Python, onde cada atributo da classe representa uma coluna da tabela. Essas classes herdam de uma base declarativa fornecida pela biblioteca.

Portanto, para criar uma tabela no banco de dados precisaremos importar a função declarative_base.

Essa base criada servirá como classe-mãe para todas as tabelas que serão definidas no banco de dados.

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base

db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()

Base = declarative_base()

Criando as Tabelas do Banco de Dados

Vamos pegar como exemplo o banco de dados para uma biblioteca. Para criar esse banco de dados, precisaremos de no mínimo duas tabelas: Usuários e Livro.

Cada tabela precisará ter colunas que representem os dados que serão armazenados nelas.

A tabela de usuários incluirá as colunas: id, nome, e-mail, senha e ativo (indicando se o usuário está ativo). Já a tabela de livros conterá: id, título, quantidade de páginas e dono (o usuário que possui o livro).

Cada tabela será definida como uma classe Python, e cada instância da classe representará um registro na tabela.

As classes herdarão da Base, e seus nomes estarão no singular, enquanto os nomes das tabelas (definidos com __tablename__) estarão no plural.

Para criar os campos, utilizamos os tipos específicos do SQLAlchemy, como Column (colunas), String (texto), Integer (número inteiro) e Boolean (valores verdadeiro ou falso).

Cada coluna é definida usando a função Column, onde o primeiro parâmetro é o nome do campo e o segundo é seu tipo.

from sqlalchemy import create_engine, Column, String, Integer, Boolean
from sqlalchemy.orm import sessionmaker, declarative_base

db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()


Base = declarative_base()

#Tabelas
class Usuario(Base):
    __tablename__ = "usuarios"

    id = Column("id", Integer)
    nome = Column("nome", String)
    email = Column("email", String)
    senha = Column("senha", String)
    ativo = Column("ativo", Boolean)


# Livros
class Livro(Base):
    __tablename__ = "livros"

    id = Column("id", Integer)
    titulo = Column("titulo", String)
    qtde_paginas = Column("qtde_paginas", Integer)
    dono = Column("dono", )

Por enquanto não preencheremos o campo dono, porque antes precisamos entender sobre relacionamento entre tabelas.

Relacionamento Entre Tabelas – Primary Keys e Foreign Keys

Ao trabalhar com bancos de dados relacionais, é fundamental compreender o conceito de chaves primárias (Primary Keys) e chaves estrangeiras (Foreign Keys).

Essas chaves desempenham um papel fundamental na integridade dos dados e na definição do relacionamento entre tabelas.

A primary key (chave primário) é uma coluna que identifica de forma única cada registro em uma tabela e deve ser única, não nula e imutável:

• Única: Nenhum valor duplicado é permitido. Cada registro deve ter um identificador único.
• Não nula: A chave primária não pode conter valores NULL.
• Imutável: O valor de uma chave primária raramente muda, pois é usado para identificar um registro de maneira consistente

Na maioria dos casos, a chave primária é representada por um número inteiro que é automaticamente incrementado toda vez que um novo registro é inserido na tabela.

A foreign key (chave estrangeira, por sua vez, é uma coluna em uma tabela que estabelece um vínculo, um relacionamento, com a chave primária de outra tabela.

As chaves estrangeiras são usadas para manter a integridade referencial, garantindo que o valor da chave estrangeira corresponda a um valor existente na tabela referenciada.

Por exemplo, no sistema de biblioteca que estamos desenvolvendo, a coluna id na tabela de usuários será a chave primária. Na tabela de livros, a coluna dono será uma chave estrangeira que faz referência ao campo id da tabela de usuários.

A tabela de livros além de ter uma coluna como chave estrangeira, também pode ter na coluna id, a sua chave primária, que pode ser usada para fazer referência em outras tabelas do sistema e garantindo um identificar único para cada livro.

Definindo a Chave Primária da Tabela de Usuários:

Para criar a chave primária de uma tabela, definimos o parâmetro primary_key como True. Além disso, como esse valor precisa ser incrementado automaticamente, também configuramos o parâmetro autoincrement como True.

Dessa forma, a coluna id da tabela de usuários será a chave primária, única para cada registro e automaticamente incrementada, garantindo que cada usuário tenha um identificador exclusivo.

#Tabelas
class Usuario(Base):
    __tablename__ = "usuarios"

    id = Column("id", Integer, primary_key=True, autoincrement=True)
    nome = Column("nome", String)
    email = Column("email", String)
    senha = Column("senha", String)
    ativo = Column("ativo", Boolean)

Definindo a Chave Primária e Estrangeira da Tabela de Livros:

A tabela de livros também terá a coluna id como sua chave primária, assim como fizemos com a tabela de usuários.

Para definir a chave estrangeira, precisamos importar a função ForeignKey e atribuí-la à coluna dono, passando como argumento o nome da tabela e a coluna a qual ela faz referência.

No nosso caso, desejamos vincular o campo dono da tabela de livros com a coluna id da tabela de usuários, então passaremos usuarios.id como argumento.

from sqlalchemy import create_engine, Column, String, Integer, Boolean, ForeignKey
from sqlalchemy.orm import sessionmaker, declarative_base

db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()


Base = declarative_base()

#Tabelas
class Usuario(Base):
    __tablename__ = "usuarios"

    id = Column("id", Integer, primary_key=True, autoincrement=True)
    nome = Column("nome", String)
    email = Column("email", String)
    senha = Column("senha", String)
    ativo = Column("ativo", Boolean)


# Livros
class Livro(Base):
    __tablename__ = "livros"

    id = Column("id", Integer, primary_key=True, autoincrement=True)
    titulo = Column("titulo", String)
    qtde_paginas = Column("qtde_paginas", Integer)
    dono = Column("dono", ForeignKey("usuarios.id"))

Para entender mais sobre os conceitos envolvendo relacionamentos entre tabelas, chaves primárias e estrangeiras, confira a nossa aula: JOIN no SQL: Conceitos e Aplicações (Guia para Iniciantes)

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

Função __init__ nas Tabelas do SQLAlchemy

Com os campos das tabelas criados, precisamos definir a função __init__ para inicializar essas classes.

Em Python, a função __init__ é um método especial, também conhecido como construtor de classe. Quando você cria uma nova instância de uma classe, o método __init__ é automaticamente chamado para inicializar o objeto.

Usamos esse método para definir os atributos de um objeto no momento de sua criação.

Dentro das classes de tabelas do SQLAlchemy, esse método facilita a criação de novos registros no banco de dados.

Com o __init__, os objetos podem ser criados de forma direta, passando os atributos necessários como argumentos ao inicializar uma nova instância da classe.

Assim, quando você criar um novo Usuario ou Livro, poderá passar os dados diretamente para o construtor, pois, através da função __init__, ele sabe exatamente quais informações precisa receber.

Para garantir que todos os usuários sejam criados com status ativo por padrão, você pode definir o parâmetro ativo=True na função __init__.

Além disso, o parâmetro id será gerado automaticamente pela classe, portanto não precisará ser declarado na função __init__, evitando que o usuário forneça um id manualmente.

from sqlalchemy import create_engine, Column, String, Integer, Boolean, ForeignKey
from sqlalchemy.orm import sessionmaker, declarative_base

db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()


Base = declarative_base()

# as tabelas
class Usuario(Base):
    __tablename__ = "usuarios"

    id = Column("id", Integer, primary_key=True, autoincrement=True)
    nome = Column("nome", String)
    email = Column("email", String)
    senha = Column("senha", String)
    ativo = Column("ativo", Boolean)

    def __init__(self, nome, email, senha, ativo=True):
        self.nome = nome
        self.email = email
        self.senha = senha
        self.ativo = ativo


# Livros
class Livro(Base):
    __tablename__ = "livros"

    id = Column("id", Integer, primary_key=True, autoincrement=True)
    titulo = Column("titulo", String)
    qtde_paginas = Column("qtde_paginas", Integer)
    dono = Column("dono", ForeignKey("usuarios.id"))

    def __init__(self, titulo, qtde_paginas, dono):
        self.titulo = titulo
        self.qtde_paginas = qtde_paginas
        self.dono = dono

Para saber mais sobre Classes no Python, confira a nossa aula: Classes no Python – Como Sair do Zero

Criando as Tabelas e o Banco de Dados com Python

Após definir todas as classes para suas tabelas, o próximo passo é criar as tabelas no banco de dados. Isso pode ser feito executando a função create_all e passando a variável que representa o banco de dados como parâmetro para o argumento bind.

from sqlalchemy import create_engine, Column, String, Integer, Boolean, ForeignKey
from sqlalchemy.orm import sessionmaker, declarative_base

db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()


Base = declarative_base()

# as tabelas
class Usuario(Base):
    __tablename__ = "usuarios"

    id = Column("id", Integer, primary_key=True, autoincrement=True)
    nome = Column("nome", String)
    email = Column("email", String)
    senha = Column("senha", String)
    ativo = Column("ativo", Boolean)

    def __init__(self, nome, email, senha, ativo=True):
        self.nome = nome
        self.email = email
        self.senha = senha
        self.ativo = ativo


# Livros
class Livro(Base):
    __tablename__ = "livros"

    id = Column("id", Integer, primary_key=True, autoincrement=True)
    titulo = Column("titulo", String)
    qtde_paginas = Column("qtde_paginas", Integer)
    dono = Column("dono", ForeignKey("usuarios.id"))

    def __init__(self, titulo, qtde_paginas, dono):
        self.titulo = titulo
        self.qtde_paginas = qtde_paginas
        self.dono = dono


Base.metadata.create_all(bind=db)

Ao executar esse código, você criará o banco de dados e todas as tabelas previamente configuradas.

Para visualizar e manipular o banco de dados, você pode utilizar um aplicativo como o DB Browser for SQLite. Este software gratuito permite visualizar o banco de dados de forma clara e intuitiva. Acesse o site oficial do DB Browser para fazer o download.

Operações CRUD no Banco de Dados

Agora que você já sabe como criar o banco de dados, vamos aprender a manipular e editar essas tabelas através das operações CRUD (Create, Read, Update e Delete).

Create (Criar):

Para adicionar um novo registro às suas tabelas, você precisa criar uma instância da classe que representa a tabela e adicionar essa instância à sessão.

Por exemplo, para definir um novo usuário, criamos uma instância da classe Usuario passando os atributos necessários. Em seguida, o usuário criado deve ser adicionado à sessão do banco de dados.

Por fim, para editar o banco, deve-se realizar um commit para salvar as alterações oficialmente.

usuario = Usuario(nome="Lira", email="qlqcoisa@email.com", senha="123123")
session.add(usuario)
session.commit()

Depois de executar esse código, se você acessar a tabela pelo DB Browser, será possível visualizar o usuário criado.

Read (Ler):

Para buscar informações no banco de dados, você deve realizar uma consulta dentro da sessão. Para isso, Utilizamos o método query() e passamos a tabela que desejamos consultar.

Para obter todos os itens retornados pela consulta, usamos o método .all().

lista_usuarios = session.query(Usuario).all()
print(lista_usuarios)

O resultado dessa consulta é uma lista Python, onde podemos acessar e manipular os registros.

Para buscar um usuário específico por e-mail, usamos o método query() seguido de filter_by(), passando o parâmetro desejado.

Obs.: O nome do parâmetro deve corresponder exatamente ao nome dos campos na tabela.

Essa consulta também pode retornar um único item com .first() ou todos os itens correspondentes com .all().

usuario_lira = session.query(Usuario).filter_by(email="qlqcoisa@email.com").first()
print(usuario_lira)
print(usuario_lira.nome)
print(usuario_lira.email)

Observe que podemos acessar as informações do usuário através da estrutura de classes do Python, como usuario.nome e usuario.email.

Agora que temos um usuário no banco de dados e sabemos como acessar suas informações, podemos adicionar um livro a um usuário existente.

livro = Livro(titulo="Nome do Vento", qtde_paginas=1000, dono=usuario_lira.id)
session.add(livro)
session.commit()

Update (Atualizar):

Para atualizar um registro, primeiro você o busca, altera os atributos desejados e, em seguida, realiza um commit.

usuario_lira.nome = "Joao Lira"
session.add(usuario_lira)
session.commit()

Delete (Deletar):

Para deletar um registro do banco de dados, basta buscar o dado que deseja remover e utilizar o método delete() para deletá-lo.

session.delete(usuario_lira)
session.commit()

Perguntas frequentes

Conclusão – Como Criar Banco de Dados em Python – SQLAlchemy

O SQLAlchemy facilita muito o trabalho com bancos de dados em Python, eliminando a necessidade de escrever SQL diretamente e permitindo que você trabalhe com classes e objetos Python.

Isso torna o processo mais intuitivo e claro, especialmente se você já está familiarizado com Python.

Com essa biblioteca, você pode criar, ler, atualizar e deletar registros de forma eficiente, além de definir relacionamentos entre tabelas.

Para aprofundar seus conhecimentos em Python e SQL e se tornar um profissional impressionador nessas áreas, confira os nossos cursos completos:

• Curso Completo Python Impressionador
• Curso Completo SQL Impressionador

Se quiser pode acompanhar esse conteúdo em formato de vídeo ou pode acessar o nosso Canal do YouTube para mais vídeos!

O que você aprende neste vídeo

Resposta rápida: O SQLAlchemy é um ORM: você descreve as tabelas como classes Python e ele gera o SQL. O fluxo é criar a engine com create_engine, abrir a sessão, declarar as classes herdando da base, chamar Base.metadata.create_all e então fazer o CRUD pela sessão, com add, query, atribuição direta e delete, sempre fechando com commit.

Neste vídeo (34 min):

• 0:00 - O que é o SQLAlchemy, e por que ele evita escrever SQL dentro do Python
• 1:50 - Instalação, e onde ele costuma aparecer: Flask, Streamlit, aplicativo de desktop
• 3:00 - create_engine: cria o banco se não existir e conecta se já existir
• 4:00 - Trocar SQLite por PostgreSQL: o que muda é a string de conexão e o driver
• 5:30 - A sessão do banco, em três linhas que se repetem em todo projeto
• 8:00 - A base declarativa, de onde as classes de tabela herdam
• 9:20 - O banco criado e ainda vazio: por que ele não tem tabela nenhuma
• 10:20 - Declarando a primeira classe, e as colunas como atributos dela
• 11:40 - O tipo de cada coluna, e a chave estrangeira apontando para outra tabela
• 15:00 - O nome da tabela definido explicitamente, e por que a chave estrangeira exige isso
• 17:00 - O init da classe, e os parâmetros que ela recebe ao criar um registro
• 20:00 - Chave primária e auto incremento, os dois parâmetros que todo id leva
• 23:00 - Create: instanciar, dar add na sessão e commit para salvar
• 27:00 - Read com query e filtro, e o update e o delete pela mesma sessão

Trechos do vídeo:

• Ele permite que você edite, crie e mexa com bancos de dados SQL por meio de código em Python.
• O create_engine cria o banco de dados, e conecta com o banco caso ele já exista.
• Sem o commit, a alteração fica só na sessão e não é salva no banco.

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.