Como Conectar Python ao MySQL de Forma Fácil

Foto pequena do Leandro
  • Atualizado em: 07/12/2025
Tempo de leitura: 19 minutos
Logo do Python e do MySQL com um símbolo de '+' entre as logos

Conectar Python ao MySQL é uma habilidade essencial para qualquer desenvolvedor que trabalha com aplicações que precisam armazenar dados. Seja para criar um sistema de cadastro, uma loja virtual ou um painel de análise de dados, saber integrar essas duas tecnologias abre portas para projetos mais robustos e profissionais.

Neste guia completo, você vai aprender passo a passo como estabelecer essa conexão. Vamos explorar desde a instalação das bibliotecas necessárias até operações avançadas como inserção, consulta e atualização de dados. Mesmo que você nunca tenha trabalhado com bancos de dados antes, este tutorial foi criado para tornar o processo simples e acessível.

O Que é MySQL e Por Que Usar com Python?

O MySQL é um dos sistemas de gerenciamento de banco de dados mais populares do mundo. Ele é gratuito, confiável e usado por milhões de aplicações, desde pequenos sites até grandes plataformas como Facebook e Twitter. Quando você acessa um site e faz login, provavelmente há um MySQL guardando suas informações.

Para mais informações confira o vídeo abaixo do canal IlustraDev:

YouTube player

Já o Python é conhecido pela sua simplicidade e versatilidade. Juntar essas duas tecnologias permite criar aplicações que armazenam, consultam e manipulam dados de forma eficiente. Pense em um sistema de estoque: você pode usar Python para criar a lógica do programa e MySQL para guardar todos os produtos e quantidades.

A combinação de Python com MySQL é especialmente útil para quem trabalha com análise de dados, desenvolvimento web e automação de processos. Empresas de todos os tamanhos usam essa integração para construir sistemas internos, APIs e ferramentas de relatório.

Bibliotecas Python para Conexão com MySQL

Existem várias formas de conectar Python ao MySQL. Cada biblioteca tem suas características e vantagens. Vamos conhecer as principais opções disponíveis para você escolher a que melhor se adapta ao seu projeto.

MySQL Connector/Python

Esta é a biblioteca oficial da Oracle para conectar Python ao MySQL. Ela segue a especificação PEP 249, que define um padrão para conexões com bancos de dados em Python. A versão mais recente é a 9.5.0, lançada em outubro de 2025, e funciona com Python 3.10 ou superior.

O MySQL Connector é escrito inteiramente em Python, o que significa que não precisa de dependências externas complicadas. Isso facilita muito a instalação e o uso em diferentes sistemas operacionais.

PyMySQL

O PyMySQL é uma alternativa leve e popular. Também é escrito em Python puro e oferece compatibilidade com o antigo MySQLdb. Muitos desenvolvedores preferem essa biblioteca por sua simplicidade e por funcionar bem em ambientes onde instalar extensões C pode ser complicado.

mysqlclient (MySQLdb)

Esta biblioteca usa extensões em C, o que a torna mais rápida em operações intensivas. Porém, a instalação pode ser mais trabalhosa em alguns sistemas. É uma boa escolha para aplicações que precisam de alto desempenho.

SQLAlchemy

O SQLAlchemy não é apenas um conector, mas um ORM completo. Ele permite trabalhar com bancos de dados usando classes Python em vez de escrever SQL diretamente. É muito usado em projetos maiores e frameworks como Flask e Django.

Instalando o MySQL Connector/Python

Antes de começar a programar, você precisa ter o Python instalado no seu computador. Se ainda não tem, confira nosso guia sobre como instalar Python. Também é necessário ter o MySQL Server funcionando na sua máquina ou acesso a um servidor MySQL remoto.

A instalação do MySQL Connector é simples. Abra o terminal ou prompt de comando e execute:

Bash
pip install mysql-connector-python

Para verificar se a instalação funcionou corretamente, crie um arquivo Python e adicione o seguinte código:

Python
import mysql.connector
print("MySQL Connector instalado com sucesso!")
print(f"Versão: {mysql.connector.__version__}")

Se o código rodar sem erros e mostrar a versão da biblioteca, você está pronto para seguir em frente. Recomendamos usar um ambiente virtual para manter suas bibliotecas organizadas por projeto.

Criando Sua Primeira Conexão com o Banco de Dados

