Categories
Apprentissage Python

Jeu de Roulette – Python Orienté Objet (POO)

Ça y est, c’est fait… Je viens de terminer mon programme du jeu de roulette en Python orienté objet ! Et je peux vous dire que je suis vraiment contente d’y être arrivée… 😀

En détail, ça donne quoi ?

J’ai donc créé deux objets :
l’objet « joueur » qui est défini par son pseudo, son porte-monnaie (l’argent qu’il a au départ), le numéro sur lequel il mise et la somme qu’il mise sur ce numéro.
l’objet « jeu » qui est défini par un numéro gagnant et un calcul des gains.

Pour simplifier la visualisation de ces objets, j’ai créé 2 fichiers distincts enregistrés dans le même dossier que le fichier avec mon programme final (ce qui permet d’appeler plus facilement ces fichiers).

L’objet « Joueur »

Pour chaque caractéristique de mon objet « Joueur », j’ai défini une fonction (ou méthode) qui sera utilisée dans le programme final.
Je me suis servi du code que j’avais déjà créé lors de mon premier programme : j’en ai extrait les éléments nécessaires et les ai amélioré pour un meilleur fonctionnement du programme.

Voici le code de mon objet « Joueur » :

class Joueur:
    """Classe définissant un joueur de roulette caractérisé par :
    - son pseudo ;
    - son porte monnaie ;
    - un numéro misé
    - une somme misée   """

    
    def __init__(self, pseudo, porte_monnaie, numero_mise, somme_misee):
        """Constructeur de notre classe"""
        self.pseudo = pseudo
        self.porte_monnaie = porte_monnaie
        self.numero_mise = numero_mise
        self.somme_misee = somme_misee

    def nom_joueur(self, pseudo):
        """Méthode permettant de vérifier que le nom du joueur n'est pas un chiffre et de l'afficher   """
        NomCorrect = False
        while NomCorrect == False :
            self.pseudo = input("Quel est votre nom ?")
            #self.pseudo = 'Anonyme' if len(self.pseudo) == 0 else self.pseudo
            try:
                int(self.pseudo) != False
            except ValueError:
                print("Bienvenue {} sur la table de la Roulette du Zcasino !".format(self.pseudo))
                NomCorrect = True
            else :
                print("Il y a une erreur, êtes vous certain de votre frappe ?")



    def argent_joueur(self, porte_monnaie):
        """Méthode permettant de vérifier que le joueur a de l'argent pour jouer"""
        Argent = False
        while Argent == False :
            self.porte_monnaie = input("\nAvec quelle somme d'argent souhaitez vous jouer ? ")
            try:
                int(self.porte_monnaie) != False
            except ValueError:
                print("Il y a une erreur, êtes vous certain de votre frappe ?")
            else :
                self.porte_monnaie = int(self.porte_monnaie)
                if self.porte_monnaie < 1 :
                    print("Vous ne pouvez pas jouer sans argent !")
                else :
                    Argent = True

    def num_joueur(self, numero_mise):
        """Méthode permettant de vérifier que le joueur a bien misé sur un numéro de la roulette"""
        Numero = False
        while Numero == False :
            self.numero_mise = input("\nSur quel numéro souhaitez vous miser (entre 0 et 49) ? : ")
            try:
                int(self.numero_mise) != False
            except ValueError:
                print("Il y a une erreur, êtes vous certain de votre frappe ?")
            else :
                self.numero_mise = int(self.numero_mise)
                if self.numero_mise < 0 or self.numero_mise > 49:
                    print("Le numéro choisi n'existe pas, veuillez en choisir un autre !")
                else :
                    Numero = True
    
    def mise_joueur(self, somme_misee):
        """ Methode permettant de vérifier que le joueur mise l'argent qu'il a dans son porte monnaie """
        Mise = False
        while Mise == False :
            self.somme_misee = input("\nQuelle somme souhaitez vous miser sur ce numéro ? : ")
            try:
                int(self.somme_misee) != False
            except ValueError :
                print("Etes vous certain de votre frappe ?")
            else :
                self.somme_misee = int(self.somme_misee)
                if self.somme_misee < 0:
                    print("Vous ne pouvez pas miser un nombre négatif !")
                elif self.somme_misee > self.porte_monnaie:
                    print("Vous n'avez pas assez d'argent !")
                else :
                    Mise = True
L’objet « Jeu »

Cet objet est plus simple, car il ne contient qu’une seule fonction : celle du calcul des gains.
Il y a une petite particularité importante à prendre en compte : seule la variable « gain » est associée à l’objet. Lors de la rédaction de la fonction de l’objet, il n’y aura donc que cette variable qui sera nommée avec « self.~ ».

Voici le code de mon objet « Jeu »

