Feat: correction pour File et Pile et skel pour backjack

This commit is contained in:
Bertrand Benjamin 2021-06-09 10:49:28 +02:00
parent 6b603bfbac
commit e613a95712
4 changed files with 440 additions and 91 deletions

183
blackjack.py Normal file
View File

@ -0,0 +1,183 @@
"""
Projet jeu de Blackjack
=======================
But du jeu : Après avoir reçu deux cartes, le joueur tire des cartes pour sapprocher de la valeur 21 sans la dépasser. Le but du joueur est de battre le croupier en obtenant un total de points supérieur à celui-ci ou en voyant ce dernier dépasser 21. Chaque joueur joue contre le croupier, qui représente la banque, ou le casino, et non contre les autres joueurs.
Une carte sera un tuple (valeur, couleur).
Le croupier sera représenter par un deck de carte c'est à dire une Pile de cartes.
Chaque joueur sera représenter par une main de carte c'est à dire une liste (au sens de Python) de carte.
L'ensemble des joueurs sera une file de mains. On ne fera pas de différence entre un jour et le croupier.
"""
import random
from .pile import Pile
from .file import File
values = {
2: 2,
3: 3,
4: 4,
5: 5,
6: 6,
7: 7,
8: 8,
9: 9,
"Valet": 10,
"Dame": 10,
"Roi": 10,
"As": 11, # dans la vrai version du BlackJack, l'As peut valoir 1 ou 11 au choix du joueur.
}
colors = ["Pique", "Coeur", "Trefle", "Carreau"]
def build_deck():
"""Construit une pile de 54 cartes mélangés
Pour mélanger les cartes de façon aléatoire, vous pouvez utiliser la bibliothèque random.
:return: Une pile de 54 cartes différentes mélangées
:example:
>>> deck = build_deck()
>>> deck.is_empty()
False
>>> for i in range(54):
deck.pop()
>>> deck.is_empty()
True
"""
deck = Pile()
return deck
def build_players(nbr):
"""Construit une file de joueurs avec des mains vides
:param nbr: nombre de joueurs (on se limitera à 4 joueurs)
:return: file de mains vides
:example:
>>> players = build_players(3)
>>> players.is_empty()
False
>>> for _ in range(3):
print(players.pop())
[]
[]
[]
>>> players.is_empty()
True
"""
players = File()
# -----------------------
# -----------------------
return players
def compute_score(hand):
"""Calculer le score d'une main
:param hand: liste de cartes
:return: le score associé
:example:
>>> hand = [(2, "Pique"), ("As", "Coeur"), (8, "Carreau")]
>>> compute_score(hand)
11
>>> compute_score([])
0
"""
pass
def can_play(player):
"""détermine si un joueur peu encore jouer
:param player: une joueur
:return: True if his score is lower than 21
:example:
>>>
"""
pass
def first_draw(players, deck):
"""Distribue 2 cartes à chaque joueur
:param players: pile de joueur avec des mains vides
:param deck: pile avec toutes les cartes
:return: (players, deck) les joueurs ont deux cartes et le deck a été mis à jour.
:example:
>>> players = build_players(3)
>>> deck = build_deck()
>>> players, deck = fist_draw(players, deck)
>>> for i in range(3):
print(len(players.pop()))
2
2
2
"""
pass
def draw(players, deck):
"""Distribue 1 carte à chaque joueur
:param players: pile de joueur avec des mains non vides
:param deck: pile avec toutes les cartes
:return: (players, deck) les joueurs ont plus de deux cartes et le deck a été mis à jour.
:example:
>>> players = build_players(3)
>>> deck = build_deck()
>>> players, deck = fist_draw(players, deck)
>>> players, deck = draw(players, deck)
>>> for i in range(3):
print(len(players.pop()))
3
3
3
"""
pass
def play_backjack(nbr_players):
"""Simule une partie de blackjack entre "nbr_players"
:param nbr_players: nombre de joueurs
:return: File de tuples (joueur, score, tour élimination) dans l'ordre d'élimination
:example:
>>>
"""
result = File()
# -----------------------
# -----------------------
return result
if __name__ == "__main__":
# Test : Distribution de toutes les cartes
j = DeckOfCards()
while not j.is_empty():
print(j.depile())
# Test : Calcul de mains de blackjack
j = DeckOfCards()
while not j.is_empty():
mjoueurain_bjack(j)

187
blackjack_correction.py Normal file
View File

