🎰 Slot Machine Program¶

🚀 Open Notebook¶

📺 Video Tutorial¶

Let’s code a beginners Python SLOT MACHINE 🎰 (16:38)

What You’ll Learn¶

In this chapter, you’ll build a complete slot machine game that demonstrates random number generation, list comprehensions, conditional payout logic, game loop mechanics, and input validation. You’ll create an engaging game with emoji symbols, balance management, betting mechanics, and win conditions - bringing together multiple Python concepts into an entertaining project.

Learning Objectives¶

Generate random outcomes using random.choice() and list comprehensions
Implement conditional logic for calculating payouts based on matching patterns
Manage game state with balance tracking and bet validation
Create engaging user interfaces with emoji symbols
Design game loops with proper entry and exit conditions
Validate user input to prevent crashes and cheating

Concept Explanation¶

Slot Machine Game Mechanics¶

A slot machine game involves:

Player starts with balance → Place bet → Spin reels → Check for matches → Award payout → Repeat

Win Conditions:

Jackpot: All three symbols match (especially 777)
Three of a Kind: All three symbols match
Two of a Kind: Any two symbols match
No Match: Player loses bet

Random Symbol Generation¶

Using list comprehensions with random.choice():

import random

symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']

# Generate 3 random symbols
row = [random.choice(symbols) for _ in range(3)]
# Example: ['🍒', '🍒', '🍋']

How it works:

# Traditional loop way:
row = []
for _ in range(3):
    row.append(random.choice(symbols))

# List comprehension way (concise):
row = [random.choice(symbols) for _ in range(3)]

List Comprehension Breakdown¶

[random.choice(symbols) for _ in range(3)]
│                       │            │
│                       │            └─ Loop 3 times
│                       └─ Loop variable (not used, so _)
└─ Expression to evaluate each iteration

The underscore _ indicates we don’t need the loop counter:

# When you need the counter:
[i * 2 for i in range(5)]  # [0, 2, 4, 6, 8]

# When you don't need it:
[random.choice(symbols) for _ in range(3)]  # Just need 3 random picks

Payout Logic¶

Conditional checks determine winnings:

def calculate_payout(row, bet):
    # Check 1: All three match
    if row[0] == row[1] == row[2]:
        if row[0] == '7️⃣':
            return bet * 10  # Jackpot!
        else:
            return bet * 5   # Regular three-of-a-kind
    
    # Check 2: Any two match
    elif row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    
    # No match
    return 0

Matching Logic:

row = ['🍒', '🍒', '🍋']

# All three equal: row[0] == row[1] == row[2]
row[0] == row[1] == row[2]  # '🍒' == '🍒' == '🍋' → False

# First two equal: row[0] == row[1]
row[0] == row[1]  # '🍒' == '🍒' → True

# Last two equal: row[1] == row[2]
row[1] == row[2]  # '🍒' == '🍋' → False

# First and last equal: row[0] == row[2]
row[0] == row[2]  # '🍒' == '🍋' → False

Balance Management¶

Track player’s money throughout the game:

balance = 100  # Starting balance

# Placing a bet
balance -= bet  # Deduct bet from balance

# Winning
payout = calculate_payout(row, bet)
balance += payout  # Add winnings to balance

Balance Flow:

Start: $100
Bet $10 → Balance: $90
Win $20 → Balance: $110
Bet $20 → Balance: $90
Lose    → Balance: $90 (no payout)

Input Validation¶

Multiple validation layers prevent errors:

bet = input("Enter bet: ")

# Validation 1: Is it a number?
if not bet.isdigit():
    print("Please enter a number.")
    continue

bet = int(bet)

# Validation 2: Is it in valid range?
if bet > balance or bet < 0:
    print("Invalid bet amount.")
    continue

# Validation 3: Check for quit condition
if bet == 0:
    break  # Exit game

String Methods for Validation:

"123".isdigit()   # True
"abc".isdigit()   # False
"-5".isdigit()    # False (minus sign not a digit)
"12.5".isdigit()  # False (decimal point not a digit)