class Jeu:
    """Classe définissant le jeu de la roulette caractérisé par :
    - un numéro gagnant ;
    - un gain rapporté    """

    
    def __init__(self, gagne, gain):
        """Constructeur de notre classe"""
        self.gagne = gagne
        self.gain = gain

    import random
    def num_gagnant(self, gagne):
        """Méthode permettant de selectionner le numéro gagnant   """
        self.gagne = random.randrange(50)
        print("Le numéro gagnant est le numéro ", self.gagne)
        
    import math
    def gain_partie(self, gagne, somme_misee, numero_mise, gain):
        """Méthode permettant de déterminer le gain du joueur en fonction du numéro gagnant  """
        import math
        if gagne != numero_mise :
            if (self.gagne %2 == 0 and numero_mise %2 == 0) or (gagne %2 != 0 and numero_mise %2 != 0):
                self.gain = math.ceil(somme_misee * 0.5)
                print("\n Vous avez misé sur la bonne couleur, vous gagnez {} $".format(self.gain))
            else:
                print("\n Loupé, Vous venez de perdre votre mise !")
                self.gain = -somme_misee                
        else:
            self.gain = 3 * somme_misee
            print("\n Votre gain est de 3 fois votre mise, soit {} $".format(self.gain))
Le programme final

J’ai ensuite remplacé dans mon programme initial tous les morceaux mis dans mes objets par l’appel des objets eux-mêmes.
Là j’ai eu a me creuser les méninges, car un remplacement brut ne marche pas… 😉
Déjà, il faut bien penser à importer les 2 fichiers objets.

import ZCasino_jeu
import ZCasino_joueur

Ensuite, l’appel des objets et de ses fonctions doit être fait correctement.
J’ai commencé par créer les variables et je les ai mises nulles au départ. Puis j’ai créé le « joueur1 » auquel j’ai attribué mon objet « Joueur » (récupéré depuis mon fichier).

# appel de variables 'nulles'
pseudo = 0
porte_monnaie = 0
numero_mise = 0
somme_misee = 0

# description du joueur
joueur1 = ZCasino_joueur.Joueur(pseudo, porte_monnaie, numero_mise, somme_misee)

Puis j’ai appelé les différentes fonctions du joueur.
Il ne faut pas oublier d’attribuer les fonctions directement au « joueur1 » ! 😉

pseudo = joueur1.nom_joueur(pseudo)
porte_monnaie = joueur1.argent_joueur(porte_monnaie)
# ...
numero_mise = joueur1.num_joueur(numero_mise)
# ...
somme_misee = joueur1.mise_joueur(somme_misee)

Lors du calcul des gains, j’ai ensuite créé la variable « gain » nulle pour pouvoir créer le système de calcul en appelant mon objet « Jeu » (via le fichier !).

 # gains
        gain = 0
        jeu = ZCasino_jeu.Jeu(gagne, gain)
        gain = jeu.gain_partie(gagne, joueur1.somme_misee, joueur1.numero_mise, gain)

Il reste ensuite à mettre à jour le porte-monnaie du « joueur1 ».

joueur1.porte_monnaie = joueur1.porte_monnaie + jeu.gain
        print("Il vous reste donc {} $ pour continuer de jouer.".format(joueur1.porte_monnaie))

Et voila le programme est fait ! 😉

Le voici complet :

import os
import random
import math
import ZCasino_jeu
import ZCasino_joueur


# ****** programme du jeu de la roulette **********
print("Bienvenue au ZCasino, voici le jeu de la Roulette !")

# appel de variables 'nulles'
pseudo = 0
porte_monnaie = 0
numero_mise = 0
somme_misee = 0
# description du joueur
joueur1 = ZCasino_joueur.Joueur(pseudo, porte_monnaie, numero_mise, somme_misee)
pseudo = joueur1.nom_joueur(pseudo)
porte_monnaie = joueur1.argent_joueur(porte_monnaie)
# début du jeu
j=1
while j != 0 :
        # numéro choisi par le joueur
        numero_mise = joueur1.num_joueur(numero_mise)
        # choisir sa mise
        somme_misee = joueur1.mise_joueur(somme_misee)
        print("\n Votre mise est de {} $ sur le numéro {} \n".format(joueur1.somme_misee, joueur1.numero_mise))
        # lance la roulette
        print("A vos jeux... La roulette est lancée... \n")
        gagne=random.randrange(50)
        print("Le numéro gagnant est le numéro ", gagne)
        # gains
        gain = 0
        jeu = ZCasino_jeu.Jeu(gagne, gain)
        gain = jeu.gain_partie(gagne, joueur1.somme_misee, joueur1.numero_mise, gain)
        # argent restant au joueur
        joueur1.porte_monnaie = joueur1.porte_monnaie + jeu.gain
        print("Il vous reste donc {} $ pour continuer de jouer.".format(joueur1.porte_monnaie))
        # possibilité de rejouer ou non
        if joueur1.porte_monnaie == 0:
                print("\nVous n'avez plus d'argent ! Au revoir et à bientôt au ZCasino ")
                j=0
        else:
                r=input(" Voulez vous rejouer ? (O / N) ")
                if r == "O" or r == "o" :
                        j=1
                else:
                        print("Au revoir et à bientôt au ZCasino ")
                        j=0

