Travail pratique de Poker

Je suis à traiter les cas d'erreurs possibles.
Auriez-vous une idée ou une piste comment je pourrais faire qu'une donne de poker contenant deux cartes identiques (figure et sorte) soit toujours évaluée comme étant moins bonne que n'importe quelle autre donne valide.

Module Poker modififé

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
"""
Ce module contient une classe permettant de gérer une donne de poker.
"""
__auteur__ = "anbut13"
__coequipiers__ = None
__date__ = "2012-10-16"
 
import JeuDeCarte
 
class Donne(JeuDeCarte.Donne):
    """ Cette classe encapsule une donne de poker, capable de se comparer
    avec une autre donne et de déterminer laquelle est supérieure. """
    valeurs = {'2': 1, '3': 2, '4': 3, '5': 4, '6': 5, '7': 6, '8': 7, '9': 8, '10': 9,
               'J': 10, 'Q': 11, 'K': 12, 'A': 13}
 
    def _valeur(self):
        """ Cette fonction produit un tuple qui détermine la valeur relative
        d'une donne de Poker.
 
        :returns: un tuple de la forme (s, (v1, v2, v3, v4, v5)), où s correspond 
        à la valeur du type de la donne (carré=17, full=13, brelan=11, double paire=9, 
        paire=7, carte haute=5), et où v1, v2, v3, v4 et v5 sont les valeurs ordonnées 
        des cinq cartes.
        """
        valeurs = tuple(self.valeurs[x.figure] for x in self.cartes)
        comptes = tuple(valeurs.count(x) for x in valeurs)
        valeurs = (b for (a, b) in sorted(zip(comptes, valeurs), reverse=True))
 
 
        if len(list(self.valeurs)) != 5:
            raise AssertionError('pour pouvoir être évaluée, une donne doit posséder 5 cartes')
 
 
        return sum(comptes), tuple(valeurs)
 
 
    def __lt__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.
 
        :param donne: la donne à comparer avec self.
        :returns: True si self est inférieure à donne; False autrement.
        """
        if not isinstance(self, Donne):
            raise TypeError('une donne de poker ne peut être comparée qu\'avec une autre donne de poker')
 
        if not isinstance(donne, Donne):
            raise TypeError('une donne de poker ne peut être comparée qu\'avec une autre donne de poker')
 
        return self._valeur() < donne._valeur()
 
 
 
 
    def __le__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.
 
        :param donne: la donne à comparer avec self.
        :returns: True si self est inférieure ou égale à donne; False autrement.
        """
        return self._valeur() <= donne._valeur()
 
    def __gt__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.
 
        :param donne: la donne à comparer avec self.
        :returns: True si self est supérieure à donne; False autrement.
        """
        return self._valeur() > donne._valeur()
 
    def __ge__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.
 
        :param donne: la donne à comparer avec self.
        :returns: True si self est supérieure ou égale à donne; False autrement.
        """
        return self._valeur() >= donne._valeur()
 
    def __eq__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.
 
        :param donne: la donne à comparer avec self.
        :returns: True si self est égale à donne; False autrement.
        """
        return self._valeur() == donne._valeur()
 
    def __ne__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.
 
        :param donne: la donne à comparer avec self.
        :returns: True si self n'est pas égale à donne; False autrement.
        """
        return self._valeur() != donne._valeur()
 
    def __str__(self):
        """ Convertir en chaîne de caractères.
 
        :returns: la donne sous la forme d'une séquence ordonnée de cartes.
        """
        valeurs = tuple(self.valeurs[x.figure] for x in self.cartes)
        comptes = (valeurs.count(x) for x in valeurs)
        indices = (c for (a, b, c) in sorted(zip(comptes, valeurs, range(len(self.cartes))),
                                             reverse=True))
        return ''.join(str(self.cartes[i]) for i in indices)
 
if __name__ == '__main__':
    # programme principal
    print("Ceci est le module Poker; test de 10 donnes aléatoires")
    p = JeuDeCarte.Paquet()
    for i in range(10):
        print('Donnes #{}'.format(i+1))
        d1 = Donne()
        d2 = Donne()
        for i in range(5):
            d1.ajouter(p.tirer().flipper())
            d2.ajouter(p.tirer().flipper())
 
 
        if d1 < d2:
            print('{:>24} < {:<24}'.format(d1, d2))
            print('{:>24} < {:<24}'.format(d1._valeur(), d2._valeur()))
        else:
            print('{:>24} ≥ {:<24}'.format(d1, d2))
            print('{:>24} ≥ {:<24}'.format(d1._valeur(), d2._valeur()))

