Python 小型项目大全 26~30

Fibonacci Sequence, by Al Sweigart email@protected
`--snip--`
Enter the Nth Fibonacci number you wish to
calculate (such as 5, 50, 1000, 9999), or QUIT to quit:
> 50
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049

"""Fibonacci Sequence, by Al Sweigart email@protected
Calculates numbers of the Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13...
This code is available at https://nostarch.com/big-book-small-python-programming
Tags: short, math"""
import sys
print('''Fibonacci Sequence, by Al Sweigart email@protected
The Fibonacci sequence begins with 0 and 1, and the next number is the
sum of the previous two numbers. The sequence continues forever:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987...
''')
while True:  # Main program loop.
    while True:  # Keep asking until the user enters valid input.
        print('Enter the Nth Fibonacci number you wish to')
        print('calculate (such as 5, 50, 1000, 9999), or QUIT to quit:')
        response = input('> ').upper()
        if response == 'QUIT':
            print('Thanks for playing!')
            sys.exit()
        if response.isdecimal() and int(response) != 0:
            nth = int(response)
            break  # Exit the loop when the user enteres a valid number.
        print('Please enter a number greater than 0, or QUIT.')
    print()
    # Handle the special cases if the user entered 1 or 2:
    if nth == 1:
        print('0')
        print()
        print('The #1 Fibonacci number is 0.')
        continue
    elif nth == 2:
        print('0, 1')
        print()
        print('The #2 Fibonacci number is 1.')
        continue
    # Display warning if the user entered a large number:
    if nth >= 10000:
        print('WARNING: This will take a while to display on the')
        print('screen. If you want to quit this program before it is')
        print('done, press Ctrl-C.')
        input('Press Enter to begin...')
    # Calculate the Nth Fibonacci number:
    secondToLastNumber = 0
    lastNumber = 1
    fibNumbersCalculated = 2
    print('0, 1, ', end='')  # Display the first two Fibonacci numbers.
    # Display all the later numbers of the Fibonacci sequence:
    while True:
        nextNumber = secondToLastNumber + lastNumber
        fibNumbersCalculated += 1
        # Display the next number in the sequence:
        print(nextNumber, end='')
        # Check if we've found the Nth number the user wants:
        if fibNumbersCalculated == nth:
            print()
            print()
            print('The #', fibNumbersCalculated, ' Fibonacci ',
                  'number is ', nextNumber, sep='')
            break
        # Print a comma in between the sequence numbers:
        print(', ', end='')
        # Shift the last two numbers:
        secondToLastNumber = lastNumber
        lastNumber = nextNumber

"""Fish Tank, by Al Sweigart email@protected
A peaceful animation of a fish tank. Press Ctrl-C to stop.
Similar to ASCIIQuarium or @EmojiAquarium, but mine is based on an
older ASCII fish tank program for DOS.
https://robobunny.com/projects/asciiquarium/html/
https://twitter.com/EmojiAquarium
This code is available at https://nostarch.com/big-book-small-python-programming
Tags: extra-large, artistic, bext"""
import random, sys, time
try:
   import bext
except ImportError:
   print('This program requires the bext module, which you')
   print('can install by following the instructions at')
   print('https://pypi.org/project/Bext/')
   sys.exit()
# Set up the constants:
WIDTH, HEIGHT = bext.size()
# We can't print to the last column on Windows without it adding a
# newline automatically, so reduce the width by one:
WIDTH -= 1
NUM_KELP = 2  # (!) Try changing this to 10.
NUM_FISH = 10  # (!) Try changing this to 2 or 100.
NUM_BUBBLERS = 1  # (!) Try changing this to 0 or 10.
FRAMES_PER_SECOND = 4  # (!) Try changing this number to 1 or 60.
# (!) Try changing the constants to create a fish tank with only kelp,
# or only bubblers.
# NOTE: Every string in a fish dictionary should be the same length.
FISH_TYPES = [
 {'right': ['><>'],          'left': ['<><']},
 {'right': ['>||>'],         'left': ['<||<']},
 {'right': ['>))>'],         'left': ['<[[<']},
 {'right': ['>||o', '>||.'], 'left': ['o||<', '.||<']},
 {'right': ['>))o', '>)).'], 'left': ['o[[<', '.[[<']},
 {'right': ['>-==>'],        'left': ['<==-<']},
 {'right': [r'>\\>'],        'left': ['<//<']},
 {'right': ['><)))*>'],      'left': ['<*(((><']},
 {'right': ['}-[[[*>'],      'left': ['<*]]]-{']},
 {'right': [']-<)))b>'],     'left': ['<d(((>-[']},
 {'right': ['><XXX*>'],      'left': ['<*XXX><']},
 {'right': ['_.-._.-^=>', '.-._.-.^=>',
            '-._.-._^=>', '._.-._.^=>'],
  'left':  ['<=^-._.-._', '<=^.-._.-.',
            '<=^_.-._.-', '<=^._.-._.']},
 ]  # (!) Try adding your own fish to FISH_TYPES.
