Bancos de Dados e Integração com SQL em Python 🐍 Etapa 13

Academy Code Christ 0

 Seja muito bem-vindo à Academy Code Christ!


🌍 Academy Code Christ está disponível em vários idiomas.
Fique à vontade para usar o tradutor na Barra lateral (Sidebar) e aprender no seu idioma.

Python 🐍 Etapa 13
Bancos de Dados 



📚 Continue sua jornada de aprendizado


A Academy Code Christ oferece trilhas de aprendizado em diferentes tecnologias. Explore os cursos, acompanhe as aulas e avance em sua jornada de conhecimento acessando os menus correspondentes:



💻 Pratique o que você aprende


🎯 O que é um banco de dados?


Um banco de dados é uma coleção organizada de informações que pode ser facilmente acessada e gerenciada.

 Ele é composto por tabelas, que contêm colunas (campos) e linhas (registros) — parecidas com uma planilha Excel altamente estruturada.


Tipos principais:

●     SQL (relacional) :

○     Usa tabelas com relacionamentos (ex: SQLite, MySQL, PostgreSQL, Oracle, SQL Server).

●     NoSQL (não relacional) :

○     Usa formatos mais flexíveis (ex: MongoDB, Redis).


Nesta etapa, focaremos em bancos relacionais SQL e, para os exemplos, usaremos o SQLite, pois ele vem embutido no Python.


Por que usar SQLite?


●     Já incluído no Python (sem instalação extra).

●     Leve e fácil de usar.

●     Cria arquivos .db independentes — perfeitos para testes e pequenos sistemas.


Para projetos maiores, o mesmo código pode ser adaptado para MySQL ou PostgreSQL com pequenas alterações.


Conectando-se a um banco de dados SQLite


Vamos usar o módulo nativo sqlite3.

import sqlite3

 

# Cria (ou conecta) a um banco de dados

con = sqlite3.connect("empresa.db")

 

# Cria o cursor para executar comandos SQL

cur = con.cursor()

 

O arquivo empresa.db será criado automaticamente no diretório do projeto.


Criando uma tabela


cur.execute('''

CREATE TABLE IF NOT EXISTS funcionarios (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    nome TEXT NOT NULL,

    cargo TEXT,

    salario REAL

)

''')

 

con.commit()

print("Tabela criada com sucesso!")

 

A tabela funcionarios tem quatro colunas: um id automático, nome, cargo e salário.


Inserindo dados


cur.execute("INSERT INTO funcionarios (nome, cargo, salario) VALUES (?, ?, ?)",

            ("Ana", "Gerente", 5500.00))

 

cur.execute("INSERT INTO funcionarios (nome, cargo, salario) VALUES (?, ?, ?)",

            ("Carlos", "Analista", 4200.00))

 

con.commit()

print("Registros inseridos!")

 

O uso de ? evita ataques de SQL injection e permite inserir valores dinamicamente.


Consultando dados


cur.execute("SELECT * FROM funcionarios")

 

for linha in cur.fetchall():

    print(linha)

 

Saída esperada:

(1, 'Ana', 'Gerente', 5500.0)

(2, 'Carlos', 'Analista', 4200.0)

 


Filtrando resultados (WHERE)


cur.execute("SELECT * FROM funcionarios WHERE salario > 5000")

resultado = cur.fetchall()

print(resultado)

 

Saída:

[(1, 'Ana', 'Gerente', 5500.0)]

 


Atualizando registros (UPDATE)


cur.execute("UPDATE funcionarios SET salario = ? WHERE nome = ?", (6000, "Ana"))

con.commit()

print("Salário atualizado!")

 


Excluindo registros (DELETE)


cur.execute("DELETE FROM funcionarios WHERE id = ?", (2,))

con.commit()

print("Registro removido!")

 


Fechando a conexão

con.close()

 

Sempre feche a conexão quando não estiver mais acessando o banco.


Usando contexto with para segurança


Assim como em arquivos, o sqlite3 também é compatível com blocos with.

import sqlite3

 

with sqlite3.connect("empresa.db") as con:

    cur = con.cursor()

    cur.execute("SELECT * FROM funcionarios")

    print(cur.fetchall())

 

O with garante o fechamento e commit automático.


Funções SQL úteis

Comando

Função

AVG()

média

MIN()

mínimo

MAX()

máximo

COUNT()

contagem

SUM()

soma

Exemplo:

cur.execute("SELECT AVG(salario) FROM funcionarios")

print("Média salarial:", cur.fetchone()[0])

 


Integrando Python + POO com banco de dados


Vamos criar uma classe para gerenciar nossas operações.

import sqlite3

 