os.system("pause")   # met en pause le système Windows

Pour conclure

Voici une citation qui correspond tout à fait à mon état d’esprit après ma réussite.

Car oui, je suis fière d’avoir réussi cette étape ! 🙂


Categories
Apprentissage Python

Python et la programmation Orientée Objet

Allez, je me lance dans l’aventure de l’orienté objet en Python…

Mais qu’est ce que c’est ?

En Python (ainsi que dans d’autres langages), il est possible de faire des programmes dits « orientés objets ».

Pour cela, il faut définir une classe. C’est la représentation informatique d’un objet issu du monde réel.

L’exemple le plus simple pour comprendre est le cas d’une voiture.

Résultat de recherche d'images pour "objet python"

On définit une classe « Voiture ».
Les objets de cette classe contiennent des attributs ou caractéristiques : « Marque », « Couleur », « Moteur », « Nombre de roues », etc.
Ainsi que des méthodes ou actions à effectuer : « Démarrer », « Accélérer », « Ralentir », etc.

Chaque objet sera ensuite défini selon ses attributs et ses méthodes, l’objet est alors une instance de la classe.

Nous pourrons donc définir des objets différents, par exemple :
– la voiture de Jonathan, qui est de couleur rouge avec une vitesse de 30 km/h,
– la voiture de Denis, qui est de couleur grise avec une vitesse de 50 km/h,
– etc.

Comment coder un objet en Python ?

On définit en premier la « class ».
Puis on ajoute un constructeur permettant qu’un certain nombre d’actions puissent être réalisées. Un constructeur n’est rien d’autre qu’une méthode, sans valeur de retour, qui porte un nom imposé par le langage Python : « __init__( ) ». Il peut avoir plusieurs paramètres, sachant qu’au minimum le paramètre « self » lui sera attribué.
Puis on incrémente avec d’autres méthodes permettant de caractériser chaque action de l’objet.

class Voiture ():
    def __init__(self, nom, couleur, vitesse):
        self.nom = nom
        self.couleur = couleur
        self.vitesse = vitesse
    def Avance(self):
        print("La voiture {} de {} roule à {} km/h ".format(couleur, nom, vitesse))

Voiture1 = Voiture("Jonhatan", "rouge", 30)
Voiture2 = Voiture("Denis", "grise", 50)

Voiture1.Avance()
La voiture rouge de Jonhatan roule à 30 km/h
Mise en application

J’ai donc décidé de retravailler mon code pour le jeu de la roulette en orienté objet.
Le code fera l’affaire d’un prochain post

À bientôt pour le découvrir ! 😉

Categories
Apprentissage Découverte Python

Le jeu du Pong

Vous connaissez tous le jeu du Pong ?

Mais si, le jeu du Pong c’est ce jeu où l’on doit faire rebondir une balle entre deux barres…
Vous ne voyez toujours pas ?

PongGame

Le voici :


Aujourd’hui je suis allée voir un tuto sur YouTube de FreeCodeCamp : https://youtu.be/XGf2GcyHPhc pour réaliser le jeu du Pong.

J’ai réalisé le jeu en même temps que la vidéo.
C’était ma petite partie récréative pour me réconcilier avec Python (car en ce moment j’ai une overdose du cours que je suis sur OpenClassrooms; et surtout des classes et méthodes qui sont pour moi imbuvables ! 😉 )

Alors le principe est simple : il faut créer une fenêtre avec des dimensions précises, des barres et une balle. Puis programmer pour que tout se déplace, que la balle rebondisse et que les scores s’affichent…

Simple comme bonjour ? Presque…

J’ai suivi la vidéo et j’ai dû faire quelques modifications pour que le programme marche sur mon ordinateur !

  • Tout d’abord, j’ai fait des erreurs de frappe. Par exemple pour le déplacement des barres, j’ai oublié de mettre le signe négatif pour le déplacement en bas… Ce qui fait que, quelle que soit la touche paramétrée utilisée, ma barre se déplaçait uniquement en haut !
# Function
def paddle_a_up():
    y = paddle_a.ycor()
    y += 20
    paddle_a.sety(y)

def paddle_a_down():
    y = paddle_a.ycor()
    y += -20
    paddle_a.sety(y)
  • Le déplacement de la balle était bien trop rapide avec une valeur de 2. J’ai donc diminué progressivement jusqu’à 0.1 pour que la balle se déplace suffisamment lentement pour pouvoir jouer sans perdre dès le début !