LONGEST_FISH_LENGTH = 10  # Longest single string in FISH_TYPES.
# The x and y positions where a fish runs into the edge of the screen:
LEFT_EDGE = 0
RIGHT_EDGE = WIDTH - 1 - LONGEST_FISH_LENGTH
TOP_EDGE = 0
BOTTOM_EDGE = HEIGHT - 2
def main():
   global FISHES, BUBBLERS, BUBBLES, KELPS, STEP
   bext.bg('black')
   bext.clear()
   # Generate the global variables:
   FISHES = []
   for i in range(NUM_FISH):
       FISHES.append(generateFish())
   # NOTE: Bubbles are drawn, but not the bubblers themselves.
   BUBBLERS = []
   for i in range(NUM_BUBBLERS):
       # Each bubbler starts at a random position.
       BUBBLERS.append(random.randint(LEFT_EDGE, RIGHT_EDGE))
   BUBBLES = []
   KELPS = []
   for i in range(NUM_KELP):
       kelpx = random.randint(LEFT_EDGE, RIGHT_EDGE)
       kelp = {'x': kelpx, 'segments': []}
       # Generate each segment of the kelp:
       for i in range(random.randint(6, HEIGHT - 1)):
           kelp['segments'].append(random.choice(['(', ')']))
       KELPS.append(kelp)
   # Run the simulation:
   STEP = 1
   while True:
       simulateAquarium()
       drawAquarium()
       time.sleep(1 / FRAMES_PER_SECOND)
       clearAquarium()
       STEP += 1
def getRandomColor():
   """Return a string of a random color."""
   return random.choice(('black', 'red', 'green', 'yellow', 'blue',
                         'purple', 'cyan', 'white'))
def generateFish():
    """Return a dictionary that represents a fish."""
    fishType = random.choice(FISH_TYPES)
    # Set up colors for each character in the fish text:
    colorPattern = random.choice(('random', 'head-tail', 'single'))
    fishLength = len(fishType['right'][0])
    if colorPattern == 'random':  # All parts are randomly colored.
        colors = []
        for i in range(fishLength):
            colors.append(getRandomColor())
    if colorPattern == 'single' or colorPattern == 'head-tail':
        colors = [getRandomColor()] * fishLength  # All the same color.
    if colorPattern == 'head-tail':  # Head/tail different from body.
        headTailColor = getRandomColor()
        colors[0] = headTailColor  # Set head color.
        colors[-1] = headTailColor  # Set tail color.
    # Set up the rest of fish data structure:
    fish = {'right':            fishType['right'],
            'left':             fishType['left'],
            'colors':           colors,
            'hSpeed':           random.randint(1, 6),
            'vSpeed':           random.randint(5, 15),
            'timeToHDirChange': random.randint(10, 60),
            'timeToVDirChange': random.randint(2, 20),
            'goingRight':       random.choice([True, False]),
            'goingDown':        random.choice([True, False])}
    # 'x' is always the leftmost side of the fish body:
    fish['x'] = random.randint(0, WIDTH - 1 - LONGEST_FISH_LENGTH)
    fish['y'] = random.randint(0, HEIGHT - 2)
    return fish
