• Welcome
• Revel Resources

Frequently Referenced Videos

• Downloading and Installing Python
• Use Python IDLE
• Anaconda, JupyterLab, and iPython

Chapter 1 Introduction to Computers, Programs, and Python

• Guide and Tips for Python Chapter 1
• 1.1 Introduction
• 1.2: What Is a Computer?
• 1.3: Programming Languages
• 1.4: Operating Systems
• 1.5: History of Python
• 1.6: Getting Started with Python
• 1.7: Programming Style and Documentation
• 1.8: Programming Errors
• 1.9: Getting Started with Graphics Programming

Chapter 2 Elementary Programming

• 2.1: Introduction
• 2.2: Writing a Simple Program
• 2.3: Reading Input from the Console
• 2.4: Identifiers
• 2.5: Variables, Assignment Statements, and Expressions
• 2.6: Simultaneous Assignments
• 2.7: Named Constants
• 2.8: Numeric Data Types and Operators
• 2.9: Case Studies: Minimum Number of Changes
• 2.10: Evaluating Expressions and Operator Precedence
• 2.11: Augmented Assignment Operators
• 2.12: Type Conversions and Rounding
• 2.13: Case Study: Displaying the Current Time
• 2.14: Software Development Process Part A Part B
• 2.15: Case Study: Computing Distances

Chapter 3 Selections

• 3.1 Introduction
• 3.2: Boolean Types, Values, and Expressions
• 3.3: Generating Random Numbers
• 3.4: if Statements
• 3.5: Two-Way if-else Statements
• 3.6: Nested if and Multi-Way if-elif-else Statements
• 3.7: Common Errors in Selection Statements
• 3.8: Case Study: Computing Body Mass Index
• 3.9: Case Study: Computing Taxes
• 3.10: Logical Operators
• 3.11: Case Study: Determining Leap Year
• 3.12: Case Study: Lottery
• 3.13: Conditional Expressions
• 3.14: Operator Precedence and Associativity
• 3.15: Detecting the Location of an Object

Chapter 4 Mathematical Functions, Characters, and Strings

• 4.1 Introduction
• 4.2: Common Python Functions
• 4.3: Strings and Characters 4.3: Part A 4.3: Part B
• 4.4: Case Study: Revising the Lottery Program Using Strings
• 4.5: Introduction to Objects and Methods
• 4.6: String Methods 4.6: Part A 4.6: Part B
• 4.7: Case Studies 4.7: Part A 4.7: Part B
• 4.8: Formatting Numbers and Strings
• 4.9: Drawing Various Shapes
• 4.10: Drawing with Colors and Fonts

Chapter 5 Loops

• 5.1 Introduction
• 5.2: The while Loop
• 5.3: Case Study: Guessing Numbers
• 5.4: Loop Design Strategies
• 5.5: Controlling a Loop with User Confirmation and Sentinel Value
• 5.6: The for Loop
• 5.7: Nested Loops
• 5.8: Minimizing Numerical Errors
• 5.9: Case Studies 5.9: Case Studies 5.9: Case Studies 5.9: Case Studies
• 5.10: Keywords break and continue
• 5.11: Case Study: Checking Palindrome
• 5.12: Case Study: Displaying Prime Numbers
• 5.13: Case Study: Random Walk

Chapter 6 Methods

• 6.1 Introduction
• 6.2 Defining a Function
• 6.3: Calling a Function
• 6.4: Functions with/without Return Values
• 6.5: Positional and Keyword
• 6.6: Passing Arguments by Reference Values
• 6.7: Modularizing Code
• 6.8: The Scope of Variables
• 6.9: Default Arguments
• 6:10: Returnning Multiple Values
• 6.11: Case Study: Generating Random ASCII Characters
• 6.12: Converting Hexadecimals to Decimals
• 6.13: Function Abstraction and Stepwise Refinement
• 6.14: Case Study: Resuable Graphics Functions