ball.dx = 0.1			# speed
ball.dy = -0.1			# speed
  • Lorsque je suis passée au codage du déplacement de la balle, la balle doit toujours se retrouver au milieu après être sortie sur un côté. Mon code a marché lorsque j’ai supprimé les espaces dans la ligne.
if ball.xcor() > 390:  # right side of the screen
    ball.goto(0,0)
    ball.dx *= -1

if ball.xcor() < -390:  # left side of the screen
    ball.goto(0,0)
    ball.dx *= -1
  • Pour les conditions permettant à la balle de « rebondir » sur les barres, je n’avais pas mis toutes les parenthèses nécessaires. Ce qui provoquait un arrêt du programme…
# Paddle and ball collisions
if (ball.xcor() > 340 and ball.xcor() < 350) and (ball.ycor() < paddle_b.ycor() + 40 and ball.ycor() > paddle_b.ycor() -40):
    ball.setx(340)
    ball.dx *= -1

if (ball.xcor() < -340 and ball.xcor() > -350) and (ball.ycor() < paddle_a.ycor() + 40 and ball.ycor() > paddle_a.ycor() -40):
    ball.setx(-340)
    ball.dx *= -1

Finalement, ce moment récréatif a été très instructif !
En effet, même en ayant le modèle sous les yeux, j’ai eu quelques bugs qui m’ont permis de réfléchir et donc de m’améliorer !!! 🙂

De plus j’ai découvert une nouvelle bibliothèque : « turtle » qui permet notamment de dessiner des lignes. Et ça c’est top ! 😎


Et voici le code final !

# Simple Pong
# By @TokyoEdTech

import turtle

wn = turtle.Screen()
wn.title("Pong by @TokyoEdTech")
wn.bgcolor("black")
wn.setup(width=800, height=600)
wn.tracer(0)

# Score
score_a = 0
score_b = 0

# Paddle A
paddle_a = turtle.Turtle()
paddle_a.speed(0)
paddle_a.shape("square")
paddle_a.color("white")
paddle_a.shapesize(stretch_wid=5, stretch_len=1)
paddle_a.penup()
paddle_a.goto(-350, 0)

# Paddle B
paddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5, stretch_len=1)
paddle_b.penup()
paddle_b.goto(350, 0)

# Ball
ball = turtle.Turtle()
ball.speed(0)
ball.shape("square")
ball.color("white")
ball.penup()
ball.goto(0, 0)
ball.dx = 0.2			# speed
ball.dy = -0.2			# speed

# Pen
pen = turtle.Turtle()
pen.speed(0)
pen.color("white")
pen.penup()
pen.hideturtle()
pen.goto(0, 260)
pen.write("Player A: 0  Player B: 0", align="center", font=("Courier", 24, "normal"))

# Function
def paddle_a_up():
    y = paddle_a.ycor()
    y += 20
    paddle_a.sety(y)

def paddle_a_down():
    y = paddle_a.ycor()
    y += -20
    paddle_a.sety(y)

def paddle_b_up():
    y = paddle_b.ycor()
    y += 20
    paddle_b.sety(y)

def paddle_b_down():
    y = paddle_b.ycor()
    y += -20
    paddle_b.sety(y)

# Keyboard binding
wn.listen()
wn.onkeypress(paddle_a_up, "a")
wn.onkeypress(paddle_a_down, "q")
wn.onkeypress(paddle_b_up, "p")
wn.onkeypress(paddle_b_down, "m")

# Main game loop
while True:
    wn.update()

    # Move the ball
    ball.setx(ball.xcor() + ball.dx)
    ball.sety(ball.ycor() + ball.dy)

    # Border checking
    if ball.ycor() > 290:    # top of the screen
        ball.sety(290)
        ball.dy *= -1

    if ball.ycor() < -290:   # bottom of the screen
        ball.sety(-290)
        ball.dy *= -1

    if ball.xcor() > 390:  # right side of the screen
        ball.goto(0,0)
        ball.dx *= -1
        score_a += 1
        pen.clear()
        pen.write("Player A: {}  Player  B: {}". format(score_a, score_b), align="center", font=("Courier", 24, "normal"))

    if ball.xcor() < -390:  # left side of the screen
        ball.goto(0,0)
        ball.dx *= -1
        score_b += 1
        pen.clear()
        pen.write("Player A: {}  Player  B: {}". format(score_a, score_b), align="center", font=("Courier", 24, "normal"))

    # Paddle and ball collision
    if (ball.xcor() > 340 and ball.xcor() < 350) and (ball.ycor() < paddle_b.ycor() + 40 and ball.ycor() > paddle_b.ycor() -40):
        ball.setx(340)
        ball.dx *= -1

    if (ball.xcor() < -340 and ball.xcor() > -350) and (ball.ycor() < paddle_a.ycor() + 40 and ball.ycor() > paddle_a.ycor() -40):
        ball.setx(-340)
        ball.dx *= -1
