Download More ebooks [PDF]. Format PDF ebook download PDF KINDLE.

Full download ebooks at ebookmass.com

Fundamentals Of Python: Data Structures

2nd Edition Kenneth A. Lambert

For dowload this book click BUTTON or LINK below

https://ebookmass.com/product/fundamentals-of-
python-data-structures-2nd-edition-kenneth-a-
lambert/
OR CLICK BUTTON

DOWLOAD NOW

Download More ebooks from https://ebookmass.com

More products digital (pdf, epub, mobi) instant
download maybe you interests ...

Fundamentals of Python: First Programs, 2nd Edition

Kenneth A. Lambert

https://ebookmass.com/product/fundamentals-of-python-first-
programs-2nd-edition-kenneth-a-lambert/

Data Structures & Algorithms in Python 1st Edition John

Canning

https://ebookmass.com/product/data-structures-algorithms-in-
python-1st-edition-john-canning-2/

Data Structures & Algorithms in Python 1st Edition John

Canning

https://ebookmass.com/product/data-structures-algorithms-in-
python-1st-edition-john-canning/

Data Structures and Algorithms in C++ 2nd Edition

https://ebookmass.com/product/data-structures-and-algorithms-
in-c-2nd-edition/
A Textbook of Data Structures and Algorithms, Volume 2:
Mastering Nonlinear Data Structures Vijayalakshmi Pai

https://ebookmass.com/product/a-textbook-of-data-structures-and-
algorithms-volume-2-mastering-nonlinear-data-structures-
vijayalakshmi-pai/

Python for Finance: Mastering Data-Driven Finance 2nd

Edition

https://ebookmass.com/product/python-for-finance-mastering-data-
driven-finance-2nd-edition/

Data Science from Scratch: First Principles with Python

2nd Edition

https://ebookmass.com/product/data-science-from-scratch-first-
principles-with-python-2nd-edition/

Data Structures E. Balagurusamy

https://ebookmass.com/product/data-structures-e-balagurusamy/

Fundamentals of Structural Analysis 5th Edition Kenneth

M. Leet

https://ebookmass.com/product/fundamentals-of-structural-
analysis-5th-edition-kenneth-m-leet/
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
 second Edition

Fundamentals of Python:
Data STRUCTURES

Kenneth A. Lambert

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

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 This is an electronic version of the print textbook. Due to electronic rights restrictions,
some third party content may be suppressed. Editorial review has deemed that any suppressed
content does not materially affect the overall learning experience. The publisher reserves the right
to remove content from this title at any time if subsequent rights restrictions require it. For
valuable information on pricing, previous editions, changes to current editions, and alternate
formats, please visit www.cengage.com/highered to search by ISBN#, author, title, or keyword for
materials in your areas of interest.

Important Notice: Media content referenced within the product description or the product
text may not be available in the eBook version.

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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, c­ ontact 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 m
­ aterials 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 c­ onnection
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

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Table of Contents
iii

Pref ace �������������������������������������������������� xi

CHAPTER 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

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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

CHAPTER 3 Search in g , ­S o 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
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
  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

CHAPTER 4 Ar r ays an d Linked 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
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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

CHAPTER 5  In t er f aces , ­I m pl ementati ons,

an d Po lym o r phi 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 an d 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
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
  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

CHAPTER 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 HAPTER 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
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 contents 

An Array Implementation ��������������������������������������������� 215

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

CHAPTER 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

CHAPTER 10 Trees ���������������������������������������������������� 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

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
  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

CHAPTER 11 Set s an d Dict ionari 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

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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.

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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.
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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. H
­ ands-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.
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 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 [email protected]. 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
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1
Basic Python
Programming

After completing this chapter, you will be able to:

Write a simple Python program using its basic structure

Perform simple input and output operations
Perform operations with numbers such as arithmetic and
comparisons
Perform operations with Boolean values
Implement an algorithm using the basic constructs of
sequences of statements, selection statements, and loops
Define functions to structure code
Use built-in data structures such as strings, files, lists,
tuples, and dictionaries
Define classes to represent new types of objects
Structure programs in terms of cooperating functions,
data structures, classes, and modules

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

This chapter gives a quick overview of Python programming. It is intended to bring those
new to or rusty in Python up to speed, but it does not pretend to be a thorough introduc-
tion to computer science or the Python programming language. For a more detailed treat-
ment of programming in Python, see my book Fundamentals of Python: First Programs,
Second Edition (Cengage Learning, 2019). For documentation on the Python programming
2
language, visit www.python.org.
If your computer already has Python, check the version number by running the python
or python3 command at a terminal prompt. (Linux and Mac users first open a terminal
­window, and Windows users first open a DOS window.) You are best off using the most
current version of Python available. Check for that at www.python.org, and download and
install the latest version if necessary. You will need Python 3.0 or higher to run the pro-
grams presented in this book.

Basic Program Elements

Like all contemporary programming languages, Python has a vast array of features and
constructs. However, Python is among the few languages whose basic program ele-
ments are quite simple. This section discusses the essentials to get you started in Python
programming.

Programs and Modules

A Python program consists of one or more modules. A module is just a file of Python code,
which can include statements, function definitions, and class definitions. A short Python
program, also called a script, can be contained in one module. Longer, more complex pro-
grams typically include one main module and one or more supporting modules. The main
module contains the starting point of program execution. Supporting modules contain
function and class definitions.

An Example Python Program: Guessing a Number

Next, you’ll see a complete Python program that plays a game of guess-the-number with
the user. The computer asks the user to enter the lower and upper bounds of a range of
numbers. The computer then “thinks” of a random number in that range and repeatedly
asks the user to guess this number until the user enters a correct guess. The computer gives
a hint to the user after each guess and displays the total number of guesses at the end of the
process. The program includes several of the types of Python statements to be discussed
later in this chapter, such as input statements, output statements, assignment statements,
loops, and conditional statements. The program also includes a single function definition.
Here is the code for the program, in the file numberguess.py:
"""
Author: Ken Lambert
Plays a game of guess the number with the user.
"""

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Basic Program Elements

import random

def main():
"""Inputs the bounds of the range of numbers
and lets the user guess the computer’s number until
the guess is correct."""
smaller = int(input("Enter the smaller number: ")) 3
larger = int(input("Enter the larger number: "))
myNumber = random.randint(smaller, larger)
count = 0
while True:
count += 1
userNumber = int(input("Enter your guess: "))
if userNumber < myNumber:
print("Too small")
elif userNumber > myNumber:
print("Too large")
else:
print("You’ve got it in", count, "tries!")
break

if __name__ == "__main__":
main()

Here is a trace of a user’s interaction with the program:

Enter the smaller number: 1
Enter the larger number: 32
Enter your guess: 16
Too small
Enter your guess: 24
Too large
Enter your guess: 20
You’ve got it in 3 tries!

Note that the code and its trace appear in the colors black, blue, orange, and green. Python’s
IDLE uses color coding to help the reader recognize various types of program elements.
The role of each color will be explained shortly.

Editing, Compiling, and Running Python Programs

You can run complete Python programs, including most of the examples presented, by
entering a command in a terminal window. For example, to run the program contained in
the file numberguess.py, enter the following command in most terminal windows:
python3 numberguess.py

To create or edit a Python module, try using Python’s IDLE (short for Integrated
­DeveLopment Environment). To start IDLE, enter the idle or idle3 command at a terminal
prompt or launch its icon if it is available. You can also launch IDLE by double-clicking on
a Python source code file (any file with a .py extension) or by right-clicking on the file and

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

selecting Open or Edit with IDLE. Make sure that your system is set to open IDLE when
files of this type are launched (this is the default on macOS but not on Windows).
IDLE gives you a shell window for interactively running Python expressions and statements.
Using IDLE, you can move back and forth between editor windows and the shell window to
develop and run complete programs. IDLE also formats your code and color-codes it.
4
When you open an existing Python file with IDLE, the file appears in an editor window, and
the shell pops up in a separate window. To run a program, move the cursor into the editor
window and press the F5 (function-5) key. Python compiles the code in the editor window
and runs it in the shell window.
If a Python program appears to hang or not quit normally, you can exit by pressing Ctrl+C
or closing the shell window.