Agora vamos ao que interessa: conectar seu programa Python ao MySQL. O processo envolve fornecer algumas informações básicas sobre onde o banco está e como acessá-lo.

Python
import mysql.connector

# Estabelecendo a conexão
conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="nome_do_banco"
)

# Verificando se a conexão foi bem-sucedida
if conexao.is_connected():
    print("Conexão estabelecida com sucesso!")
    
# Sempre feche a conexão quando terminar
conexao.close()

Vamos entender cada parâmetro usado na função connect():

  • host: endereço do servidor MySQL. Use “localhost” se o banco estiver na sua máquina.
  • user: nome do usuário do MySQL. O padrão é “root”.
  • password: senha do usuário MySQL.
  • database: nome do banco de dados que você quer acessar.

Se você ainda não criou um banco de dados, pode conectar sem especificar o parâmetro database e criar um depois.

Usando Arquivos de Configuração para Maior Segurança

Nunca é uma boa ideia deixar senhas diretamente no código. Uma prática recomendada é usar um dicionário de configuração ou variáveis de ambiente:

Python
import mysql.connector

# Configurações do banco em um dicionário
config = {
    'host': 'localhost',
    'user': 'seu_usuario',
    'password': 'sua_senha',
    'database': 'nome_do_banco',
    'raise_on_warnings': True
}

# Conectando usando o dicionário
conexao = mysql.connector.connect(**config)

if conexao.is_connected():
    info = conexao.get_server_info()
    print(f"Conectado ao MySQL Server versão {info}")

conexao.close()

O parâmetro raise_on_warnings faz com que o Python levante exceções quando houver avisos do MySQL. Isso ajuda a identificar problemas mais rapidamente durante o desenvolvimento.

Criando Bancos de Dados e Tabelas com Python

Para executar comandos SQL no MySQL através do Python, usamos um objeto chamado cursor. O cursor funciona como um ponteiro que permite executar comandos e percorrer resultados.

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha"
)

cursor = conexao.cursor()

# Criando um banco de dados
cursor.execute("CREATE DATABASE IF NOT EXISTS minha_loja")

print("Banco de dados criado com sucesso!")

cursor.close()
conexao.close()

Agora vamos criar uma tabela dentro desse banco. Primeiro, conectamos especificando o banco de dados:

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="minha_loja"
)

cursor = conexao.cursor()

# Criando uma tabela de produtos
criar_tabela = """
CREATE TABLE IF NOT EXISTS produtos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nome VARCHAR(100) NOT NULL,
    preco DECIMAL(10, 2) NOT NULL,
    quantidade INT DEFAULT 0,
    data_cadastro TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
"""

cursor.execute(criar_tabela)
print("Tabela criada com sucesso!")

cursor.close()
conexao.close()

Inserindo Dados no MySQL com Python

Existem duas formas principais de inserir dados: inserção única e inserção em lote. Vamos ver ambas:

Inserção Única

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="minha_loja"
)

cursor = conexao.cursor()

# Inserindo um produto
sql = "INSERT INTO produtos (nome, preco, quantidade) VALUES (%s, %s, %s)"
valores = ("Notebook Dell", 3500.00, 10)

cursor.execute(sql, valores)

# Importante: confirmar a transação
conexao.commit()

print(f"Produto inserido! ID: {cursor.lastrowid}")

cursor.close()
conexao.close()

Note o uso de %s como placeholder. Isso é fundamental para evitar ataques de SQL Injection. Nunca concatene strings diretamente em comandos SQL!

Inserção em Lote

Quando você precisa inserir muitos registros, usar executemany() é muito mais eficiente:

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="minha_loja"
)

cursor = conexao.cursor()

sql = "INSERT INTO produtos (nome, preco, quantidade) VALUES (%s, %s, %s)"

produtos = [
    ("Mouse Gamer", 150.00, 25),
    ("Teclado Mecânico", 280.00, 15),
    ("Monitor 24 polegadas", 899.00, 8),
    ("Headset Wireless", 320.00, 20),
    ("Webcam Full HD", 199.00, 30)
]

cursor.executemany(sql, produtos)
conexao.commit()

print(f"{cursor.rowcount} produtos inseridos!")

cursor.close()
conexao.close()

Consultando Dados do MySQL

A consulta de dados é uma das operações mais comuns. Veja como buscar informações do banco:

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="minha_loja"
)

cursor = conexao.cursor()

# Buscando todos os produtos
cursor.execute("SELECT * FROM produtos")

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

