Main
Invent Your Own Computer Games with Python
Invent Your Own Computer Games with Python
Al Sweigart
Invent Your Own Computer Games with Python will teach you how to make computer games using the popular Python programming language—even if you’ve never programmed before!
Begin by building classic games like Hangman, Guess the Number, and Tic-Tac-Toe, and then work your way up to more advanced games, like a text-based treasure hunting game and an animated collision-dodging game with sound effects. Along the way, you’ll learn key programming and math concepts that will help you take your game programming to the next level.
Learn how to:
–Combine loops, variables, and flow control statements into real working programs
–Choose the right data structures for the job, such as lists, dictionaries, and tuples
–Add graphics and animation to your games with the pygame module
–Handle keyboard and mouse input
–Program simple artificial intelligence so you can play against the computer
–Use cryptography to convert text messages into secret code
–Debug your programs and find common errors
As you work through each game, you’ll build a solid foundation in Python and an understanding of computer science fundamentals.
What new game will you create with the power of Python?
The projects in this book are compatible with Python 3.
Begin by building classic games like Hangman, Guess the Number, and Tic-Tac-Toe, and then work your way up to more advanced games, like a text-based treasure hunting game and an animated collision-dodging game with sound effects. Along the way, you’ll learn key programming and math concepts that will help you take your game programming to the next level.
Learn how to:
–Combine loops, variables, and flow control statements into real working programs
–Choose the right data structures for the job, such as lists, dictionaries, and tuples
–Add graphics and animation to your games with the pygame module
–Handle keyboard and mouse input
–Program simple artificial intelligence so you can play against the computer
–Use cryptography to convert text messages into secret code
–Debug your programs and find common errors
As you work through each game, you’ll build a solid foundation in Python and an understanding of computer science fundamentals.
What new game will you create with the power of Python?
The projects in this book are compatible with Python 3.
Categories:
Computers\\Programming: Programming Languages
Year:
2016
Edition:
4
Publisher:
No Starch Press
Language:
english
Pages:
376 / 374
ISBN 10:
1593277954
ISBN 13:
9781593277956
File:
PDF, 8.42 MB
Download (pdf, 8.42 MB)
Preview
- Open in Browser
- Checking other formats...
- Please login to your account first
-
Need help? Please read our short guide how to send a book to Kindle.The file will be sent to your email address. It may take up to 1-5 minutes before you receive it.The file will be sent to your Kindle account. It may takes up to 1-5 minutes before you received it.
Please note you need to add our NEW email km@bookmail.org to approved e-mail addresses. Read more.
You may be interested in
Most frequently terms
player667
loop282
variable246
spam238
python226
variables172
input156
def155
pygame153
rect145
treasure143
coordinate130
strings129
integer128
coordinates126
module121
sonar120
tile116
execution116
spaces114
lists104
evaluates103
programs90
operator90
hangman90
score85
int81
len78
valid75
baddies75
quit75
tic72
debugger71
tac71
import70
chests66
user66
tiles65
dragon63
pixels61
guesses61
integers59
makemove55
boolean55
str51
tuple49
You can write a book review and share your experiences. Other readers will always be interested in your opinion of the books you've read. Whether you've loved the book or not, if you give your honest and detailed thoughts then people will find new books that are right for them.
1
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
2
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
E
You’ll also learn how to:
• Combine loops, variables, and flow control statements into real working programs
• Choose the right data structures for the job, such as
lists, dictionaries, and tuples
• Use cryptography to convert text messages into
secret code
• Debug your programs and find common errors
As you work your way through each game, you’ll build
a solid foundation in Python and an understanding of
computer science fundamentals.
What new game will you create with the power of
Python?
ABOUT THE AUTHOR
Al Sweigart is a software developer who teaches
programming to kids and adults. His programming
tutorials can be found at https://inventwithpython.com/.
He is the best-selling author of Automate the Boring
Stuff with Python and Scratch Programming Playground.
• Add graphics and animation to your games with the
pygame module
COVERS PYTHON 3.X
This book uses a durable binding that won’t snap shut.
FSC FPO
SHELVE IN:
PROGRAMMING LANGUAGES/PYTHON
“ I L I E F L AT .”
$29.95 ($34.95 CDN)
SWEIGART
T H E F I N E ST I N G E E K E N T E RTA I N M E N T ™
w w w.nostarch.com
INVENT
YO U R O W N
COMPU TER G A MES
WITH PY THON
H N
T O
4 TI
I
D
Begin by building classic games like Hangman,
Tic-Tac-Toe, and Guess the Number, and then work
your way up to more advanced games, like Find the
Buried Treasure and a graphical “Dodge the Bad
Guys” game. Along the way, you’ll learn key programming and math concepts, like how to allow for user
input and use the Cartesian coordinate system, that will
help you take your game programming to the next
level.
• Program simple artificial intelligence to create smarter
adversaries
IN V E N T YOU R OW N COMPU T E R
GAMES WITH PY THON
Invent Your Own Computer Games with Python will
teach you how to make computer games using the
popular Python programming language—even if
you’ve never programmed before!
4TH
EDITION
DON’T JUST
PLAY GAMES—
MAKE THEM!
AL SWEIGART
invent your own computer games
with python
INVENT
YOUR OWN
COMPUTER GAMES
WITH PYTHON
4 th E d ition
b y Al S w e i g a r t
San Francisco
Invent Your Own Computer Games with Python, 4th edition.
Copyright © 2017 by Al Sweigart.
Some rights reserved. This work is licensed under the Creative Commons Attribution-NonCommercialShareAlike 3.0 United States License. To view a copy of this license, visit http://creativecommons.org/licenses/
by-nc-sa/3.0/us/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
Printed in USA
First printing
20 19 18 17 16
123456789
ISBN-10: 1-59327-795-4
ISBN-13: 978-1-59327-795-6
Publisher: William Pollock
Production Editor: Laurel Chun
Cover Illustration: Josh Ellingson
Interior Design: Octopod Studios
Developmental Editor: Jan Cash
Technical Reviewer: Ari Lacenski
Copyeditor: Rachel Monaghan
Compositor: Susan Glinert Stevens
Proofreader: Paula L. Fleming
Indexer: Nancy Guenther
The sprite images in Figure 20-1 on page 302, from left to right, were created by fsvieira, przemek.sz,
LordNeo, and Suppercut. The grass sprite image in Figure 20-2 on page 302 was created by txturs. These
images have been dedicated to the public domain with a CC0 1.0 Public Domain Dedication.
For information on distribution, translations, or bulk sales, please contact No Starch Press, Inc. directly:
No Starch Press, Inc.
245 8th Street, San Francisco, CA 94103
phone: 1.415.863.9900; info@nostarch.com
www.nostarch.com
Library of Congress Cataloging-in-Publication Data
Names: Sweigart, Al, author.
Title: Invent your own computer games with Python / by Al Sweigart.
Description: San Francisco : No Starch Press, Inc., [2017]
Identifiers: LCCN 2016037817 (print) | LCCN 2016044807 (ebook) | ISBN
9781593277956 | ISBN 1593277954 | ISBN 9781593278113 (epub) | ISBN
159327811X (epub) | ISBN 9781593278120 (mobi) | ISBN 1593278128 (mobi)
Subjects: LCSH: Computer games--Programming. | Python (Computer program
language)
Classification: LCC QA76.76.C672 S785 2017 (print) | LCC QA76.76.C672 (ebook)
| DDC 794.8/1526--dc23
LC record available at https://lccn.loc.gov/2016037817
No Starch Press and the No Starch Press logo are registered trademarks of No Starch Press, Inc. Other
product and company names mentioned herein may be the trademarks of their respective owners. Rather
than use a trademark symbol with every occurrence of a trademarked name, we are using the names only
in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The information in this book is distributed on an “As Is” basis, without warranty. While every precaution
has been taken in the preparation of this work, neither the author nor No Starch Press, Inc. shall have any
liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or
indirectly by the information contained in it.
To Caro
About the Author
Al Sweigart is a software developer, tech book author, and hoopy frood
who really knows where his towel is. He has written several programming
books for beginners, including Automate the Boring Stuff with Python and
Scratch Programming Playground, also from No Starch Press. His books are
freely available under a Creative Commons license at his website https://
inventwithpython.com/.
About the Technical Reviewer
Ari Lacenski is a developer of Android applications and Python software.
She lives in the Bay Area, where she writes about Android programming at
http://gradlewhy.ghost.io/ and mentors with Women Who Code.
Brief Contents
Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi
Chapter 1: The Interactive Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Chapter 2: Writing Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Chapter 3: Guess the Number . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Chapter 4: A Joke-Telling Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Chapter 5: Dragon Realm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Chapter 6: Using the Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Chapter 7: Designing Hangman with Flowcharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Chapter 8: Writing the Hangman Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Chapter 9: Extending Hangman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Chapter 10: Tic-Tac-Toe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Chapter 11: The Bagels Deduction Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Chapter 12: The Cartesian Coordinate System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Chapter 13: Sonar Treasure Hunt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Chapter 14: Caesar Cipher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Chapter 15: The Reversegam Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Chapter 16: Reversegam AI Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Chapter 17: Creating Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Chapter 18: Animating Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
Chapter 19: Collision Detection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Chapter 20: Using Sounds and Images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
Chapter 21: A Dodger Game with Sounds and Images . . . . . . . . . . . . . . . . . . . . . . . 311
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
viii Brief Contents
Conte nt s in De ta il
Acknowledgments
xix
Introduction
xxi
Who Is This Book For? . . . . . . . . . . . .
About This Book . . . . . . . . . . . . . . . . .
How to Use This Book . . . . . . . . . . . . .
Line Numbers and Indentation .
Long Code Lines . . . . . . . . . .
Downloading and Installing Python . . . .
Starting IDLE . . . . . . . . . . . . . . . . . . . .
Finding Help Online . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
xxii
xxiii
xxiv
xxiv
. xxv
. xxv
xxvi
xxvii
1
The Interactive Shell
Some Simple Math . . . . . . . . . . . . . . . . . . .
Integers and Floating-Point Numbers .
Expressions . . . . . . . . . . . . . . . . . .
Evaluating Expressions . . . . . . . . . . . . . . . . .
Syntax Errors . . . . . . . . . . . . . . . . . . . . . . .
Storing Values in Variables . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
Writing Programs
String Values . . . . . . . . . . . . . . . . . . . . . . . . . . .
String Concatenation . . . . . . . . . . . . . . . . . . . . . .
Writing Programs in IDLE’s File Editor . . . . . . . . . .
Creating the Hello World Program . . . . . .
Saving Your Program . . . . . . . . . . . . . . .
Running Your Program . . . . . . . . . . . . . .
How the Hello World Program Works . . . . . . . . . .
Comments for the Programmer . . . . . . . . .
Functions: Mini-Programs Inside Programs .
The End of the Program . . . . . . . . . . . . .
Naming Variables . . . . . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
2
2
3
3
4
5
8
11
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
Guess the Number
Sample Run of Guess the Number . . . . . . . . . . . . . . . . . . . . . . .
Source Code for Guess the Number . . . . . . . . . . . . . . . . . . . . .
Importing the random Module . . . . . . . . . . . . . . . . . . . . . . . . .
Generating Random Numbers with the random.randint() Function .
Welcoming the Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
13
13
14
15
16
17
17
18
19
20
20
21
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
22
22
23
24
26
Flow Control Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Using Loops to Repeat Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Grouping with Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Looping with for Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Getting the Player’s Guess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Converting Values with the int(), float(), and str() Functions . . . . . . . . . . . . . . . .
The Boolean Data Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Checking for True or False with Conditions . . . . . . . . . . . . . . . . . . . .
Experimenting with Booleans, Comparison Operators, and Conditions .
The Difference Between = and == . . . . . . . . . . . . . . . . . . . . . . . . . .
if Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Leaving Loops Early with the break Statement . . . . . . . . . . . . . . . . . . . . . . . . .
Checking Whether the Player Won . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Checking Whether the Player Lost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
A Joke-Telling Program
39
Sample Run of Jokes . . . . . . . . . . . . . . . . . .
Source Code for Jokes . . . . . . . . . . . . . . . . .
How the Code Works . . . . . . . . . . . . . . . . .
Escape Characters . . . . . . . . . . . . . . . . . . .
Single and Double Quotes . . . . . . . . . . . . . .
The print() Function’s end Keyword Parameter .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
Dragon Realm
How to Play Dragon Realm . . . . . . . . . . .
Sample Run of Dragon Realm . . . . . . . . . .
Flowchart for Dragon Realm . . . . . . . . . . .
Source Code for Dragon Realm . . . . . . . .
Importing the random and time Modules . .
Functions in Dragon Realm . . . . . . . . . . . .
def Statements . . . . . . . . . . . . . .
Calling a Function . . . . . . . . . . .
Where to Put Function Definitions .
Multiline Strings . . . . . . . . . . . . . . . . . . .
How to Loop with while Statements . . . . . .
Boolean Operators . . . . . . . . . . . . . . . . .
The and Operator . . . . . . . . . . .
The or Operator . . . . . . . . . . . . .
The not Operator . . . . . . . . . . . .
Evaluating Boolean Operators . . .
Return Values . . . . . . . . . . . . . . . . . . . . .
Global Scope and Local Scope . . . . . . . . .
Function Parameters . . . . . . . . . . . . . . . .
x Contents in Detail
26
26
27
28
29
29
31
32
32
33
34
34
35
35
35
36
40
40
41
41
42
43
44
45
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
45
46
46
47
48
49
49
49
50
50
51
52
52
53
53
54
55
56
57
Displaying the Game Results . . . . . . . . . . . . . .
Deciding Which Cave Has the Friendly Dragon .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . .
Calling the Functions in the Program . . .
Asking the Player to Play Again . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
Using the Debugger
63
Types of Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
The Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Starting the Debugger . . . . . . . . . . . . . . . . . . . . .
Stepping Through the Program with the Debugger .
Finding the Bug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Setting Breakpoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Using Breakpoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
Designing Hangman with Flowcharts
How to Play Hangman . . . . . . . . . . . . . . .
Sample Run of Hangman . . . . . . . . . . . . .
ASCII Art . . . . . . . . . . . . . . . . . . . . . . . .
Designing a Program with a Flowchart . . .
Creating the Flowchart . . . . . . . .
Branching from a Flowchart Box .
Ending or Restarting the Game . .
Guessing Again . . . . . . . . . . . . .
Offering Feedback to the Player . .
Summary . . . . . . . . . . . . . . . . . . . . . . . .
58
59
60
60
61
61
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
64
65
65
67
70
73
73
75
77
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Source Code for Hangman . . . . . . . . . . . . . . . .
Importing the random Module . . . . . . . . . . . . . .
Constant Variables . . . . . . . . . . . . . . . . . . . . . .
The Lists Data Type . . . . . . . . . . . . . . . . . . . . . .
Accessing Items with Indexes . . . . . . . . .
List Concatenation . . . . . . . . . . . . . . . .
The in Operator . . . . . . . . . . . . . . . . . .
Calling Methods . . . . . . . . . . . . . . . . . . . . . . . .
The reverse() and append() List Methods .
The split() String Method . . . . . . . . . . . .
Getting a Secret Word from the Word List . . . . . .
Displaying the Board to the Player . . . . . . . . . . . .
The list() and range() Functions . . . . . . . .
List and String Slicing . . . . . . . . . . . . . .
Displaying the Secret Word with Blanks .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
Writing the Hangman Code
78
78
79
80
81
81
83
83
85
86
87
88
91
91
92
92
94
94
94
95
95
96
97
98
98
99
Contents in Detail xi
Getting the Player’s Guess . . . . . . . . . . . . . . . . . . . . . . . .
The lower() and upper() String Methods . . . . . . . .
Leaving the while Loop . . . . . . . . . . . . . . . . . . . .
elif Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Making Sure the Player Entered a Valid Guess . . . . . . . . . .
Asking the Player to Play Again . . . . . . . . . . . . . . . . . . . .
Review of the Hangman Functions . . . . . . . . . . . . . . . . . . .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Calling the displayBoard() Function . . . . . . . . . . .
Letting the Player Enter Their Guess . . . . . . . . . . .
Checking Whether the Letter Is in the Secret Word .
Checking Whether the Player Won . . . . . . . . . . .
Handling an Incorrect Guess . . . . . . . . . . . . . . . .
Checking Whether the Player Lost . . . . . . . . . . . .
Ending or Resetting the Game . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
Extending Hangman
111
Adding More Guesses . . . . . . . . . . . . . . . . . . . . . . . .
The Dictionary Data Type . . . . . . . . . . . . . . . . . . . . . .
Getting the Size of Dictionaries with len() . . . .
The Difference Between Dictionaries and Lists .
The keys() and values() Dictionary Methods . . .
Using Dictionaries of Words in Hangman . . . .
Randomly Choosing from a List . . . . . . . . . . . . . . . . . .
Deleting Items from Lists . . . . . . . . . . . . . . . . . . . . . . .
Multiple Assignment . . . . . . . . . . . . . . . . . . . . . . . . .
Printing the Word Category for the Player . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
Tic-Tac-Toe
Sample Run of Tic-Tac-Toe . . . . . . . . . . . . . . . . .
Source Code for Tic-Tac-Toe . . . . . . . . . . . . . . . .
Designing the Program . . . . . . . . . . . . . . . . . . .
Representing the Board as Data . . . . . . .
Strategizing with the Game AI . . . . . . . .
Importing the random Module . . . . . . . . . . . . . .
Printing the Board on the Screen . . . . . . . . . . . . .
Letting the Player Choose X or O . . . . . . . . . . . . .
Deciding Who Goes First . . . . . . . . . . . . . . . . . .
Placing a Mark on the Board . . . . . . . . . . . . . . .
List References . . . . . . . . . . . . . . . . . . .
Using List References in makeMove() . . .
Checking Whether the Player Won . . . . . . . . . . .
Duplicating the Board Data . . . . . . . . . . . . . . . .
Checking Whether a Space on the Board Is Free .
Letting the Player Enter a Move . . . . . . . . . . . . . .
xii Contents in Detail
101
101
103
103
104
104
105
105
106
106
106
107
107
108
108
109
112
112
113
113
114
115
115
117
118
119
120
121
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
122
123
127
127
128
129
129
130
131
131
132
135
135
137
138
138
Short-Circuit Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Choosing a Move from a List of Moves . . . . . . . . . . . . . . . . . . . . . . . .
The None Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Creating the Computer’s AI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Checking Whether the Computer Can Win in One Move . . . . .
Checking Whether the Player Can Win in One Move . . . . . . . .
Checking the Corner, Center, and Side Spaces (in That Order) .
Checking Whether the Board Is Full . . . . . . . . . . . . . . . . . . . .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Choosing the Player’s Mark and Who Goes First . . . . . . . . . . .
Running the Player’s Turn . . . . . . . . . . . . . . . . . . . . . . . . . . .
Running the Computer’s Turn . . . . . . . . . . . . . . . . . . . . . . . . .
Asking the Player to Play Again . . . . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11
The Bagels Deduction Game
149
Sample Run of Bagels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Source Code for Bagels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Flowchart for Bagels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Importing random and Defining getSecretNum() . . . . . . . . . . . . . . . .
Shuffling a Unique Set of Digits . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Changing List Item Order with the random.shuffle() Function .
Getting the Secret Number from the Shuffled Digits . . . . . . .
Augmented Assignment Operators . . . . . . . . . . . . . . . . . . . . . . . . .
Calculating the Clues to Give . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
The sort() List Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
The join() String Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Checking Whether a String Has Only Numbers . . . . . . . . . . . . . . . .
Starting the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
String Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Getting the Player’s Guess . . . . . . . . . . . . . . . . . . . . . . . . .
Getting the Clues for the Player’s Guess . . . . . . . . . . . . . . .
Checking Whether the Player Won or Lost . . . . . . . . . . . . .
Asking the Player to Play Again . . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
The Cartesian Coordinate System
Grids and Cartesian Coordinates . . . . . . . . . . . . . . . . . . . . . .
Negative Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
The Coordinate System of a Computer Screen . . . . . . . . . . . . .
Math Tricks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Trick 1: A Minus Eats the Plus Sign on Its Left . . . . . . . .
Trick 2: Two Minuses Combine into a Plus . . . . . . . . . .
Trick 3: Two Numbers Being Added Can Swap Places .
Absolute Values and the abs() Function . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
139
141
142
142
143
144
144
145
145
146
146
147
148
148
150
151
152
153
154
154
154
155
156
157
158
158
159
159
160
161
161
161
162
162
163
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
164
166
167
168
168
169
169
170
170
Contents in Detail xiii
13
Sonar Treasure Hunt
171
Sample Run of Sonar Treasure Hunt . . . . . . . . . . . . . . . . . . . . . . .
Source Code for Sonar Treasure Hunt . . . . . . . . . . . . . . . . . . . . . .
Designing the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Importing the random, sys, and math Modules . . . . . . . . . . . . . . . .
Creating a New Game Board . . . . . . . . . . . . . . . . . . . . . . . . . . .
Drawing the Game Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Drawing the X-Coordinates Along the Top of the Board . . .
Drawing the Ocean . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Printing a Row in the Ocean . . . . . . . . . . . . . . . . . . . . . .
Drawing the X-Coordinates Along the Bottom of the Board .
Creating the Random Treasure Chests . . . . . . . . . . . . . . . . . . . . . .
Determining Whether a Move Is Valid . . . . . . . . . . . . . . . . . . . . . .
Placing a Move on the Board . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Finding the Closest Treasure Chest . . . . . . . . . . . . . . . . . .
Removing Values with the remove() List Method . . . . . . . . .
Getting the Player’s Move . . . . . . . . . . . . . . . . . . . . . . . .
Printing the Game Instructions for the Player . . . . . . . . . . . . . . . . . .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Displaying the Game Status for the Player . . . . . . . . . . . . .
Handling the Player’s Move . . . . . . . . . . . . . . . . . . . . . . .
Finding a Sunken Treasure Chest . . . . . . . . . . . . . . . . . . .
Checking Whether the Player Won . . . . . . . . . . . . . . . . .
Checking Whether the Player Lost . . . . . . . . . . . . . . . . . .
Terminating the Program with the sys.exit() Function . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
14
Caesar Cipher
Cryptography and Encryption . . . . . . . . . . . . . . . . . . . . . . .
How the Caesar Cipher Works . . . . . . . . . . . . . . . . . . . . . .
Sample Run of Caesar Cipher . . . . . . . . . . . . . . . . . . . . . .
Source Code for Caesar Cipher . . . . . . . . . . . . . . . . . . . . .
Setting the Maximum Key Length . . . . . . . . . . . . . . . . . . . . .
Deciding to Encrypt or Decrypt the Message . . . . . . . . . . . .
Getting the Message from the Player . . . . . . . . . . . . . . . . . .
Getting the Key from the Player . . . . . . . . . . . . . . . . . . . . . .
Encrypting or Decrypting the Message . . . . . . . . . . . . . . . . .
Finding Passed Strings with the find() String Method .
Encrypting or Decrypting Each Letter . . . . . . . . . . .
Starting the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
The Brute-Force Technique . . . . . . . . . . . . . . . . . . . . . . . . .
Adding the Brute-Force Mode . . . . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
The Reversegam Game
173
175
180
180
180
181
182
183
184
184
184
185
185
186
189
190
191
192
193
193
194
194
195
195
196
197
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
198
199
200
201
202
202
203
203
203
204
205
206
206
207
208
209
How to Play Reversegam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Sample Run of Reversegam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
xiv Contents in Detail
Source Code for Reversegam . . . . . . . . . . . . . . . . . . . . . .
Importing Modules and Setting Up Constants . . . . . . . . . . .
The Game Board Data Structure . . . . . . . . . . . . . . . . . . . .
Drawing the Board Data Structure on the Screen . .
Creating a Fresh Board Data Structure . . . . . . . . .
Checking Whether a Move Is Valid . . . . . . . . . . . . . . . . . .
Checking Each of the Eight Directions . . . . . . . . . .
Finding Out Whether There Are Tiles to Flip Over .
Checking for Valid Coordinates . . . . . . . . . . . . . . . . . . . .
Getting a List with All Valid Moves . . . . . . . . . . . .
Calling the bool() Function . . . . . . . . . . . . . . . . .
Getting the Score of the Game Board . . . . . . . . . . . . . . . .
Getting the Player’s Tile Choice . . . . . . . . . . . . . . . . . . . .
Determining Who Goes First . . . . . . . . . . . . . . . . . . . . . .
Placing a Tile on the Board . . . . . . . . . . . . . . . . . . . . . . .
Copying the Board Data Structure . . . . . . . . . . . . . . . . . . .
Determining Whether a Space Is on a Corner . . . . . . . . . .
Getting the Player’s Move . . . . . . . . . . . . . . . . . . . . . . . .
Getting the Computer’s Move . . . . . . . . . . . . . . . . . . . . . .
Strategizing with Corner Moves . . . . . . . . . . . . . .
Getting a List of the Highest-Scoring Moves . . . . . .
Printing the Scores to the Screen . . . . . . . . . . . . . . . . . . . .
Starting the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Checking for a Stalemate . . . . . . . . . . . . . . . . . .
Running the Player’s Turn . . . . . . . . . . . . . . . . . .
Running the Computer’s Turn . . . . . . . . . . . . . . . .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Asking the Player to Play Again . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
16
Reversegam AI Simulation
Making the Computer Play Against Itself . . . . . . . . . . . . . . . . . . . . . .
Sample Run of Simulation 1 . . . . . . . . . . . . . . . . . . . . . . . . .
Source Code for Simulation 1 . . . . . . . . . . . . . . . . . . . . . . .
Removing the Player Prompts and Adding a Computer Player .
Making the Computer Play Itself Several Times . . . . . . . . . . . . . . . . . .
Sample Run of Simulation 2 . . . . . . . . . . . . . . . . . . . . . . . . .
Source Code for Simulation 2 . . . . . . . . . . . . . . . . . . . . . . .
Keeping Track of Multiple Games . . . . . . . . . . . . . . . . . . . .
Commenting Out print() Function Calls . . . . . . . . . . . . . . . . .
Using Percentages to Grade the AIs . . . . . . . . . . . . . . . . . . .
Comparing Different AI Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . .
Source Code for Simulation 3 . . . . . . . . . . . . . . . . . . . . . . .
How the AIs Work in Simulation 3 . . . . . . . . . . . . . . . . . . . .
Comparing the AIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
215
220
220
221
222
222
223
224
225
226
227
227
228
228
229
229
230
230
232
232
233
234
234
234
235
236
237
238
238
239
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
240
240
241
242
243
243
244
245
245
246
247
248
249
252
254
Contents in Detail xv
17
Creating Graphics
Installing pygame . . . . . . . . . . . . . . . . . . . . . . . . . .
Hello World in pygame . . . . . . . . . . . . . . . . . . . . . .
Sample Run of pygame Hello World . . . . . . . . . . . . .
Source Code for pygame Hello World . . . . . . . . . . . .
Importing the pygame Module . . . . . . . . . . . . . . . . .
Initializing pygame . . . . . . . . . . . . . . . . . . . . . . . . .
Setting Up the pygame Window . . . . . . . . . . . . . . . .
Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Surface Objects . . . . . . . . . . . . . . . . . . . . .
Setting Up Color Variables . . . . . . . . . . . . . . . . . . . .
Writing Text on the pygame Window . . . . . . . . . . . .
Using Fonts to Style Text . . . . . . . . . . . . . . .
Rendering a Font Object . . . . . . . . . . . . . . .
Setting the Text Location with Rect Attributes .
Filling a Surface Object with a Color . . . . . . . . . . . . .
pygame’s Drawing Functions . . . . . . . . . . . . . . . . . .
Drawing a Polygon . . . . . . . . . . . . . . . . . .
Drawing a Line . . . . . . . . . . . . . . . . . . . . .
Drawing a Circle . . . . . . . . . . . . . . . . . . . .
Drawing an Ellipse . . . . . . . . . . . . . . . . . . .
Drawing a Rectangle . . . . . . . . . . . . . . . . .
Coloring Pixels . . . . . . . . . . . . . . . . . . . . .
The blit() Method for Surface Objects . . . . . . . . . . . .
Drawing the Surface Object to the Screen . . . . . . . . .
Events and the Game Loop . . . . . . . . . . . . . . . . . . . .
Getting Event Objects . . . . . . . . . . . . . . . . .
Exiting the Program . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
255
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
18
Animating Graphics
Sample Run of the Animation Program . . . . . . . . . . . . . . . . . . . . . .
Source Code for the Animation Program . . . . . . . . . . . . . . . . . . . .
Moving and Bouncing the Boxes . . . . . . . . . . . . . . . . . . . . . . . . . .
Setting Up the Constant Variables . . . . . . . . . . . . . . . . . . . . . . . . .
Constant Variables for Direction . . . . . . . . . . . . . . . . . . . .
Constant Variables for Color . . . . . . . . . . . . . . . . . . . . . .
Setting Up the Box Data Structures . . . . . . . . . . . . . . . . . . . . . . . .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Handling When the Player Quits . . . . . . . . . . . . . . . . . . .
Moving Each Box . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Bouncing a Box . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Drawing the Boxes on the Window in Their New Positions .
Drawing the Window on the Screen . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
xvi Contents in Detail
256
256
257
257
259
259
260
260
261
261
262
262
263
264
266
266
266
267
268
268
268
269
270
270
270
271
271
272
273
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
274
274
276
277
277
278
278
279
279
280
281
282
282
283
19
Collision Detection
285
Sample Run of the Collision Detection Program . . .
Source Code for the Collision Detection Program .
Importing the Modules . . . . . . . . . . . . . . . . . . . .
Using a Clock to Pace the Program . . . . . . . . . . .
Setting Up the Window and Data Structures . . . . .
Setting Up Variables to Track Movement . . . . . . .
Handling Events . . . . . . . . . . . . . . . . . . . . . . . .
Handling the KEYDOWN Event . . . . . . .
Handling the KEYUP Event . . . . . . . . . .
Teleporting the Player . . . . . . . . . . . . . . . . . . . .
Adding New Food Squares . . . . . . . . . . . . . . . .
Moving the Player Around the Window . . . . . . . .
Drawing the Player on the Window . . . .
Checking for Collisions . . . . . . . . . . . . .
Drawing the Food Squares on the Window . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
20
Using Sounds and Images
301
Adding Images with Sprites . . . . . . . . . . . . . . . .
Sound and Image Files . . . . . . . . . . . . . . . . . . .
Sample Run of the Sprites and Sounds Program . .
Source Code for the Sprites and Sounds Program .
Setting Up the Window and the Data Structure . . .
Adding a Sprite . . . . . . . . . . . . . . . . . .
Changing the Size of a Sprite . . . . . . . .
Setting Up the Music and Sounds . . . . . . . . . . . .
Adding Sound Files . . . . . . . . . . . . . . .
Toggling the Sound On and Off . . . . . . .
Drawing the Player on the Window . . . . . . . . . . .
Checking for Collisions . . . . . . . . . . . . . . . . . . .
Drawing the Cherries on the Window . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
A Dodger Game with Sounds and Images
Review of the Basic pygame Data Types . . . .
Sample Run of Dodger . . . . . . . . . . . . . . . . .
Source Code for Dodger . . . . . . . . . . . . . . .
Importing the Modules . . . . . . . . . . . . . . . . .
Setting Up the Constant Variables . . . . . . . . .
Defining Functions . . . . . . . . . . . . . . . . . . . .
Ending and Pausing the Game . . . .
Keeping Track of Baddie Collisions .
Drawing Text to the Window . . . . . .
286
287
289
289
290
291
292
293
294
295
295
296
297
297
298
299
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
302
302
303
304
306
307
307
307
308
308
309
309
310
310
311
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
312
313
313
317
318
319
319
320
320
Contents in Detail xvii
Initializing pygame and Setting Up the Window . . . . .
Setting Up Font, Sound, and Image Objects . . . . . . . .
Displaying the Start Screen . . . . . . . . . . . . . . . . . . . .
Starting the Game . . . . . . . . . . . . . . . . . . . . . . . . .
The Game Loop . . . . . . . . . . . . . . . . . . . . . . . . . . .
Handling Keyboard Events . . . . . . . . . . . . .
Handling Mouse Movement . . . . . . . . . . . . .
Adding New Baddies . . . . . . . . . . . . . . . . . . . . . . .
Moving the Player’s Character and the Baddies . . . . .
Implementing the Cheat Codes . . . . . . . . . . . . . . . . .
Removing the Baddies . . . . . . . . . . . . . . . . . . . . . . .
Drawing the Window . . . . . . . . . . . . . . . . . . . . . . .
Drawing the Player’s Score . . . . . . . . . . . . .
Drawing the Player’s Character and Baddies .
Checking for Collisions . . . . . . . . . . . . . . . . . . . . . .
The Game Over Screen . . . . . . . . . . . . . . . . . . . . . .
Modifying the Dodger Game . . . . . . . . . . . . . . . . . .
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Index
xviii Contents in Detail
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
321
322
323
324
325
325
327
327
328
329
330
330
331
331
332
332
333
334
335
Acknowledgments
This book would not have been possible without the exceptional work of the
No Starch Press team. Thanks to my publisher, Bill Pollock; thanks to my
editors, Laurel Chun, Jan Cash, and Tyler Ortman, for their incredible help
throughout the process; thanks to my technical editor Ari Lacenski for her
thorough review; and thanks to Josh Ellingson for yet another great cover.
Introduction
When I first played video games as a kid,
I was hooked. But I didn’t just want to
play video games, I wanted to make them.
I found a book like this one that taught me
how to write my first programs and games. It was fun
and easy. The first games I made were like the ones
in this book. They weren’t as fancy as the Nintendo
games my parents bought for me, but they were games
I had made myself.
Now, as an adult, I still have fun programming and I get paid for it. But
even if you don’t want to become a computer programmer, programming
is a useful and fun skill to have. It trains your brain to think logically, make
plans, and reconsider your ideas whenever you find mistakes in your code.
Many programming books for beginners fall into two categories. The
first category includes books that don’t teach programming so much as
“game creation software” or languages that simplify so much that what is
taught is no longer programming. The other category consists of books
that teach programming like a mathematics textbook—all principles and
concepts, with few real-life applications for the reader. This book takes
a different approach and teaches you how to program by making video
games. I show the source code for the games right up front and explain
programming principles from the examples. This approach was the key
for me when I was learning to program. The more I learned how other
people’s programs worked, the more ideas I had for my own programs.
All you’ll need is a computer, some free software called the Python
interpreter, and this book. Once you learn how to create the games in this
book, you’ll be able to develop games on your own.
Computers are incredible machines, and learning to program them
isn’t as hard as people think. A computer program is a bunch of instructions
that the computer can understand, just like a storybook is a bunch of sentences that the reader can understand. To instruct a computer, you write a
program in a language the computer understands. This book will teach you
a programming language called Python. There are many other programming languages you can learn, like BASIC, Java, JavaScript, PHP, and C++.
When I was a kid, I learned BASIC, but newer programming languages
like Python are even easier to learn. Python is also used by professional programmers in their work and when programming for fun. Plus it’s totally free
to install and use—you’ll just need an internet connection to download it.
Because video games are nothing but computer programs, they are
also made up of instructions. The games you’ll create from this book seem
simple compared to the games for Xbox, PlayStation, or Nintendo. These
games don’t have fancy graphics because they’re meant to teach you coding
basics. They’re purposely simple so you can focus on learning to program.
Games don’t have to be complicated to be fun!
Who Is This Book For?
Programming isn’t hard, but it is hard to find materials that teach you to
do interesting things with programming. Other computer books go over
many topics most new coders don’t need. This book will teach you how to
program your own games; you’ll learn a useful skill and have fun games to
show for it! This book is for:
•
•
•
•
xxii Introduction
Complete beginners who want to teach themselves programming, even
if they have no previous experience.
Kids and teenagers who want to learn programming by creating games.
Adults and teachers who wish to teach others programming.
Anyone, young or old, who wants to learn how to program by learning a
professional programming language.
About This Book
In most of the chapters in this book, a single new game project is introduced and explained. A few of the chapters cover additional useful topics,
like debugging. New programming concepts are explained as games make
use of them, and the chapters are meant to be read in order. Here’s a brief
rundown of what you’ll find in each chapter:
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Chapter 1: The Interactive Shell explains how Python’s interactive shell
can be used to experiment with code one line at a time.
Chapter 2: Writing Programs covers how to write complete programs
in Python’s file editor.
In Chapter 3: Guess the Number, you’ll program the first game in the
book, Guess the Number, which asks the player to guess a secret number
and then provides hints as to whether the guess is too high or too low.
In Chapter 4: A Joke-Telling Program, you’ll write a simple program
that tells the user several jokes.
In Chapter 5: Dragon Realm, you’ll program a guessing game in which
the player must choose between two caves: one has a friendly dragon,
and the other has a hungry dragon.
Chapter 6: Using the Debugger covers how to use the debugger to fix
problems in your code.
Chapter 7: Designing Hangman with Flowcharts explains how flowcharts can be used to plan longer programs, such as the Hangman game.
In Chapter 8: Writing the Hangman Code, you’ll write the Hangman
game, following the flowchart from Chapter 7.
Chapter 9: Extending Hangman extends the Hangman game with new
features by making use of Python’s dictionary data type.
In Chapter 10: Tic-Tac-Toe, you’ll learn how to write a human-versuscomputer Tic-Tac-Toe game that uses artificial intelligence.
In Chapter 11: The Bagels Deduction Game, you’ll learn how to make
a deduction game called Bagels in which the player must guess secret
numbers based on clues.
Chapter 12: The Cartesian Coordinate System explains the Cartesian
coordinate system, which you’ll use in later games.
In Chapter 13: Sonar Treasure Hunt, you’ll learn how to write a treasure
hunting game in which the player searches the ocean for lost treasure
chests.
In Chapter 14: Caesar Cipher, you’ll create a simple encryption program that lets you write and decode secret messages.
In Chapter 15: The Reversegam Game, you’ll program an advanced
human-versus-computer Reversi-type game that has a nearly unbeatable
artificial intelligence opponent.
Introduction xxiii
•
•
•
•
•
•
Chapter 16: Reversegam AI Simulation expands on the Reversegam
game in Chapter 15 to make multiple AIs that compete in computerversus-computer games.
Chapter 17: Creating Graphics introduces Python’s pygame module and
shows you how to use it to draw 2D graphics.
Chapter 18: Animating Graphics shows you how to animate graphics
with pygame.
In Chapter 19: Collision Detection, you’ll learn how to detect when
objects collide with each other in 2D games.
In Chapter 20: Using Sounds and Images, you’ll improve your simple
pygame games by adding sounds and images.
Chapter 21: A Dodger Game with Sounds and Images combines
the concepts in Chapters 17 to 20 to make an animated game called
Dodger.
How to Use This Book
Most chapters in this book will begin with a sample run of the chapter’s
featured program. This sample run shows you what the program looks like
when you run it. The parts the user types are shown in bold.
I recommend that you enter the code for each program into IDLE’s file
editor yourself rather than downloading or copying and pasting it. You’ll
remember more if you take the time to type the code.
Line Numbers and Indentation
When typing the source code from this book, do not type the line numbers
at the start of each line. For example, if you saw the following line of code,
you would not need to type the 9. on the left side, or the one space immediately following it:
9. number = random.randint(1, 20)
You’d enter only this:
number = random.randint(1, 20)
Those numbers are there just so this book can refer to specific lines in
the program. They are not part of the actual program’s source code.
Aside from the line numbers, enter the code exactly as it appears in this
book. Notice that some of the lines of code are indented by four or eight (or
more) spaces. The spaces at the beginning of the line change how Python
interprets instructions, so they are very important to include.
Let’s look at an example. The indented spaces here are marked with
black circles (•) so you can see them.
xxiv Introduction
while guesses < 10:
••••if number == 42:
••••••••print('Hello')
The first line is not indented, the second line is indented four spaces,
and the third line is indented eight spaces. Although the examples in this
book don’t have black circles to mark the spaces, each character in IDLE
is the same width, so you can count the number of spaces by counting the
number of characters on the line above or below.
Long Code Lines
Some code instructions are too long to fit on one line in the book and will
wrap around to the next line. But the line will fit on your computer screen,
so type it all on one line without pressing enter. You can tell when a new
instruction starts by looking at the line numbers on the left. This example
has only two instructions:
1. print('This is the first instruction!xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxx')
2. print('This is the second instruction, not the third instruction.')
The first instruction wraps around to a second line on the page, but the
second line does not have a line number, so you can see that it’s still line 1
of the code.
Downloading and Installing Python
You’ll need to install software called the Python interpreter. The interpreter
program understands the instructions you write in Python. I’ll refer to the
Python interpreter software as just Python from now on.
In this section, I’ll show you how to download and install Python 3—specifically, Python 3.4—for Windows, OS X, or Ubuntu. There are newer versions of Python than 3.4, but the pygame module, which is used in Chapters 17
to 21, currently only supports up to 3.4.
It’s important to know that there are some
significant differences between Python 2
Make sure you’re
and Python 3. The programs in this book use
using Python 3,
Python 3, and you’ll get errors if you try to
not Python 2!
run them with Python 2. This is so important,
in fact, that I’ve added a cartoon penguin to
remind you about it.
On Windows, download the Windows
x86-64 MSI installer from https://www.python
.org/downloads/release/python-344/ and then
double-click it. You may have to enter the
administrator password for your computer.
Introduction xxv
Follow the instructions the installer displays on the screen to install Python,
as listed here:
1.
2.
3.
Select Install for All Users and then click Next.
Install to the C:\Python34 folder by clicking Next.
Click Next to skip the Customize Python section.
On OS X, download the Mac OS X 64-bit/32-bit installer from https://
www.python.org/downloads/release/python-344/ and then double-click it. Follow
the instructions the installer displays on the screen to install Python, as
listed here:
1.
2.
3.
If you get the warning “‘Python.mpkg’ can’t be opened because it is from
an unidentified developer,” hold down control while right-clicking the
Python.mpkg file and then select Open from the menu that appears. You
may have to enter the administrator password for your computer.
Click Continue through the Welcome section and click Agree to accept
the license.
Select Macintosh HD (or whatever your hard drive is named) and click
Install.
If you’re running Ubuntu, you can install Python from the Ubuntu
Software Center by following these steps:
1.
2.
3.
4.
Open the Ubuntu Software Center.
Enter Python in the search box in the top-right corner of the window.
Select IDLE (Python 3.4 GUI 64 bit).
Click Install. You may have to enter the administrator password to complete the installation.
If the above steps do not work, you can find alternative Python 3.4
install instructions at https://www.nostarch.com/inventwithpython/.
Starting IDLE
IDLE stands for Interactive DeveLopment Environment. IDLE is like a word
processor for writing Python programs. Starting IDLE is different on each
operating system:
•
•
•
xxvi Introduction
On Windows, click the Start menu in the lower-left corner of the
screen, type IDLE, and select IDLE (Python GUI).
On OS X, open Finder and click Applications. Double-click Python 3.x
and then double-click the IDLE icon.
On Ubuntu or other Linux distros, open a terminal window and enter
idle3. You may also be able to click Applications at the top of the screen.
Then click Programming and IDLE 3.
The window that appears when you first run IDLE is the interactive
shell, as shown in Figure 1. You can enter Python instructions into the
interactive shell at the >>> prompt and Python will perform them. After
the computer performs the instructions, a new >>> prompt will wait for
your next instruction.
Figure 1: The IDLE program’s interactive shell
Finding Help Online
You can find the source code files and other resources for this book at https://
www.nostarch.com/inventwithpython/. If you want to ask programming questions related to this book, visit https://reddit.com/r/inventwithpython/, or you can
email your programming questions to me at al@inventwithpython.com.
Before you ask any questions, make sure you do the following:
•
•
If you are typing out a program in this book but are getting an error,
check for typos with the online diff tool at https://www.nostarch.com/
inventwithpython#diff before asking your question. Copy and paste your
code into the diff tool to find any differences between the book’s code
and yours.
Search the web to see whether someone else has already asked (and
answered) your question.
Introduction xxvii
Keep in mind that the better you phrase your programming questions,
the better others will be able to help you. When asking programming questions, do the following:
•
•
•
•
•
Explain what you are trying to do when you get the error. This will let
your helper know if you are on the wrong path entirely.
Copy and paste the entire error message and your code.
Provide your operating system and version.
Explain what you’ve already tried to do to solve your problem. This tells
people you’ve already put in some work to try to figure things out on
your own.
Be polite. Don’t demand help or pressure your helpers to respond
quickly.
Now that you know how to ask for help, you’ll be learning to program
your own computer games in no time!
xxviii Introduction
1
T h e I n t e r a c ti v e S h e l l
Before you can make games, you need to
learn a few basic programming concepts.
You’ll start in this chapter by learning how
to use Python’s interactive shell and perform
basic arithmetic.
Topics Cov e re d in This Ch a p te r
•
Operators
•
Integers and floating-point numbers
•
Values
•
Expressions
•
Syntax errors
•
Storing values in variables
Some Simple Math
Start IDLE by following the steps in “Starting IDLE” on page xxvi. First
you’ll use Python to solve some simple math problems. The interactive
shell can work just like a calculator. Type 2 + 2 into the interactive shell at
the >>> prompt and press enter. (On some keyboards, this key is return.)
Figure 1-1 shows how this math problem looks in the interactive shell—
notice that it responds with the number 4.
Figure 1-1: Entering 2 + 2 into the interactive shell
This math problem is a simple programming instruction. The plus
sign (+) tells the computer to add the numbers 2 and 2. The computer does
this and responds with the number 4 on the next line. Table 1-1 lists the
other math symbols available in Python.
Table 1-1: Math Operators
Operator
Operation
+
Addition
-
Subtraction
*
Multiplication
/
Division
The minus sign (-) subtracts numbers, the asterisk (*) multiplies numbers, and the slash (/) divides numbers. When used in this way, +, -, *, and /
are called operators. Operators tell Python what to do with the numbers surrounding them.
Integers and Floating-Point Numbers
Integers (or ints for short) are whole numbers such as 4, 99, and 0. Floatingpoint numbers (or floats for short) are fractions or numbers with decimal
points like 3.5, 42.1, and 5.0. In Python, 5 is an integer, but 5.0 is a float.
2 Chapter 1
These numbers are called values. (Later we will learn about other kinds
of values besides numbers.) In the math problem you entered in the shell,
2 and 2 are integer values.
Expressions
The math problem 2 + 2 is an example of
an expression. As Figure 1-2 shows, expressions are made up of values (the numbers)
connected by operators (the math signs)
that produce a new value the code can use.
Computers can solve millions of expressions
in seconds.
Try entering some of these expressions
into the interactive shell, pressing enter
after each one:
>>>
10
>>>
48
>>>
11
>>>
4
Operator
Value
2 + 2
Value
Expression
Figure 1-2: An expression
is made up of values and
operators.
2+2+2+2+2
8*6
10-5+6
2
+
2
These expressions all look like regular math equations, but notice all
the spaces in the 2 +
2 example. In Python, you can add any number
of spaces between values and operators. However, you must always start
instructions at the beginning of the line (with no spaces) when entering
them into the interactive shell.
Evaluating Expressions
When a computer solves the expression 10 + 5 and returns the value 15, it
has evaluated the expression. Evaluating an expression reduces the expression
to a single value, just like solving a math problem reduces the problem to a
single number: the answer. For example, the expressions 10 + 5 and 10 + 3 + 2
both evaluate to 15.
When Python evaluates an expression, it follows an order of operations
just like you do when you do math. There are just a few rules:
•
•
•
Parts of the expression inside parentheses are evaluated first.
Multiplication and division are done before addition and subtraction.
The evaluation is performed left to right.
The Interactive Shell 3
The expression 1 + 2 * 3 + 4 evaluates to 11, not 13, because 2 * 3 is
evaluated first. If the expression were (1 + 2) * (3 + 4) it would evaluate to
21, because the (1 + 2) and (3 + 4) inside parentheses are evaluated before
multiplication.
Expressions can be of any size, but they will always evaluate to a single
value. Even single values are expressions. For example, the expression 15
evaluates to the value 15. The expression 8 * 3 / 2 + 2 + 7 - 9 will evaluate
to the value 12.0 through the following steps:
8 * 3 / 2 + 2 + 7 - 9
24 / 2 + 2 + 7 - 9
12.0 + 2 + 7 - 9
14.0 + 7 - 9
21.0 - 9
12.0
Even though the computer is performing all of these steps, you don’t
see them in the interactive shell. The interactive shell shows you just the
result:
>>> 8 * 3 / 2 + 2 + 7 - 9
12.0
Notice that expressions with the / division operator always evaluate to
a float; for example, 24 / 2 evaluates to 12.0. Math operations with even one
float value also evaluate to float values, so 12.0 + 2 evaluates to 14.0.
Syntax Errors
If you enter 5 + into the interactive shell, you’ll get the following error
message:
>>> 5 +
SyntaxError: invalid syntax
This error happened because 5 + isn’t an expression. Expressions have
values connected by operators, and the + operator expects a value before
and after it. An error message appears when an expected value is missing.
SyntaxError means Python doesn’t understand the instruction because
you typed it incorrectly. Computer programming isn’t just about giving
the computer instructions to follow but also knowing how to give it those
instructions correctly.
4 Chapter 1
Don’t worry about making mistakes, though. Errors won’t damage your
computer. Just retype the instruction correctly into the interactive shell at
the next >>> prompt.
Storing Values in Variables
When an expression evaluates to a value, you can use that value later by
storing it in a variable. Think of a variable as a box that can hold a value.
An assignment statement will store a value inside a variable. Type a name
for the variable, followed by the equal sign (=), which is called the assignment operator, and then the value to store in the variable. For example, enter
the following into the interactive shell:
>>> spam = 15
>>>
The spam variable’s box now stores the value 15, as shown in Figure 1-3.
15
spam
Figure 1-3: Variables are like
boxes that can hold values.
When you press enter, you won’t see anything in response. In Python,
you know the instruction was successful if no error message appears. The
>>> prompt will appear so you can enter the next instruction.
Unlike expressions, statements are instructions that do not evaluate to
any value. This is why there’s no value displayed on the next line in the
interactive shell after spam = 15. If you’re confused about which instructions
are expressions and which are statements, remember that expressions evaluate to a single value. Any other kind of instruction is a statement.
Variables store values, not expressions. For example, consider the
expressions in the statements spam = 10 + 5 and spam = 10 + 7 - 2. They
both evaluate to 15. The end result is the same: both assignment statements store the value 15 in the variable spam.
A good variable name describes the data it contains. Imagine that you
moved to a new house and labeled all of your moving boxes Stuff. You’d
never find anything! The variable names spam, eggs, and bacon are example
names used for variables in this book.
The Interactive Shell 5
The first time a variable is used in an assignment statement, Python will
create that variable. To check what value is in a variable, enter the variable
name into the interactive shell:
>>> spam = 15
>>> spam
15
The expression spam evaluates to the value inside the spam variable: 15.
You can also use variables in expressions. Try entering the following in
the interactive shell:
>>> spam = 15
>>> spam + 5
20
You set the value of the variable spam to 15, so typing spam + 5 is like typing the expression 15 + 5. Here are the steps of spam + 5 being evaluated:
spam + 5
15 + 5
20
You cannot use a variable before an assignment statement creates it. If
you try to do so, Python will give you a NameError because no such variable by
that name exists yet. Mistyping the variable name also causes this error:
>>> spam = 15
>>> spma
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
spma
NameError: name 'spma' is not defined
The error appeared because there’s a spam variable but no spma variable.
You can change the value stored in a variable by entering another assignment statement. For example, enter the following into the interactive shell:
>>>
>>>
20
>>>
>>>
8
spam = 15
spam + 5
spam = 3
spam + 5
When you first enter spam + 5, the expression evaluates to 20 because
you stored 15 inside spam. However, when you enter spam = 3, the value 15 in
6 Chapter 1
the variable’s box is replaced, or overwritten, with the value 3 since the variable can hold only one value at a time. Because the value of spam is now 3,
when you enter spam + 5, the expression evaluates to 8. Overwriting is like
taking a value out of the variable’s box to put a new value in, as shown in
Figure 1-4.
15
3
spam
Figure 1-4: The value 15 in spam is overwritten
by the value 3.
You can even use the value in the spam variable to assign a new value
to spam:
>>> spam = 15
>>> spam = spam + 5
20
The assignment statement spam = spam + 5 says, “The new value of the
spam variable will be the current value of spam plus five.” To keep increasing
the value in spam by 5 several times, enter the following into the interactive
shell:
>>>
>>>
>>>
>>>
>>>
30
spam
spam
spam
spam
spam
=
=
=
=
15
spam + 5
spam + 5
spam + 5
In this example, you assign spam a value of 15 in the first statement. In
the next statement, you add 5 to the value of spam and assign spam the new
value spam + 5, which evaluates to 20. When you do this three times, spam
evaluates to 30.
The Interactive Shell 7
So far we’ve looked at just one variable, but you can create as many
variables as you need in your programs. For example, let’s assign different
values to two variables named eggs and bacon, like so:
>>> bacon = 10
>>> eggs = 15
Now the bacon variable has 10 inside it, and the eggs variable has 15
inside it. Each variable is its own box with its own value, as shown in
Figure 1-5.
15
10
baco
n
eggs
Figure 1-5: The bacon and eggs variables each store values.
Enter spam = bacon + eggs into the interactive shell, then check the new
value of spam:
>>>
>>>
>>>
>>>
25
bacon = 10
eggs = 15
spam = bacon + eggs
spam
The value in spam is now 25. When you add bacon and eggs, you are adding
their values, which are 10 and 15, respectively. Variables contain values, not
expressions, so the spam variable was assigned the value 25, not the expression
bacon + eggs. After the spam = bacon + eggs statement assigns the value 25 to
spam, changing bacon or eggs will not affect spam.
Summary
In this chapter, you learned the basics of writing Python instructions.
Because computers don’t have common sense and only understand specific instructions, Python needs you to tell it exactly what to do.
8 Chapter 1
Expressions are values (such as 2 or 5) combined with operators (such
as + or -). Python can evaluate expressions—that is, reduce the expression
to a single value. You can store values inside of variables so that your program can remember those values and use them later.
There are a few other types of operators and values in Python. In the
next chapter, you’ll go over some more basic concepts and write your first
program. You’ll learn about working with text in expressions. Python isn’t
limited to just numbers; it’s more than a calculator!
The Interactive Shell 9
2
Writing Progr ams
Now let’s see what Python can do with
text. Almost all programs display text to
the user, and the user enters text into pro
grams through the keyboard. In this chapter,
you’ll make your first program, which does both of
these things. You’ll learn how to store text in variables,
combine text, and display text on the screen. The pro
gram you’ll create displays the greeting Hello world!
and asks for the user’s name.
Topics Cov e re d in This Ch a p te r
•
Strings
•
String concatenation
•
Data types (such as strings or integers)
•
Using the file editor to write programs
•
Saving and running programs in IDLE
•
Flow of execution
•
Comments
•
The print() function
•
The input() function
•
Case sensitivity
String Values
In Python, text values are called strings. String values can be used just like
integer or float values. You can store strings in variables. In code, string
values start and end with a single quote, '. Enter this code into the inter
active shell:
>>> spam = 'hello'
The single quotes tell Python where the string begins and ends. They
are not part of the string value’s text. Now if you enter spam into the inter
active shell, you’ll see the contents of the spam variable. Remember, Python
evaluates variables as the value stored inside the variable. In this case, this
is the string 'hello'.
>>> spam = 'hello'
>>> spam
'hello'
Strings can have any keyboard character in them and can be as long as
you want. These are all examples of strings:
'hello'
'Hi there!'
'KITTENS'
'7 apples, 14 oranges, 3 lemons'
'Anything not pertaining to elephants is irrelephant.'
'A long time ago, in a galaxy far, far away...'
'O*&#wY%*&OCfsdYO*&gfC%YO*&%3yc8r2'
12 Chapter 2
String Concatenation
You can combine string values with operators to make expressions, just as you
did with integer and float values. When you combine two strings with the +
operator, it’s called string concatenation. Enter 'Hello' + 'World!' into the inter
active shell:
>>> 'Hello' + 'World!'
'HelloWorld!'
The expression evaluates to a single string value, 'HelloWorld!'. There is
no space between the words because there was no space in either of the two
concatenated strings, unlike in this example:
>>> 'Hello ' + 'World!'
'Hello World!'
The + operator works differently on string and integer values because
they are different data types. All values have a data type. The data type of the
value 'Hello' is a string. The data type of the value 5 is an integer. The data
type tells Python what operators should do when evaluating expressions.
The + operator concatenates string values, but adds integer and float values.
Writing Programs in IDLE’s File Editor
Until now, you’ve been typing instructions into IDLE’s interactive shell one
at a time. When you write programs, though, you enter several instructions
and have them run all at once, and this is what you’ll do next. It’s time to
write your first program!
In addition to the interpreter, IDLE has another part called the file editor. To open it, click the File menu at the top of the interactive shell. Then
select New Window if you are using Windows or New File if you are using
OS X. A blank window will appear for you to type your program’s code into,
as shown in Figure 2-1.
Figure 2-1: The file editor (left) and the interactive shell (right)
Writing Programs 13
The two windows look similar, but just remember this: the interactive
shell will have the >>> prompt, while the file editor will not.
Creating the Hello World Program
It’s traditional for programmers to make
their first program display Hello world! on the
screen. You’ll create your own Hello World
program now.
When you enter your program, remember
not to enter the numbers at the beginning of
each code line. They’re there so this book can
refer to the code by line number. The bottomright corner of the file editor will tell you where
the blinking cursor is so you can check which
line of code you are on. Figure 2-2 shows that
the cursor is on line 1 (going up and down the
editor) and column 0 (going left and right).
Make sure you’re
using Python 3,
not Python 2!
Figure 2-2: The bottom-right of the file
editor tells you what line the cursor is on.
Enter the following text into the new file editor window. This is the pro
gram’s source code. It contains the instructions Python will follow when the
program is run.
hello.py
1.
2.
3.
4.
5.
# This program says hello and asks for my name.
print('Hello world!')
print('What is your name?')
myName = input()
print('It is good to meet you, ' + myName)
IDLE will write different types of instructions with different colors.
After you’re done typing the code, the window should look like Figure 2-3.
14 Chapter 2
Figure 2-3: The file editor will look like this after you enter your code.
Check to make sure your IDLE window looks the same.
Saving Your Program
Once you’ve entered your source code, save it by clicking File4Save As. Or
press ctrl-S to save with a keyboard shortcut. Figure 2-4 shows the Save As
window that will open. Enter hello.py in the File name text field and then
click Save.
Figure 2-4: Saving the program
You should save your programs often while you write them. That way,
if the computer crashes or you accidentally exit from IDLE, you won’t lose
much work.
To load your previously saved program, click File4 Open. Select the
hello.py file in the window that appears and click the Open button. Your
saved hello.py program will open in the file editor.
Writing Programs 15
Running Your Program
Now it’s time to run the program. Click File4Run Module. Or just press
F5 from the file editor (fn-5 on OS X). Your program will run in the inter
active shell.
Enter your name when the program asks for it. This will look like
Figure 2-5.
Figure 2-5: The interactive shell after you run hello.py
When you type your name and press enter, the program will greet you
by name. Congratulations! You have written your first program and are now
a computer programmer. Press F5 again to run the program a second time
and enter another name.
If you got an error, compare your code to this book’s code with the
online diff tool at https://www.nostarch.com/inventwithpython#diff. Copy
and paste your code from the file editor into the web page and click the
Compare button. This tool will highlight any differences between your
code and the code in this book, as shown in Figure 2-6.
While coding, if you get a NameError that looks like the following, that
means you are using Python 2 instead of Python 3.
Hello world!
What is your name?
Albert
Traceback (most recent call last):
File "C:/Python26/test1.py", line 4, in <module>
myName = input()
File "<string>", line 1, in <module>
NameError: name 'Albert' is not defined
To fix the problem, install Python 3.4 and rerun the program. (See
“Downloading and Installing Python” on page xxv.)
16 Chapter 2
Figure 2-6: Using the diff tool at https://www.nostarch.com/inventwithpython#diff
How the Hello World Program Works
Each line of code is an instruction interpreted by Python. These instruc
tions make up the program. A computer program’s instructions are like the
steps in a recipe. Python completes each instruction in order, beginning
from the top of the program and moving downward.
The step where Python is currently working in the program is called the
execution. When the program starts, the execution is at the first instruction.
After executing the instruction, Python moves down to the next instruction.
Let’s look at each line of code to see what it’s doing. We’ll begin with
line number 1.
Comments for the Programmer
The first line of the Hello World program is a comment:
1. # This program says hello and asks for my name.
Writing Programs 17
Any text following a hash mark (#) is a comment. Comments are the
programmer’s notes about what the code does; they are not written for
Python but for you, the programmer. Python ignores comments when it
runs a program. Programmers usually put a comment at the top of their
code to give their program a title. The comment in the Hello World pro
gram tells you that the program says hello and asks for your name.
Functions: Mini-Programs Inside Programs
A function is kind of like a mini-program inside your program that contains
several instructions for Python to execute. The great thing about functions
is that you only need to know what they do, not how they do it. Python
provides some built-in functions already. We use print() and input() in the
Hello World program.
A function call is an instruction that tells Python to run the code inside a
function. For example, your program calls the print() function to display a
string on the screen. The print() function takes the string you type between
the parentheses as input and displays that text on the screen.
The print() Function
Lines 2 and 3 of the Hello World program are calls to print():
2. print('Hello world!')
3. print('What is your name?')
A value between the parentheses in a function call is an argument. The
argument on line 2’s print() function call is 'Hello world!', and the argu
ment on line 3’s print() function call is 'What is your name?'. This is called
passing the argument to the function.
The input() Function
Line 4 is an assignment statement with a variable, myName, and a function
call, input():
4. myName = input()
When input() is called, the program waits for the user to enter text.
The text string that the user enters becomes the value that the function
call evaluates to. Function calls can be used in expressions anywhere a
value can b