SQLite é um banco de dados leve, autônomo e embutido que não requer um servidor para ser

executado. Ele é amplamente utilizado em aplicações que precisam de um banco de dados

simples e eficiente. Em Python, você pode usar o módulo integrado sqlite3 para interagir
com o SQLite.

Passos Básicos para Usar SQLite em Python

1. Importar o Módulo sqlite3 O módulo sqlite3 já vem com o Python por padrão.

2. Conectar ao Banco de Dados Use sqlite3.connect() para criar uma conexão

com o banco de dados. Se o banco de dados não existir, ele será criado.

3. Criar um Cursor O cursor é usado para executar comandos SQL.

4. Executar Comandos SQL Use o método execute() para executar comandos como
CREATE TABLE, INSERT, SELECT, etc.

5. Confirmar Alterações Após comandos como INSERT, UPDATE, ou DELETE, chame

commit() para salvar as alterações.

6. Fechar a Conexão Sempre feche a conexão com o banco de dados para liberar
recursos.
Exemplo de Uso

import sqlite3

# Conectar ao banco de dados (ou criar um novo)

conn = sqlite3.connect('example.db')

# Criar um cursor
cursor = conn.cursor()

# Criar uma tabela

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
age INTEGER NOT NULL
)
''')

# Inserir dados
cursor.execute('''
INSERT INTO users (name, age)
VALUES ('Alice', 25), ('Bob', 30)
''')

# Confirmar alterações
conn.commit()

# Recuperar dados
cursor.execute('SELECT * FROM users')
rows = cursor.fetchall()
for row in rows:
print(row)

# Fechar a conexão
conn.close()
Principais Funções e Métodos

1. Conexão

○ sqlite3.connect('database_name.db'): Conecta ou cria o banco de

dados.
2. Cursor

○ cursor.execute(sql_query): Executa uma consulta SQL.

○ cursor.executemany(sql_query, data): Insere vários registros de uma
vez.
○ cursor.fetchall(): Retorna todos os resultados de uma consulta.
○ cursor.fetchone(): Retorna apenas o próximo registro.
3. Salvar e Fechar

○ conn.commit(): Salva as alterações feitas no banco de dados.

○ conn.close(): Fecha a conexão.

Vantagens do SQLite

● Simplicidade de configuração.
● Ideal para aplicações pequenas ou embarcadas.
● Armazenamento em um único arquivo.

Limitações do SQLite

● Não é adequado para aplicações de larga escala com múltiplos usuários simultâneos.
● Suporte limitado a operações complexas e altas cargas de transação.

Se você precisar de algo mais específico ou dicas sobre o uso avançado do SQLite, posso
ajudar!
O objeto Cursor no SQLite em Python é usado para interagir com o banco de dados. Ele é
criado a partir de uma conexão com o banco de dados e serve para executar comandos SQL e
manipular resultados. Vamos explorar as funcionalidades do objeto Cursor.

Como Criar um Cursor

Você cria um cursor a partir de uma conexão com o banco de dados:

import sqlite3

# Criar uma conexão

conn = sqlite3.connect('example.db')

# Criar um cursor
cursor = conn.cursor()

Principais Métodos do Objeto Cursor

1. execute(sql, params=None) Executa uma consulta ou comando SQL.

cursor.execute('CREATE TABLE IF NOT EXISTS users (id INTEGER, name

TEXT)')
cursor.execute('INSERT INTO users (id, name) VALUES (?, ?)', (1,
'Alice'))

2. executemany(sql, seq_of_params) Executa uma consulta ou comando SQL

várias vezes com diferentes parâmetros.
users = [(2, 'Bob'), (3, 'Charlie')]
cursor.executemany('INSERT INTO users (id, name) VALUES (?, ?)',
users)
 3. fetchone() Retorna o próximo registro do resultado como uma tupla. Retorna None
se não houver mais registros.

cursor.execute('SELECT * FROM users')

print(cursor.fetchone()) # Retorna o primeiro registro

4. fetchall() Retorna todos os registros do resultado como uma lista de tuplas.

cursor.execute('SELECT * FROM users')

print(cursor.fetchall()) # Retorna todos os registros

5. fetchmany(size=n) Retorna até n registros do resultado como uma lista de tuplas.

cursor.execute('SELECT * FROM users')

print(cursor.fetchmany(2)) # Retorna os próximos 2 registros

6. rowcount Retorna o número de registros afetados pelo último comando INSERT,

UPDATE ou DELETE.

cursor.execute('DELETE FROM users WHERE id = 1')

print(cursor.rowcount) # Número de registros excluídos

7. description Contém metadados sobre as colunas do resultado. Cada entrada é uma

tupla com informações como o nome da coluna.
cursor.execute('SELECT * FROM users')
print(cursor.description) # Exibe os nomes das colunas
Exemplo Completo

import sqlite3

# Conectar ao banco de dados

conn = sqlite3.connect('example.db')

# Criar um cursor
cursor = conn.cursor()

# Criar uma tabela

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
)
''')