Game Loop Structure¶

while balance > 0:
    # Show current balance
    print(f"Balance: ${balance}")
    
    # Get bet from player
    bet = get_valid_bet()
    
    # Deduct bet
    balance -= bet
    
    # Spin reels
    row = spin_row()
    print(row)
    
    # Calculate payout
    payout = calculate_payout(row, bet)
    
    # Award winnings
    balance += payout
    
    # Show result
    if payout > 0:
        print(f"You won ${payout}!")
    else:
        print("No win.")

print(f"Game over! Final balance: ${balance}")

Loop Control¶

while balance > 0:
    # continue - skip rest of loop, start next iteration
    if invalid_input:
        continue
    
    # break - exit loop completely
    if bet == 0:
        break

Difference between continue and break:

for i in range(5):
    if i == 2:
        continue  # Skip just this iteration
    print(i)
# Output: 0 1 3 4

for i in range(5):
    if i == 2:
        break  # Exit loop completely
    print(i)
# Output: 0 1

Emoji Symbols¶

Emojis make the game visually appealing:

symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']

# Display with separator
print(" | ".join(['🍒', '🍒', '🍋']))
# Output: 🍒 | 🍒 | 🍋

Using join():

symbols = ['🍒', '🍒', '🍋']

" | ".join(symbols)  # "🍒 | 🍒 | 🍋"
"-".join(symbols)    # "🍒-🍒-🍋"
"".join(symbols)     # "🍒🍒🍋"

Examples¶

Example 1: Basic Slot Machine (Complete)¶

import random

def spin_row():
    """Generate random slot result."""
    symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']
    return [random.choice(symbols) for _ in range(3)]

def calculate_payout(row, bet):
    """Calculate winnings based on matches."""
    # All three match
    if row[0] == row[1] == row[2]:
        if row[0] == '7️⃣':
            return bet * 10  # Jackpot
        return bet * 5       # Three of a kind
    
    # Two match
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    
    return 0  # No win

def main():
    """Main game loop."""
    balance = 100
    print("🎰 Slot Machine Game!")
    print(f"Starting balance: ${balance}")
    
    while balance > 0:
        print(f"\nBalance: ${balance}")
        bet_input = input("Enter bet (0 to quit): ")
        
        # Validate input
        if not bet_input.isdigit():
            print("Please enter a number.")
            continue
        
        bet = int(bet_input)
        
        # Quit condition
        if bet == 0:
            print("Thanks for playing!")
            break
        
        # Validate bet amount
        if bet > balance or bet < 0:
            print("Invalid bet amount.")
            continue
        
        # Deduct bet
        balance -= bet
        
        # Spin
        row = spin_row()
        print("Spinning...")
        print(" | ".join(row))
        
        # Calculate and award payout
        payout = calculate_payout(row, bet)
        balance += payout
        
        if payout > 0:
            print(f"🎉 You won ${payout}!")
        else:
            print("No win this time.")
    
    print(f"\nGame Over! Final balance: ${balance}")

if __name__ == "__main__":
    main()

Example 2: Slot Machine with Statistics¶

import random

def spin_row():
    """Generate random slot result."""
    symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']
    return [random.choice(symbols) for _ in range(3)]

def calculate_payout(row, bet):
    """Calculate winnings."""
    if row[0] == row[1] == row[2]:
        return bet * 10 if row[0] == '7️⃣' else bet * 5
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    return 0