Program Comments
A program comment is text ignored by the Python compiler but valuable to the reader as
documentation. An end-of-line comment in Python begins with a # symbol and extends to
the end of the current line. It is color-coded in red. For example:
# This is an end-of-line comment.

A multiline comment is a string enclosed in triple single quotes or triple double quotes.
Such comments, which are colored green, are also called docstrings, to indicate that they
can document major constructs within a program. The numberguess program shown
­earlier includes two doc strings. The first one, at the top of the program file, serves as a
comment for the entire numberguess module. The second one, just below the header of the
main function, describes what this function does. As we shall see shortly, docstrings play a
critical role in giving help to a programmer within the Python shell.

Lexical Elements
The lexical elements in a language are the types of words or symbols used to construct
­sentences. As in all high-level programming languages, some of Python’s basic symbols are
keywords, such as if, while, and def, which are colored orange. Also included among lexical
items are identifiers (names), literals (numbers, strings, and other built-in data structures),
operators, and delimiters (quotation marks, commas, parentheses, square brackets, and
braces). Among the identifiers are the names of built-in functions, which are colored purple.

Spelling and Naming Conventions

Python keywords and names are case-sensitive. Thus, while is a keyword, whereas While
is a programmer-defined name. Python keywords are spelled in lowercase letters and are
color-coded in orange in an IDLE window.

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Basic Program Elements

All Python names, other than those of built-in functions, are color-coded in black, except
when they are introduced as function, class, or method names, in which case they appear
in blue. A name can begin with a letter or an underscore (_), followed by any number of
­letters, underscores, or digits.
In this book, the names of modules, variables, functions, and methods are spelled in lower-
case letters. With the exception of modules, when one of these names contains one or more 5
embedded words, the embedded words are capitalized. The names of classes follow the
same conventions but begin with a capital letter. When a variable names a constant, all the
letters are uppercase, and an underscore separates any embedded words. Table 1-1 shows
examples of these naming conventions.

Type of Name Examples

Variable salary, hoursWorked, isAbsent

Constant ABSOLUTE_ZERO, INTEREST_RATE

Function or method printResults, cubeRoot, input

Class BankAccount, SortedSet

Table 1-1 Examples of Python Naming Conventions

Use names that describe their role in a program. In general, variable names should
be nouns or adjectives (if they denote Boolean values), whereas function and method
names should be verbs if they denote actions, or nouns or adjectives if they denote values
returned.

Syntactic Elements
The syntactic elements in a language are the types of sentences (expressions, statements,
definitions, and other constructs) composed from the lexical elements. Unlike most high-
level languages, Python uses white space (spaces, tabs, or line breaks) to mark the syntax
of many types of sentences. This means that indentation and line breaks are significant in
Python code. A smart editor like Python’s IDLE can help indent code correctly. The pro-
grammer need not worry about separating sentences with semicolons and marking blocks
of sentences with braces. In this book, I use an indentation width of four spaces in all
Python code.

Literals
Numbers (integers or floating-point numbers) are written as they are in other program-
ming languages. The Boolean values True and False are keywords. Some data structures,
such as strings, tuples, lists, and dictionaries, also have literals, as you will see shortly.

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

String Literals
You can enclose strings in single quotes, double quotes, or sets of three double quotes or
three single quotes. The last notation is useful for a string containing multiple lines of text.
Character values are single-character strings. The \ character is used to escape nongraphic
characters such as the newline (\n) and the tab (\t), or the \ character itself. The next code
6 segment, followed by the output, illustrates the possibilities.
print("Using double quotes")
print('Using single quotes')
print("Mentioning the word ‘Python’ by quoting it")
print("Embedding a\nline break with \\n")
print("""Embedding a
line break with triple quotes""")

Output:
Using double quotes
Using single quotes
Mentioning the word 'Python' by quoting it
Embedding a
line break with \n
Embedding a
line break with triple quotes

Operators and Expressions

Arithmetic expressions use the standard operators (+, –, *, /, %) and infix notation. The
/ operator produces a floating-point result with any numeric operands, whereas the //
­operator produces an integer quotient. The + operator means concatenation when used
with collections, such as strings and lists. The ** operator is used for exponentiation.
The comparison operators <, <=, >, >=, ==, and != work with numbers and strings.
The == operator compares the internal contents of data structures, such as two lists, for
structural equivalence, whereas the is operator compares two values for object identity.
Comparisons return True or False.
The logical operators and, or, and not treat several values, such as 0, None, the empty string,
and the empty list, as False. In contrast, most other Python values count as True.
The subscript operator, [], used with collection objects, will be examined shortly.
The selector operator, ‘ ’, is used to refer to a named item in a module, class, or object.
•

The operators have the standard precedence (selector, function call, subscript, arithmetic,
comparison, logical, assignment). Parentheses are used in the usual manner, to group sub-
expressions for earlier evaluation.
The ** and = operators are right associative, whereas the others are left associative.

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Basic Program Elements

Function Calls
Functions are called in the usual manner, with the function’s name followed by a parenthe-
sized list of arguments. For example:
min(5, 2) # Returns 2

Python includes a few standard functions, such as abs and round. Many other functions are 7
available by import from modules, as you will see shortly.

The print Function

The standard output function print displays its arguments on the console. This function
allows a variable number of arguments. Python automatically runs the str function on each
argument to obtain its string representation and separates each string with a space before
output. By default, print terminates its output with a newline.

The input Function

The standard input function input waits for the user to enter text at the keyboard. When the
user presses the Enter key, the function returns a string containing the characters entered.
This function takes an optional string as an argument and prints this string, ­without a line
break, to prompt the user for the input.

Type Conversion Functions and Mixed-Mode Operations

You can use some data type names as type conversion functions. For example, when the
user enters a number at the keyboard, the input function returns a string of digits, not a
numeric value. The program must convert this string to an int or a float before numeric
processing. The next code segment inputs the radius of a circle, converts this string to a
float, and computes and outputs the circle’s area:

radius = float(input("Radius: "))

print("The area is", 3.14 * radius ** 2)

Like most other languages, Python allows operands of different numeric types in arithmetic
expressions. In those cases, the result type is the same type as the most general operand
type. For example, the addition of an int and a float produces a float as the result.

Optional and Keyword Function Arguments

Functions may allow optional arguments, which can be named with keywords when the
function is called. For example, the print function by default outputs a newline after

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

its arguments are displayed. To prevent this from happening, you can give the optional
­argument end a value of the empty string, as follows:
print("The cursor will stay on this line, at the end", end = "")

Required arguments have no default values. Optional arguments have default values and
can appear in any order when their keywords are used, as long as they come after the
8
required arguments.
For example, the standard function round expects one required argument, a rounded num-
ber, and a second, optional argument, the number of figures of precision. When the second
argument is omitted, the function returns the nearest whole number (an int). When the
second argument is included, the function returns a float. Here are some examples:
>>> round(3.15)
3

>>> round(3.15, 1)
3.2

In general, the number of arguments passed to a function when it is called must be at least
the same number as its required arguments.
Standard functions and Python’s library functions check the types of their arguments when
the function is called. Programmer-defined functions can receive arguments of any type,
including functions and types themselves.

Variables and Assignment Statements

A Python variable is introduced with an assignment statement. For example:
PI = 3.1416

sets PI to the value 3.1416. The syntax of a simple assignment statement is:
<identifier> = <expression>

Several variables can be introduced in the same assignment statement, as follows:

minValue, maxValue = 1, 100

To swap the values of the variables a and b, you write:

a, b = b, a

Assignment statements must appear on a single line of code, unless the line is broken after
a comma, parenthesis, curly brace, or square bracket. When these options are unavailable,
another means of breaking a line within a statement is to end it with the escape symbol \.
You typically place this symbol before or after an operator in an expression. Here are some
admittedly unrealistic examples:
minValue = min(100,
200)
product = max(100, 200) \
* 30
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Basic Program Elements

When you press Enter after a comma or the escape symbol, IDLE automatically indents the
next line of code.

Python Data Typing

9
In Python, any variable can name a value of any type. Variables are not declared to have a
type, as they are in many other languages; they are simply assigned a value.
Consequently, data type names almost never appear in Python programs. However, all
­values or objects have types. The types of operands in expressions are checked at run time,
so type errors do not go undetected; however, the programmer does not have to worry
about mentioning data types when writing code.

