(Ebook) Programming and Mathematical Thinking: A Gentle Introduction To Discrete Math Featuring Python by Allan M. Stavely ISBN 9781938159008, 9781938159015, 1938159004, 1938159012 Download
(Ebook) Programming and Mathematical Thinking: A Gentle Introduction To Discrete Math Featuring Python by Allan M. Stavely ISBN 9781938159008, 9781938159015, 1938159004, 1938159012 Download
https://ebooknice.com/product/biota-grow-2c-gather-2c-cook-6661374
https://ebooknice.com/product/sat-ii-success-
math-1c-and-2c-2002-peterson-s-sat-ii-success-1722018
(Ebook) Master SAT II Math 1c and 2c 4th ed (Arco Master the SAT
Subject Test: Math Levels 1 & 2) by Arco ISBN 9780768923049,
0768923042
https://ebooknice.com/product/master-sat-ii-math-1c-and-2c-4th-ed-
arco-master-the-sat-subject-test-math-levels-1-2-2326094
https://ebooknice.com/product/matematik-5000-kurs-2c-larobok-23848312
(Ebook) Cambridge IGCSE and O Level History Workbook 2C - Depth Study:
the United States, 1919-41 2nd Edition by Benjamin Harrison ISBN
9781398375147, 9781398375048, 1398375144, 1398375047
https://ebooknice.com/product/cambridge-igcse-and-o-level-history-
workbook-2c-depth-study-the-united-states-1919-41-2nd-edition-53538044
https://ebooknice.com/product/programming-for-computations-python-a-
gentle-introduction-to-numerical-simulations-with-python-3-6-10556354
https://ebooknice.com/product/math-2001-introduction-to-discrete-
mathematics-10544556
https://ebooknice.com/product/python-programming-an-introduction-to-
computer-science-7343896
https://ebooknice.com/product/python-for-the-life-sciences-a-gentle-
introduction-to-python-for-life-scientists-43425662
Programming and Mathematical
Thinking
A Gentle Introduction to Discrete Math
Featuring Python
Allan M. Stavely
First Edition
Content of this book available under the Creative Commons Attribution-Noncommercial-ShareAlike License. See
http://creativecommons.org/licenses/by-nc-sa/4.0/ for details.
Stavely, Allan M
Programming and mathematical thinking: a gentle introduction to discrete
math featuring Python / Allan M. Stavely.
xii, 246 p.: ill. ; 28 cm
ISBN 978-1-938159-00-8 (pbk.) — 978-1-938159-01-5 (ebook)
1. Computer science — Mathematics. 2. Mathematics — Discrete
Mathematics. 3. Python (Computer program language).
Published by The New Mexico Tech Press, a New Mexico nonprofit corporation
i
ii
Table of Contents
Preface ........................................................................................................ vii
1. Introduction ............................................................................................. 1
1.1. Programs, data, and mathematical objects ..................................... 1
1.2. A first look at Python .................................................................... 3
1.3. A little mathematical terminology ................................................ 10
2. An overview of Python ........................................................................... 17
2.1. Introduction ................................................................................. 17
2.2. Values, types, and names ............................................................. 18
2.3. Integers ........................................................................................ 19
2.4. Floating-point numbers ................................................................ 23
2.5. Strings .......................................................................................... 25
3. Python programs .................................................................................... 29
3.1. Statements ................................................................................... 29
3.2. Conditionals ................................................................................ 31
3.3. Iterations ..................................................................................... 35
4. Python functions ..................................................................................... 41
4.1. Function definitions ..................................................................... 41
4.2. Recursive functions ...................................................................... 43
4.3. Functions as values ...................................................................... 45
4.4. Lambda expressions ..................................................................... 48
5. Tuples ..................................................................................................... 51
5.1. Ordered pairs and n-tuples .......................................................... 51
5.2. Tuples in Python .......................................................................... 52
5.3. Files and databases ...................................................................... 54
6. Sequences ............................................................................................... 57
6.1. Properties of sequences ................................................................ 57
6.2. Monoids ...................................................................................... 59
6.3. Sequences in Python ..................................................................... 64
6.4. Higher-order sequence functions .................................................. 67
6.5. Comprehensions .......................................................................... 73
6.6. Parallel processing ....................................................................... 74
7. Streams ................................................................................................... 83
7.1. Dynamically-generated sequences ................................................ 83
7.2. Generator functions ..................................................................... 85
iii
Programming and Mathematical Thinking
iv
List of Examples
1.1. Finding a name ...................................................................................... 4
1.2. Finding an email address ....................................................................... 7
1.3. Average of a collection of observations .................................................. 8
6.1. Finding a name again, in functional style ............................................. 71
6.2. Average of observations again, in functional style ................................ 72
7.1. Combinations using a generator function ............................................ 89
8.1. Finding job candidates using set operations ....................................... 117
8.2. Job candidates again, with different input files .................................. 122
9.1. Finding given words in a document ................................................... 139
9.2. A memoized function: the nth Fibonacci number ................................ 144
9.3. Number of students in each major field ............................................. 149
10.1. Distances using symmetry and reflexivity ......................................... 159
11.1. The MovingAverage class .................................................................. 191
11.2. The MovingAverage class, version 2 ................................................. 193
11.3. The Pushbutton class ....................................................................... 204
11.4. A state machine for finding fields in a string .................................... 206
11.5. Code that uses a FieldsStateMachine ............................................. 207
11.6. A state machine for finding fields, version 2 .................................... 209
v
vi
Preface
My mission in this book is to encourage programmers to think mathematically
as they develop programs.
1
This paragraph and the example that follows are adapted from a previous book: Allan M. Stavely,
Toward Zero-Defect Programming (Reading, Mass.: Addison Wesley Longman, 1999), 142–143.
vii
First I'll read the first web page and store all the URLs I find in a list.
Then I'll read the second web page and, every time I find a URL, search
the list for it. But wait: I don't want to include the same URL in my
result more than once. I'll keep a second list of the URLs that I've
already found in both web pages, and search that before I search the
list of URLs from the first web page.
The URLs in a web page are a set. I'll read each web page and build
up the set of URLs in each using set insertion. Then I can get the URLs
common to both web pages by using set intersection.
Either approach will work, but the second is conceptually simpler, and it will
probably be more straightforward to implement. In fact, once the problem is
described in mathematical terms, most of the design work is already done.
viii
programmers never learn, and we'll see how to use them to create simple and
elegant solutions to programming problems.
For example, one recurring theme in the book is the concept of a monoid. It
turns out that monoids (more than, for example, groups and semigroups) are
ubiquitous in the data types and data structures that programmers use most
often. I emphasize the extent to which all monoids behave alike and how
concepts and algorithms can be transferred from one to another.
Otherwise, the ideal reader is someone who has had at least some experience
with programming, using either Python or another programming language.
In fact, I hope that some of my readers will be quite experienced programmers
who may never have been through a modern, mathematically-oriented program
of study in computer science. If you are such a person, you'll see many ideas
that will probably be new to you and that will probably improve your
programming.
At the end of most chapters is a set of exercises. Instructors can use these
exercises in laboratory sessions or as homework exercises, and some can be
used as starting points for class discussions. Many instructors will want to
supplement these exercises with their own extended programming assignments.
ix
exception handling, parallel computing, distributed computing, various
advanced data structures and algorithms, object-oriented programming, and
state machines.
• the extensive standard library and the many other libraries that are
commonly available
x
• almost all “special” attributes and methods (those whose names start and
end with a double underbar) that expose internal details of objects
Any programmer who uses Python extensively should learn about all of these
features of the language. I recommend that such a person peruse a
comprehensive Python textbook or reference manual.2
In any case, there is more to Python than I present in this book. So whenever
you think to yourself, “I see I can do x with Python — can I do y too?”, maybe
you can. Again, you can find out in a Python textbook or reference manual.
This book will describe the most modern form of Python, called Python 3. It
may be that the version of Python that you have on your computer is a version
of Python 2, such as Python 2.3 or 2.7. There are only a few differences that
you may see as you use the features of Python mentioned in this book. Here
are the most important differences (for our purposes) between Python 3 and
Python 2.7, the final and most mature version of Python 2:
2
As of the time of writing, comprehensive Python documentation, including the official reference
manual, can be found at http://docs.python.org.
xi
• In Python 2, characters in a string are ASCII and not Unicode by default;
there is a separate Unicode type.
Versions of Python earlier than 2.7 have more incompatibilities than these:
check the documentation for the version you use.
In the chapters that follow I usually use the author's “we” for a first-person
pronoun, but I say “I” when I am expressing my personal opinion, speaking
of my own experiences, and so on. And I follow this British punctuation
convention: punctuation is placed inside quotation marks only if it is part of
what is being quoted. Besides being more logical (in my opinion), this treatment
avoids ambiguity. For example, here's how many American style guides tell
you to punctuate:
Is the “.” part of what you would write, or not? It can make a big difference,
as any programmer knows. There is no ambiguity this way:
I am grateful to all the friends and colleagues who have given me help,
suggestions, and support in this writing project, most prominently Lisa
Beinhoff, Horst Clausen, Jeff Havlena, Peter Henderson, Daryl Lee, Subhashish
Mazumdar, Angelica Perry, Steve Schaffer, John Shipman, and Steve Simpson.
3
Harold Abelson and Gerald Jay Sussman with Julie Sussman, Structure and Interpretation of Computer
Programs (Cambridge, Mass.: The MIT Press, 1985).
xii
Chapter 1
Introduction
1.1. Programs, data, and mathematical objects
A master programmer learns to think of programs and data at many levels of
detail at different times. Sometimes the appropriate level is bits and bytes and
machine words and machine instructions. Often, though, it is far more
productive to think and work with higher-level data objects and higher-level
program constructs.
Ultimately, at the lowest level, the program code that runs on our computers
is patterns of bits in machine words. In the early days of computing, all
programmers had to work with these machine-level instructions all the time.
Now almost all programmers, almost all the time, use higher-level
programming languages and are far more productive as a result.
The thesis of this book is that, very often, mathematical objects are exactly
the higher-level data objects we want. Some of these mathematical objects are
numbers, but many — the objects of discrete mathematics — are quite different,
as we will see.
So this book will present programming as done at a high level and with a
mathematical slant. Here's how we will view programs and data:
Programs will be text, in a form (which we call “syntax”) that does not look
much like sequences of machine instructions. On the contrary, our programs
will be in a higher-level programming language, whose syntax is designed for
1
Programs, data, and mathematical objects
The data in our programs will reside in a computer's main storage (which we
often metaphorically call “memory”) that may look like a long sequence of
machine words, but most of the time we will not be concerned with exactly
how our data objects are represented there; the data objects will look like
mathematical objects from our point of view. We assume that the main storage
is quite large, usually large enough for all the data we might want to put into
it, although not infinite in size.
We will assume that what looks simple in a program is also reasonably simple
at the level of bits and bytes and machine instructions. There will be a
straightforward correspondence between the two levels; a computer science
student or master programmer will learn how to construct implementations
of the higher-level constructs from low-level components, but from other
books than this one. We will play fair; we will not present any program
construct that hides lengthy computations or a mass of complexity in its low-
level implementation. Thus we will be able to make occasional statements
about program efficiency that may not be very specific, but that will at least
be meaningful. And you can be assured that the programming techniques that
we present will be reasonable to use in practical programs.
2
A first look at Python
Python falls into several categories of programming language that you might
hear programmers talk about:
• It's a scripting language. This term doesn't have a precise definition, but
generally it means a language that lends itself to writing little programs
called scripts, perhaps using the kinds of commands that you might type
into a command-line window on a typical computer system. For example,
some scripts are programs that someone writes on the spur of the moment
to do simple manipulations on files or to extract data from them. Some
scripts control other programs, and system administrators often use scripting
languages to combine different functions of a computer's operating system
to perform a task. We'll see examples of Python scripts shortly. (Other
scripting languages that you might encounter are Perl and Ruby.)
• It's a very high-level language, or at least it has been called that. This is
another concept that doesn't have a precise definition, but in the case of
Python it means that mathematical objects are built into the core of the
language, more so than in most other programming languages. Furthermore,
in many cases we'll be able to work with these objects in notation that
3
A first look at Python
Depending on how you use it, Python can be a language of any of these kinds
or all of them at once.
Let's look at a few simple Python programs, to give you some idea of what
Python looks like.
The first program is the kind of very short script that a Python programmer
might write to use just once and then discard. Let's say that you have just
attended a lecture, and you met someone named John, but you can't remember
his last name. Fortunately, the lecturer has a file of the names of all the
attendees and has made that file available to you. Let's say that you have put
that file on your computer and called it “names”. There are several hundred
names in the file, so you'd like to have the computer do the searching for you.
Example 1.1 shows a Python script that will display all the lines of the file
that start with the letters “John”.
You may be able to guess (and guess correctly) what most of the parts of this
script do, especially if you have done any programming in another
programming language, but I'll explain the script a line at a time. Let's not
bother with the fine points, such as what the different punctuation marks
mean in Python; you'll learn all that later. For now, I'll just explain each line
in very general terms.
file = open("names")
4
A first look at Python
This line performs an operation called “opening” a file on our computer. It's
a rather complicated sequence of operations, but the general idea is this: get
a file named “names” from our computer's file system and make it available
for our program to read from. We give the name file to the result.
Here and in the other examples in this book, we won't worry about what
might happen if the open operation fails: for example, if there is no file with
the given name, or if the file can't be read for some reason. Serious Python
programmers need to learn about the features of Python that are used for
handling situations like these, and need to include code for handling
exceptional situations in most programs that do serious work.1 In a simple
one-time script like this one, though, a Python programmer probably wouldn't
bother. In any case, we'll omit all such code in our examples, simply because
that code would only distract from the points that we are trying to make.
for line in file:
This means, “For each line in file, do what comes next.” More precisely, it
means this: take each line of file, one at a time. Each time, give that line the
name line, and then do the lines of the program that come next, the lines that
are indented.
if line.startswith("John"):
This means what it appears to mean: if line starts with the letters “John”, do
what comes next.
print(line)
Since the line of the file starts with “John”, it's one that we want to see, and
this is what displays the line. On most computers, we can run the program in
a window on our computer's screen, and print will display its results in that
window.
1
The term for such code is “exception handling”, in case you want to look up the topic in Python
documentation. Handling exceptions properly can be complicated, sometimes involving difficult design
decisions, which is why we choose to treat the topic as beyond the scope of the current book.
5
A first look at Python
If you run the program, here's what you might see (depending, of course, on
what is in the file names).
John Atencio
John Atkins
Johnson Cummings
John Davis
John Hammerstein
And so on. This is pretty much as you might expect, although there may be
a couple of surprises here. Why is this output double-spaced? Well, it turns
out that each line of the file ends with a “new line” character, and the print
operation adds another. (As you learn more details of Python, you'll probably
learn how to make output like this come out single-spaced if that's what you'd
prefer.) And why is there one person here with the first name “Johnson”
instead of “John”? That shouldn't be a surprise, since our simple little program
doesn't really find first names in a line: it just looks for lines in which the first
four letters are “John”. Anyway, this output is probably good enough for a
script that you're only going to use once, especially if it reminds you that the
person you were thinking of is John Davis.
Now let's say that you'd like to get in touch with John Davis. Your luck
continues: the lecturer has provided another file containing the names and
email addresses of all the attendees. Each line of the file contains a person's
name and that person's email address, separated by a comma.
Suppose you transfer that file to your computer and give it the name “emails”.
Then Example 1.2 shows a Python script that will find and display John
Davis's email address if it's in the file.
6
Exploring the Variety of Random
Documents with Different Content
THE ADVENTURES OF ROBINSON CRUSOE.
70 illustrations.
ALICE’S ADVENTURES IN WONDERLAND.
42 illustrations.
THROUGH THE LOOKING GLASS AND
WHAT ALICE FOUND THERE. 50
illustrations.
BUNYAN’S PILGRIM’S PROGRESS. 46
illustrations.
A CHILD’S STORY OF THE BIBLE. 72
illustrations.
A CHILD’S LIFE OF CHRIST. 49 illustrations.
ÆSOP’S FABLES. 62 illustrations.
SWISS FAMILY ROBINSON. 50 illustrations.
EXPLORATION AND ADVENTURE IN
AFRICA. 80 illustrations.
GULLIVER’S TRAVELS. 50 illustrations.
MOTHER GOOSE’S RHYMES, JINGLES AND
FAIRY TALES. 234 illustrations.
THE STORY OF THE FROZEN SEAS. 70
illustrations.
WOOD’S NATURAL HISTORY. 80
illustrations.
BLACK BEAUTY. By Anna Sewell. 50
illustrations.
ARABIAN NIGHTS’ ENTERTAINMENTS. 130
illustrations.
ANDERSEN’S FAIRY TALES. 75 illustrations.
GRIMM’S FAIRY TALES. 50 Illustrations.
FLOWER FABLES. By Louisa M. Alcott. 50
illustrations.
AUNT MARTHA’S CORNER CUPBOARD. By
Mary and Elizabeth Kirby. 54
illustrations.
WATER BABIES. By Charles Kingsley. 84
illustrations.
UNCLE TOM’S CABIN. 90 illustrations.
TALES FROM SHAKESPEARE. By Charles
and Mary Lamb. 65 illustrations.
ADVENTURES IN TOYLAND. 70 illustrations.
ADVENTURES OF A BROWNIE. 18
illustrations.
MIXED PICKLES. 31 illustrations.
LITTLE LAME PRINCE. By Miss Mulock. 24
illustrations.
THE SLEEPY KING. 77 illustrations.
RIP VAN WINKLE. By Washington Irving. 46
illustrations.
A CHILD’S GARDEN OF VERSES. By Robert
Louis Stevenson. 100 illustrations.
ANIMAL STORIES FOR LITTLE PEOPLE. 50
illustrations.
ALTEMUS’
Stories from History Series
A series of stories from history which every
boy and girl should know. No library
is complete without these valuable
contributions to juvenile literature.
Profusely illustrated. Bound in cloth with
illuminated covers, 50 cents each.
ROMULUS, THE FOUNDER OF ROME. By
Jacob Abbott, 49 illustrations.
CYRUS THE GREAT, THE FOUNDER OF THE
PERSIAN EMPIRE. By Jacob Abbott.
40 illustrations.
DARIUS THE GREAT, KING OF THE MEDES
AND PERSIANS. By Jacob Abbott. 34
illustrations.
XERXES THE GREAT, KING OF PERSIA. By
Jacob Abbott. 39 illustrations.
ALEXANDER THE GREAT, KING OF
MACEDON. By Jacob Abbott. 51
illustrations.
PYRRHUS, KING OF EPIRUS. By Jacob
Abbott. 45 illustrations.
HANNIBAL, THE CARTHAGINIAN. By Jacob
Abbott. 37 illustrations.
JULIUS CÆSAR, THE ROMAN CONQUEROR.
By Jacob Abbott. 44 illustrations.
DICKENS’ CHILD’S HISTORY OF ENGLAND.
80 illustrations.
ALFRED THE GREAT, OF ENGLAND. By
Jacob Abbott. 40 illustrations.
WILLIAM THE CONQUEROR, OF ENGLAND.
By Jacob Abbott. 43 illustrations.
CHRISTOPHER COLUMBUS AND THE
DISCOVERY OF AMERICA. 70
illustrations.
HERNANDO CORTEZ, THE CONQUEROR OF
MEXICO. By Jacob Abbott. 30
illustrations.
QUEEN ELIZABETH, OF ENGLAND. By Jacob
Abbott. 49 illustrations.
MARY, QUEEN OF SCOTS. By Jacob Abbott.
45 illustrations.
GRANDFATHER’S CHAIR. By Nathaniel
Hawthorne. 68 illustrations.
KING CHARLES THE FIRST, OF ENGLAND.
By Jacob Abbott. 41 illustrations.
KING CHARLES THE SECOND, OF
ENGLAND. By Jacob Abbott. 28
illustrations.
MADAME ROLAND, A HEROINE OF THE
FRENCH REVOLUTION. By Jacob
Abbott. 42 illustrations.
MARIE ANTOINETTE, QUEEN OF FRANCE.
By John S. C. Abbott. 41 illustrations.
JOSEPHINE, EMPRESS OF FRANCE. By
Jacob Abbott. 40 illustrations.
BATTLES OF THE WAR FOR
INDEPENDENCE, By Prescott
Holmes. 70 illustrations.
MILITARY HEROES OF THE UNITED
STATES. 60 illustrations.
HEROES OF THE UNITED STATES NAVY. 60
illustrations.
LIVES OF THE PRESIDENTS OF THE
UNITED STATES. With portraits and
illustrations.
BATTLES OF THE WAR FOR THE UNION. By
Prescott Holmes. 80 illustrations.
YOUNG PEOPLE’S HISTORY OF THE WAR
WITH SPAIN. 50 illustrations.
Altemus’ Illustrated
Mother Goose Series
A series of entirely new editions of the most
popular books for young people.
Handsomely printed from large, clear
type, on choice paper; each volume
containing about one hundred
illustrations. Half vellum, with
illuminated sides (6⅞ × 8¾ inches).
Price, 50 cents each.
Aladdin; or, The Wonderful Lamp.—Our Animal
Friends.—Beauty and the Beast.—Bird
Stories for Little People.—Cinderella;
or, The Little Glass Slipper.—The
House that Jack Built.—Jack and the
Bean-Stalk.—Jack the Giant-Killer.—
Little Red Riding Hood.—Puss in Boots.
—The Sleeping Beauty.—Who Killed
Cock Robin?
Altemus’ Illustrated
Little Men and Women Series
A new series for young people, by the best
known English and American
authors. Profusely illustrated, and
with handsome and appropriate
bindings. Cloth, 12mo. Price, 50 cts.
each.
Altemus’ Illustrated
Wee Books for Wee Folks
Filled with charming stories, beautifully
illustrated with pictures in colors and
black and white. Daintily, yet durably
bound. Price, 50 cents each.
Nursery Tales.—Nursery Rhymes.—The Story
of Peter Rabbit.—The Foolish Fox.—
Three Little Pigs.—The Robber Kitten.
One-Syllable Series
For Young Readers
Embracing popular works arranged for the
young folks in words of one syllable.
With numerous illustrations by the
best artists. Handsomely bound, with
illuminated covers. Price, 50 cents
each.
Æsop’s Fables.—A Child’s Life of Christ.—The
Adventures of Robinson Crusoe.—
Bunyan’s Pilgrim’s Progress.—Swiss
Family Robinson.—Gulliver’s Travels.—
A Child’s Story of the Old Testament.—
A Child’s Story of the New Testament.—
Bible Stories for Little Children.—The
Story of Jesus.
Altemus’ Illustrated
Dainty Series of Choice Gift Books
Bound in half-white vellum, illuminated sides,
unique designs in gold and colors, with
numerous half-tone illustrations. Price, 50
cents each.
Altemus’
Young Folks Puzzle Pictures’ Series
A new series for young people, including
numerous Puzzle Pictures by the best
artists. Full cloth, illuminated cover design.
Price, 50 cents each.
Annapolis Series
By H. IRVING HANCOCK
The principal characters in these narratives are manly,
young in these volumes.
Transcriber’s Notes:
Obvious punctuation errors repaired.
Page 15, “canot” changed to “cannot” (cannot
think of God)
Page 49, “dressinig” changed to “dressing” (babe
a-dressing)
Page 64, repeated word “been” removed from
text (has been very naughty)
Page 69, “arisinig” changed to “arising” (the maid
arising)
Page 88, “wil” changed to “will” (I will show you
where)
Page 119, “the” changed to “they” (they saw the
angels)
Page 124, “crucifid” changed to “crucified”
(crucified to save men)
Page 145, repeated word “to” removed from text
(Singing to harps of)
Page 148, “prasing” changed to “praising”
(praising him for having)
*** END OF THE PROJECT GUTENBERG EBOOK THE PEEP OF DAY
***
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
ebooknice.com