Head First Learn To Code A Learner's Guide Coding And Computational Thinking

Head%20First%20Learn%20to%20Code%20-%20A%20Learner's%20Guide%20to%20Coding%20and%20Computational%20Thinking

User Manual: Pdf

Open the PDF directly: View PDF .
Page Count: 641 [warning: Documents this large are best viewed by clicking the View PDF Link!]

Praise
Copyright
Table of Contents
Intro: How to use this book
Chapter 1: Getting Started: Thinking computationally
Chapter 2: Know Your Value: Simple values, variables, and types
Chapter 3: Decisive Code: Booleans, decisions, and loops
Chapter 4: Providing Some Structure: Lists and iteration
Chapter 5: Getting Functional: Functions and abstraction
Chapter 4, part 2: Putting Some Order in Your Data: Sorting and nested iteration
Chapter 6: Putting It All Together: Text, strings, and heuristics
Chapter 7: Getting Modular: Modules, methods, classes, and objects
Chapter 8: Beyond Iteration and Indices: Recursion and dictionaries
Chapter 9: Persistence: Saving and retrieving files
Chapter 10: You Really Should Get Out More: Using web APIs
Chapter 11: Getting Interactive: Widgets, events, and emergent behavior
Chapter 12: A Trip to Objectville: Object-oriented programming
Appendix: The Top Ten Topics (We Didn't Cover): Leftovers
Index

Elisabeth Robson & Eric Freeman

Launch your

programming

career in

one chapter

A learner’s guide

to coding and

computational

thinking

Avoid embarrassing

syntax errors

Learn why everything

your friends know about

computer science is

probably wrong

Watch out for

common traps

and pitfalls

Head First

Bend your mind

around 130 puzzles

& exercises

Learn to Code

Eric Freeman

A Brain-Friendly Guide

Praise for

Head First Learn to Code

“This is one of the most surprising, entertaining and brilliantly-planned software books I’ve ever read.

It’s more interesting and better thought-out than all other beginning programming books I know put

together. I run into people all the time who need to learn programming and want to know what course

to take; I plan to tell them to forget about courses and get this book instead.”

— David Gelernter, Professor of Computer Science, Yale University

“Head First Learn to Code has humor, emotions, and step by step instructions. This book turns on your

brain, makes you laugh and teaches you to be a code master—it’s a keeper.”

— Smore Magazine, a science magazine to know more and be more

“The book is a great read, even for an experienced programmer, with new perspectives on how to teach

difﬁcult concepts we take for granted. Whether your just starting out or trying to ﬁgure out ways to

bring more people to code, this book will serve you well. Eric has made learning to code accessible and

approachable without dumbing anything down and setting the expectations of effort and difﬁculty that

actually exist.”

— Avi Flombaum, Dean and Chief Product Ocer of the Flatiron School

“As a high school computer science teacher, Head First Learn to Code is my new primary resource for

introducing topics to students. It has an immensely personal touch and its conversational nature, humor,

and general style make it feel as if you are learning from another human rather than merely reading a

piece of text.”

— Brandon Shuebarger, Regents School of Austin

“This is the book I wish would have been around when I ﬁrst started learning to code. Unlike other beginner’s

programming books, Freeman strikes a perfect balance of humor, concise tutorials, and helpful background

information—without sounding condescending or overly technical. Head First Learn to Code will certainly be a

valuable resource for beginning coders at our school fablab.”

— Patrick Beneld, Innovation Director, The Magellan International School

“It takes talent and creativity to write in such an accessible manner. I am looking forward to using the

book next school year in an introductory course. I became enthralled with the relevant and accessible

examples that were substantive rather than the typical irrelevant and superﬁcial examples presented to

the reader of a typical text on the subject.”

— Josh Sharfman, Teacher, Shalhevet Advanced Studies, Computer Science

“In keeping with a book about a language named for Monty Python, there’s a lot of meta-humor here

about the software industry, about programmer culture, and about tutorial books themselves. It’s nice to be

reminded that coding takes place in the (sometimes illogical) world of humans.”

— Adjunct Professor of Music Technology at NYU

and Montclair State University

Praise for other books by Eric Freeman

“I feel like a thousand pounds of books have just been lifted off of my head.”

— Ward Cunningham, inventor of the Wiki

“The admirable clarity, humor and substantial doses of clever make it the sort of book that helps even

non-programmers think well about problem-solving.”

— Cory Doctorow, co-editor of Boing Boing, Science Fiction author

“Freeman continues to use innovative teaching methods for communicating complex concepts to basic

principles.”

— Mark Arana, Strategy & Innovation, The Walt Disney Studios

“I can think of no better tour guide than Eric.”

— Miko Matsumura, VP of Marketing and Developer Relations at Hazelcast

Former Chief Java Evangelist, Sun Microsystems

“The definitive book on HTML5 for everyone from beginners to experienced developers.”

— Aaron LaBerge, CTO, ESPN

“The highly graphic and incremental approach precisely mimics the best way to learn this stuff...”

— Danny Goodman, author of Dynamic HTML: The Denitive Guide

“Eric clearly knows his stuff. As the Internet becomes more complex, inspired construction of web pages

becomes increasingly critical. Elegant design is at the core of every chapter here, each concept conveyed

with equal doses of pragmatism and wit.”

— Ken Goldstein, former CEO of Shop.com and author of

This is Rage: A Novel of Silicon Valley and Other Madness

“As a National Champion Rock Band Coach, I understand that students must feel inspired by a subject

in order to consistently practice and enjoy themselves in the process. Without inspiration and joy, people

eventually lose focus and enthusiasm. That’s why good teachers are so valuable to our society. They

can break a potentially boring complex subject, like learning code, down into easily digestible, delicious

nuggets of fun. As and educator, Eric Freeman is masterful. He shows us how learning can be simple,

enjoyable and easily retainable.”

— James Mays, Director, Band Aid School of Music

“HFL2C is a pleasurable, entertaining and eective way to learn computational thinking and python

basics. The book has strong pedagogical underpinnings, an exciting array of learning activities

and is well written in a fun and conversational tone that is approachable and breaks down complex

computational concepts in an easy, digestible way.”

— Troy Welch, Coordinator, Innovations, Thompson Rivers University

Make it Stick

Other O’Reilly books by Eric Freeman

Head First HTML and CSS

Head First JavaScript Programming

Head First HTML5 Programming

Head First Design Patterns

Other books in O’Reilly’s Head First series

Head First HTML and CSS

Head First JavaScript Programming

Head First HTML5 Programming

Head First Design Patterns

Head First Servlets and JSP

Head First Java

Head First Python

Eric Freeman

Head First

Learn to Code

Wouldn’t it be dreamy if there was

a book for learning to code that was

more fun than going to the dentist and

more revealing than an IRS form? It’s

probably just a fantasy...

Boston

Head First Learn to Code

by Eric Freeman

Printed in the United States of America.

Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.

O’Reilly Media books may be purchased for educational, business, or sales promotional use. Online editions are

also available for most titles (http://oreilly.com/safari). For more information, contact our corporate/institutional

sales department: (800) 998-9938 or corporate@oreilly.com.

Editors: Jeff Bleiel, Dawn Schanafelt, Meghan Blanchette

Cover Designer: Randy Comer

Production Editor: Melanie Yarbrough

Indexer: Lucie Haskins

Proofreader: Rachel Monaghan

Printing History:

January 2018: First Edition.

Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly

Media, Inc. The Head First series designations, Head First Learn to Code, and related trade dress are trademarks of

O’Reilly Media, Inc.

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as

trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trademark

claim, the designations have been printed in caps or initial caps.

While every precaution has been taken in the preparation of this book, the publisher and the author assume no

responsibility for errors or omissions, or for damages resulting from the use of the information contained herein.

In other words, if you use anything in Head First Learn to Code to, say, run a nuclear power plant, you’re on your

own.

No turtles were harmed in the making of this book.

ISBN: 978-1-491-95886-5

[M]

table of contents

Before KISS I had zero experience playing in a rock band

that wears makeup. —Gene Simmons

viii

the author

Eric Freeman

Eric is described by Head First series co-creator Kathy Sierra as “one of those rare

individuals uent in the language, practice, and culture of multiple domains from

hipster hacker, corporate VP, engineer, think tank.” And his background matches that

description well. By training, Eric is a computer scientist, having studied with industry

luminary David Gelernter during his Ph.D. work at Yale University. Professionally,

Eric is a former media company executive—having held the position of CTO of

Disney.com at The Walt Disney Company. Eric has also held positions at O’Reilly

Media, NASA, and several startups, and his IP is licensed and in use on every Mac

and PC. Over the last 15 years Eric has been one of the top-selling technical authors

on topics from beginning web development to high-level software design.

Eric is currently is a Principal at WickedlySmart, LLC, and lives with his wife and

young daughter in Austin, Texas.

Write to Eric at eric@wickedlysmart.com or visit http://wickedlysmart.com.

table of contents

Intro

Your brain on coding. Here you are trying to learn something, while here your

brain is doing you a favor by making sure the learning doesn’t stick. Your brain’s thinking,

“Better leave room for more important things, like which wild animals to avoid and whether

naked snowboarding is a bad idea.” So how do you trick your brain into thinking that your

life depends on knowing how to code?

Table of Contents (summary)

Intro xxv

1 Getting started: Thinking computationally 1

2 Know your value: Simple values, variables, and types 33

3 Decisive code: Booleans, decisions, and loops 73

4 Providing some structure: Lists and iteration 125

5 Getting functional: Functions and abstraction 179

4b Putting some order in your data: Sorting and nested iteration 225

6 Putting it all together: Text, strings, and heuristics 245

7 Getting modular: Modules, methods, classes, and objects 291

8 Beyond iteration and indices: Recursion and dictionaries 341

9 Persistence: Saving and retrieving les 393

10 You really should get out more: Using web APIs 435

11 Getting interactive: Widgets, events, and emergent behavior 467

12 A trip to Objectville: Object-oriented programming 523

Appendix: The Top Ten Topics (we didn’t cover): Leftovers 575

Table of Contents (the real thing)

table of contents

Who is this book for? xxvi

We know what you’re thinking xxvii

We think of a “Head First” reader as a learner xxviii

Metacognition: thinking about thinking xxix

Here’s what WE did xxx

Here’s what YOU can do to bend your brain into submission xxxi

Read Me xxxii

Acknowledgments xxxvii

The Review Team xxxviii

table of contents

thinking computationally

1Getting Started

Breaking it down 2

How coding works 6

Are we even speaking the same language? 7

The world of programming languages 8

How you’ll write and run code with Python 13

A very brief history of Python 15

Putting Python through its paces 18

Saving your work 20

Congrats on coding your first Python program! 21

Phrase-O-Matic 25

Getting the code in the machine 26

Knowing how to think computationally puts you in control.

It’s no secret the world around you is becoming more connected, more configurable,

more programmable, and more, well, computational. You can remain a passive

participant, or you can learn to code. When you can code, you’re the director, the

creator—you’re telling all those computers what they should be doing for you. When

you can code, you control your own destiny (or at least you’ll be able to program

your internet-connected lawn sprinker system). But how do you learn to code? First,

learn to think computationally. Next, you grab a programming language so you

can speak the same lingo as your computer, mobile device, or anything with a CPU.

What’s in it for you? More time, more power, and more creative possibilities to do the

things you really want to do.

table of contents

Know Your Value

simple values, variables, and types

Coding the Dog Age Calculator 34

Going from pseudocode to code 36

Step 1: Getting some input 37

How the input function works 38

Using variables to remember and store values 38

Assigning the user’s input to a variable 39

Step 2: Getting more input 39

It’s time to run some code 40

Getting some code entered 43

A deep dive on variables 44

Adding some expression 45

Variables are called VARY-ables for a reason 46

Better living through operator precedence 47

Computing with operator precedence 48

Back away from that keyboard! 51

Step 3: Computing the dog’s age 52

Houston, we’ve got a problem! 53

To err is human to code 54

A little more debugging... 56

What are Python types, anyway? 58

Fixing our code 59

Houston, we have liftoff 60

Step 4: User-friendly output 61

Computers really only do two things well: store values and perform

operations on those values. You might think they’re doing a whole lot more, as you send

texts, shop online, use Photoshop, or rely on your phone to navigate in your car; however,

everything computers do can be broken down into simple operations that are performed on

simple values. Now, part of computational thinking is learning to use these operations and

values to build something that is much more sophisticated, complex, and meaningful—and

we’re going to get to that. First, though, we’re going to take a look at what these values are,

the operations you can perform on them, and just what role variables play in all this.

table of contents

xii

Would you like to play a game? 74

First, a high-level design 76

The computer’s choice 77

How to use the random number 78

Introducing the Boolean type 81

Making decisions 82

Decisions and more decisions 83

Back to Rock, Paper, Scissors 84

Getting the user’s choice 85

Taking a look at the user’s choice 88

Adding the code to detect a tie 89

Who won? 90

How to implement the game logic 92

More about Boolean operators 93

Got documentation? 98

How to add comments to your code 99

We need to finish that game! 100

How do we know if the user’s choice is invalid? 101

How to continually prompt the user 104

Doing things more than once 105

How the while loop works 106

How to use while to prompt the user until you get a valid choice 110

Congratulations on coding your first game! 112

booleans, decisions, and loops

Decisive Code

Have you noticed how, so far, our programs aren’t

very, well, interesting? That is, all our code has strictly been a set of

statements the interpreter evaluates from top to bottom—no twists in the plot,

no sudden turns, no surprises, no independent thinking. For code to be more

interesting, it needs to make decisions, to control its own destiny, and to do

things more than once straight through. And in this chapter that’s exactly what

we’re going to learn to do. Along the way we’ll learn about the mysterious game

called shoushiling, meet a character named Boole, and see how a data type

with only two values could be worth our time. We’re even going to learn how to

deal with the dreaded infinite loop.

table of contents

xiii

lists and iteration

4Providing Some Structure

Can you help Bubbles-R-Us? 126

How to represent multiple values in Python 127

How lists work 128

How big is that list, anyway? 131

Accessing the last item in the list 132

Python makes this even easier 132

Using Python’s negative indices 133

Meanwhile, back at Bubbles-R-Us... 135

How to iterate over a list 138

Fixing the output glitch 139

Really fixing the output glitch 140

The for loop, the preferred way to iterate over a list 142

How the for loop works on a range of numbers 145

Doing more with ranges 146

Putting it all together 148

Building your own list, from scratch 156

Doing even more with lists 157

Test drive the final report 161

And the winners are... 161

Testing the most cost-effective solution 165

There’s more to data types than numbers, strings, and Booleans.

So far you’ve been writing Python code using primitive types—those floats, integers, strings,

and of course Booleans—with values like 3.14, 42, “hey, it’s my turn”, and True. And

you can do a lot with primitives, but at some point you’ll want to write code that deals with lots

of data—say, all the items in a shopping cart, the names of all the notable stars, or an entire

product catalog. For that we need a little more ummph. In this chapter we’re going to look at a

new type, called a list, which can hold a collection of values. With lists, you’ll be able to provide

some structure for your data, rather than just having a zillion variables floating around your code

holding values. You’re also going to learn how to treat all those values as a whole as well as how

to iterate over each item in a list using that for loop we mentioned in the last chapter. After this

chapter, your ability to deal with data is going to grow and expand.

table of contents

xiv

functions and abstraction

5Getting Functional

What’s wrong with the code, anyway? 181

Turning a block of code into a FUNCTION 183

We created a function, so how do we use it? 184

But how does all this actually work? 184

Functions can RETURN things too 192

How to call a function that has a return value 193

Getting a little refactoring under our belts 195

Running the code 196

How to abstract the avatar code 197

Writing the get attribute function body 198

Calling get attribute 199

Let’s talk about variables a little more... 201

Understanding variable scope 202

When variables get passed to functions 203

Making the drink me function call 204

What about using global variables in functions? 207

Going further with parameters: default values and keywords 210

How default parameter values work 210

Always list your required parameters first! 211

Using arguments with keywords 212

How to think about all these options 212

You already know a lot. Variables and data types and conditionals and

iteration—that’s enough to write basically any program you’d ever want to. In fact,

a computer scientist would tell you it’s enough to write any program that anyone

could ever conceive of. But you don’t want to stop now, because your next step

in computational thinking is learning how to create abstractions in your code.

That may sound complex, but it’s actually going to make your coding life simpler.

Creating abstractions gives you leverage; with abstraction, you can more easily

create programs of increasing complexity and power. You can put your code in neat

little packages that you can reuse over and over. And you can forget all the nitty-

gritty details of your code and to start thinking at a higher level.

table of contents

sorting and nested iteration

Putting Some Order

in Your Data

Top Bubble

Software Maker

Built-in

sort! Maybe

you could have let

us know 10 pages

back?

Understanding bubble sort 228

Starting with pass 1 228

Some bubble sort pseudocode 231

Implementing bubble sort in Python 234

Computing bubble solution numbers 236

Sometimes the default ordering of your data doesn’t cut it.

You’ve got that list of high scores on 80s arcade games, but you really need it sorted

alphabetically by game name. Then there’s that list of the number of times your coworkers

have stabbed you in the back—it would be nice to know who’s at the top of that list. To do

that, though, we need to learn how to sort data, and to do that we’ll need to explore some

algorithms that are a little more involved than the ones we’ve seen so far. We’re also going

to have to explore how nested loops work as well as think a little about the efficiency of the

code we’re writing.

part 2

table of contents

xvi

Definitely some

sophisticated writing in

this book.

text, strings, and heuristics

6Putting It All Together

Welcome to the data sciences 246

How do you compute something like readability? 247

The game plan 248

Writing some pseudocode 249

We need some text to analyze 250

Setting up the function 252

First up: we need the total number of words in our text 253

Computing the total number of sentences 257

Writing the count sentences function 258

Computing the number of syllables, or, learning to love heuristics 264

Setting up the heuristic 267

Writing the heuristic 268

How to count vowels 269

Ignoring consecutive vowels 269

Writing the code to ignore consecutive vowels 270

Removing final e’s, y’s, and punctuation 272

Putting slicing (substrings) to work 274

Finishing off the heuristic code 276

Implementing the reading ease formula 278

Taking it even further 283

You’ve already got a lot of superpowers. Now it’s time to use

them. In this chapter we’re going to integrate what we’ve learned so far, bringing

it all together to build some increasingy cool code. We’re also going to keep

adding to your knowledge and coding skills. More specifically, in this chapter

we’ll explore how to write code that grabs some text, slices it, dices it, and then

does a little data analysis on it. We’re going to find out what a heuristic is too,

and implement one. Get ready—this is an all-out, heads-down, pedal-to-the-

metal, serious coding chapter!

table of contents

xvii

modules, methods, classes, and objects

7Getting Modular

Nice job, I was quickly

able to use the analyze

module, especially with the help

of the great documentation!

A quick module review 294

The __name__ global variable 296

Updating analyze.py 297

Using analyze.py as a module 299

Adding docstrings to analyze.py 301

Exploring other Python modules 305

Wait, did someone say “turtles”?! 306

Creating your very own turtle 308

Turtle lab 309

Adding a second turtle 311

What are turtles, anyway? 314

What are objects? 315

Okay, what’s a class then? 316

How to use objects and classes 318

What about those methods and attributes? 319

Seeing classes and objects everywhere 320

Get ready for some turtle races 322

Planning the game 323

Let’s start coding 324

Setting up the game 324

Writing the setup code 325

Not so fast! 326

Starting the race 328

Your code is growing in size and complexity. As that happens you need better ways

to abstract, to modularize, to organize your code. You’ve seen that functions can be used to group lines

of code together into bundles you can reuse over and over. And you’ve also seen that collections of

functions and variables can be placed into modules so that they can be more easily shared and reused.

In this chaper we’ll revisit modules and learn how to use them even more effectively (so you’re all ready

to share your code with others) and then we’re going to look at the ultimate in code reuse: objects.

You’re going to see that Python objects are all around you, just waiting to be used.

table of contents

xviii

recursion and dictionaries

8Beyond Iteration and Indices

A different way to compute 342

And now the different way... 343

Now let’s write some code for our two cases 344

Let’s get some more practice 347

Using recursion to detect palindromes 348

Writing a recursive palindrome detector 349

The Anti-Social Network 360

Introducing the dictionary 362

Let’s see how to create a dictionary 362

Keys and values do not have to be strings 363

Of course you can remove keys as well 363

But you might want to test to see if it exists first 363

What about iterating through a dictionary? 364

Leveraging dictionaries at the Anti-Social Network 366

But how do we add more attributes? 368

Remember the Anti-Social Network’s killer feature? 370

Finding the most anti-social user 371

Can we just remember function call results? 376

Using a dictionary to remember our Fibonacci results 376

Memoization 377

A closer look at the koch function 380

Truly exploring the koch fractal 382

It’s time to take your computational thinking up a notch. And

this is the chapter to do it: we’ve been happily coding along with an iterative style of

programming—we’ve created data structures like lists and strings and ranges of numbers,

and we’ve written code to compute by iterating over them. In this chapter we’re going to look

at the world differently, first in terms of computation, and then in terms of data structures.

Computationally we’ll look at a style of computing that involves writing code that recurs,

or calls itself. We’ll expand the kinds of data structures we can work with by looking at a

dictionary-like data type that is more like an associative map than a list. We’ll then put them

together and cause all kinds of trouble. Be forewarned: these topics take a while to settle

into your brain, but the effort is going to pay off in spades.

table of contents

xix

saving and retrieving files

9Persistence

Ready for some Crazy Libs? 394

How Crazy Libs is going to work 396

Step 1: Read the text of the story from a file 399

How to use file paths 400

Absolute paths 401

Oh, and don’t forget to clean up when you’re done! 402

Reading a file into your Python code 403

Oh, give it a break already... 406

Using the readline method of the file object 407

How do we know when we’ve read the last line? 409

Reading in a Crazy Lib template 410

Processing the template text 411

Using a new string method to fix the bug 413

Actually fixing the bug 414

Some code has real problems 415

Handling exceptions 417

Explicitly handling exceptions 418

Updating Crazy Libs to handle exceptions 420

Our last step: storing the Crazy Lib 421

Updating the rest of the code 421

You know you can save values in variables, but once your program ends

poof!—they’re gone forever. That’s where persistent storage comes in—storage that allows

your values and data to stick around a while. Most of the devices you’re going to run Python on also have

persisistent storage, like hard drives and flash cards, or they may have access to storage in the cloud as

well. In this chapter you’ll see how to write code to store and retrieve data from files. What good is that?

Oh, anytime you want to save a user’s configuration, store the results of your big analysis for the boss,

read an image into your code to process it, write some code to search a decade’s worth of email messages,

reformat some data to be used in your spreadsheet app—we could go on and on.

table of contents

You Really Should Get Out More

using web apis

Extending your reach with Web APIs 436

How Web APIs work 437

All Web APIs have a web address 438

Time for a quick upgrade 441

Doing the upgrade 442

All we need now is a good Web API... 443

A closer look at the API 444

Web APIs provide data using JSON 445

Now let’s look at that request module again 447

Putting it all together: making a request to Open Notify 449

How to use JSON in Python 450

Using the JSON module on our ISS data 451

Let’s add some graphics 452

Meet the screen object 453

Let’s add a turtle to represent the ISS 455

Turtles can look like space stations too 456

Forget the ISS—where are we? 457

Finishing off the ISS code 458

You’ve been writing some great code, but you really need to get out

more. There’s a whole world of data just waiting for you on the web: Need weather data? Or

how about access to a huge database of recipes? Or are sports scores more your thing? Maybe

a music database of artists, albums, and songs? They’re all out there for the taking from Web

APIs. To use them all you need is to learn a bit more about how the web works, how to speak the

local web lingo, and how to use a couple of new Python modules: requests and json. In this

chapter we’re going to explore Web APIs and take your Python skills to new heights; in fact, we’re

going to take them all the way to outer space and back.

table of contents

xxi

Getting Interactive

widgets, events, and emergent behavior

Enter the WONDERFUL WORLD of Artifical Life 468

A closer look at the Game of Life 469

What we’re going to build 472

Do we have the right design? 473

Building the data model 477

Representing the grid 477

Computing a generation of the Game of Life 478

Computing each cell’s fate 478

Completing the model code 482

Building the view 485

Creating your first widget 486

Adding the rest of the widgets 487

Correcting the layout 488

Placing the widgets into a grid layout 489

Translating the grid layout to code 489

Moving on to the controller 491

Adding an update function 491

Ready for another new style of computation? 494

How the start/pause button is going to work 497

Another kind of event 499

We have the technology: the after method 501

How to enter and edit cells directly 504

Writing the grid view handler 505

Now it’s time to add some patterns 506

Writing a handler for the OptionMenu 507

Writing the pattern loader 510

Taking it Even Further! 517

You’ve certainly written some graphical applications, but you haven’t

created a real user interface yet. That is, you haven’t written anything that lets the user

interact with a graphical user interface (otherwise known as a GUI). To do that you need to adopt a

new way of thinking about how a program executes, one that is more reactive. Wait, did the user just

click on that button? Your code better know how to react and what to do next. Coding for interfaces is

quite different from the typical procedural method we’ve been using, and it requires a different way of

thinking about the problem. In this chapter you’re going to write your first real GUI, and no, we’re not

going to write a simple to-do list manager or height/weight calculator, we’re going to do something far

more interesting. We’re going to write an artificial life simulator with emergent behavior.

table of contents

xxii

object-oriented programming

A Trip to Objectville

Breaking it down, a different way 524

What’s the point of object-oriented programming, anyway? 525

Designing your first class 527

Writing your first class 528

How the constructor works 528

Writing the bark method 531

How methods work 532

Adding some inheritance 534

Implementing the ServiceDog class 535

A closer look at subclassing 536

A ServiceDog IS-A Dog 537

Testing IS-A in code 538

Overriding and extending behavior 542

Welcome to Jargon City 544

Object can HAS-Another object 546

Designing a Doggie Hotel 549

Implementing the Doggie Hotel 550

Adding some hotel activities 554

I can do anything you can, or Polymorphism 555

It’s about time we teach the other dogs to walk 556

The power of inheritance 558

In this book you’ve used functions to abstract your code. And you’ve

approached coding in a procedural manner using simple statements, conditionals, and for/while

loops with functions—none of this is exactly object-oriented. In fact, it’s not object-oriented at all! We

have looked at objects and how to use them in our code, but you haven’t created any objects of your

own yet, and you haven’t really approached designing your code in an object-oriented way. So, the time

has come to leave this boring procedural town behind. In this chapter, you’re going to find out why using

objects is going to make your life so much better—well, better in a programming sense (we can’t really

help you with other areas of your life and your coding skills, all in one book).

table of contents

xxiii

appendix: leftovers

The Top Ten Topics

(We Didn’t Cover)

Client-side code executes

on the client—that is, on

your computer.

Server-side code

executes on a server on

the internet.

request

#1 List comprehensions 576

#2 Dates and times 577

#3 Regular expressions 578

#4 Other data types: tuples 579

#5 Other data types: sets 580

#6 Server-side coding 581

#7 Lazy evaluation 582

#8 Decorators 583

#9 Higher-order and first-class functions 584

#10 A lot of libraries 585

We’ve covered a lot of ground, and you’re almost finished with this book.

We’ll miss you, but before we let you go, we wouldn’t feel right about sending you out into the world

without a little more preparation. We can’t possibly fit everything you’ll need to know into this relatively

small chapter. Actually, we did originally include everything you need to know about Python programming

(not already covered by the other chapters), by reducing the type point size to .00004. It all fit, but nobody

could read it. So we threw most of it away, and kept the best bits for this Top Ten appendix.

xxv

Intro

how to use this book

I can’t believe they

put

that

in a book on

learning to code!

In this section, we answer the burning question:

“So, why DID they put that in a book on learning to code?”

how to use this book

xxvi intro

Who is this book for?

Do you want to learn, understand, and remember how

to program?

this book is for you.

Who should probably back away from this book?

1Are you completely new to computers?

If you don’t know your way around your computer,

how to manage files and folders, how to install apps,

or how to use a word processor, you should probably

learn those first.

this book is not for you.

Are you afraid to try something different? Would you

rather have a root canal than mix stripes with plaid? Do

you believe that a technical book can’t be serious if we

have fun learning to code?

If you can answer “yes” to all of these:

If you can answer “yes” to any one of these:

2Are you a kick-butt programmer looking for a

reference

book?

[Note from marketing: this book is

for anyone with a credit card.]

Do you prefer stimulating dinner party conversation

to dry, dull, academic lectures?

This is NOT a

reference book.

Head First Learn

to Code is a

book designed

for learning to

code. It’s not an

encyclopedia of

programming facts

(you have Google

for that, right?).

the intro

you are here�xxvii

“How can this be a serious book?”

“What’s with all the graphics?”

“Can I actually learn it this way?”

We know what you’re thinking.

Your brain craves novelty. It’s always searching, scanning, waiting for

something unusual. It was built that way, and it helps you stay alive.

Today, you’re less likely to be a tiger snack. But your brain’s still looking.

You just never know.

So what does your brain do with all the routine, ordinary, normal things

you encounter? Everything it can to stop them from interfering with the

brain’s real job—recording things that matter. It doesn’t bother saving the

boring things; they never make it past the “this is obviously not important”

filter.

How does your brain know what’s important? Suppose you’re out for a day

hike and a tiger jumps in front of you. What happens inside your head

and body?

Neurons fire. Emotions crank up. Chemicals surge.

And that’s how your brain knows…

This must be important! Don’t forget it!

But imagine you’re at home, or in a library. It’s a safe, warm, tiger-

free zone. You’re studying. Getting ready for an exam. Or trying to

learn some tough technical topic your boss thinks will take a week,

10 days at the most.

Just one problem. Your brain’s trying to do you a big favor. It’s

trying to make sure that this obviously non-important content doesn’t

clutter up scarce resources. Resources that are better spent storing

the really big things. Like tigers. Like the danger of fire. Like how

you should never again snowboard in shorts.

And there’s no simple way to tell your brain, “Hey brain, thank

you very much, but no matter how dull this book is, and how little

I’m registering on the emotional Richter scale right now, I really do

want you to keep this stuff around.”

And we know what your brain is thinking.

Your brain thinks

THIS is important.

Your brain thinks

THIS isn’t worth

saving.

Great. Only 600

more dull, dry,

boring pages.

how to use this book

xxviii intro

We think of a “Head First” reader as a learner.

I really think you’ll

want to abstract that

code into a function.

Now that I have your

attention, you should be

more careful using global

variables.

So what does it take to

learn

something? First, you have to

get

it, then make

sure you don’t

forget

it. It’s not about pushing facts into your head. Based

on the latest research in cognitive science, neurobiology, and educational

psychology,

learning

takes a lot more than text on a page. We know what

turns your brain on.

Some of the Head First learning principles:

Make it visual. Images are far more memorable than words alone,

and make learning much more effective (up to 89% improvement in

recall and transfer studies). It also makes things more understandable.

Put the words within or near the graphics they relate to, rather than

on the bottom or on another page, and learners will be up to twice as likely to

solve problems related to the content.

Use a conversational and personalized style. In recent

studies, students performed up to 40% better on post-learning tests

if the content spoke directly to the reader, using a first-person, conversational

style rather than taking a formal tone. Tell stories instead of lecturing. Use casual

language. Don’t take yourself too seriously. Which would you pay more attention

to: a stimulating dinner party companion, or a lecture?

Get the learner to think more deeply. In other words,

unless you actively flex your neurons, nothing much happens in

your head. A reader has to be motivated, engaged, curious, and

inspired to solve problems, draw conclusions, and generate new

knowledge. And for that, you need challenges, exercises and

thought-provoking questions, and activities that involve

both sides of the brain and multiple senses.

Get—and keep—the reader’s attention. We’ve all

had the “I really want to learn this, but I can’t stay awake past

page one” experience. Your brain pays attention to things that are out

of the ordinary, interesting, strange, eye-catching, unexpected. Learning a new,

tough, technical topic doesn’t have to be boring. Your brain will learn much more quickly if it’s not.

Touch their emotions. We now know that your ability to remember something is largely

dependent on its emotional content. You remember what you care about. You remember when you

feel something. No, we’re not talking heart-wrenching stories about a boy and his dog. We’re talking

emotions like surprise, curiosity, fun, “what the…?” , and the feeling of “I rule!” that comes when you

solve a puzzle, learn something everybody else thinks is hard, or realize you know something that

“I’m more technical than thou” Bob from Engineering doesn’t.

Don’t just learn to

code—learn to think

computationally.

Your code

The Python

Intepreter

the intro

you are here�xxix

If you really want to learn, and you want to learn more quickly and more deeply,

pay attention to how you pay attention. Think about how you think. Learn how you

learn.

Most of us did not take courses on metacognition or learning theory when we were

growing up. We were expected to learn, but rarely taught how to learn.

But we assume that if you’re holding this book, you really want to learn

how to code to create programs and apps. And you probably don’t want

to spend a lot of time. And you want to remember what you read, and be

able to apply it. And for that, you’ve got to understand it. To get the most

from this book, or any book or learning experience, take responsibility for

your brain.

The trick is to get your brain to see the new material you’re learning as

Really Important. Crucial to your well-being. As important as a tiger.

Otherwise, you’re in for a constant battle, with your brain doing its best

to keep the new content from sticking.

Metacognition: thinking about thinking

I wonder how I

can trick my brain

into remembering

this stuff...

So how

you get your brain to think coding is as

important as a tiger?

There’s the slow, tedious way, or the faster, more effective way. The

slow way is about sheer repetition. You obviously know that you are

able to learn and remember even the dullest of topics, if you keep pounding on the same

thing. With enough repetition, your brain says, “This doesn’t feel important to him, but he

keeps looking at the same thing over and over and over, so I suppose it must be.”

The faster way is to do anything that increases brain activity, especially different

types of brain activity. The things on the previous page are a big part of the solution,

and they’re all things that have been proven to help your brain work in your favor. For

example, studies show that putting words within the pictures they describe (as opposed to

somewhere else in the page, like a caption or in the body text) causes your brain to try

to make sense of how the words and picture relate, and this causes more neurons to fire.

More neurons firing = more chances for your brain to get that this is something worth

paying attention to, and possibly recording.

A conversational style helps because people tend to pay more attention when they

perceive that they’re in a conversation, since they’re expected to follow along and hold up

their end. The amazing thing is, your brain doesn’t necessarily care that the “conversation”

is between you and a book! On the other hand, if the writing style is formal and dry, your

brain perceives it the same way you experience being lectured to while sitting in a roomful

of passive attendees. No need to stay awake.

But pictures and conversational style are just the beginning.

xxx intro

how to use this book

We used pictures, because your brain is tuned for visuals, not text. As far as your brain’s

concerned, a picture really is worth 1,024 words. And when text and pictures work together, we

embedded the text in the pictures because your brain works more effectively when the text is

within the thing the text refers to, as opposed to in a caption or buried in the text somewhere.

We used redundancy, saying the same thing in different ways and with different media types,

and multiple senses, to increase the chance that the content gets coded into more than one area of

your brain.

We used concepts and pictures in unexpected ways because your brain is tuned for novelty,

and we used pictures and ideas with at least some emotional content, because your brain is

tuned to pay attention to the biochemistry of emotions. That which causes you to feel something

is more likely to be remembered, even if that feeling is nothing more than a little humor,

surprise, or interest.

We used a personalized, conversational style, because your brain is tuned to pay more

attention when it believes you’re in a conversation than if it thinks you’re passively listening to a

presentation. Your brain does this even when you’re reading.

We included more than 120 activities, because your brain is tuned to learn and remember

more when you do things than when you read about things. And we made the exercises

challenging-yet-doable, because that’s what most people prefer.

We used multiple learning styles, because you might prefer step-by-step procedures, while

someone else wants to understand the big picture first, while someone else just wants to see a

code example. But regardless of your own learning preference, everyone benefits from seeing the

same content represented in multiple ways.

We include content for both sides of your brain, because the more of your brain you

engage, the more likely you are to learn and remember, and the longer you can stay focused.

Since working one side of the brain often means giving the other side a chance to rest, you can

be more productive at learning for a longer period of time.

And we included stories and exercises that present more than one point of view, because

your brain is tuned to learn more deeply when it’s forced to make evaluations and judgments.

We included challenges, by providing exercises and by asking questions that don’t always

have a straight answer, because your brain is tuned to learn and remember when it has to work

at something. Think about it—you can’t get your body in shape just by watching people at the

gym. But we did our best to make sure that when you’re working hard, it’s on the right things.

That you’re not spending one extra dendrite processing a hard-to-understand example,

or parsing difficult, jargon-laden, or overly terse text.

We used people. In stories, examples, pictures, and so on, because, well, you’re a person. And

your brain pays more attention to people than it does to things.

We used an 80/20 approach. We assume that if you’re going to be a kick-butt programmer,

this won’t be your only book. So we don’t talk about everything. Just the stuff you’ll actually need.

Here’s what WE did:

BULLET POINTS

Puzzles

Be the Python

interpreter

They’re coming

along with us.

the intro

you are here�xxxi

So, we did our part. The rest is up to you. These tips are a

starting point; listen to your brain and figure out what works

for you and what doesn’t. Try new things.

Here’s what YOU can do to bend

your brain into submission

1Slow down. The more you understand,

the less you have to memorize.

Don’t just read. Stop and think. When the

book asks you a question, don’t just skip to the

answer. Imagine that someone really is asking

the question. The more deeply you force your

brain to think, the better chance you have of

learning and remembering.

2Do the exercises. Write your own notes.

We put them in, but if we did them for you,

that would be like having someone else do

your workouts for you. And don’t just look at

the exercises. Use a pencil. There’s plenty of

evidence that physical activity

while

learning

can increase the learning.

3Read the “There Are No Dumb Questions”

That means all of them. They’re not optional

sidebars—they’re part of the core content!

Don’t skip them.

4Make this the last thing you read before

bed. Or at least the last

challenging

thing.

Part of the learning (especially the transfer to

long-term memory) happens after

you put the

book down. Your brain needs time on its own, to

do more processing. If you put in something new

during that processing time, some of what you

just learned will be lost.

5Drink water. Lots of it.

Your brain works best in a nice bath of fluid.

Dehydration (which can happen before you ever

feel thirsty) decreases cognitive function.

6Talk about it. Out loud.

Speaking activates a different part of the brain.

If you’re trying to understand something, or

increase your chance of remembering it later, say

it out loud. Better still, try to explain it out loud

to someone else. You’ll learn more quickly, and

you might uncover ideas you hadn’t known were

there when you were reading about it.

7Listen to your brain.

Pay attention to whether your brain is getting

overloaded. If you find yourself starting to skim the

surface or forget what you just read, it’s time for a

break. Once you go past a certain point, you won’t

learn faster by trying to shove more in, and you

might even hurt the process.

Create

something!

Apply this to something new you’re designing, or

rework an older project. Just do something to get some

experience beyond the exercises and activities in

this book. All you need is a pencil and a problem

to solve…a problem that might benefit from

programming.

Cut this out and stick it

on your refrigerator.

Feel

something!

Your brain needs to know that this matters. Get

involved with the stories. Make up your own

captions for the photos. Groaning over a bad joke is

still better than feeling nothing at all.

Get sleep.

You’ve got to create a lot of new brain connections

to learn to program. Sleep often; it helps.

xxxii intro

Read Me

how to use this book

This is a learning experience, not a reference book. We deliberately stripped out everything

that might get in the way of learning whatever it is we’re working on at that point in the

book. And the first time through, you need to begin at the beginning, because the book

makes assumptions about what you’ve already seen and learned.

We want you to learn the thinking process behind programming.

Some might call that computer science, but here’s a little secret: computer science isn’t a

science and it’s not even all that much about computers (any more than astronomy is about

telescopes). It’s a way of thinking, otherwise known these days as computational thinking,

and once you learn to think computationally, you’ll be in a good position to apply that to any

problem, environment, or programming language.

In this book we use Python.

Learning to drive without a vehicle is a little academic. And learning to think

computationally without a programming language is more of a thought experiment than

a marketable skill. So, in this book we use the very popular Python language. We’ll tell you

more about its accolades in Chapter 1, but whether you’re a hobbyist or hoping to land a six-

figure software development position, Python is a good place to start (and maybe end).

We don’t exhaustively cover every aspect of the Python language.

Not even close. There’s a lot you can learn about Python. This book is not a reference book,

it’s a learning book, so it doesn’t cover everything there is to know about Python. Our goal is

to teach you the fundamentals of coding and computational thinking so that you can pick up

a book on any programming language and not feel totally lost.

You can use a Mac or PC, or Linux for that matter.

As Python is our primary vehicle used in this book and it is cross-platform, you can use

whatever operating system you’re used to. Most of the screenshots in this book are from a

Mac, but they should look similar on your PC or Linux box.

This book advocates well-structured and readable code based

on best practices. You want to write code that you and other people can read and

understand, code that will still work in next year’s version of Python. In this book we’re going

to teach you to write clear, well-organized code from the get-go—code you can be proud of,

code you’ll want to frame and put on the wall (just take it down before you bring your date

over). The only thing that differs from what we’d write as professional code is that this book

uses handwritten annotations next to code to explain what the code is doing. We found this

works better in a learning book than traditional comments in code (if you have no idea what

we’re talking about, you will; just give it a few chapters). But don’t worry because we’ll teach

you how to document your code and we’ll show you examples of how we’d document our

own code. All that said, we’re interested in teaching you to write code in the most straight-

forward way so you can get the job done and move on to better things.

Annotations

like this

the intro

you are here�xxxiii

Programming is serious business. You’re going to have to work,

sometimes hard. A programmer has a different mindset, a different way of thinking

about the world. At times you’re going to find coding very logical, while at other times it

can be very abstract, if not downright mind bending. Some programming concepts take

time to sink into your brain—you actually do have to sleep on them before you’ll get it. But

no worries; we’re going to do all that in a brain-friendly way. Just take your time, give the

concepts time to sink in, and go over the material multiple times if needed.

The activities are NOT optional.

The exercises and activities in this book are not add-ons; they’re part of the core content of

the book. Some of them are to help with memory, some are for understanding, and some

will help you apply what you’ve learned. If you skip them you will be missing large parts of

the book (and you’ll probably be very confused). The crossword puzzles are the only things

you don’t have to do, but they’re good for giving your brain a chance to think about the

words in a different context.

The redundancy is intentional and important.

One distinct difference in a Head First book is that we want you to really get it. And we

want you to finish the book remembering what you’ve learned. Most reference books don’t

have retention and recall as a goal, but this book is about learning, so you’ll see some of the

same concepts come up more than once.

The examples are as lean as possible.

Our readers tell us that it’s frustrating to wade through 200 lines of an example looking for

the two lines they need to understand. Most examples in this book are shown within the

smallest possible context, so that the part you’re trying to learn is clear and simple. Don’t

expect all of the examples to be robust—they are written specifically for learning, and aren’t

always fully functional. That said, for the larger examples we also try to make them fun,

fascinating, and downright cool—something you’d want to show your friends and family.

We’ve placed all the example files on the web so you can download them. You’ll find them

at http://wickedlysmart.com/hflearntocode.

The Brain Power exercises don’t usually have answers.

For some of them, there is no right answer, and for others, part of the learning experience

of the Brain Power activities is for you to decide if and when your answers are right. In

some of the Brain Power exercises, you will find hints to point you in the right direction.

Get the code examples, help, and discussion online.

You’ll find everything you need for this book online at http://wickedlysmart.com/

hflearntocode, including code sample files and additional support material.

Operators are NOT

standing by, but you can

get all the code and

samples files you’ll need at

http://wickedlysmart.com/

hflearntocode.

how to use this book

xxxiv intro

More than likely your computer is either not going to have Python installed, or it’s not going

to have the right version of Python installed. In this book we use Python 3, which at the

time of writing was version 3.6. So, you’ll need to install version 3.6 or later. Here’s how:

• For macOS, open your browser and enter:

https://www.python.org/downloads

On this page you should see the macOS download links. If not, look

under the Downloads menu on the page.

1. Click the Download button for Python 3.x (where x is the latest

version). Do not download version 2.7.

2. Once the installer is downloaded, open the installation package in

your downloads folder and follow the installation instructions.

3. After you’ve completed the install, navigate to your Applications

folder, under which you’ll find the Python 3.x folder. To test your

installation, double click the IDLE application in the Python 3.x

folder:

4. When the IDLE application appears on your screen, you should

see something similar to the screenshot below. If not, recheck your

installation for any errors that might have occurred.

The IDLE app is located in the Python 3.x

folder, which you’ll find in the Applications

folder. We’ll talk more about what IDLE is in

the first chapter.

It’s a good idea to add IDLE to your dock if

you haven’t already, as we’ll be using it a fair

bit in this book. To do that control-click the

icon in the dock and choose Options > Keep in

Dock from the pop-up menu.

You can choose the IDLE > Quit IDLE

menu option to exit the application.

You’re going to have to install Python

Note that you’ll need administrator privileges

to install Python—if you commonly install

apps, you should be fine; otherwise, ask your

administrator for help.

the intro

you are here�xxxv

Note to Linux users: We’re not

worried about you; let’s be real,

you know what you’re doing. Just

grab the approriate distribution

from python.org

• For Windows, open your browser and enter:

https://www.python.org/downloads

1. Click the Download button for Python 3.x (where x is

the latest version). Do not download version 2.7.

2. Choose to either save or run the executable installer.

If the latter, click to run the installer after you’ve

downloaded it.

3. When you see the installer window appear on your

screen, make sure the “Add Python to PATH”

checkbox is checked at the bottom of the installer, then

click “Install Now.”

4. After you’ve completed the install, navigate using

the Start button to All Programs, and in your list of

apps you should see a menu option for Python 3.x

(with your version number in place of the x). Under

the Python menu you’ll see choices for Python 3.x,

documentation, and IDLE, which is an editor we will

also be using in this book.

5. To test, click the IDLE menu item; when the IDLE

application appears on your screen, you should see

something similar to the screenshot below. If not,

recheck your installation and any errors that might

have occurred.

You can choose the IDLE

> Quit IDLE menu option

to exit the application.

how to use this book

xxxvi intro

Your source code is all the code you’ll be writing with this book. We

recommend keeping your code organized on a per-chapter basis and

throughout the book we’ve assumed that you’ll be creating one folder

per chapter, like this:

A word on organizing your code

You should also visit:

http://wickedlysmart.com/hflearntocode

The first thing

that stands

between you and

VERB_ING your

first, real,

piece of NOUN,

is VERB_ING

the skill of

breaking

dogcalc.py

code

ch12

ch2 ...

my_file =

my_text = my

print(my_text

my_file.

close(

phraseomatic.py

ch1

The first thing

that stands

between you and

VERB_ING your

first, real,

piece of NOUN,

is VERB_ING

the skill of

breaking

dog.py

The first thing

that stands

between you and

VERB_ING your

first, real,

piece of NOUN,

is VERB_ING

the skill of

breaking

palindrome.py

There you’ll find instructions for downloading the complete source

code for the book. In this code you’ll find our versions of the programs

you’re going to write as well as a few data files and images you’ll need.

We do ask that you take the time to type in the programs yourself (this

will help you develop your muscle memory for coding and help things

sink into your brain), but if you run into any issues you just can’t figure

out, you can always compare your code with ours to see where you

might have made a mistake.

We created a top-level

folder for all the code

in the book.

And a folder for each

chapter named ch1, ch2,

and so on, up to ch12.

Thoughout the book we’ll

guide you on what to call

your folders and files.

While you’re there don’t

forget to sign up for

the Head First Learn to

Code newsletter, where

we’ll do our best to keep

your brain engaged in

learning to code!

the intro

you are here�xxxvii

A huge thanks goes out first

to my esteemed technical

reviewers: Elisabeth

Robson carefully and

expertly reviewed the

manuscript with a keen Head

First and computer science

eye. Josh Sharfman was

the MVP reviewer who added

depth and quality to every

corner of the book. David Powers, in his usual style,

rigorously scoured the technical text (his Harry Potter knowledge ain’t

too shabby either). And veteran Head First author Paul Barry provided a

much-needed Python critical eye. In addition, my review team (listed on the next

page) was invaluable across every aspect of reviewing the book.

My biggest thanks to my editors, Jeff Bleiel, Dawn Schanafelt, and Meghan Blanchette. Meghan was

instrumental in getting this book off the ground, Dawn carefully saw it through its early developmental stages, and Jeff

drove the book through to its publication.

Also a big thanks to the entire O’Reilly team including Susan Conant, Rachel Roumeliotis, and Melanie

Yarbrough. At WickedlySmart, thanks to Jamie Burton for all her help, including early reader surveys and

managing the review team forum. And as always, thanks to Bert Bates and Kathy Sierra for inspiration,

interesting discussion, and all their help solving writing conundrums. Thanks to Cory Doctorow for his support and

for lending his writing to Chapter 7.

Finally, a number of individuals and organizations unknowingly inspired aspects of

this book, including Daniel P. Friedman, Nathan Bergey, the Raspberry Pi

Foundation, and Socratica.

Dawn Schanafelt

Meghan Blanchette

Jeff Bleiel

Paul Barry

Kathy Sierra

Bert Bates

Jamie Burton

Acknowledgments*

*The large number of acknowledgments is because we’re testing the theory

that everyone mentioned in a book acknowledgment will buy at least one copy,

probably more, what with relatives and everything. If you’d like to be in the

acknowledgment of our next book, and you have a large family, write to us.

Dawn Schanafelt

Elisabeth Robson

Josh Sharfman

David Powers

Paul Barry

how to use this book

xxxviii intro

The Review Team

Meet the review team!

An amazing group of people took on

reviewing this book. With backgrounds

from newbie to expert, and professions as

diverse as architect, dentist, elementary

school teacher, real estate agent, and

AP computer science teacher, they

participated across the globe from Albania

to Australia, from Kenya to Kosovo,

from the Netherlands to Nigeria to New

Zealand.

This group read every page, did every

exercise, and entered and executed every

line of code, providing feedback and

encouragement over 600 pages.

They also, on their own, worked as

a team, helping each other through

new concepts, double-checking

errors, and locating problems in the

text and code.

Every reviewer here made

significant contributions

to this book and vastly

improved its quality.

Thank you!

Also a big thanks to Christopher Davies, Constance Mallon, and Wanda Hernandez for their

significant contributions to this book.

Abdul Rahman Shaik

Alfred J. Speller

Tiron Andric

Hudson Read

Mitch Johnson

Mark S. van der Linden

Ridvan Bunjaku

Crystal Gilmore Rodriguez

Troy Welch

Mauro Caser

David Kinoti

David Oparanti

Chris Talent

Chris Griggs

Andrea Toston

Michael Peck

Johnny Rivera

Dennis Fitzgerald

Benjamin E. Hall

this is a new chapter 1

thinking computationally

Knowing how to think computationally puts you in

control. It’s no secret the world around you is becoming more connected,

more configurable, more programmable, and more, well, computational. You

can remain a passive participant, or you can learn to code. When you can code,

you’re the director, the creator—you’re telling all those computers what they

should be doing for you. When you can code, you control your own destiny (or

at least you’ll be able to program your internet-connected lawn sprinker system).

But how do you learn to code? First, learn to think computationally. Next,

you grab a programming language so you can speak the same lingo as your

computer, mobile device, or anything with a CPU. What’s in it for you? More

time, more power, and more creative possibilities to do the things you really

want to do. Come on, let’s get started...

Getting Started

2 Chapter 1

breaking it down

Breaking it down

The ﬁrst thing that stands between you and writing your ﬁrst

real piece of code is learning the skill of breaking problems

down into achievable little actions that a computer can do for

you. Of course, you and the computer will also need to be

speaking a common language, but we’ll get to that topic in

just a bit.

Now breaking problems down into a number of steps may

sound like a new skill, but it’s actually something you do

every day. Let’s look at a simple example: say you wanted

to break the activity of ﬁshing down into a simple set of

instructions that you could hand to a robot, who would do

your ﬁshing for you. Here’s our ﬁrst attempt to do that:

1Put worm on hook.

2Cast line into pond.

3Watch the bobber until it goes underwater.

4Hook and pull in fish.

5If done fishing, then go home; otherwise,

go back to step 1.

Let’s break the process of catching

fish down into a number of easily

understood steps.

Some steps are simple instructions, or statements

if you will, like “cast line into pond.”

A statement might conditionally wait

before proceeding.

We follow the steps in order.

Notice that often statements repeat, like

here: if we don’t go home, we instead

go back to the beginning and repeat the

instructions to catch another fish.

Statements can also make

decisions, like is it time to go

home or should we keep fishing?

This statement only happens after the bobber has

gone underwater in the previous statement.

The bobber

The hook

The worm

you are here 4 3

thinking computationally

You can think of these statements as a nice recipe for ﬁshing.

Like any recipe, this one provides a set of steps that, when

followed in order, will produce some result or outcome (in our

case, hopefully, catching some ﬁsh).

Notice that most steps consist of a simple instruction, like

“cast line into pond,” or “pull in the ﬁsh.” But also notice that

other instructions are a bit different because they depend

on a condition, like “is the bobber above or below water?”

Instructions might also direct the ﬂow of the recipe, like “if

you haven’t ﬁnished ﬁshing, then cycle back to the beginning

and put another worm on the hook.” Or, how about a

condition for stopping, as in “if you’re done, then go home”?

You’re going to ﬁnd that these simple statements or

instructions are the foundation of coding. In fact, every app

or software program you’ve ever used has been nothing more

than a (sometimes large) set of simple instructions to the

computer that tell it what to do.

Real recipes don’t just tell you what to do, they

also include objects that are used in making

a particular dish (like measuring cups, whisks,

food processors, and of course ingredients).

What objects are used in our fishing recipe?

Circle all the objects in the fishing recipe on

the previous page, and check your answer at

the end of the chapter before moving on.

This is a workbook.

You can write in it; in

fact, we encourage it.

One thing to understand right up front is that computers do exactly what

you tell them—nothing more, nothing less. Look at our recipe for fishing on

the previous page. If you were the robot and you followed these instructions

precisely, what problems might you encounter? Do you think we would really

be successful using this recipe?

A. If there are no fish, you’re

going to be fishing for a very

long time (like, forever).

B. If the worm falls off the

hook, you’ll never know about

it or replace it.

C. What happens if we run

out of worms?

D. Did we specify what

to do with a fish when we

pulled it in?

E. What happened to the

fishing rod?

F. _______________

__________________

Can you think

of more issues?

In case you are

not familiar with

fishing, this is a

bobber, otherwise

known as a fishing

float. When a

fish bites, it goes

underwater.

You’ll find the

answers to

Sharpen Your

Pencil exercises

at the end of

the chapter.

4 Chapter 1

recipes, algorithms, and pseudocode

I bought this

expensive technical book

to learn to code and you’re starting by

telling me about recipes? That doesn’t

sound very promising or, well,

technical

Actually, a recipe is a perfectly good way

to describe a set of instructions to a computer. You might

even run into that term loosely used here and there in

more advanced programming books. Heck, you’ll even

find books on common software development techniques

that are called cookbooks. That said, if you want to

get technical we can—a computer scientist or serious

software developer would commonly call a recipe an

algorithm. What’s an algorithm? Well, not much more

than a recipe—it’s a sequence of instructions that solves

some problem. Often you’ll find algorithms are first

written in an informal form of code called pseudocode.

One thing to keep in mind is that, whether you’re talking

about a recipe, pseudocode, or an algorithm, the whole

point is to work out a high-level description of how to

solve a problem before you get into the nitty-gritty details

of writing code that the computer can understand and

execute.

In this book, you’ll hear us interchange all these terms,

where appropriate—and, oh, in your next job interview

you might want to use the term algorithm or even

pseudocode to ensure that larger signing bonus (but there’s

still nothing wrong with the word recipe).

As you’ll see,

this can make

the task of

coding more

straightforward

and less error-

prone.

Top Bubble Solutions

1) Bubble solution #10 score: 68

2) Bubble solution #12 score: 60

3) Bubble solution #2 score: 57

4) Bubble solution #31 score: 50