def simulateAquarium():
    """Simulate the movements in the aquarium for one step."""
    global FISHES, BUBBLERS, BUBBLES, KELP, STEP
    # Simulate the fish for one step:
    for fish in FISHES:
        # Move the fish horizontally:
        if STEP % fish['hSpeed'] == 0:
            if fish['goingRight']:
                if fish['x'] != RIGHT_EDGE:
                    fish['x'] += 1  # Move the fish right.
                else:
                    fish['goingRight'] = False  # Turn the fish around.
                    fish['colors'].reverse()  # Turn the colors around.
            else:
                if fish['x'] != LEFT_EDGE:
                    fish['x'] -= 1  # Move the fish left.
                else:
                    fish['goingRight'] = True  # Turn the fish around.
                    fish['colors'].reverse()  # Turn the colors around.
        # Fish can randomly change their horizontal direction:
        fish['timeToHDirChange'] -= 1
        if fish['timeToHDirChange'] == 0:
            fish['timeToHDirChange'] = random.randint(10, 60)
            # Turn the fish around:
            fish['goingRight'] = not fish['goingRight']
        # Move the fish vertically:
        if STEP % fish['vSpeed'] == 0:
            if fish['goingDown']:
                if fish['y'] != BOTTOM_EDGE:
                    fish['y'] += 1  # Move the fish down.
                else:
                    fish['goingDown'] = False  # Turn the fish around.
            else:
                if fish['y'] != TOP_EDGE:
                    fish['y'] -= 1  # Move the fish up.
                else:
                    fish['goingDown'] = True  # Turn the fish around.
        # Fish can randomly change their vertical direction:
        fish['timeToVDirChange'] -= 1
        if fish['timeToVDirChange'] == 0:
            fish['timeToVDirChange'] = random.randint(2, 20)
            # Turn the fish around:
            fish['goingDown'] = not fish['goingDown']
    # Generate bubbles from bubblers:
    for bubbler in BUBBLERS:
        # There is a 1 in 5 chance of making a bubble:
        if random.randint(1, 5) == 1:
            BUBBLES.append({'x': bubbler, 'y': HEIGHT - 2})
    # Move the bubbles:
    for bubble in BUBBLES:
        diceRoll = random.randint(1, 6)
        if (diceRoll == 1) and (bubble['x'] != LEFT_EDGE):
            bubble['x'] -= 1  # Bubble goes left.
        elif (diceRoll == 2) and (bubble['x'] != RIGHT_EDGE):
            bubble['x'] += 1  # Bubble goes right.
        bubble['y'] -= 1  # The bubble always goes up.
    # Iterate over BUBBLES in reverse because I'm deleting from BUBBLES
    # while iterating over it.
    for i in range(len(BUBBLES) - 1, -1, -1):
        if BUBBLES[i]['y'] == TOP_EDGE:  # Delete bubbles that reach the top.
            del BUBBLES[i]
    # Simulate the kelp waving for one step:
    for kelp in KELPS:
        for i, kelpSegment in enumerate(kelp['segments']):
            # 1 in 20 chance to change waving:
            if random.randint(1, 20) == 1:
                if kelpSegment == '(':
                    kelp['segments'][i] = ')'
                elif kelpSegment == ')':
                    kelp['segments'][i] = '('
def drawAquarium():
    """Draw the aquarium on the screen."""
    global FISHES, BUBBLERS, BUBBLES, KELP, STEP
    # Draw quit message.
    bext.fg('white')
    bext.goto(0, 0)
    print('Fish Tank, by Al Sweigart    Ctrl-C to quit.', end='')
    # Draw the bubbles:
    bext.fg('white')
    for bubble in BUBBLES:
        bext.goto(bubble['x'], bubble['y'])
        print(random.choice(('o', 'O')), end='')
    # Draw the fish:
    for fish in FISHES:
        bext.goto(fish['x'], fish['y'])
        # Get the correct right- or left-facing fish text.
        if fish['goingRight']:
            fishText = fish['right'][STEP % len(fish['right'])]
        else:
            fishText = fish['left'][STEP % len(fish['left'])]
        # Draw each character of the fish text in the right color.
        for i, fishPart in enumerate(fishText):
            bext.fg(fish['colors'][i])
            print(fishPart, end='')
    # Draw the kelp:
    bext.fg('green')
    for kelp in KELPS:
        for i, kelpSegment in enumerate(kelp['segments']):
            if kelpSegment == '(':
                bext.goto(kelp['x'], BOTTOM_EDGE - i)
            elif kelpSegment == ')':
                bext.goto(kelp['x'] + 1, BOTTOM_EDGE - i)
            print(kelpSegment, end='')
    # Draw the sand on the bottom:
    bext.fg('yellow')
    bext.goto(0, HEIGHT - 1)
    print(chr(9617) * (WIDTH - 1), end='')  # Draws '░' characters.
    sys.stdout.flush()  # (Required for bext-using programs.)
