Learn to Program with Python

Irv Kalb

Learn to Program with Python

Irv Kalb Mountain View, California, USA

ISBN-13 (pbk): 978-1-4842-1868-6 ISBN-13 (electronic): 978-1-4842-2172-3DOI 10.1007/ 978-1-4842-2172-3

Library of Congress Control Number: 2016949498

Copyright © 2016 by Irv Kalb

This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed.

Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark.

The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights.

While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein.

Managing Director: Welmoed SpahrLead Editor: Steve AnglinTechnical Reviewer: Michael ThomasEditorial Board: Steve Anglin, Pramila Balan, Laura Berendson, Aaron Black, Louise Corrigan, Jonathan

Gennick, Robert Hutchinson, Celestin Suresh John, Nikhil Karkal, James Markham, Susan McDermott, Matthew Moodie, Natalie Pao, Gwenan Spearing

Coordinating Editor: Mark PowersCopy Editor: Kim Burton-WeismanCompositor: SPi GlobalIndexer: SPi GlobalArtist: SPi Global

Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny@springer-sbm.com , or visit www.springeronline.com . Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation.

For information on translations, please e-mail rights@apress.com , or visit www.apress.com .

Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Special Bulk Sales–eBook Licensing web page at www.apress.com/bulk-sales .

Any source code or other supplementary materials referenced by the author in this text are available to readers at www.apress.com/9781484218686 . For detailed information about how to locate your book’s source code, go to www.apress.com/source-code . Readers can also access source code at SpringerLink in the Supplementary Material section for each chapter.

Printed on acid-free paper

Th is book is dedicated to the memory of my mother, Lorraine Kalb.

I started learning about programming when I was 16 years old, at Columbia High School in Maplewood, NJ. We were extremely fortunate to have a very

early computer, an IBM 1130, that students could use.

I remember learning the basics of the Fortran programming language and writing a simple program that would add two numbers together and print the result. I was thrilled when I fi nally got my program to work correctly. It was a

rewarding feeling to be able to get this huge, complicated machine to do exactly what I wanted it to do.

I clearly remember explaining to my mother that I wrote this program that got the computer to add 9 and 5 and come up with an answer of 14. She said

that she didn’t need a computer to do that. I tried to explain to her that getting the answer of 14 was not the important part. What was important was that I had

written a program that would add any two numbers and print the result. She still didn’t get it, but she was happy for me and very supportive.

Hopefully, through my explanations in this book, you will get it.

v

Contents at a Glance

About the Author ...................................................................................................xvii

About the Technical Reviewer ................................................................................xix

Acknowledgments ..................................................................................................xxi

■Chapter 1: Getting Started ..................................................................................... 1

■Chapter 2: Variables and Assignment Statements ................................................ 7

■Chapter 3: Built-in Functions ............................................................................... 35

■Chapter 4: User-Defi ned Functions ...................................................................... 47

■Chapter 5: if, else, and elif Statements ................................................................ 71

■Chapter 6: Loops ................................................................................................ 103

■Chapter 7: Lists ................................................................................................. 133

■Chapter 8: Strings.............................................................................................. 165

■Chapter 9: File Input/Output .............................................................................. 181

■Chapter 10: Internet Data .................................................................................. 209

■Chapter 11: Data Structures .............................................................................. 227

■Chapter 12: Where to Go from Here ................................................................... 257

Index ..................................................................................................................... 261

vii

Contents

About the Author ............................................................................................... xvii

About the Technical Reviewer ............................................................................ xix

Acknowledgments .............................................................................................. xxi

■Chapter 1: Getting Started ..................................................................................1

Welcome ....................................................................................................................... 1

What Is Python? ........................................................................................................... 1

Installing Python ........................................................................................................... 2

IDLE and the Python Shell ............................................................................................ 2

Hello World ................................................................................................................... 3

Creating, Saving, and Running a Python File ................................................................ 4

IDLE on Multiple Platforms ........................................................................................... 6

Summary ...................................................................................................................... 6

■Chapter 2: Variables and Assignment Statements .............................................7

A Sample Python Program ........................................................................................... 8

The Building Blocks of Programming ........................................................................... 9

Four Types of Data ...................................................................................................... 10

Integers............................................................................................................................................ 10

Floats ............................................................................................................................................... 10

Strings ............................................................................................................................................. 10

Booleans .......................................................................................................................................... 11

Examples of Data ............................................................................................................................. 11

Form with Underlying Data .............................................................................................................. 12

■ CONTENTS

viii