import Statements
The import statement makes visible to a program the identifiers from another module.
These identifiers might name objects, functions, or classes. There are several ways to
express an import statement. The simplest is to import the module name, as in:
import math

This makes any name defined in the math module available to the current module, by using
the syntax math.<name>. Thus, math.sqrt(2) would return the square root of 2.
A second style of importing brings in a name itself, which you can use directly without the
module name as a prefix:
from math import sqrt
print(sqrt(2))

You can import several individual names by listing them:

from math import pi, sqrt
print(sqrt(2) * pi)

You can import all names from a module using the * operator, but that is not usually
­considered good programming practice.

Getting Help on Program Components

Although the Python website at www.python.org has complete documentation for the
Python language, help on most language components is also readily available within
the Python shell. To access such help, just enter the function call help(<component>) at the
shell prompt, where <component> is the name of a module, data type, function, or method.
For example, help(abs) and help(math.sqrt) display documentation for the abs and
math.sqrt functions, respectively. Calls of dir(int) and dir(math) list all the operations
in the int type and math module, respectively. You can then run help to get help on one of
these operations.
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

Note that if a module is not the built-in module that Python loads when the shell starts, the
programmer must first import that module before asking for help on it. For example, the
following session with the shell displays the documentation for the numberguess program
discussed earlier in this chapter:
>>> import numberguess
10 >>> help(numberguess)
Help on module numberguess:
NAME
numberguess
DESCRIPTION
Author: Ken Lambert
Plays a game of guess the number with the user.
FUNCTIONS
main()
Inputs the bounds of the range of numbers,
and lets the user guess the computer’s number until
the guess is correct.
FILE
/Users/ken/Documents/CS2Python/Chapters/Chapter1/numberguess.py

Control Statements
Python includes the usual array of control statements for sequencing, conditional execu-
tion, and iteration. A sequence of statements is a set of statements written one after the
other. Each statement in a sequence must begin in the same column. This section examines
the control statements for conditional execution and iteration.

Conditional Statements
The structure of Python’s conditional statements is similar to that of other languages. The
keywords if, elif, and else are significant, as is the colon character and indentation.
The syntax of the one-way if statement is:
if <Boolean expression>:
<sequence of statements>

A Boolean expression is any Python value; as mentioned earlier, some of these count as
False, and the others count as True. If the Boolean expression is True, the sequence of
statements is run; otherwise, nothing happens. The sequence of (one or more) statements
must be indented and aligned at least one space or tab (typically four spaces). The colon
character is the only separator; if there is only one statement in the sequence, it may imme-
diately follow the colon on the same line.
The syntax of the two-way if statement is:
if <Boolean expression>:
<sequence of statements>
else:
<sequence of statements>
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Control Statements

Note the indentation and the colon following the keyword else. Exactly one of these two
sequences of statements will be run. The first sequence is run if the Boolean expression is
True; the second sequence is run if the Boolean expression is False.

The syntax of the multiway if statement is:

if <Boolean expression>:
<sequence of statements>
11
elif <Boolean expression>:
<sequence of statements>
...
else:
<sequence of statements>

A multiway if statement runs exactly one sequence of statements. The multiway if

s­ tatement includes one or more alternative Boolean expressions, each of which follows the
keyword elif. You can omit the trailing else: clause.
The next example outputs the appropriate answer to a question about the relative sizes of
two numbers:
if x > y:
print("x is greater than y")
elif x < y:
print("x is less than y")
else:
print("x is equal to y")

Using if __name__ == "__main__"

The numberguess program discussed earlier includes the definition of a main function and
the following if statement:
if __name__ == "__main__":
main()

The purpose of this if statement is to allow the programmer either to run the module as a
standalone program or to import it from the shell or another module. Here is how this works:
every Python module includes a set of built-in module variables, to which the Python vir-
tual machine automatically assigns values when the module is loaded. If the module is being
loaded as a standalone program (either by running it from a terminal prompt or by loading it
from an IDLE window), the module’s __name__ variable is set to the string "__main__".
Otherwise, this variable is set to the module’s name—in this case, "numberguess". Either
assignment is accomplished before any of the code within the module is loaded. Thus, when
control reaches the if statement at the end of the module, the module’s main function will be
called only if the module has been launched as a standalone program.
The if __name__ == "__main__" idiom is useful when developing standalone program
modules, because it allows the programmer to view help on the module just by importing it
into the shell. Likewise, the programmer can use this idiom in supporting modules to run a
test bed function during module development within IDLE.
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

Loop Statements
The structure of Python’s while loop statement is similar to that of other languages. Here is
the syntax:
while <Boolean expression>:
<sequence of statements>
12
The next example computes and prints the product of the numbers from 1 to 10:
product = 1
value = 1
while value <= 10:
product *= value
value += 1
print(product)

Note the use of the extended assignment operator *=. The line of code in which this
appears is equivalent to:
product = product * value

Python includes a for loop statement for more concise iteration over a sequence of values.
The syntax of this statement is:
for <variable> in <iterable object>:
<sequence of statements>

When this loop runs, it assigns to the loop variable each value contained in the iterable object
and runs the sequence of statements in the context of each such assignment. ­Examples of
iterable objects are strings and lists. The next code segment uses Python’s range function,
which returns an iterable sequence of integers, to compute the product shown earlier:
product = 1
for value in range(1, 11):
product *= value
print(product)

Python programmers generally prefer a for loop to iterate over definite ranges or sequences
of values. They use a while loop when the continuation condition is an arbitrary Boolean
expression.

Strings and Their Operations

As in other languages, a Python string is a compound object that includes other objects,
namely, its characters. However, each character in a Python string is itself a single-character
string and is written literally in a similar manner. Python’s string type, named str, includes
a large set of operations, some of which are introduced in this section.

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Strings and Their Operations

Operators
When strings are compared with the comparison operators, the pairs of characters at each
position in the two strings are compared, using ASCII ordering. Thus, 'a' is less than 'b',
but 'A' is less than 'a'. Note that in this book, we enclose single-character strings in single
quotes and multi-character strings in double quotes.
13
The + operator builds and returns a new string that contains the characters of the two
operands.
The subscript operator in its simplest form expects an integer in the range from 0 to the
length of the string minus 1. The operator returns the character at that position in the
string. Thus:
"greater"[0]   # Returns 'g'

Although a string index cannot exceed its length minus 1, negative indexes are allowed.
When an index is negative, Python adds this value to the string’s length to locate the char-
acter to be returned. In these cases, the index provided cannot be less than the negation of
the string’s length.
Strings are immutable; that is, once you create them, you cannot modify their internal
contents. Thus, you cannot use a subscript to replace the character at a given position in a
string.
A variation of the subscript, called the slice operator, is what you use to obtain a substring
of a string. The syntax of the slice is:
<a string>[<lower>:<upper>]

The value of <lower>, if it is present, is an integer ranging from 0 to the length of the string
minus 1. The value of <upper>, if it is present, is an integer ranging from 0 to the length of
the string.
When you omit both values, the slice returns the entire string. When the first value is
­omitted, the slice returns a substring starting with the string’s first character. When the
second value is omitted, the slice returns a substring ending with the string’s last character.
Otherwise, the slice returns a substring starting with the character at the lower index and
ending with the character at the upper index minus 1.
Here are some examples of the slice operator in action:
"greater"[:]   # Returns "greater"
"greater"[2:]   # Returns "eater"
"greater"[:2]   # Returns "gr"
"greater"[2:5]  # Returns "eat"

The reader is encouraged to experiment with the slice operator in the Python shell.

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

Formatting Strings for Output

Many data-processing applications require output that has a tabular format. In this format,
numbers and other information are aligned in columns that can be either left-justified or
right-justified. A column of data is left-justified if its values are vertically aligned beginning
with their leftmost characters. A column of data is right-justified if its values are verti-
14 cally aligned beginning with their rightmost characters. To maintain the margins between
columns of data, left justification requires the addition of spaces to the right of the datum,
whereas right justification requires adding spaces to the left of the datum. A column of data
is centered if there are equal numbers of spaces on both sides of the data within that column.
The total number of data characters and additional spaces for a given datum in a formatted
string is called its field width.
The print function automatically begins printing an output datum in the first available
column. The next example, which displays the exponents 7 through 10 and the values of 107
through 1010, shows the format of two columns produced by the print statement:
>>> for exponent in range(7, 11):
print(exponent, 10 ** exponent)
7 10000000
8 100000000
9 1000000000
10 10000000000

