SECOND EDITION

FUNDAMENTALS OF PYTHON:
DATA STRUCTURES

KENNETH A. LAMBERT

Australia • Brazil • Mexico • Singapore • United Kingdom • United States

 Fundamentals of Python: © 2019, 2014 Cengage Learning, Inc.
Data Structures, Second Edition
Unless otherwise noted, all content is © Cengage.
Kenneth A. Lambert
ALL RIGHTS RESERVED. No part of this work covered by the
copyright herein may be reproduced or distributed in any form or
SVP, GM Skills & Global Product by any means, except as permitted by U.S. copyright law, without
Management: Jonathan Lau the prior written permission of the copyright owner.

Product Team Manager: Kristin McNary

Product Manager: Chris Shortt For product information and technology assistance, contact us
at Cengage Customer & Sales Support,
Product Assistant: Thomas Benedetto
1-800-354-9706 or support.cengage.com.
Executive Director, Content Design: Marah
Bellegarde
For permission to use material from this text or product,
Director, Learning Design: Leigh Hefferon submit all requests online at
www.cengage.com/permissions.
Learning Designer: Kate Mason

Vice President, Strategic Marketing Services:

Jennifer Baker Library of Congress Control Number: 2018956860

Marketing Director: Michele McTighe

Associate Marketing Manager: Cassie Cloutier ISBN: 978-0-357-12275-4

Director, Content Delivery: Patty Stephan

Cengage
Senior Content Manager: Michelle Ruelos
20 Channel Center Street
Cannistraci
Boston, MA 02210
Designer: Erin K. Griffin
USA
Cover image: Digital_Art/Shutterstock.com
Cengage is a leading provider of customized learning solutions with
Service Provider/Compositor: SPi Global employees residing in nearly 40 different countries and sales in
more than 125 countries around the world. Find your local repre-
sentative at www.cengage.com.

Cengage products are represented in Canada by

Nelson Education, Ltd.

To learn more about Cengage platforms and services, register or

access your online learning solution, or purchase materials for your
course, visit www.cengage.com.

Notice to the Reader

Publisher does not warrant or guarantee any of the products described herein or perform any independent analysis in connection
with any of the product information contained herein. Publisher does not assume, and expressly disclaims, any obligation to
obtain and include information other than that provided to it by the manufacturer. The reader is expressly warned to consider
and adopt all safety precautions that might be indicated by the activities described herein and to avoid all potential hazards.
By following the instructions contained herein, the reader willingly assumes all risks in connection with such instructions. The
publisher makes no representations or warranties of any kind, including but not limited to, the warranties of fitness for particular
purpose or merchantability, nor are any such representations implied with respect to the material set forth herein, and the
publisher takes no responsibility with respect to such material. The publisher shall not be liable for any special, consequential, or
exemplary damages resulting, in whole or part, from the readers’ use of, or reliance upon, this material.

Printed in the United States of America

Print Number: 01 Print Year: 2018
Table of Contents
iii

Pref ace . . . . . . . . . . . . . . . . . xi

CHAP TER 1 B as ic Pyt h o n Programmi ng . . . . . . . . . 1

Basic Program Elements . . . . . . . . . . . . . . . . . .2
Programs and Modules . . . . . . . . . . . . . . . . .2
An Example Python Program: Guessing a Number . . . . .2
Editing, Compiling, and Running Python Programs . . . . .3
Program Comments . . . . . . . . . . . . . . . . . . .4
Lexical Elements . . . . . . . . . . . . . . . . . . . .4
Spelling and Naming Conventions . . . . . . . . . . . . .4
Syntactic Elements . . . . . . . . . . . . . . . . . . .5
Literals . . . . . . . . . . . . . . . . . . . . . . . . .5
Operators and Expressions . . . . . . . . . . . . . . . .6
Function Calls . . . . . . . . . . . . . . . . . . . . . .7
The print Function . . . . . . . . . . . . . . . . . . .7
The input Function . . . . . . . . . . . . . . . . . . . .7
Type Conversion Functions and Mixed-Mode Operations . . .7
Optional and Keyword Function Arguments . . . . . . . . .7
Variables and Assignment Statements . . . . . . . . . . .8
Python Data Typing . . . . . . . . . . . . . . . . . . .9
import Statements . . . . . . . . . . . . . . . . . . .9
Getting Help on Program Components . . . . . . . . . . .9
Control Statements . . . . . . . . . . . . . . . . . . . 10
Conditional Statements . . . . . . . . . . . . . . . . 10
Using if __name__ == "__main__" . . . . . . . . . 11
Loop Statements . . . . . . . . . . . . . . . . . . . 12
Strings and Their Operations . . . . . . . . . . . . . . . 12
Operators . . . . . . . . . . . . . . . . . . . . . . 13
Formatting Strings for Output . . . . . . . . . . . . . 14
Objects and Method Calls . . . . . . . . . . . . . . . 15
Built-In Python Collections and Their Operations . . . . . . 16
Lists . . . . . . . . . . . . . . . . . . . . . . . . . 16
Tuples . . . . . . . . . . . . . . . . . . . . . . . . 17
 CONTENTS