5) Bubble solution #3 score: 34

Note these aren't real scores; this is

just an illustration of what I want.

Thanks!!

you are here 4 227

sorting and nested iteration

Cubicle conversation

Frank: Well, it doesn’t sound bad, but how do we do it?

Judy: We’ve been coming up with some great algorithms, so

I’m sure we can tackle sorting.

Joe: Actually, sorting algorithms are a topic some computer

scientists spend their entire careers researching. They’re not

something we should “come up with,” but rather we need

to research the existing algorithms and choose one that is

appropriate for our problem.

Frank: It sounds like we’re going to be researching for a

while. Should we postpone the softball game this afternoon?

Joe: I don’t think so, Frank. I saw this coming and I’ve already taken a look.

Frank: Oh, why didn’t you say so? What kind of sort are we going to use?

Joe: Bubble sort.

Judy, Frank (chuckling): Very funny, Joe. We know we’re sorting bubbles. Do you have a sort

that is appropriate or not?

Joe: I’m actually being completely serious. We’re going to use a bubble sort. It’s not the most

efficient sorting algorithm ever invented, but it is one of the easiest to understand.

Frank: I don’t get it; was it invented by one of our competitors?

Joe: Oh, you mean the name. It’s called bubble sort because as you run the algorithm, the larger

(or smaller) items in the list tend to “bubble up” to one end. You’ll see how that looks when we