@ -0,0 +1,187 @@
"""
Projet jeu de Blackjack
=======================
But du jeu : Après avoir reçu deux cartes, le joueur tire des cartes pour sapprocher de la valeur 21 sans la dépasser. Le but du joueur est de battre le croupier en obtenant un total de points supérieur à celui-ci ou en voyant ce dernier dépasser 21. Chaque joueur joue contre le croupier, qui représente la banque, ou le casino, et non contre les autres joueurs.
Une carte sera un tuple (valeur, couleur).
Le croupier sera représenter par un deck de carte c'est à dire une Pile de cartes.
Chaque joueur sera représenter par une main de carte c'est à dire une liste (au sens de Python) de carte.
L'ensemble des joueurs sera une file de mains. On ne fera pas de différence entre un jour et le croupier.
"""
import random
from .pile import Pile
from .file import File
values = {
2: 2,
3: 3,
4: 4,
5: 5,
6: 6,
7: 7,
8: 8,
9: 9,
"Valet": 10,
"Dame": 10,
"Roi": 10,
"As": 11, # dans la vrai version du BlackJack, l'As peut valoir 1 ou 11 au choix du joueur.
}
colors = ["Pique", "Coeur", "Trefle", "Carreau"]
def build_deck():
"""Construit une pile de 54 cartes mélangés
Pour mélanger les cartes de façon aléatoire, vous pouvez utiliser la bibliothèque random.
:return: Une pile de 54 cartes différentes mélangées
:example:
>>> deck = build_deck()
>>> deck.is_empty()
False
>>> for i in range(54):
deck.pop()
>>> deck.is_empty()
True
"""
deck = Pile()
cards = zip(values, colors)
random.shuffle(cards)
for card in cards:
deck.append(card)
return deck
def build_players(nbr):
"""Construit une file de joueurs avec des mains vides
:param nbr: nombre de joueurs (on se limitera à 4 joueurs)
:return: file de mains vides
:example:
>>> players = build_players(3)
>>> players.is_empty()
False
>>> for _ in range(3):
print(players.pop())
[]
[]
[]
>>> players.is_empty()
True
"""
players = File()
# -----------------------
# -----------------------
return players
def compute_score(hand):
"""Calculer le score d'une main
:param hand: liste de cartes
:return: le score associé
:example:
>>> hand = [(2, "Pique"), ("As", "Coeur"), (8, "Carreau")]
>>> compute_score(hand)
11
>>> compute_score([])
0
"""
pass
def can_play(player):
"""détermine si un joueur peu encore jouer
:param player: une joueur
:return: True if his score is lower than 21
:example:
>>>
"""
pass
def first_draw(players, deck):
"""Distribue 2 cartes à chaque joueur
:param players: pile de joueur avec des mains vides
:param deck: pile avec toutes les cartes
:return: (players, deck) les joueurs ont deux cartes et le deck a été mis à jour.
:example:
>>> players = build_players(3)
>>> deck = build_deck()
>>> players, deck = fist_draw(players, deck)
>>> for i in range(3):
print(len(players.pop()))
2
2
2
"""
pass
def draw(players, deck):
"""Distribue 1 carte à chaque joueur
:param players: pile de joueur avec des mains non vides
:param deck: pile avec toutes les cartes
:return: (players, deck) les joueurs ont plus de deux cartes et le deck a été mis à jour.
:example:
>>> players = build_players(3)
>>> deck = build_deck()
>>> players, deck = fist_draw(players, deck)
>>> players, deck = draw(players, deck)
>>> for i in range(3):
print(len(players.pop()))
3
3
3
"""
pass
def play_backjack(nbr_players):
"""Simule une partie de blackjack entre "nbr_players"
:param nbr_players: nombre de joueurs
:return: File de tuples (joueur, score, tour élimination) dans l'ordre d'élimination
:example:
>>>
"""
result = File()
# -----------------------
# -----------------------
return result
if __name__ == "__main__":
# Test : Distribution de toutes les cartes
j = DeckOfCards()
while not j.is_empty():
print(j.depile())
# Test : Calcul de mains de blackjack
j = DeckOfCards()
while not j.is_empty():
mjoueurain_bjack(j)

102
file.py
View File