Loops Over Sequences . . . . . . . . . . . . . . . . 17

Dictionaries . . . . . . . . . . . . . . . . . . . . . . 18
Searching for a Value . . . . . . . . . . . . . . . . . 18
Pattern Matching with Collections . . . . . . . . . . . . 18
Creating New Functions . . . . . . . . . . . . . . . . . 19
iv Function Definitions . . . . . . . . . . . . . . . . . . 19
Recursive Functions . . . . . . . . . . . . . . . . . . 20
Nested Function Definitions . . . . . . . . . . . . . . 22
Higher-Order Functions . . . . . . . . . . . . . . . . 23
Creating Anonymous Functions with lambda . . . . . . . 24
Catching Exceptions . . . . . . . . . . . . . . . . . . . 24
Files and Their Operations . . . . . . . . . . . . . . . . 25
Text File Output . . . . . . . . . . . . . . . . . . . . 26
Writing Numbers to a Text File . . . . . . . . . . . . . 26
Reading Text from a Text File . . . . . . . . . . . . . . 27
Reading Numbers from a File . . . . . . . . . . . . . . 28
Reading and Writing Objects with pickle . . . . . . . . 29
Creating New Classes . . . . . . . . . . . . . . . . . . 30

CHAPTER 2 An Over view o f Col l ecti ons . . . . . . . . . 37

Collection Types . . . . . . . . . . . . . . . . . . . . 38
Linear Collections . . . . . . . . . . . . . . . . . . . 38
Hierarchical Collections . . . . . . . . . . . . . . . . 39
Graph Collections . . . . . . . . . . . . . . . . . . . 39
Unordered Collections . . . . . . . . . . . . . . . . . 40
Sorted Collections. . . . . . . . . . . . . . . . . . . 40
A Taxonomy of Collection Types . . . . . . . . . . . . 40
Operations on Collections . . . . . . . . . . . . . . . . 41
Fundamental Operations on All Collection Types . . . . . 41
Type Conversion . . . . . . . . . . . . . . . . . . . 43
Cloning and Equality . . . . . . . . . . . . . . . . . . 43
Iterators and Higher-Order Functions . . . . . . . . . . . 44
Implementations of Collections . . . . . . . . . . . . . . 44

CHAP TER 3 Search in g , So r ti ng, and Compl ex i ty Anal y si s . 49

Measuring the Efficiency of Algorithms . . . . . . . . . . 50
Measuring the Run Time of an Algorithm . . . . . . . . . 50
Counting Instructions . . . . . . . . . . . . . . . . . 53
Measuring the Memory Used by an Algorithm . . . . . . 55
Complexity Analysis . . . . . . . . . . . . . . . . . . . 55
Orders of Complexity . . . . . . . . . . . . . . . . . 56
Big-O Notation . . . . . . . . . . . . . . . . . . . . 57
The Role of the Constant of Proportionality . . . . . . . 58
 CONTENTS

Search Algorithms . . . . . . . . . . . . . . . . . . . . 59
Search for the Minimum . . . . . . . . . . . . . . . . 59
Sequential Search of a List . . . . . . . . . . . . . . . 60
Best-Case, Worst-Case, and Average-Case Performance . 60
Binary Search of a Sorted List . . . . . . . . . . . . . 61
Comparing Data Items . . . . . . . . . . . . . . . . . 62 v
Basic Sort Algorithms . . . . . . . . . . . . . . . . . . 64
Selection Sort . . . . . . . . . . . . . . . . . . . . 64
Bubble Sort . . . . . . . . . . . . . . . . . . . . . . 65
Insertion Sort . . . . . . . . . . . . . . . . . . . . . 67
Best-Case, Worst-Case, and Average-Case Performance
Revisited . . . . . . . . . . . . . . . . . . . . . . 68
Faster Sorting . . . . . . . . . . . . . . . . . . . . 69
Overview of Quicksort . . . . . . . . . . . . . . . . . 70
Merge Sort . . . . . . . . . . . . . . . . . . . . . . 74
An Exponential Algorithm: Recursive Fibonacci . . . . . . . 77
Converting Fibonacci to a Linear Algorithm . . . . . . . 78

CHAP TER 4 Ar r ays an d Li nked Structures . . . . . . . . 89

