Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

A

abecedarian, Traversal with a for Loop, Exercises
abs function, Return Values
absolute path, Filenames and Paths, Glossary
access, Lists Are Mutable
accumulator, Map, Filter, and Reduce, Map, Filter, and Reduce, Glossary, Word Histogram, Printing the Deck
histogram, Word Histogram
list, Map, Filter, and Reduce
string, Printing the Deck
sum, Map, Filter, and Reduce
Ackermann function, Exercises, Memos
add method, Operator Overloading
addition with carrying, Algorithms
algorithm, What Is a Program?, Glossary, Exercises, Algorithms, Exercises, Long Integers, Random Words, Pipes, Analysis of Algorithms
Euclid, Exercises
MD5, Pipes
RSA, Long Integers
square root, Exercises
aliasing, Objects and Values, Aliasing, Debugging, Glossary, Attributes, Copying, Exercises
copying to avoid, Debugging
alphabet, Exercises
alternative execution, Alternative Execution
ambiguity, Formal and Natural Languages
anagram, Exercises
anagram set, Exercises, Pickling
analysis of algorithms, Analysis of Algorithms
analysis of primitives, Analysis of Basic Python Operations
and operator, Logical Operators
anydbm module, Databases
append method, List Methods, List Arguments, Exercises, Decks, Add, Remove, Shuffle, and Sort
arc function, Exercises
Archimedian spiral, Exercises
argument, Function Calls, Adding New Functions, Parameters and Arguments, Parameters and Arguments, Glossary, Generalization, Glossary, String Methods, Lists and Strings, List Arguments, List Arguments, Reverse Lookup, Variable-Length Argument Tuples, Variable-Length Argument Tuples, Comparing Tuples, Buttons and Callbacks
gather, Variable-Length Argument Tuples
keyword, Generalization, Glossary, Comparing Tuples, Buttons and Callbacks
list, List Arguments
optional, String Methods, Lists and Strings, Reverse Lookup
variable-length tuple, Variable-Length Argument Tuples
argument scatter, Variable-Length Argument Tuples
arithmetic operator, Operators and Operands
assert statement, Debugging
assignment, Glossary, Multiple Assignment, Glossary, Strings Are Immutable, A List Is a Sequence, Lists Are Mutable, Map, Filter, and Reduce, Glossary, Global Variables, Tuples Are Immutable, Tuple Assignment, Tuples as Return Values, Lists and Tuples, Glossary
augmented, Map, Filter, and Reduce, Glossary
item, Strings Are Immutable, Lists Are Mutable, Tuples Are Immutable
multiple, Glossary, Global Variables
tuple, Tuple Assignment, Tuples as Return Values, Lists and Tuples, Glossary
assignment statement, Variables
asymptotic analysis, Analysis of Algorithms
attribute, Attributes, Glossary, Debugging, Debugging, Interface and Implementation, Class Attributes, Class Attributes, Glossary, Glossary
class, Class Attributes, Glossary
initializing, Debugging
instance, Attributes, Glossary, Class Attributes, Glossary
__dict__, Debugging
AttributeError, Debugging, When I Run the Program, I Get an Exception
augmented assignment, Map, Filter, and Reduce, Glossary
Austin, Jane, Word Histogram
available colors, Exercises, Exercises
average case, Analysis of Algorithms
average cost, Hashtables

B

badness, Order of Growth
Bangladesh, national flag, Exercises
base case, Stack Diagrams for Recursive Functions, Glossary, Stack Diagram
benchmarking, Data Structures, Glossary
BetterMap, Hashtables
big, hairy expression, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect
big-oh notation, Order of Growth
binary search, Exercises
binding, Binding, Glossary
bingo, Exercises
birthday, Exercises
birthday paradox, Exercises
bisect module, Analysis of Search Algorithms
bisect module, Exercises, Analysis of Search Algorithms
bisection search, Exercises, Analysis of Search Algorithms
bisection, debugging by, Debugging
bitwise operator, Operators and Operands
body, Adding New Functions, Glossary, The while Statement
bool type, Boolean Expressions
boolean expression, Boolean Expressions, Glossary
boolean function, Boolean Functions, Time
boolean operator, The in Operator
borrowing, subtraction with, Algorithms, Prototyping Versus Planning
bound method, Packing Widgets, Glossary
bounded, Hashtables
bounding box, Exercises, Coordinate Sequences, Glossary
bracket, Dictionaries
squiggly, Dictionaries
bracket operator, A String Is a Sequence, Lists Are Mutable, Tuples Are Immutable
branch, Alternative Execution, Glossary
break statement, break
bubble sort, Analysis of Algorithms
bug, What Is Debugging?, What Is Debugging?, Glossary, Exercises, Exercises
worst, Exercises
worst ever, Exercises
Button widget, Buttons and Callbacks

C

calculator, Exercises, Exercises
call graph, Memos, Glossary
Callable object, Menus and Callables
callback, Buttons and Callbacks, Packing Widgets, Menus and Callables, Binding, Debugging, Glossary
Canvas coordinate, Canvas Widgets, Binding
Canvas item, Canvas Widgets
Canvas object, Exercises
Canvas widget, Canvas Widgets
Car Talk, Exercises, Exercises, Exercises, Exercises, Exercises
Card class, Card Objects, Class Diagrams
card, playing, Inheritance
carrying, addition with, Algorithms, Pure Functions, Prototyping Versus Planning
case-sensitivity, variable names, Debugging
catch, Glossary
chained conditional, Chained Conditionals, Glossary
character, A String Is a Sequence
checksum, Pipes, Pipes
child class, Inheritance, Glossary
choice function, Random Numbers
circle function, Exercises
circular definition, More Recursion
class, User-Defined Types, User-Defined Types, Rectangles, Glossary, Time, The init Method, Exercises, Card Objects, Decks, Inheritance, Inheritance, Inheritance, Glossary, Packing Widgets, Object Diagrams, Object Diagrams
Card, Card Objects
child, Inheritance, Glossary
Deck, Decks
Hand, Inheritance
Kangaroo, Exercises
parent, Inheritance
Point, User-Defined Types, The init Method, Object Diagrams
Rectangle, Rectangles, Object Diagrams
SimpleTurtleWorld, Packing Widgets
Time, Time
class attribute, Class Attributes, Glossary
class definition, User-Defined Types
class diagram, Class Diagrams, Glossary, Lumpy, Class Diagrams, Class Diagrams
class object, User-Defined Types, Glossary, Function and Class Objects
close method, Reading and Writing, Databases, Pipes
cmp function, Comparing Cards
__cmp__ method, Comparing Cards
Collatz conjecture, The while Statement
colon, Adding New Functions, Syntax Errors
color list, Exercises, Exercises
comment, Comments, Glossary
commutativity, String Operations, Type-Based Dispatch
compare function, Return Values
comparing algorithms, Analysis of Algorithms
comparison, String Comparison, Comparing Tuples, Comparing Cards
string, String Comparison
tuple, Comparing Tuples, Comparing Cards
comparison sort, Analysis of Basic Python Operations
compile, The Python Programming Language, Glossary
composition, Composition, Parameters and Arguments, Glossary, Composition, Decks
compound statement, Conditional Execution, Glossary
concatenation, String Operations, Glossary, Variables and Parameters Are Local, Traversal with a for Loop, Strings Are Immutable, List Operations, Lists and Strings, List Arguments, Exercises
list, List Operations, List Arguments, Exercises
condition, Conditional Execution, Glossary, The while Statement, Infinite loop
conditional, Chained Conditionals, Nested Conditionals, Glossary, Glossary, Syntax Errors
chained, Chained Conditionals, Glossary
nested, Nested Conditionals, Glossary
conditional execution, Conditional Execution
conditional statement, Conditional Execution, Glossary, Boolean Functions
config method, Canvas Widgets
consistency check, Debugging, Prototyping Versus Planning
constant time, Hashtables
constructor, Function and Class Objects
contributors, Contributor List
conversion, Type Conversion Functions
type, Type Conversion Functions
coordinate, Canvas Widgets, Binding, Binding
Canvas, Canvas Widgets, Binding
pixel, Binding
coordinate sequence, Coordinate Sequences
copy, String Slices, List Slices, Debugging, Copying, Copying, Object Diagrams
deep, Copying
shallow, Copying
slice, String Slices, List Slices
to avoid aliasing, Debugging
copy module, Copying
copying objects, Copying
count method, String Methods
counter, Looping and Counting, Glossary, Dictionary as a Set of Counters, Global Variables
counting and looping, Looping and Counting
Creative Commons, Acknowledgments
crossover point, Order of Growth
crosswords, Reading Word Lists
cummings, e. e., Syntax Errors
cumulative sum, Map, Filter, and Reduce
Czech Republic, national flag, Exercises