Variables ......................................................................................................................... 13

Assignment Statements ................................................................................................. 16

Variable Names .............................................................................................................. 18

Naming Convention .............................................................................................................................. 19

Keywords .............................................................................................................................................. 20

Case Sensitivity .................................................................................................................................... 21

More Complicated Assignment Statements.......................................................................................... 21

Print Statements ............................................................................................................ 22

Simple Math ................................................................................................................... 24

Order of Operations ........................................................................................................ 26

First Python Programs .................................................................................................... 27

Shorthand Naming Convention ....................................................................................... 28

Adding Comments .......................................................................................................... 30

Full-Line Comment ............................................................................................................................... 30

Add a Comment After a Line of Code .................................................................................................... 30

Multiline Comment ............................................................................................................................... 30

Whitespace ..................................................................................................................... 31

Errors .............................................................................................................................. 32

Syntax Error .......................................................................................................................................... 32

Exception Error ..................................................................................................................................... 33

Logic Error ............................................................................................................................................ 34

Summary ........................................................................................................................ 34

■Chapter 3: Built-in Functions ............................................................................... 35

Overview of Built-in Functions ....................................................................................... 35

Function Call .................................................................................................................. 36

Arguments ...................................................................................................................... 36

Results ........................................................................................................................... 36

Built-in type Function ..................................................................................................... 36

■ CONTENTS

ix

Getting Input from the User ............................................................................................ 38

Conversion Functions ..................................................................................................... 39

int Function ........................................................................................................................................... 39

fl oat Function ........................................................................................................................................ 39

str Function .......................................................................................................................................... 39

First Real Programs ........................................................................................................ 40

Concatenation ................................................................................................................ 42

Another Programming Exercise ...................................................................................... 43

Using Function Calls Inside Assignment Statements ..................................................... 45

Summary ........................................................................................................................ 46

■Chapter 4: User-Defi ned Functions ...................................................................... 47

A Recipe as an Analogy for Building Software ............................................................... 48

Ingredients ............................................................................................................................................ 48

Directions ............................................................................................................................................. 48

Defi nition of a Function .................................................................................................. 50

Building Our First Function ............................................................................................. 51

Calling a User-Defi ned Function ..................................................................................... 51

Receiving Data in a User-Defi ned Function: Parameters ................................................ 53

Building User-Defi ned Functions with Parameters......................................................... 54

Building a Simple Function that Does Addition .............................................................. 56

Building a Function to Calculate an Average .................................................................. 57

Returning a Value from a Function: The return Statement ............................................. 57

Returning No Value: None ............................................................................................... 59

Returning More Than One Value ..................................................................................... 59

Specifi c and General Variable Names in Calls and Functions ........................................ 60

Temperature Conversion Functions ................................................................................ 61

Placement of Functions in a Python File ........................................................................ 62

Never Write Multiple Copies of the Same Code .............................................................. 62

Constants ....................................................................................................................... 64

■ CONTENTS

x

Scope ............................................................................................................................. 64

Global Variables and Local Variables with the Same Names .......................................... 67

Finding Errors in Functions: Traceback .......................................................................... 68

Summary ........................................................................................................................ 70

■Chapter 5: if, else, and elif Statements ................................................................ 71

Flowcharting .................................................................................................................. 72

The if Statement ............................................................................................................. 74

Comparison Operators .................................................................................................... 76

Examples of if Statements ............................................................................................. 76

Nested if Statement ....................................................................................................... 77

The else Statement ........................................................................................................ 78

Using if/else Inside a Function ....................................................................................... 80

The elif Statement .......................................................................................................... 80

Using Many elif Statements ........................................................................................... 82

A Grading Program ......................................................................................................... 84

A Small Sample Program: Absolute Value ...................................................................... 84

Programming Challenges ............................................................................................... 86

Negative, Positive, Zero......................................................................................................................... 86

isSquare................................................................................................................................................ 88

isEven ................................................................................................................................................... 91

isRectangle ........................................................................................................................................... 93

Conditional Logic ............................................................................................................ 94

The Logical not Operator ............................................................................................... 95

The Logical and Operator ............................................................................................... 95

The Logical or Operator ................................................................................................. 96

Precedence of Comparison and Logical Operators ........................................................ 97

Booleans in if Statements .............................................................................................. 98

Program to Calculate Shipping ....................................................................................... 98

Summary ...................................................................................................................... 101

■ CONTENTS

xi

■Chapter 6: Loops ................................................................................................ 103

User’s View of the Game .............................................................................................. 104