The Array Data Structure. . . . . . . . . . . . . . . . . 90
Random Access and Contiguous Memory . . . . . . . . 92
Static Memory and Dynamic Memory . . . . . . . . . . 93
Physical Size and Logical Size . . . . . . . . . . . . . 94
Operations on Arrays . . . . . . . . . . . . . . . . . . 94
Increasing the Size of an Array . . . . . . . . . . . . . 95
Decreasing the Size of an Array . . . . . . . . . . . . 95
Inserting an Item into an Array That Grows . . . . . . . . 96
Removing an Item from an Array . . . . . . . . . . . . 97
Complexity Trade-Off: Time, Space, and Arrays . . . . . 98
Two-Dimensional Arrays (Grids) . . . . . . . . . . . . . . 99
Processing a Grid . . . . . . . . . . . . . . . . . . . 100
Creating and Initializing a Grid . . . . . . . . . . . . . 100
Defining a Grid Class . . . . . . . . . . . . . . . . . 101
Ragged Grids and Multidimensional Arrays . . . . . . . . 101
Linked Structures . . . . . . . . . . . . . . . . . . . . 102
Singly Linked Structures and Doubly Linked Structures . . 103
Noncontiguous Memory and Nodes . . . . . . . . . . . 104
Defining a Singly Linked Node Class . . . . . . . . . . 106
Using the Singly Linked Node Class . . . . . . . . . . . 106
Operations on Singly Linked Structures . . . . . . . . . . 108
Traversal . . . . . . . . . . . . . . . . . . . . . . . 108
Searching . . . . . . . . . . . . . . . . . . . . . . 109
Replacement . . . . . . . . . . . . . . . . . . . . . 110
Inserting at the Beginning . . . . . . . . . . . . . . . 111
 CONTENTS

Inserting at the End . . . . . . . . . . . . . . . . . . 111

Removing at the Beginning . . . . . . . . . . . . . . . 112
Removing at the End. . . . . . . . . . . . . . . . . . 113
Inserting at Any Position . . . . . . . . . . . . . . . . 114
Removing at Any Position . . . . . . . . . . . . . . . 116
vi Complexity Trade-Off: Time, Space, and Singly Linked
Structures . . . . . . . . . . . . . . . . . . . . . . 116
Variations on a Link . . . . . . . . . . . . . . . . . . . 118
A Circular Linked Structure with a Dummy Header Node. . 118
Doubly Linked Structures . . . . . . . . . . . . . . . 119

CHAP TER 5 In t er f aces , I m pl ementati ons,

an d Po lym o rphi sm . . . . . . . . . . . 126
Developing an Interface . . . . . . . . . . . . . . . . . 127
Designing the Bag Interface . . . . . . . . . . . . . . 127
Specifying Arguments and Return Values . . . . . . . . 129
Constructors and Implementing Classes . . . . . . . . . . 130
Preconditions, Postconditions, Exceptions,
and Documentation . . . . . . . . . . . . . . . . . . 131
Coding an Interface in Python . . . . . . . . . . . . . 132
Developing an Array-Based Implementation . . . . . . . . 134
Choose and Initialize the Data Structures . . . . . . . . 134
Complete the Easy Methods First . . . . . . . . . . . . 135
Complete the Iterator . . . . . . . . . . . . . . . . . 136
Complete the Methods That Use the Iterator . . . . . . . 137
The in Operator and the __contains__ Method. . . . . 137
Complete the remove Method . . . . . . . . . . . . . 138
Developing a Link-Based Implementation. . . . . . . . . . 139
Initialize the Data Structures . . . . . . . . . . . . . . 139
Complete the Iterator . . . . . . . . . . . . . . . . . 140
Complete the Methods clear and add . . . . . . . . . 140
Complete the Method remove . . . . . . . . . . . . . 141
Run-Time Performance of the Two Bag Implementations . . . 142
Testing the Two Bag Implementations . . . . . . . . . . . 142
Diagramming the Bag Resource with UML . . . . . . . . . 144

CHAPTER 6 In h er it an ce and Abstract Cl asses . . . . . 148

Using Inheritance to Customize an Existing Class. . . . . . 149
Subclassing an Existing Class . . . . . . . . . . . . . 150
Revising the __init__ Method . . . . . . . . . . . . . 150
Adding a New __contains__ Method . . . . . . . . . . 152
Modifying the Existing add Method . . . . . . . . . . . 152
 CONTENTS

Modifying the Existing __add__ Method . . . . . . . . . 153

Run-Time Performance of ArraySortedBag . . . . . . . 153
A Note on Class Hierarchies in Python . . . . . . . . . . 154
Using Abstract Classes to Eliminate Redundant Code . . . . 155
Designing an AbstractBag Class . . . . . . . . . . . 155
Redoing the __init__ Method in AbstractBag . . . . . 157 vii
Modifying the Subclasses of AbstractBag . . . . . . . 157
Generalizing the __add__ Method in AbstractBag . . . 158
An Abstract Class for All Collections . . . . . . . . . . . 159
Integrating AbstractCollection into the Collection
Hierarchy . . . . . . . . . . . . . . . . . . . . . . 159
Using Two Iterators in the __eq__ Method . . . . . . . . 161
A Professional-Quality Framework of Collections . . . . . . 162