def main():
    """Game with statistics tracking."""
    balance = 100
    spins = 0
    wins = 0
    total_wagered = 0
    total_won = 0
    
    print("🎰 Slot Machine with Stats!")
    
    while balance > 0:
        print(f"\n{'='*40}")
        print(f"Balance: ${balance} | Spins: {spins} | Wins: {wins}")
        
        bet_input = input("Bet (0 to quit): ")
        
        if not bet_input.isdigit():
            print("Invalid input.")
            continue
        
        bet = int(bet_input)
        
        if bet == 0:
            break
        
        if bet > balance or bet < 0:
            print("Invalid bet amount.")
            continue
        
        # Process spin
        balance -= bet
        total_wagered += bet
        spins += 1
        
        row = spin_row()
        print(f"\n{' | '.join(row)}")
        
        payout = calculate_payout(row, bet)
        
        if payout > 0:
            balance += payout
            total_won += payout
            wins += 1
            print(f"🎉 WIN! ${payout}")
        else:
            print("No win.")
    
    # Final statistics
    print(f"\n{'='*40}")
    print("GAME STATISTICS")
    print(f"{'='*40}")
    print(f"Total Spins: {spins}")
    print(f"Wins: {wins}")
    print(f"Win Rate: {(wins/spins*100 if spins > 0 else 0):.1f}%")
    print(f"Total Wagered: ${total_wagered}")
    print(f"Total Won: ${total_won}")
    print(f"Net Result: ${total_won - total_wagered:+d}")
    print(f"Final Balance: ${balance}")

if __name__ == "__main__":
    main()

Example 3: Multi-Line Slot Machine¶

import random

def spin_row():
    """Spin one row of symbols."""
    symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']
    return [random.choice(symbols) for _ in range(3)]

def spin_multi_line(lines):
    """Spin multiple rows."""
    return [spin_row() for _ in range(lines)]

def check_line_win(row, bet):
    """Check if a single line wins."""
    if row[0] == row[1] == row[2]:
        return bet * 10 if row[0] == '7️⃣' else bet * 5
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    return 0

def display_reels(reels):
    """Display the slot machine reels."""
    for i, row in enumerate(reels, 1):
        print(f"Line {i}: {' | '.join(row)}")

def main():
    """Multi-line slot machine."""
    balance = 200
    
    print("🎰 Multi-Line Slot Machine!")
    print("Bet on 1, 2, or 3 lines!")
    
    while balance > 0:
        print(f"\nBalance: ${balance}")
        
        # Get number of lines
        lines_input = input("Lines to play (1-3, 0 to quit): ")
        
        if not lines_input.isdigit():
            print("Please enter a number.")
            continue
        
        lines = int(lines_input)
        
        if lines == 0:
            break
        
        if lines < 1 or lines > 3:
            print("Choose 1-3 lines.")
            continue
        
        # Get bet per line
        bet_input = input(f"Bet per line: $")
        
        if not bet_input.isdigit():
            print("Please enter a number.")
            continue
        
        bet_per_line = int(bet_input)
        total_bet = bet_per_line * lines
        
        if total_bet > balance:
            print(f"Insufficient funds. Need ${total_bet}")
            continue
        
        # Process spin
        balance -= total_bet
        reels = spin_multi_line(lines)
        
        print("\nSpinning...")
        display_reels(reels)
        
        # Calculate total payout
        total_payout = 0
        for i, row in enumerate(reels, 1):
            payout = check_line_win(row, bet_per_line)
            if payout > 0:
                print(f"Line {i} wins ${payout}!")
                total_payout += payout
        
        balance += total_payout
        
        if total_payout > 0:
            print(f"\n🎉 Total won: ${total_payout}")
        else:
            print("\nNo wins this spin.")
    
    print(f"\nFinal balance: ${balance}")

if __name__ == "__main__":
    main()

Example 4: Slot Machine with Bonus Features¶

import random

def spin_row():
    """Spin slot machine row."""
    symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣', '💎']
    return [random.choice(symbols) for _ in range(3)]

def calculate_payout(row, bet):
    """Calculate payout with bonus for diamonds."""
    # Count diamonds (bonus symbol)
    diamond_count = row.count('💎')
    
    # Three diamonds = mega bonus
    if diamond_count == 3:
        return bet * 20
    
    # Two diamonds = good bonus
    if diamond_count == 2:
        return bet * 10
    
    # One diamond = small bonus
    if diamond_count == 1:
        bonus = bet * 3
    else:
        bonus = 0
    
    # Regular wins
    if row[0] == row[1] == row[2]:
        if row[0] == '7️⃣':
            return bet * 10 + bonus
        return bet * 5 + bonus
    
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2 + bonus
    
    return bonus

