Python으로 대화형 Mad Libs 게임 만들기: 초보자 가이드

Vous est-il déjà arrivé de rire de manière incontrôlable en remplissant des mots aléatoires pour créer une histoire hilarante et absurde ? Si tel est le cas, vous avez probablement connu la joie de Mad Libs, un jeu de mots classique qui divertit les gens de tous âges depuis les années 1950.

Mais et si je vous disais que ce jeu simple pourrait aussi être votre porte d'entrée vers le monde passionnant de la programmation Python ?

Qu’est-ce que Mad Libs ?

Mad Libs, à la base, est un jeu de narration à remplir. Les joueurs sont invités à fournir des mots de types spécifiques (noms, verbes, adjectifs, etc.) sans connaître le contexte de l'histoire.

Découvrez les boucles ici : Python Loops : un guide complet pour les débutants

Ces mots sont ensuite insérés dans un récit pré-écrit, aboutissant souvent à un conte comique et absurde qui suscite le rire et la créativité.

Mais Mad Libs est bien plus qu'une simple source de divertissement. Lorsqu'il est traduit en projet de programmation, il devient un outil pédagogique puissant, offrant aux futurs codeurs une manière amusante et engageante d'apprendre les concepts fondamentaux de la programmation.

Configuration de votre environnement Python

Pour commencer, assurez-vous que Python est installé sur votre ordinateur. Vous pouvez le télécharger depuis le site officiel de Python. Pour ce projet, nous utiliserons Python 3.12.7.

Une fois Python installé, ouvrez votre éditeur de texte préféré ou votre environnement de développement intégré (IDE). Les choix populaires pour les débutants incluent IDLE (fourni avec Python), Visual Studio Code ou PyCharm.

Pour ce projet, j'utiliserai Pycharm.

Construire le jeu Mad Libs : étape par étape

Décomposons notre jeu Mad Libs en étapes gérables. Nous commencerons par une version de base et ajouterons progressivement plus de fonctionnalités pour la rendre plus interactive et attrayante.

Vous pouvez trouver le code complet ici.

Pour exécuter ce jeu, vous devrez installer certaines dépendances et l'une d'entre elles est la bibliothèque colorama. Vous pouvez le faire en exécutant :

pip install colorama

Importez certaines des bibliothèques dont nous aurions besoin pour ce projet, notamment ramdom, os colorama

    import random
    import os
    from colorama import init, Fore, Style

Ensuite, nous utiliserions init() qui nous permet d'utiliser une sortie colorée pour améliorer l'interface utilisateur, comme l'affichage des messages de bienvenue en cyan, des erreurs en rouge et de l'histoire terminée en blanc avec un style lumineux.

• Création du modèle d'histoire

Tout d’abord, nous définirons notre modèle d’histoire. Ce sera une chaîne avec des espaces réservés pour les mots que nous voulons que le joueur remplisse. Voici un exemple :

    story_template = """
    Once upon a time, in a {adjective} {noun}, there lived a {adjective} {noun}.
    Every day, they would {verb} to the {noun} and {verb} with their {adjective} {noun}.
    One day, something {adjective} happened! They found a {adjective} {noun} that could {verb}!
    From that day on, their life became even more {adjective} and full of {noun}.
    """

• Collecte de types de mots

Ensuite, nous allons créer une liste des types de mots dont nous avons besoin pour notre histoire :

    word_types = ["adjective", "noun", "adjective", "noun", "verb", "noun", "verb", "adjective", "noun", "adjective", "adjective", "noun", "verb", "adjective", "noun"]

• Demander des mots au joueur

Maintenant, créons une fonction pour demander des mots au joueur :

    def get_word(word_type):
        return input(f"Enter a(n) {word_type}: ")

    def collect_words(word_types):
        return [get_word(word_type) for word_type in word_types]

• Remplir l'histoire

Avec les mots collectés, nous pouvons remplir notre modèle d'histoire :

    def fill_story(template, words):
        for word in words:
            template = template.replace("{" + word_types[words.index(word)] + "}", word, 1)
        return template

• Rassembler tout cela

Créons une fonction principale pour exécuter notre jeu :

    def play_mad_libs():
        print("Welcome to Mad Libs!")
        print("I'll ask you for some words to fill in the blanks of our story.")

        words = collect_words(word_types)
        completed_story = fill_story(story_template, words)

        print("\nHere's your Mad Libs story:\n")
        print(completed_story)

    if __name__ == "__main__":
        play_mad_libs()

Nous avons maintenant une version fonctionnelle de base de notre jeu Mad Libs ! Mais ne nous arrêtons pas là. Nous pouvons le rendre encore plus attrayant et convivial.

Améliorer le jeu

Ajout de plusieurs modèles d'histoires
Pour garder le jeu intéressant, ajoutons plusieurs modèles d'histoire :

    import random

    story_templates = [
        # ... (add your original story template here)
        """
        In a {adjective} galaxy far, far away, a {adjective} {noun} embarked on a {adjective} quest.
        Armed with a {adjective} {noun}, they set out to {verb} the evil {noun} and save the {noun}.
        Along the way, they encountered a {adjective} {noun} who taught them to {verb} with great skill.
        In the end, they emerged {adjective} and ready to face any {noun} that came their way.
        """,
        # ... (add more story templates as desired)
    ]

    def choose_random_template():
        return random.choice(story_templates)

