This Introduction to Computer Science and Programming using Python course is designed for students with minimal or no programming experience. The goal is to help students understand how computation can be used to solve problems. It also aims to build confidence in writing simple programs, allowing students from any major to achieve practical goals. The course will use Python 3 as the programming language.
Lecture 1: Introduction to CS and Programming using Python
This lecture covers the basics of computation, introduces Python, and explores mathematical operations, variables, and types in Python. Students will learn about Python objects and how to structure Python programs.
Lecture 2: Strings, Input/Output, and Branching
We will discuss the core elements of programs such as strings, input/output, f-strings, operators, and branching. Key takeaway: Debug early and often. Start by writing small code snippets and testing them rather than writing a complete program. Use Python Tutor to debug code step by step.
Lecture 3: Iteration
This lecture introduces control flow and iteration using loops. We’ll cover both while and for loops, and emphasize practicing syntax. While loops continue as long as a condition is true, while for loops iterate over ranges or strings.
Lecture 4: Loops over Strings, Guess-and-Check, and Binary
We explore iteration in simple programs like guess-and-check, binary numbers, and fractions in Python. Understanding binary numbers helps us see how machines store values. Guess-and-check helps solve problems by enumerating potential solutions.
Lecture 5: Floats and Approximation Methods
This lecture explains the challenges of floating-point numbers and introduces approximation methods. Floating-point numbers cannot always be represented exactly in memory, leading to approximations in calculations.
Lecture 6: Bisection Search
We discuss simple algorithms like bisection search and Newton-Raphson. Bisection search takes advantage of problem properties, and we explore how decomposition and abstraction simplify code creation, modification, and maintenance.
Lecture 7: Decomposition, Abstraction, and Functions
An introduction to functions, decomposition, abstractions, and specifications. Functions encapsulate computations into black boxes, making them reusable and simplifying code. Functions run only when called and return a result.
Lecture 8: Functions as Objects
This lecture delves deeper into functions as objects. Functions in Python are first-class citizens, meaning they have types, can be assigned as values, passed as arguments, or returned from other functions. Understanding scope and environments helps create clear and concise code.
Lecture 9: Lambda Functions, Tuples, and Lists
This lecture covers lambda functions, tuples, and lists. Lambda functions are used for quick, one-time tasks. Tuples and lists are sequences that are indexed, with tuples being immutable and lists being mutable.
Lecture 10: Lists and Mutability
We explore list operations and mutability, covering mutation, aliasing, and tricky examples with loops. Lists are used for dynamic data, while tuples hold immutable data such as geographical coordinates.
Lecture 11: Aliasing and Cloning
We discuss aliasing, cloning, and the difference between shallow and deep copies of lists. List comprehensions are also covered, allowing for more concise data manipulation.
Lecture 12: List Comprehension, Functions as Objects, Testing, and Debugging
Further exploration of functions as objects, keyword arguments, default arguments, and various debugging techniques, including glassbox and blackbox testing.
Lecture 13: Exceptions and Assertions
This lecture covers exceptions and assertions—how to handle errors and raise assertion failures in Python.
Lecture 14: Dictionaries
Introduction to dictionaries, their keys and values, mutability, and iteration. Dictionaries map unique, immutable keys to any value, and they can be highly efficient for certain tasks.
Lecture 15: Recursion
This lecture introduces recursion, a programming technique for breaking problems into base cases and recursive steps. Recursion allows problems to be solved more effectively by breaking them down into smaller instances.
Lecture 16: Recursion on Non-numerics
The concept of recursion is extended to indexable sequences like strings and tuples, demonstrating its application beyond numbers.
Lecture 17: Python Classes
Introduction to classes, which enable code reuse and organization. Classes allow us to avoid naming conflicts in functions and use inheritance to extend or modify behavior.
Lecture 18: More Python Class Methods
This lecture explores the decomposition and abstraction within Python classes. By bundling data and behavior together, classes promote consistency in object usage.
Lecture 19: Inheritance
We discuss inheritance, a mechanism that allows child classes to inherit properties and methods from parent classes. This facilitates hierarchical structures in programming.
Lecture 20: Fitness Tracker Object-Oriented Programming Example
A practical example involving fitness trackers demonstrates how to use classes for object-oriented programming and modularize code by grouping data and behavior together.
Lecture 21: Timing Programs and Counting Operations
Learn to evaluate programs by measuring execution time, counting operations, and abstracting performance growth in relation to algorithm efficiency.
Lecture 22: Big Oh and Theta
This lecture introduces Big O and Theta notation for comparing the efficiency of algorithms. We’ll learn how to describe algorithm performance and its upper and lower bounds.
Lecture 23: Complexity Classes Examples
We explore complexity classes to compare algorithm efficiency and use Θ notation for both upper and lower bounds to determine growth rates.
Lecture 24: Sorting Algorithms
We discuss several sorting algorithms (BOGO sort, bubble sort, selection sort, and merge sort) and analyze their complexity.
Lecture 25: Plotting
This lecture covers plotting in Python, an essential tool for visualizing data and exploring trends. We’ll explore Python libraries for numerical and stochastic computations.
Lecture 26: List Access, Hashing, Simulations, and Wrap-Up
The course concludes with a focus on list access, hashing techniques, and simulations, summarizing key concepts and offering a final review of the material.