D

data encapsulation, Data Encapsulation
data structure, Debugging, Glossary, Data Structures
database, Databases, Glossary
datetime module, Exercises
dead code, Return Values, Glossary, I Added So Many Print Statements I Get Inundated with Output
debugger (pdb), When I Run the Program, I Get an Exception
debugging, What Is Debugging?, What Is Debugging?, Experimental Debugging, Debugging, Debugging, Glossary, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, I’m Really, Really Stuck and I Need Help, I’m Really, Really Stuck and I Need Help
by bisection, Debugging
emotional response, Debugging, I’m Really, Really Stuck and I Need Help
experimental, Experimental Debugging
superstition, I’m Really, Really Stuck and I Need Help
Deck class, Decks, Class Diagrams
deck, playing cards, Decks
declaration, Global Variables, Glossary
decorate-sort-undecorate pattern, Comparing Tuples
decrement, Updating Variables, Glossary
deep copy, Copying, Glossary
deepcopy function, Copying
def keyword, Adding New Functions
default value, Optional Parameters, Glossary, The init Method, Exercises
avoiding mutable, Exercises
definition, Adding New Functions, More Recursion, Exercises, User-Defined Types
circular, More Recursion
class, User-Defined Types
function, Adding New Functions
recursive, Exercises
del operator, Deleting Elements
deletion, element of list, Deleting Elements
delimiter, Lists and Strings, Glossary
deterministic, Random Numbers, Glossary
development plan, A Development Plan, Glossary, Incremental Development, Search, Looping with Indices, Debugging, Pure Functions, Prototyping Versus Planning, Prototyping Versus Planning, Data Encapsulation, Syntax Errors, I’m Really, Really Stuck and I Need Help
encapsulation and generalization, A Development Plan
incremental, Incremental Development, Syntax Errors
planned, Prototyping Versus Planning
problem recognition, Search, Looping with Indices
prototype and patch, Pure Functions, Prototyping Versus Planning
random walk programming, Debugging, I’m Really, Really Stuck and I Need Help
diagram, Variables, Stack Diagrams, Multiple Assignment, Debugging, Lists Are Mutable, Objects and Values, Aliasing, List Arguments, Dictionaries and Lists, Glossary, Dictionaries and Tuples, Attributes, Attributes, Rectangles, Rectangles, Copying, Copying, Glossary, Time, Time, Class Attributes, Class Attributes, Class Diagrams, Glossary, Lumpy, Lumpy, Lumpy, Lumpy, State Diagram, Stack Diagram, Object Diagrams, Class Diagrams, Class Diagrams
call graph, Glossary
class, Class Diagrams, Glossary, Lumpy, Class Diagrams, Class Diagrams
object, Attributes, Rectangles, Copying, Glossary, Time, Class Attributes, Lumpy, Object Diagrams
stack, Stack Diagrams, List Arguments, Lumpy, Stack Diagram
state, Variables, Multiple Assignment, Debugging, Lists Are Mutable, Objects and Values, Aliasing, Dictionaries and Lists, Dictionaries and Tuples, Attributes, Rectangles, Copying, Time, Class Attributes, Lumpy, State Diagram
__dict__ attribute, Debugging
dict function, Dictionaries
dictionary, Dictionaries, Dictionaries, Looping and Dictionaries, Reverse Lookup, Reverse Lookup, Dictionaries and Lists, Glossary, Dictionaries and Tuples, Dictionaries and Tuples, Dictionaries and Tuples, Dictionary Subtraction, Debugging, When I Run the Program, I Get an Exception, Object Diagrams
initialize, Dictionaries and Tuples
invert, Dictionaries and Lists
lookup, Reverse Lookup
looping with, Looping and Dictionaries
reverse lookup, Reverse Lookup
subtraction, Dictionary Subtraction
traversal, Dictionaries and Tuples, Debugging
dictionary methods, Databases, Analysis of Basic Python Operations
anydbm module, Databases
diff, Pipes
Dijkstra, Edsger, Debugging
directory, Filenames and Paths, Filenames and Paths, Filenames and Paths, Glossary
walk, Filenames and Paths
working, Filenames and Paths
dispatch, Polymorphism
type-based, Polymorphism
dispatch, type-based, Type-Based Dispatch
divisibility, Modulus Operator
division, Operators and Operands, Operators and Operands, Debugging
floating-point, Operators and Operands
floor, Operators and Operands, Debugging
divmod, Tuples as Return Values, Prototyping Versus Planning
docstring, Docstring, Glossary, User-Defined Types
dot notation, Math Functions, Importing with from, Glossary, String Methods, Attributes, Printing Objects, Class Attributes
Double Day, Exercises
double letters, Exercises
Doyle, Arthur Conan, Experimental Debugging
drag-and-drop, Binding
DSU pattern, Comparing Tuples, Glossary, Most Common Words
duplicate, Exercises, Exercises, Exercises, Pipes

E