Si vous voulez les UnitTests dites le moi !

Merci

j'ai pas regardé le code mais genre tu peux set() les donnes avant de les comparer pour éliminer les doublons.

On cherche le cas général, mais je vais vous mettre le cas spécifique de triche:

UnitTest:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
import unittest
import random
 
import JeuDeCarte
import Poker
 
class DummyCard:
    """
    Classe utilisée dans certains tests unitaires.
    """
    figures = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
    sortes = {'pique': '♠', 'coeur': '♥', 'carreau': '♦', 'trèfle': '♣'}
    def __init__(self, figure, sorte, face_visible=False):
        self.figure = figure
        self.sorte = sorte
        self.face_visible = face_visible 
 
 
class TP5_2012(unittest.TestCase):
    def setUp(self):
        """
        Tâches à exécuter avant les tests unitaires. Rien dans ce cas ci.
        """
        pass
 
    def testCarteArgumentsMinusculesMajuscules(self):
        """
        Teste si on peut créer avec succès une carte sans tenir compte de
        la casse (point 1 de l'énoncé)
        """
        listFig = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
        listSortes = ['pique', 'coeur', 'carreau', 'trèfle']
 
        fig, sorte = random.choice(listFig), random.choice(listSortes)
        carte1 = JeuDeCarte.Carte(fig, sorte, True)
        carte2 = JeuDeCarte.Carte(fig.lower(), sorte.upper(), True)
        sorte2 = ''
        for i in range(len(sorte)):
            if random.random() < 0.5:
                sorte2 += sorte[i].upper()
            else:
                sorte2 += sorte[i]
        carte3 = JeuDeCarte.Carte(fig, sorte2, True)
 
        self.assertEqual(str(carte1), str(carte2), msg="Les objets JeuDeCarte.Carte"
                                "('{0}', '{1}', True) et JeuDeCarte.Carte('{2}', '{3}', True)"
                                " devraient être identiques, mais votre programme donne '{4}'"
                                " comme représentation de la première et '{5}' comme"
                                " représentation de la seconde. ".format(fig, sorte, 
                                fig.lower(), sorte.upper(), str(carte1), str(carte2)))
        self.assertEqual(str(carte1), str(carte3), msg="Les objets JeuDeCarte.Carte"
                                "('{0}', '{1}', True) et JeuDeCarte.Carte('{2}', '{3}', True)"
                                " devraient être identiques, mais votre programme donne '{4}'"
                                " comme représentation de la première et '{5}' comme"
                                " représentation de la seconde. ".format(fig, sorte, 
                                fig, sorte2, str(carte1), str(carte3)))
 
    def testCarteAvecFigureInconnue(self):
        """
        Teste si une exception est bien renvoyée lorsque l'on tente de créer
        une carte avec une figure invalide (point 2 de l'énoncé)
        """
        listBad = ['B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'L', 'M', 'N',
                     'O', 'P', 'R', 'S', 'T', 'V', 'U', 'X', 'W', 'Y', 'Z']
 
        badfig = random.choice(listBad)
        self.assertRaisesRegex(ValueError, "figure '"+badfig+"' inconnue", 
                                    JeuDeCarte.Carte, badfig, "pique")
        self.assertRaisesRegex(ValueError, "figure 'JJ' inconnue", 
                                    JeuDeCarte.Carte, 'JJ', 'pique') 
 
    def testCarteAvecSorteInconnue(self):
        """
        Teste si une exception est bien renvoyée lorsque l'on tente de créer
        une carte avec une sorte invalide (point 3 de l'énoncé)
        """
        sorte = ""
        for i in range(random.randint(1,8)):
            sorte += chr(random.randrange(ord('a'), ord('z')))
 
        self.assertRaisesRegex(ValueError, "sorte '"+sorte+"' inconnue", 
                                    JeuDeCarte.Carte, 'A', sorte)
 
    def testPaquetAvecCarteInvalide(self):
        """
        Teste si l'initialisation d'un paquet avec un type de carte invalide
        produit bien une exception de type TypeError (point 4 de l'énoncé)
        """
        expmsg = "le type de carte doit être dérivé de JeuDeCarte.Carte"
 
        self.assertRaisesRegex(TypeError, expmsg, JeuDeCarte.Paquet, DummyCard)
 
    def testComparaisonPokerAvecAutreType(self):
        """
        Teste si une exception de type TypeError est bien lancée lorsque on
        tente de comparer une donne non dérivée de Poker.Donne
        (point 5 de l'énoncé)
        """
 
        expmsg = "une donne de poker ne peut être comparée qu'avec une autre donne de poker"
        d1 = Poker.Donne()
        d2 = JeuDeCarte.Donne()
        paquet = JeuDeCarte.Paquet()
        for i in range(5):
            d1.ajouter(paquet.tirer().flipper())
            d2.ajouter(paquet.tirer().flipper())
 
        self.assertRaisesRegex(TypeError, expmsg, d1.__lt__, d2)
 
    def testDonnePokerAvecMoinsOuPlusDeCinqCartes(self):
        """
        Teste si une exception de type AssertionError est bien lancée lorsque
        on tente de comparer deux donnes dont une n'a pas exactement cinq
        cartes (point 6 de l'énoncé)
        """
 
        d1, d2 = Poker.Donne(), Poker.Donne()
        expmsg = "pour pouvoir être évaluée, une donne doit posséder 5 cartes"
 
        self.assertRaisesRegex(AssertionError, expmsg, d1.__lt__, d2)
        self.assertRaisesRegex(AssertionError, expmsg, d1.__gt__, d2)
        self.assertRaisesRegex(AssertionError, expmsg, d1.__eq__, d2)
        self.assertRaisesRegex(AssertionError, expmsg, d1.__le__, d2)
        self.assertRaisesRegex(AssertionError, expmsg, d1.__ge__, d2)
        self.assertRaisesRegex(AssertionError, expmsg, d1.__ne__, d2)
 
        paquet = JeuDeCarte.Paquet()
        for i in range(5):
            d1.ajouter(paquet.tirer().flipper())
        self.assertRaisesRegex(AssertionError, expmsg, d1.__lt__, d2)
 
        for i in range(6):
            d2.ajouter(paquet.tirer().flipper())
        self.assertRaisesRegex(AssertionError, expmsg, d1.__lt__, d2)
 
    def testPokerAvecCartesSemblables(self):
        """
        Teste si une donne avec une carte répétée est bien inférieure à toute
        autre donne valide (point 7 de l'énoncé).
        """
        paquet = JeuDeCarte.Paquet()
        d1 = Poker.Donne()
        d2 = Poker.Donne()
 
        d1.ajouter(JeuDeCarte.Carte('5', 'pique', True))
        d1.ajouter(JeuDeCarte.Carte('A', 'carreau', True))
        d1.ajouter(JeuDeCarte.Carte('3', 'pique', True))
        d1.ajouter(JeuDeCarte.Carte('9', 'coeur', True))
        d1.ajouter(JeuDeCarte.Carte('3', 'pique', True))
 
        d2.ajouter(JeuDeCarte.Carte('A', 'coeur', True))
        d2.ajouter(JeuDeCarte.Carte('Q', 'trèfle', True))
        d2.ajouter(JeuDeCarte.Carte('3', 'coeur', True))
        d2.ajouter(JeuDeCarte.Carte('K', 'pique', True))
        d2.ajouter(JeuDeCarte.Carte('2', 'trèfle', True))
 
        random.shuffle(d1.cartes)
        random.shuffle(d2.cartes)
 
        self.assertTrue(d1 < d2, msg="La donne {} devrait être considérée inférieure à {}"
                                    " car elle contient deux fois la même carte, mais votre"
                                    " classe Poker.Donne ne l'a pas donnée comme"
                                    " inférieure".format(d1, d2))
        self.assertFalse(d2 < d1, msg="La donne {} devrait être considérée supérieure à {}"
                                    " car la seconde contient deux fois la même carte, mais"
                                    " votre classe Poker.Donne l'a pas donnée comme"
                                    " inférieure".format(d2, d1))
 
 
 