@ -21,37 +21,37 @@ class Node:
>>> assert n1.value == 1 >>> assert n1.value == 1
>>> assert n1.nxt is None >>> assert n1.nxt is None
>>> n2 = Node(5, n1) >>> n2 = Node(5, n1)
>>> assert n1.value == 5 >>> assert n2.value == 5
>>> assert n1.nxt == n1 >>> assert n2.nxt == n1
>>> n3 = Node("a", n2) >>> n3 = Node("a", n2)
>>> assert n1.value == "a" >>> assert n3.value == "a"
>>> assert n1.nxt == n3 >>> assert n3.nxt == n2
""" """
pass self.value = value
self.nxt = nxt
class File: class File:
""" """
La classe ```File``` doit posséder un élément "courant" qui est l'élément sur le dessus de la file. La classe ```File``` doit posséder un élément "courant" qui est l'élément sur le dessus de la file.
Fonctionnement d'une pile Fonctionnement d'une file
----------- -----------
append ----> _ _ _ _ _ append ----> _ _ _ _ _
----------- -----------
----------- -----------
_ _ _ _ _ ----> pop _ _ _ _ _ ----> pop
----------- -----------
Elle doit aussi posséder un entier ```n``` qui compte le nombre d'éléments dans la file Elle doit aussi posséder un entier ```n``` qui compte le nombre d'éléments dans la file
Cette classe aura donc 2 attributs: Cette classe aura donc 2 attributs:
- current avec l'élément courant - current avec l'élément courant
- n avec le nombre d'éléments dans la file - n avec le nombre d'éléments dans la file
:consignes: Compléter les méthodes suivantes. :consignes: Compléter les méthodes suivantes."""
"""
def __init__(self) -> None: def __init__(self) -> None:
"""Initialisation de la File vide """Initialisation de la File vide
@ -61,29 +61,32 @@ class File:
>>> assert file.n == 0 >>> assert file.n == 0
>>> assert file.current is None >>> assert file.current is None
""" """
# ----------------------- self.current = None
self.n = 0
# -----------------------
pass
def append(self, value): def append(self, value):
"""Ajoute "value" dans la file """Ajoute "value" dans la file
Comme nous sommes dans une pile, l'élément doit être ajouté en dernière position. Comme nous sommes dans une file, l'élément doit être ajouté en dernière position.
:example: :example:
>>> file = File() >>> file = File()
>>> file.append(1) >>> file.append(1)
>>> assert file.n == 1 >>> assert file.n == 1
>>> assert file.current == 1 >>> assert file.current.value == 1
>>> file.append("a") >>> file.append("a")
>>> assert file.n == 2 >>> assert file.n == 2
>>> assert file.current == 1 >>> assert file.current.value == 1
""" """
# ----------------------- if self.current is None:
self.current = Node(value, nxt=None)
# ----------------------- self.n = 1
pass else:
nxt = self.current
while nxt.nxt is not None:
nxt = nxt.nxt
nxt.nxt = Node(value, nxt=None)
self.n += 1
def get_current(self): def get_current(self):
"""Renvoie la prochaine valeur sans l'enlever de la file """Renvoie la prochaine valeur sans l'enlever de la file
@ -92,17 +95,13 @@ class File:
:example: :example:
>>> file = File() >>> file = File()
>>> file.get_current() >>> file.get_current()
None
>>> file.append(3) >>> file.append(3)
>>> file.get_current() >>> file.get_current()
3 3
>>> file.get_current() >>> file.get_current()
3 3
""" """
# ----------------------- return self.current.value if not self.is_empty() else None
# -----------------------
pass
def is_empty(self): def is_empty(self):
"""Vérifie si le file est vide """Vérifie si le file est vide
@ -116,30 +115,25 @@ class File:
False False
""" """
# ----------------------- return self.current is None
# -----------------------
pass
def pop(self): def pop(self):
"""Renvoie le prochain élément de la file et l'enlève """Renvoie le prochain élément de la file et l'enlève
Comme c'est une file, le prochain élément est le premier élément arrivé. Comme c'est une file, le prochain élément est le premier élément arrivé.
Si la liste est vide, la fonction renvoie None. Si la liste est vide, la fonction renvoie rien
:example: :example:
>>> file = File() >>> file = File()
>>> file.pop() >>> file.pop()
None
>>> file.append(2) >>> file.append(2)
>>> file.pop() >>> file.pop()
2 2
>>> file.pop() >>> file.pop()
None >>> file.append(2)
>>> pile.append(2) >>> file.append(5)
>>> pile.append(5) >>> file.append("a")
>>> pile.append("a")
>>> file.pop() >>> file.pop()
2 2
>>> file.pop() >>> file.pop()
@ -149,10 +143,11 @@ class File:
>>> >>>
""" """
# ----------------------- if not self.is_empty():
a = self.current.value
# ----------------------- self.current = self.current.nxt
pass self.n -= 1
return a
def empty(self): def empty(self):
"""vide la file c'est à dire element tous les elements de cette dernière """vide la file c'est à dire element tous les elements de cette dernière
@ -163,14 +158,11 @@ class File:
>>> file.append(5) >>> file.append(5)
>>> file.append("a") >>> file.append("a")
>>> file.get_current() >>> file.get_current()
"a" 3
>>> assert file.n == 3 >>> assert file.n == 3
>>> file.empty() >>> file.empty()
>>> file.get_current() >>> file.get_current()
None
>>> assert file.n == 0 >>> assert file.n == 0
""" """
# ----------------------- while not self.is_empty():
self.pop()
# -----------------------
pass