Note that when the exponent reaches 10, the output of the second column shifts over by a
space and looks ragged. The output would look neater if the left column were left-justified
and the right column were right-justified. When you format floating-point numbers for
output, you should specify the number of digits of precision to be displayed as well as the
field width. This is especially important when displaying financial data in which exactly two
digits of precision are required.
Python includes a general formatting mechanism that allows the programmer to specify
field widths for different types of data. The next session shows how to right justify and left
justify the string "four" within a field width of 6:
>>> "%6s" % "four" # Right justify
' four'
>>> "%-6s" % "four" # Left justify
'four '

The first line of code right justifies the string by padding it with two spaces to its left. The
next line of code left justifies by placing two spaces to the string’s right.
The simplest form of this operation is the following:
<format string> % <datum>

This version contains a format string, the format operator %, and a single data value to
be formatted. The format string can contain string data and other information about
the ­format of the datum. To format the string data value, you can use the notation
%<field width>s in the format string. When the field width is positive, the datum is

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Strings and Their Operations

right-justified; when the field width is negative, you get left justification. If the field width is
less than or equal to the datum’s print length in characters, no justification is added. The
% operator works with this information to build and return a formatted string.

To format integers, the letter d is used instead of s. To format a sequence of data values,
you construct a format string that includes a format code for each datum and place the data
values in a tuple following the % operator. The form of the second version of this operation 15
follows:
<format string> % (<datum-1>, …, <datum-n>)

Armed with the format operation, the powers of 10 loop can now display the numbers in
nicely aligned columns. The first column is left-justified in a field width of 3, and the second
column is right-justified in a field width of 12.
>>> for exponent in range(7, 11):
print("%-3d%12d" % (exponent, 10 ** exponent))
7 10000000
8 100000000
9 1000000000
10 10000000000

The format information for a data value of type float has the form
%<field width>.<precision>f

where .<precision> is optional. The next session shows the output of a floating-point
number without, and then with, a format string:
>>> salary = 100.00
>>> print("Your salary is $" + str(salary))
Your salary is $100.0
>>> print("Your salary is $%0.2f" % salary)
Your salary is $100.00

Here is another, minimal, example of the use of a format string, which says to use a field
width of 6 and a precision of 3 to format the float value 3.14:
>>> "%6.3f" % 3.14
' 3.140'

Note that Python adds a digit of precision to the number’s string and pads it with a space to
the left to achieve the field width of 6. This width includes the place occupied by the deci-
mal point.

Objects and Method Calls

In addition to standard operators and functions, Python includes a vast number of methods
that operate on objects. A method is similar to a function, in that it expects arguments,
performs a task, and returns a value. However, a method is always called on an associated
object. The syntax of a method call is:
<object>.<method name>(<list of arguments>)

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

Here are some examples of method calls on strings:

"greater".isupper() # Returns False
"greater".upper() # Returns "GREATER"
"greater".startswith("great") # Returns True

If you try to run a method that an object does not recognize, Python raises an exception
16 and halts the program. To discover the set of methods that an object recognizes, you
run Python’s dir function, in the Python shell, with the object’s type as an argument.
For ­example, dir(str) returns a list of the names of the methods recognized by string
objects. Running help(str.upper) prints documentation on the use of the method
str.upper.

Some method names, such as __add__ and __len__, are run when Python sees an object
used with certain operators or functions. Thus, for example:
len("greater") # Is equivalent to "greater".__len__()
"great" + "er" # Is equivalent to "great".__add__("er")
"e" in "great" # Is equivalent to "great".__contains__("e")

The reader is encouraged to explore the str methods with the dir and help functions.

Built-In Python Collections and Their Operations

Modern programming languages include several types of collections, such as lists, that
allow the programmer to organize and manipulate several data values at once. This section
explores the built-in collections in Python; the rest of the book discusses how to add new
types of collections to the language.

Lists
A list is a sequence of zero or more Python objects, commonly called items. A list has a
literal representation, which uses square brackets to enclose items separated by commas.
Here are some examples:
[] # An empty list
["greater"] # A list of one string
["greater", "less"] # A list of two strings
["greater", "less", 10] # A list of two strings and an int
["greater", ["less", 10]] # A list with a nested list

Like strings, lists can be sliced and concatenated with the standard operators. However,
the results returned in this case are lists. Unlike strings, lists are mutable, meaning that you
can replace, insert, or remove items contained in them. This fact has two consequences.
First, the lists returned by the slice and concatenation operators are new lists, not pieces
of the original list. Second, the list type includes several methods called mutators, whose
purpose is to modify the structure of a list. You can enter dir(list) in a Python shell to
view them.
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Built-In Python Collections and Their Operations

The most commonly used list mutator methods are append, insert, pop, remove, and sort.
Here are some examples of their use:
testList = [] # testList is []
testList.append(34) # testList is [34]
testList.append(22) # testList is [34, 22]
testList.sort() # testList is [22, 34]
17
testList.pop() # Returns 22; testList is [34]
testList.insert(0, 22) # testList is [22, 34]
testList.insert(1, 55) # testList is [22, 55, 34]
testList.pop(1) # Returns 55; testList is [22, 34]
testList.remove(22) # testList is [34]
testList.remove(55) # raises ValueError

The string methods split and join extract a list of words from a string and glue a list of
words together to form a string, respectively:
"Python is cool".split() # Returns ['Python', 'is', 'cool']
" ".join(["Python", "is", "cool"]) # Returns 'Python is cool'

You are encouraged to explore the list methods with the dir and help functions.

Tuples
A tuple is an immutable sequence of items. Tuple literals enclose items in parentheses.
A tuple is essentially like a list without mutator methods. However, a tuple with one item
must still include a comma, as follows:
>>> (34)
34

>>> (34,)
(34)

Note that Python treats the first expression, (34), as an integer enclosed in parentheses,
whereas the second expression, (34,), is treated as a new tuple of one item. For the avail-
able tuple methods, run dir(tuple) in the Python shell.

Loops Over Sequences

The for loop is used to iterate over items in a sequence, such as a string, a list, or a tuple.
For example, the following code segment prints the items in a list:
testList = [67, 100, 22]
for item in testList:
print(item)

This is equivalent to but simpler than an index-based loop over the list:
testList = [67, 100, 22]
for index in range(len(testList)):
print(testList[index])

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

Dictionaries
A dictionary contains zero or more entries. Each entry associates a unique key with a value.
Keys are typically strings or integers, whereas values are any Python objects.
A dictionary literal encloses the key-value entries in a set of braces. Here are some
18 examples:
{} # An empty dictionary
{"name":"Ken"} # One entry
{"name":"Ken", "age":67} # Two entries
{"hobbies":["reading", "running"]} # One entry, value is a list

You use the subscript operator to access a value at a given key, add a value at a new key, and
replace a value at a given key. The pop method removes the entry and returns the value for
a given key. The keys method returns an iterable object over the keys, whereas the values
method returns an iterable object over the values. Like a list, a dictionary itself is an iterable
object, but the for loop iterates over a dictionary’s keys. The next code segment prints the
keys in a small dictionary:
>>> for key in {"name":"Ken", "age":67}:
print(key)
name
age

The reader is encouraged to explore the dict methods with the dir and help functions and
to experiment with dictionaries and their operations in a Python shell.

Searching for a Value

The programmer can search strings, lists, tuples, or dictionaries for a given value by run-
ning the in operator with the value and the collection. This operator returns True or False.
The target value for a dictionary search should be a potential key.
When it is known that a given value is in a sequence (string, list, or tuple), the index
method returns the position of the first such value.
For dictionaries, the methods get and pop can take two arguments: a key and a default
value. A failed search returns the default value, whereas a successful search returns the
value associated with the key.

Pattern Matching with Collections

Although the subscript can be used to access items within lists, tuples, and dictionaries, it
is often more convenient to access several items at once by means of pattern matching. For
example, the value returned by a color chooser dialog is a tuple that contains two items.
When the user selects a color, the first item is a nested tuple of three numbers, and the
second item is a string. Thus, the outer tuple has the form ((<r>, <g>, <b>), <string>).
It’s best for the three numbers to be assigned to three distinct variables and the string to a
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Creating New Functions

