Course Series
Python Basics
Learn Python variables, data types, operators, loops, functions, lists, and OOP.
Educational Concept
The course series is designed as a step-by-step introduction to central Python programming basics: from variables and data types through control structures to lists and object-oriented programming. The progression follows a clear logical structure: Initially, input, output, and type conversion are secured, followed by decisions and repetitions as control mechanisms introduced and applied in task formats. Building on this, functions are established for structuring programs, before lists as data structures and finally classes, methods, and inheritance as OOP building blocks are added. In all modules, the connection between concept clarification and implementation in executable code is supported through short exercises, typical error situations, and systematic debugging.
For teachers, this results in a structured introduction with transparent competence development and clearly divided building blocks. The modules can be used individually according to the learning group and time budget, while the sequence also enables a comprehensible overall composition with clear learning objectives.
Competence Development
- Safe handling of variables, data types, type conversion, and formatted input and output as a basis for executable programs.
- Application of comparison operators, logical conjunctions, and if/elif/else to model decision logic and input checking.
- Use of for- and while-loops including break/continue to implement repeated operations and validate inputs.
- Structuring programs through functions (parameters, return values, default values, function calls) including controlled handling of None.
- Work with lists as a data structure (acquiring, evaluating, searching, aggregating) as well as transition to object-oriented modeling with classes, methods, encapsulation, and inheritance up to algorithmic operations (sorting, managing data).
Structure of the series
Foundations of Python Programming
Learn variables, data types, type conversion in Python.
This module establishes the subject basis of the series by systematically introducing input and output, data types, and type conversions. Operators, output formatting, as well as handling typical error situations and debugging establish a reliable working method early on. This creates a stable foundation for the subsequent modules on decisions, loops, and further program structure.
Conditional Statements
Learn Programming with if Statements.
Based on secure data type and operator work, comparison expressions and logical conjunctions (OR/AND) are gradually developed into complete decision structures. Nested conditions, string checks, and the combination of if with try/except expand input checking towards robust program design. This prepares the central control idea that will be picked up again in loops and later application tasks.
Loops and Control Structures
Implement Python Loops and Tasks.
This module extends decision logic with repetition as the central control structure and introduces for- and while-loops in typical exercise formats. Iterative procedures (e.g., factorial calculation), access controls, and input validation combine concept knowledge with application-oriented implementation. With break/continue, the control of processes is refined and used as preparation for more structured programs.
Working with Functions
Learn Python Functions with Parameters & Return Values.
After control structures are established, structured decomposition of programs into subtasks takes center stage. Parameters, return values, default values, and function chains promote clean task distribution (e.g., with main() as a flow controller). Controlled handling of None supports robust result checking and creates connectivity for data- and object-oriented concepts in the following modules.
Arrays
Learn Python lists and array manipulation.
This module introduces lists as the central data structure and consistently connects them with loops, conditions, and functions. Tasks for recording, searching, and evaluating (e.g., counting, calculating averages, min/max, sums) strengthen the transfer between model (list as a collection of data) and implementation. With two-dimensional lists and nested loops, more complex structures are prepared that can be used in OOP- and administration tasks afterwards.
Introduction to OOP
Learn object-oriented programming.
Building on functions and lists, the modeling with classes, attributes, and methods is introduced and deepened fachlich through encapsulation (getters/setters). Project-oriented units (e.g., account-, book- or administration models) support the transition from individual constructs to cohesive program structures. Inheritance and calling parent methods expand the repertoire with reuse and override, making complex domain models systematically accessible.
Programming Flows
Managing Students/Staff and Sorting Algorithms.
This final module consolidates previously built competencies in algorithmically driven task assignments. With Bubblesort and Quicksort (recursive function calls), flows are precisely structured and broken down into traceable steps, while the management task combines working with data structures and evaluations. This results in a clear progression from basics to structured problem-solving and systematic implementation.
For private clients, there is also a corresponding course offer for Python Basics and object-oriented programming available. Course offer for Python Basics and object-oriented programming .
Contents at a glance
Python Programming Basics
| Content | Focus | Duration |
|---|---|---|
| Introduction to Variables and Data Types | Introduction to Variables and Data Types; using input() and converting inputs; exercise program for arithmetic operations. | 15 min |
| Type Conversion with Console Output | Type conversion of user inputs with int(); output simple calculations. | 15 min |
| Data Type Recognition and Conversion | Explain type(), str(), float(), bool(); recognize and convert input types. | 25 minutes |
| Basic Operators in Python | Arithmetic operators +, -, *, /, //, %; examples and exercises on division and remainder. | 25 minutes |
| Output Formatting and Text Concatenation | Text and number concatenation with comma, +, and f-Strings; understand differences and apply. | 25 minutes |
| Error Situations for Inputs | Understand ValueError for incorrect inputs; read and analyze errors. | 20 minutes |
| Introduction to Debugging Techniques | Debugging: find and fix typical programming errors (e.g. division by zero). | 15 minutes |
Conditional Statements
| Content | Focus | Duration |
|---|---|---|
| Introduction to Logical Expressions | Logical expressions with comparisons (greater than or equal, less than or equal). | 10 min |
| Checking for Equal or Not Equal | Expressions to check for equality or inequality. | 5 min |
| Logical Expressions with "OR" Combine | OR-connections to combine multiple conditions (at least one fulfilled). | 10 min |
| Using if Statements for Age Checks | if/else and comparison operators based on age checks with user input. | 15 minutes |
| Decision logic with if, elif, and else | If/elif/else for decision logic; example with temperature input and weather description. | 15 minutes |
| Logical AND-connection (and) | And-operator for combined conditions; age and ticket check; access control. | 15 minutes |
| Nested if-conditions | Nested if-structures and dependencies; example rain and jacket; action recommendation. | 20 minutes |
| Texts and string checking | String comparison; normalization with .lower() and .strip(); password check and feedback. | 20 minutes |
| Error handling with if and try | If with try/except for input checking; number validation and error messages. | 20 min |
| Truth values and empty variables | Truthy/falsy; checking empty strings/variables; input check by if-statement. | 15 min |
Loops and control structures
| Content | Focus | Duration |
|---|---|---|
| Understanding loops: for and while | Basic structure of for/while; examples; loops for repetitive tasks; code adaptation. | 10 min |
| Iterations with loops: factorial calculation | Factorial iteratively calculated in the main program; multiply step by step. | 15 min |
| Access control with password | Password verification with if and loops; optionally consider case sensitivity. | 10 minutes |
| Input validation with while loop | Repeated input checking with while until a valid value is present. | 20 minutes |
| Loop control with break and continue | break/continue for control; Modulo (%) for divisibility check; flow control. | 20 minutes |
| Grading system with score | Grade calculation with if/elif/else; optionally output comments per grade. | 15 minutes |
Working with functions
| Content | Focus | Duration |
|---|---|---|
| Brief introduction to functions | Simple function call with output. | 10 minutes |
| Introduction to functions with return values | Passing and returning values; if-queries; Modulo operator for parity check. | 15 min |
| Functions: parameters and return values in Python | Functions with parameters and return values; exercise: calculate the area of a rectangle. | 15 min |
| Multiple parameters and default values | Multiple parameters; default values; flexible calls with and without additional parameters. | 20 min |
| Functions that call other functions | Task separation into sub-functions; function calls; main() for flow control. | 25 min |
| Check return values and handle None | None as "no result"; Check with is None; Safe error handling without interruption. | 25 minutes |
Arrays
| Content | Focus | Duration |
|---|---|---|
| What are Arrays? | Introduction to Arrays. | 10 min -> @@ITEM_0001@@10 minutes |
| Adding elements to an Array | Introduction to push(). | 10 minutes |
| Removing elements from an Array | Introduction to pop(), shift() and splice(). | 15 minutes |
| Simple shopping list with Lists in Python | Create a list; Add/Remove elements; Functions for interactive actions. | 15 min |
| Counting favorite subjects in a List | Recurring values count with for- and if-statements; Output with print(). | 15 min |
| Searching names in a List | Name search by loop and if; .lower() for case sensitivity. | 20 min |
| Grading notes with Loop | Evaluating lists; Counting with loop and if; Average with sum() and len(). | 20 min |
| Weekly temperature measurement | Recording temperatures; Evaluation with max(), min(), sum(); hottest day determination. | 25 min |
| Calculating shopping costs | Saving inputs; sum(), len() and if for price calculation and warning. | 25 minutes |
| Calorie Calculator with Evaluation | Collect calorie values; form a sum; evaluate using if-statement. | 25 minutes |
| Seat row output with lists | Iterate through two-dimensional list; output rows; add name search. | 25 minutes |
| Height comparison in sports class | Find largest/smallest number using loop and comparison; calculate difference. | 25 minutes |
| Calculate average, best, worst, and median note | Process inputs; calculate average, best/worst, and median note. | 15 minutes |
| Alphabet analysis with lists | Convert input to alphabet list; count; determine length. | 20 minutes |
Introduction to OOP
| Content | Focus | Duration |
|---|---|---|
| Einführung in "Objektorientierte Programmierung" | Classes for reusable structures; properties and methods for objects. | 15 minutes |
| Classes with own methods | Methods within class definition; call using instantiated objects. | 15 minutes |
| Getter- and Setter-methods | Getters/setters; private/public variables; access control and encapsulation. | 30 minutes |
| Student class with average grade | Extend class; grades list; average method; output with average. | 30 minutes |
| Bank account with deposits and withdrawals | Private variables; check for deposit/withdrawal; getter for account balance; secure data modification. | 35 minutes |
| Managing library books | Private attributes; lend/borrow/status; boolean status management. | 30 minutes |
| Introduction to inheritance | Inheritance and overriding in child classes (extends). | 10 min -> @@ITEM_0001@@10 minutes |
| Calling parent methods | Calling parent methods in inherited classes with super(). | 15 min -> @@ITEM_0001@@15 minutes |
| Vehicle fleet with inheritance | Practicing inheritance; overriding methods; using super(). | 35 min |
| School administration with classes | Classes student and school class; lists, loops, and average calculation. | 35 min |
Programming workflows
| Content | Focus | Duration |
|---|---|---|
| Bubblesort | Sorting arrays with Bubblesort by completing an existing basic code. | 30 min |
| Quicksort with recursion | Sorting arrays with Quicksort by recursive function call. | 30 min |
| Managing students and grades | Programming a simple student management system that flexibly manages subjects and grades. | 15 min |
For teaching, a clearly structured sequence of modules results with a comprehensible progression and transparent competence development. The building blocks can be combined and adapted in time according to the learning group.
To get an insight into structure and materials, a demo access can be used to test the series in your own teaching context. This allows you to pragmatically check the fit with your existing curriculum planning.