Travail pratique de Poker

Version imprimable

10/10/2012, 02h57
toniobuteau

Travail pratique de Poker

Bonjour,

Je voudrais enlever des éléments d'un tuple qui est dans une liste.

[(11, 3), (11, 3), (11, 3), (10, 1), (8, 1)]

Je veux enlever les nombres après la virgule dans le tuple.
Pour qu'il me reste :
[11, 11, 11, 10, 8]

Vu que le tuple est immuable j'avais pensé retransformer les tuples en listes, mais j'imagine qu'il y a une méthode plus simple.

Merci

Bonjour,
Voila deux méthodes :

Code:

1
2
3
4
5
6
7
8
9
10
11
datas=[(11, 3), (11, 3), (11, 3), (10, 1), (8, 1)]
# Methode avec comprehension list
x=[i[0] for i in datas]
print x
 
# Methode avec l'inverse de zip : zip(* )
x1, x2 = zip(*datas)
print list(x1)
 
[11, 11, 11, 10, 8]
[11, 11, 11, 10, 8]

Alex

Dans un autre ordre d'idée, je ne sais pas si certain d'entre-vous pourrait m'aider à résoudre un problème.

Un serveur test me fournit 2 donnes que je dois comparer.

J'ai le module JeuDeCarte et je dois créer le module Poker qui sera capable de comparer.

Pour voir le tp : http://wcours.gel.ulaval.ca/2012/a/G...vaux/tp4.chtml

Je recois comme message d'erreur:

Cette erreur peut être causée par un échec d'exécution! Veuillez corriger les échecs d'exécution en priorité
Notez que cette erreur peut aussi être due à une erreur de logique dans votre code.
Erreur lors du test unitaire 'None' :
AttributeError: 'module' object has no attribute 'Donne'

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
 import random
 