start implementing it.

Judy: Joe, you seem to have done your homework, so we’ll take your lead on this.

Joe: Okay, let’s do it.

Judy: That reminds me, I told Greg to get on this too. I didn’t realize you’d already done all this

research. I need to remember to tell him not to bother. Don’t let me forget!

We just need to sort

them? That doesn’t

sound too bad.

Frank

Judy

Joe

228 Chapter 4B

how bubble sort works

We’re going to look at some pseudocode for bubble sort shortly, but before we

do, let’s get an intuitive feel for how this algorithm works. To do that, let’s sort a

list of numbers:

Understanding bubble sort

[6, 2, 5, 3, 9]

We typically think of sorting lists into ascending order, so we’re expecting our list

to look like this after the bubble sort algorithm has finished:

[2, 3, 5, 6, 9]

Here’s our

unsorted list.

The same list sorted in

ascending order.

One thing to know up front: bubble sort works by making a number of passes over a

list. As you’ll see, in each pass, if we end up swapping any values in the list, we’ll need

to make another pass. When no values are swapped in a pass, we’re done. Keep that in

mind, as it’s key to how the algorithm works.

[6, 2, 5, 3, 9]

Compare these. The

first is larger, so we

need to swap them.

[2, 6, 5, 3, 9]

We begin by comparing the first and second items (the items at index

0 and 1). If the first item is larger than the second, we swap them:

