Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

1
resposta

Faça como eu fiz: construindo um sistema inteligente de recomendação

# Importa a biblioteca heapq, utilizada para organizar a fila de prioridade do algoritmo A*
import heapq


# Etapa 1: Criar a classe Produto
# Essa classe armazena o nome, a categoria e a probabilidade de conversão de cada produto

class Produto:

    def __init__(self, nome, categoria, probabilidade_conversao):
        self.nome = nome
        self.categoria = categoria
        self.probabilidade_conversao = probabilidade_conversao

    # Define como o produto será exibido
    def __repr__(self):
        return f"{self.nome} ({self.categoria})"


# Etapa 2: Criar a classe AStarRecommendation
# Essa classe será responsável por construir o grafo e executar o algoritmo A*

class AStarRecommendation:

    def __init__(self, produtos):

        # Recebe a lista de produtos
        self.produtos = produtos

        # Cria o grafo simplificado
        self.grafo = self.criar_grafo()


    # Cria um grafo onde cada produto se conecta a todos os outros

    def criar_grafo(self):

        grafo = {}

        for produto in self.produtos:

            grafo[produto] = [

                p for p in self.produtos

                if p != produto

            ]

        return grafo


    # Etapa 3: Implementar a heurística

    # Quanto maior a probabilidade de conversão,
    # maior a prioridade do produto

    def heuristica(self, produto):

        return -produto.probabilidade_conversao


    # Implementação do algoritmo A*

    def a_star(self, inicio, objetivo):

        # Cria a fila de prioridade

        fila = []

        # Adiciona o produto inicial

        heapq.heappush(fila, (0, inicio))

        visitados = set()

        caminhos = {}

        while fila:

            # Remove o item com maior prioridade

            _, atual = heapq.heappop(fila)

            if atual in visitados:

                continue

            visitados.add(atual)

            # Interrompe a busca quando encontra o objetivo

            if atual == objetivo:

                break


            # Percorre os produtos vizinhos

            for vizinho in self.grafo[atual]:

                if vizinho not in visitados:

                    # Calcula a prioridade utilizando a heurística

                    prioridade = 1 + self.heuristica(vizinho)

                    # Adiciona o vizinho na fila

                    heapq.heappush(

                        fila,

                        (prioridade, vizinho)

                    )

                    # Armazena o caminho percorrido

                    caminhos[vizinho] = atual


        # Reconstrói o caminho encontrado

        caminho = []

        produto = objetivo

        while produto in caminhos:

            caminho.insert(0, produto)

            produto = caminhos[produto]

        caminho.insert(0, inicio)

        return caminho


# Etapa 4: Inserir produtos de exemplo

produtos = [

    Produto(

        "Notebook Gamer",

        "Informática",

        0.95

    ),

    Produto(

        "Mouse Sem Fio",

        "Periféricos",

        0.85

    ),

    Produto(

        "Teclado Mecânico",

        "Periféricos",

        0.88

    ),

    Produto(

        "Monitor 24 Polegadas",

        "Monitores",

        0.80

    )

]


# Criar o sistema de recomendação

recomendador = AStarRecommendation(produtos)


# Definir o produto inicial e o produto objetivo

inicio = produtos[0]

objetivo = produtos[2]


# Executar o algoritmo A*

caminho = recomendador.a_star(inicio, objetivo)


# Exibir o resultado

print("Caminho recomendado:")

for produto in caminho:

    print(produto)
1 resposta

Oii Estudante, tudo bem?

Obrigada por compartilhar esse projeto aqui no fórum! Com certeza vai ajudar outros alunos que estiverem desenvolvendo soluções semelhantes.

A implementação ficou bem estruturada. Você organizou direitinho as responsabilidades em duas classes distintas, a heurística usando probabilidade de conversão negativa faz sentido para inverter a prioridade do heapq (que é um min-heap), e a reconstrução do caminho ao final está correta.

Uma observação vale notar: o heapq compara os elementos da tupla em ordem. Quando dois produtos tiverem a mesma prioridade numérica, o Python vai tentar comparar o segundo elemento da tupla, que é o objeto Produto. Como a classe não define __lt__, isso causaria um TypeError. Uma forma simples de evitar é incluir um contador como desempate:

contador = 0
heapq.heappush(fila, (0, contador, inicio))
contador += 1

# e dentro do loop:
heapq.heappush(fila, (prioridade, contador, vizinho))
contador += 1

Assim o Python nunca precisa comparar os objetos diretamente.

Conte com a Alura para evoluir seus estudos. Em caso de dúvidas, fico à disposição.

Bons estudos!

Sucesso

Imagem da comunidade