CHAP TER 7 St ack s . . . . . . . . . . . . . . . . . 167

Overview of Stacks . . . . . . . . . . . . . . . . . . . 168
Using a Stack . . . . . . . . . . . . . . . . . . . . . . 169
The Stack Interface . . . . . . . . . . . . . . . . . . 169
Instantiating a Stack . . . . . . . . . . . . . . . . . . 170
Example Application: Matching Parentheses . . . . . . . 171
Three Applications of Stacks . . . . . . . . . . . . . . . 174
Evaluating Arithmetic Expressions . . . . . . . . . . . 174
Evaluating Postfix Expressions . . . . . . . . . . . . . 175
Converting Infix to Postfix . . . . . . . . . . . . . . . 176
Backtracking . . . . . . . . . . . . . . . . . . . . . 179
Memory Management . . . . . . . . . . . . . . . . . 181
Implementations of Stacks . . . . . . . . . . . . . . . . 184
Test Driver . . . . . . . . . . . . . . . . . . . . . . 184
Adding Stacks to the Collection Hierarchy . . . . . . . . 185
Array Implementation . . . . . . . . . . . . . . . . . 186
Linked Implementation . . . . . . . . . . . . . . . . . 187
The Role of the Abstract Stack Class . . . . . . . . . . 190
Time and Space Analysis of the Two Implementations . . . 191

C HAP TER 8 Qu eu es . . . . . . . . . . . . . . . . . 205

Overview of Queues . . . . . . . . . . . . . . . . . . . 206
The Queue Interface and Its Use . . . . . . . . . . . . . 207
Two Applications of Queues . . . . . . . . . . . . . . . 210
Simulations . . . . . . . . . . . . . . . . . . . . . . 210
Round-Robin CPU Scheduling . . . . . . . . . . . . . . 212
Implementations of Queues. . . . . . . . . . . . . . . . 213
A Linked Implementation of Queues . . . . . . . . . . . 213
 CONTENTS

An Array Implementation . . . . . . . . . . . . . . . . 215

Time and Space Analysis for the Two Implementations . . 217
Priority Queues . . . . . . . . . . . . . . . . . . . . . 226

CHAP TER 9 Lis t s . . . . . . . . . . . . . . . . . . 239

viii Overview of Lists . . . . . . . . . . . . . . . . . . . . 240
Using Lists . . . . . . . . . . . . . . . . . . . . . . . 240
Index-Based Operations . . . . . . . . . . . . . . . . 241
Content-Based Operations . . . . . . . . . . . . . . . 242
Position-Based Operations . . . . . . . . . . . . . . . 242
Interfaces for Lists . . . . . . . . . . . . . . . . . . 247
Applications of Lists . . . . . . . . . . . . . . . . . . . 249
Heap-Storage Management . . . . . . . . . . . . . . . 249
Organization of Files on a Disk . . . . . . . . . . . . . 250
Implementation of Other Collections. . . . . . . . . . . 252
List Implementations. . . . . . . . . . . . . . . . . . . 252
The Role of the AbstractList Class . . . . . . . . . . 252
An Array-Based Implementation . . . . . . . . . . . . . 254
A Linked Implementation . . . . . . . . . . . . . . . . 255
Time and Space Analysis for the Two Implementations . . 258
Implementing a List Iterator . . . . . . . . . . . . . . . 260
Role and Responsibilities of a List Iterator . . . . . . . . 260
Setting Up and Instantiating a List Iterator Class . . . . . 261
The Navigational Methods in the List Iterator . . . . . . . 262
The Mutator Methods in the List Iterator . . . . . . . . . 263
Design of a List Iterator for a Linked List . . . . . . . . 264
Time and Space Analysis of List Iterator
Implementations . . . . . . . . . . . . . . . . . . . 265
Recursive List Processing . . . . . . . . . . . . . . . . 270
Basic Operations on a Lisp-Like List. . . . . . . . . . . 271
Recursive Traversals of a Lisp-Like List . . . . . . . . . 272
Building a Lisp-Like List . . . . . . . . . . . . . . . . 273
The Internal Structure of a Lisp-Like List. . . . . . . . . 275
Printing Lisp-Like Lists in IDLE with __repr__ . . . . . . 276
Lists and Functional Programming . . . . . . . . . . . 277

CHAP TER 10 Tre e s . . . . . . . . . . . . . . . . . 282