def main():
    """Slot machine with bonus features."""
    balance = 150
    free_spins = 0
    
    print("🎰 Slot Machine with Bonus!")
    print("💎 Diamonds are bonus symbols!")
    
    while balance > 0 or free_spins > 0:
        print(f"\nBalance: ${balance}")
        if free_spins > 0:
            print(f"🎁 Free spins: {free_spins}")
        
        # Free spin mode
        if free_spins > 0:
            input("Press Enter to use free spin...")
            bet = 10  # Free spins use default bet
            free_spins -= 1
        else:
            bet_input = input("Bet (0 to quit): ")
            
            if not bet_input.isdigit():
                print("Invalid input.")
                continue
            
            bet = int(bet_input)
            
            if bet == 0:
                break
            
            if bet > balance or bet < 0:
                print("Invalid bet.")
                continue
            
            balance -= bet
        
        # Spin
        row = spin_row()
        print(f"\n{' | '.join(row)}")
        
        # Calculate payout
        payout = calculate_payout(row, bet)
        
        # Award free spins for three stars
        if row.count('⭐') == 3:
            free_spins += 5
            print("⭐ BONUS! 5 Free Spins!")
        
        if payout > 0:
            balance += payout
            print(f"🎉 Won ${payout}!")
        else:
            print("No win.")
    
    print(f"\nFinal balance: ${balance}")

if __name__ == "__main__":
    main()

Example 5: Progressive Jackpot Slot¶

import random

jackpot = 1000  # Progressive jackpot pool

def spin_row():
    """Spin slot machine."""
    symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']
    return [random.choice(symbols) for _ in range(3)]

def calculate_payout(row, bet):
    """Calculate payout including jackpot."""
    global jackpot
    
    # Jackpot win - three 7s
    if row[0] == row[1] == row[2] == '7️⃣':
        payout = jackpot + (bet * 10)
        jackpot = 100  # Reset jackpot
        return payout
    
    # Regular three of a kind
    if row[0] == row[1] == row[2]:
        return bet * 5
    
    # Two of a kind
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    
    return 0

def main():
    """Progressive jackpot slot machine."""
    global jackpot
    balance = 200
    
    print("🎰 Progressive Jackpot Slot!")
    print("Hit 7️⃣ 7️⃣ 7️⃣ to win the jackpot!")
    
    while balance > 0:
        print(f"\n{'='*40}")
        print(f"Balance: ${balance}")
        print(f"💰 JACKPOT: ${jackpot}")
        print(f"{'='*40}")
        
        bet_input = input("Bet (0 to quit): ")
        
        if not bet_input.isdigit():
            print("Invalid input.")
            continue
        
        bet = int(bet_input)
        
        if bet == 0:
            break
        
        if bet > balance or bet < 1:
            print("Invalid bet.")
            continue
        
        # Deduct bet and add to jackpot
        balance -= bet
        jackpot += bet * 0.1  # 10% of each bet goes to jackpot
        
        # Spin
        row = spin_row()
        print(f"\n{' | '.join(row)}")
        
        # Calculate payout
        payout = calculate_payout(row, bet)
        
        if row[0] == row[1] == row[2] == '7️⃣':
            print(f"\n🎊🎊🎊 JACKPOT!!! 🎊🎊🎊")
            print(f"You won ${payout}!")
        elif payout > 0:
            print(f"🎉 Won ${payout}!")
        else:
            print("No win.")
        
        balance += payout
    
    print(f"\nFinal balance: ${balance}")
    print(f"Jackpot when you left: ${jackpot}")

if __name__ == "__main__":
    main()

Example 6: Slot Machine with Achievements¶

import random

achievements = {
    'first_win': False,
    'jackpot': False,
    'big_spender': False,
    'lucky_streak': False
}

