Skip to content

Beginning Python — Concept List v1

This concept list was derived from the existing manually created course content in the docs/ directory and supplemented with additional concepts appropriate for a beginning Python course. The original textbook was created by hand by humans starting around May of 2020 when Trinket was the best practice for teaching introduction to Python with Turtle graphics. This course was used in the CoderDojo Twin Cities coding clubs and the Code Savvy clubs for many years. It serves as the foundation for the learning graph used to regenerate the course in June of 2026 using Claude Code Opus 2.6 in High effort mode.

1. Development Environments & Setup

  1. Python interpreter overview
  2. Python 2 vs Python 3 differences
  3. Trinket.io — web-based Python environment
  4. repl.it — online Python IDE
  5. Thonny — beginner-friendly Python IDE
  6. Spyder IDE — scientific Python IDE
  7. VS Code — general-purpose code editor
  8. Jupyter Notebooks — interactive computational environment
  9. JupyterLab — enhanced Jupyter environment
  10. Conda — environment and package manager
  11. pip — Python package installer
  12. Virtual environments
  13. Installing Python locally
  14. Running Python scripts from the terminal
  15. The Python REPL (interactive shell)
  16. Raspberry Pi as a Python platform

2. Basic Syntax & Output

  1. print() function
  2. Comments (single-line with #)
  3. Multi-line strings (triple quotes)
  4. Indentation as syntax (whitespace rules)
  5. Case sensitivity in Python
  6. Python keywords (reserved words)
  7. Blank lines and code readability

3. Variables & Assignment

  1. Variable definition and assignment (=)
  2. Variable naming rules (letters, digits, underscores)
  3. Snake_case naming convention
  4. Meaningful variable names
  5. Multiple assignment (a, b = 1, 2)
  6. Augmented assignment operators (+=, -=, *=, /=)
  7. Constants (by convention, ALL_CAPS)

4. Data Types

Numeric

  1. Integers (int) — whole numbers, positive and negative
  2. Floats (float) — decimal numbers
  3. Division always returns float in Python 3
  4. Integer division (//)
  5. Modulo operator (%) — remainder after division
  6. Exponentiation (**)
  7. Arithmetic operators: +, -, *, /

Boolean

  1. Boolean type (bool) — True and False
  2. Comparison operators: >, <, >=, <=, ==, !=
  3. Logical operators: and, or, not
  4. Truthiness and falsiness of values

Strings

  1. String type (str) — text enclosed in quotes
  2. Single vs double quotes
  3. String concatenation with +
  4. String repetition with *
  5. String indexing (0-based)
  6. String slicing (s[start:end:step])
  7. Escape characters (\n, \t, \\, \")
  8. String length with len()
  9. String methods: .lower(), .upper(), .strip(), .lstrip(), .rstrip()
  10. String methods: .split(), .join(), .replace()
  11. String methods: .startswith(), .endswith(), .find(), .count()
  12. String methods: .isdigit(), .isalpha(), .isalnum()
  13. String formatting with .format()
  14. f-strings (formatted string literals)
  15. String immutability

None

  1. None — null/empty value, NoneType
  2. Functions without return return None
  3. Checking for None with is None

5. Type Conversion (Casting)

  1. int() — convert to integer
  2. float() — convert to float
  3. str() — convert to string
  4. bool() — convert to boolean
  5. type() — inspect a variable's type
  6. isinstance() — check if object is an instance of a type

6. User Input

  1. input() function — read text from user
  2. Prompting the user (passing a string to input())
  3. Converting input strings to numbers with int() / float()
  4. Input validation basics

7. Control Flow — Conditionals

  1. if statement
  2. if...else block
  3. elif (else-if) chains
  4. Nested if statements
  5. Conditional expressions (ternary): x if condition else y
  6. match/case statement (Python 3.10+, structural pattern matching)

8. Control Flow — Loops

  1. for loop — iterating over a sequence
  2. for loop with range()
  3. range(start, stop, step)
  4. while loop — condition-based repetition
  5. break — exit a loop early
  6. continue — skip to next iteration
  7. else clause on loops
  8. Nested loops
  9. Loop counter variable (i, j)
  10. Infinite loops and how to avoid them
  11. enumerate() — iterate with index and value
  12. zip() — iterate over multiple sequences simultaneously

9. Functions

  1. Defining a function with def
  2. Calling a function
  3. Function parameters (positional)
  4. Default parameter values
  5. Keyword arguments
  6. return statement
  7. Functions that return None implicitly
  8. Local scope — variables inside functions
  9. Global scope — variables at module level
  10. global keyword — access global variable inside function
  11. nonlocal keyword — access enclosing scope variable
  12. Docstrings — documenting functions
  13. Pure functions vs functions with side effects
  14. Recursion — a function calling itself
  15. Recursion base case and recursive case
  16. Recursion depth and stack overflow
  17. Lambda functions (anonymous functions)

10. Collections — Lists

  1. List type (list) — ordered, mutable collection
  2. Creating a list with []
  3. List indexing (0-based, negative indexing)
  4. List slicing
  5. len() — number of items in a list
  6. List methods: .append(), .insert(), .extend()
  7. List methods: .remove(), .pop(), .clear()
  8. List methods: .sort(), .reverse(), .copy()
  9. List methods: .index(), .count()
  10. Checking membership with in
  11. List concatenation and repetition
  12. Iterating over a list with for
  13. Nested lists (lists of lists)
  14. List comprehensions

11. Collections — Tuples

  1. Tuple type (tuple) — ordered, immutable collection
  2. Creating a tuple with ()
  3. Tuple indexing and slicing
  4. Tuple unpacking
  5. When to use tuples vs lists
  6. Single-element tuple syntax ((x,))

12. Collections — Dictionaries

  1. Dictionary type (dict) — key-value pairs
  2. Creating a dictionary with {}
  3. Accessing values by key (d[key])
  4. .get() method — safe key access with default
  5. Adding and updating key-value pairs
  6. Removing entries: .pop(), del
  7. Dictionary methods: .keys(), .values(), .items()
  8. Iterating over a dictionary
  9. Checking key membership with in
  10. Nested dictionaries
  11. Dictionary comprehensions

13. Collections — Sets

  1. Set type (set) — unordered collection of unique items
  2. Creating a set with {} or set()
  3. Set operations: union (|), intersection (&), difference (-)
  4. .add(), .remove(), .discard() methods
  5. Checking membership with in
  6. Frozensets (immutable sets)

14. Built-in Functions

  1. print() — output to console
  2. input() — read user input
  3. len() — length of a sequence
  4. range() — generate a sequence of numbers
  5. type() — get type of an object
  6. int(), float(), str(), bool() — type conversions
  7. list(), tuple(), set(), dict() — collection constructors
  8. max(), min() — find maximum/minimum
  9. sum() — sum values in an iterable
  10. abs() — absolute value
  11. round() — round a number
  12. sorted() — return sorted list
  13. reversed() — return reverse iterator
  14. enumerate() — iterate with index
  15. zip() — combine iterables
  16. map() — apply function to each item
  17. filter() — filter items by condition
  18. dir() — list attributes/methods of an object
  19. help() — display documentation

15. Modules & Imports

  1. import statement
  2. from ... import ... — import specific names
  3. import ... as ... — alias a module
  4. from ... import * — import all (use sparingly)
  5. Creating custom modules (.py files)
  6. __name__ == "__main__" guard
  7. The Python standard library overview

Standard Library Modules

  1. random — random number generation
  2. random.randint(min, max)
  3. random.choice(sequence)
  4. random.shuffle(list)
  5. random.seed() — reproducibility
  6. math — mathematical functions
  7. math.sqrt(), math.floor(), math.ceil()
  8. math.sin(), math.cos(), math.pi
  9. math.radians() — degrees to radians
  10. string — string constants (punctuation, digits, etc.)
  11. time — time operations
  12. time.sleep() — pause execution
  13. sys — system-level operations
  14. sys.path — Python module search path
  15. os — operating system interface
  16. os.path — file path operations
  17. re — regular expressions

16. Regular Expressions

  1. Importing re module
  2. re.search(pattern, string) — find first match
  3. re.findall(pattern, string) — find all matches
  4. re.split(pattern, string) — split by pattern
  5. re.sub(pattern, replacement, string) — substitute matches
  6. Common patterns: \d (digit), \w (word char), \s (whitespace)
  7. Anchors: ^ (start), $ (end)
  8. Character classes: [a-z], [A-Z], [0-9]
  9. Quantifiers: + (one or more), * (zero or more), ? (optional)
  10. Alternation with |
  11. Escaping special characters with \
  12. Raw strings for regex patterns (r"...")

17. File Input/Output

  1. open() function
  2. File modes: 'r' (read), 'w' (write), 'a' (append), 'b' (binary)
  3. file.read() — read entire file as string
  4. file.readlines() — read all lines into a list
  5. file.readline() — read one line at a time
  6. file.write() — write string to file
  7. file.close() — close file handle
  8. with statement (context manager) for safe file handling
  9. Iterating over file lines with for
  10. String methods for text processing: .strip(), .lower(), .replace()
  11. CSV file reading basics

18. Error Handling

  1. Types of errors: syntax errors vs runtime errors vs logic errors
  2. Common exceptions: ValueError, TypeError, IndexError, KeyError, NameError, ZeroDivisionError
  3. Reading a traceback (stack trace)
  4. try...except block
  5. except ExceptionType as e — catching specific exceptions
  6. else clause in try/except
  7. finally clause — always executes
  8. raise — raising exceptions manually
  9. assert statement with error messages
  10. Debugging with print() statements
  11. Using Google and Stack Overflow to debug errors

19. Object-Oriented Programming (Intro)

  1. Objects and classes — conceptual overview
  2. Attributes — properties of an object
  3. Methods — functions belonging to an object
  4. class keyword — defining a class
  5. __init__() — constructor method
  6. self parameter
  7. Creating instances of a class
  8. Accessing attributes and calling methods (obj.attr, obj.method())
  9. String methods as examples of OOP
  10. List methods as examples of OOP
  11. Inheritance — basics
  12. __str__() — string representation of an object

20. Turtle Graphics

  1. import turtle
  2. Creating a turtle.Turtle() object
  3. Creating a turtle.Screen() object
  4. Screen setup: setup(width, height), bgcolor(color), title(text)
  5. Movement: forward(), backward(), left(), right()
  6. Absolute positioning: goto(x, y), setx(), sety()
  7. Pen control: penup(), pendown(), pensize()
  8. Color: color(), pencolor(), fillcolor()
  9. Fill: begin_fill(), end_fill()
  10. Drawing shapes: circle(radius), drawing squares/polygons with loops
  11. Turtle appearance: shape() (turtle, arrow, circle, square, triangle, classic)
  12. Hiding/showing turtle: hideturtle(), showturtle()
  13. Writing text: write(text, font=...)
  14. Clearing: clear(), reset()
  15. Position query: xcor(), ycor(), heading()
  16. Speed control: speed(value)
  17. Direction: setheading(angle)
  18. Event handling: onscreenclick(function)
  19. Animation with turtle (frame-based loops)
  20. Building a color picker with turtle
  21. Drawing fractals with recursion and turtle
  22. Drawing a sine wave with turtle and math

21. Data Visualization

  1. matplotlib library overview
  2. import matplotlib.pyplot as plt
  3. plt.plot(x, y) — line plot
  4. plt.show() — display plot
  5. plt.title(), plt.xlabel(), plt.ylabel() — labels
  6. plt.grid() — show grid lines
  7. Plotting a sine wave
  8. Working with lists as x/y data

22. Numerical Computing (NumPy Intro)

  1. numpy library overview
  2. import numpy as np
  3. np.array() — creating arrays
  4. np.argmax() — index of maximum value
  5. Array operations and broadcasting basics
  6. Reshaping arrays (array.reshape())

23. Image Processing (Intro)

  1. PIL (Python Imaging Library) / Pillow overview
  2. Image.open(path) — open an image
  3. image.show() — display an image
  4. Pixel data and image arrays

24. Data Structures & Algorithms

  1. Abstract data types overview
  2. Stack — LIFO (Last In, First Out)
  3. Queue — FIFO (First In, First Out)
  4. Queue operations: enqueue (append()), dequeue (pop(0))
  5. Graph — nodes and edges
  6. Adjacency list representation
  7. Breadth-First Search (BFS) algorithm
  8. BFS color tracking (white, gray, black)
  9. BFS for path finding
  10. Depth-First Search (DFS) algorithm
  11. DFS with recursion and backtracking
  12. DFS and BFS for maze solving
  13. Sorting algorithms overview (bubble, selection, insertion)
  14. Binary search concept

25. Machine Learning & Neural Networks (Advanced)

  1. Machine learning overview — supervised vs unsupervised
  2. keras library overview
  3. Sequential model
  4. Dense layers — fully connected layers
  5. Activation functions: relu, softmax
  6. Conv2D — convolutional layers
  7. MaxPooling2D — pooling layers
  8. Dropout — regularization to prevent overfitting
  9. Flatten layer — reshape for dense layers
  10. model.compile() — loss function, optimizer, metrics
  11. model.fit() — training the model
  12. model.evaluate() — testing accuracy
  13. model.predict() — making predictions
  14. Loss functions: categorical_crossentropy
  15. Optimizer: Adam
  16. Metrics: accuracy
  17. Batch size and epochs
  18. MNIST dataset — handwritten digit recognition
  19. Data normalization/preprocessing
  20. Convolutional Neural Networks (CNN)
  21. Feedforward networks
  22. Recurrent networks (RNN) — overview
  23. LSTM networks — overview
  24. Autoencoders — overview

26. Graphics in Jupyter

  1. ipycanvas — canvas drawing in Jupyter
  2. mobilechelonian — turtle graphics in Jupyter
  3. Drawing shapes on a canvas
  4. Color bars and data visualization in Jupyter

27. Event-Driven & Interactive Programming

  1. Event-driven programming model
  2. Mouse click event handlers (onscreenclick)
  3. Keyboard event handlers (turtle onkey)
  4. Callback functions
  5. Animation loops

28. Programming Practices & Patterns

  1. Modularity — breaking code into functions
  2. Code reusability
  3. DRY principle (Don't Repeat Yourself)
  4. Meaningful variable and function names
  5. Code comments — when and why
  6. Literate programming with Jupyter
  7. Reading documentation with help() and dir()
  8. Version control basics (git overview)
  9. Searching Stack Overflow and documentation

29. Color & Graphics Concepts

  1. Named colors (red, green, blue, orange, etc.)
  2. Hex color values (#FA057F)
  3. RGB color model
  4. Color in turtle graphics
  5. Background and pen colors

Concepts Added Beyond Existing Content

The following concepts are recommended additions to make the course more complete for a modern beginning Python curriculum:

  1. f-strings (formatted string literals) — more readable than .format()
  2. List comprehensions — concise way to build lists
  3. Dictionary comprehensions
  4. with statement / context managers — safe resource handling
  5. match/case statement (Python 3.10+) — modern pattern matching
  6. Lambda functions — anonymous single-expression functions
  7. map() and filter() — functional programming basics
  8. Sorting with a key function (sorted(list, key=...))
  9. String f-string formatting with format specifiers (e.g., {x:.2f})
  10. os and os.path — file path and directory operations
  11. CSV files — reading/writing structured data
  12. Exception hierarchy — understanding Exception base class
  13. raise — throwing custom errors
  14. Class __str__() and __repr__() methods
  15. Inheritance — subclasses and method overriding
  16. DRY principle and code reuse patterns
  17. __name__ == "__main__" guard for runnable modules
  18. Virtual environments — keeping projects isolated
  19. Reading and writing JSON files (json module)