Chapter 7 Lists

• 7.1: Introduction
• 7.2 List Basics
• 7.3: Case Study: Analyzing Numbers
• 7.4: Case Study: Deck of Cards
• 7.5: Copying Lists
• 7.6: Passing Lists to Functions
• 7.7: Returning a List from a Function
• 7.8: Case Study: Counting the Occurrences of Each Letter
• 7.9: Searching Lists
• 7.10: Sorting Lists

Chapter 8 Multidimensional Lists

• 8.1: Introduction
• 8.2: Processing Two-Dimensional Lists
• 8.3: Passing Two-Dimensional Lists to Functions
• 8.4: Problem: Grading a Multiple-Choice Test
• 8.5: Problem: Finding the Closest Pair
• 8.6: Problem: Sudoku
• 8.7: Multidimensional Lists

Chapter 9 Objects and Classes

• 9.1 Introduction
• 9.2: Defining Classes for Objects
• 9.3: UML Class Diagrams
• 9.4: Using Classes from the Python Library: the datetime Class
• 9.5: Immutable Objects vs. Mutable Objects
• 9.6: Hidden Data Fields
• 9.7: Class Abstraction and Encapsulation
• 9.8: Object-Oriented Thinking
• 9.9: Operator Overloading and Special Methods
• 9.10: Case Study: The Rational Class

Chapter 10 Basic GUI Programming Using Tkinter

• 10.1 Introduction
• 10.2: Getting Started with Tkinter
• 10.3: Processing Events
• 10.4: The Widget Classes
• 10.5: Canvas
• 10.6: The Geometry Managers
• 10.7: Case Study: Loan Calculator
• 10.8: Case Study: Sudoku GUI
• 10.9: Displaying Images
• 10.10: Case Study: Deck of Cards GUI

Chapter 11 Advanced GUI Programming Using Tkinter

• 11.1 Introduction
• 11.2: Combo Boxes
• 11.3: Menus
• 11.4: Popup Menus
• 11.5: Mouse, Key Events, and Bindings
• 11.6: Case Study: Finding the Closest Pair
• 11.7: Animations
• 11.8: Case Study: Bouncing Balls
• 11.9: Scrollbars
• 11.10: Standard Dialog Boxes

Chapter 12 Inheritance and Polymorphism

• 12.1 Introduction
• 12.2: Superclasses and Subclasses
• 12.3: Overriding Methods
• 12.4: The object Class
• 12.5: Polymorphism and Dynamic Binding
• 12.6: The isinstance Function
• 12.7: Case Study: A Reusable Clock
• 12.8: Class Relationships
• 12.9: Case Study: Designing the Course Class
• 12.10: Designing a Class for Stacks
• 12.11: Case Study: The FigureCanvas Class

Chapter 13 Files and Exception Handling

• 13.1 Introduction
• 13.2: Text Input and Output
• Part 1
• Part 2
• Part 3
• 13.3: File
• 13.4: Case Study: Counting Each Letter in a File
• 13.5: Retrieving Data from the Web
• 13.6: Exception Handling
• 13.7: Raising Exceptions
• 13.8: Processing Exceptions Using Exception Objects
• 13.9: Defining Custom Exception Classes
• 13.10: Case Study: Web Crawler
• 13.11: Binary IO Using Pickling
• 13.12: Case Study: Address Book

Chapter 14 Tuples, Sets, and Dictionaries

• 14.1 Introduction
• 14.2: Tuples
• 14.3: Sets
• 14.4: Comparing the Performance of Sets and Lists
• 14.5: Case Study: Counting Keywords
• 14.6: Dictionaries
• 14.7: Case Study: Occurrences of Words

Chapter 15 Recursion