def clearAquarium():
    """Draw empty spaces over everything on the screen."""
    global FISHES, BUBBLERS, BUBBLES, KELP
    # Draw the bubbles:
    for bubble in BUBBLES:
        bext.goto(bubble['x'], bubble['y'])
        print(' ', end='')
    # Draw the fish:
    for fish in FISHES:
        bext.goto(fish['x'], fish['y'])
        # Draw each character of the fish text in the right color.
        print(' ' * len(fish['left'][0]), end='')
    # Draw the kelp:
    for kelp in KELPS:
        for i, kelpSegment in enumerate(kelp['segments']):
            bext.goto(kelp['x'], HEIGHT - 2 - i)
            print('  ', end='')
    sys.stdout.flush()  # (Required for bext-using programs.)
# If this program was run (instead of imported), run the game:
if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        sys.exit()  # When Ctrl-C is pressed, end the program.

"""Flooder, by Al Sweigart email@protected
A colorful game where you try to fill the board with a single color. Has
a mode for colorblind players.
Inspired by the "Flood It!" game.
This code is available at https://nostarch.com/big-book-small-python-programming
Tags: large, bext, game"""
import random, sys
try:
   import bext
except ImportError:
   print('This program requires the bext module, which you')
   print('can install by following the instructions at')
   print('https://pypi.org/project/Bext/')
   sys.exit()
# Set up the constants:
BOARD_WIDTH = 16  # (!) Try changing this to 4 or 40.
BOARD_HEIGHT = 14  # (!) Try changing this to 4 or 20.
MOVES_PER_GAME = 20  # (!) Try changing this to 3 or 300.
# Constants for the different shapes used in colorblind mode:
HEART     = chr(9829)  # Character 9829 is '♥'.
DIAMOND   = chr(9830)  # Character 9830 is '♦'.
SPADE     = chr(9824)  # Character 9824 is '♠'.
CLUB      = chr(9827)  # Character 9827 is '♣'.
BALL      = chr(9679)  # Character 9679 is '●'.
TRIANGLE  = chr(9650)  # Character 9650 is '▲'.
BLOCK     = chr(9608)  # Character 9608 is '█'
LEFTRIGHT = chr(9472)  # Character 9472 is '─'
UPDOWN    = chr(9474)  # Character 9474 is '│'
DOWNRIGHT = chr(9484)  # Character 9484 is '┌'
DOWNLEFT  = chr(9488)  # Character 9488 is '┐'
UPRIGHT   = chr(9492)  # Character 9492 is '└'
UPLEFT    = chr(9496)  # Character 9496 is '┘'
# A list of chr() codes is at https://inventwithpython.com/chr
# All the color/shape tiles used on the board:
TILE_TYPES = (0, 1, 2, 3, 4, 5)
COLORS_MAP = {0: 'red', 1: 'green', 2:'blue',
             3:'yellow', 4:'cyan', 5:'purple'}
COLOR_MODE = 'color mode'
SHAPES_MAP = {0: HEART, 1: TRIANGLE, 2: DIAMOND,
             3: BALL, 4: CLUB, 5: SPADE}