Mise en œuvre d'une fonctionnalité Play Again
Ajoutons la possibilité aux joueurs de jouer plusieurs tours :

    def play_again():
        return input("Would you like to play again? (yes/no): ").lower().startswith('y')

    def mad_libs_game():
        while True:
            template = choose_random_template()
            word_types = extract_word_types(template)
            play_mad_libs(template, word_types)
            if not play_again():
                print("Thanks for playing Mad Libs!")
                break

    def extract_word_types(template):
        return [word.split('}')[0] for word in template.split('{')[1:]]

Ajout de la gestion des erreurs
Pour rendre notre jeu plus robuste, ajoutons quelques gestions d'erreurs :

    def get_word(word_type):
        while True:
            word = input(f"Enter a(n) {word_type}: ").strip()
            if word:
                return word
            print("Oops! You didn't enter anything. Please try again.")

Amélioration de l'expérience utilisateur
Ajoutons un peu de couleur et de mise en forme pour rendre notre jeu plus attrayant visuellement :

    from colorama import init, Fore, Style

    init()  # Initialize colorama

    def print_colored(text, color=Fore.WHITE, style=Style.NORMAL):
        print(f"{style}{color}{text}{Style.RESET_ALL}")

    def play_mad_libs(template, word_types):
        print_colored("Welcome to Mad Libs!", Fore.CYAN, Style.BRIGHT)
        print_colored("I'll ask you for some words to fill in the blanks of our story.", Fore.YELLOW)

        words = collect_words(word_types)
        completed_story = fill_story(template, words)

        print_colored("\nHere's your Mad Libs story:\n", Fore.GREEN, Style.BRIGHT)
        print_colored(completed_story, Fore.WHITE, Style.BRIGHT)

**Saving Stories**
Let's give players the option to save their stories:


    import os

    def save_story(story):
        if not os.path.exists("mad_libs_stories"):
            os.makedirs("mad_libs_stories")

        filename = f"mad_libs_stories/story_{len(os.listdir('mad_libs_stories')) + 1}.txt"
        with open(filename, "w") as file:
            file.write(story)

        print_colored(f"Your story has been saved as {filename}", Fore.GREEN)

    def play_mad_libs(template, word_types):
        # ... (previous code)

        if input("Would you like to save this story? (yes/no): ").lower().startswith('y'):
            save_story(completed_story)

Exécutez le code

Tout d’abord, assurez-vous que Python est installé sur votre système. Vous pouvez vérifier cela en ouvrant un terminal et en tapant.

python --version

ou

python3 --version

Cela devrait renvoyer la version de Python installée sur votre système.
Si Python est installé, vous devez exécuter le script à l'aide de l'interpréteur Python. Au lieu de courir.

./first_test.py

Vous devriez courir :

python first_test.py

ou si vous utilisez spécifiquement Python 3 :

python3 first_test.py

Assurez-vous également que le fichier dispose des autorisations appropriées pour être exécuté. Vous pouvez définir cela avec :

chmod +x first_test.py<br>

Conclusion

Félicitations ! Vous avez maintenant créé un jeu Mad Libs interactif, coloré et riche en fonctionnalités en Python. Ce projet vous a présenté plusieurs concepts de programmation importants :

1. 문자열 조작
2. 사용자 입력 및 출력
3. 함수 및 모듈형 프로그래밍
4. 목록과 목록 이해
5. 파일 I/O 작업
6. 오류 처리
7. 타사 라이브러리(colorama)
8. 무작위 선택
9. While 루프 및 제어 흐름

이 게임을 구축함으로써 재미있는 것을 창조했을 뿐만 아니라 고급 Python 프로젝트를 위한 탄탄한 기반을 마련했습니다. 능숙한 프로그래머가 되기 위한 열쇠는 연습과 실험임을 기억하십시오. 이 게임을 수정하거나, 새로운 기능을 추가하거나, 이러한 개념을 사용하여 완전히 새로운 프로젝트를 만드는 것을 두려워하지 마세요!

Python 여정을 계속하면서 객체 지향 프로그래밍, 그래픽 사용자 인터페이스(GUI), Django 또는 Flask와 같은 프레임워크를 사용한 웹 개발과 같은 고급 주제를 살펴보세요.

여기에서 배운 기술은 소프트웨어 개발의 더욱 복잡한 영역을 위한 훌륭한 발판 역할을 할 것입니다.

즐거운 코딩을 즐기시고 Mad Libs의 모험이 웃음과 배움으로 가득하길 바랍니다!

리소스

• Folium 시작하기
• Visual Studio Code용 20가지 필수 Python 확장
• 웹 스크래핑 및 데이터 추출에 Python 사용
• Python 시작하기
• Folium과 Python으로 대화형 지도 만들기

위 내용은 Python으로 대화형 Mad Libs 게임 만들기: 초보자 가이드의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!