def spin_row():
    """Generate random symbols."""
    symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']
    return [random.choice(symbols) for _ in range(3)]

def calculate_payout(row, bet):
    """Calculate winnings."""
    if row[0] == row[1] == row[2]:
        return bet * 10 if row[0] == '7️⃣' else bet * 5
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    return 0

def check_achievements(payout, bet, consecutive_wins, total_wagered):
    """Check and unlock achievements."""
    unlocked = []
    
    if payout > 0 and not achievements['first_win']:
        achievements['first_win'] = True
        unlocked.append("🏆 First Win!")
    
    if payout >= bet * 10 and not achievements['jackpot']:
        achievements['jackpot'] = True
        unlocked.append("🏆 Jackpot Winner!")
    
    if total_wagered >= 500 and not achievements['big_spender']:
        achievements['big_spender'] = True
        unlocked.append("🏆 Big Spender!")
    
    if consecutive_wins >= 3 and not achievements['lucky_streak']:
        achievements['lucky_streak'] = True
        unlocked.append("🏆 Lucky Streak!")
    
    return unlocked

def main():
    """Slot machine with achievements."""
    balance = 200
    consecutive_wins = 0
    total_wagered = 0
    
    print("🎰 Slot Machine with Achievements!")
    
    while balance > 0:
        print(f"\nBalance: ${balance}")
        
        bet_input = input("Bet (0 to quit, 'achievements' to view): ")
        
        if bet_input.lower() == 'achievements':
            print("\nACHIEVEMENTS:")
            for name, unlocked in achievements.items():
                status = "✅" if unlocked else "❌"
                print(f"{status} {name.replace('_', ' ').title()}")
            continue
        
        if not bet_input.isdigit():
            print("Invalid input.")
            continue
        
        bet = int(bet_input)
        
        if bet == 0:
            break
        
        if bet > balance or bet < 1:
            print("Invalid bet.")
            continue
        
        balance -= bet
        total_wagered += bet
        
        row = spin_row()
        print(f"\n{' | '.join(row)}")
        
        payout = calculate_payout(row, bet)
        
        if payout > 0:
            balance += payout
            consecutive_wins += 1
            print(f"🎉 Won ${payout}! (Streak: {consecutive_wins})")
        else:
            consecutive_wins = 0
            print("No win.")
        
        # Check for new achievements
        unlocked = check_achievements(payout, bet, consecutive_wins, total_wagered)
        for achievement in unlocked:
            print(achievement)
    
    print(f"\nFinal balance: ${balance}")

if __name__ == "__main__":
    main()

Example 7: Slot Machine with Auto-Play¶

import random
import time

def spin_row():
    """Generate random slot result."""
    symbols = ['🍒', '🍋', '🍊', '🍉', '⭐', '🔔', '7️⃣']
    return [random.choice(symbols) for _ in range(3)]

def calculate_payout(row, bet):
    """Calculate payout."""
    if row[0] == row[1] == row[2]:
        return bet * 10 if row[0] == '7️⃣' else bet * 5
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    return 0

def auto_play(balance, bet_amount, num_spins):
    """Auto-play mode - automatically spin multiple times."""
    print(f"\n🤖 AUTO-PLAY MODE")
    print(f"Spins: {num_spins} | Bet: ${bet_amount}")
    print("-" * 40)
    
    for spin_num in range(1, num_spins + 1):
        if balance < bet_amount:
            print("\n❌ Insufficient balance for next spin!")
            break
        
        balance -= bet_amount
        row = spin_row()
        payout = calculate_payout(row, bet_amount)
        balance += payout
        
        print(f"\nSpin {spin_num}: {' | '.join(row)}")
        
        if payout > 0:
            print(f"  ✅ Won ${payout}")
        else:
            print(f"  ❌ No win")
        
        print(f"  Balance: ${balance}")
        
        time.sleep(0.5)  # Pause between spins
    
    print(f"\n{'='*40}")
    print(f"AUTO-PLAY COMPLETE!")
    print(f"Final Balance: ${balance}")
    print(f"{'='*40}")
    
    return balance

