CS 1210

Computer science is a science of abstraction—creating the right model for a problem and devising the appropriate mechanizable techniques to solve it.

–Alfred V. Aho

Abstraction is deliverance.

–James Brandon Lewis

Introduction to Programming

Presented here is a subset of materials for use in CS 1210 Introduction to Programming. What follows is incomplete, and subject to revision, deletion, and rearrangement.

Textbook: Cafiero, Clayton. 2023–2025. An Introduction to Programming and Computer Science with Python. ISBN: 979-8-9887092-0-6. Hard copy available in UVM Bookstore (price should be $14.00). Revision history (from first print edition forward)

Feedback, including reports of errata, criticisms, suggestions, and proposed revisions, is warmly encouraged.

Second edition in the works

The second edition of the textbook is almost done, and I expect to have it completed by August 2025. Here’s a draft (incomplete, and content subject to change): An Introduction to Programming and Computer Science with Python, Second Edition. ISBN: 979-8-9887092-1-3.

Second edition adds the following:

• expanded treatment of functions and scope, with coverage of free variables and Python’s LEGB resolution strategy;
• coverage of UnboundLocalError and UnicodeDecodeError exceptions;
• coverage of Python’s built-in sorted()
• coverage of string methods .replace(), .join(), and .split();
• coverage of sequence method .count();
• using the keyword is to test for identity;
• coverage of list method .extend();
• coverage of random module functions .gauss() and .sample() and math module functions .exp(), .log(), .log2(), .log10(), .floor(), .ceil(), .degrees() and .radians();
• sets;
• expanded treatment of structured data including named tuples and the json module;
• use and abuse of the global keyword;
• strategies for dealing with long lines and PEP 8; and
• new appendices: Code smells for beginners, An even deeper dive into functions, The joy of Unicode, and An introduction to databases with SQLite

Preliminaries

Since we’ll be writing programs in Python, you’ll need… Python!

• Installing Python
• Syntax highlighting
• Getting started with Thonny IDE (video 6:40)

Selections from the textbook

Here are selections from the textbook, An Introduction To Programming and Computer Science With Python, and some supplemental videos.

01: Introduction

• Introduction
• Documentation

02: Programming and the Python Shell

• Introduction
• Why learn a programming language?
• The Python shell
• The Python shell (video 7:18)
• Hello, Python!
• Syntax and semantics
• Introduction to binary numbers

03: Types and literals

• Introduction
• What are types?
• Dynamic typing
• Types and memory
• More on string literals
• Literals, types, expressions, and operators (video 22:33)
• Representation error of numeric types

04: Variables, statements, and expressions

• Introduction
• Variables and assignment
• Variables and assignment (video 15:46)
• Expressions
• Expressions (video 8:16)
• Euclidean or “floor” division
• Exponentiation
• Exceptions

05: Functions

• Introduction
• Introduction to functions
• A deeper dive into functions
• Passing arguments to a function
• Functions (video 9:21)
• Functions with more than one parameter (video 15:35)
• Scope
• Pure and impure functions
• Pure and impure functions (video 5:00)
• The math module
• Free variables, scope, and LEGB
• Exceptions

06: Style

• Introduction
• The importance of style
• Constants
• Comments in code
• Dealing with long lines

07: Console I/O

• Introduction
• Motivation and the command line interface (CLI)
• Using the input() function (video 13:51)
• Some ways to format output
• Example: currency converter
• Format specifiers: a quick reference
• Using f-strings and format specifiers (video 19:57)
• Exceptions
• How to read exceptions (video 7:49)

08: Branching, comparisons, and conditions

• Introduction
• Boolean logic and Boolean expressions
• Booleans (video 6:59)
• Comparison operators
• Branching
• Even or odd (video 7:06)
• Truthy and falsey
• Truthy and falsey (video 5:15)
• Identity and equivalence
• Input validation
• Some string methods
• Decision trees

09: Structure, development, and testing

• Introduction
• main the Python way
• Program structure
• Iterative and incremental development
• Testing your code
• The origin of the term “bug”
• Using assertions to test your code
• Rubberducking
• Exceptions

10: Sequences

• Introduction
• Lists
• Tuples
• Mutability and immutability
• Subscripts are indices
• Concatenating lists and tuples
• Copying lists
• Finding an element within a sequence
• Counting elements within a sequence
• Sequence unpacking
• Strings are sequences
• More string methods
• Sequences: a quick reference guide
• The Python built-in sorted()
• Slicing
• Passing mutables to functions
• The global keyword
• Exceptions

11: Loops, iteration, and iterables

• Introduction
• Loops: an introduction
• Loops (video 48:43)
• while loops
• An ancient algorithm with a while loop
• for loops
• Iterables
• Iterating over strings
• The list method .extend()
• Calculating a sum in a loop
• Summations and loops (video 10:23)
• enumerate()
• Tracing a loop
• Nested loops
• Stacks and queues
• A deeper dive into iteration in Python
• Slicing and sequences (video 10:03)

12: Randomness, games, and simulations

• Introduction
• The random module
• Pseudo-randomness in more detail

13: File I/O

• Introduction
• Context managers
• Reading from a file
• Writing to a file
• Keyword arguments
• More on printing strings
• The csv module
• Exceptions

14: Data analysis and presentation

• Introduction
• Some elementary statistics
• A brief introduction to plotting with Matplotlib
• The basics of Matplotlib
• Exceptions

15: Exception handling

• Introduction
• Exceptions
• Handling exceptions
• Exceptions and flow of control

16: Dictionaries and structured data

• Introduction
• Introduction to dictionaries
• Iterating over dictionaries
• Deleting dictionary keys
• Hashables
• Counting letters in a string
• Sets
• Named tuples
• Structured data with JSON
• Exceptions

17: Graphs

• Introduction
• Introduction to graphs

Appendices

• Appendix A: Glossary
• Appendix B: Mathematical notation
• Appendix C: pip and venv
• Appendix D: File systems
• Appendix E: Flow charts
• Appendix F: Code for cover artwork
• Appendix G: Code smells for beginners
• Appendix H: An even deeper dive into functions (coming soon)
• Appendix I: The joy of Unicode
• Appendix J: An introduction to databases with SQLite