• 15.1 Introduction
• 15.2: Case Study: Computing Factorials
• 15.3: Case Study: Computing Fibonacci Numbers
• 15.4: Problem Solving Using Recursion
• 15.5: Recursive Helper Functions
• 15.6: Case Study: Finding the Directory Size
• 15.7: Case Study: Tower of Hanoi
• 15.8: Case Study: Fractals
• 15.9: Case Study: Eight Queens
• 15.10: Recursion vs. Iteration
• 15.11: Tail Recursion

Chapter 16 Developing Efficient Algorithms

• 16.1: Introduction
• 16.2: Big O Notation
• 16.3: Example: Determining Big O
• 16.4: Analyzing Algorithm Time Complexity
• 16.5: Case Study: Finding Fibonacci Numbers
• 16.6: Case Study: Finding Greatest Common Divisors
• 16.7: Case Study: Finding Prime Numbers
• 16.8: Case Study: Closest Pair of Points
• 16.9: Case Study: The Eight Queen Problem
• 16.10: Finding a Convex Hull
• 16.11: String Matching
• 16.11.1 The Boyer-Moore Algorithm
• 16.11.2 The Knuth-Morris-Pratt Algorithm

Chapter 17 Sorting

• 17.1 Introduction
• 17.2: Insertion Sort
• 17.3: Bubble Sort
• 17.4: Merge Sort
• 17.5: Quick Sort
• 17.6: Heap Sort
• 17.6.1: Storing a Heap
• 17.6.2: Adding a New Node
• 7.6.4: The Heap Class
• 17.6.5: Sorting Using the Heap Class
• 17.6.6: Heap Sort Time Complexity
• 17.7: Bucket Sort and Radix Sort

Chapter 18 Linked Lists, Stacks, Queues, and Priority Queues

• 18.1 Introduction
• 18.2: Linked Lists
• 18.3: Iterators
• 18.4: Generators
• 18.5: Stacks
• 18.6: Queues
• 18.7: Priority Queues
• 18.8 Case Study: Evaluating Expressions

Chapter 19 Binary Search Trees

• 19.1 Introduction
• 19.2: Binary Search Trees Basics
• 19.3: Representing Binary Search Trees
• 19.4: Searching for an Element in BST
• 19.5: Inserting an Element into a BST
• 19.6: Tree Traversal
• 19.7: The BST Class
• 19.8: Deleting Elements in a BST
• 19.9: Tree Visulization
• 19.10: Case Study: Data Compression

Chapter 20 AVL Trees

• 20.1 Introduction
• 20.2: Rebalancing Trees
• 20.3: Designing Classes for AVL Trees
• 20.4: Overriding the insert Method
• 20.5: Implementing Rotations
• 20.6: Implementing the delete Method
• 20.7: The AVLTree Class
• 20.8: Testing the AVLTree Class
• 20.9: Maximum Height of an AVL Tree

Chapter 21 Hashing

• 21.1 Introduction
• 21.2: What is Hashing?
• 21.3: Hash Functions and Hash Codes
• 21.3.1: Compressing Hash Codes
• 21.4: Handling Collisions Using Open Addressing
• 21.5: Handling Collissions Using Separate Chaining
• 21.6: Load Factor and Rehashing
• 21.7: Implementing a Map Using Hashing
• 21.8: Implementing a Set Using Hashing

Chapter 22 Graphs and Applications

• 22.1 Introduction
• 22.2: Basic Graph Terminologies
• 22.3: Representing Graphs
• 22.4: Modeling Graphs
• 22.5: Graph Visualization
• 22.6: Graph Traversal
• 22.7: Depth-First Search (DFS)
• 22.8: Case Study: The Connected Circles Problem
• 22.9: Breadth-First Search (BFS)
• 22.10: Case Study: The Nine Tail Problem

Chapter 23 Weighted Graphs and Applications

• 23.1 Introduction
• 23.2: Representing Weighted Graphs
• 23.3: The WeightedGraph Class
• 23.4: Minimum Spanning Trees
• 23.5: Finding Shortest Paths
• 23.6: Case Study: The Weighted Nine Tail Problem