An Overview of Trees . . . . . . . . . . . . . . . . . . 283
Tree Terminology . . . . . . . . . . . . . . . . . . . 283
General Trees and Binary Trees . . . . . . . . . . . . . 284
Recursive Definitions of Trees . . . . . . . . . . . . . 285
Why Use a Tree?. . . . . . . . . . . . . . . . . . . . . 286
The Shape of Binary Trees . . . . . . . . . . . . . . . . 288
 CONTENTS

Binary Tree Traversals . . . . . . . . . . . . . . . . . . 291

Preorder Traversal. . . . . . . . . . . . . . . . . . . 291
Inorder Traversal . . . . . . . . . . . . . . . . . . . 291
Postorder Traversal . . . . . . . . . . . . . . . . . . 292
Level Order Traversal . . . . . . . . . . . . . . . . . 292
Three Common Applications of Binary Trees . . . . . . . . 293 ix
Heaps . . . . . . . . . . . . . . . . . . . . . . . . 293
Binary Search Trees . . . . . . . . . . . . . . . . . . 293
Expression Trees . . . . . . . . . . . . . . . . . . . 295
Developing a Binary Search Tree . . . . . . . . . . . . . 297
The Binary Search Tree Interface . . . . . . . . . . . . 297
Data Structure for the Linked Implementation . . . . . . 299
Complexity Analysis of Binary Search Trees . . . . . . . 304
Recursive Descent Parsing and Programming
Languages . . . . . . . . . . . . . . . . . . . . . . 304
Introduction to Grammars . . . . . . . . . . . . . . . 305
Recognizing, Parsing, and Interpreting Sentences
in a Language . . . . . . . . . . . . . . . . . . . . 306
Lexical Analysis and the Scanner . . . . . . . . . . . . 307
Parsing Strategies. . . . . . . . . . . . . . . . . . . 307
An Array Implementation of Binary Trees. . . . . . . . . . 313
Implementing Heaps . . . . . . . . . . . . . . . . . . . 315

CHAP TER 11 Set s an d Di ct i onari es . . . . . . . . . . 322

Using Sets . . . . . . . . . . . . . . . . . . . . . . . 323
The Python Set Class . . . . . . . . . . . . . . . . . . 324
A Sample Session with Sets . . . . . . . . . . . . . . 325
Applications of Sets . . . . . . . . . . . . . . . . . . 325
Relationship Between Sets and Bags . . . . . . . . . . 325
Relationship Between Sets and Dictionaries . . . . . . . 326
Implementations of Sets . . . . . . . . . . . . . . . . 326
Array-Based and Linked Implementations of Sets . . . . . . 326
The AbstractSet Class . . . . . . . . . . . . . . . . 327
The ArraySet Class . . . . . . . . . . . . . . . . . 328
Using Dictionaries . . . . . . . . . . . . . . . . . . . . 329
Array-Based and Linked Implementations of Dictionaries . . 330
The Entry Class . . . . . . . . . . . . . . . . . . . 330
The AbstractDict Class . . . . . . . . . . . . . . . 331
The ArrayDict Class . . . . . . . . . . . . . . . . . 333
Complexity Analysis of the Array-Based and Linked
Implementations of Sets and Dictionaries. . . . . . . . 334
Hashing Strategies . . . . . . . . . . . . . . . . . . . 335
 CONTENTS

The Relationship of Collisions to Density. . . . . . . . . 336

Hashing with Nonnumeric Keys . . . . . . . . . . . . . 337
Linear Probing . . . . . . . . . . . . . . . . . . . . 339
Quadratic Probing . . . . . . . . . . . . . . . . . . . 340
Chaining . . . . . . . . . . . . . . . . . . . . . . . 341
x Complexity Analysis . . . . . . . . . . . . . . . . . . 342
Hashing Implementation of Sets . . . . . . . . . . . . . 349
Hashing Implementation of Dictionaries . . . . . . . . . . 352
Sorted Sets and Dictionaries . . . . . . . . . . . . . . . 354

CHAPTER 12 Gr aph s . . . . . . . . . . . . . . . . . 359