Einstein, Albert, Interface Design
element, A List Is a Sequence, Glossary
element deletion, Deleting Elements
elif keyword, Chained Conditionals
Elkner, Jeff, The Strange History of This Book, Acknowledgments
ellipses, Adding New Functions
else keyword, Alternative Execution
email address, Tuple Assignment
embedded object, Rectangles, Copying, Glossary, Exercises
copying, Copying
emotional debugging, Debugging, I’m Really, Really Stuck and I Need Help
empty list, A List Is a Sequence
empty string, Glossary, Lists and Strings
encapsulation, Encapsulation, Glossary, Composition, Square Roots, Looping and Counting, Inheritance, Data Encapsulation
data, Data Encapsulation
encode, Card Objects, Glossary
encrypt, Card Objects
encryption, Long Integers
end of line character, Debugging
Entry widget, More Widgets
enumerate function, Lists and Tuples
epsilon, Square Roots
equality and assignment, Multiple Assignment
equivalence, Objects and Values
equivalent, Glossary
error, Syntax Errors, Runtime Errors, Semantic Errors, Values and Types, Debugging, Debugging, Debugging, Infinite Recursion, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Debugging, Semantic Errors
compile-time, Debugging
runtime, Runtime Errors, Debugging, Infinite Recursion, Debugging, Debugging
semantic, Semantic Errors, Values and Types, Debugging, Debugging, Debugging, Semantic Errors
shape, Debugging
syntax, Syntax Errors, Debugging, Debugging
error checking, Checking Types
error message, Syntax Errors, Semantic Errors, Debugging, Values and Types, Debugging, Syntax Errors
Euclid’s algorithm, Exercises
eval function, Exercises
evaluate, Expressions and Statements
event, Glossary
event handler, Binding
event loop, GUI, Glossary
Event object, Binding
event string, Binding
event-driven programming, Buttons and Callbacks, Debugging, Glossary
exception, Runtime Errors, Glossary, Debugging, Composition, Variables and Parameters Are Local, Infinite Recursion, Keyboard Input, Debugging, A String Is a Sequence, len, Strings Are Immutable, Debugging, Lists Are Mutable, Dictionaries, Reverse Lookup, Dictionaries and Lists, Global Variables, Tuples Are Immutable, Tuple Assignment, Variable-Length Argument Tuples, Format Operator, Catching Exceptions, Debugging, Another Example, Debugging, When I Run the Program, I Get an Exception, When I Run the Program, I Get an Exception, When I Run the Program, I Get an Exception, When I Run the Program, I Get an Exception, When I Run the Program, I Get an Exception, When I Run the Program, I Get an Exception
AttributeError, Debugging, When I Run the Program, I Get an Exception
IndexError, len, Debugging, Lists Are Mutable, When I Run the Program, I Get an Exception
IOError, Catching Exceptions
KeyError, Dictionaries, When I Run the Program, I Get an Exception
NameError, Variables and Parameters Are Local, When I Run the Program, I Get an Exception
OverflowError, Debugging
RuntimeError, Infinite Recursion
SyntaxError, Composition
TypeError, A String Is a Sequence, Strings Are Immutable, Dictionaries and Lists, Tuples Are Immutable, Variable-Length Argument Tuples, Format Operator, Another Example, When I Run the Program, I Get an Exception
UnboundLocalError, Global Variables
ValueError, Keyboard Input, Reverse Lookup, Tuple Assignment
exception, catching, Catching Exceptions
executable, The Python Programming Language, Glossary
exercise, secret, Exercises
exists function, Filenames and Paths
experimental debugging, Experimental Debugging, Debugging
exponent, Order of Growth
exponential growth, Order of Growth
expression, Operators and Operands, Expressions and Statements, Glossary, Boolean Expressions, Glossary, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect
big and hairy, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect
boolean, Boolean Expressions, Glossary
extend method, List Methods

F

factorial function, More Recursion, Checking Types
False special value, Boolean Expressions
Fermat’s Last Theorem, Exercises
fibonacci function, One More Example, Memos
file, Persistence, Reading and Writing, Catching Exceptions
permission, Catching Exceptions
reading and writing, Reading and Writing
file object, Reading Word Lists, Glossary
filename, Filenames and Paths
filter pattern, Map, Filter, and Reduce, Glossary
find function, Searching
flag, Global Variables, Glossary
float function, Type Conversion Functions
float type, Values and Types
floating-point, Glossary, Square Roots
floating-point division, Operators and Operands
floor division, Operators and Operands, Glossary, Debugging
flow of execution, Flow of Execution, Glossary, One More Example, Debugging, The while Statement, Debugging, Debugging, Flow of execution
flower, Exercises
folder, Filenames and Paths
for loop, Simple Repetition, Traversal with a for Loop, Traversing a List, Lists and Tuples
formal language, Formal and Natural Languages, Glossary
format operator, Format Operator, Glossary, When I Run the Program, I Get an Exception
format sequence, Format Operator, Glossary
format string, Format Operator, Glossary
frame, Stack Diagrams, Glossary, Stack Diagrams for Recursive Functions, More Recursion, Memos, Stack Diagram
Frame widget, Packing Widgets
Free Documentation License, GNU, The Strange History of This Book, Acknowledgments
frequency, Dictionary as a Set of Counters, Exercises, Word Frequency Analysis, Exercises
letter, Exercises
word, Word Frequency Analysis, Exercises
fruitful function, Fruitful Functions and Void Functions, Glossary
frustration, I’m Really, Really Stuck and I Need Help
function, The First Program, Type Conversion Functions, Type Conversion Functions, Type Conversion Functions, Math Functions, Math Functions, Adding New Functions, Glossary, Exercises, Exercises, Exercises, Exercises, Recursion, Keyboard Input, Return Values, Return Values, Incremental Development, More Recursion, One More Example, Checking Types, Exercises, Exercises, len, Searching, Reading Word Lists, Reading Word Lists, Lists and Strings, Exercises, Dictionaries, Dictionaries, Memos, Memos, Tuples Are Immutable, Tuples as Return Values, Tuples as Return Values, Variable-Length Argument Tuples, Variable-Length Argument Tuples, Variable-Length Argument Tuples, Lists and Tuples, Lists and Tuples, Comparing Tuples, Sequences of Sequences, Sequences of Sequences, Random Numbers, Random Numbers, Random Numbers, Reading and Writing, Filenames and Paths, Filenames and Paths, Catching Exceptions, Databases, Pipes, Writing Modules, Debugging, Copying, Debugging, Debugging, Object-Oriented Features, Type-Based Dispatch, Debugging, Debugging, Comparing Cards, Add, Remove, Shuffle, and Sort, I Keep Making Changes and It Makes No Difference
abs, Return Values
ack, Exercises, Memos
arc, Exercises
choice, Random Numbers
circle, Exercises
cmp, Comparing Cards
compare, Return Values
deepcopy, Copying
dict, Dictionaries
enumerate, Lists and Tuples
eval, Exercises
exists, Filenames and Paths
factorial, More Recursion
fibonacci, One More Example, Memos
find, Searching
float, Type Conversion Functions
getattr, Debugging
getcwd, Filenames and Paths
hasattr, Debugging, Debugging
int, Type Conversion Functions
isinstance, Checking Types, Type-Based Dispatch
len, Exercises, len, Dictionaries
list, Lists and Strings
log, Math Functions
max, Tuples as Return Values, Variable-Length Argument Tuples
min, Tuples as Return Values, Variable-Length Argument Tuples
open, Reading Word Lists, Reading Word Lists, Reading and Writing, Catching Exceptions, Databases
polygon, Exercises
popen, Pipes
randint, Exercises, Random Numbers
random, Comparing Tuples, Random Numbers
raw_input, Keyboard Input
recursive, Recursion
reload, Writing Modules, I Keep Making Changes and It Makes No Difference
repr, Debugging
reversed, Sequences of Sequences
shuffle, Add, Remove, Shuffle, and Sort
sorted, Sequences of Sequences
sqrt, Math Functions, Incremental Development
str, Type Conversion Functions
sum, Variable-Length Argument Tuples
tuple, Tuples Are Immutable
type, Debugging
zip, Lists and Tuples
function argument, Parameters and Arguments
function call, Function Calls, Glossary
function composition, Composition
function definition, Adding New Functions, Definitions and Uses, Glossary, Glossary
function frame, Stack Diagrams, Glossary, Stack Diagrams for Recursive Functions, More Recursion, Memos, Stack Diagram
function object, Adding New Functions, Exercises, Function and Class Objects
function parameter, Parameters and Arguments
function syntax, Printing Objects
function type, Pure Functions, Modifiers
modifier, Modifiers
pure, Pure Functions
function, fruitful, Fruitful Functions and Void Functions
function, math, Math Functions
function, reasons for, Why Functions?
function, trigonometric, Math Functions
function, tuple as return value, Tuples as Return Values
function, void, Fruitful Functions and Void Functions
functional programming style, Modifiers, Glossary