Starting with pass 1

[2, 5, 6, 3, 9]

Notice the value 6 used to be the first in the list, and it is

slowly making its way (bubbling) toward the end of the list.

[2, 5, 3, 6, 9]

Next we compare the values of index 1 and index 2. If the first value,

6, is larger than the second value, 5 (and it is), we swap them.

Moving along, we compare the next values at index 2 and index 3,

and once again, the first is larger. So we swap.

Next we compare the value at index 3 to the value at index 4, and it is

not larger. So, we do nothing and pass 1 is complete.

At this point we’re done with pass 1, but we swapped some values, so

we need to do another pass. On to pass 2!

[2, 5, 3, 6, 9]

No change.

Swap.

you are here 4 229

sorting and nested iteration

[2, 5, 3, 6, 9]

[2, 3, 5, 6, 9]

Moving on, we compare the values of index 1 and index 2; in this case,

the index 2 value is larger than index 3, so we swap values.

Pass 2

You’re staring to understand the method now: we now compare the

values of index 2 and index 3, and the value 5 is not larger than 6, so

we do not swap values.

[2, 3, 5, 6, 9]

No change.

[2, 3, 5, 6, 9]

No change.

Swap.

Moving on, we compare the 3rd and 4th index values, and the 4th

value is larger, so we do not need to swap.