SHAPE_MODE = 'shape mode'
def main():
   bext.bg('black')
   bext.fg('white')
   bext.clear()
   print('''Flooder, by Al Sweigart email@protected
Set the upper left color/shape, which fills in all the
adjacent squares of that color/shape. Try to make the
entire board the same color/shape.''')
   print('Do you want to play in colorblind mode? Y/N')
   response = input('> ')
   if response.upper().startswith('Y'):
       displayMode = SHAPE_MODE
   else:
       displayMode = COLOR_MODE
   gameBoard = getNewBoard()
   movesLeft = MOVES_PER_GAME
   while True:  # Main game loop.
       displayBoard(gameBoard, displayMode)
       print('Moves left:', movesLeft)
       playerMove = askForPlayerMove(displayMode)
       changeTile(playerMove, gameBoard, 0, 0)
       movesLeft -= 1
       if hasWon(gameBoard):
           displayBoard(gameBoard, displayMode)
           print('You have won!')
           break
       elif movesLeft == 0:
           displayBoard(gameBoard, displayMode)
           print('You have run out of moves!')
           break
def getNewBoard():
   """Return a dictionary of a new Flood It board."""
   # Keys are (x, y) tuples, values are the tile at that position.
   board = {}
   # Create random colors for the board.
   for x in range(BOARD_WIDTH):
       for y in range(BOARD_HEIGHT):
           board[(x, y)] = random.choice(TILE_TYPES)
   # Make several tiles the same as their neighbor. This creates groups
    # of the same color/shape.
    for i in range(BOARD_WIDTH * BOARD_HEIGHT):
        x = random.randint(0, BOARD_WIDTH - 2)
        y = random.randint(0, BOARD_HEIGHT - 1)
        board[(x + 1, y)] = board[(x, y)]
    return board
def displayBoard(board, displayMode):
    """Display the board on the screen."""
    bext.fg('white')
    # Display the top edge of the board:
    print(DOWNRIGHT + (LEFTRIGHT * BOARD_WIDTH) + DOWNLEFT)
    # Display each row:
    for y in range(BOARD_HEIGHT):
        bext.fg('white')
        if y == 0:  # The first row begins with '>'.
            print('>', end='')
        else:  # Later rows begin with a white vertical line.
            print(UPDOWN, end='')
        # Display each tile in this row:
        for x in range(BOARD_WIDTH):
            bext.fg(COLORS_MAP[board[(x, y)]])
            if displayMode == COLOR_MODE:
                print(BLOCK, end='')
            elif displayMode == SHAPE_MODE:
                print(SHAPES_MAP[board[(x, y)]], end='')
        bext.fg('white')
        print(UPDOWN)  # Rows end with a white vertical line.
    # Display the bottom edge of the board:
    print(UPRIGHT + (LEFTRIGHT * BOARD_WIDTH) + UPLEFT)
def askForPlayerMove(displayMode):
    """Let the player select a color to paint the upper left tile."""
    while True:
        bext.fg('white')
        print('Choose one of ', end='')
        if displayMode == COLOR_MODE:
            bext.fg('red')
            print('(R)ed ', end='')
            bext.fg('green')
            print('(G)reen ', end='')
            bext.fg('blue')
            print('(B)lue ', end='')
            bext.fg('yellow')
            print('(Y)ellow ', end='')
            bext.fg('cyan')
            print('(C)yan ', end='')
            bext.fg('purple')
            print('(P)urple ', end='')
        elif displayMode == SHAPE_MODE:
            bext.fg('red')
            print('(H)eart, ', end='')
            bext.fg('green')
            print('(T)riangle, ', end='')
            bext.fg('blue')
            print('(D)iamond, ', end='')
            bext.fg('yellow')
            print('(B)all, ', end='')
            bext.fg('cyan')
            print('(C)lub, ', end='')
            bext.fg('purple')
            print('(S)pade, ', end='')
        bext.fg('white')
        print('or QUIT:')
        response = input('> ').upper()
        if response == 'QUIT':
            print('Thanks for playing!')
            sys.exit()
        if displayMode == COLOR_MODE and response in tuple('RGBYCP'):
            # Return a tile type number based on the response:
            return {'R': 0, 'G': 1, 'B': 2,
                'Y': 3, 'C': 4, 'P': 5}[response]
        if displayMode == SHAPE_MODE and response in tuple('HTDBCS'):
            # Return a tile type number based on the response:
            return {'H': 0, 'T': 1, 'D':2,
                'B': 3, 'C': 4, 'S': 5}[response]