Categories
Apprentissage Python

Deuxième TP, deuxième casse-tête !

Bonjour à tous ! 🙂

Voilà 3 jours que je travaille sur mon deuxième TP (quel casse-tête!) : le jeu du Pendu…
Et je vous avouerais que j’ai fait face à de nombreuses difficultés !

Après avoir bien visualisé mon code, puis commencé la rédaction simplifiée, je me suis lancée dans l’écriture complète du programme.
J’ai réalisé beaucoup d’essais pour réussir à faire fonctionner mon jeu.
Et notamment pour trouver comment :

Afficher le mot sous forme de mot mystère (avec des étoiles)

J’ai d’abord mis le mot sélectionné sous forme de liste en utilisant la recherche dans une chaîne de caractères :

mon_mot = [ lettre for lettre in m]

Ici, la liste – que j’ai nommée « mon_mot » – va être créée en prenant le mot « m » lettre après lettre et en ajoutant chaque caractère comme un objet de la liste.

Sur le même principe, j’ai créé le mot mystère comme étant une liste où chaque objet (lettre) de « mon_mot » est remplacé par une étoile.

mystere = [" * " for lettre in mon_mot]

Bonus : pour un affichage sans les crochets caractéristiques de la liste, j’ai utilisé le paramètre « en liste » lors de l’exécution de « print » :

print(*mystere)
Trouver la lettre demandée dans le mot (surtout quand il y a plusieurs fois la même lettre !)

Ici, j’ai créé une boucle de recherche dans toute la liste pour que toutes les lettres identiques puissent être trouvées.

J’ai d’abord demandé de compter le nombre de lettres identiques dans le mot :

compte_lettre = m.count(choix_lettre)

Puis j’ai mis comme paramètre d’arrêt de la boucle sur ce nombre :

i=0
while i != compte_lettre :
    rech_lettre = mon_mot.index(choix_lettre)
    mon_mot[rech_lettre] = "*"
    mystere[rech_lettre] = choix_lettre
    i += 1
Arrêter le programme lorsque le mot est trouvé

Ce point fut plus compliqué à démêler, car j’arrivais à finir le mot sans que le programme passe ensuite au calcul des scores…

Dans un premier temps, il faut arrêter la recherche de lettre.
Pour ça, il faut qu’à chaque lettre trouvée la longueur du mot « m » diminue.
Et j’ai mis une condition « if » sur cette longueur qui doit être strictement inférieure à 1 (si c’est à 0, après avoir trouvé toutes les lettres, le programme me demande encore une lettre !) :

long = len(m)
compte_lettre = m.count(choix_lettre)
if long > 1 :
    # recherche et remplacement de la lettre - voir au dessus #
    long = long - compte_lettre

La fin de la condition « if » ainsi créée permet ensuite de sortir du programme en ayant trouvé le mot. Et pour arrêter complètement la boucle, j’ai utilisé la fonction « break » :

else :
    print("\nBravo, vous avez trouvé le mot mystere : ", m )
    break

Casse-tête résolu ! 🙂
J’ai donc sorti un programme permettant de jouer au Pendu, dont voici le code :

# -*-coding:Latin-1 -*

# ************* Programme du jeu du Pendu ***************
import os
import random

print("Bienvenue dans le jeu du Pendu ! \n")

pseudo = input("Quel est votre nom ? ")  #*** joueur
score = 0   #*** score nul pour débuter
print("\nL'ordinateur va choisir aléatoirement un mot à découvrir.\n\
      Vous avez 8 chances pour y arriver ! \n\
      C'est parti...")
mot_mystere = ["vision", "bateau", "chouette", "bonjour", "amour", "festival"]
no_mot = random.randrange(6) # **** recherche aléatoire du mot dans liste données
m=mot_mystere[no_mot]
long = len(m)
print("\nLe mot mystère comporte ", long, " lettres à trouver :")
mon_mot = [ lettre for lettre in m]   # *** extraire le mot sous forme de liste par lettre
mystere = [" * " for lettre in mon_mot]   # *** remplace les lettres par une *
print(*mystere)
print("\nA vous de le trouver ! ")
essai = 8
while essai > 0 :
    choix_lettre = input("\nTapez une lettre :   ")
    choix_lettre = choix_lettre.lower()  # *** mettre la mettre en minuscule
    compte_lettre = m.count(choix_lettre)
    try :
        rech_lettre = mon_mot.index(choix_lettre)   # *** recherche la lettre dans le mot
    except ValueError :  # *** si la lettre n'est pas dans le mot
        try :
            choix_lettre != int(choix_lettre)  # *** vérifie que ce n'est pas un nombre
        except ValueError :
            print("Cette lettre n'est pas dans le mot mystère")
            essai = essai -1
            print("Il vous reste ", essai, " coups")
            coup_rest = essai
        else :
            print("Etes vous sûr de votre frappe ?")
    else :  
        if long > 1 :
            i=0
            while i != compte_lettre :   # *** si lettre ds mot, remplacer *
                rech_lettre = mon_mot.index(choix_lettre)
                mon_mot[rech_lettre] = "*"
                mystere[rech_lettre] = choix_lettre
                i += 1
            long = long - compte_lettre
        else :  # *** mot entièrement trouvé
            print("\nBravo, vous avez trouvé le mot mystere : ", m )
            break
        print(*mystere)
        print("Il vous reste ", essai, " coups")