for produto in resultados:
    print(f"ID: {produto[0]} | Nome: {produto[1]} | Preço: R${produto[2]}")

cursor.close()
conexao.close()

Existem três métodos para obter resultados:

  • fetchall(): retorna todos os registros de uma vez.
  • fetchone(): retorna apenas um registro por vez.
  • fetchmany(n): retorna n registros.

Para consultas com filtros, use parâmetros para maior segurança:

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="minha_loja"
)

cursor = conexao.cursor()

# Buscando produtos com preço menor que um valor
preco_maximo = 500.00
sql = "SELECT nome, preco FROM produtos WHERE preco < %s ORDER BY preco"

cursor.execute(sql, (preco_maximo,))

for nome, preco in cursor.fetchall():
    print(f"{nome}: R${preco:.2f}")

cursor.close()
conexao.close()

Atualizando e Excluindo Registros

Atualizar dados segue o mesmo padrão de uso do cursor:

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="minha_loja"
)

cursor = conexao.cursor()

# Atualizando o preço de um produto
sql = "UPDATE produtos SET preco = %s WHERE id = %s"
cursor.execute(sql, (3200.00, 1))

conexao.commit()
print(f"{cursor.rowcount} registro(s) atualizado(s)")

cursor.close()
conexao.close()

Para excluir registros:

Python
import mysql.connector

conexao = mysql.connector.connect(
    host="localhost",
    user="seu_usuario",
    password="sua_senha",
    database="minha_loja"
)

cursor = conexao.cursor()

# Excluindo um produto pelo ID
sql = "DELETE FROM produtos WHERE id = %s"
cursor.execute(sql, (5,))

conexao.commit()
print(f"{cursor.rowcount} registro(s) excluído(s)")

cursor.close()
conexao.close()

Tratando Erros e Exceções

Em aplicações reais, sempre podem ocorrer problemas de conexão ou erros SQL. Usar try-except é fundamental:

Python
import mysql.connector
from mysql.connector import Error

def conectar_banco():
    try:
        conexao = mysql.connector.connect(
            host="localhost",
            user="seu_usuario",
            password="sua_senha",
            database="minha_loja"
        )
        
        if conexao.is_connected():
            return conexao
            
    except Error as erro:
        print(f"Erro ao conectar: {erro}")
        return None

def inserir_produto(nome, preco, quantidade):
    conexao = conectar_banco()
    
    if conexao is None:
        return False
    
    try:
        cursor = conexao.cursor()
        sql = "INSERT INTO produtos (nome, preco, quantidade) VALUES (%s, %s, %s)"
        cursor.execute(sql, (nome, preco, quantidade))
        conexao.commit()
        print(f"Produto '{nome}' inserido com sucesso!")
        return True
        
    except Error as erro:
        print(f"Erro ao inserir: {erro}")
        conexao.rollback()
        return False
        
    finally:
        cursor.close()
        conexao.close()

# Testando a função
inserir_produto("SSD 500GB", 299.00, 50)

O bloco finally garante que a conexão será fechada mesmo se ocorrer um erro. O método rollback() desfaz alterações caso algo dê errado durante a transação.

Usando SQLAlchemy para Conexão com MySQL

O SQLAlchemy oferece uma abordagem diferente, mais orientada a objetos. Ele permite mapear tabelas do banco para classes Python:

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

# Criando a conexão
engine = create_engine("mysql+mysqlconnector://usuario:senha@localhost/minha_loja")

# Base para as classes
Base = declarative_base()

# Definindo o modelo
class Produto(Base):
    __tablename__ = 'produtos'
    
    id = Column(Integer, primary_key=True)
    nome = Column(String(100), nullable=False)
    preco = Column(Float, nullable=False)
    quantidade = Column(Integer, default=0)

# Criando a sessão
Session = sessionmaker(bind=engine)
sessao = Session()

# Inserindo um produto
novo_produto = Produto(nome="Placa de Vídeo RTX", preco=2500.00, quantidade=5)
sessao.add(novo_produto)
sessao.commit()

# Consultando produtos
produtos = sessao.query(Produto).filter(Produto.preco < 1000).all()
for p in produtos:
    print(f"{p.nome}: R${p.preco}")

sessao.close()

O SQLAlchemy é especialmente útil em projetos maiores, onde a organização do código em classes facilita a manutenção. Frameworks como Flask e Django usam ORMs semelhantes.

