Question

Player Class Represents a participant in the game of blackjack.

Must meet the following requirements: Stores the individual cards that are dealt (i.e. cannot just store the sum of the cards, you need to track which specific cards you receive) Provided methods: decide_hit(self): decides whether hit or stand by randomly selecting one of the two options.

Parameters: None

Returns: True to indicate a hit, False to indicate a stand

Must implement the following methods:

Hi!! i just need help with the player class for this. Ive added comments into my python where I need help with codes so if you could help with the red that would be great!

import random class Player: def __init__(self, name, dealer): #creates a new player with the given name, and initializes win, tie, and loss counters #Also creates an empty list to store the player's hand. return None def decide_hit(self): # DO NOT MODIFY return random.choice([True, True, False]) def deal_to(self, card_value): >>> player = Player (None, None) >>> player.deal_to(11) >>> player.hand [11] >>> player.deal_to(10) >>> player.hand [11, 10] #used to deal a card to this player. #The player must add the dealt card to his hand. return None @property def card_sum(self): >>> player = Player (None, None) >>> player.deal_to(2) >>> player.card_sum >>> player.deal_to(10) >>> player.card_sum 12 #Cproperty method): gets the sum of the cards in the player's hand return None

Answer 1

Working code implemented in Python and appropriate comments provided for better understanding:

Here I am attaching code for these 4 files:

• player.py
• dealer.py
• card_deck.py
• blackjack_game.py

Source code for player.py:

import random

class Player:

def __init__(self, name, dealer):
self.name = name
self.dealer = dealer
self.hand = []

self.__wins = 0
self.__ties = 0
self.__losses = 0
self.busted = False

def decide_hit(self):
# DO NOT MODIFY
return random.choice([True, True, False])

def deal_to(self, card_value):
"""
>>> player = Player(None, None)
>>> player.deal_to(11)
>>> player.hand
[11]
>>> player.deal_to(10)
>>> player.hand
[11, 10]
"""
self.hand.append(card_value)
if self.card_sum > 21:
self.busted = True

@property
def card_sum(self):
"""
>>> player = Player(None, None)
>>> player.deal_to(2)
>>> player.card_sum
2
>>> player.deal_to(10)
>>> player.card_sum
12
"""
return sum(self.hand)

def play_round(self):
"""
>>> from dealer import Dealer
>>> import random; random.seed(1)
>>> dealer = Dealer()
>>> dealer.shuffle_deck()
>>> player = Player(None, dealer)

We see that after the first call the play_round, we have only hit once as dictated by decide_hit
>>> player.play_round()
>>> player.hand
[10]

After calling play_round again, decide_hit has decided to stand
>>> player.play_round()
>>> player.hand
[10]

After a third call to play_round, we've decided to hit, but busted!
>>> player.play_round()
>>> player.hand
[10, 8, 10]

After a final call to play_round, our hand shouldn't change since we've already busted
>>> player.play_round()
>>> player.hand
[10, 8, 10]
"""
while not self.busted and self.decide_hit():
self.dealer.signal_hit(self)

def discard_hand(self):
"""
>>> player = Player(None, None)
>>> player.deal_to(11)
>>> player.deal_to(5)
>>> player.discard_hand()
>>> player.hand
[]
"""
self.busted = False
self.hand = []

@property
def wins(self):
return self.__wins

@property
def ties(self):
return self.__ties

@property
def losses(self):
return self.__losses

def record_win(self):
"""
>>> player = Player(None, None)
>>> player.record_win()
>>> player.wins
1
"""
self.__wins += 1

def record_loss(self):
"""
>>> player = Player(None, None)
>>> player.record_loss()
>>> player.losses
1
"""
self.__losses += 1

def record_tie(self):
"""
>>> player = Player(None, None)
>>> player.record_tie()
>>> player.ties
1
"""
self.__ties += 1

def reset_stats(self):
"""
>>> player = Player(None, None)
>>> player.record_tie()
>>> player.record_loss()
>>> player.record_win()
>>> player.reset_stats()
>>> player.ties
0
>>> player.wins
0
>>> player.losses
0
"""
self.__ties = self.__wins = self.__losses = 0

def __repr__(self):
"""
Output should include the player name, their current hand, and their wins/ties/losses in that order
>>> player = Player("Eric", None)
>>> player.record_loss()
>>> player.record_win()
>>> player.record_win()
>>> player
Eric: [] 2/0/1
"""