# *** calcul du score
score = score + coup_rest
if coup_rest == 0 :  # *** mention spéciale si le mot n'a pas été trouvé
    print("\nVous avez perdu ! Le mot mystère était : ", m)
print("\n", pseudo, " , votre score est de : ", score, " points")

os.system("pause")   # met en pause le système Windows

Pour mémoire, voici le lien de l’énoncé : https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232565-tp-realisez-un-bon-vieux-pendu


Je vous vois venir…
Vous allez me dire :  » c’est bien beau tout ça, mais tu n’as pas réalisé le TP exactement comme demandé dans le cours ! »
Exact !
Tout simplement parce que je voulais vous proposer un début de solution à ce casse-tête avant de continuer à bosser dessus… Car je dois faire des recherches plus approfondies sur la lecture/écriture dans un fichier !


La suite dans un prochain post ! 😉

Categories
Apprentissage Conseil Python

Faire travailler ses méninges !

Aujourd’hui, j’ai travaillé d’arrache-pied sur mon 2ème TP : le jeu du Pendu.
Et pour une débutante comme moi, il y a beaucoup de travail… J’ai donc pas mal fait travailler mes méninges ! 😉

Pour mémoire, voici le lien vers le TP :
https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232565-tp-realisez-un-bon-vieux-pendu 

Après avoir visualisé mon code, j’ai commencé à l’écrire.
J’ai d’abord codé les passages les plus faciles pour moi, et j’ai mis des commentaires pour les passages sur lesquels j’avais du mal.

Ensuite, j’ai fait des petits morceaux de tests pour vérifier que mon code fonctionnait comme demandé dans l’énoncé…
J’ai aussi fait des recherches sur les différentes fonctions à utiliser pour compléter certaines parties…

Petit à petit, mon code prend forme.
Et il va me falloir encore travailler quelques heures et faire plusieurs recherches pour le finaliser !


Je mets cette citation ici pour ne pas oublier que rien n’est désespéré !


Categories
Apprentissage Conseil Python

Visualiser son code

Je m’attaque à un nouveau programme : celui du jeu du Pendu.
Vous savez, ce jeu où l’on doit retrouver un mot en le découvrant une lettre après l’autre avant d’être « pendu »…

Jeu du Pendu

Dans l’énoncé de l’exercice, il y a beaucoup de paramètres à prendre en compte. Et tous doivent être exécutés dans le bon ordre pour que le programme marche correctement !

Voici l’énoncé : https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232565-tp-realisez-un-bon-vieux-pendu

Et pour être sûre de ne pas me tromper dans mon code, il a fallu que je dessine de façon algorithmique les différentes étapes du programme…

Voyez par vous même ci contre –>

Merci Pierre 😉


Important !

Visualiser son programme est très important pour ne pas faire d’erreur dans les différentes étapes du code.

Alors n’oubliez pas de commencer un nouveau programme
par la Visualisation !


Categories
Apprentissage Python

Résolution de problème

Souvenez-vous… J’avais partagé avec vous mon premier TP : le programme d’un jeu de roulette – le ZCasino.

Il s’avère que mon programme est facilement « plantable »…
Et sur de nombreux points en plus ! 😮

Alors voici les remarques et ma résolution de problème (ou plus simplement ma correction !).

  1. Au départ, j’ai une erreur lorsque je ne tape pas un entier alors que le programme en attend un.
  2. La gestion des paris négatifs n’est pas prise en compte… Du coup, je perds mais je gagne !
  3. Si je mise plus d’argent que je n’en ai apporté, je me retrouve à découvert !
  4. Miser sur un numéro négatif est permis…

Dans mon programme, je n’ai pas mis de conditions sur mes différentes variables pour vérifier qu’elles étaient bien des chiffres valables.
De plus, je me suis rendu compte qu’il ne faut pas oublier de mettre une boucle pour que la condition se répète jusqu’à ce que l’utilisateur tape la valeur attendue. 


Il est donc vraiment important de toujours vérifier son code.
Dans tous les sens, même si on se dit que cela ne pourra jamais arriver.

Parce que si, tout est possible !

Alors, prenez le temps de tester et retester votre code.
Et surtout, soumettez le à une tierce personne, ou plusieurs.
Car elle(s) sera(seront) bien plus maligne(s) que vous pour trouver comment faire planter votre programme !