# Inserir dados
users = [(1, 'Alice'), (2, 'Bob'), (3, 'Charlie')]
cursor.executemany('INSERT INTO users (id, name) VALUES (?, ?)',
users)

# Consultar dados
cursor.execute('SELECT * FROM users')

# Iterar sobre os resultados

for row in cursor.fetchall():
print(row)

# Recuperar apenas uma linha

cursor.execute('SELECT * FROM users WHERE id = 1')
print(cursor.fetchone())

# Fechar a conexão
conn.commit()
conn.close()
Cuidados ao Usar o Cursor

1. Fechar a Conexão: Sempre feche a conexão após o uso (conn.close()).

2. Injeção SQL: Use parâmetros (?) em vez de concatenar strings SQL diretamente para
evitar vulnerabilidades de injeção SQL.
3. Persistência do Cursor: O cursor deve ser associado a uma conexão aberta. Se a
conexão for fechada, o cursor será inválido.

O objeto Cursor é central para trabalhar com bancos de dados em SQLite. Ele é eficiente para
realizar operações como leitura, escrita e manipulação de dados. Se precisar de algo mais
avançado, é só pedir!
Criar uma tabela no SQLite usando Python envolve o uso de comandos SQL no objeto
Cursor. O comando SQL padrão para criar tabelas é o CREATE TABLE. Aqui está um guia
completo para criar tabelas no SQLite com Python:

Passos para Criar uma Tabela

1. Importar o módulo sqlite3: O módulo sqlite3 é integrado ao Python.

2. Conectar ao Banco de Dados: Use sqlite3.connect() para criar ou abrir um

banco de dados.

3. Criar um Cursor: O cursor executará os comandos SQL.

4. Executar o Comando CREATE TABLE: Use o método execute() para executar a

instrução de criação de tabela.

5. Confirmar Alterações e Fechar a Conexão: Use commit() para salvar as alterações

no banco de dados e close() para liberar os recursos.
Exemplo Simples

import sqlite3

# Conectar ao banco de dados (ou criar um novo arquivo se não

existir)
conn = sqlite3.connect('example.db')

# Criar um cursor
cursor = conn.cursor()

# Criar uma tabela

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
email TEXT UNIQUE NOT NULL,
age INTEGER,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')

# Confirmar as alterações
conn.commit()

# Fechar a conexão
conn.close()

Explicação do Exemplo

● CREATE TABLE IF NOT EXISTS: Garante que a tabela seja criada apenas se não
existir.
● Colunas da Tabela:
○ id INTEGER PRIMARY KEY AUTOINCREMENT: Coluna de ID única e
incremental.
○ name TEXT NOT NULL: Nome como texto obrigatório.
○ email TEXT UNIQUE NOT NULL: Email como texto obrigatório e único.
 ○ age INTEGER: Idade como número inteiro.
○ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP: Data/hora de
criação com valor padrão.

Exemplo com Mais Tabelas

Você pode criar várias tabelas no mesmo banco de dados:

import sqlite3

conn = sqlite3.connect('store.db')
cursor = conn.cursor()

# Criar tabela de produtos

cursor.execute('''
CREATE TABLE IF NOT EXISTS products (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
price REAL NOT NULL,
stock INTEGER NOT NULL
)
''')

# Criar tabela de vendas

cursor.execute('''
CREATE TABLE IF NOT EXISTS sales (
id INTEGER PRIMARY KEY AUTOINCREMENT,
product_id INTEGER NOT NULL,
quantity INTEGER NOT NULL,
sale_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (product_id) REFERENCES products(id)
)
''')

conn.commit()
conn.close()
Boas Práticas ao Criar Tabelas

1. Use IF NOT EXISTS: Evita erros ao executar o código várias vezes.

2. Chaves Primárias: Inclua sempre uma coluna de chave primária para identificar
registros.