return f"{self.name}: {self.hand} {self.wins}/{self.ties}/{self.losses}"

if __name__ == "__main__":
import doctest
doctest.testmod()

Code Screenshots:

import random class Player: def __init_(self, name, dealer): self.name = name self.dealer = dealer self.hand = [] self. _wins = 0 self._ties = 0 self. _losses = 0 self.busted = False def decide_hit(self): # DO NOT MODIFY return random.choice ([True, True, False]), def deal_to(self, card_value): >>> player = Player(None, None) >>> player.deal_to(11) >>> player.hand [11] >>> player.deal_to (10) >>> player.hand [11, 10] self.hand.append(card_value) if self.card_sum > 21: self.busted = True @property def card_sum(self): >>> player = Player(None, None) >>> player.deal_to(2) >>> player.card_sum >>> player.deal_to(10) >>> player.card_sum 12 return sum(self.hand) def play_round(self): >>> from dealer import Dealer >>> import random; random.seed (1) >>> dealer = Dealer) >>> dealer.shuffle_deck) >>> player = Player(None, dealer) We see that after the first call the play_round, we have only hit once as dictated by decide_hit >>> player.play_round >>> player.hand [10] After calling play_round again, decide_hit has decided to stand

>>> player = Player(None, None) >>> player.record_tie >>> player.ties 124 125 126 self._ties += 1 128 129 130 def reset_stats(self): в ليبيا بيا о بيا بيا ليبيا ليبية >>> player = Player(None, None) >>> player.record_tie() >>> player.record_loss >>> player.record_win() >>> player.reset_stats() >>> player.ties л в о ليبية ليبية со >>> player.wins >>> player.losses self._ties - self. wins = self._losses - @ 140 141 142 143 144 145 146 147 148 149 def _repr_(self): Output should include the player name, their current hand, and their wins/ties/losses in that order >>> player = Player("Eric", None) >>> player.record_loss() >>> player.record_win() >>> player.record_win() >>> player Eric: [] 2/0/1 л лллллллл WN CON O return f"{self.name}: {self.hand} {self.wins}/{self.ties}/{self.losses}" 159 160 161 162 if _name_== "_main_": import doctest doctest.testmod()

Source code for dealer.py:

from player import Player
from card_deck import CardDeck

class Dealer(Player):

def __init__(self):
super().__init__("Dealer", None)
self.deck = CardDeck()

def shuffle_deck(self):
"""
>>> import random; random.seed(1)
>>> dealer = Dealer()
>>> dealer.shuffle_deck()
>>> str(dealer.deck)[0:20]
'10 8 10 6 8 9 3 10 2'
"""
self.deck.shuffle()

def signal_hit(self, player):
"""
A method called by players when they want to hit
Player objects should pass their `self` references to this method
Should deal one card to the player that signalled a hit

These doctests will not run properly if the `deal_to` method
in the `Player` class is not properly implemented

>>> import random; random.seed(1)
>>> dealer = Dealer()
>>> dealer.shuffle_deck()
>>> player = Player(None, None)
>>> dealer.signal_hit(player)
>>> player.hand
[10]
"""
card = self.deck.draw()
if card:
player.deal_to(card)

def play_round(self):
"""
A dealer should hit if his hand totals to 16 or less

>>> import random; random.seed(1)
>>> dealer = Dealer()
>>> dealer.shuffle_deck()
>>> dealer.play_round()
>>> dealer.hand
[10, 8]
"""
while not self.busted and self.card_sum <= 16:
self.signal_hit(self)

if __name__ == "__main__":
import doctest
doctest.testmod()

Code Screenshots:

from player import Player from card_deck import CardDeck class Dealer (PLayer): def init__(self): super(). __init_("Dealer", None) self.deck = CardDeck() def shuffle_deck(self): >>> import random; random.seed(1) >>> dealer = Dealer >>> dealer.shuffle_deck() >>> str(dealer.deck)[0:20] * 10 8 10 6 8 9 3 10 2 self.deck.shuffle() def signal_hit(self, player): A method called by players when they want to hit Player objects should pass their self references to this method Should deal one card to the player that signalled a hit These doctests will not run properly if the deal_to" method in the player class is not properly implemented >>> import random; random.seed(1) >>> dealer = Dealer >>> dealer.shuffle_deck() >>> player = Player(None, None) >>> dealer.signal_hit(player) >>> player.hand [10] card = self.deck.draw() if card: player.deal_to(card) def play_round(self): A dealer should hit if his hand totals to 16 or less >>> import random; random.seed(1) >>> dealer = Dealer >>> dealer.shuffle_deck) >>> dealer.play_round >>> dealer.hand [10, 8] while not self.busted and self.card_sum <= 16: self.signal_hit(self) if name__ == "_main__": import doctest doctest. testmod()