Now pass 2 is over, but we swapped index 2 and 3 during this pass, so

we need to do another pass. On to pass 3.

[2, 3, 5, 6, 9]

On pass 3 we start over once again, comparing index 0’s value to

index 1’s; index 1 has a larger value, so we don’t need to swap values.

Pass 3

Moving on we compare the values of index 2 and 3; index 3’s value is

larger, so we don’t need to swap.

[2, 3, 5, 6, 9]

No change.

[2, 3, 5, 6, 9]

No change.

Likewise, we compare the values of index 3 and 4; index 4’s value is

larger, so we don’t need to swap.

Now pass 3 is over, and we didn’t swap any values. So our

algorithm is complete and we have a sorted list!

[2, 5, 3, 6, 9]

On pass 2 we start over, comparing the values of index 0 and index 1;

index 1 has a larger value, so we don’t need to swap values.

[2, 3, 5, 6, 9]

No change.

[2, 3, 5, 6, 9]

Now we compare the values of index 1 and 2; index 2’s value is larger,

so we don’t need to swap.

No change.

230 Chapter 4B

some practice with bubble sort

Hopefully you now have a good feel for how to apply bubble sort’s

algorithm. Let’s practice. Take the list below and bubble sort it, showing

your work just like we did on the previous two pages. This will help to lock