Merci Romain 😉


Je vous mets ci-dessous mon code corrigé si vous souhaitez l’essayer 🙂

# ****** programme du jeu de la roulette **********
print("Bienvenue au ZCasino, voici le jeu de la Roulette !")
import random
import math
# Somme disponible au départ
a = input("\nAvec quelle somme d'argent souhaitez vous jouer ? ")
while type(a) != int:
        try:
                int(a) == True
        except ValueError:
                print("Il y a une erreur, êtes vous certain de votre frappe ?")
                a = input("Avec quelle somme d'argent souhaitez vous jouer ? ")
        else :
                a = int(a)
                if a < 1 :
                        print("Vous ne pouvez pas jouer sans argent !")
                        a = input("Avec quelle somme d'argent souhaitez vous jouer ? ")
# début du jeu
j=1
while j != 0 :
        # numéro choisi par le joueur
        num_joueur = input("\nSur quel numéro souhaitez vous miser (entre 0 et 49) ? : ")
        while type(num_joueur) != int:
                try:
                        int(num_joueur) == True
                except ValueError:
                        print("Il y a une erreur, êtes vous certain de votre frappe ?")
                        num_joueur = input("Sur quel numéro souhaitez vous miser (entre 0 et 49) ? : ")
                else :
                        num_joueur = int(num_joueur)
                        if num_joueur < 0 or num_joueur > 49:
                                print("Le numéro choisi n'existe pas, veuillez en choisir un autre !")
                                num_joueur = input("Sur quel numéro souhaitez vous miser (entre 0 et 49) ? : ")
        # choisir sa mise
        mise = input("\nQuelle somme souhaitez vous miser sur ce numéro ? : ")
        while type(mise) != int :
                try:
                        int(mise) == True
                except ValueError :
                        print("Etes vous certain de votre frappe ?")
                        mise = input("Quelle somme souhaitez vous miser sur ce numéro ? : ")
                else :
                        mise = int(mise)
                        if mise <0:
                                print("Vous ne pouvez pas miser un nombre négatif !")
                                mise = input("Quelle somme souhaitez vous miser sur ce numéro ? : ") 
                        elif mise >a:
                                print("Vous n'avez pas assez d'argent !")
                                mise = input("Quelle somme souhaitez vous miser sur ce numéro ? : ")
        print("\n Votre mise est de ", mise, "$ sur le numéro ", num_joueur, "\n")
        # lance la roulette
        print("A vos jeux... La roulette est lancée... \n")
        jeu=random.randrange(50)
        print("Le numéro gagnant est le numéro ", jeu)
        # résultats et gains
        if jeu != num_joueur :
                if (jeu %2 == 0 and num_joueur %2 == 0) or (jeu %2 != 0 and num_joueur %2 != 0):
                        gain = math.ceil(mise * 0.5)
                        print("\n Vous avez misé sur la bonne couleur, vous gagnez ", gain, "$")
                        a = a + gain
                else:
                        gain = 0
                        print("\n Loupé, Vous venez de perdre votre mise !")
                        a = a - mise
        else:
                gain = 3 * mise
                print("\n Votre gain est de 3 fois votre mise, soit ", gain, "$")
                a = a + gain
        print("Il vous reste donc ", a, " $ pour continuer de jouer.")
        # possibilité de rejouer ou non
        if a == 0:
                print("\nVous n'avez plus d'argent ! Au revoir et à bientôt au ZCasino ")
                j=0
        else:
                r=input(" Voulez vous rejouer ? (O / N) ")
                if r == "O" or r == "o" :
                        j=1
                else:
                        print("Au revoir et à bientôt au ZCasino ")
                        j=0
Categories
Apprentissage Python

Des listes, et des dictionnaires…

Je viens de me frotter aux listes… Et là, il y a de quoi faire !
On peut en créer de toutes sortes. Le plus important à retenir c’est qu’une liste est caractérisée par son index.

J’ai donc appris à créer une liste, à supprimer ou insérer des éléments. Et surtout, je sais enfin comment faire une recherche et modifier une liste !!! 😉

Je suis ensuite passée aux dictionnaires.
Ils fonctionnent comme les listes, sauf qu’ils sont caractérisés par des mots clés et n’ont donc pas d’ordre précis.
Ce qui rend les modifications et les recherches plus faciles : plus besoin de se souvenir de l’index de l’élément cherché, il suffit de passer par sa clé !


Petit exercice pratique

