Python e SQLite: Como Manipular 2 Tabelas com Tratamento de Dados

		Python e SQLite: Manipulação de 2 Tabelas
Canal de Programação

Estrutura do Banco de Dados

Este código Python utiliza duas tabelas SQLite:

• last_value: Armazena apenas o último valor da faixa gerada (INTEGER)
• responses: Contém todas as consultas com suas respectivas respostas (TEXT UNIQUE)

Código Completo

import asyncio
import aiohttp
import sqlite3
from bs4 import BeautifulSoup

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            html = await response.text()
            soup = BeautifulSoup(html, 'html.parser')
            title = soup.find('title')
            if title and "Page Not Found" not in title.text:
                return f"{url.split('/')[-1]}: {title.text}"
            print(title.text)

async def fetch_all(urls):
    responses = await asyncio.gather(*[fetch(url) for url in urls])
    return [r for r in responses if r]

async def insert_last_value(conn, value):
    cursor = conn.cursor()
    cursor.execute("INSERT INTO last_value (value) VALUES (?)", (value,))
    conn.commit()

async def get_last_value(conn):
    cursor = conn.cursor()
    cursor.execute("SELECT value FROM last_value ORDER BY ROWID DESC LIMIT 1")
    result = cursor.fetchone()
    return result[0] if result else None

async def insert_response(conn, value):
    cursor = conn.cursor()
    cursor.execute("INSERT INTO responses (value) VALUES (?)", (value,))
    conn.commit()

async def main():
    try:
        db_conn = sqlite3.connect("urls.db")
        cursor = db_conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS last_value (value INTEGER)''')
        cursor.execute('''CREATE TABLE IF NOT EXISTS responses (value TEXT UNIQUE)''')

        last_value = await get_last_value(db_conn)
        if not last_value:
            last_value = 0

        end_value = int(input("Digite o valor final: "))
        urls = [f'https://pt.aliexpress.com/item/{i}.html' for i in range(last_value + 1, end_value + 1)]
        responses = await fetch_all(urls)

        for response in responses:
            if response:
                value = response.split(':')[0]
                try:
                    await insert_response(db_conn, value)
                    print(f"Valor {value} inserido na tabela de respostas")
                except sqlite3.IntegrityError:
                    print(f"Valor {value} já existe na tabela de respostas")

        await insert_last_value(db_conn, end_value)
        print(f"Último valor da faixa ({end_value}) inserido na tabela de último valor")

    except RuntimeError:
        pass
    finally:
        db_conn.close()

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Explicação das Funções

1. fetch(url): Faz requisição HTTP e extrai o título da página
2. fetch_all(urls): Processa múltiplas URLs simultaneamente
3. insert_last_value(): Insere o último valor processado
4. get_last_value(): Recupera o último valor processado
5. insert_response(): Armazena respostas válidas
6. main(): Coordena todo o fluxo de execução

Solução para Erros Comuns

1. AttributeError: 'NoneType' object has no attribute 'text'

Ocorre quando não encontra o título na página. Solução:

if title and "Page Not Found" not in title.text:
    return f"{url.split('/')[-1]}: {title.text}"
elif title:
    print(title.text)
else:
    print(f"Não foi possível encontrar o título da página: {url}")

2. Atualização de Linha Existente

Para atualizar ao invés de inserir nova linha:

cursor.execute("REPLACE INTO last_value (value) VALUES (?)", (end_value,))

3. Incluir Título nas Mensagens

Para mostrar título sem armazenar:

value, title = response.split(':')
print(f"Valor {value} com título '{title.strip()}' inserido")

Considerações Finais

Este script demonstra uma aplicação prática de Python com SQLite para:

• Web scraping assíncrono
• Manipulação de banco de dados
• Tratamento de erros
• Persistência de dados entre execuções

Para aprender mais sobre Python e SQLite, visite a documentação oficial.