Source code for card_deck.py:

import random
class CardDeck:
class Card:
def __init__(self, value):
self.value = value
self.next = None

def __repr__(self):
return "{}".format(self.value)

def __init__(self):
self.top = None

def shuffle(self):
card_list = 4 * [x for x in range(2, 12)] + 12 * [10]
random.shuffle(card_list)

self.top = None

for card in card_list:
new_card = self.Card(card)
new_card.next = self.top
self.top = new_card

def __repr__(self):
curr = self.top
out = ""
card_list = []
while curr is not None:
card_list.append(str(curr.value))
curr = curr.next
return " ".join(card_list)

def draw(self):
"""
>>> import random; random.seed(1)
>>> deck = CardDeck()
>>> deck.shuffle()
>>> deck.draw()
10
>>> deck.draw()
8
>>> deck.draw()
10
>>> deck.draw()
6
>>> deck
8 9 3 10 2 10 6 5 8 10 3 10 9 2 10 9 6 10 5 5 2 6 8 7 2 4 10 4 11 10 3 10 10 5 7 10 10 11 7 7 3 11 10 4 4 9 11 10
"""

if self.top is not None:
node = self.top
self.top = self.top.next
return node.value
else:
return None

if __name__ == "__main__":
import doctest
doctest.testmod()

Code Screenshots:

1 import random class CardDeck: class Card: def __init__(self, value): self.value = value self.next = None def repr__(self): return "{}".format(self.value) def init__(self): self.top= None def shuffle(self): card list = 4 * [x for x in range (2, 12)] + 12 * [10] random.shuffle(card_list) self.top = None for card in card_list: new_card = self.Card(card) new_card.next = self.top self.top = new_card def _repr__(self): curr = self.top out = "" card_list = [] while curr is not None: card_list.append(str(curr.value)) curr = curr.next return" ".join(card_list) def draw(self): >>> import random; random.seed(1) >>> deck = CardDeck() >>> deck.shuffle() >>> deck.draw() 10 >>> deck.draw() 8 >>> deck.draw() 10 >>> deck.draw() >>> deck 8 9 3 10 2 10 6 5 8 10 3 10 9 2 10 9 6 10 5 5 2 6 8 7 24 10 4 11 10 3 10 10 5 7 10 10 11 7 7 3 11 10 4 4 9 11 10 if self.top is not None: node = self.top self.top = self.top.next return node.value else: return None if __name__ == "_main__": import doctest doctest.testmod()

Source code for blackjack_game.py:

from player import Player
from dealer import Dealer

class BlackjackGame:
def __init__(self, player_names):
self.dealer = Dealer()
self.player_list = [Player(name, self.dealer) for name in player_names]

def play_rounds(self, num_rounds=1):
"""
>>> import random; random.seed(1)
>>> game = BlackjackGame(["Lawrence","Melissa"])
>>> print(game.play_rounds(2))
Round 1
Dealer: [10, 9] 0/0/0
Lawrence: [10, 6, 3] 0/1/0
Melissa: [8, 8] 0/0/1
Round 2
Dealer: [10, 10] 0/0/0
Lawrence: [10, 3] 0/1/1
Melissa: [9, 10] 0/0/2
"""
string = ""
for i in range(0, num_rounds):
self.dealer.hand = []
for p in self.player_list:
p.hand = []
self.dealer.shuffle_deck()
# deal first two cards
for _ in [1, 2]:
for p in self.player_list:
self.dealer.signal_hit(p)
self.dealer.signal_hit(self.dealer)

# play out round
for p in self.player_list:
p.play_round()
self.dealer.play_round()