3. Tipos de Dados: SQLite aceita os tipos básicos: INTEGER, TEXT, REAL, BLOB, NULL.

4. Integridade Referencial: Use chaves estrangeiras (FOREIGN KEY) para relacionar

tabelas.
Para inserir dados em uma tabela SQLite usando Python, você pode usar o método
execute() ou executemany() do objeto Cursor. Aqui está um guia completo sobre como
inserir dados no SQLite:

Método 1: Inserir Dados com execute()

O método execute() é usado para inserir um único registro por vez.

Exemplo

import sqlite3

# Conectar ao banco de dados

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Inserir um único registro

cursor.execute('''
INSERT INTO users (name, email, age)
VALUES (?, ?, ?)
''', ('Alice', '[email protected]', 25))

# Confirmar as alterações
conn.commit()

# Fechar a conexão
conn.close()

Detalhes

● VALUES (?, ?, ?): Os ? são marcadores de posição que previnem injeções SQL.
● O segundo argumento de execute() é uma tupla com os valores correspondentes aos
marcadores.
Método 2: Inserir Múltiplos Dados com executemany()

Se você precisar inserir vários registros ao mesmo tempo, use o método executemany().

Exemplo

import sqlite3

# Conectar ao banco de dados

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Dados a serem inseridos

users = [
('Bob', '[email protected]', 30),
('Charlie', '[email protected]', 22),
('Diana', '[email protected]', 28)
]

# Inserir múltiplos registros

cursor.executemany('''
INSERT INTO users (name, email, age)
VALUES (?, ?, ?)
''', users)

# Confirmar as alterações
conn.commit()

# Fechar a conexão
conn.close()
Método 3: Inserir Dados com Colunas Opcionais

Se sua tabela tiver colunas com valores padrão ou que aceitam NULL, você pode omitir essas
colunas na inserção.

Exemplo

cursor.execute('''
INSERT INTO users (name, email)
VALUES (?, ?)
''', ('Eve', '[email protected]'))

Nesse caso, a coluna age será NULL ou usará o valor padrão definido.

Boas Práticas ao Inserir Dados

1. Usar Marcadores de Posição (?): Sempre use marcadores de posição para evitar
vulnerabilidades de injeção SQL.

2. Confirmar Alterações: Use conn.commit() após inserir dados para salvar as

alterações no banco de dados.

3. Validar Dados: Antes de inserir, verifique se os dados atendem aos requisitos do banco
(e.g., valores únicos, tipos corretos).
Exemplo Completo com Criação de Tabela e Inserção

import sqlite3

# Conectar ao banco de dados

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Criar a tabela
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
email TEXT UNIQUE NOT NULL,
age INTEGER
)''')

# Inserir dados
users = [
('Alice', '[email protected]', 25),
('Bob', '[email protected]', 30),
('Charlie', '[email protected]', 22)]

cursor.executemany('''
INSERT INTO users (name, email, age)
VALUES (?, ?, ?)
''', users)

# Confirmar as alterações
conn.commit()

# Recuperar e exibir os dados inseridos

cursor.execute('SELECT * FROM users')
for row in cursor.fetchall():
print(row)

# Fechar a conexão
conn.close()
Exemplo de como inserir dados dinamicamente(esse trecho de um dos
meus projetos kkk)

import sqlite3

conn = sqlite3.connect("Database/estudantes.db")
cursor = conn.cursor()

cursor.execute('''
CREATE TABLE IF NOT EXISTS estudantes(
id INTEGER PRIMARY KEY AUTOINCREMENT,
nome TEXT,
classe INTEGER,
turma TEXT,
number INTEGER

''')
conn.commit()

def adicionarAluno():
nome = input("Digite o seu nome: ")
classe = int(input("Digite a sua classe(10ª-13ª): "))
turma = input("Digite a sua turma: ")
number = int(input("Digite o seu número: "))
cursor.execute("INSERT INTO estudantes (nome, classe, turma,
number) VALUES (?,?,?,?)", (nome, classe, turma, number,))
conn.commit()
print("Aluno registrado com sucesso!")

def menu():
while True:
print("\nMenu")
print("1. Adicionar estudante")
print("5. Sair")

escolha = input("Escolha a opção: ")

 if escolha == '1':
adicionarAluno()
elif escolha == '5':
print("Saindo...")
break
else:
print("Opção inaceitável!")

menu()

conn.close()