fourth variable, for further processing. Here is the code to accomplish this, using the sub-
script operator on colorTuple, which names the value returned by the color chooser:
rgbTuple = colorTuple[0]
hexString = colorTuple[1]
r = rgbTuple[0]
g = rgbTuple[1]
19
b = rgbTuple[2]

A pattern match uses an assignment of a structure to another structure of exactly the same
form. The target structure includes variables that will pick up the values at the correspond-
ing positions in the source structure. You can then use the variables for further processing.
Using pattern matching, you can accomplish this task in a single line of code, as follows:
((r, g, b), hexString) = colorTuple

Creating New Functions

Although Python is an object-oriented language, it includes a number of built-in functions
and allows the programmer to create new functions as well. These new functions can uti-
lize recursion, and they can receive and return functions as data. Python thus allows the
programmer to design solutions using a thoroughly functional style of programming. This
section introduces some of these ideas.

Function Definitions
The syntax of a Python function definition is:
def <function name>(<list of parameters>):
<sequence of statements>

The rules and conventions for spelling function names and parameter names are the same
as for variable names. The list of required parameters can be empty or can include names
separated by commas. Again, unlike some other programming languages, no data types are
associated with the parameter names or with the function name itself.
Here is the definition of a simple function to compute and return the square of a number:
def square(n):
"""Returns the square of n."""
result = n ** 2
return result

Note the use of the string with triple quotes beneath the function header. This is a doc-
string. This string behaves like a comment within the function but also will be displayed
when the user enters help(square) at a Python shell prompt. Every function you define
should include a docstring that states what the function does and gives information about
any arguments or returned values.
Functions can introduce new variables, also called temporary variables. In the square
function, n is a parameter and result is a temporary variable. A function’s parameters and
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

temporary variables exist only during the lifetime of a function call and are not visible to
other functions or the surrounding program. Thus, several different functions may use the
same parameters and variable names without conflicts.
When a function does not include a return statement, it automatically returns the value
None after its last statement executes.
20
You can define functions in any order in a module, as long as no function is actually exe-
cuted before its definition has been compiled. The next example shows an illegal function
call at the beginning of a module:
first() # Raises a NameError (function undefined yet)

def first():
print("Calling first.")
second() # Not an error, because not actually
# called until after second is defined

def second():
print("Calling second.")

first() # Here is where the call of first should go

When Python runs the first line of code, function first has not yet been defined, so an
exception is raised. Were you to place a comment symbol # at the beginning of this line
and run the code again, the program would run to a normal termination. In this case, even
though function second appears to be called before it is defined, it is not actually called
until function first is called, by which time both functions have been defined.
You can specify parameters as optional, with default values, using the notation ­<parameter
name> = <default value>. Required parameters (those without default values) must
­precede optional parameters in the parameter list.

Recursive Functions
A recursive function is a function that calls itself. To prevent a function from repeating
itself indefinitely, it must contain at least one selection statement. This statement examines
a condition called a base case to determine whether to stop or to continue with a recursive
step.
Let’s examine how to convert an iterative algorithm to a recursive function. Here is a
­ efinition of a function displayRange that prints the numbers from a lower bound to an
d
upper bound:
def displayRange(lower, upper):
"""Outputs the numbers from lower to upper."""
while lower <= upper:
print(lower)
lower = lower + 1

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Creating New Functions

How would you go about converting this function to a recursive one? First, you should note
two important facts:
•• The loop’s body continues execution while lower <= upper.
•• When the function executes, lower is incremented by 1 but upper never changes.
The equivalent recursive function performs similar primitive operations, but the loop is 21
replaced with an if statement and the assignment statement is replaced with a recursive
call of the function. Here is the code with these changes:
def displayRange(lower, upper):
"""Outputs the numbers from lower to upper."""
if lower <= upper:
print(lower)
displayRange(lower + 1, upper)

Although the syntax and design of the two functions are different, the same algorith-
mic process is executed. Each call of the recursive function visits the next number in the
sequence, just as the loop does in the iterative version of the function.
Most recursive functions expect at least one argument. This data value tests for the
base case that ends the recursive process. It is also modified in some way before each
­recursive step. The modification of the data value should produce a new data value that
allows the function to eventually reach the base case. In the case of displayRange, the
value of the argument lower is incremented before each recursive call so that it eventu-
ally exceeds the value of the argument upper.
The next example is a recursive function that builds and returns a value. Python’s sum func-
tion expects a collection of numbers and returns their sum. This function should return the
sum of the numbers from a lower bound through an upper bound. The recursive ourSum
function returns 0 if lower exceeds upper (the base case). Otherwise, the function adds
lower to the ourSum of lower+ 1 through upper and returns this result. Here is the code for
this function:
def ourSum(lower, upper):
"""Returns the sum of the numbers from lower thru upper."""
if lower > upper:
return 0
else:
return lower + ourSum(lower + 1, upper)

The recursive call of ourSum adds the numbers from lower + 1 through upper. The func-
tion then adds lower to this result and returns it.
To get a better understanding of how recursion works, it is helpful to trace its calls. You
can do that for the recursive version of the ourSum function. You add an argument for a
margin of indentation and a print statement to trace the two arguments and the value
returned on each call. The first statement on each call computes the indentation, which
is then used in printing the two arguments. The value computed is also printed with

Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
 Chapter 1 Basic Python Programming

this indentation just before each call returns. Here is the code, followed by a session
showing its use:
def ourSum(lower, upper, margin = 0):
"""Returns the sum of the numbers from lower to upper,
and outputs a trace of the arguments and return values
on each call."""
22
blanks = " " * margin
print(blanks, lower, upper) # Print the arguments
if lower > upper:
print(blanks, 0) # Print the returned value
return 0
else:
result = lower + ourSum(lower + 1, upper, margin + 4)
print(blanks, result) # Print the returned value
return result

Usage:
>>> ourSum(1, 4)
1 4
2 4
3 4
4 4
5 4
0
4
7
9
10
10

The displayed pairs of arguments are indented further to the right as the calls of
­ urSum proceed. Note that the value of lower increases by 1 on each call, whereas
o
the value of upper stays the same. The final call of ourSum returns 0. As the recursion
unwinds, each value returned is aligned with the arguments above it and increases
by the current value of lower. This type of tracing can be a useful debugging tool for
recursive functions.

Nested Function Definitions

Definitions of other functions may be nested within a function’s sequence of s­ tatements.
Consider the following two definitions of a recursive factorial function. The first
­definition uses a nested helper function to carry out the recursion with required ­parameters.
The second definition gives the second parameter a default value to simplify the design.
# First definition
def factorial(n):
"""Returns the factorial of n."""

def recurse(n, product):

"""Helper function to compute factorial."""
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. WCN 02-200-203
Copyright 2019 Cengage Learning. All Rights Reserved. May not be copied, scanned, or duplicated, in whole or in part. Due to electronic rights, some third party content may be suppressed from the eBook and/or eChapter(s).
Editorial review has deemed that any suppressed content does not materially affect the overall learning experience. Cengage Learning reserves the right to remove additional content at any time if subsequent rights restrictions require it.
Another random document with
no related content on Scribd:
 Further; we see in Plato, that one of the grounds of the failure in
this attempt, was the assumption that the reason why every thing is
what it is and as it is, must be that so it is best, according to some
view of better or worse attainable by man. Socrates, in his dying
conversation, as given in the Phædo, declares this to have been
what he sought in the philosophy of his time; and tells his friends that
he turned away from the speculations of Anaxagoras because they
did not give him such reasons for the constitution of the world; and
Plato’s Timæus is, in reality, an attempt to supply this deficiency, and
to present a Theory of the Universe, in which every thing is
accounted for by such reasons. Though this is a failure, it is a noble
as well as an instructive failure. ~Additional material in the 3rd
edition.~
 B O O K III.

HISTORY
OF

G R E E K A S T R O N O M Y.
 Τόδε δὲ μηδείς ποτε φοβηθῇ τῶν Ἑλλήνων, ὡς οὐ χρὴ περὶ τὰ θεῖα ποτὲ