59
pile.py
View File

@ -21,13 +21,14 @@ class Node:
>>> assert n1.value == 1 >>> assert n1.value == 1
>>> assert n1.nxt is None >>> assert n1.nxt is None
>>> n2 = Node(5, n1) >>> n2 = Node(5, n1)
>>> assert n1.value == 5 >>> assert n2.value == 5
>>> assert n1.nxt == n1 >>> assert n2.nxt == n1
>>> n3 = Node("a", n2) >>> n3 = Node("a", n2)
>>> assert n1.value == "a" >>> assert n3.value == "a"
>>> assert n1.nxt == n3 >>> assert n3.nxt == n2
""" """
pass self.value = value
self.nxt = nxt
class Pile: class Pile:
@ -62,10 +63,8 @@ class Pile:
>>> assert pile.n == 0 >>> assert pile.n == 0
>>> assert pile.current is None >>> assert pile.current is None
""" """
# ----------------------- self.current = None
self.n = 0
# -----------------------
pass
def append(self, value): def append(self, value):
"""Ajoute "value" dans la pile """Ajoute "value" dans la pile
@ -74,15 +73,13 @@ class Pile:
>>> pile = Pile() >>> pile = Pile()
>>> pile.append(1) >>> pile.append(1)
>>> assert pile.n == 1 >>> assert pile.n == 1
>>> assert pile.current == 1 >>> assert pile.current.value == 1
>>> pile.append("a") >>> pile.append("a")
>>> assert pile.n == 2 >>> assert pile.n == 2
>>> assert pile.current == "a" >>> assert pile.current.value == "a"
""" """
# ----------------------- self.current = Node(value, nxt=self.current)
self.n += 1
# -----------------------
pass
def get_current(self): def get_current(self):
"""Renvoie la prochaine valeur sans l'enlever de la pile """Renvoie la prochaine valeur sans l'enlever de la pile
@ -91,17 +88,14 @@ class Pile:
:example: :example:
>>> pile = Pile() >>> pile = Pile()
>>> pile.get_current() >>> pile.get_current()
None
>>> pile.append(3) >>> pile.append(3)
>>> pile.get_current() >>> pile.get_current()
3 3
>>> pile.get_current() >>> pile.get_current()
3 3
""" """
# ----------------------- if not self.is_empty():
return self.current.value
# -----------------------
pass
def is_empty(self): def is_empty(self):
"""Vérifie si le pile est vide """Vérifie si le pile est vide
@ -115,10 +109,7 @@ class Pile:
False False
""" """
# ----------------------- return self.current is None
# -----------------------
pass
def pop(self): def pop(self):
"""Renvoie le prochain élément de la pile et l'enlève. """Renvoie le prochain élément de la pile et l'enlève.
@ -130,12 +121,10 @@ class Pile:
:example: :example:
>>> pile = Pile() >>> pile = Pile()
>>> pile.pop() >>> pile.pop()
None
>>> pile.append(2) >>> pile.append(2)
>>> pile.pop() >>> pile.pop()
2 2
>>> pile.pop() >>> pile.pop()
None
>>> pile.append(2) >>> pile.append(2)
>>> pile.append(5) >>> pile.append(5)
>>> pile.append("a") >>> pile.append("a")
@ -148,10 +137,11 @@ class Pile:
>>> >>>
""" """
# ----------------------- if not self.is_empty():
a = self.current.value
# ----------------------- self.current = self.current.nxt
pass self.n -= 1
return a
def empty(self): def empty(self):
"""vide la pile c'est à dire element tous les elements de cette dernière """vide la pile c'est à dire element tous les elements de cette dernière
@ -162,14 +152,11 @@ class Pile:
>>> pile.append(5) >>> pile.append(5)
>>> pile.append("a") >>> pile.append("a")
>>> pile.get_current() >>> pile.get_current()
"a" 'a'
>>> assert pile.n == 3 >>> assert pile.n == 3
>>> pile.empty() >>> pile.empty()
>>> pile.get_current() >>> pile.get_current()
None
>>> assert pile.n == 0 >>> assert pile.n == 0
""" """
# ----------------------- while not self.is_empty():
self.pop()
# -----------------------
pass