in your understanding. If you get stuck, take a peek at our solution at the

end of the chapter.

['coconut', 'strawberry', 'banana', 'pineapple']

Here's the list. Don't

let the strings throw

you; just compare them

alphabetically (what a

computer scientist would

call lexicographically,

otherwise known as

dictionary order).

Pass 1

Start pass 1 here.

We’re not asking you to write

any code, we’re just asking

you to use the bubble sort

algorithm to sort this list.

you are here 4 231

sorting and nested iteration

DECLARE a variable swapped and set to True.

WHILE swapped:

SET swapped to False.

FOR variable i in range(0, len(list)-1)

IF list[i] > list[i+1]:

DECLARE a variable temp and set to list[i].

SET list[i] to list[i+1]

SET list[i+1] to temp

SET swapped to True.

DEFINE a function bubble_sort(list):

Pseudocode can take many

forms. This form is closer to

code, but still not quite code,

at least not Python.

Now that you have an intutive feel for the bubble sort, let’s actually look at some

pseudocode for the algorithm. You’ve already got all the knowledge you need

to understand this code; it uses basic Boolean logic and some loops. However,

it does use loops in a more complex way than you’ve seen before by using two

loops together—what we call a nested loop.

Nested loops can make you stop and think the first time you see one, but here’s

the trick: you just mentally did a nested loop when you worked through the last

Sharpen exercise (as well as when we walked through sorting the list of numbers

together). The outer loop represents each pass in the algorithm. The inner

loop goes through each item in the list and performs the comparisons (and any

needed swapping). So with that in mind, let’s have a look:

Some bubble sort pseudocode

We’re going to have a function, bubble_sort,

which takes a list as a parameter.

And we’re going to have a

variable to track if we’ve

swapped any values in the

current pass. We set this

to True initially to kick off

the first pass.

We’re going to use a

while loop that loops as

long as swapped is True.

Think of the while loop

as performing each pass.

Each time through the

loop is another pass.

In the for loop, you

iterate through each

item in the list (except

the last item) and

compare it to the next.

If it’s greater, then you

swap the values.

The first thing we

do in the loop is set

swapped to False.

If we ever swap any values, we set swapped

to True, meaning we’re going to have to do

another pass when the for loop finishes.

This pseudocode sorts a list in ascending order. What change would you need to make to sort in

descending order?

Let’s put all that

Chapter 5 function

knowledge to work!

232 Chapter 4B

understanding the pseudocode

Cubicle conversation

continued...

Judy: I think so, if I understand the two

loops.

Joe: Right, so there is a while loop and a

for loop that runs within it.

Judy: Okay, so stepping through this—the