πραγματεύεσθαι θνητοὺς ὄντας· πᾶν δε τούτου διανοηθῆναι τοὐναντίον,
ὡς οὔτε ἄφρον ἔστι ποτὲ τὸ θεῖον, οὔτε ἀγνοεῖ που τὴν ἀνθρωπίνην φυσιν·
ἀλλ’ οἶδεν ὅτι, διδάσκοντος αὐτοῦ, ξυνακολουθήσει καὶ μαθήσεται τὰ
διδάσκομενα.—Plato, Epinomis, p. 988.

Nor should any Greek have any misgiving of this kind; that it is not fitting
for us to inquire narrowly into the operations of Superior Powers, such as
those by which the motions of the heavenly bodies are produced: but, on
the contrary, men should consider that the Divine Powers never act
without purpose, and that they know the nature of man: they know that by
their guidance and aid, man may follow and comprehend the lessons
which are vouchsafed him on such subjects.
 INTRODUCTION.

T HE earliest and fundamental conceptions of men respecting the

objects with which Astronomy is concerned, are formed by
familiar processes of thought, without appearing to have in them any
thing technical or scientific. Days, Years, Months, the Sky, the
Constellations, are notions which the most uncultured and incurious
minds possess. Yet these are elements of the Science of Astronomy.
The reasons why, in this case alone, of all the provinces of human
knowledge, men were able, at an early and unenlightened period, to
construct a science out of the obvious facts of observation, with the
help of the common furniture of their minds, will be more apparent in
the course of the philosophy of science: but I may here barely
mention two of these reasons. They are, first, that the familiar act of
thought, exercised for the common purposes of life, by which we
give to an assemblage of our impressions such a unity as is implied
in the above notions and terms, a Month, a Year, the Sky, and the
like, is, in reality, an inductive act, and shares the nature of the
processes by which all sciences are formed; and, in the next place,
that the ideas appropriate to the induction in this case, are those
which, even in the least cultivated minds, are very clear and definite;
namely, the ideas of Space and Figure, Time and Number, Motion
and Recurrence. Hence, from their first origin, the modifications of
those ideas assume a scientific form.

We must now trace in detail the peculiar course which, in

consequence of these causes, the knowledge of man respecting the
heavenly bodies took, from the earliest period of his history. 112
 CHAPTER I.

Earliest Stages of Astronomy.

Sect. 1.—Formation of the Notion of a Year.

T HE notion of a Day is early and obviously impressed upon man

in almost any condition in which we can imagine him. The
recurrence of light and darkness, of comparative warmth and cold, of
noise and silence, of the activity and repose of animals;—the rising,
mounting, descending, and setting of the sun;—the varying colors of
the clouds, generally, notwithstanding their variety, marked by a daily
progression of appearances;—the calls of the desire of food and of
sleep in man himself, either exactly adjusted to the period of this
change, or at least readily capable of being accommodated to it;—
the recurrence of these circumstances at intervals, equal, so far as
our obvious judgment of the passage of time can decide; and these
intervals so short that the repetition is noticed with no effort of
attention or memory;—this assemblage of suggestions makes the
notion of a Day necessarily occur to man, if we suppose him to have
the conception of Time, and of Recurrence. He naturally marks by a
term such a portion of time, and such a cycle of recurrence; he calls
each portion of time, in which this series of appearances and
occurrences come round, a Day; and such a group of particulars are
considered as appearing or happening in the same day.

A Year is a notion formed in the same manner; implying in the

same way the notion of recurring facts; and also the faculty of
arranging facts in time, and of appreciating their recurrence. But the
notion of a Year, though undoubtedly very obvious, is, on many
accounts, less so than that of a Day. The repetition of similar
circumstances, at equal intervals, is less manifest in this case, and
the intervals being much longer, some exertion of memory becomes
requisite in order that the recurrence may be perceived. A child
might easily be persuaded that successive years were of unequal
length; or, if the summer were cold, and the spring and autumn
warm, might be made to believe, if all who spoke in its hearing
agreed to support the delusion, that one year was two. It would be
impossible to practise such a deception with regard to the day,
without the use of some artifice beyond mere words. 113

Still, the recurrence of the appearances which suggest the notion

of a Year is so obvious, that we can hardly conceive man without it.
But though, in all climes and times, there would be a recurrence, and
at the same interval in all, the recurring appearances would be
extremely different in different countries; and the contrasts and
resemblances of the seasons would be widely varied. In some
places the winter utterly alters the face of the country, converting
grassy hills, deep leafy woods of various hues of green, and running
waters, into snowy and icy wastes, and bare snow-laden branches;
while in others, the field retains its herbage, and the tree its leaves,
all the year; and the rains and the sunshine alone, or various
agricultural employments quite different from ours, mark the passing
seasons. Yet in all parts of the world the yearly cycle of changes has
been singled out from all others, and designated by a peculiar name.
The inhabitant of the equatorial regions has the sun vertically over
him at the end of every period of six months, and similar trains of
celestial phenomena fill up each of these intervals, yet we do not find
years of six months among such nations. The Arabs alone, 1 who
practise neither agriculture nor navigation, have a year depending
upon the moon only; and borrow the word from other languages,
when they speak of the solar year.
1 Ideler, Berl. Trans. 1813, p. 51.

In general, nations have marked this portion of time by some word

which has a reference to the returning circle of seasons and
employments. Thus the Latin annus signified a ring, as we see in the
derivative annulus: the Greek term ἐνιαυτὸς implies something which
returns into itself: and the word as it exists in Teutonic languages, of
which our word year is an example, is said to have its origin in the
word yra which means a ring in Swedish, and is perhaps connected
with the Latin gyrus.

Sect. 2.—Fixation of the Civil Year.

The year, considered as a recurring cycle of seasons and of

general appearances, must attract the notice of man as soon as his
attention and memory suffice to bind together the parts of a
succession of the length of several years. But to make the same
term imply a certain fixed number of days, we must know how many
days the cycle of the seasons occupies; a knowledge which requires
faculties and artifices beyond what we have already mentioned. For
instance, men cannot reckon as far as any number at all
approaching the number of days in the year, without possessing a
system of numeral terms, and methods 114 of practical numeration
on which such a system of terms is always founded. 2 The South
American Indians, the Koussa Caffres and Hottentots, and the
natives of New Holland, all of whom are said to be unable to reckon
further than the fingers of their hands and feet, 3 cannot, as we do,
include in their notion of a year the fact of its consisting of 365 days.
This fact is not likely to be known to any nation except those which
have advanced far beyond that which may be considered as the
earliest scientific process which we can trace in the history of the
human race, the formation of a method of designating the
successive numbers to an indefinite extent, by means of names,
framed according to the decimal, quinary, or vigenary scale.
2 Arithmetic in Encyc. Metrop. (by Dr. Peacock), Art. 8.

3 Ibid. Art. 32.

But even if we suppose men to have the habit of recording the

passage of each day, and of counting the score thus recorded, it
would be by no means easy for them to determine the exact number
of days in which the cycle of the seasons recurs; for the
indefiniteness of the appearances which mark the same season of
the year, and the changes to which they are subject as the seasons
are early or late, would leave much uncertainty respecting the
duration of the year. They would not obtain any accuracy on this
head, till they had attended for a considerable time to the motions
and places of the sun; circumstances which require more precision
of notice than the general facts of the degrees of heat and light. The
motions of the sun, the succession of the places of his rising and
setting at different times of the year, the greatest heights which he
reaches, the proportion of the length of day and night, would all
exhibit several cycles. The turning back of the sun, when he had
reached the greatest distance to the south or to the north, as shown
either by his rising or by his height at noon, would perhaps be the
most observable of such circumstances. Accordingly the τροπαὶ
ἠελίοιο, the turnings of the sun, are used repeatedly by Hesiod as a
mark from which he reckons the seasons of various employments.
“Fifty days,” he says, “after the turning of the sun, is a seasonable
time for beginning a voyage.” 4
4
Ἤματα πεντήκοντα μετὰ τροπὰς ἠελίοιο
Ἐς τέλος ἐλθόντος θέρεος.—Op. et Dies, 661.

The phenomena would be different in different climates, but the

recurrence would be common to all. Any one of these kinds of
phenomena, noted with moderate care for a year, would show what
was the number of days of which a year consisted; and if several
years 115 were included in the interval through which the scrutiny
extended, the knowledge of the length of the year so acquired would
be proportionally more exact.