G

gamma function, Checking Types
gather, Variable-Length Argument Tuples, Glossary
GCD (greatest common divisor), Exercises
generalization, Generalization, Glossary, Search, Prototyping Versus Planning
geometric resizing, Hashtables
geometry manager, Packing Widgets, Glossary
get method, Dictionary as a Set of Counters
getattr function, Debugging
getcwd function, Filenames and Paths
global statement, Global Variables
global variable, Global Variables, Global Variables, Glossary, State Diagram
update, Global Variables
GNU Free Documentation License, The Strange History of This Book, Acknowledgments
graphical user interface, GUI
greatest common divisor (GCD), Exercises
grid, Exercises
guardian pattern, Checking Types, Glossary, Debugging
GUI, GUI, Glossary
Gui module, GUI

H

Hand class, Inheritance, Class Diagrams
hanging, My Program Hangs
HAS-A relationship, Class Diagrams, Glossary, Class Diagrams
hasattr function, Debugging, Debugging
hash function, Dictionaries and Lists, Glossary, Hashtables
hashable, Dictionaries and Lists, Glossary, Dictionaries and Tuples
HashMap, Hashtables
hashtable, Dictionaries, Glossary, Hashtables
header, Adding New Functions, Glossary, Syntax Errors
Hello, World, The First Program
help utility, Exercises
hexadecimal, User-Defined Types
high-level language, The Python Programming Language, Glossary
histogram, Dictionary as a Set of Counters, Dictionary as a Set of Counters, Glossary, Random Numbers, Word Histogram, Random Words
random choice, Random Numbers, Random Words
word frequencies, Word Histogram
Holmes, Sherlock, Experimental Debugging
homophone, Exercises
HTMLParser module, Exercises
hyperlink, Exercises
hypotenuse, Incremental Development

I

identical, Glossary
identity, Objects and Values
if statement, Conditional Execution
Image module, Exercises
image viewer, Exercises
immutability, Strings Are Immutable, Strings Are Immutable, Glossary, Aliasing, Dictionaries and Lists, Tuples Are Immutable, Sequences of Sequences
implementation, Dictionary as a Set of Counters, Glossary, Data Structures, Interface and Implementation
import statement, Glossary, TurtleWorld, Writing Modules
in operator, Analysis of Search Algorithms
in operator, The in Operator, Lists Are Mutable, Dictionaries
increment, Updating Variables, Glossary, Modifiers, Another Example
incremental development, Glossary, Syntax Errors
indentation, Adding New Functions, Printing Objects, Syntax Errors
index, A String Is a Sequence, A String Is a Sequence, A String Is a Sequence, len, String Slices, Debugging, Glossary, Looping with Indices, Lists Are Mutable, Lists Are Mutable, Traversing a List, List Slices, Glossary, Dictionaries, When I Run the Program, I Get an Exception
looping with, Looping with Indices, Traversing a List
negative, len
slice, String Slices, List Slices
starting at zero, A String Is a Sequence, Lists Are Mutable
IndexError, len, Debugging, Lists Are Mutable, When I Run the Program, I Get an Exception
indexing, Analysis of Basic Python Operations
infinite loop, The while Statement, Glossary, GUI, My Program Hangs, Infinite loop
infinite recursion, Infinite Recursion, Glossary, Checking Types, My Program Hangs, Infinite recursion
information hiding, Interface and Implementation, Glossary
inheritance, Inheritance, Glossary
init method, The init Method, Debugging, Card Objects, Decks, Inheritance
initialization, Glossary
variable, Glossary
initialization (before update), Updating Variables
instance, TurtleWorld, Glossary, User-Defined Types, Attributes, Instances as Return Values, Glossary
as argument, Attributes
as return value, Instances as Return Values
instance attribute, Attributes, Glossary, Class Attributes, Glossary
instantiate, Function and Class Objects
instantiation, User-Defined Types
int function, Type Conversion Functions
int type, Values and Types
integer, Glossary, Long Integers
long, Long Integers
interactive mode, The Python Programming Language, Glossary, Interactive Mode and Script Mode, Fruitful Functions and Void Functions
interface, Interface Design, Debugging, Glossary, Interface and Implementation, Debugging
interlocking words, Exercises
interpret, The Python Programming Language, Glossary
invariant, Debugging, Glossary, Debugging
invert dictionary, Dictionaries and Lists
invocation, String Methods, Glossary
IOError, Catching Exceptions
is operator, Objects and Values, Copying
IS-A relationship, Class Diagrams, Glossary, Class Diagrams
isinstance function, Checking Types, Type-Based Dispatch
item, Glossary, A List Is a Sequence, Glossary, Canvas Widgets, Glossary
Canvas, Canvas Widgets, Glossary
dictionary, Glossary
item assignment, Strings Are Immutable, Lists Are Mutable, Tuples Are Immutable
item update, Traversing a List
items method, Dictionaries and Tuples
iteration, The while Statement, Glossary

J

join, Analysis of Basic Python Operations
join method, Lists and Strings, Printing the Deck

K

Kangaroo class, Exercises
key, Dictionaries, Glossary
key-value pair, Dictionaries, Glossary, Dictionaries and Tuples
keyboard input, Keyboard Input
KeyError, Dictionaries, When I Run the Program, I Get an Exception, Hashtables
keys method, Looping and Dictionaries
keyword, Variable Names and Keywords, Variable Names and Keywords, Glossary, Adding New Functions, Alternative Execution, Chained Conditionals, Syntax Errors
def, Adding New Functions
elif, Chained Conditionals
else, Alternative Execution
keyword argument, Generalization, Glossary, Comparing Tuples, Buttons and Callbacks, Glossary
Koch curve, Exercises

L

Label widget, Buttons and Callbacks
language, The Python Programming Language, The Python Programming Language, The Python Programming Language, Runtime Errors, Formal and Natural Languages, Formal and Natural Languages, More Recursion
formal, Formal and Natural Languages
high-level, The Python Programming Language
low-level, The Python Programming Language
natural, Formal and Natural Languages
programming, The Python Programming Language
safe, Runtime Errors
Turing complete, More Recursion
leading coefficient, Order of Growth
leading term, Order of Growth
leap of faith, Leap of Faith
len function, Exercises, len, Dictionaries
letter frequency, Exercises
letter rotation, Exercises, Exercises
linear growth, Order of Growth
linear search, Analysis of Search Algorithms
LinearMap, Hashtables
Linux, Experimental Debugging
lipogram, Exercises
list, A List Is a Sequence, A List Is a Sequence, A List Is a Sequence, Lists Are Mutable, Lists Are Mutable, Lists Are Mutable, Traversing a List, Traversing a List, List Operations, List Operations, List Operations, List Slices, List Slices, List Methods, Map, Filter, and Reduce, Lists and Strings, Lists and Strings, List Arguments, List Arguments, Glossary, Glossary, Exercises, Lists and Tuples, Sequences of Sequences, Decks
as argument, List Arguments
comprehension, Map, Filter, and Reduce
concatenation, List Operations, List Arguments, Exercises
copy, List Slices
element, Lists Are Mutable
empty, A List Is a Sequence
function, Lists and Strings
index, Lists Are Mutable
membership, Lists Are Mutable
method, List Methods
nested, A List Is a Sequence, Traversing a List
of objects, Decks
of tuples, Lists and Tuples
operation, List Operations
repetition, List Operations
slice, List Slices
traversal, Traversing a List, Glossary
list index, Object Diagrams
list methods, Analysis of Basic Python Operations
literalness, Formal and Natural Languages
local variable, Variables and Parameters Are Local, Glossary
log function, Math Functions
logarithm, Exercises
logarithmic growth, Order of Growth
logical operator, Boolean Expressions, Logical Operators
long integer, Long Integers
lookup, Glossary
lookup, dictionary, Reverse Lookup
loop, Simple Repetition, Simple Repetition, Glossary, The while Statement, The while Statement, The while Statement, Traversal with a for Loop, Traversal with a for Loop, Traversing a List, Lists and Tuples, Decks, GUI, GUI, Infinite loop, Infinite loop
condition, Infinite loop
event, GUI
for, Simple Repetition, Traversal with a for Loop, Traversing a List
infinite, The while Statement, GUI, Infinite loop
nested, Decks
traversal, Traversal with a for Loop
while, The while Statement
looping, Looping and Counting, Looping with Indices, Traversing a List, Looping and Dictionaries
with dictionaries, Looping and Dictionaries
with indices, Looping with Indices, Traversing a List
with strings, Looping and Counting
looping and counting, Looping and Counting
low-level language, The Python Programming Language, Glossary
ls (Unix command), Pipes
Lumpy, Lumpy, Lumpy