def main():
    """Slot machine with auto-play feature."""
    balance = 200
    
    print("🎰 Slot Machine with Auto-Play!")
    
    while balance > 0:
        print(f"\nBalance: ${balance}")
        print("1. Manual spin")
        print("2. Auto-play")
        print("3. Quit")
        
        choice = input("\nChoice: ").strip()
        
        if choice == "1":
            # Manual spin
            bet_input = input("Bet: $")
            
            if not bet_input.isdigit():
                print("Invalid input.")
                continue
            
            bet = int(bet_input)
            
            if bet > balance or bet < 1:
                print("Invalid bet.")
                continue
            
            balance -= bet
            row = spin_row()
            print(f"\n{' | '.join(row)}")
            
            payout = calculate_payout(row, bet)
            balance += payout
            
            if payout > 0:
                print(f"🎉 Won ${payout}!")
            else:
                print("No win.")
        
        elif choice == "2":
            # Auto-play
            bet_input = input("Bet per spin: $")
            spins_input = input("Number of spins: ")
            
            if not (bet_input.isdigit() and spins_input.isdigit()):
                print("Invalid input.")
                continue
            
            bet = int(bet_input)
            num_spins = int(spins_input)
            
            if bet < 1 or num_spins < 1:
                print("Invalid values.")
                continue
            
            balance = auto_play(balance, bet, num_spins)
        
        elif choice == "3":
            break
        
        else:
            print("Invalid choice.")
    
    print(f"\nFinal balance: ${balance}")

if __name__ == "__main__":
    main()

Practice Exercises¶

Beginner Exercises¶

Simple Random Picker
- Use list comprehension to pick 3 random numbers from 1-10
- Display the results
- Check if all three are the same
- Award points based on matches
Coin Flip Game
- Generate random heads or tails
- Let user bet on outcome
- Track win/loss record
- Show win percentage
Dice Roller
- Roll three dice (random 1-6)
- Check for triples, doubles, or all different
- Award points based on combinations
- Track total score
Color Matcher
- Generate 3 random colors from a list
- Check for matching colors
- Award points for matches
- Use emojis for colors
Number Generator
- Generate 3 random numbers
- Calculate their sum
- Award points if sum is even/odd
- Track statistics

Intermediate Exercises¶

Enhanced Slot Machine
- Add more symbol types (10+ symbols)
- Different payout rates for each symbol
- Implement wild card symbols
- Add sound effects (print descriptions)
- Save high scores to file
Roulette Game
- Simulate roulette wheel (0-36)
- Bet on: single number, red/black, even/odd, ranges
- Different payout rates for different bets
- Track betting history
- Show statistics
Card Draw Game
- Draw 3 random cards from deck
- Check for poker hands (three of a kind, straight, etc.)
- Different payouts for different hands
- Implement deck reshuffling
- Multiple rounds
Lottery Simulator
- Pick 5 random numbers
- User selects 5 numbers
- Compare and calculate matches
- Different prizes for different match counts
- Track total spent vs won
Scratch Card Game
- Generate hidden symbols
- User “scratches” to reveal
- Match 3 symbols to win
- Different prize amounts
- Multiple card types

Advanced Exercises¶

Casino Simulator
- Multiple games (slots, roulette, blackjack)
- Shared balance across games
- Achievement system
- Loyalty points/VIP system
- Daily bonuses
- Save game state
Advanced Slot Machine
- 5-reel, 3-row grid
- Multiple paylines (up to 20)
- Scatter symbols trigger free spins
- Wild symbols with multipliers
- Progressive jackpot
- Bonus rounds
- Animation effects (text-based)
Horse Racing Betting
- Multiple horses with different odds
- Various bet types (win, place, show, exacta)
- Simulate race with random outcomes weighted by odds
- Track race history
- Statistics for each horse
Crypto Trading Simulator
- Simulate cryptocurrency price changes
- Buy/sell with balance
- Price volatility simulation
- Portfolio tracking
- Price alerts
- Trading history
Gacha Game System
- Collection of items with rarity tiers
- Pull mechanics with probability rates
- Pity system (guaranteed rare after X pulls)
- Duplicate system
- Collection tracking
- Banner system with rate-ups