Besides those notices of the sun which offered exact indications of

the seasons, other more indefinite natural occurrences were used;
as the arrival of the swallow (χελιδών) and the kite (ἰκτίν), The birds,
in Aristophanes’ play of that name, mention it as one of their offices
to mark the seasons; Hesiod similarly notices the cry of the crane as
an indication of the departure of winter. 5
5 Ideler, i. 240.

Among the Greeks the seasons were at first only summer and
winter (θέρος and χειμών), the latter including all the rainy and cold
portion of the year. The winter was then subdivided into the χειμών
and ἔαρ (winter proper and spring), and the summer, less definitely,
into θέρος and ὀπώρα (summer and autumn). Tacitus says that the
Germans knew neither the blessings nor the name of autumn,
“Autumni perinde nomen ac bona ignorantur.” Yet harvest, herbst, is
certainly an old German word. 6
6 Ib. i. 243.
 In the same period in which the sun goes through his cycle of
positions, the stars also go through a cycle of appearances
belonging to them; and these appearances were perhaps employed
at as early a period as those of the sun, in determining the exact
length of the year. Many of the groups of fixed stars are readily
recognized, as exhibiting always the same configuration; and
particular bright stars are singled out as objects of attention. These
are observed, at particular seasons, to appear in the west after
sunset; but it is noted that when they do this, they are found nearer
and nearer to the sun every successive evening, and at last
disappear in his light. It is observed also, that at a certain interval
after this, they rise visibly before the dawn of day renders the stars
invisible; and after they are seen to do this, they rise every day at a
longer interval before the sun. The risings and settings of the stars
under these circumstances, or under others which are easily
recognized, were, in countries where the sky is usually clear,
employed at an early period to mark the seasons of the year.
Eschylus 7 makes Prometheus mention this among the benefits of
which 116 he, the teacher of arts to the earliest race of men, was the
communicator.
7
Οὔκ ἤν γαρ αὐτοῖς οὔτε χείματος τέκμαρ,
Οὔτ’ ἀνθεμώδους ἦρος, οὔδε καρπίμου
Θέρους βέβαιον· ἀλλ’ ἄτερ γνώμης τὸ πᾶν
Ἔπρασσον, ἔστε δή σφιν ἀνατολὰς ἐγὼ
Ἄστρων ἔδειξα, τάς τε δυσκρίτους δύσεις.—Prom.
V. 454.

Thus, for instance, the rising 8 of the Pleiades in the evening was a
mark of the approach of winter. The rising of the waters of the Nile in
Egypt coincided with the heliacal rising of Sirius, which star the
Egyptians called Sothis. Even without any artificial measure of time
or position, it was not difficult to carry observations of this kind to
such a degree of accuracy as to learn from them the number of days
which compose the year; and to fix the precise season from the
appearance of the stars.
8 Ideler (Chronol. i. 242) says that this rising of the Pleiades took
place at a time of the year which corresponds to our 11th May,
and the setting to the 20th October; but this does not agree with
the forty days of their being “concealed,” which, from the context,
must mean, I conceive, the interval between their setting and
rising. Pliny, however, says, “Vergiliarum exortu æstas incipit,
occasu hiems; semestri spatio intra se messes vindemiasque et
omnium maturitatem complexæ.” (H. N. xviii. 69.)
The autumn of the Greeks, ὀπώρα, was earlier than our
autumn, for Homer calls Sirius ἀστὴρ ὀπωρινός, which rose at the
end of July.

A knowledge concerning the stars appears to have been first

cultivated with the last-mentioned view, and makes its first
appearance in literature with this for its object. Thus Hesiod directs
the husbandman when to reap by the rising, and when to plough by
the setting of the Pleiades. 9 In like manner Sirius, 10 Arcturus, 11 the
Hyades and Orion, 12 are noticed.
9
Πληίαδων Ἀτλαγενέων ἐπιτελλομενάων.
Ἄρχεσθ’ ἀμητοῦ· ἀρότοιο δὲ, δυσομενάων.
Αἵ δή τοι νύκτας τε καὶ ἤματα τεσσεράκοντα
Κεκρύφαται, αὔτις δὲ περιπλομένου ἐνιαυτοῦ
Φαίνονται. Op. et Dies, l. 381.

10 Ib. l. 413.

11
Εὖτ’ ἂν δ’ ἑξήκοντα μετὰ τροπὰς ἠελίοιο
Χειμέρι’, ἐκτελέσῃ Ζεὺς ἤματα, δή ῥα τότ’ ἀστὴρ
Ἀρκτοῦρος, προλιπὼν ἱερὸν ῥόον Ὠκεανοῖο
Πρῶτον παμφαίνων ἐπιτέλλεται ἀκροκνέφαιος.
 Op. et Dies, l. 562.

Εὖτ’ ἂν δ’ Ὠρίων καὶ Σείριος ἐς μέσον ἔλθῃ

Οὐρανὸν, Ἀρκτοῦρον δ’ ἐσὶδῃ ῥοδοδάκτυλος ἠὼς.
Ib. 607.
12
. . . . . . . αὐτὰρ ἐπὴν δὴ
Πληϊάδες Ὑάδες τε τὸ τε σθένος Ὠρίωνος
Δύνωσιν. Ib. 612.

These methods were employed to a late period, because the

Greek months, being lunar, did not correspond to the seasons.
Tables of such motions were called παραπήγματα.—Ideler, Hist.
Untersuchungen, p. 209.

117 By such means it was determined that the year consisted, at

least, nearly, of 365 days. The Egyptians, as we learn from
Herodotus, 13 claimed the honor of this discovery. The priests
informed him, he says, “that the Egyptians were the first men who
discovered the year, dividing it into twelve equal parts; and this they
asserted that they discovered from the stars.” Each of these parts or
months consisted of 30 days, and they added 5 days more at the
end of the year, “and thus the circle of the seasons come round.” It
seems, also, that the Jews, at an early period, had a similar
reckoning of time, for the Deluge which continued 150 days (Gen. vii.
24), is stated to have lasted from the 17th day of the second month
(Gen. vii. 11) to the 17th day of the seventh month (Gen. viii. 4), that
is, 5 months of 30 days.
13 Ib. ii. 4.

A year thus settled as a period of a certain number of days is

called a Civil Year. It is one of the earliest discoverable institutions of
States possessing any germ of civilization; and one of the earliest
portions of human systematic knowledge is the discovery of the
length of the civil year, so that it should agree with the natural year,
or year of the seasons.

Sect. 3.—Correction of the Civil Year. (Julian Calendar.)

In reality, by such a mode of reckoning as we have described, the

circle of the seasons would not come round exactly. The real length
of the year is very nearly 365 days and a quarter. If a year of 365
days were used, in four years the year would begin a day too soon,
when considered with reference to the sun and stars; and in 60
years it would begin 15 days too soon: a quantity perceptible to the
loosest degree of attention. The civil year would be found not to
coincide with the year of the seasons; the beginning of the former
would take place at different periods of the latter; it would wander
into various seasons, instead of remaining fixed to the same season;
the term year, and any number of years, would become ambiguous:
some correction, at least some comparison, would be requisite.

We do not know by whom the insufficiency of the year of 365 days

was first discovered; 14 we find this knowledge diffused among all
civilized nations, and various artifices used in making the correction.
The method which we employ, and which consists in reckoning an
118 additional day at the end of February every fourth or leap year, is
an example of the principle of intercalation, by which the correction
was most commonly made. Methods of intercalation for the same
purpose were found to exist in the new world. The Mexicans added
13 days at the end of every 52 years. The method of the Greeks was
more complex (by means of the octaëteris or cycle of 8 years); but it
had the additional object of accommodating itself to the motions of
the moon, and therefore must be treated of hereafter. The Egyptians,
on the other hand, knowingly permitted their civil year to wander, at
least so far as their religious observances were concerned. “They do
not wish,” says Geminus, 15 “the same sacrifices of the gods to be
made perpetually at the same time of the year, but that they should
go through all the seasons, so that the same feast may happen in
summer and winter, in spring and autumn.” The period in which any
festival would thus pass through all the seasons of the year is 1461
years; for 1460 years of 365¼ days are equal to 1461 years of 365
days. This period of 1461 years is called the Sothic Period, from
Sothis, the name of the Dog-star, by which their fixed year was
determined; and for the same reason it is called the Canicular
Period. 16
14 Syncellus (Chronographia, p. 123) says that according to the
legend, it was King Aseth who first added the 5 additional days to
360, for the year, in the eighteenth century, b. c.