outer while statement loops until the

swapped variable has the value False.

Joe: Yes, we go one time through the

while loop for each pass we need to make

over the list.

Judy: But in all our examples wasn’t that

always three times?

What do you

think of the pseudocode;

does it make sense?

Joe: Oh, that was a total coincidence; the algorithm can have any number of passes. Actually, that

isn’t quite accurate—in the worst case, it has the same number of passes as there are items in the list.

Judy: So if I have 100 items, the while loop could loop 100 times?

Joe: Yup.

Judy: Why so many?

Joe: That’s the worst case; if the list is in totally backward order, it takes that many passes.

Judy: Got it. Okay, now the inner loop, the for loop. What’s happening there?

Joe: The for loop walks through every item and compares it to the next item. If the first item is of

greater value, then we swap the two.

Judy: So the for loop is also iterating through all items in the list as well, only not in the worst case,

but always.

Joe: Technically the number of items minus one, but yes.

Judy: For a big list that is a lot of iterating.

Joe: It sure is. If you use your example of 100 items, the worst case is roughly 100 passes comparing

100 items in each pass. So we’re talking 100 * 100 = 10,000 comparisons.

Judy: Whoa!

Joe: Yes, bubble sort is known more for its simplicity than its efficiency. Why do you think so many

people spend their time trying to create fast sorting algorithms? But our lists are very small, so it’s

really not a problem in our case, and a perfectly acceptable way for us to sort.

Judy: Okay, and the only other thing happening in the for loop is that if we swapped some values,

we have to set the swapped variable back to True, which means we’ll do another pass.

Joe: Bingo.

you are here 4 233

sorting and nested iteration

for word in ['ox', 'cat', 'lion', 'tiger', 'bobcat']:

for i in range(2, 7):

letters = len(word)

if (letters % i) == 0:

print(i, word)

For these bits of code, your job is to

play like you’re the Python interpreter.

Step through each bit of code and evaluate

it (in your brain). After you’ve done the

exercises, look at the end of the chapter to

see if you got it right.

BE the

Interpreter

for i in range(0,4):

for j in range(0,4):

print(i * j)

full = False

donations = []

full_load = 45

toys = ['robot', 'doll', 'ball', 'slinky']

while not full:

for toy in toys:

donations.append(toy)

size = len(donations)

if (size >= full_load):

full = True

print('Full with', len(donations), 'toys')

print(donations)

Remember modulus is like

finding the remainder of a

division. So, 4%2 would be 0,

while 4%3 would be 1.

234 Chapter 4B

implementing bubble sort

def bubble_sort(scores):

swapped = True

while swapped:

swapped = False

for i in range(0, len(scores)-1):

if scores[i] > scores[i+1]:

temp = scores[i]

scores[i] = scores[i+1]

scores[i+1] = temp

swapped = True

Our pseudocode is fairly close to code, and translating it into Python is

straightforward. Let’s take a look:

Implementing bubble sort in Python

Just like the variable swap code

we looked at in Chapter 2!

Here’s our function,

which takes a

Python list.

We set the swapped variable to True

to kick off the first pass.

Our nested loop: a

for loop within a

while loop

We make our passes with the while

loop as long as swapped is True…

…and then step through the entire list

comparing and swapping values where needed.

Note there is nothing to return because

we've swapped the actual values of the list.

In other words, we've changed the original

list to be in sorted order.

scores = [60, 50, 60, 58, 54, 54,

58, 50, 52, 54, 48, 69,

34, 55, 51, 52, 44, 51,

69, 64, 66, 55, 52, 61,

46, 31, 57, 52, 44, 18,

41, 53, 55, 61, 51, 44]

bubble_sort(scores)

print(scores)

smoothies = ['coconut', 'strawberry', 'banana', 'pineapple']

bubble_sort(smoothies)

print(smoothies)

Python 3.6.0 Shell

[18, 31, 34, 41, 44, 44, 44, 46, 48, 50,

50, 51, 51, 51, 52, 52, 52, 52, 53, 54,

54, 54, 55, 55, 55, 57, 58, 58, 60, 60,

61, 61, 64, 66, 69, 69]

['banana', 'coconut', 'pineapple',

'strawberry']

>>>

Nice, those look

sorted!

Python's > comparison works with

strings too, so we can also have the

sort function sort our smoothies.

Let’s start a new file called sort.py. Copy the code above into it, and add the test

code below:

A Test Drive

you are here 4 235

sorting and nested iteration

def bubble_sort(scores):

swapped = True

while swapped:

swapped = False

for i in range(0, len(scores)-1):

if scores[i] < scores[i+1]:

temp = scores[i]

scores[i] = scores[i+1]

scores[i+1] = temp

swapped = True

This is all you need to change

to have a descending sort.

Why does this work?

Python 3.6.0 Shell

[69, 69, 66, 64, 61, 61, 60, 60, 58, 58,

57, 55, 55, 55, 54, 54, 54, 53, 52, 52,

52, 52, 51, 51, 51, 50, 50, 48, 46, 44,

44, 44, 41, 34, 31, 18]

['strawberry', 'pineapple', 'coconut',

'banana']

>>>

There we go; sort in

descending bubble score

order.

I think we’re almost there; we just

need to generate the report with

the top 5 solutions, scores along with

their number.

Frank: Yay, Joe wrote all the sort code! But something is missing. We’re sorting the

list of scores, but we have no idea what the original index of the score was, so how do

we know the score number? We need that for the report.

Judy: That’s a good point. How can we do that?

Frank: Well, Joe may be the rock star here, but I had an idea. What if we make

another list, a parallel list called solutions_numbers, where each value in the list

is the same as its index, like [0, 1, 2, 3, ..., 35]? Then, when we sort the

scores, we sort this list exactly the same way. So, at the end, each score number will

be in the same relative position as its corresponding score.

Judy: How do we create a list like that where the values match the indices?

Frank: Remember, you can use range and list together to do that. Like this:

Judy: Interesting. Okay, I think I sort of understand your direction.

Frank: Some things are actually easier to explain over code. Here, check this out...

We’d like to have the solutions with the highest bubble scores first (in other words

we want descending order, not ascending). We can do that by simply changing the

comparison in the sort function from a > to a < comparison. Make the change

and do another test drive.

A Test Drive

number_of_scores = len(scores)

solution_numbers = list(range(number_of_scores))

Get the length of the list.

Create a range from 0 to the

length of the list (minus 1) and then

use the list function to convert the

range into a list [0, 1, 2, ... ].

236 Chapter 4B

sorting the bubble solution numbers too

def bubble_sort(scores, numbers):

swapped = True

while swapped:

swapped = False

for i in range(0, len(scores)-1):

if scores[i] < scores[i+1]:

temp = scores[i]

scores[i] = scores[i+1]

scores[i+1] = temp

temp = numbers[i]

numbers[i] = numbers[i+1]

numbers[i+1] = temp

swapped = True

scores = [60, 50, 60, 58, 54, 54,

58, 50, 52, 54, 48, 69,

34, 55, 51, 52, 44, 51,

69, 64, 66, 55, 52, 61,

46, 31, 57, 52, 44, 18,

41, 53, 55, 61, 51, 44]

number_of_scores = len(scores)

solution_numbers = list(range(number_of_scores))

bubble_sort(scores, solution_numbers)

Frank was right. We have a way to sort the bubble scores, but

when we do sort them we lose the identifying number of that

score (because we’ve always used the index of the solution

as the bubble number). So what we’re going to do is create

a second list that contains each solution’s corresponding

bubble number, and then, when we sort the solution’s scores,

we’re going to, in sync, sort the bubble numbers list the same

exact way. Let’s check out his code:

Computing bubble solution numbers

…except, when we swap two values of

the score list, we swap the same two

values in the numbers list.

Everything else works

exactly the same as

before...

First, we’re going to accept two lists

in our bubble_sort function, the scores

and the corresponding bubble numbers.

If you think this looks like

duplicated code, it is. We’ll find out

in the next chapter how to remove

duplicate code.

Here we’re just creating the

solution_numbers list, which holds

the number of each solution (and

corresponds to its original index in

the scores list).

Now when we call sort, we pass both lists.

Serious Coding

How do you go about evaluating an

expression like the one below? Evaluate

from the inside out:

list(range(number_of_scores))

Evalutes to the integer

length of scores: 36

Evaluates to the range 0

through 35

Evaluates to the list

containing the numbers 0

through 35

you are here 4 237

sorting and nested iteration

print('Top Bubble Solutions')

for i in range(0,5):

print(str(i+1) + ')',

'Bubble solution #' + str(solution_numbers[i]),

'score:', scores[i])

Python 3.6.0 Shell

Top Bubble Solutions

1) Bubble solution #11 score: 69

2) Bubble solution #18 score: 69

3) Bubble solution #20 score: 66

4) Bubble solution #19 score: 64

5) Bubble solution #23 score: 61

>>>

Take the code from the last Sharpen exercise (repeated below) and add to your

sort.py file, replacing the previous test code. Give it a test drive.

A Test Drive

Exactly like the CEO requested. Boy,

is he going to be happy!

Now our code produces two lists, one with the

scores sorted and another with the corresponding

solution numbers. Write the code to generate the

report given these two lists.

Bubbles-R-Us

Top Bubble Solutions

1) Bubble solution #10 score: 68

2) Bubble solution #12 score: 60

3) Bubble solution #2 score: 57

4) Bubble solution #31 score: 50

5) Bubble solution #3 score: 34

Remember the report looks like this;

also remember this is not the actual

data your report will generate, just a

mockup from the CEO.

238 Chapter 4B

review of sorting

Top Bubble

Software Maker

Not only am I giving my top

five bubble solution engineers awards,

I’m giving YOU an award. We could not

have made Bubbles-R-Us successful without

all the business intelligence your code

provided!

Nice job.

It’s been a short but challenging

chapter. You’ve had to wrap your head

around lots of new concepts. Give

your brain some time to let it all sink

in. Of course make some more of that

bubble solution #11; that’s a great way

to relax and do something completely

different. Get some rest too, and after

that, maybe even quickly review this

chapter before you move on.

Of course you aren’t quite done yet.

You’ve got a brain twister ahead, and

the bullet points and the crossword...

There are many sorting algorithms with

various tradeoffs in complexity and space/

time considerations.

Bubble sort is a simple algorithm that

makes passes through a list, comparing

and swapping values as it goes.

Bubble sort is complete when a pass

through the list nds no items that are out

of order.

Most languages and libraries provide sort

functionality.

When we have a loop within a loop, we call

it a nested loop.

Nested loops often increase the runtime

and complexity of an algorithm.

It’s worth studying sorting algorithms

and the sort algorithms provided by your

language’s libraries, which, speaking of...

you are here 4 239

sorting and nested iteration

Uh, you’re not going to believe

this. I just went to tell Greg we