def changeTile(tileType, board, x, y, charToChange=None):
    """Change the color/shape of a tile using the recursive flood fill
    algorithm."""
    if x == 0 and y == 0:
        charToChange = board[(x, y)]
        if tileType == charToChange:
            return  # Base Case: Already is the same tile.
    board[(x, y)] = tileType
    if x > 0 and board[(x - 1, y)] == charToChange:
        # Recursive Case: Change the left neighbor's tile:
        changeTile(tileType, board, x - 1, y, charToChange)
    if y > 0 and board[(x, y - 1)] == charToChange:
        # Recursive Case: Change the top neighbor's tile:
        changeTile(tileType, board, x, y - 1, charToChange)
    if x < BOARD_WIDTH - 1 and board[(x + 1, y)] == charToChange:
        # Recursive Case: Change the right neighbor's tile:
        changeTile(tileType, board, x + 1, y, charToChange)
    if y < BOARD_HEIGHT - 1 and board[(x, y + 1)] == charToChange:
        # Recursive Case: Change the bottom neighbor's tile:
        changeTile(tileType, board, x, y + 1, charToChange)
def hasWon(board):
    """Return True if the entire board is one color/shape."""
    tile = board[(0, 0)]
    for x in range(BOARD_WIDTH):
        for y in range(BOARD_HEIGHT):
            if board[(x, y)] != tile:
                return False
    return True
# If this program was run (instead of imported), run the game:
if __name__ == '__main__':
    main()

"""Forest Fire Sim, by Al Sweigart email@protected
A simulation of wildfires spreading in a forest. Press Ctrl-C to stop.
Inspired by Nicky Case's Emoji Sim http://ncase.me/simulating/model/
This code is available at https://nostarch.com/big-book-small-python-programming
Tags: short, bext, simulation"""
import random, sys, time
try:
   import bext
except ImportError:
   print('This program requires the bext module, which you')
   print('can install by following the instructions at')
   print('https://pypi.org/project/Bext/')
   sys.exit()
# Set up the constants:
WIDTH = 79
HEIGHT = 22
TREE = 'A'
FIRE = 'W'
EMPTY = ' '
# (!) Try changing these settings to anything between 0.0 and 1.0:
INITIAL_TREE_DENSITY = 0.20  # Amount of forest that starts with trees.
GROW_CHANCE = 0.01  # Chance a blank space turns into a tree.
FIRE_CHANCE = 0.01  # Chance a tree is hit by lightning & burns.
# (!) Try setting the pause length to 1.0 or 0.0:
PAUSE_LENGTH = 0.5
def main():
   forest = createNewForest()
   bext.clear()
   while True:  # Main program loop.
       displayForest(forest)
       # Run a single simulation step:
       nextForest = {'width': forest['width'],
                     'height': forest['height']}
       for x in range(forest['width']):
           for y in range(forest['height']):
               if (x, y) in nextForest:
                   # If we've already set nextForest[(x, y)] on a
                   # previous iteration, just do nothing here:
                   continue
               if ((forest[(x, y)] == EMPTY)
                   and (random.random() <= GROW_CHANCE)):
                   # Grow a tree in this empty space.
                   nextForest[(x, y)] = TREE
               elif ((forest[(x, y)] == TREE)
                   and (random.random() <= FIRE_CHANCE)):
                   # Lightning sets this tree on fire.
                   nextForest[(x, y)] = FIRE
               elif forest[(x, y)] == FIRE:
                   # This tree is currently burning.
                   # Loop through all the neighboring spaces:
                   for ix in range(-1, 2):
                       for iy in range(-1, 2):
                           # Fire spreads to neighboring trees:
                           if forest.get((x + ix, y + iy)) == TREE:
                               nextForest[(x + ix, y + iy)] = FIRE
                   # The tree has burned down now, so erase it:
                   nextForest[(x, y)] = EMPTY
               else:
                   # Just copy the existing object:
                   nextForest[(x, y)] = forest[(x, y)]
       forest = nextForest
       time.sleep(PAUSE_LENGTH)
def createNewForest():
   """Returns a dictionary for a new forest data structure."""
   forest = {'width': WIDTH, 'height': HEIGHT}
   for x in range(WIDTH):
       for y in range(HEIGHT):
           if (random.random() * 100) <= INITIAL_TREE_DENSITY:
               forest[(x, y)] = TREE  # Start as a tree.
           else:
               forest[(x, y)] = EMPTY  # Start as an empty space.
   return forest