M

machine model, Analysis of Algorithms
maintainable, Interface and Implementation
map pattern, Map, Filter, and Reduce, Glossary
map to, Card Objects
mapping, Lists Are Mutable, Glossary, Markov Analysis
Markov analysis, Markov Analysis
mash-up, Markov Analysis
math function, Math Functions
Matplotlib, Exercises
max function, Tuples as Return Values, Variable-Length Argument Tuples
McCloskey, Robert, Traversal with a for Loop
md5, Pipes
MD5 algorithm, Pipes
md5sum, Pipes
membership, Lists Are Mutable, Exercises, Exercises, Dictionaries, Dictionaries
binary search, Exercises
bisection search, Exercises
dictionary, Dictionaries
list, Lists Are Mutable
set, Dictionaries
memo, Memos, Glossary
mental model, My Program Doesn’t Work
Menubutton widget, Menus and Callables
metaphor, method invocation, Printing Objects
metathesis, Exercises
method, String Methods, String Methods, String Methods, Glossary, Reading Word Lists, Reading Word Lists, List Methods, List Methods, List Methods, List Methods, Deleting Elements, Deleting Elements, Lists and Strings, Lists and Strings, List Arguments, Debugging, Dictionaries, Dictionary as a Set of Counters, Looping and Dictionaries, Dictionaries and Lists, Tuple Assignment, Dictionaries and Tuples, Dictionaries and Tuples, Comparing Tuples, Word Frequency Analysis, Word Frequency Analysis, Word Frequency Analysis, Reading and Writing, Databases, Pipes, Pipes, Pipes, Object-Oriented Features, The init Method, The __str__ Method, Operator Overloading, Type-Based Dispatch, Glossary, Card Objects, Comparing Cards, Decks, Decks, Printing the Deck, Printing the Deck, Add, Remove, Shuffle, and Sort, Add, Remove, Shuffle, and Sort, Add, Remove, Shuffle, and Sort, Inheritance, Debugging, Canvas Widgets
add, Operator Overloading
append, List Methods, List Arguments, Decks, Add, Remove, Shuffle, and Sort
close, Reading and Writing, Databases, Pipes
config, Canvas Widgets
count, String Methods
extend, List Methods
get, Dictionary as a Set of Counters
init, The init Method, Card Objects, Decks, Inheritance
items, Dictionaries and Tuples
join, Lists and Strings, Printing the Deck
keys, Looping and Dictionaries
mro, Debugging
pop, Deleting Elements, Add, Remove, Shuffle, and Sort
radd, Type-Based Dispatch
read, Pipes
readline, Reading Word Lists, Pipes
remove, Deleting Elements
replace, Word Frequency Analysis
setdefault, Dictionaries and Lists
sort, List Methods, Debugging, Comparing Tuples, Add, Remove, Shuffle, and Sort
split, Lists and Strings, Tuple Assignment
string, String Methods
strip, Reading Word Lists, Word Frequency Analysis
translate, Word Frequency Analysis
update, Dictionaries and Tuples
values, Dictionaries
void, List Methods
__cmp__, Comparing Cards
__str__, The __str__ Method, Printing the Deck
method append, Exercises
method resolution order, Debugging
method syntax, Printing Objects
method, bound, Packing Widgets
method, list, List Methods
Meyers, Chris, Acknowledgments
min function, Tuples as Return Values, Variable-Length Argument Tuples
Moby Project, Reading Word Lists
model, mental, My Program Doesn’t Work
modifier, Modifiers, Glossary
module, Math Functions, Glossary, Glossary, Exercises, Exercises, Exercises, Debugging, Comparing Tuples, Debugging, Word Frequency Analysis, Random Numbers, Data Structures, Persistence, Filenames and Paths, Databases, Pickling, Pickling, Writing Modules, Exercises, Copying, Exercises, Exercises, Exercises, Exercises, Add, Remove, Shuffle, and Sort, GUI, Exercises, Exercises, Exercises, I Keep Making Changes and It Makes No Difference, Analysis of Search Algorithms
anydbm, Databases
bisect, Exercises, Analysis of Search Algorithms
copy, Copying
datetime, Exercises
Gui, GUI
HTMLParser, Exercises
Image, Exercises
os, Filenames and Paths
pickle, Persistence, Pickling
pprint, Debugging
profile, Data Structures
random, Exercises, Comparing Tuples, Random Numbers, Add, Remove, Shuffle, and Sort
reload, Writing Modules, I Keep Making Changes and It Makes No Difference
shelve, Pickling
string, Word Frequency Analysis
structshape, Debugging
time, Exercises
urllib, Exercises, Exercises
Visual, Exercises
vpython, Exercises
World, Exercises
module object, Math Functions, Writing Modules
module, writing, Writing Modules
module-level variable, State Diagram
modulus operator, Modulus Operator, Glossary
Monty Python and the Holy Grail, Pure Functions
MP3, Pipes
mro method, Debugging
multiline string, Docstring, Syntax Errors
multiple assignment, Multiple Assignment, Glossary, Global Variables
multiplicity (in class diagram), Class Diagrams, Glossary
mutability, Strings Are Immutable, Lists Are Mutable, List Slices, Aliasing, Global Variables, Tuples Are Immutable, Sequences of Sequences, Objects Are Mutable
mutable object, as default value, Exercises

N

NameError, Variables and Parameters Are Local, When I Run the Program, I Get an Exception
natural language, Formal and Natural Languages, Glossary
negative index, len
nested conditional, Nested Conditionals, Glossary
nested list, A List Is a Sequence, Traversing a List, Glossary
newline, Keyboard Input, Multiple Assignment, Printing the Deck
Newton’s method, Square Roots
None special value, Fruitful Functions and Void Functions, Return Values, Glossary, List Methods, Deleting Elements
not operator, Logical Operators
number, random, Random Numbers

O