Why Use Graphs? . . . . . . . . . . . . . . . . . . . . 360
Graph Terminology . . . . . . . . . . . . . . . . . . . 360
Representations of Graphs . . . . . . . . . . . . . . . . 364
Adjacency Matrix . . . . . . . . . . . . . . . . . . . 365
Adjacency List . . . . . . . . . . . . . . . . . . . . 366
Analysis of the Two Representations . . . . . . . . . . 367
Further Run-Time Considerations . . . . . . . . . . . . 368
Graph Traversals . . . . . . . . . . . . . . . . . . . . 369
A Generic Traversal Algorithm . . . . . . . . . . . . . 369
Breadth-First and Depth-First Traversals . . . . . . . . . 370
Graph Components . . . . . . . . . . . . . . . . . . 372
Trees Within Graphs . . . . . . . . . . . . . . . . . . . 373
Spanning Trees and Forests . . . . . . . . . . . . . . 373
Minimum Spanning Tree . . . . . . . . . . . . . . . . 373
Algorithms for Minimum Spanning Trees . . . . . . . . . 373
Topological Sort. . . . . . . . . . . . . . . . . . . . . 376
The Shortest-Path Problem . . . . . . . . . . . . . . . . 377
Dijkstra’s Algorithm . . . . . . . . . . . . . . . . . . 377
The Initialization Step . . . . . . . . . . . . . . . . . 377
The Computation Step . . . . . . . . . . . . . . . . . 379
Representing and Working with Infinity. . . . . . . . . . 380
Analysis . . . . . . . . . . . . . . . . . . . . . . . 380
Floyd’s Algorithm . . . . . . . . . . . . . . . . . . . 380
Analysis . . . . . . . . . . . . . . . . . . . . . . . 382
Developing a Graph Collection . . . . . . . . . . . . . . 382
Example Use of the Graph Collection . . . . . . . . . . 383
The Class LinkedDirectedGraph . . . . . . . . . . . 384
The Class LinkedVertex . . . . . . . . . . . . . . . 388
The Class LinkedEdge . . . . . . . . . . . . . . . . 390

Glo s s ar y . . . . . . . . . . . . . . . . . . 401

In dex . . . . . . . . . . . . . . . . . 410
Preface
xi

Welcome to Fundamentals of Python: Data Structures, 2nd Edition. This text is intended
for a second semester course in programming and problem solving with data structures. It
covers the material taught in a typical Computer Science 2 course (CS2) at the undergradu-
ate level. Although this book uses the Python programming language, you need only have a
basic knowledge of programming in a high-level programming language before beginning
Chapter 1.

What You’ll Learn

The book covers four major aspects of computing:
1. Programming basics—Data types, control structures, algorithm development,
and program design with functions are basic ideas that you need to master to solve
problems with computers. You’ll review these core topics in the Python program-
ming language and employ your understanding of them to solve a wide range of
problems.
2. Object-Oriented Programming (OOP)—Object-Oriented Programming is the
dominant programming paradigm used to develop large software systems. You’ll
be introduced to the fundamental principles of OOP so that you can apply them
successfully. Unlike other textbooks, this book helps you develop a professional-
quality framework of collection classes to illustrate these principles.
3. Data structures—Most useful programs rely on data structures to solve prob-
lems. At the most concrete level, data structures include arrays and various types
of linked structures. You’ll use these data structures to implement various types of
collection structures, such as stacks, queues, lists, trees, bags, sets, dictionaries, and
graphs. You’ll also learn to use complexity analysis to evaluate the space/time trade-
offs of different implementations of these collections.
4. Software development life cycle—Rather than isolate software development tech-
niques in one or two chapters, this book deals with them throughout in the context
of numerous case studies. Among other things, you’ll learn that coding a program
is often not the most difficult or challenging aspect of problem solving and software
development.
 P R E FA C E Why Python?

Why Python?
Computer technology and applications have become increasingly more sophisticated over
the past three decades, and so has the computer science curriculum, especially at the intro-
ductory level. Today’s students learn a bit of programming and problem solving and are
then expected to move quickly into topics like software development, complexity analysis,
xii
and data structures that, 30 years ago, were relegated to advanced courses. In addition,
the ascent of object-oriented programming as the dominant paradigm has led instructors
and textbook authors to bring powerful, industrial-strength programming languages such
as C++ and Java into the introductory curriculum. As a result, instead of experiencing the
rewards and excitement of solving problems with computers, beginning computer science
students often become overwhelmed by the combined tasks of mastering advanced con-
cepts as well as the syntax of a programming language.
This book uses the Python programming language as a way of making the second course
in computer science more manageable and attractive for students and instructors alike.
Python has the following pedagogical benefits:
• Python has simple, conventional syntax. Python statements are very close to those of
pseudocode algorithms, and Python expressions use the conventional notation found
in algebra. Thus, you can spend less time dealing with the syntax of a programming
language and more time learning to solve interesting problems.
• Python has safe semantics. Any expression or statement whose meaning violates the
definition of the language produces an error message.
• Python scales well. It is easy for beginners to write simple programs in Python. Python
also includes all the advanced features of a modern programming language, such as
support for data structures and object-oriented software development, for use when
they become necessary, especially in the second course in computer science
• Python is highly interactive. You can enter expressions and statements at an interpreter’s
prompts to try out experimental code and receive immediate feedback. You can also
compose longer code segments and save them in script files to be loaded and run as
modules or stand-alone applications.
• Python is general purpose. In today’s context, this means that the language includes
resources for contemporary applications, including media computing and web
services.
• Python is free and is in widespread use in the industry. You can download Python to run
on a variety of devices. There is a large Python user community, and expertise in Python
programming has great resume value.
To summarize these benefits, Python is a comfortable and flexible vehicle for expressing
ideas about computation, both for beginners and for experts. If you learn these ideas well
in the first year, you should have no problems making a quick transition to other lan-
guages needed for courses later in the curriculum. Most importantly, you will spend less
time staring at a computer screen and more time thinking about interesting problems
to solve.
 Organization of This Book P R E FA C E