Common Mistakes to Avoid¶

Mistake 1: Not Validating Input Type¶

❌ Wrong:

balance = 100
bet = int(input("Enter bet: "))  # Crashes if user enters "abc"
balance -= bet

✅ Correct:

balance = 100
bet_input = input("Enter bet: ")

if not bet_input.isdigit():
    print("Please enter a valid number.")
else:
    bet = int(bet_input)
    if bet <= balance:
        balance -= bet

Why: Direct conversion with int() crashes if user enters non-numeric input. Always validate first.

Mistake 2: Deducting Bet After Payout¶

❌ Wrong:

# Spin first
row = spin_row()
payout = calculate_payout(row, bet)
balance += payout
balance -= bet  # Wrong order - should deduct before spinning!

✅ Correct:

# Deduct bet BEFORE spinning
balance -= bet

# Then spin and calculate payout
row = spin_row()
payout = calculate_payout(row, bet)
balance += payout  # Add winnings to already-deducted balance

Why: In real gambling, you pay your bet before seeing the result. Also prevents logic errors if player quits mid-game.

Mistake 3: Not Handling Edge Cases in Matching¶

❌ Wrong:

def calculate_payout(row, bet):
    # Only checks first two positions
    if row[0] == row[1]:
        return bet * 2
    return 0
# Misses cases like [🍒, 🍋, 🍒] where first and last match!

✅ Correct:

def calculate_payout(row, bet):
    # Check all three match
    if row[0] == row[1] == row[2]:
        return bet * 5
    
    # Check all possible two-match combinations
    if row[0] == row[1] or row[1] == row[2] or row[0] == row[2]:
        return bet * 2
    
    return 0

Why: Must check all possible matching combinations, not just adjacent positions.

Mistake 4: Not Providing Quit Option¶

❌ Wrong:

while balance > 0:
    # No way to exit except running out of money!
    bet = int(input("Enter bet: "))
    # ... rest of game

✅ Correct:

while balance > 0:
    bet_input = input("Enter bet (0 to quit): ")
    
    if not bet_input.isdigit():
        continue
    
    bet = int(bet_input)
    
    if bet == 0:
        print("Thanks for playing!")
        break  # Let user quit whenever they want
    
    # ... rest of game

Why: Players should be able to quit even if they have money remaining. Always provide a clean exit option.

Real-World Applications¶

1. Gaming Industry¶

Slot machine mechanics are fundamental to game design:

Examples:

Casino games (slots, roulette, cards)
Gacha systems in mobile games
Loot box mechanics
Randomized rewards in RPGs
Battle/combat randomization

Key Concepts:

Random number generation
Probability calculations
Reward systems
Player retention mechanics
Balance and fairness

2. Simulation and Modeling¶

Random outcomes model real-world scenarios:

Examples:

Financial market simulators
Risk assessment tools
Monte Carlo simulations
A/B testing frameworks
Statistical sampling

Key Concepts:

Probability distributions
Statistical analysis
Pattern recognition
Data collection
Result aggregation

3. Game Balance Testing¶

Developers use similar systems to test game mechanics:

Examples:

Reward drop rate testing
Economy balancing
Difficulty curve analysis
RNG fairness verification
Player progression simulation

Key Concepts:

Automated testing
Statistical validation
Balance tuning
Player experience optimization

4. Educational Tools¶

Teaching probability and statistics:

Examples:

Probability demonstrators
Statistics learning tools
Math game applications
Random sampling demos
Experimental design tools

Key Concepts:

Visual probability representation
Interactive learning
Concept demonstration
Engagement through gamification

Challenge Projects¶

1. Complete Casino Simulator¶

Build a multi-game casino application:

Requirements:

