Introduction to Computer Science using Python

Computation & Python Basics

01Algorithms as Recipes 02The Six Operations Behind Every Program 03Primitives, Syntax, and Semantics 04Objects, Types, and Type Casting 05Expressions, Operators, and Types 06Assignment vs. Equality Problem set0/10 Practice∞

01Objects, Names, and Assignment 02String Concatenation, Repetition, and len()03String Indexing and Slicing 04String Immutability and the print() Function 05User Input, Type Conversion, and f-strings 06Comparisons, Booleans, and Logical Operators 07Conditionals: if, elif, and else Problem set0/10 Practice∞

Control Flow & Iteration

01Conditional Branching: if, elif, and else 02Iteration and the While Loop 03While Loops, Counters, and Infinite Loops 04While Loop Variables and Running Products 05The for Loop and range()06The Accumulator Pattern and range()Problem set0/10 MIT problem set0/2 Practice∞

01The break Statement: Exiting a Loop Early 02Looping Over Strings and the in Operator 03Guess-and-Check: Exhaustive Enumeration 04for Loops, Boolean Flags, and Cube Roots 05Nested Loops and Brute-Force Search 06Floats, Binary, and Floating-Point Error Problem set0/10 Practice∞

Numbers & Algorithms

01Converting Integers to Binary (and Negatives)02Why 0.1 Can't Be Stored: Fractions in Binary 03How Floats Are Stored, and Why You Never Use ==04Successive Approximation and the Loop That Never Ends Problem set0/10 Practice∞

01Why Approximation Search Hits a Wall 02Halving the Search Space at Every Step 03Coding Bisection Search for Square Roots 04Fixing Bisection Search for Numbers Below One 05Newton-Raphson: Sliding Down the Tangent Line Problem set0/10 MIT problem set0/1 Practice∞

Functions & Abstraction

01Abstraction and Decomposition: Why Your Phone Is a Black Box 02What a Function Really Is: The Specification and Its Four Parts 03Writing Your First Function: From a Sentence to is_even 04How a Function Call Becomes Its Value: Parameters vs. Arguments 05Return vs. Print: The Mysterious None, and Functions in Real Code 06Building sum_odds: Plan on Paper, Then Catch the Off-by-One Bug Problem set0/10 Practice∞

Scope & Higher-Order Functions

01return vs. print, and the Hidden None That Reveals a Bug 02Turning Bisection Square Root Into a Reusable Function 03Environments and Scope: The Rule Behind UnboundLocalError 04A Function Is an Object: Naming, Passing, and Tracing Calls 05Higher-Order Functions: Building apply(criteria, n)Problem set0/10 Practice∞

Lambdas & Sequences

01Writing Anonymous Functions With Lambda 02Tracing Nested Calls with the Environment Model 03Tuples: An Ordered, Mixed-Type Sequence 04Why Tuples Are Immutable: Nesting and Iteration 05Tuple Unpacking: One-Line Swaps and Many Returns 06The Star (*args), Lists, and Pythonic Loops Problem set0/10 MIT problem set0/3 Practice∞

Mutating Lists

01Lists Mutate, Tuples Don't: The Name vs the Object 02append: Growing a List and the None Trap 03Dot Notation: Building and Filtering Lists 04split and join: Converting Between Strings and Lists 05sort vs. sorted: Mutate in Place or Return a New List 06Writing Functions That Mutate a List In Place 07Appending While Looping, and extend vs append 08Reassignment vs Mutation, Proven with id()Problem set0/10 MIT problem set0/1 Practice∞

Aliases & Copies

01Cloning with L[:]: Mutating a List In Place 02del, pop, and remove: Three Ways to Delete 03The Loop That Skips: Removing While Iterating 04Aliases vs Clones: Why L2 = L1 Is Not a Copy 05Shallow vs Deep Copy: copy.copy and copy.deepcopy Problem set0/10 Practice∞

Comprehensions, Testing & Debugging

01List Comprehensions: Your Build-a-List Loop in One Line 02Reading Any Comprehension: Iterable, Expression, Condition 03Default Parameters: Defaults Last, Keywords at the Call Site 04Returning a Function Object: return g, Not return g()05Catching a Returned Function: Two Names, One Object 06Unit, Regression, and Integration Testing 07Black Box vs Glass Box: Where Test Cases Come From 08Debugging by Bisection: Print Statements as Evidence Problem set0/10 Practice∞

Exceptions & Assertions

01try and except: Catching an Exception Instead of Crashing 02Named Exception Handlers, else, finally, and raise 03raise ValueError and assert: Enforcing Your Docstring 04One Empty List, Four Designs: Crash, None, Default, Assert Problem set0/10 Practice∞

Dictionaries

01Why Lists Fail at Lookup: Parallel Lists and Nested Search 02Dictionaries: Custom Keys, Curly Braces, and KeyError 03Mutating a Dictionary: Add, Overwrite, del, and in 04keys(), values(), items(): Three Windows Into a Dictionary 05Hashing and Immutable Keys: Why a List Can't Be a Key 06Case Study: Building a Word Frequency Dictionary 07Ranking Words by Deleting Them: The Cost of Mutation Problem set0/10 MIT problem set0/8 Practice∞

Recursion

01Multiplying With Only Addition: From Loops to a Smaller Copy 02Writing mult_recur: Base Case, Recursive Step, and the Call Stack 03Divide and Conquer: The Regrade Chain and Writing power_recur 04Recursive Factorial Acted Out: Environments and When to Recurse Problem set0/10 Practice∞