class Banco:

    def __init__(self, nome_arquivo):

        self.nome = nome_arquivo

        self.conn = sqlite3.connect(self.nome)

        self.cursor = self.conn.cursor()

 

    def criar_tabela(self):

        self.cursor.execute('''

        CREATE TABLE IF NOT EXISTS produtos (

            id INTEGER PRIMARY KEY AUTOINCREMENT,

            nome TEXT NOT NULL,

            preco REAL

        )

        ''')

        self.conn.commit()

 

    def inserir(self, nome, preco):

        self.cursor.execute("INSERT INTO produtos (nome, preco) VALUES (?, ?)", (nome, preco))

        self.conn.commit()

 

    def listar(self):

        self.cursor.execute("SELECT * FROM produtos")

        return self.cursor.fetchall()

 

    def fechar(self):

        self.conn.close()

 

Uso:

banco = Banco("loja.db")

banco.criar_tabela()

banco.inserir("Notebook", 4200)

banco.inserir("Mouse", 80)

print(banco.listar())

banco.fechar()

 


Conectando Python ao MySQL (visão geral)


Para sistemas profissionais, o MySQL é uma escolha comum.
 Para isso, instale o conector:

pip install mysql-connector-python

 

Conexão básica:

import mysql.connector

 

con = mysql.connector.connect(

    host="localhost",

    user="root",

    password="senha123",

    database="empresa"

)

 

cursor = con.cursor()

cursor.execute("SELECT * FROM funcionarios")

for linha in cursor.fetchall():

    print(linha)

 

Apenas substitua as credenciais e banco correspondentes.


Trabalhando com Pandas e SQL


Pandas integra-se nativamente a bancos, tornando fácil importar dados para análise.

import pandas as pd

import sqlite3

 

con = sqlite3.connect("empresa.db")

df = pd.read_sql_query("SELECT * FROM funcionarios", con)

print(df)

 

Você pode gerar gráficos sobre esses dados conforme aprendido no capítulo anterior.


Mini‑projeto prático: Cadastro de clientes com banco de dados


import sqlite3

 

def conectar():

    return sqlite3.connect("clientes.db")

 

def criar_tabela():

    con = conectar()

    cur = con.cursor()

    cur.execute('''

        CREATE TABLE IF NOT EXISTS clientes (

            id INTEGER PRIMARY KEY AUTOINCREMENT,

            nome TEXT NOT NULL,

            email TEXT NOT NULL,

            telefone TEXT

        )

    ''')

    con.commit()

    con.close()

 

def cadastrar(nome, email, telefone):

    con = conectar()

    cur = con.cursor()

    cur.execute("INSERT INTO clientes (nome, email, telefone) VALUES (?, ?, ?)",

                (nome, email, telefone))

    con.commit()

    con.close()

 

def listar():

    con = conectar()

    cur = con.cursor()

    cur.execute("SELECT * FROM clientes")

    for c in cur.fetchall():

        print(c)

    con.close()

 

# -------- Programa principal --------

criar_tabela()

 

while True:

    print("\n[1] Cadastrar  [2] Listar  [3] Sair")

    op = input("Opção: ")

 

    if op == "1":

        nome = input("Nome: ")

        email = input("E-mail: ")

        telefone = input("Telefone: ")

        cadastrar(nome, email, telefone)

    elif op == "2":

        listar()

    elif op == "3":

        print("Encerrando...")

        break

    else:

        print("Opção inválida.")

 

Tudo o que for cadastrado fica salvo de forma permanente no arquivo clientes.db.


Boas práticas com bancos de dados


1.    Feche conexões após concluir o uso.

2.    Use transações (commit) apenas quando necessário.

3.    Evite SQL Injection → sempre use ? ou parâmetros nomeados.

4.    Versione scripts SQL para recriar tabelas facilmente.

5.    Crie backups automáticos dos bancos de produção.

6.    Monitore erros e utilize logs em todas as operações.


Resumo

Nesta etapa você aprendeu:

 ✅ O que é um banco de dados e como ele armazena informações.
 ✅ Usar o módulo sqlite3 para criar, consultar e atualizar dados.
 ✅ Executar comandos SQL diretamente do Python.
 ✅ Aplicar conceitos de POO para criar uma camada de acesso a dados.
 ✅ Fazer integração entre Pandas e SQL.
 ✅ Conectar Python a bancos mais robustos, como MySQL.
 ✅ Desenvolver um mini‑sistema completo de cadastro persistente.


Agora você já tem o conhecimento necessário para construir aplicativos com armazenamento real e integração profissional de dados.


🎯 Na próxima etapa, veremos “Publicação, Testes e Boas Práticas no Desenvolvimento Python”, onde você aprenderá a transformar seus scripts em verdadeiras aplicações distribuíveis, testadas e mantidas com qualidade.



Este conteúdo faz parte do Academy Code Christ. 

Um projeto criado para ajudar jovens e iniciantes a aprender programação do zero, de forma simples e gratuita.

Nossa missão é compartilhar conhecimento e incentivar mais pessoas a descobrir que também podem aprender tecnologia, criar projetos e desenvolver novas habilidades.
Todo o conteúdo é disponibilizado gratuitamente, de forma clara, prática e 
sem enrolação. 

Você pode apoiar o projeto se quiser 
com um café. 



Tags

Post a Comment

Postar um comentário

Postagem Anterior Próxima Postagem