5+ different games (slots, roulette, blackjack, poker, dice)
Shared player balance and profile
Achievement/trophy system
Daily login bonuses
VIP levels based on total wagered
Game statistics and analytics
Leaderboards
Save/load game state
Configurable game rules
Admin mode for testing

Skills Applied:

Multiple game mechanics
State management
Data persistence
Complex calculations
User progression systems

2. Advanced Slot Machine¶

Create a professional slot machine game:

Requirements:

5×3 grid (5 reels, 3 rows)
20+ paylines
Wild and scatter symbols
Free spin bonus rounds
Progressive jackpot
Symbol animations (text-based)
Sound effects (descriptions)
Autoplay with settings
Bet level adjustments
RTP (Return to Player) calculations
Statistics tracking

Skills Applied:

Complex grid systems
Advanced pattern matching
Feature systems
Animation sequencing
Statistical analysis

3. Gacha Collection Game¶

Build a collection-based gacha game:

Requirements:

100+ collectible items with rarity tiers
Multiple gacha banners with different rates
Pity system (guaranteed rare after X pulls)
Currency system (free and premium)
Inventory management
Collection completion tracking
Trading/exchange system
Daily missions for free pulls
Event banners with rate-ups
Wish list system

Skills Applied:

Large data management
Probability weighting
Collection systems
Event systems
Complex UI/menu design

4. Trading Simulator¶

Create a stock/crypto trading game:

Requirements:

Multiple assets with realistic price movements
Buy/sell mechanics
Portfolio tracking
Price charts (text-based)
News events affecting prices
Stop-loss and limit orders
Market analysis tools
Trading history
Performance analytics
Different difficulty levels

Skills Applied:

Time-series simulation
Financial calculations
Order management
Data visualization
Market modeling

5. Lottery and Scratch Card Simulator¶

Build a comprehensive lottery system:

Requirements:

Multiple lottery games (pick-3, pick-5, powerball-style)
Scratch cards with various themes
Instant win games
Draw scheduling system
Ticket purchasing
Prize claim system
Odds calculator
Statistics and probabilities
Syndicate/group play
Results archive

Skills Applied:

Multiple game types
Probability calculations
Number generation
Prize distribution
Historical tracking

🎓 Key Takeaways from Video¶

Functions are reusable blocks of code
Define functions using the def keyword
Import modules to use external code
Use loops to repeat actions
Use if-elif-else for conditional logic

💡 These points cover the main concepts from the video tutorial to help reinforce your learning.

🎰 Slot Machine Program¶

🚀 Open Notebook¶

📺 Video Tutorial¶

What You’ll Learn¶

Learning Objectives¶

Concept Explanation¶

Slot Machine Game Mechanics¶

Random Symbol Generation¶

List Comprehension Breakdown¶

Payout Logic¶

Balance Management¶

Input Validation¶

Game Loop Structure¶

Loop Control¶

Emoji Symbols¶

Examples¶

Example 1: Basic Slot Machine (Complete)¶

Example 2: Slot Machine with Statistics¶

Example 3: Multi-Line Slot Machine¶

Example 4: Slot Machine with Bonus Features¶

Example 5: Progressive Jackpot Slot¶

Example 6: Slot Machine with Achievements¶

Example 7: Slot Machine with Auto-Play¶

Practice Exercises¶

Beginner Exercises¶

Intermediate Exercises¶

Advanced Exercises¶

Common Mistakes to Avoid¶

Mistake 1: Not Validating Input Type¶

Mistake 2: Deducting Bet After Payout¶

Mistake 3: Not Handling Edge Cases in Matching¶

Mistake 4: Not Providing Quit Option¶

Real-World Applications¶

1. Gaming Industry¶

2. Simulation and Modeling¶

3. Game Balance Testing¶

4. Educational Tools¶

Challenge Projects¶

1. Complete Casino Simulator¶

2. Advanced Slot Machine¶

3. Gacha Collection Game¶

4. Trading Simulator¶

5. Lottery and Scratch Card Simulator¶

Navigation¶

🎓 Key Takeaways from Video¶