Obama, Barack, Analysis of Algorithms
object, Adding New Functions, Exercises, Strings Are Immutable, Glossary, Reading Word Lists, Glossary, Objects and Values, Objects and Values, Glossary, Writing Modules, User-Defined Types, User-Defined Types, Rectangles, Objects Are Mutable, Copying, Glossary, Glossary, Exercises, Printing Objects, Exercises, Menus and Callables, Binding, Function and Class Objects, Function and Class Objects
Callable, Menus and Callables
Canvas, Exercises
class, User-Defined Types, Glossary, Function and Class Objects
copying, Copying
embedded, Rectangles, Glossary, Exercises
Event, Binding
file, Reading Word Lists, Glossary
function, Adding New Functions, Exercises, Function and Class Objects
module, Writing Modules
mutable, Objects Are Mutable
printing, Printing Objects
object code, The Python Programming Language, Glossary
object diagram, Attributes, Rectangles, Copying, Glossary, Time, Class Attributes, Lumpy, Object Diagrams
object-oriented design, Interface and Implementation
object-oriented language, Glossary
object-oriented programming, Object-Oriented Features, Glossary, Inheritance
octal, Variables
odometer, Exercises
Olin College, The Strange History of This Book
open function, Reading Word Lists, Reading Word Lists, Reading and Writing, Catching Exceptions, Databases
operand, Operators and Operands, Glossary
operator, Operators and Operands, String Operations, Glossary, Modulus Operator, Boolean Expressions, Boolean Expressions, Logical Operators, Logical Operators, Logical Operators, Logical Operators, Glossary, A String Is a Sequence, String Slices, The in Operator, The in Operator, Exercises, Lists Are Mutable, Lists Are Mutable, List Slices, Map, Filter, and Reduce, Deleting Elements, Objects and Values, List Arguments, Dictionaries, Tuples Are Immutable, Tuples Are Immutable, Format Operator, Glossary, Copying, Glossary, Comparing Cards, When I Run the Program, I Get an Exception
and, Logical Operators
bitwise, Operators and Operands
boolean, The in Operator
bracket, A String Is a Sequence, Lists Are Mutable, Tuples Are Immutable
del, Deleting Elements
format, Format Operator, Glossary, When I Run the Program, I Get an Exception
in, The in Operator, Lists Are Mutable, Dictionaries
is, Objects and Values, Copying
logical, Boolean Expressions, Logical Operators
modulus, Modulus Operator, Glossary
not, Logical Operators
or, Logical Operators
overloading, Glossary
relational, Boolean Expressions, Comparing Cards
slice, String Slices, Exercises, List Slices, List Arguments, Tuples Are Immutable
string, String Operations
update, Map, Filter, and Reduce
operator overloading, Operator Overloading, Comparing Cards
operator, arithmetic, Operators and Operands
option, Buttons and Callbacks, Glossary
optional argument, String Methods, Lists and Strings, Reverse Lookup
optional parameter, Optional Parameters, The init Method
or operator, Logical Operators
order of growth, Order of Growth
order of operations, Order of Operations, Debugging, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect
os module, Filenames and Paths
other (parameter name), A More Complicated Example
OverflowError, Debugging
overloading, Glossary
override, Optional Parameters, Glossary, The init Method, Comparing Cards, Inheritance, Debugging

P

package, TurtleWorld
packing widgets, Packing Widgets, Glossary
palindrome, Exercises, Exercises, Looping with Indices, Exercises, Exercises
parameter, Parameters and Arguments, Variables and Parameters Are Local, Glossary, List Arguments, Variable-Length Argument Tuples, Optional Parameters, Printing Objects, A More Complicated Example, The init Method
gather, Variable-Length Argument Tuples
optional, Optional Parameters, The init Method
other, A More Complicated Example
self, Printing Objects
parent class, Inheritance, Inheritance, Glossary
parentheses, Syntax Errors, Order of Operations, Function Calls, Adding New Functions, Parameters and Arguments, Variables and Parameters Are Local, String Methods, Tuples Are Immutable, Inheritance
argument in, Function Calls
empty, Adding New Functions, String Methods
matching, Syntax Errors
overriding precedence, Order of Operations
parameters in, Parameters and Arguments, Variables and Parameters Are Local
parent class in, Inheritance
tuples in, Tuples Are Immutable
parse, Formal and Natural Languages, Glossary
pass statement, Conditional Execution
path, Filenames and Paths, Filenames and Paths, Filenames and Paths, Glossary
absolute, Filenames and Paths
relative, Filenames and Paths
pattern, Checking Types, Glossary, Searching, Debugging, Glossary, Search, Map, Filter, and Reduce, Map, Filter, and Reduce, Map, Filter, and Reduce, Glossary, Glossary, Glossary, Reverse Lookup, Tuple Assignment, Comparing Tuples, Comparing Tuples, Most Common Words
decorate-sort-undecorate, Comparing Tuples
DSU, Comparing Tuples, Most Common Words
filter, Map, Filter, and Reduce, Glossary
guardian, Checking Types, Glossary, Debugging
map, Map, Filter, and Reduce, Glossary
reduce, Map, Filter, and Reduce, Glossary
search, Searching, Glossary, Search, Reverse Lookup
swap, Tuple Assignment
pdb (Python debugger), When I Run the Program, I Get an Exception
PEMDAS, Order of Operations
permission, file, Catching Exceptions
persistence, Persistence, Glossary
pi, Math Functions, Exercises
pickle module, Persistence, Pickling
pickling, Pickling
pie, Exercises
PIL (Python Imaging Library), Exercises
pipe, Pipes
pixel coordinate, Binding
plain text, Reading Word Lists, Word Frequency Analysis, Exercises
planned development, Prototyping Versus Planning, Glossary
playing card, Anglo-American, Inheritance
poetry, Formal and Natural Languages
Point class, User-Defined Types, The init Method, Object Diagrams
point, mathematical, User-Defined Types
poker, Inheritance, Exercises
polygon function, Exercises
polymorphism, Polymorphism, Glossary, Debugging
pop method, Deleting Elements, Add, Remove, Shuffle, and Sort
popen function, Pipes
portability, The Python Programming Language, Glossary
postcondition, Debugging, Debugging, Debugging
pprint module, Debugging
practical analysis of algorithms, Order of Growth
precedence, Glossary, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect
precondition, Debugging, Glossary, Glossary, Debugging, Exercises, Debugging
prefix, Markov Analysis
pretty print, Debugging
print function, The First Program
print statement, The First Program, Glossary, The __str__ Method, I Added So Many Print Statements I Get Inundated with Output
problem recognition, Search, Looping with Indices, Glossary
problem solving, The Way of the Program, Glossary
profile module, Data Structures
program, What Is a Program?, Glossary
program testing, Debugging
programming language, The Python Programming Language
Project Gutenberg, Word Frequency Analysis
prompt, The Python Programming Language, Glossary, Keyboard Input
prose, Formal and Natural Languages
prototype and patch, Pure Functions, Prototyping Versus Planning, Glossary
pseudorandom, Random Numbers, Glossary
pure function, Pure Functions, Glossary
Puzzler, Exercises, Exercises, Exercises, Exercises, Exercises
Pythagorean theorem, Incremental Development
Python 3, The First Program, Operators and Operands, Keyboard Input, Long Integers, Lists and Tuples
Python debugger (pdb), When I Run the Program, I Get an Exception
Python Imaging Library (PIL), Exercises

Q

quadratic growth, Order of Growth
quotation mark, The First Program, Values and Types, Values and Types, Docstring, String Slices, Syntax Errors

R

