Programming foundations cheat sheet (Python)

1. 1Language basicsThe building blocks every program uses: values and types, decisions, loops, functions, strings and missing values. Get these automatic before anything else.9 concepts

   1. 1Variables and typesA variable is a name that refers to a value.
   2. 2Static and dynamic typingStatically typed languages (Java, C++, C#) check types when the code is compiled.
   3. 3ConditionalsCode that runs only when a condition is true, with else if branches checked in order and an optional else for everything left.
   4. 4LoopsA loop repeats a block of code: a for-each loop visits every item in a collection, a counting for loop runs over a range of indexes, and a while loop…
   5. 5FunctionsA named block of code that takes inputs (parameters), does one job and can return a result.
   6. 6ScopeScope is the part of the code where a name is visible.
   7. 7Strings and formattingA string is a sequence of text characters.
   8. 8Null and missing valuesA special value meaning "nothing here": None in Python, null and undefined in JavaScript, null in Java and C#.
   9. 9Reading and validating inputReading text typed by a user or passed to the program, then converting it to the type you need, such as an integer, and rejecting anything that does not fit.

   9 in this chapterOpen this chapter
2. 2Collections, errors and filesThe core collections you use every day, what happens when you share them, and how to handle errors, files and code split across modules.8 concepts

   1. 1Lists and dynamic arraysAn ordered collection that grows as you add items and gives fast access by index: list in Python, arrays in JavaScript, ArrayList in Java, std::vector in…
   2. 2Dictionaries and mapsA collection of key and value pairs where you look a value up by its key, such as a product name to its stock count.
   3. 3SetsAn unordered collection of unique values with fast membership checks.
   4. 4Mutability and copyingA mutable value can change in place; an immutable one cannot.
   5. 5ExceptionsAn exception is an error object thrown when something goes wrong.
   6. 6Reading files and cleaning upFiles, network connections and locks must be closed when you are done, even if an error happens halfway.
   7. 7Modules and importsA module is a file (or group of files) of related code that other files import by name.
   8. 8Reading errors and debuggingA stack trace lists the chain of function calls that led to an error, with file names and line numbers.

   8 in this chapterOpen this chapter
3. 3Python essentialsThe idioms that make Python code look like Python: comprehensions, generators, type hints, dataclasses and the traps every beginner meets once.7 concepts

   1. 1ComprehensionsA compact expression that builds a list, dictionary or set by transforming and filtering another iterable, in one line.
   2. 2Generators and yieldA function that uses yield produces values one at a time, pausing between them, instead of building a whole list in memory.
   3. 3Truthiness and is NoneIn a condition, empty collections, 0, "" and None count as false and almost everything else as true.
   4. 4Mutable default argumentsDefault values are created once, when the function is defined, not on every call.
   5. 5Type hintsAnnotations that state the expected types of parameters, return values and variables.
   6. 6DataclassesA decorator that writes __init__, __repr__ and __eq__ for a class from its annotated fields.
   7. 7The main guardThe check if __name__ == "__main__": is true only when the file is run directly, not when another file imports it.

   7 in this chapterOpen this chapter
4. 4Command line and GitThe terminal and Git commands every team expects from day one: moving around, committing, branching, working with GitHub and recovering from mistakes.11 concepts

   1. 1Shell navigationThe shell is a text interface for running programs and working with files.
   2. 2Repositories and commitsA Git repository stores the full history of a project.
   3. 3Staging areaThe staging area holds the changes that will go into the next commit.
   4. 4.gitignoreA file listing patterns of files and folders Git should not track, such as dependencies, build output, logs and local secrets.
   5. 5BranchesA branch is a movable name that points to a commit.
   6. 6Merging and rebasingMerging joins another branch into yours, adding a merge commit if both changed.
   7. 7Merge conflictsA conflict happens when two branches changed the same lines.
   8. 8Remotes: clone, fetch, pull and pushA remote is a copy of the repository on a server such as GitHub, usually named origin.
   9. 9Pull requestsA pull request asks to merge one branch into another on GitHub.
   10. 10Undoing mistakesrestore discards uncommitted changes to a file, commit --amend fixes the last commit, revert adds a commit that undoes an old one, reset moves your…
   11. 11Commit messagesA short summary line in the imperative mood (about 50 characters), a blank line, then a body that explains why the change was made.

   11 in this chapterOpen this chapter
5. 5How computers run your codeEnough of what happens below your code that memory and number bugs stop surprising you: bits, text, the CPU, memory, compilers and the operating system.10 concepts

   1. 1Bits, bytes and binaryA bit is a 0 or 1.
   2. 2Text encoding and UnicodeUnicode gives every character a number (a code point).
   3. 3How the CPU runs a programThe CPU repeatedly fetches an instruction from memory, decodes it and executes it: simple steps such as add, compare, jump and copy.
   4. 4Compiled and interpreted codeA compiler translates source to machine code before running (C++).
   5. 5Stack and heapThe stack holds each running function's local variables in frames that vanish when it returns.
   6. 6Passing arguments to functionsPython, JavaScript and Java always pass a copy of the value, but for objects that value is a reference, so the function can change the object but not rebind…
   7. 7Garbage collectionThe runtime frees heap objects automatically once nothing can reach them.
   8. 8Floating point numbersFloats store numbers in binary with limited precision, so most decimal fractions such as 0.1 are approximations.
   9. 9Integer overflowFixed-size integers have a maximum.
   10. 10Processes and threadsThe operating system runs each program as a process with its own memory.

   10 in this chapterOpen this chapter
6. 6Data structures and Big-OThe handful of structures most code is built from, and how to reason about the time and memory a solution costs as the input grows.10 concepts

   1. 1Big-O notationBig-O describes how the running time or memory of an algorithm grows as the input size n grows, ignoring constants.
   2. 2Arrays and amortised growthAn array stores items side by side in memory, so reading by index is O(1).
   3. 3Linked listsA chain of nodes where each node holds a value and a pointer to the next (and, in a doubly linked list, the previous) node.
   4. 4StacksA last-in, first-out collection: you push onto the top and pop from the top, both O(1).
   5. 5Queues and dequesA queue is first-in, first-out: add at the back, remove from the front, both O(1).
   6. 6How hash tables workA hash table turns a key into a number with a hash function, uses it to pick a bucket in an array, and stores the entry there.
   7. 7Trees and binary search treesA tree is a hierarchy of nodes with one root, where each node has children and no cycles.
   8. 8GraphsA graph is a set of nodes (vertices) connected by edges, which may have directions or weights.
   9. 9RecursionA function that calls itself on a smaller version of the problem, with a base case that stops the calls.
   10. 10Binary searchSearching a sorted array by checking the middle element and discarding the half that cannot contain the target, until it is found or the range is empty.

   10 in this chapterOpen this chapter
7. 7Object-oriented design and clean codeHow to organise programs so they stay readable as they grow: classes where they help, clear boundaries, good names and the principles reviewers ask about.10 concepts

   1. 1Classes and objectsA class is a blueprint that groups data (fields) with the behaviour that works on it (methods).
   2. 2EncapsulationKeeping an object's data private and exposing only the operations that keep it valid.
   3. 3Inheritance and compositionInheritance builds a class from a parent class and reuses its code ("is a").
   4. 4Interfaces and polymorphismAn interface is a contract listing methods a type must provide.
   5. 5Separation of concernsSplitting a program so each part handles one concern: reading input, business logic, storage and output live in separate functions or modules.
   6. 6DRY, KISS and YAGNIDRY: keep each piece of knowledge in one place.
   7. 7Naming and small functionsNames that say what a value is or what a function does (unpaid_invoices, send_reminder), and functions short enough to do one thing at one level of detail.
   8. 8SOLIDFive design principles: a class has one reason to change; extend behaviour without editing working code; subtypes must work wherever the parent does; keep…
   9. 9Code smells and refactoringA code smell is a sign of a deeper design problem: long functions, duplicated blocks, many parameters, deep nesting.
   10. 10Comments, docstrings and READMEsComments explain why code does something non-obvious.

   10 in this chapterOpen this chapter
8. 8Testing your codeUnit tests on the logic that matters, test-driven development, test doubles and the edge cases that break most beginner programs.5 concepts

   1. 1Unit testsSmall automated tests that call one function or class with known input and assert on the result.
   2. 2Test-driven developmentWriting a failing test first (red), then the least code that makes it pass (green), then cleaning up (refactor), in short cycles.
   3. 3Test doublesStand-ins for real dependencies in tests: a stub returns fixed answers, a fake is a simple working version (an in-memory store), and a mock checks how it was…
   4. 4Edge casesInputs at or beyond the limits of normal use: empty collections, zero, negative numbers, one item, very large values, missing fields and unexpected text.
   5. 5The test pyramidA guideline for balancing test types: many fast unit tests, fewer integration tests that check parts working together, and a few slow end-to-end tests through…

   5 in this chapterOpen this chapter
9. 9Build and ship projectsTurning skills into finished, shareable work: scoping, JSON and APIs, dependencies, configuration, a good README and publishing on GitHub.7 concepts

   1. 1Scoping a small projectCutting an idea down to the smallest version that solves one real problem end to end, then splitting it into a handful of milestones.
   2. 2Reading and writing JSONJSON is a text format for objects, arrays, strings, numbers, booleans and null.
   3. 3Calling a public APISending an HTTP request (usually GET or POST) to a web service and reading its response, typically a status code plus a JSON body.
   4. 4Virtual environments and pipA virtual environment is a project-local folder with its own Python packages.
   5. 5Configuration and secretsSettings that change between machines (API keys, URLs, file paths) are read from environment variables or a local config file instead of being written into the…
   6. 6Writing a READMEThe front page of a repository: what the project does and for whom, a demo, how to install, run and test it, how it works and its known limits.
   7. 7Publishing on GitHubPushing a project to a public GitHub repository with a README, a licence, a .gitignore and a clean history of meaningful commits.

   7 in this chapterOpen this chapter
10. 10Glossary, A to ZEvery concept in the sheet and the smaller terms it uses, in one list.160 terms

First language, Git, CS basics.