01fib_recur: Two Recursive Calls and an Exploding Call Tree 02Memoization: One Dictionary Cuts 11 Million Calls to 65 03Counting Basketball Scores: Three Base Cases, Three Branches 04Recursion on Lists: Peel One Element, Trust the Rest 05Debugging a Recursive Search: Print, Fix, and Return Types 06Nested Lists: Flatten, Search, and Why Loops Fall Short 07Reversing a List Recursively: The Brackets That Make It Legal 08deep_rev: One Type Test Reverses Every Layer Problem set0/10 MIT problem set0/3 Practice∞

Classes & Objects

01Class vs Instance: The Blueprint Behind Every Object 02Choosing Data and Behavior: Elevators, Employees, and Stacks 03class Coordinate(object): Implementing a Type vs Using It 04The __init__ Constructor: Why Every Method Starts With self 05Creating Instances: Coordinate(3, 4), Dot Notation, and Memory 06Methods and the Dot Operator: distance, and How self Gets Bound Problem set0/10 MIT problem set0/3 Practice∞

Composition & Dunder Methods

01Data Attributes vs Parameter Names: What self Guarantees 02Returning a Value vs Mutating the Object: Writing to_origin 03Composition and ValueError: A Circle Made of Coordinate Objects 04Before the Dot Becomes self: Writing a SimpleFraction Class 05Every Operator Is a Method: Meet Python's Dunder Names 06The __str__ Method: You Decide What print Shows 07Overloading * and float() for a Fraction Class 08Inside reduce: a Nested gcd and the Branch That Returns an int Problem set0/10 Practice∞

Inheritance

01Data and Procedural Attributes: Building the Animal Class 02Getters, Setters and __str__: Why the Method Outlives the Attribute 03Attribute Abuse From Outside, and a Dictionary of Animal Objects 04make_animals: Walking Two Lists in Step to Build a List of Objects 05Hierarchies and Subclasses: The Three Moves a Subclass Can Make 06class Cat(Animal): Inheriting __init__ and the Chain Python Climbs 07Overriding __init__: Person Calls Animal.__init__ By Name 08Student, a Subclass of a Subclass, and the Rabbit Class Variable 09__add__ and __eq__ on Rabbits: Operator Overloading With Shared IDs Problem set0/10 MIT problem set0/5 Practice∞

An Object-Oriented Case Study

01Designing a Workout Class: __init__ Makes Five Attributes From Three 02Two State Dictionaries: __dict__ on the Class and on the Object 03A Getter That Estimates: Class Variables, None, and datetime 04parser.parse and Where a Class Variable Actually Lives 05class RunWorkout(Workout): Inheritance and super().__init__06One __str__ in the Parent, Three Kinds of Workout Printing 07A Subclass Where Its Parent Goes, and Positional Argument Order 08Overriding get_calories: How Python Picks Which Method Runs 09__eq__ With super(), and the Last Word on Building Classes Problem set0/10 MIT problem set0/4 Practice∞

Program Efficiency

01Correct Isn't Fast: time.time() and Three Functions Built to Be Measured 02Timing Nine Input Sizes, and Four Reasons the Seconds Measure the Machine 03One Unit per Operation: Costing Three Functions by Hand, Then in Code 04Ten Times the Input, a Hundred Times the Work: Reading Operation Counts Problem set0/10 Practice∞

01A Finer Clock: time.perf_counter and a Runtime That Never Moves 02Which Parameter Costs Time? compound, sum_of, and One Linear Shape 03Brute Force, Bisection, or in: Timing Three Searches to 100 Million 04A Loop Inside a Loop: the diameter Function and Quadratic Growth 05Counting Operations: Exact Formulas and a Program That Counts Itself 06Order of Growth: What to Measure, Which Input, and the Worst Case 07Big O: An Upper Bound That Only Has to Hold Past the Crossover 08Big Theta: Bounded From Both Sides, Keep Only the Dominant Term 09Reading Theta Off the Loops: Two Laws and Six Complexity Classes Problem set0/10 Practice∞

The Six Operations Behind Every Program

From fixed-program calculators to Turing's stored-program insight — every computation reduces to six primitive operations.

Finger exercises

Short drills on what this video just taught. Write the code, run the checks, and reveal the answer only if you are stuck.

0 / 5 passed

A computer's memory is a grid of numbered locations, each holding a value. A Python variable plays the same role: the name is the address, and the value is what's stored there.

Pretend address 3456 should hold the number 3, just like the machine in the video. Assign 3 to mem.
1
2
3
4
# Store the value the instruction asks for. mem = ... # your code here
Python runs in your browser
⌘/Ctrl + Enter runs
is an int, not a string
holds the number the instruction stores

←Previous Algorithms as Recipes Next Primitives, Syntax, and Semantics →

Your summary note

1. Dumb but fast machines
  Record that a machine carries out exactly the steps it is given, together with the two things it does well: storing enormous amounts of data and running operations at enormous speed.
2. Fixed-program versus stored-program designs
  State the pre-1940s calculator design against the post-1940s design that stores instructions as data, and name the interpreter plus its basic instructions: arithmetic, simple tests and moving data.
3. Hand-trace of the add-and-compare program
  Walk memory, the ALU and the control unit through the sample run: fetch 3 and 4 from locations 3456 and 3457, store 7 at 3458, compare with 7891, print True.
4. Six primitives and language equivalence
  List move left, move right, read, write, erase and no-op, and write the statement that anything computable in one programming language is computable in every other.
Attempt 1 of 2