if __name__ == '__main__':
    # Programme principal
    # Lance les unit tests
    unittest.main()

JeuDeCarte

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
class Carte:
    """ Cette classe encapsule une carte avec sa figure et sa sorte. """
    figures = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
    sortes = {'pique': '♠', 'coeur': '♥', 'carreau': '♦', 'trèfle': '♣'}
 
 
 
    def __init__(self, figure, sorte, face_visible=False):
        """ Construire une carte à partir d'une figure et d'une sorte. 
        Par défaut, la face de la carte est cachée. 
 
        :param figure: une chaîne d'un seul caractère spécifiant la figure de 
        la carte. Les figures possibles sont 'A', '2', '3', '4', '5', '6', '7', 
        '8', '9', '10', 'J', 'Q', 'K'.
        :param sorte: une chaîne de caractères spécifiant la sorte de carte.
        Les sortes possibles sont 'pique', 'coeur', 'carreau' et 'trèfle'.
        :param face_visible: bouléen spécifiant si la face de la carte est
        visible ou non (par défaut: non).
        :returns: rien.
        """
        self.figure = figure
        self.sorte = sorte
        self.face_visible = face_visible
 
        if str.upper(figure) not in Carte.figures: 
            raise ValueError("figure '{}' inconnue".format(figure))
 
        if str.lower(sorte) not in Carte.sortes:
            raise ValueError("sorte '{}' inconnue".format(sorte))
 
 
    def __str__(self):
        """ Convertir en chaîne de caractères. 
 
        :returns: la carte sous la forme «FS», où «F» représente la figure 
        (parmi 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'), 
        et «S» représente la sorte (parmi '♠', '♥', '♦', '♣'), si la face 
        est visible; retourne «??» autrement.
        """
        if self.face_visible:
            return str.upper(self.figure) + (Carte.sortes[str.lower(self.sorte)])
        else:
            return '??'
 
    def flipper(self):
        """ Renverser la face de la carte. 
 
        :returns: la carte self.
        """
        self.face_visible = not self.face_visible
        return self
 