def displayForest(forest):
   """Display the forest data structure on the screen."""
   bext.goto(0, 0)
   for y in range(forest['height']):
       for x in range(forest['width']):
           if forest[(x, y)] == TREE:
               bext.fg('green')
               print(TREE, end='')
           elif forest[(x, y)] == FIRE:
               bext.fg('red')
                print(FIRE, end='')
            elif forest[(x, y)] == EMPTY:
                print(EMPTY, end='')
        print()
    bext.fg('reset')  # Use the default font color.
    print('Grow chance: {}%  '.format(GROW_CHANCE * 100), end='')
    print('Lightning chance: {}%  '.format(FIRE_CHANCE * 100), end='')
    print('Press Ctrl-C to quit.')
# If this program was run (instead of imported), run the game:
if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        sys.exit()  # When Ctrl-C is pressed, end the program.

Four in a Row, by Al Sweigart email@protected
`--snip--`
     1234567
    +-------+
    |.......|
    |.......|
    |.......|
    |.......|
    |.......|
    |.......|
    +-------+
Player X, enter a column or QUIT:
> 3
     1234567
    +-------+
    |.......|
    |.......|
    |.......|
    |.......|
    |.......|
    |..X....|
    +-------+
Player O, enter a column or QUIT:
> 5
`--snip--`
Player O, enter a column or QUIT:
> 4
     1234567
    +-------+
    |.......|
    |.......|
    |XXX.XO.|
    |OOOOXO.|
    |OOOXOX.|
    |OXXXOXX|
    +-------+
Player O has won!

"""Four in a Row, by Al Sweigart email@protected
A tile-dropping game to get four in a row, similar to Connect Four.
This code is available at https://nostarch.com/big-book-small-python-programming
Tags: large, game, board game, two-player"""
import sys
# Constants used for displaying the board:
EMPTY_SPACE = '.'  # A period is easier to count than a space.
PLAYER_X = 'X'
PLAYER_O = 'O'
# Note: Update displayBoard() & COLUMN_LABELS if BOARD_WIDTH is changed.
BOARD_WIDTH = 7
BOARD_HEIGHT = 6
COLUMN_LABELS = ('1', '2', '3', '4', '5', '6', '7')
assert len(COLUMN_LABELS) == BOARD_WIDTH
def main():
   print("""Four in a Row, by Al Sweigart email@protected
Two players take turns dropping tiles into one of seven columns, trying
to make four in a row horizontally, vertically, or diagonally.
""")
   # Set up a new game:
   gameBoard = getNewBoard()
   playerTurn = PLAYER_X
   while True:  # Run a player's turn.
       # Display the board and get player's move:
       displayBoard(gameBoard)
       playerMove = askForPlayerMove(playerTurn, gameBoard)
       gameBoard[playerMove] = playerTurn
       # Check for a win or tie:
       if isWinner(playerTurn, gameBoard):
           displayBoard(gameBoard)  # Display the board one last time.
           print('Player ' + playerTurn + ' has won!')
           sys.exit()
       elif isFull(gameBoard):
           displayBoard(gameBoard)  # Display the board one last time.
           print('There is a tie!')
           sys.exit()
       # Switch turns to other player:
       if playerTurn == PLAYER_X:
           playerTurn = PLAYER_O
       elif playerTurn == PLAYER_O:
           playerTurn = PLAYER_X
def getNewBoard():
   """Returns a dictionary that represents a Four in a Row board.
   The keys are (columnIndex, rowIndex) tuples of two integers, and the
   values are one of the 'X', 'O' or '.' (empty space) strings."""
   board = {}
   for columnIndex in range(BOARD_WIDTH):
       for rowIndex in range(BOARD_HEIGHT):
           board[(columnIndex, rowIndex)] = EMPTY_SPACE
   return board
