Python niveau 7 — Projet final et ouvertures

import turtle
from datetime import datetime

def polygone(t, nb_cotes, longueur):
    for i in range(nb_cotes):
        t.forward(longueur)
        t.left(360 / nb_cotes)

t = turtle.Turtle()
for n in (3, 6, 8):
    polygone(t, n, 80)
turtle.done()

saisie = input("Date de naissance (jj/mm/aaaa) : ")
naissance = datetime.strptime(saisie, "%d/%m/%Y")
print(f"Tu as vécu {(datetime.now() - naissance).days} jours.")

Explication

L’angle extérieur d’un polygone régulier vaut 360 / nb_cotes : c’est de combien la tortue doit tourner à chaque sommet. strptime transforme un texte en date selon un format ; la soustraction de deux dates donne une durée dont .days est le nombre de jours.

class Livre:
    def __init__(self, titre, auteur):
        self.titre = titre
        self.auteur = auteur
        self.emprunte = False

    def emprunter(self):
        if self.emprunte:
            return False
        self.emprunte = True
        return True

    def rendre(self):
        self.emprunte = False

biblio = [Livre("Germinal", "Zola"), Livre("Candide", "Voltaire"), Livre("Nana", "Zola")]
biblio[0].emprunter()
for livre in biblio:
    if not livre.emprunte:
        print(f"Disponible : {livre.titre} ({livre.auteur})")

Explication

__init__ initialise chaque nouvel objet ; self permet à chaque livre d’avoir ses propres valeurs. emprunter() renvoie un booléen pour que le programme sache si l’opération a réussi.

Pour aller plus loin

    def __str__(self):
        etat = "emprunté" if self.emprunte else "disponible"
        return f"{self.titre} ({self.auteur}) - {etat}"

Avec cette méthode ajoutée à la classe, print(livre) affiche directement une description lisible.

import random, json
from datetime import datetime

VIES = 7
FICHIER_SCORES = "scores.json"
ACCENTS = {"é": "e", "è": "e", "ê": "e", "ë": "e", "à": "a", "â": "a",
           "î": "i", "ï": "i", "ô": "o", "ù": "u", "û": "u", "ç": "c"}

def sans_accent(texte):
    return "".join(ACCENTS.get(c, c) for c in texte.lower())

def charger_mots(chemin="mots.txt"):
    try:
        with open(chemin, encoding="utf-8") as f:
            mots = [l.strip().lower() for l in f if l.strip().isalpha()]
        if mots:
            return mots
    except FileNotFoundError:
        pass
    return ["python", "ordinateur", "variable", "fonction", "élève"]

def masquer(mot, trouvees):
    return " ".join(c if sans_accent(c) in trouvees else "_" for c in mot)

def demander_lettre(deja):
    while True:
        l = sans_accent(input("Lettre : ").strip())
        if len(l) != 1 or not l.isalpha():
            print("Une seule lettre, s'il te plaît.")
        elif l in deja:
            print("Déjà proposée.")
        else:
            return l

def jouer_partie():
    mot = random.choice(charger_mots())
    lettres_mot = set(sans_accent(mot))
    trouvees, ratees = set(), set()
    while len(ratees) < VIES and not lettres_mot <= trouvees:
        print(f"\n{masquer(mot, trouvees)}   vies : {VIES - len(ratees)}")
        l = demander_lettre(trouvees | ratees)
        if l in lettres_mot:
            trouvees.add(l)
        else:
            ratees.add(l)
    gagne = lettres_mot <= trouvees
    print(("Gagné ! " if gagne else "Perdu... ") + f"Le mot était : {mot}")
    return mot, len(ratees), gagne

def charger_scores():
    try:
        with open(FICHIER_SCORES, encoding="utf-8") as f:
            donnees = json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        return []
    # on ne garde que les scores bien formés
    return [s for s in donnees if isinstance(s, dict)
            and isinstance(s.get("erreurs"), int) and isinstance(s.get("nom"), str)]

def enregistrer_score(nom, mot, erreurs):
    scores = charger_scores()
    scores.append({"nom": nom, "mot": mot, "erreurs": erreurs,
                   "date": datetime.now().strftime("%d/%m/%Y")})
    with open(FICHIER_SCORES, "w", encoding="utf-8") as f:
        json.dump(scores, f, indent=2, ensure_ascii=False)

def afficher_top5():
    scores = sorted(charger_scores(), key=lambda s: s["erreurs"])
    for i, s in enumerate(scores[:5], 1):
        print(f"{i}. {s['nom'][:20]:<20} {s['erreurs']} erreur(s)  {s.get('date', '')}")

def main():
    while True:
        choix = input("\n1 Jouer  2 Top 5  3 Quitter > ")
        if choix == "1":
            mot, erreurs, gagne = jouer_partie()
            if gagne:
                nom = input("Ton pseudo : ").strip()[:20] or "Anonyme"
                enregistrer_score(nom, mot, erreurs)
        elif choix == "2":
            afficher_top5()
        elif choix == "3":
            break

main()

Nouveautés utilisées : les ensembles (set, collection sans doublons, <= teste l’inclusion), les expressions génératrices dans join et lambda (petite fonction anonyme utilisée comme critère de tri). Chacune se découvre facilement dans la documentation : c’est ta première occasion d’apprendre en autonomie.

Explication

Les ensembles (set) simplifient beaucoup le jeu : lettres_mot <= trouvees vérifie que toutes les lettres du mot ont été trouvées, et trouvees | ratees réunit toutes les lettres déjà proposées. Chaque fonction est testable séparément, par exemple masquer("chat", {"a"}) doit donner _ _ a _.

Pour aller plus loin

# Tests unitaires à placer avant main()
assert sans_accent("Élève") == "eleve"
assert masquer("chat", {"a"}) == "_ _ a _"
assert masquer("été", {"e"}) == "é _ é"