Organization of This Book

The approach in this book is easygoing, with each new concept introduced only when it is
needed.
Chapter 1 provides a review of the features of Python programming that are needed to begin
a second course in programming and problem solving in Python. The content of this chapter xiii
is organized so that you can skim it quickly if you have experience in Python programming,
or you can dig a bit deeper to get up to speed in the language if you are new to Python.
Chapters 2 through 12 covers the major topics in a typical CS2 course, especially the specifica-
tion, implementation, and application of abstract data types, with the collection types as the
primary vehicle and focus. Along the way, you will be thoroughly exposed to object-oriented
programming techniques and the elements of good software design. Other important CS2 topics
include recursive processing of data, search and sort algorithms, and the tools used in software
development, such as complexity analysis and graphical notations (UML) to document designs.
Chapter 2 introduces the concept of an abstract data type (ADT) and provides an overview
of various categories of collection ADTs.
Chapters 3 and 4 explore the data structures used to implement most collections and the
tools for analyzing their performance trade-offs. Chapter 3 introduces complexity analysis
with big-O notation. Enough material is presented to enable you to perform simple analyses
of the running time and memory usage of algorithms and data structures, using search and
sort algorithms as examples. Chapter 4 covers the details of processing arrays and linear
linked structures, the concrete data structures used to implement most collections. You’ll
learn the underlying models of computer memory that support arrays and linked structures
and the time/space trade-offs that they entail.
Chapters 5 and 6 shift the focus to the principles of object-oriented design. These principles
are used to organize a professional-quality framework of collection classes that will be cov-
ered in detail in later chapters.
Chapter 5 is concerned with the critical difference between interface and implementation.
A single interface and several implementations of a bag collection are developed as a first
example. Emphasis is placed on the inclusion of conventional methods in an interface, to
allow different types of collections to collaborate in applications. For example, one such
method creates an iterator, which allows you to traverse any collection with a simple loop.
Other topics covered in this chapter include polymorphism and information hiding, which
directly stem from the difference between interface and implementation.
Chapter 6 shows how class hierarchies can reduce the amount of redundant code in an object-
oriented software system. The related concepts of inheritance, dynamic binding of method
calls, and abstract classes are introduced here and used throughout the remaining chapters.
Armed with these concepts and principles, you’ll then be ready to consider the other major
collection ADTs, which form the subject of Chapters 7 through 12.
Chapters 7 through 9 present the linear collections, stacks, queues, and lists. Each collec-
tion is viewed first from the perspective of its users, who are aware only of an interface and
a set of performance characteristics possessed by a chosen implementation. The use of each
 P R E FA C E Special Features

collection is illustrated with one or more applications, and then several implementations
are developed, and their performance trade-offs are analyzed.
Chapters 10 through 12 present advanced data structures and algorithms as a transition to
later courses in computer science. Chapter 10 discusses various tree structures, including
binary search trees, heaps, and expression trees. Chapter 11 examines the implementation
xiv of the unordered collections, bags, sets, and dictionaries, using hashing strategies.
Chapter 12 introduces graphs and graph-processing algorithms.
As mentioned earlier, this book is unique in presenting a professional-quality framework of
collection types. Instead of encountering a series of apparently unrelated collections, you
will explore the place of each collection in an integrated whole. This approach allows you
to see what the collection types have in common as well as what makes each one unique.
At the same time, you will be exposed to a realistic use of inheritance and class hierarchies,
topics in object-oriented software design that are difficult to motivate and exemplify at this
level of the curriculum.

Special Features
This book explains and develops concepts carefully, using frequent examples and diagrams.
New concepts are then applied in complete programs to show how they aid in solving prob-
lems. The chapters place an early and consistent emphasis on good writing habits and neat,
readable documentation.
The book includes several other important features:
• Case studies—These present complete Python programs ranging from the simple to the
substantial. To emphasize the importance and usefulness of the software development life
cycle, case studies are discussed in the framework of a user request, followed by analysis,
design, implementation, and suggestions for testing, with well-defined tasks performed at
each stage. Some case studies are extended in end-of-chapter programming projects.
• Chapter summaries—Each chapter after the first one ends with a summary of the
major concepts covered in the chapter.
• Key terms—When a new term is introduced in the text, it appears in bold face.
Definitions of the key terms are also collected in a glossary.
• Exercises—Most major sections of each chapter after the first one end with exercise
questions that reinforce the reading by asking basic questions about the material in the
section. After Chapter 2, each chapter ends with review questions.
• Programming projects—Each chapter ends with a set of programming projects of
varying difficulty.