def displayBoard(board):
   """Display the board and its tiles on the screen."""
   '''Prepare a list to pass to the format() string method for the
   board template. The list holds all of the board's tiles (and empty
   spaces) going left to right, top to bottom:'''
   tileChars = []
   for rowIndex in range(BOARD_HEIGHT):
       for columnIndex in range(BOARD_WIDTH):
           tileChars.append(board[(columnIndex, rowIndex)])
   # Display the board:
   print("""
    1234567
   +-------+
   |{}{}{}{}{}{}{}|
   |{}{}{}{}{}{}{}|
   |{}{}{}{}{}{}{}|
   |{}{}{}{}{}{}{}|
   |{}{}{}{}{}{}{}|
   |{}{}{}{}{}{}{}|
   +-------+""".format(*tileChars))
def askForPlayerMove(playerTile, board):
   """Let a player select a column on the board to drop a tile into.
   Returns a tuple of the (column, row) that the tile falls into."""
   while True:  # Keep asking player until they enter a valid move.
       print('Player {}, enter a column or QUIT:'.format(playerTile))
       response = input('> ').upper().strip()
       if response == 'QUIT':
           print('Thanks for playing!')
            sys.exit()
        if response not in COLUMN_LABELS:
            print('Enter a number from 1 to {}.'.format(BOARD_WIDTH))
            continue  # Ask player again for their move.
        columnIndex = int(response) - 1  # -1 for 0-based the index.
        # If the column is full, ask for a move again:
        if board[(columnIndex, 0)] != EMPTY_SPACE:
            print('That column is full, select another one.')
            continue  # Ask player again for their move.
        # Starting from the bottom, find the first empty space.
        for rowIndex in range(BOARD_HEIGHT - 1, -1, -1):
            if board[(columnIndex, rowIndex)] == EMPTY_SPACE:
                return (columnIndex, rowIndex)
def isFull(board):
    """Returns True if the `board` has no empty spaces, otherwise
    returns False."""
    for rowIndex in range(BOARD_HEIGHT):
        for columnIndex in range(BOARD_WIDTH):
            if board[(columnIndex, rowIndex)] == EMPTY_SPACE:
                return False  # Found an empty space, so return False.
    return True  # All spaces are full.
def isWinner(playerTile, board):
    """Returns True if `playerTile` has four tiles in a row on `board`,
    otherwise returns False."""
    # Go through the entire board, checking for four-in-a-row:
    for columnIndex in range(BOARD_WIDTH - 3):
        for rowIndex in range(BOARD_HEIGHT):
            # Check for horizontal four-in-a-row going right:
            tile1 = board[(columnIndex, rowIndex)]
            tile2 = board[(columnIndex + 1, rowIndex)]
            tile3 = board[(columnIndex + 2, rowIndex)]
            tile4 = board[(columnIndex + 3, rowIndex)]
            if tile1 == tile2 == tile3 == tile4 == playerTile:
                return True
    for columnIndex in range(BOARD_WIDTH):
        for rowIndex in range(BOARD_HEIGHT - 3):
            # Check for vertical four-in-a-row going down:
            tile1 = board[(columnIndex, rowIndex)]
            tile2 = board[(columnIndex, rowIndex + 1)]
            tile3 = board[(columnIndex, rowIndex + 2)]
            tile4 = board[(columnIndex, rowIndex + 3)]
            if tile1 == tile2 == tile3 == tile4 == playerTile:
                return True
    for columnIndex in range(BOARD_WIDTH - 3):
        for rowIndex in range(BOARD_HEIGHT - 3):
            # Check for four-in-a-row going right-down diagonal:
            tile1 = board[(columnIndex, rowIndex)]
            tile2 = board[(columnIndex + 1, rowIndex + 1)]
            tile3 = board[(columnIndex + 2, rowIndex + 2)]
            tile4 = board[(columnIndex + 3, rowIndex + 3)]
            if tile1 == tile2 == tile3 == tile4 == playerTile:
                return True
            # Check for four-in-a-row going left-down diagonal:
            tile1 = board[(columnIndex + 3, rowIndex)]
            tile2 = board[(columnIndex + 2, rowIndex + 1)]
            tile3 = board[(columnIndex + 1, rowIndex + 2)]
            tile4 = board[(columnIndex, rowIndex + 3)]
            if tile1 == tile2 == tile3 == tile4 == playerTile:
                return True
    return False
# If the program is run (instead of imported), run the game:
if __name__ == '__main__':
    main()