Boas Práticas ao Trabalhar com MySQL e Python

Para garantir que seu código seja seguro e eficiente, siga estas recomendações:

  • Sempre use parâmetros em vez de concatenar strings SQL. Isso previne SQL Injection.
  • Feche conexões quando terminar de usá-las para não sobrecarregar o servidor.
  • Use transações para operações que envolvem múltiplas alterações.
  • Implemente tratamento de erros com try-except em todas as operações.
  • Guarde credenciais em variáveis de ambiente ou arquivos de configuração separados.
  • Considere usar pools de conexão em aplicações que fazem muitas requisições.

Exemplo Completo: Sistema de Cadastro de Clientes

Vamos criar um exemplo mais completo que demonstra todas as operações CRUD (Create, Read, Update, Delete):

Python
import mysql.connector
from mysql.connector import Error

class GerenciadorClientes:
    def __init__(self, host, user, password, database):
        self.config = {
            'host': host,
            'user': user,
            'password': password,
            'database': database
        }
    
    def conectar(self):
        try:
            return mysql.connector.connect(**self.config)
        except Error as e:
            print(f"Erro na conexão: {e}")
            return None
    
    def criar_tabela(self):
        conexao = self.conectar()
        if conexao:
            cursor = conexao.cursor()
            sql = """
            CREATE TABLE IF NOT EXISTS clientes (
                id INT AUTO_INCREMENT PRIMARY KEY,
                nome VARCHAR(100) NOT NULL,
                email VARCHAR(100) UNIQUE,
                telefone VARCHAR(20),
                cidade VARCHAR(50)
            )
            """
            cursor.execute(sql)
            conexao.commit()
            cursor.close()
            conexao.close()
            print("Tabela criada!")
    
    def adicionar(self, nome, email, telefone, cidade):
        conexao = self.conectar()
        if conexao:
            try:
                cursor = conexao.cursor()
                sql = """INSERT INTO clientes (nome, email, telefone, cidade) 
                         VALUES (%s, %s, %s, %s)"""
                cursor.execute(sql, (nome, email, telefone, cidade))
                conexao.commit()
                print(f"Cliente {nome} adicionado!")
            except Error as e:
                print(f"Erro: {e}")
            finally:
                cursor.close()
                conexao.close()
    
    def listar_todos(self):
        conexao = self.conectar()
        if conexao:
            cursor = conexao.cursor()
            cursor.execute("SELECT * FROM clientes ORDER BY nome")
            clientes = cursor.fetchall()
            cursor.close()
            conexao.close()
            return clientes
        return []
    
    def buscar_por_cidade(self, cidade):
        conexao = self.conectar()
        if conexao:
            cursor = conexao.cursor()
            sql = "SELECT nome, email FROM clientes WHERE cidade = %s"
            cursor.execute(sql, (cidade,))
            resultados = cursor.fetchall()
            cursor.close()
            conexao.close()
            return resultados
        return []
    
    def atualizar_email(self, cliente_id, novo_email):
        conexao = self.conectar()
        if conexao:
            cursor = conexao.cursor()
            sql = "UPDATE clientes SET email = %s WHERE id = %s"
            cursor.execute(sql, (novo_email, cliente_id))
            conexao.commit()
            alterados = cursor.rowcount
            cursor.close()
            conexao.close()
            return alterados > 0
        return False
    
    def remover(self, cliente_id):
        conexao = self.conectar()
        if conexao:
            cursor = conexao.cursor()
            sql = "DELETE FROM clientes WHERE id = %s"
            cursor.execute(sql, (cliente_id,))
            conexao.commit()
            removidos = cursor.rowcount
            cursor.close()
            conexao.close()
            return removidos > 0
        return False


# Usando o sistema
if __name__ == "__main__":
    gerenciador = GerenciadorClientes(
        host="localhost",
        user="seu_usuario",
        password="sua_senha",
        database="minha_loja"
    )
    
    # Criar tabela
    gerenciador.criar_tabela()
    
    # Adicionar clientes
    gerenciador.adicionar("Maria Silva", "maria@email.com", "(11) 99999-0001", "São Paulo")
    gerenciador.adicionar("João Santos", "joao@email.com", "(21) 99999-0002", "Rio de Janeiro")
    
    # Listar todos
    print("\nTodos os clientes:")
    for cliente in gerenciador.listar_todos():
        print(cliente)
    
    # Buscar por cidade
    print("\nClientes de São Paulo:")
    for nome, email in gerenciador.buscar_por_cidade("São Paulo"):
        print(f"{nome} - {email}")