New in This Edition

The most obvious change in this edition is the addition of full color. All program examples
include the color coding used in Python’s IDLE, so students can easily identify program
elements such as keywords, comments, and function, method, and class names. Learning
 Instructor Resources P R E FA C E

objectives have been added to the beginning of each chapter. Several new figures have been
added to illustrate concepts, and many programming projects have been added or reworked.
A new section on iterators and higher-order functions has been added to Chapter 2. Finally,
a new section on Lisp-like lists, recursive list processing, and functional programming has
been added to Chapter 9.
xv
Instructor Resources
MindTap
MindTap activities for Fundamentals of Python: Data Structures are designed to help stu-
dents master the skills they need in today's workforce. Research shows employers need
critical thinkers, troubleshooters, and creative problem-solvers to stay relevant in our
fast-paced, technology-driven world. MindTap helps you achieve this with assignments
and activities that provide hands-on practice and real-life relevance. Students are guided
through assignments that help them master basic knowledge and understanding before
moving on to more challenging problems.
All MindTap activities and assignments are tied to defined unit learning objectives. Hands-on
coding labs provide real-life application and practice. Readings and dynamic visualizations
support the lecture, while a post-course assessment measures exactly how much a class
stands in terms of progress, engagement, and completion rates. Use the content and learning
path as-is, or pick and choose how our materials will wrap around yours. You control what
the students see and when they see it. Learn more at http://www.cengage.com/mindtap/.

Instructor Companion Site

The following teaching tools are available for download at the Companion Site for this text.
Go to instructor.cengage.com and sign in to the instructor account. Search for the textbook
and add the text to the instructor dashboard.
• Instructor’s Manual: The Instructor’s Manual that accompanies this textbook includes
additional instructional material to assist in class preparation, including items such as
Overviews, Chapter Objectives, Teaching Tips, Quick Quizzes, Class Discussion Topics,
Additional Projects, Additional Resources, and Key Terms. A sample syllabus is also available.
• Test Bank: Cengage Testing Powered by Cognero is a flexible, online system that allows
you to:
• author, edit, and manage test bank content from multiple Cengage solutions
• create multiple test versions in an instant
• deliver tests from your LMS, your classroom, or wherever you want
• PowerPoint Presentations: This text provides PowerPoint slides to accompany each
chapter. Slides may be used to guide classroom presentations, to make available to stu-
dents for chapter review, or to print as classroom handouts. Files are provided for every
figure in the text. Instructors may use the files to customize PowerPoint slides, illustrate
quizzes, or create handouts.
 P R E FA C E Dedication

• Solutions: Solutions to all programming exercises are available. If an input file is

needed to run a programming exercise, it is included with the solution file.
• Source Code: The source code is available at www.cengage.com. If an input file is
needed to run a program, it is included with the source code.

xvi

The first-of-its-kind digital subscription designed specially to lower costs. Students get total
access to everything Cengage has to offer on demand—in one place. That’s 20,000 eBooks,
2,300 digital learning products, and dozens of study tools across 70 disciplines and over
675 courses. Currently available in select markets. Details at www.cengage.com/unlimited

We Appreciate Your Feedback

We have tried to produce a high-quality text, but should you encounter any errors, please report
them to lambertk@wlu.edu. A listing of errata, should they be found, as well as other informa-
tion about the book, will be posted on the website http://home.wlu.edu/~lambertk/python/.

Acknowledgments
I would like to thank my friend, Martin Osborne, for many years of advice, friendly
criticism, and encouragement on several of my book projects.
I would also like to thank my students in Computer Science 112 at Washington and Lee
University for classroom testing this book over several semesters.
Finally, I would like to thank Kristin McNary, Product Team Manager; Chris Shortt, Product
Manager; Maria Garguilo and Kate Mason, Learning Designers; Magesh Rajagopalan, Senior
Project Manager; Danielle Shaw, Tech Editor; and especially Michelle Ruelos Cannistraci,
Senior Content Manager, for handling all the details of producing this edition of the book.

About the Author

Kenneth A. Lambert is a professor of computer science and the chair of that department
at Washington and Lee University. He has taught introductory programming courses for
over 30 years and has been an active researcher in computer science education. Lambert
has authored or coauthored a total of 28 textbooks, including a series of introductory C++
textbooks with Douglas Nance and Thomas Naps, a series of introductory Java textbooks
with Martin Osborne, and a series of introductory Python textbooks.

Dedication
To Brenda Wilson, with love and admiration.
Kenneth A. Lambert
Lexington, VA