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 [Link]() 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 = [Link]('[Link]')

# Criar um cursor
cursor = [Link]()

# Criar uma tabela

[Link]('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
age INTEGER NOT NULL
)
''')

# Inserir dados
[Link]('''
INSERT INTO users (name, age)
VALUES ('Alice', 25), ('Bob', 30)
''')

# Confirmar alterações
[Link]()

# Recuperar dados
[Link]('SELECT * FROM users')
rows = [Link]()
for row in rows:
print(row)

# Fechar a conexão
[Link]()
Principais Funções e Métodos

1. Conexão

○ [Link]('database_name.db'): Conecta ou cria o banco de

dados.
2. Cursor

○ [Link](sql_query): Executa uma consulta SQL.

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

○ [Link](): Salva as alterações feitas no banco de dados.

○ [Link](): 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 = [Link]('[Link]')

# Criar um cursor
cursor = [Link]()

Principais Métodos do Objeto Cursor

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

[Link]('CREATE TABLE IF NOT EXISTS users (id INTEGER, name

TEXT)')
[Link]('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')]
[Link]('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.

[Link]('SELECT * FROM users')

print([Link]()) # Retorna o primeiro registro

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

[Link]('SELECT * FROM users')

print([Link]()) # Retorna todos os registros

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

[Link]('SELECT * FROM users')

print([Link](2)) # Retorna os próximos 2 registros

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

UPDATE ou DELETE.

[Link]('DELETE FROM users WHERE id = 1')

print([Link]) # 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.
[Link]('SELECT * FROM users')
print([Link]) # Exibe os nomes das colunas
Exemplo Completo

import sqlite3

# Conectar ao banco de dados

conn = [Link]('[Link]')

# Criar um cursor
cursor = [Link]()

# Criar uma tabela

[Link]('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
)
''')

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

# Consultar dados
[Link]('SELECT * FROM users')

# Iterar sobre os resultados

for row in [Link]():
print(row)

# Recuperar apenas uma linha

[Link]('SELECT * FROM users WHERE id = 1')
print([Link]())

# Fechar a conexão
[Link]()
[Link]()
Cuidados ao Usar o Cursor

1. Fechar a Conexão: Sempre feche a conexão após o uso ([Link]()).

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 [Link]() 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 = [Link]('[Link]')

# Criar um cursor
cursor = [Link]()

# Criar uma tabela

[Link]('''
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
[Link]()

# Fechar a conexão
[Link]()

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 = [Link]('[Link]')
cursor = [Link]()

# Criar tabela de produtos

[Link]('''
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

[Link]('''
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)
)
''')

[Link]()
[Link]()
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 = [Link]('[Link]')
cursor = [Link]()

# Inserir um único registro

[Link]('''
INSERT INTO users (name, email, age)
VALUES (?, ?, ?)
''', ('Alice', 'alice@[Link]', 25))

# Confirmar as alterações
[Link]()

# Fechar a conexão
[Link]()

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 = [Link]('[Link]')
cursor = [Link]()

# Dados a serem inseridos

users = [
('Bob', 'bob@[Link]', 30),
('Charlie', 'charlie@[Link]', 22),
('Diana', 'diana@[Link]', 28)
]

# Inserir múltiplos registros

[Link]('''
INSERT INTO users (name, email, age)
VALUES (?, ?, ?)
''', users)

# Confirmar as alterações
[Link]()

# Fechar a conexão
[Link]()
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

[Link]('''
INSERT INTO users (name, email)
VALUES (?, ?)
''', ('Eve', 'eve@[Link]'))

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 [Link]() 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 = [Link]('[Link]')
cursor = [Link]()

# Criar a tabela
[Link]('''
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', 'alice@[Link]', 25),
('Bob', 'bob@[Link]', 30),
('Charlie', 'charlie@[Link]', 22)]

[Link]('''
INSERT INTO users (name, email, age)
VALUES (?, ?, ?)
''', users)

# Confirmar as alterações
[Link]()

# Recuperar e exibir os dados inseridos

[Link]('SELECT * FROM users')
for row in [Link]():
print(row)

# Fechar a conexão
[Link]()
Exemplo de como inserir dados dinamicamente(esse trecho de um dos
meus projetos kkk)

import sqlite3

conn = [Link]("Database/[Link]")
cursor = [Link]()

[Link]('''
CREATE TABLE IF NOT EXISTS estudantes(
id INTEGER PRIMARY KEY AUTOINCREMENT,
nome TEXT,
classe INTEGER,
turma TEXT,
number INTEGER

''')
[Link]()

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: "))
[Link]("INSERT INTO estudantes (nome, classe, turma,
number) VALUES (?,?,?,?)", (nome, classe, turma, number,))
[Link]()
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()

[Link]()