class Carte:
    """ Cette classe encapsule une carte avec son rang et sa sorte. """
    figures = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
    sortes = {'pique': '♠', 'coeur': '♥', 'carreau': '♦', 'trèfle': '♣'}
    face_visible = False
 
    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 
 
    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 == False:
            return '??'
        else: 
            return self.figure + self.sortes[self.sorte]
 
        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 len (self.cartes) == 0:
            return None
        else:
            return " ".join(str(x) for x in self.cartes)
 
 
    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):
        """ Construire un paquet de 52 cartes prémélangées. 
 
        :returns: rien.
        """
        super().__init__()
        self.renouveler()
        self.melanger()
 
    def melanger(self):
        """ Mélanger aléatoirement les cartes. 
 
        :returns: rien.
        """
        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(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")

Main Module Poker

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
import JeuDeCarte
 
#programme principal
 
if __name__ == '__main__':
 
    class Carte(JeuDeCarte.Carte):
        """Classe où on encapsule les cartes et la valeur de la carte"""
 
    def valeur(self):
        """ Calculer la valeur de la carte. 
 
        :returns: la valeur nominale de la carte pour les cartes de '2' à '10',
        10 pour les figures ('J', 'Q' et 'K'), et 1 pour les aces.
        """
        return self.valeurs[self.figure]
 
    class Donne(JeuDeCarte.Donne):
 
        """Valeurs des cartes dans la donne"""
 
        valeurs = {'A': 14, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
               '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13}
 
 
 
    def _lt_(self, other):
 
        """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
        d1 = self.carte 
        d2 = other.carte
 
        self.carte = sum([list(d1).count(x) for x in list(d1)])
        other.carte = sum([list(d2).count(x) for x in list(d2)])
 
        if self.carte < other.carte:
            return True
        else: 
            return False
 
 
    def _eq_(self, other):
        """On redéfinit la fonction = pour qu'elle puisse s'exécuter selon nos spécificités"""
 
        d1 = self.carte
        d2 = other.carte
 
        self.carte = sum([list(d1).count(x) for x in list(d1)])
        other.carte = sum([list(d2).count(x) for x in list(d2)])
 
        if self.carte == other.carte:
            d1 = list(zip(list(d1), self.carte))
            d2 = list(zip(list(d2), other.carte))
 
            d1 = sorted(d1, reverse = True)
            d2 = sorted(d2, reverse = True)
 
            d1 = [i[0] for i in d1]
            d2 = [[i[0] for i in d2]]
 
            if self.carte < other.carte:
                return True
            else: 
                return False
 
 
    '''Valeurs des donnes'''
 
 
    carre = 17
    pleine = 13
    brelan = 11
    doublepaire = 9
    paire = 7
    haute = 5
 
 
 
    paquet = JeuDeCarte.Paquet()
    d1 = Poker.Donne()
    d2 = Poker.Donne()
 
    for i in range (5):
        d1.ajouter(paquet.tirer().flipper())
        d2.ajouter(paquet.tirer().flipper())
 
 
 
    if d1 < d2:
        print('{:>20} < {:<20}'.format(d1, d2))
    else:
        print('{:>20} => {:<20}'.format(d1, d2))

11/10/2012, 16h53
afranck64
Tu pourrais passer la trace complète de l'erreur?

Citation:

XYZError at line n in file foo.py:
Module ...

Sinon, dans ton second code, tu fais un import de <JeuDeCarte> que je suppose être le premier code posté, et tu te sers de <Poker> pour accéder à ta classe <Donne> j'ai pas trouvé l'import de Poker, ni sa définition.

Mais je suppose que le soucis est à la ligne 81:
Code:

1 2 d1 = Poker.Donne() d2 = Poker.Donne()
Tout ce qui est définit dans le bloc:

Code:

if __name__=="__main__":

est inexistant en cas d'un import. Tout les classes devraient(doivent!) être définies hors de se bloc.

++ :mrgreen:

Merci pour l'info.

J'ai modifié mon code, mais ça me donne toujours comme si Poker n'existait pas.

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
import JeuDeCarte
 
class Donne(JeuDeCarte.Donne):
 
        """Valeurs des cartes dans la donne"""
 
        valeurs = {'A': 14, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
               '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13}
 
 
 
        def __lt__(self, other):
 
            """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
            if sum(([list(self).count(x) for x in list(self)])) < sum([list(other).count(x) for x in list(other)]):
                return True
 
            elif sum(([list(self).count(x) for x in list(self)])) == sum([list(other).count(x) for x in list(other)]):
                self = list(zip(list(self), self)) 
                other = list(zip(list(other), other))
 
                self = sorted(d1, reverse = True)
                other = sorted(d2, reverse = True)
 
                self = [i[0] for i in self]
                other = [[i[0] for i in other]]
 
                if self < other:
                    return True
                else: 
                    return False
 
if __name__ == '__main__':
 
#programme principal
    paquet = JeuDeCarte.Paquet()
    d1 = Poker.Donne()
    d2 = Poker.Donne() 
 
    for i in range (5):
        d1.ajouter(paquet.tirer().flipper())
        d2.ajouter(paquet.tirer().flipper())
 
 
 
    if d1 < d2:
        print('{:>20} < {:<20}'.format(d1, d2))
    else:
        print('{:>20} => {:<20}'.format(d1, d2))

11/10/2012, 18h33
toniobuteau

Ok je viens de comprendre c'est le serveur qui fait le programme.

Merci mille fois
11/10/2012, 19h23
afranck64

Moi, j'ai pas compris. Bref, c'est pas de moi qu'il s'agit alors...
:mouarf:

Je vais t'expliquer.

Au fond, je dois mettre ce code dans un module à part de mon fichier poker.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import Poker
import JeuDeCarte

paquet = JeuDeCarte.Paquet()
d1 = Poker.Donne()
d2 = Poker.Donne()
    
for i in range(5):
    d1.ajouter(paquet.tirer().flipper())
    d2.ajouter(paquet.tirer().flipper())
    
    
    
if d1 < d2:
    print('{:>20} < {:<20}'.format(d1, d2))
else:
    print('{:>20} ≥ {:<20}'.format(d1, d2))

Sans la comparaison, il me retournerait des valeurs comme ceci:

J♥ A♥ J♣ 4♣ 7♠

Je dois transformer ceci dans une liste et faire des étapes pour qu'il me donne 2 éléments que je peux comparer, mais j'ai un peu de difficulté à savoir si je dois utiliser une liste ou non.

J'avais pensé faire ceci, mais je ne sais pas si ça fonctionne:

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
import JeuDeCarte
 
class Donne(JeuDeCarte.Donne):
 
    """Valeurs des cartes dans la donne"""
 
    valeurs = {'A': 14, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
               '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13}
def valeur(self):
        """ Calculer la valeur de la carte. 
 
        :returns: la valeur nominale de la carte pour les cartes de '2' à '10',
        10 pour les figures ('J', 'Q' et 'K'), et 1 pour les aces.
        """
        return self.valeurs[self.figure]
 
        valeur = 0
 
        jeu1 = []
        jeu2 = []
 
        liste1 = jeu1.append(self)
        liste2 = jeu2.append(self)
 
 
 
 
def __lt__(self, other):
 
        """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
 
            if self.valeur() < other.valeur():
                return True
            else: 
                return False

Des idées ?

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
import JeuDeCarte
 
class Donne(JeuDeCarte.Donne):
 
    """Valeurs des cartes dans la donne"""
 
    valeurs = {'A': 14, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
               '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13}
 
 
def valeur (self):
 
    """ Cree une liste qui contient uniquement les valeurs de chacune des cartes des donnes"""
 
    valeur1 = []
    valeur2 = []
 
    for i in self.cartes: 
        valeur1 = valeur1.append(self.valeurs[i.figure])
        valeur2 = valeur2.append(self.valeurs[i.figure])
        return valeur1, valeur2
 
        somme = sum([valeur1.count(x) for x in valeur])
        zipper = list(zip(somme, valeur2))   
        trier = sorted(zipper, reverse = True)
        final = [i[0] for i in trier]
 
        return final
 
def __lt__(self, other):
 
        """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
        if self.valeur() < other.valeur():
            return True
        else: 
            return False
 
if __name__ == '__main__': pass

Mais j'obtiens

Traceback (most recent call last):
line 18, in <module>
if d1 < d2:
TypeError: unorderable types: Donne() < Donne()

Donc évidemment il y a quelque chose de pas correct.

Oui, et ici, le quelque chose de pas correct, c'est l'indention. Tu as défini tes méthodes à l'extérieur de ta classe(au même niveau d'indention) alors, c'est normal qu'elles soient "libres".
En indentant tes méthodes, ca devrait être Ok.

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
import JeuDeCarte
 
class Donne(JeuDeCarte.Donne):
 
    """Valeurs des cartes dans la donne"""
 
    valeurs = {'A': 14, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
               '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13}
 
 
    def valeur (self):
 
        """ Cree une liste qui contient uniquement les valeurs de chacune des cartes des donnes"""
 
        valeur1 = []
        valeur2 = []
 
        for i in self.cartes:
            valeur1 = valeur1.append(self.valeurs[i.figure])
            valeur2 = valeur2.append(self.valeurs[i.figure])
            return valeur1, valeur2
 
            somme = sum([valeur1.count(x) for x in valeur])
            zipper = list(zip(somme, valeur2))
            trier = sorted(zipper, reverse = True)
            final = [i[0] for i in trier]
 
            return final
 
    def __lt__(self, other):
 
            """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
            if self.valeur() < other.valeur():
                return True
            else:
                return False
 
if __name__ == '__main__': pass  #Pas necessaire :D

12/10/2012, 13h45
toniobuteau

Ça fonctionne !!!!

Merci mille fois !

Étrangement quand je faisais moi même les indentations ça ne fonctionnait pas.
Possible que je me sois trompé:mouarf:

P.s. Le seul problème restant c'est qu'il me renvoit toujours plus grand que:mrgreen:

Je crois que c'est a cause du return valeur1,valeur2
12/10/2012, 17h08
afranck64

Je ne comprends pas le rôle de

Code:

return valeur1, valeur2

vu qu'il y a en dessous un

Code:

return final

De plus, je me demande si le type de comparaison des listes, correspont vraiment à ce que tu veux faire:

Code:

[1, 2, 3, 4, 5]<[2, 0, 0, 0, 0]
12/10/2012, 17h33
toniobuteau

Non, le code ne fonctionne pas.

Le final n'a pas rapport.

Sinon j'ai ça, que je voudrais ramener à plus simple.

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
import JeuDeCarte
 
class Donne(JeuDeCarte.Donne):
    """ Cette classe encapsule une donne, c-a-d une sequence de cartes. """
 
    valeurs = {'A': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
               '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13}
 
    def valeur (self):
 
        """ Cree une liste qui contient uniquement les valeurs de chacune des cartes des donnes"""
 
        valeur = []
        for i in self.cartes: 
            valeur.append(self.valeurs[i.figure])
        #print ("liste ak juste des valeurs", valeur)
        return valeur 
 
    def nombre (self):
        """ Creer pour chacune des donnes une liste qui combien il y a de fois chacune des cartes"""
 
        nombre = [] 
        for i in self.valeur(): 
            repetition = 0
            for j in self.valeur(): 
                if i == j: 
                    repetition += 1
            nombre.append( repetition )
        #print ("combien de fois chaque valeur", nombre)
        return nombre           
 
 
    def val (self): 
        """determiner la valeur de chacune de donne"""
        somme = 0
        for i in self.nombre(): 
            somme += i
        #print ("somme des valeures", somme)
        return somme  
 
    def classer (self):
        """ Si la valeur des 2 donnes est egale
                Trie chaque donne et retourne une liste qui contient les cartes uniquement"""
        b = [] 
        z = list(zip(self.nombre(), self.valeur()))
        #print ("zip", z)
        x = sorted(z, reverse = True)
        #print ("sorted", x)
        for i in x: 
            #print ("i[1]", i[1])
            b.append(i[1])
        #print ("liste des cartes triees", b)
        return b
 
 
    def __lt__ (self, d2):
 
        """ Construire une donne vide. Une donne est une liste de cartes. """
 
        if self.val() < d2.val():
            return True 
        elif self.val() > d2.val():
            return False
        else: 
            if self.classer() < d2.classer():
                return True 
            else: 
                return False

List-Comprehensions:
Code:

1 2 3 4 5 valeur = [] for i in self.cartes: valeur.append(self.valeurs[i.figure]) #print ("liste ak juste des valeurs", valeur) return valeur
est identique à:

Code:

return [self.valeurs[i.figure] for i in self.cartes]

Il doit y avoir 2-3 blocs semblables dans ton code.

Vraiment pratique les listes en compréhension.

Comment je pourrais modifier ces deux là ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 def somme(self):
 
        resultat = 0
        for x in self.compter():
            resultat += x
 
            return resultat
 
 
    def classer (self):
        """ Si la valeur des 2 donnes est egale
                Trie chaque donne et retourne une liste qui contient les cartes uniquement"""
        b = [] 
        z = list(zip(self.compter(), self.valeur()))
        #print ("zip", z)
        x = sorted(z, reverse = True)
        #print ("sorted", x)
        for i in x: 
            #print ("i[1]", i[1])
            b.append(i[1])
        #print ("liste des cartes triees", b)
        return b

Merci

Attention à tes indentations*!

Code:

1
2
3
4
5
def somme(self):
    resultat = 0
    for x in self.compter():
        resultat += x
    return resultat

… s’écrira plutôt avec la builtin sum()*:

Code:

1
2
def somme(self):
    return sum(self.compter())

Pour ce qui est de*:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
def classer (self):
    """ Si la valeur des 2 donnes est egale
       Trie chaque donne et retourne une liste qui contient les cartes uniquement"""
    b = [] 
    z = list(zip(self.compter(), self.valeur()))
    #print ("zip", z)
    x = sorted(z, reverse = True)
    #print ("sorted", x)
    for i in x: 
        #print ("i[1]", i[1])
        b.append(i[1])
    #print ("liste des cartes triees", b)
    return b

Voici la list comprehension équivalente*:

Code:

1
2
def classer(self):
    return [i[1] for i in sorted(zip(self.compter(), self.valeur()), reverse=True)]

14/10/2012, 21h08
toniobuteau

Merci à tous !

Donc module Poker final:

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
import JeuDeCarte
 
class Donne(JeuDeCarte.Donne):
 
    """Valeurs des cartes dans la donne"""
 
    valeurs = {'A': 14, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
               '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13}
 
 
    def valeur (self):
 
        """ Cree une liste qui contient uniquement les valeurs de chacune des cartes des donnes"""
 
        return [self.valeurs[i.figure] for i in self.cartes]
 
    def compter(self):
 
 
        return [self.valeur().count(num) for num in self.cartes]
 
    def somme(self):
 
        return sum(self.compter())
 
    def zipper(self):
        return [(zip(self.somme(), self.valeur()))]
 
    def classer (self):
        """ Si la valeur des 2 donnes est egale
                Trie chaque donne et retourne une liste qui contient les cartes uniquement"""
        return [i[1] for i in sorted(zip(self.compter(), self.valeur()), reverse=True)]
 
 
    def __lt__(self, other):
 
            """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
            if self.classer() < other.classer():
                return True
            else:
                return False

Citation:

Code:

1
2
3
4
5
6
7
8
def __lt__(self, other):
 
            """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
            if self.classer() < other.classer():
                return True
            else:
                return False

Mieux

Code:

1
2
3
4
5
def __lt__(self, other):
 
            """On redéfinit la fonction < pour qu'elle puisse s'exécuter selon nos spécificités"""
 
            return self.classer() < other.classer()

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

16/10/2012, 19h18
josmiley

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

17/10/2012, 14h07
toniobuteau

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à. :?