Trier un inventaire de fruits sous forme de liste.
(lien de l’énoncé : https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/232143-creez-des-listes-et-des-tuples-2-2#/id/r-2232422 )

Et voici mon code :

inventaire = [
    ("pommes", 22),
    ("melons", 4),
    ("poires", 18),
    ("fraises", 76),
    ("prunes", 51),
    ]
# met les quantités en premier
inventaire_trie = [(qte, fruit) for fruit, qte in inventaire]

print(inventaire_trie)  # vérifie l'affichage

inventaire = inventaire_trie.sort(reverse = True)  # trie dans l'ordre croissant
inventaire = [(fruit, qte) for qte, fruit in inventaire_trie]  # remet la liste avec les fruits en premier

print(inventaire)  # affiche le résultat final
Categories
Apprentissage Python

Le monde merveilleux des objets !

Le monde merveilleux des objets

Aujourd’hui, je viens de faire connaissance avec les objets…

Enfin, plutôt de découvrir qu’en langage Python il faut tout considérer comme étant « objets » (les chaines de caractères, les variables, les fonctions, etc.)

Et le top avec les objets c’est qu’on peut leur faire faire de nombreuses choses.

Les exemples sont nombreux !
Mettre en forme les chaines de caractères, les formater, les ajouter…
On peut créer des listes, les parcourir ou sélectionner des éléments de cette liste…
etc.

Bref, la découverte de Python est pleine de (bonnes) surprises. Et ces dernières permettront à coup sûr de réaliser des (petits) programmes intéressants !


En parlant de programme, vous vous demandez sûrement ce qu’il en est de mon projet perso ?
Un peu de patience, j’ai des idées que je vous présenterai lorsque j’aurai mieux avancé dans mon apprentissage ! 🙂


Categories
Apprentissage Python

Premier TP, premier casse-tête

Aujourd’hui, j’ai réalisé mon premier TP : écrire un programme en Python pour simuler le célèbre jeu de Casino, la Roulette !

Le lien vers le TP c'est ici :
https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/231735-tp-tous-au-zcasino 

Après avoir bien revu toutes les notions apprises hier, je me suis lancée…
Heureusement, le cours est bien expliqué ! J’ai donc tout écrit sur une feuille pour mettre les idées au clair. C’est important de prendre le temps de bien tout décortiquer quand on est débutant ! Ça permet de moins galérer pour écrire le code.

Ensuite, je suis passée à la rédaction sur l’éditeur Python (IDLE).
De façon simple dans un premier temps, en écrivant ou codant toutes les informations nécessaires : ce que doit renseigner le joueur, le déroulement du jeu, les façons de gagner (j’ai écrit en français ce que je n’arrivais pas à coder directement !).

Puis au fur et à mesure, j’ai enrichi mon code pour avoir mon premier programme !

Je l’ai testé et là… loupé !
Mon code ne fonctionnait pas… 🙁

À force de persévérance, j’ai fini par faire fonctionner mon programme. Youpi ! 🙂

Première étape réussie, j’en suis fière.


Je retiens

Lorsque l’on code un programme, il ne marche pas forcément du premier coup (surtout lorsqu’on est débutant !). Et c’est à force de tâtonner, de le modifier, de l’améliorer que l’on y arrive.
Alors, il faut persévérer !


Je vous mets ci dessous mon code finalisé si vous souhaitez le tester ! 🙂

# ****** programme du jeu de la roulette **********
print("Bienvenue au ZCasino, voici le jeu de la Roulette !")
import random
import math
a = input("\nAvec quelle somme d'argent souhaitez vous jouer ? ")
a = int(a)
j=1
while j != 0 :
    #num_joueur()
    num_joueur = input("\nSur quel numéro souhaitez vous miser (entre 0 et 49) ? : ")
    num_joueur = int(num_joueur)
    # choisir sa mise
    mise = input("Quelle somme souhaitez vous miser sur ce numéro ? : ")
    mise = int(mise)
    print("\n Votre mise est de ", mise, "$ sur le numéro ", num_joueur, "\n")
    # lance la roulette
    print("A vos jeux... La roulette est lancée... \n")
    jeu=random.randrange(50)
    print("Le numéro gagnant est le numéro ", jeu)
    # gains
    if jeu != num_joueur :
        if (jeu %2 == 0 and num_joueur %2 == 0) or (jeu %2 != 0 and num_joueur %2 != 0):
            gain = math.ceil(mise * 0.5)
            print("\n Vous avez misé sur la bonne couleur, vous gagnez ", gain, "$")
            a = a + gain
        else:
            gain = 0
            print("\n Loupé, Vous venez de perdre votre mise !")
            a = a - mise
    else:
            gain = 3 * mise
            print("\n Votre gain est de 3 fois votre mise, soit ", gain, "$")
            a = a + gain
    print("Et vous avez au total ", a, " $")
    # possibilité de rejouer ou non
    if a == 0:
        print("\nVous n'avez plus d'argent ! Au revoir et à bientôt au ZCasino ")
        j=0
    else:
        r=input(" Voulez vous rejouer ? (O / N) ")
        if r == "O" or r == "o" :
                 j=1
        else:
                print("Au revoir et à bientôt au ZCasino ")
                j=0