Abrindo Créditos

No momento em que tudo der certo, considere o projeto divertido. Eu construí um projeto CLI amigável ao cliente para entender como funcionam uma classe, métodos e propriedades.

Minha estrutura de diretórios era bastante simples:

└──lib
├── modelos
│ ├── __init__.py
│ └── ator.py
| └── filme.py
├── cli.py
├── debug.py
└── helpers.py
├── Arquivo Pip
├── Pipfile.lock
├── README.md

Como você pode ver pela estrutura, construí uma associação um-para-muitos onde um ator tem muitos filmes. A partir dessa associação meu cardápio entrou em cena.

1. Lista atual de atores
2. Adicionar um ator
3. Excluir um ator
4. Sair do programa

Meu menu acima foi definido por uma função chamada... menu() que estava localizada em meu arquivo cli.py junto com main() que mostra ao usuário o menu CLI:

def main():
    while True:
        welcome()
        menu()
        choice = input("> ").strip()
        if choice == "1":
            actor_list()
        elif choice == "2":
            add_actor()
        elif choice == "3":
            delete_actor()
        elif choice == "4":
            exit_program()
            break
        else:
            print("Invalid choice. Try again.\n")

Esta função específica foi a primeira de muitas em que um loop while junto com instruções if/elif/else foram executadas para dar ao nosso usuário a capacidade de navegar em nossos menus com facilidade.

O cli.py é então concluído com algum bloco de código importante:

if __name__ == "__main__":
    main() 

Este bloco de código diz ao nosso intérprete (Python) para executar nosso arquivo apenas se ele for chamado na linha de comando.

Elenco de apoio

Também havia funções auxiliares envolvidas neste projeto que também usavam um loop while junto com instruções if/elif/else. Um em particular se destaca por mostrar facilidade de navegação ao selecionar, por exemplo, nossa lista atual de atores:

def actor_list():

        actor_list = Actor.get_all()

        if actor_list:
            print("\n*** UPDATED LIST! ***")
            for i, actor in enumerate(actor_list, start=1):
                print(f"{i}. {actor.name}")  

            while True:
                choice = input("Press 'a' to add an actor\n"
                                "Press 'b' for actor profile\n"
                                "Press 'c' to return to the main menu.\n"
                                "Press 'd' delete an actor.\n").lower()
                if choice == 'a':
                    add_actor()
                    break
                elif choice == 'b':
                    actor_profile()
                    break
                elif choice == 'c':
                    return
                elif choice == 'd':
                    delete_actor()
                    break
                else:
                    print("Invalid choice. Please try again.") 
        else:
            print("List empty!")
            while True:
                choice = input("Press 'a' or to add an actor\n"
                        "Press 'b' for main menu.\n").lower()
                if choice == 'a':
                    add_actor()
                    break
                elif choice == 'b':
                    return
                else:
                    print("Invalid choice. Please try again.")

Aqui não apenas me acostumei com o loop while e as instruções if, mas também colhi os benefícios da aparência e da ordem usando enumerate() com um loop for para iterar com um índice em python, permitindo todas as listas ao longo do projeto para ser uma lista ordenada.

Mostre alguma aula

Nossos dois personagens principais, é claro, são as Classes de Ator e Filme. Ambos consistem em código semelhante em termos de métodos de classe ao criar, atualizar ou excluir uma instância daquela classe específica, mas existem diferenças:

Vamos fazer nossa aula de Filme, por exemplo:

class Movie:

    all_movies = {}

    def __init__(self, movie, genre, actor_id, id=None):
        self.id = id
        self.movie = movie
        self.genre = genre
        self.actor_id = actor_id

Como temos nosso projeto configurado onde um ator tem muitos filmes, nossa classe de filme terá um parâmetro/atributo actor_id exclusivo para estabelecer um link entre a instância do filme e um ator específico, permitindo fácil referência às informações do ator.

Agora veja este bloco de código em nossa classe Actor:

   def movies(self):
        from models.movie import Movie
        sql = """
            SELECT * FROM movie
            WHERE actor_id = ?
        """
        CURSOR.execute(sql, (self.id,),)

        rows = CURSOR.fetchall()
        return [
            Movie.instance_from_db(row) for row in rows
        ]

Aqui temos nosso método movies() recuperando todos os filmes associados à instância atual do Actor consultando a tabela do filme usando o ID do ator. Isso retornará uma lista de objetos Movie, estabelecendo um relacionamento "tem muitos" entre Ator e Filme.

Os blocos de código discutidos foram as principais áreas do projeto em que me concentrei em obter mais compreensão. No geral, este projeto serviu como um bom exercício para aprimorar minhas habilidades em python.