Discussion :

[toniobuteau]

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

[alexdevl]

Bonjour,
Voila deux méthodes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[toniobuteau]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[afranck64]

Tu pourrais passer la trace complète de l'erreur?

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    d1 = Poker.Donne()
    d2 = Poker.Donne()

Tout ce qui est définit dans le bloc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if __name__=="__main__":

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

++

[toniobuteau]

Merci pour l'info.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[toniobuteau]

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

Merci mille fois