Crédits d'ouverture

À la seconde où tout clique, considérez le projet comme amusant. J'ai construit un projet CLI convivial pour comprendre le fonctionnement d'une classe, de méthodes et de propriétés.

La structure de mes répertoires était assez simple :

└── lib
├── modèles
│ ├── __init__.py
│ └── acteur.py
| └── film.py
├──cli.py
├── debug.py
└── helpers.py
├── Fichier pip
├── Pipfile.lock
├── LISEZMOI.md

Comme vous pouvez le voir d'après la structure, j'ai construit une association un-à-plusieurs dans laquelle un acteur possède de nombreux films. De cette association est né mon menu.

1. Liste actuelle des acteurs
2. Ajouter un acteur
3. Supprimer un acteur
4. Quitter le programme

Mon menu ci-dessus a été défini par une fonction appelée... menu() qui se trouvait dans mon fichier cli.py avec le main() qui montre à l'utilisateur le 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")

Cette fonction particulière était la première d'une longue série où une boucle while avec des instructions if/elif/else était exécutée pour donner à notre utilisateur la possibilité de naviguer facilement dans nos menus.

Le cli.py se termine ensuite par un bloc de code important :

if __name__ == "__main__":
    main() 

Ce bloc de code indique à notre interpréteur (Python) d'exécuter notre fichier uniquement s'il est appelé depuis la ligne de commande.

Casting de soutien

Il y avait également des fonctions d'assistance impliquées dans ce projet qui utilisaient également une boucle while avec des instructions if/elif/else. L'un d'entre eux se démarque particulièrement par sa facilité de navigation lors de la sélection, par exemple, de notre liste actuelle d'acteurs :

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.")

Ici, non seulement je me suis habitué aux instructions while et if, mais j'ai également profité des avantages de l'apparence et de l'ordre en utilisant enumerate() avec une boucle for pour itérer avec un index en python permettant toutes les listes tout au long du projet être une liste ordonnée.

Montrez de la classe

Nos deux personnages principaux sont bien sûr l'acteur de classe et le film. Les deux consistent en un code similaire en termes de méthodes de classe lors de la création, de la mise à jour ou de la suppression d'une instance de cette classe particulière, mais il existe des différences :

Prenons par exemple notre cours Film :

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

Puisque nous avons une configuration de projet dans laquelle un acteur a de nombreux films, notre classe de film aura un paramètre/attribut acteur_id unique pour établir un lien entre l'instance de film et un acteur spécifique, permettant une référence facile aux informations de l'acteur.

Regardez maintenant ce bloc de code dans notre classe Acteur :

   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
        ]

Ici, notre méthode movies() récupère tous les films associés à l'instance d'acteur actuelle en interrogeant la table movie à l'aide de l'ID de l'acteur. Cela renverra ensuite une liste d'objets Movie, établissant une relation "à plusieurs" entre l'acteur et le film.

Les blocs de code discutés étaient les principaux domaines du projet sur lesquels je me suis concentré sur une meilleure compréhension. Dans l'ensemble, ce projet a été un bon exercice pour améliorer mes compétences en python.