Este exemplo demonstra como organizar seu código em uma classe reutilizável. Você pode adaptar esse modelo para criar sistemas mais complexos usando os conceitos de programação orientada a objetos.

Perguntas Frequentes (FAQ)

1. Qual biblioteca devo usar para conectar Python ao MySQL?

O MySQL Connector/Python é a escolha mais comum e oficial. Para projetos maiores, considere usar SQLAlchemy.

2. O MySQL Connector é gratuito?

Sim. Ele é distribuído sob licença GPL e pode ser usado livremente em projetos pessoais e comerciais.

3. Preciso ter o MySQL instalado no meu computador?

Você precisa de acesso a um servidor MySQL, seja local ou remoto. Pode ser o MySQL Server instalado ou um serviço na nuvem.

4. O que é SQL Injection e como evitar?

É um ataque que insere código malicioso em comandos SQL. Evite usando parâmetros (%s) em vez de concatenar strings.

5. Qual a diferença entre fetchall() e fetchone()?

O fetchall() retorna todos os resultados de uma vez. O fetchone() retorna um resultado por vez, economizando memória.

6. Por que devo usar commit() após inserir dados?

O commit() confirma as alterações no banco. Sem ele, as mudanças são perdidas quando a conexão é fechada.

7. Posso usar Python com MySQL em aplicações web?

Sim. Frameworks como Flask e Django funcionam muito bem com MySQL para criar aplicações web completas.

8. O SQLAlchemy é melhor que o MySQL Connector?

São ferramentas diferentes. O SQLAlchemy é um ORM completo, melhor para projetos grandes. Para scripts simples, o Connector basta.

9. Como sei se minha conexão está funcionando?

Use o método is_connected() do objeto de conexão. Ele retorna True se a conexão estiver ativa.

10. Posso conectar Python ao MySQL na nuvem?

Sim. Basta usar o endereço do servidor remoto no parâmetro host e configurar as permissões de acesso no MySQL.

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 Numpy em um fundo roxo-escuro
    Bibliotecas
    Foto do Leandro Hirt

    Introdução ao NumPy no Python para Iniciantes

    Aprender Python já abre muitas portas, mas entender como trabalhar com dados transforma suas habilidades de verdade. É aqui que

    Ler mais

    Tempo de leitura: 7 minutos
    05/12/2025
    Logo do Python com o texto 'requests' abaixo
    Bibliotecas
    Foto do Leandro Hirt

    Como usar a biblioteca Requests em Python

    A biblioteca Requests em Python permite que você envie requisições HTTP de forma simples. Você pode acessar dados de APIs,

    Ler mais

    Tempo de leitura: 5 minutos
    04/12/2025
    Logos do Python e Excel lado a lado representando a importação de dados do Excel para Python.
    Bibliotecas
    Foto do Leandro Hirt

    Python Excel: importar dados do Excel para Python

    A integração entre Python e Excel se tornou essencial para muitas rotinas de trabalho. Profissionais de diversas áreas precisam analisar

    Ler mais

    Tempo de leitura: 8 minutos
    20/11/2025
    Mesa de trabalho com laptop exibindo gráficos e a logo do Pandas em primeiro plano
    Bibliotecas
    Foto do Leandro Hirt

    Pandas Python: O que é e por que usar na análise de dados

    A análise de dados cresceu muito nos últimos anos. Cada vez mais empresas precisam entender informações para tomar decisões melhores.

    Ler mais

    Tempo de leitura: 7 minutos
    16/11/2025
    Logo do matplotlib em um fundo branco
    BibliotecasCiência de Dados
    Foto do Leandro Hirt

    Primeiros Passos com o Matplotlib: Crie Gráficos no Python

    A visualização de dados é uma das etapas mais importantes na análise de informações. Ela transforma números e tabelas em

    Ler mais

    Tempo de leitura: 8 minutos
    02/11/2025
    representação de IA com código binário na tela
    Ciência de DadosBibliotecas
    Foto do Leandro Hirt

    Scikit-Learn Python: Biblioteca de Machine Learning

    O machine learning, ou aprendizado de máquina, está mudando o mundo em que vivemos. Ele permite que computadores aprendam com

    Ler mais

    Tempo de leitura: 5 minutos
    25/05/2025

    Minicurso de Python

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