# score round
if sum(self.dealer.hand[:2]) == 21:
for p in self.player_list:
if sum(p.hand[:2]) == 21:
p.record_tie()
else:
p.record_loss()
elif self.dealer.busted:
for p in self.player_list:
p.record_win()
else:
for p in self.player_list:
if sum(p.hand[:2]) == 21:
p.record_win()
elif p.busted or p.card_sum < self.dealer.card_sum:
p.record_loss()
elif p.card_sum > self.dealer.card_sum:
p.record_win()
elif p.card_sum == self.dealer.card_sum:
p.record_tie()

# build report
string += f"Round {i + 1}\n"
string += str(self.dealer) + "\n"
for p in self.player_list:
string += str(p) + "\n"
return string[0:-1]

def reset_game(self):
"""
>>> game = BlackjackGame(["Lawrence", "Melissa"])
>>> _ = game.play_rounds()
>>> game.reset_game()
>>> game.player_list[0]
Lawrence: [] 0/0/0
>>> game.player_list[1]
Melissa: [] 0/0/0
"""
self.dealer = Dealer()
self.player_list = [Player(p.name, self.dealer) for p in self.player_list]

if __name__ == "__main__":
import doctest
doctest.testmod()

Code Screenshots:

1 2 from player import Player from dealer import Dealer class BlackjackGame: def __init__(self, player_names): self.dealer = Dealer) self.player_list = [Player(name, self.dealer) for name in player_names ] def play_rounds(self, num_rounds=1): >>> import random; random.seed(1) >>> game = BlackjackGame(["Lawrence", "Melissa"]) >>> print(game.play_rounds (2)) Round 1 Dealer: [10, 9] 0/0/0 Lawrence: [10, 6, 3] 0/1/0 Melissa: [8, 8] 0/0/1 Round 2 Dealer: [10, 10] 0/0/0 Lawrence: [10, 3] 0/1/1 Melissa: [9, 10] 0/0/2 string = "" for i in range(e, num_rounds): self.dealer.hand = [] for p in self-player_list: p.hand = [] self.dealer.shuffle_deck() # deal first two cards for in [1, 2]: for p in self-player_list: self.dealer.signal_hit(P) self.dealer.signal_hit(self.dealer) # play out round for p in self.player_list: p.play_round() self.dealer.play_round() # score round if sum(self.dealer.hand[:2]) == 21: for p in self-player_list: if sum(p.hand[:2]) == 21: p.record_tie) else: p.record_loss() elif self.dealer.busted: for p in self-player_list: p.record_win else: for p in self-player_list: if sum(p.hand[:2]) == 21: p.record_win() elif p.busted or p.card sum < self.dealer.card sum: p.record_loss() elif p.card_sum > self.dealer.card_sum: p.record win() elif p.card_sum == self.dealer.card_sum: p.record_tie()

# build report string += F"Round {i + 1}\n" string += str(self.dealer) + "\n" for p in self.player_list: = str() + "\n" return string(0:-1] def reset_game(self): >>> game = BlackjackGame (["Lawrence", "Melissa"]). >>>__ = game.play_rounds() >>> game.reset_game) >>> game.player_list[@] Lawrence: [] 0/0/0 >>> game.player_list[1] Melissa: [] 0/0/0 self.dealer = Dealer() self.player_list = [Player(p.name, self.dealer) for p in self-player_list] 82 if _name__ == "_main__": import doctest doctest.testmod()

Output Screenshots:

? player = Player (None, None) > player.deal_to (11) player.hand [11] > player.deal_to (10) > player.hand [11, 10] player = Player (None, None) > player.deal to (2) player.card_sum player.deal to (10) ? player.card_sum 12 from dealer import Dealer } import random; random.seed (1) dealer = Dealer () > dealer.shuffle deck () > player = Player (None, dealer), 3 player.play round() > player.hand [10] player.play_round() > player.hand [10] > player.play_round() > player.hand [10, 8, 10] > player.play round() > player.hand [10, 8, 10] player = Player (None, None) > player.deal_to (11) > player.deal_to (5) > player.discard_hand() 3 player.hand

> player = Player (None, None) > player.record win() > player.wins > player = Player (None, None) > player.record_loss () player.losses > player = Player (None, None) > player.record_tie () > player.ties > player = Player (None, None) player.record tie () > player.record loss () > player.record_win() > player.reset_stats() > player.reset_stats() > player.ties player.wins 3 player.losses > player = Player ("Eric", None) > player.record loss () > player.record win() > player.record win() > player Eric: [] 2/0/1

Hope it helps, if you like the answer give it thumbs up. Thank you.