Project: a card game of 21

Checkpoint 2: a deck you can control

A real game shuffles. A test needs to know which cards come next. Both are possible if the functions take the deck as a parameter and deal from the front of the list with pop(0):

import random

def new_deck(rng):
    cards = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"] * 4
    rng.shuffle(cards)
    return cards

def deal(deck):
    return deck.pop(0)

deck = new_deck(random.Random(5))
print(len(deck), deal(deck), deal(deck), len(deck))

fixed = ["K", "9", "5"]
print(deal(fixed), fixed)

In play, new_deck(random.Random()) gives a fresh shuffle every time. A check can skip shuffling and hand in ["K", "9", "5"], so it knows the first card is a king. pop(0) removes and returns the first item, so the deck shrinks as cards are dealt, like a real one.

This is the same idea as passing the random generator in, from the word game: the function asks for what it depends on, instead of reaching out for it.

def card_value(card):
    if card in ("J", "Q", "K"):
        return 10
    if card == "A":
        return 11
    return int(card)

def hand_score(cards):
    total = sum(card_value(c) for c in cards)
    aces = cards.count("A")
    while total > 21 and aces > 0:
        total = total - 10
        aces = aces - 1
    return total

def deal(deck):
    return deck.pop(0)

def dealer_turn(hand, deck):
    pass

Two loops, two ways of stopping

The player's turn and the dealer's turn are both loops, but they stop for different reasons, and it helps to name the difference.

The player's loop stops on a choice or on a fact. The choice is "stand". The facts are a bust, or reaching exactly 21, where hitting could only hurt. So it's while hand_score(player) < 21: with a break for "stand" inside. An answer that is neither "hit" nor "stand" changes nothing, and the loop simply asks again.

The dealer's loop has no choices at all. The rule says "take cards until 17 or more", which is exactly a while loop's condition: while hand_score(dealer) < 17:. There's nothing to ask and nothing to break out of.

Spotting which kind of loop a rule describes saves time. "Until the person says stop" needs input and a break. "Until a number reaches a limit" is the loop's condition, written straight from the rule.

Checkpoint 3: who won

One function compares the finished hands. The order of the tests matters, the same lesson as the labels that were checked in the wrong order:

def result(player_total, dealer_total):
    if player_total > 21:
        return "lose"
    if dealer_total > 21:
        return "win"
    if player_total > dealer_total:
        return "win"
    if player_total < dealer_total:
        return "lose"
    return "draw"

print(result(22, 25), result(19, 23), result(20, 18), result(18, 18))

The player's bust comes first: in this game, a player who busts loses even if the dealer would bust too. Get the order wrong and that case gives the wrong answer, while every other case looks fine. That's exactly the kind of quiet bug that only a test for the edge case catches.

def card_value(card):
    if card in ("J", "Q", "K"):
        return 10
    if card == "A":
        return 11
    return int(card)

def hand_score(cards):
    total = sum(card_value(c) for c in cards)
    aces = cards.count("A")
    while total > 21 and aces > 0:
        total, aces = total - 10, aces - 1
    return total

def play_round(deck):
    player = [deck.pop(0), deck.pop(0)]
    dealer = [deck.pop(0), deck.pop(0)]
    while hand_score(player) < 21:
        choice = input(f"You have {player} = {hand_score(player)}. Hit or stand? ").strip().lower()
        if choice == "stand":
            break
        if choice == "hit":
            player.append(deck.pop(0))
    while hand_score(player) <= 21 and hand_score(dealer) < 17:
        dealer.append(deck.pop(0))
    print("You:", hand_score(player), "Dealer:", hand_score(dealer))

play_round(["2", "K", "10", "6", "7", "8", "4"])

Go further

The game works. Here are some ways to grow it:

• Show only the dealer's first card until the player has finished, as in a real game.
• Keep a running score over several rounds, with a fresh shuffle each time.
• Add "double": the player takes exactly one more card and stands.
• Build a warm-up game from the same parts: show two products from the shop and ask which one has more in stock. It's another rules function plus a short loop.

Whatever you add, keep the pattern: rules in small functions you can check with fixed decks, and one loop that asks questions.