15 Uranol. p. 33.

16 Censorinus de Die Natali, c. 18.

Other nations did not regulate their civil year by intercalation at

short intervals, but rectified it by a reform when this became
necessary. The Persians are said to have added a month of 30 days
every 120 years. The Roman calendar, at first very rude in its
structure, was reformed by Numa, and was directed to be kept in
order by the perpetual interposition of the augurs. This, however,
was, from various causes, not properly done; and the consequence
was, that the reckoning fell into utter disorder, in which state it was
found by Julius Cæsar, when he became dictator. By the advice of
Sosigenes, he adopted the mode of intercalation of one day in 4
years, which we still retain; and in order to correct the derangement
which had already been produced, he added 90 days to a year of the
usual length, which thus became what was called the year of
confusion. The Julian Calendar, thus reformed, came into use,
January 1, b. c. 45.

Sect. 4.—Attempts at the Fixation of the Month.

The circle of changes through which the moon passes in about

thirty days, is marked, in the earliest stages of language, by a word
which implies the space of time which one such circle occupies; just
119 as the circle of changes of the seasons is designated by the word
year. The lunar changes are, indeed, more obvious to the sense,
and strike a more careless person, than the annual; the moon, when
the sun is absent, is almost the sole natural object which attracts our
notice; and we look at her with a far more tranquil and agreeable
attention than we bestow on any other celestial object. Her changes
of form and place are definite and striking to all eyes; they are
uninterrupted, and the duration of their cycle is so short as to require
no effort of memory to embrace it. Hence it appears to be more easy,
and in earlier stages of civilization more common, to count time by
moons than by years.

The words by which this period of time is designated in various

languages, seem to refer us to the early history of language. Our
word month is connected with the word moon, and a similar
connection is noticeable in the other branches of the Teutonic. The
Greek word μὴν in like manner is related to μήνη, which though not
the common word for the moon, is found in Homer with that
signification. The Latin word mensis is probably connected with the
same group. 17
 17 Cicero derives this word from the verb to measure: “quia
mensa spatia conficiunt, menses nominantur;” and other
etymologists, with similar views, connect the above-mentioned
words with the Hebrew manah, to measure (with which the Arabic
word almanach is connected). Such a derivation would have
some analogy with that of annus, &c., noticed above: but if we are
to attempt to ascend to the earliest condition of language, we
must conceive it probable that men would have a name for a most
conspicuous visible object, the moon, before they would have a
verb denoting the very abstract and general notion, to measure.

The month is not any exact number of days, being more than 29,
and less than 30. The latter number was first tried, for men more
readily select numbers possessing some distinction of regularity. It
existed for a long period in many countries. A very few months of 30
days, however, would suffice to derange the agreement between the
days of the months and the moon’s appearance. A little further trial
would show that months of 29 and 30 days alternately, would
preserve, for a considerable period, this agreement.

The Greeks adopted this calendar, and, in consequence,

considered the days of their month as representing the changes of
the moon: the last day of the month was called ἔνη καὶ νέα, “the old
and new” as belonging to both the waning and the reappearing
moon: 18 and their 120 festivals and sacrifices, as determined by the
calendar, were conceived to be necessarily connected with the same
periods of the cycles of the sun and moon. “The laws and the
oracles,” says Geminus, “which directed that they should in
sacrifices observe three things, months, days, years, were so
understood.” With this persuasion, a correct system of intercalation
became a religious duty.
 18 Aratus says of the moon, in a passage quoted by Geminus, p.
33:
Αἴει δ’ ἄλλοθεν ἄλλα παρακλίνουσα μετωπὰ
Εἴρῃ, ὁποσταίη μήνος περιτέλλεται ἡὼς
As still her shifting visage changing turns,
By her we count the monthly round of morns.

The above rule of alternate months of 29 and 30 days, supposes

the length of the months 29 days and a half, which is not exactly the
length of a lunar month. Accordingly the Months and the Moon were
soon at variance. Aristophanes, in “The Clouds,” makes the Moon
complain of the disorder when the calendar was deranged.

Οὐκ ἄγειν τὰς ἡμέρας

Οὐδὲν ὀρθῶς, ἀλλ’ ἀνω τε καὶ κάτω κυδοιδοπᾶν
Ὥστ’ ἀπειλεῖν φησὶν αὐτῇ τοὐς θεοὺς ἑκάστοτε
Ἡνίκ’ ἂν ψευσθῶσι δείπνου κἀπίωσιν οἴκαδε
Τῆς ἑορτῆς μὴ τυχόντες κατὰ λόγον τῶν ἡμερῶν.
Nubes, 615–19.

Chorus of Clouds.

The Moon by us to you her greeting sends,

But bids us say that she’s an ill-used moon,
And takes it much amiss that you should still
Shuffle her days, and turn them topsy-turvy:
And that the gods (who know their feast-days well)
By your false count are sent home supperless,
And scold and storm at her for your neglect.19

19This passage is supposed by the commentators to be intended

as a satire upon those who had introduced the cycle of Meton
(spoken of in Sect. 5), which had been done at Athens a few
years before “The Clouds” was acted.
 The correction of this inaccuracy, however, was not pursued
separately, but was combined with another object, the securing a
correspondence between the lunar and solar years, the main
purpose of all early cycles.

Sect. 5.—Invention of Lunisolar Years.

There are 12 complete lunations in a year; which according to the

above rule (of 29½ days to a lunation) would make 354 days, leaving
12¼ days of difference between such a lunar year and a solar year.
It is said that, at an early period, this was attempted to be corrected
by interpolating a month of 30 days every alternate year; and
Herodotus 20 relates a conversation of Solon, implying a still ruder
mode of 121 intercalation. This can hardly be considered as an
improvement in the Greek calendar already described.
20 B. i. c. 15.

The first cycle which produced any near correspondence of the

reckoning of the moon and the sun, was the Octaëteris, or period of
8 years: 8 years of 354 days, together with 3 months of 30 days
each, making up (in 99 lunations) 2922 days; which is exactly the
amount of 8 years of 365¼ days each. Hence this period would
answer its purpose, so far as the above lengths of the lunar and
solar cycles are exact; and it might assume various forms, according
to the manner in which the three intercalary months were distributed.
The customary method was to add a thirteenth month at the end of
the third, fifth, and eighth year of the cycle. This period is ascribed to
various persons and times; probably different persons proposed
different forms of it. Dodwell places its introduction in the 59th
Olympiad, or in the 6th century, b. c.: but Ideler thinks the
astronomical knowledge of the Greeks of that age was too limited to
allow of such a discovery.

This cycle, however, was imperfect. The duration of 99 lunations is

something more than 2922 days; it is more nearly 2923½; hence in
16 years there was a deficiency of 3 days, with regard to the motions
of the moon. This cycle of 16 years (Heccædecaëteris), with 3
interpolated days at the end, was used, it is said, to bring the
calculation right with regard to the moon; but in this way the origin of
the year was displaced with regard to the sun. After 10 revolutions of
this cycle, or 160 years, the interpolated days would amount to 30,
and hence the end of the lunar year would be a month in advance of
the end of the solar. By terminating the lunar year at the end of the
preceding month, the two years would again be brought into
agreement: and we have thus a cycle of 160 years. 21
21 Geminus. Ideler.

This cycle of 160 years, however, was calculated from the cycle of
16 years; and it was probably never used in civil reckoning; which
the others, or at least that of 8 years, appear to have been.

The cycles of 16 and 160 years were corrections of the cycle of 8

years; and were readily suggested, when the length of the solar and
lunar periods became known with accuracy. But a much more exact
cycle, independent of these, was discovered and introduced by
Meton, 22 432 years b. c. This cycle consisted of 19 years, and is so
correct and convenient, that it is in use among ourselves to this day.
The time occupied by 19 years, and by 235 lunations, is very nearly
the same; 122 (the former time is less than 6940 days by 9½ hours,
the latter, by 7½ hours). Hence, if the 19 years be divided into 235
months, so as to agree with the changes of the moon, at the end of