radd method, Type-Based Dispatch
radian, Math Functions
radix sort, Analysis of Algorithms
rage, I’m Really, Really Stuck and I Need Help
raise statement, Reverse Lookup, Debugging
Ramanujan, Srinivasa, Exercises
randint function, Exercises, Random Numbers
random function, Comparing Tuples, Random Numbers
random module, Exercises, Comparing Tuples, Random Numbers, Add, Remove, Shuffle, and Sort
random number, Random Numbers
random text, Markov Analysis
random walk programming, Debugging, I’m Really, Really Stuck and I Need Help
rank, Card Objects
raw_input function, Keyboard Input
read method, Pipes
readline method, Reading Word Lists, Pipes
Rectangle class, Rectangles, Object Diagrams
recursion, Recursion, Recursion, Stack Diagrams for Recursive Functions, Infinite Recursion, Glossary, More Recursion, Leap of Faith, Checking Types, Infinite recursion, Stack Diagram
base case, Stack Diagrams for Recursive Functions
infinite, Infinite Recursion, Checking Types, Infinite recursion
recursive definition, More Recursion, Exercises
red-black tree, Hashtables
reduce pattern, Map, Filter, and Reduce, Glossary
reducible word, Exercises, Exercises
redundancy, Formal and Natural Languages
refactoring, Refactoring, Refactoring, Glossary, Data Encapsulation
reference, Aliasing, Aliasing, List Arguments, Glossary
aliasing, Aliasing
rehashing, Hashtables
relational operator, Boolean Expressions, Comparing Cards
relative path, Filenames and Paths, Glossary
reload function, Writing Modules, I Keep Making Changes and It Makes No Difference
remove method, Deleting Elements
repetition, Simple Repetition, List Operations
list, List Operations
replace method, Word Frequency Analysis
repr function, Debugging
representation, User-Defined Types, Rectangles, Card Objects
return statement, Recursion, Return Values, I’ve Got a Function or Method That Doesn’t Return What I Expect
return value, Function Calls, Glossary, Return Values, Tuples as Return Values, Instances as Return Values
tuple, Tuples as Return Values
reverse lookup, dictionary, Reverse Lookup, Glossary
reverse word pair, Exercises
reversed function, Sequences of Sequences
rotation, Exercises
letters, Exercises
rotation, letter, Exercises
RSA algorithm, Long Integers
rules of precedence, Order of Operations, Glossary
running pace, Exercises, Exercises, Exercises
runtime error, Runtime Errors, Debugging, Infinite Recursion, Debugging, Debugging, When I Run the Program, I Get an Exception
RuntimeError, Infinite Recursion, Checking Types

S

safe language, Runtime Errors
sanity check, Debugging
scaffolding, Incremental Development, Glossary, Debugging
scatter, Variable-Length Argument Tuples, Glossary
Schmidt, Eric, Analysis of Algorithms
Scrabble, Exercises
script, The Python Programming Language, Glossary
script mode, The Python Programming Language, Glossary, Interactive Mode and Script Mode, Fruitful Functions and Void Functions
search, Reverse Lookup, Analysis of Search Algorithms
search pattern, Searching, Glossary, Search
search, binary, Exercises
search, bisection, Exercises
secret exercise, Exercises
self (parameter name), Printing Objects
semantic error, Semantic Errors, Glossary, Values and Types, Debugging, Debugging, Debugging, Semantic Errors
semantics, Semantic Errors, Glossary, Object-Oriented Features
sequence, A String Is a Sequence, Glossary, A List Is a Sequence, Lists and Strings, Tuples Are Immutable, Sequences of Sequences, Coordinate Sequences
coordinate, Coordinate Sequences
set, Exercises, Dictionary Subtraction, Pickling
anagram, Exercises, Pickling
set membership, Dictionaries
setdefault method, Dictionaries and Lists
sexagesimal, Prototyping Versus Planning
shallow copy, Copying, Glossary, Object Diagrams
shape, Glossary
shape error, Debugging
shell, Pipes
shelve module, Pickling
shuffle function, Add, Remove, Shuffle, and Sort
SimpleTurtleWorld class, Packing Widgets
sine function, Math Functions
singleton, Dictionaries and Lists, Glossary, Tuples Are Immutable
slice, String Slices, String Slices, Glossary, List Slices, List Slices, List Slices, Tuples Are Immutable
copy, String Slices, List Slices
list, List Slices
string, String Slices
tuple, Tuples Are Immutable
update, List Slices
slice operator, String Slices, Exercises, List Slices, List Arguments, Tuples Are Immutable
sort method, List Methods, Debugging, Comparing Tuples, Add, Remove, Shuffle, and Sort
sorted function, Sequences of Sequences
sorting, Analysis of Basic Python Operations, Analysis of Basic Python Operations
source code, The Python Programming Language, Glossary
special case, Debugging, Glossary, Modifiers
special value, Fruitful Functions and Void Functions, Boolean Expressions, Boolean Expressions, Return Values, Glossary, List Methods, Deleting Elements
False, Boolean Expressions
None, Fruitful Functions and Void Functions, Return Values, Glossary, List Methods, Deleting Elements
True, Boolean Expressions
spiral, Exercises
split method, Lists and Strings, Tuple Assignment
sqrt, Incremental Development
sqrt function, Math Functions
square root, Square Roots
squiggly bracket, Dictionaries
stable sort, Analysis of Basic Python Operations
stack diagram, Stack Diagrams, Stack Diagrams, Glossary, Exercises, Stack Diagrams for Recursive Functions, More Recursion, Exercises, List Arguments, Lumpy, Stack Diagram
state diagram, Variables, Glossary, Multiple Assignment, Debugging, Lists Are Mutable, Objects and Values, Aliasing, Dictionaries and Lists, Dictionaries and Tuples, Attributes, Rectangles, Copying, Time, Class Attributes, Lumpy, State Diagram
statement, The First Program, Glossary, Variables, Glossary, Glossary, TurtleWorld, Simple Repetition, Conditional Execution, Conditional Execution, Conditional Execution, Conditional Execution, Recursion, Glossary, Return Values, Boolean Functions, Multiple Assignment, The while Statement, break, Traversal with a for Loop, Traversing a List, Reverse Lookup, Global Variables, Catching Exceptions, Writing Modules, Debugging, Debugging, The __str__ Method, I Added So Many Print Statements I Get Inundated with Output, I’ve Got a Function or Method That Doesn’t Return What I Expect
assert, Debugging
assignment, Variables, Multiple Assignment
break, break
compound, Conditional Execution
conditional, Conditional Execution, Glossary, Boolean Functions
for, Simple Repetition, Traversal with a for Loop, Traversing a List
global, Global Variables
if, Conditional Execution
import, Glossary, TurtleWorld, Writing Modules
pass, Conditional Execution
print, The First Program, Glossary, The __str__ Method, I Added So Many Print Statements I Get Inundated with Output
raise, Reverse Lookup, Debugging
return, Recursion, Return Values, I’ve Got a Function or Method That Doesn’t Return What I Expect
try, Catching Exceptions
while, The while Statement
step size, Exercises
str function, Type Conversion Functions
__str__ method, The __str__ Method, Printing the Deck
string, Values and Types, String Operations, Glossary, Docstring, Docstring, String Slices, Strings Are Immutable, String Methods, String Comparison, Lists and Strings, Lists and Strings, Sequences of Sequences, Printing the Deck, Syntax Errors
accumulator, Printing the Deck
comparison, String Comparison
empty, Lists and Strings
immutable, Strings Are Immutable
method, String Methods
multiline, Docstring, Syntax Errors
operation, String Operations
slice, String Slices
triple-quoted, Docstring
string concatenation, Analysis of Basic Python Operations
string method, String Methods
string methods, Analysis of Basic Python Operations
string module, Word Frequency Analysis
string representation, Debugging, The __str__ Method
string type, Values and Types
strip method, Reading Word Lists, Word Frequency Analysis
structshape module, Debugging
structure, Formal and Natural Languages
subclass, Inheritance
subject, Printing Objects, Glossary, Packing Widgets
subtraction, Algorithms, Dictionary Subtraction
dictionary, Dictionary Subtraction
with borrowing, Algorithms
subtraction with borrowing, Prototyping Versus Planning
suffix, Markov Analysis
suit, Card Objects
sum function, Variable-Length Argument Tuples
superclass, Inheritance
superstitious debugging, I’m Really, Really Stuck and I Need Help
SVG, Exercises
Swampy, TurtleWorld, Exercises, Exercises, GUI, Lumpy
swap pattern, Tuple Assignment
syntax, Syntax Errors, Syntax Errors, Glossary, Object-Oriented Features, Syntax Errors
syntax error, Syntax Errors, Glossary, Debugging, Debugging
SyntaxError, Composition