Loops ............................................................................................................................ 105

The while Statement .................................................................................................... 106

First Loop in a Real Program ........................................................................................ 108

Increment and Decrement ............................................................................................ 109

Running a Program Multiple Times .............................................................................. 110

Python Built-in Packages ............................................................................................. 111

Generating a Random Number ..................................................................................... 112

Simulation of Flipping a Coin ....................................................................................... 113

Other Examples of Using Random Numbers ................................................................ 114

Creating an Infi nite Loop .............................................................................................. 115

A New Style of Building a Loop: while True, and break ................................................ 116

The continue Statement ............................................................................................... 118

Asking If the User Wants to Repeat: the Empty String ................................................. 120

Pseudocode .................................................................................................................. 120

Building the “Guess the Number” Program .................................................................. 121

Playing a Game Multiple Times .................................................................................... 125

Error Checking with try/except .................................................................................... 127

Building Error-Checking Utility Functions ..................................................................... 129

Coding Challenge ......................................................................................................... 130

Summary ...................................................................................................................... 132

■Chapter 7: Lists ................................................................................................. 133

Collections of Data ....................................................................................................... 134

Lists .............................................................................................................................. 134

Elements ...................................................................................................................... 135

Python Syntax for a List ............................................................................................... 135

Empty List..................................................................................................................... 136

■ CONTENTS

xii

Position of an Element in a List: Index ......................................................................... 136

Accessing an Element in a List .................................................................................... 137

Using a Variable or Expression as an Index in a List .................................................... 138

Changing a Value in a List ............................................................................................ 140

Using Negative Indices ................................................................................................. 140

Building a Simple Mad Libs Game ................................................................................ 141

Adding a List to Our Mad Libs Game ............................................................................ 142

Determining the Number of Elements in a List: The len Function ................................ 143

Programming Challenge 1 ............................................................................................ 144

Using a List Argument with a Function ........................................................................ 146

Accessing All Elements of a List: Iteration ................................................................... 147

for Statements and for Loops ....................................................................................... 148

Programming Challenge 2 ............................................................................................ 150

Generating a Range of Numbers .................................................................................. 151

Programming Challenge 3 ............................................................................................ 152

Scientifi c Simulations................................................................................................... 154

List Manipulation .......................................................................................................... 157

List Manipulation Example: An Inventory Example ....................................................... 158

Pizza Toppings Example ............................................................................................... 159

Summary ...................................................................................................................... 163

■Chapter 8: Strings.............................................................................................. 165

len Function Applied to Strings .................................................................................... 166

Indexing Characters in a String .................................................................................... 166

Accessing Characters in a String ................................................................................. 167

Iterating Through Characters in a String ...................................................................... 168

Creating a Substring: A Slice ........................................................................................ 170

Programming Challenge 1: Creating a Slice ................................................................. 171

■ CONTENTS

xiii

Additional Slicing Syntax .............................................................................................. 173

Slicing As Applied to a List ........................................................................................... 174

Strings Are Not Changeable ......................................................................................... 174

Programming Challenge 2: Searching a String ............................................................ 175

Built-in String Operations ............................................................................................. 176

Examples of String Operations ..................................................................................... 178

Programming Challenge 3: Directory Style .................................................................. 178

Summary ...................................................................................................................... 180

■Chapter 9: File Input/Output .............................................................................. 181

Saving Files on a Computer.......................................................................................... 182

Defi ning a Path to a File ............................................................................................... 182

Reading from and Writing to a File ............................................................................... 184

File Handle ................................................................................................................... 185

The Python os Package ................................................................................................ 186

Building Reusable File I/O Functions ............................................................................ 186

Example Using Our File I/O Functions .......................................................................... 187

Importing Our Own Modules......................................................................................... 188

Saving Data to a File and Reading It Back ................................................................... 190

Building an Adding Game ............................................................................................. 192

Programming Challenge 1 ............................................................................................ 192

Programming Challenge 2 ............................................................................................ 193

Writing/Reading One Piece of Data to and from a File ................................................. 196

Writing/Reading Multiple Pieces of Data to and from a File ......................................... 197

The join Function .......................................................................................................... 197

The split Function ......................................................................................................... 198

Final Version of the Adding Game ................................................................................. 199

Writing and Reading a Line at a Time with a File ......................................................... 201

■ CONTENTS

xiv

Example: Multiple Choice Test ...................................................................................... 203

A Compiled Version of a Module ................................................................................... 208

Summary ...................................................................................................................... 208

■Chapter 10: Internet Data .................................................................................. 209