had solved the problem and he’d

beat us to it. In fact he hardly had to

write any code; he did it using Python’s

built-in sort!

Built-in

sort! Maybe

you could have let

us know 10 pages

back?

You’ll find sort provided by most languages.

Yes, you’ll find many modern languages and many libraries

provide sort functionality. Given that, there’s ususally no

reason to write your own sort—not only would you be

reinventing the wheel, but off-the-shelf sort algorithms tend

to be more sophisticated (and more efficient) than bubble

sort and take significant time and effort to implement.

So, unless your passion turns out to be sorting algorithms,

wouldn’t you rather be working on your probem at hand?

Our time on the last 10 pages is not wasted, though,

because the techniques you just learned in implementing

bubble sort, like using nested loops, are core to

implementing many algorithms. And, should you need to

study sorting or a related algorithm, bubble sort is where

most folks start.

Back to Python, you can sort a list by simply calling sort:

scores.sort()

And there are lots of ways to customize Python’s sort to your

needs, but you’ll want to learn a few more programming

concepts to make full use of that.

Finally, if you’re interested in sorting, you’ll want to study up

on the many sorting algorithms and their advantages and

disadvantages. With every algorithm you’ll encounter, there

are tradeoffs in time (how long it takes) and space (the amount

of memory or resources it uses). Some rather well-known

sorts are insertion sort, merge sort, and quicksort, just to

name a few. Oh, and Python interally uses Timsort, a hybrid

of merge and insertion sort. Here’s a good place to start your

studies: https://en.wikipedia.org/wiki/Sorting_algorithm.

240 Chapter 4B

a deep thinking exercise

The Thing-A-Ma-Jig

The Thing-A-Ma-Jig is a crazy contraption—it clanks and clunks and even thunks,

Whether you give it lists or strings, it still does things. But how exactly does it

work? Can you uncrack the code and find its quirks?

The Thing-A-Ma-Jig

Try these as a replacement for characters’ value above:

characters = ‘amanaplanac’

characters = ‘wasitar'

characters = 'taco'

output = ''

length = len(characters)

i = 0

while (i < length):

output = output + characters[i]

i = i + 1

length = length * -1

i = -2

while (i >= length):

output = output + characters[i]

i = i - 1

print(output)

All we changed was the

list—now it's a string. But

the code still works. How?

How does this code work on lists AND strings?

We'll leave you with that deep question, and we'll

uncover some answers in Chapter 6 (and beyond).

Try a deep thinking exercise before you finish off Chapter 4, part 2...

you are here 4 241

sorting and nested iteration

['coconut', 'strawberry', 'banana', 'pineapple']

Here's the list. Don't

let the strings throw

you; just compare them

alphabetically (what a

computer scientist would

call lexicographically,

otherwise known as

dictionary order).

Pass 1

['coconut', 'strawberry', 'banana', 'pineapple']

['coconut', 'banana', 'strawberry', 'pineapple']

['coconut', 'banana', 'pineapple', 'strawberry']

Pass 2

['coconut', 'banana', 'pineapple', 'strawberry']

['banana', 'coconut', 'pineapple', 'strawberry']

Pass 3

['banana', 'coconut', 'pineapple', 'strawberry']

Swap.

No change.

Swap.

No change.

Compare each index to the

next, iterating through the list.

Swap if the first value is > the

second.

We had swaps in pass 1, so

we need to do a pass 2.

We had no swaps in pass 3,

so we're done and the list

is sorted.

We had swaps in pass 2, so

we need to do a pass 3.

Hopefully you now have a good feel for how to apply bubble sort’s

algorithm. Let’s practice. Take the list below and bubble sort it, showing

your work just like we did on the previous two pages. This will help to lock

in your understanding.

242 Chapter 4B

exercise solution

for word in ['ox', 'cat', 'lion', 'tiger', 'bobcat']:

for i in range(2, 7):

letters = len(word)

if (letters % i) == 0:

print(i, word)

For these bits of code, your job is to

play like you’re the Python interpreter.

Step through each bit of code and evaluate

it (in your brain). After you’ve done the

exercises, look at the end of the chapter to

see if you got it right.

BE the Interpreter

SOLUTION

for i in range(0,4):

for j in range(0,4):

print(i * j)

full = False

donations = []

full_load = 45

toys = ['robot', 'doll', 'ball', 'slinky']

while not full:

for toy in toys:

donations.append(toy)

size = len(donations)

if (size >= full_load):

full = True

print('Full with', len(donations), 'toys')

print(donations)

Python 3.6.0 Shell

2 ox

3 cat

2 lion

4 lion

5 tiger

2 bobcat

3 bobcat

6 bobcat

>>>

Python 3.6.0 Shell

>>>

Python 3.6.0 Shell

Full with 48 toys

['robot', 'doll', 'ball', 'slinky', 'robot', 'doll',

'ball', 'slinky', 'robot', 'doll', 'ball', 'slinky',

'robot', 'doll', 'ball', 'slinky', 'robot', 'doll',

'ball', 'slinky', 'robot', 'doll', 'ball', 'slinky',

'robot', 'doll', 'ball', 'slinky', 'robot', 'doll',

'ball', 'slinky', 'robot', 'doll', 'ball', 'slinky',

'robot', 'doll', 'ball', 'slinky', 'robot', 'doll', 'ball',

'slinky', 'robot', 'doll', 'ball', 'slinky']

>>>

you are here 4 243

sorting and nested iteration

Now our code produces two lists, one

with the scores sorted and another with

the corresponding solution numbers.

Write the code to generate the report

given these two lists.

Bubbles-R-Us

Top Bubble Solutions

1) Bubble solution #10 score: 68

2) Bubble solution #12 score: 60

3) Bubble solution #2 score: 57

4) Bubble solution #31 score: 50

5) Bubble solution #3 score: 34

print('Top Bubble Solutions')

for i in range(0,5):

print(str(i+1) + ')',

'Bubble solution #' + str(solution_numbers[i]),

'score:', scores[i])

Print the heading.

Iterate through five times

for the top five scores.

For each line of output, print the final standing of

the solution with the value i plus 1,the solution number

from the solution_numbers list, and the score from the

scores list.

this is a new chapter 245

text, strings, and heuristics

Putting It All Together

You’ve already got a lot of superpowers. Now it’s time to

use them. In this chapter we’re going to integrate what we’ve learned so far,

bringing it all together to build some increasingy cool code. We’re also going

to keep adding to your knowledge and coding skills. More specifically, in this

chapter we’ll explore how to write code that grabs some text, slices it, dices

it, and then does a little data analysis on it. We’re going to find out what a

heuristic is too, and implement one. Get ready—this is an all-out, heads-down,

pedal-to-the-metal, serious coding chapter!

Not so fast.

Sure, you know variables

and data types and

iteration and functions,

but can you put it all

together?

And by the end of the chapter

you'll realize how much you've

learned about coding!

246 Chapter 6

intro to data sciences

Heard of data science? It’s all about extracting insight and

knowledge from data, and we’re about to get into the business. Our

data? Any text: news articles, blog posts, books, anything written by

an author. And what we’re going to do with all that text is tell the

world how readable it is. That is, could a 5th grader read it, or does it

take a Ph.D.? With our app, we’ll soon know.

Now to perform such an analysis, we’re going to have to dig deep;

we’re going to examine, as you’ll soon discover:

every sentence…

and every word…

and every syllable...

not to mention every single character of the text in question!

With all that analysis, we’re going to come up with a score that

maps to a reading level, from 5th grade all the way up to a college

graduate. Let’s dig in and see more precisely how this is going to

work...

Welcome to the data sciences

Definitely

some sophisticated

writing in this book.

you are here 4 247

text, strings, and heuristics

Luckily someone else has already answered this question—namely,

the US Navy and Army, who have been testing a key formula for

years in the military to assess the readability of things like (we’re

assuming) tank training manuals. Here’s how it works: take the text

you want to analyze and run it through the following formula to get

back a reading ease score. We’ll talk in a second about what that score

means. Here’s the formula:

How do you compute

something like readability?

We’re not kidding; you can read up on

it here: https://en.wikipedia.org/wiki/

Flesch–Kincaid_readability_tests.

total words

total wordstotal sentences

total syllables

( () )

– 84.6206.835 – 1.015

The formula makes use of three

different numbers we’re going

to need to compute.

We start with the total number

of words in the text, which is

used in two places in the formula.

We also need to compute the total

number of syllables in the text.

We also need to compute the

total number of sentences.

Once we’ve computed those values, the

formula just consists of standard

multiplication, division, and subtraction,

with a few floating-point values like 84.6.

After we’ve used this formula to compute a score, we map the score to

the reading ease of the text using this chart:

Score School Level Notes

100.00–90.00 5th grade Very easy to read. Easily understood by an average 11-year-old student.

90.0–80.0 6th grade Easy to read. Conversational English for consumers.

80.0–70.0 7th grade Fairly easy to read.

70.0–60.0 8th & 9th grade Plain English. Easily understood by 13- to 15-year-olds.

60.0–50.0 10th–12th grade Fairly dicult to read.

50.0–30.0 College Dicult to read.

30.0–0.0 College Graduate Very dicult to read. Best understood by university graduates.

Say you were writing some text

for advertising; how would you

want it to score?

The higher the score, the easier your text is to read.

You'll find the original chart at

the Wikipedia URL above.

If you're wondering where numbers like 206.835

come from, all we can say is years of research (see

the Wikipedia article above).

To give due credit, the formula

was originally developed by

Rudolph Flesch in 1948. Dr.

Flesch was an author who

earned a Ph.D. in English at

Columbia University.

248 Chapter 6

planning the implementation

Can you come up with an algorithm to compute the number of syllables in an

arbitrary word? Assume you don’t have a large dictionary at your disposal. Write

your algorithm here in pseudocode.

At first glance computing readability just comes down to computing a

formula. But, if we look closer, it’s the key values that we need for that

formula where the computing comes in. That’s because, to complete

the formula, we need:

The game plan

1To compute the total number of words in our text: that

means we’ll have to take our text and break it down into

words and count them.

2To compute the total number of sentences in our text: that

means we’ll have to take our text and break it down into its

individual sentences and count them.

3To compute the total number of syllables in our text: that

means we’ll have to take each word, figure out how many

syllables it has, and then add up all the syllables in the

entire text.

to irritating differences of

open quarrels, and a coolness

by dropping the distasteful

opinion arose. It is but one

differences, with candor and

One of the first rules for a guide in polite conversation, is to avoid

political or religious discussions in general society. Such discussions

lead almost invariably to irritating differences of opinion, often to

open quarrels, and a coolness of feeling which might have been avoided

by dropping the distasteful subject as soon as marked differences of

opinion arose. It is but one out of many that can discuss either

political or religious differences, with candor and judgment, and yet so

far control his language and temper as to avoid either giving or taking

offence.