T

Tagger, Exercises
temporary variable, Return Values, Glossary, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect
test case, minimal, I Added So Many Print Statements I Get Inundated with Output
testing, The Python Programming Language, Incremental Development, Incremental Development, Leap of Faith, Debugging, Debugging, I Added So Many Print Statements I Get Inundated with Output
and absence of bugs, Debugging
incremental development, Incremental Development
interactive mode, The Python Programming Language
is hard, Debugging
knowing the answer, Incremental Development
leap of faith, Leap of Faith
minimal test case, I Added So Many Print Statements I Get Inundated with Output
text, Reading Word Lists, Word Frequency Analysis, Markov Analysis, Exercises
plain, Reading Word Lists, Word Frequency Analysis, Exercises
random, Markov Analysis
text file, Glossary
Text widget, More Widgets
Time class, Time
time module, Exercises
Tkinter, GUI
token, Formal and Natural Languages, Glossary
traceback, Stack Diagrams, Glossary, Infinite Recursion, Debugging, Reverse Lookup, When I Run the Program, I Get an Exception
translate method, Word Frequency Analysis
traversal, Traversal with a for Loop, Traversal with a for Loop, Searching, Debugging, Glossary, Search, Search, Traversing a List, Map, Filter, and Reduce, Glossary, Dictionary as a Set of Counters, Looping and Dictionaries, Lists and Tuples, Lists and Tuples, Comparing Tuples, Word Histogram, Debugging
dictionary, Debugging
list, Traversing a List
traverse, Dictionaries and Tuples
dictionary, Dictionaries and Tuples
triangle, Exercises
trigonometric function, Math Functions
triple-quoted string, Docstring
True special value, Boolean Expressions
try statement, Catching Exceptions
tuple, Tuples Are Immutable, Tuples Are Immutable, Tuples Are Immutable, Tuple Assignment, Tuples as Return Values, Dictionaries and Tuples, Dictionaries and Tuples, Comparing Tuples, Sequences of Sequences, Glossary, Data Structures, Comparing Cards
as key in dictionary, Dictionaries and Tuples, Data Structures
assignment, Tuple Assignment
comparison, Comparing Tuples, Comparing Cards
in brackets, Dictionaries and Tuples
singleton, Tuples Are Immutable
slice, Tuples Are Immutable
tuple assignment, Tuples as Return Values, Lists and Tuples, Glossary
tuple function, Tuples Are Immutable
tuple methods, Analysis of Basic Python Operations
Turing complete language, More Recursion
Turing Thesis, More Recursion
Turing, Alan, More Recursion
turtle typewriter, Exercises
TurtleWorld, TurtleWorld, Exercises, Exercises
type, Values and Types, Values and Types, Values and Types, Values and Types, Values and Types, Glossary, Boolean Expressions, A List Is a Sequence, Dictionaries, Long Integers, Tuples Are Immutable, Dictionary Subtraction, Persistence, User-Defined Types, Time
bool, Boolean Expressions
dict, Dictionaries
file, Persistence
float, Values and Types
int, Values and Types
list, A List Is a Sequence
long, Long Integers
set, Dictionary Subtraction
str, Values and Types
tuple, Tuples Are Immutable
user-defined, User-Defined Types, Time
type checking, Checking Types
type conversion, Type Conversion Functions
type function, Debugging
type-based dispatch, Type-Based Dispatch, Polymorphism, Glossary
TypeError, A String Is a Sequence, Strings Are Immutable, Dictionaries and Lists, Tuples Are Immutable, Variable-Length Argument Tuples, Format Operator, Another Example, When I Run the Program, I Get an Exception
typewriter, turtle, Exercises
typographical error, Debugging

U

UML, Lumpy, Class Diagrams
unbounded, Order of Growth
UnboundLocalError, Global Variables
underscore character, Variable Names and Keywords
Unified Modeling Language, Lumpy
uniqueness, Exercises
Unix command, Pipes
ls, Pipes
update, Updating Variables, Square Roots, Glossary, Traversing a List, List Slices, Global Variables, Word Histogram, Databases, Binding
coordinate, Binding
database, Databases
global variable, Global Variables
histogram, Word Histogram
item, Traversing a List
slice, List Slices
update method, Dictionaries and Tuples
update operator, Map, Filter, and Reduce
URL, Exercises, Exercises
urllib module, Exercises, Exercises
use before def, Debugging, Definitions and Uses
user-defined type, User-Defined Types, Time

V

value, Values and Types, Glossary, Objects and Values, Objects and Values, Glossary, Tuples as Return Values, Optional Parameters
default, Optional Parameters
tuple, Tuples as Return Values
ValueError, Keyboard Input, Reverse Lookup, Tuple Assignment
values method, Dictionaries
variable, Variables, Glossary, Variables and Parameters Are Local, Return Values, Glossary, Updating Variables, Global Variables, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect, State Diagram, State Diagram
global, Global Variables, State Diagram
local, Variables and Parameters Are Local
module-level, State Diagram
temporary, Return Values, Glossary, I’ve Got a Big Hairy Expression and It Doesn’t Do What I Expect
updating, Updating Variables
variable-length argument tuple, Variable-Length Argument Tuples
vector graphics, Exercises
veneer, Add, Remove, Shuffle, and Sort, Glossary
Visual module, Exercises
void function, Fruitful Functions and Void Functions, Glossary
void method, List Methods
vorpal, More Recursion
vpython module, Exercises

W

walk, directory, Filenames and Paths
while loop, The while Statement
whitespace, Debugging, Debugging, Reading Word Lists, Debugging, Syntax Errors
widget, GUI, Buttons and Callbacks, Buttons and Callbacks, Canvas Widgets, More Widgets, More Widgets, Packing Widgets, Menus and Callables, Glossary
Button, Buttons and Callbacks
Canvas, Canvas Widgets
Entry, More Widgets
Frame, Packing Widgets
Label, Buttons and Callbacks
Menubutton, Menus and Callables
Text, More Widgets
widget, packing, Packing Widgets
word count, Writing Modules
word frequency, Word Frequency Analysis, Exercises
word, reducible, Exercises, Exercises
working directory, Filenames and Paths
World module, Exercises
worst bug, Exercises, Exercises
ever, Exercises
worst case, Analysis of Algorithms

Z

zero, index starting at, A String Is a Sequence, Lists Are Mutable
zip function, Lists and Tuples, Dictionaries and Tuples
use with dict, Dictionaries and Tuples
Zipf’s law, Exercises
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.220.120.161