Request/Response Model ............................................................................................. 209

Request with Values ..................................................................................................... 211

Example URL: Getting a Stock Price ............................................................................. 211

Pretending to Be a Browser ......................................................................................... 212

API ................................................................................................................................ 213

Example Program to Get Stock Price Information Using an API ................................... 214

Example Program to Get Exchange Rate Information .................................................. 216

Example Program to Get Powerball Information .......................................................... 219

API Key ......................................................................................................................... 223

URL Encoding ............................................................................................................... 223

Summary ...................................................................................................................... 225

■Chapter 11: Data Structures .............................................................................. 227

Tuple ............................................................................................................................. 228

Lists of Lists ................................................................................................................. 230

Representing a Grid or a Spreadsheet ......................................................................... 231

Representing the World of an Adventure Game ............................................................ 231

Reading a Comma-Separated Value (.csv) File ............................................................ 234

Dictionary ..................................................................................................................... 238

Using the in Operator on a Dictionary .......................................................................... 240

Programming Challenge ............................................................................................... 241

A Python Dictionary to Represent a Programming Dictionary ...................................... 242

Iterating Through a Dictionary ...................................................................................... 243

Combining Lists and Dictionaries ................................................................................. 244

JSON: JavaScript Object Notation ................................................................................ 246

■ CONTENTS

xv

Example Program to Get Weather Data ........................................................................ 248

XML Data ...................................................................................................................... 250

Accessing Repeating Groupings in JSON and XML ...................................................... 253

Summary ...................................................................................................................... 255

■Chapter 12: Where to Go from Here ................................................................... 257

Python Language Documentation ................................................................................ 257

Python Standard Library ............................................................................................... 257

Python External Packages ............................................................................................ 258

Python Development Environments ............................................................................. 259

Places to Find Answers to Questions ........................................................................... 259

Projects and Practice, Practice, Practice ...................................................................... 260

Summary ...................................................................................................................... 260

Index ..................................................................................................................... 261

xvii

About the Author

Irv Kalb is an adjunct professor at UCSC (University of California, Santa Cruz) Extension Silicon Valley, Cogswell Polytechnical College, and the Art Institute of California-Silicon Valley. He has been teaching software development classes since 2010.

Irv has worked as a software developer, manager of software developers, and manager of software development projects. He has worked as an independent consultant for many years with his own company, Furry Pants Productions, where he has concentrated on educational software. Prior to that, he worked as an employee for a number of high-tech companies. He has a BS and MS in computer science.

Recently, he has been a mentor to a number of local competitive robotics teams.

His previous publications include numerous technical articles, two children’s edutainment CD-ROMs (about Darby the Dalmatian), an online e-book on object-oriented programming in the Lingo programming language, and the first book on Ultimate Frisbee, Ultimate: Fundamentals of the Sport (Revolutionary Publications, 1983).

He was highly involved in the early development of the sport of Ultimate Frisbee.

xix

About the Technical Reviewer

Michael Thomas has worked in software development for more than 20 years as an individual contributor, team lead, program manager, and vice president of engineering. Michael has more than 10 years of experience working with mobile devices. His current focus is in the medical sector, using mobile devices to accelerate information transfer between patients and health care providers.

xxi

Acknowledgments

I would like to thank the following people, without whom, this book would not have been possible: My wonderful wife, Doreen, who is the glue that keeps our family together. Our two sons, Jamie and Robbie, who keep us on our toes. Our two cats, Chester and Cody (who we think of as people). Mariah Armstrong, who created all the graphics in this book. I am not an artist (I don’t even play one

on TV). Mariah was able to take my “chicken scratches” and turn them into very clear and understandable pieces of art.

Chris Sasso and Ravi Chityala for their technical review and helpful suggestions. Luke Kwan, Catherine Chanse, and Christina Ri, at the Art Institute of California-Silicon Valley Andy Hou at the UCSC-Silicon Valley Extension. Jerome Solomon at Cogswell Polytechnical College who first suggested that I consider getting into Python. Mark Powers, Matthew Moodie, Michael Thomas, and Steve Anglin at Apress for all the work they did

reviewing, editing, etc., and expertly answering all my questions. All the students that have been in my classes over many years at the Art Institute California-Silicon

Valley, at Cogswell Polytechnical College, and at the UCSC Silicon Valley Extension. Their feedback, suggestions, smiles, frowns, light-bulb moments, frustrations, and knowing head-nods were extremely helpful in shaping the content of this book.

Finally, Guido van Rossum, without whom, Python would not exist.