class Donne:
    """ Cette classe encapsule une donne, c-à-d une séquence de cartes. """
 
    def __init__(self):
        """ Construire une donne vide. Une donne est une liste de cartes. """
        self.cartes = []
 
    def __str__(self):
        """ Convertir en chaîne de caractères. 
 
        :returns: la donne sous la forme d'une séquence de cartes séparées par
        des espaces; None dans le cas d'une donne vide.
        """
        if self.cartes:
            donne = str(self.cartes[0])
            for carte in self.cartes[1:]:
                donne += ' ' + str(carte)
        else:
            donne = None
        return donne
 
    def __add__(self, donne):
        """ Concaténer deux donnes en une seule.
 
        :param donne: la donne à concaténer avec self.
        :returns: la concaténation des deux donnes.
        """
        resultat = Donne()
        resultat.cartes = list(self.cartes)
        resultat += donne
        return resultat
 
    def __iadd__(self, donne):
        """ Concaténer deux donnes en une seule en stockant le résultat
        dans la première donne.
 
        :param donne: la donne à concaténer avec self.
        :returns: rien.
        """
        for carte in donne.cartes:
            self.ajouter(carte)
        return self
 
    def ajouter(self, carte):
        """ Ajouter une nouvelle carte à la donne.
 
        :param carte: la carte à ajouter.
        :returns: rien.
        """
        self.cartes.append(carte)
 
    def retirer(self, carte):
        """ Retirer une carte de la donne
 
        :param carte: la carte à retirer.
        :returns: rien
        """
        self.cartes.remove(carte)
 
    def vider(self):
        """ Retirer toutes les cartes de la donne. 
 
        :returns: rien.
        """
        self.cartes = []
 
class Paquet(Donne):
    """ Cette classe encapsule un paquet standard de 52 cartes. """
 
 
    def __init__(self, carte=Carte):
        """ Construire un paquet de 52 cartes prémélangées. 
 
        :param carte: le type de carte à insérer dans le paquet
        (doit être dérivé de Carte).
        :returns: rien.
        """
        super().__init__()
        self.carte = carte
        self.renouveler()
        self.melanger()
 
        if self.carte != Carte:
            raise TypeError('le type de carte doit être dérivé de JeuDeCarte.Carte')
 
 
    def melanger(self):
        """ Mélanger aléatoirement les cartes. 
 
        :returns: rien.
        """
        import random
        random.shuffle(self.cartes)
 
    def renouveler(self):
        """ Renouveler les 52 cartes sans les mélanger. 
 
        :returns: rien.
        """
        self.vider()
        for figure in Carte.figures:
            for sorte in Carte.sortes.keys():
                self.ajouter(self.carte(figure, sorte))
 
    def tirer(self):
        """ Tirer une carte du paquet.
 
        :returns: la carte sur le dessus du paquet. Si le paquet est vide,
        renouvelle et mélange automatiquement un nouveau paquet.
        """
        if not self.cartes:
            self.renouveler()
            self.melanger()
        return self.cartes.pop()
 
if __name__ == '__main__':
    # programme principal
    print("Le module JeuDeCarte n'est pas conçu pour être exécuté en tant que programme principal")

J'avais réfléchi à:

Faire une boucle pour aller chercher mes valeurs de figure et de sorte.
Comparé une à une et aussitot que j'ai 2 cartes pareils mettre la valeur de la donne à 0.

Ou

Donner une valeur à mes sortes (Pique= 1, etc.), zipper et comparer.

J'en suis là. :?