Core Skills Level

Beginner Tier

Strengthen your foundations with object-oriented programming, file handling, error management and Python modules. Build real programs that do real things.

Topics Covered

OOPClassesFile I/OError HandlingModulesPackagesIteratorsGenerators

Enjoying the lessons?

Upgrade to unlock AI features, progress sync & more

Upgrade

Lesson 1

What Dictionaries Are — Smarter Data Storage

2

Lesson 2

Accessing Dictionary Values — get() and Safe Access

3

Lesson 3

Adding and Modifying Dictionary Entries

4

Lesson 4

Removing Dictionary Entries

5

Lesson 5

Dictionary Methods — keys(), values(), items()

6

Lesson 6

Looping Through Dictionaries — Patterns and Power

7

Lesson 7

Nested Dictionaries — Data Within Data

8

Lesson 8

Dictionaries vs Lists — Choosing the Right Tool

9

Lesson 9

Building Dictionaries Dynamically — From Input and Loops

10

Lesson 10

Milestone: Budget Manager

11

Lesson 11

What Tuples Are — Immutable Sequences

12

Lesson 12

Working with Tuples — Indexing, Slicing, Unpacking

13

Lesson 13

When to Use Tuples — Real-World Patterns

14

Lesson 14

What Sets Are — The Uniqueness Guarantee

15

Lesson 15

Set Operations — add(), remove(), discard()

16

Lesson 16

Set Mathematics — Union, Intersection, Difference

17

Lesson 17

Sets vs Lists vs Tuples — The Complete Picture

18

Lesson 18

Practical Tuple Patterns — Named Tuples and More

19

Lesson 19

Practical Set Patterns — Deduplication and Membership

20

Lesson 20

Milestone: Transaction Records System

21

Lesson 21

Why Files Matter — The Persistence Problem

22

Lesson 22

Writing to Files — open(), write(), and the with Statement

23

Lesson 23

Reading from Files — read(), readlines(), readline()

24

Lesson 24

Appending to Files — Building Up Data Over Time

25

Lesson 25

File Paths and Error Handling — Safe File Operations

26

Lesson 26

Working with CSV Files — Spreadsheet-Compatible Data

27

Lesson 27

Reading CSV with Loops — Processing Tabular Data

28

Lesson 28

Introduction to JSON — The Perfect Data Format

29

Lesson 29

Reading and Writing JSON Files — Complete Persistence

30

Lesson 30

Milestone: Expense File System

31

Lesson 31

What Modules Are — Python's Built-in Toolbox

32

Lesson 32

The datetime Module — Working with Dates and Times

33

Lesson 33

Working with Dates — Arithmetic, Comparison, and More

34

Lesson 34

The random Module — Generating Test Data

35

Lesson 35

The math Module — Financial Calculations

36

Lesson 36

The os Module — File System Management

37

Lesson 37

The string Module and String Constants

38

Lesson 38

Creating Your Own Modules — Splitting Code into Files

39

Lesson 39

Import Patterns — from, as, and Best Practices

40

Lesson 40

Milestone: Timestamped Transactions

41

Lesson 41

Errors and Exceptions — The Full Picture

42

Lesson 42

try/except — Catching Specific Exceptions

43

Lesson 43

Multiple except Clauses — Handling Different Errors Differently

44

Lesson 44

else and finally — Completing the try/except Pattern

45

Lesson 45

Raising Your Own Exceptions — Enforcing Business Rules

46

Lesson 46

Custom Exception Classes — Professional Error Handling

47

Lesson 47

Exception Messages and Information — Communicating Errors Clearly

48

Lesson 48

Nested try/except — Handling Errors at Multiple Levels

49

Lesson 49

Defensive Functions — Designing for Robustness

50

Lesson 50

Milestone: Bulletproof Expense Tracker

51

Lesson 51

Why List Comprehensions Exist — The Elegant Way

52

Lesson 52

Filtered List Comprehensions — Adding Conditions

53

Lesson 53

Nested List Comprehensions — Lists of Lists

54

Lesson 54

Dictionary Comprehensions — Building Dicts Elegantly

55

Lesson 55

Set Comprehensions and Generator Expressions

56

Lesson 56

Comprehensions with Functions — Calling Functions Inside

57

Lesson 57

When NOT to Use Comprehensions — Knowing the Limits

58

Lesson 58

Comprehensions in Practice — Real Expense Tracker Patterns

59

Lesson 59

Comprehension Performance — Speed and Memory

60

Lesson 60

Milestone: Smart Expense Filters

61

Lesson 61

What Classes Are — The Big Idea

62

Lesson 62

Defining Classes — __init__ and self

63

Lesson 63

Instance Methods — Objects That Do Things

64

Lesson 64

The __str__ and __repr__ Methods — Making Objects Readable

65

Lesson 65

Class Attributes vs Instance Attributes

66

Lesson 66

Building Real Objects — Designing a Complete Class

67

Lesson 67

Objects in Lists — Collections of Instances

68

Lesson 68

Objects in Dictionaries — Organising Object Collections

69

Lesson 69

Special Methods — Making Objects Truly Pythonic

70

Lesson 70

Milestone: Transaction Class

71

Lesson 71

What Inheritance Is — The IS-A Relationship

72

Lesson 72

Creating Subclasses — Adding Specialised Behaviour

73

Lesson 73

The super() Function — Extending Parent Behaviour

74

Lesson 74

Method Overriding — Replacing Parent Behaviour

75

Lesson 75

Polymorphism — One Interface, Many Behaviours

76

Lesson 76

isinstance() with Classes — Safe Type Checking

77

Lesson 77

Class Methods and Static Methods

78

Lesson 78

Properties — Controlled Attribute Access

79

Lesson 79

Dataclasses — Classes Made Easy

80

Lesson 80

Milestone: Income and Expense Classes

81

Lesson 81

Application Architecture — Structuring a Real Application

82

Lesson 82

The Repository Pattern — Managing Collections of Objects

83

Lesson 83

Menus with Objects — Building the User Interface Layer

84

Lesson 84

Generating Reports — Analytics from Object Collections

85

Lesson 85

Saving Objects to JSON — Serialising the Complete Application State

86

Lesson 86

Loading Objects from JSON — Deserialising the Application State

87

Lesson 87

Searching and Filtering — Smart Queries Across Object Collections

88

Lesson 88

Data Validation in Classes — Keeping the Application Robust

89

Lesson 89

A Complete CLI Application — Assembling All the Pieces

90

Lesson 90

Milestone: Complete Expense Tracker

91

Lesson 91

Code Review — Reviewing Your Own OOP Code

92

Lesson 92

Refactoring OOP Code — Improving Without Breaking

93

Lesson 93

Edge Cases in OOP — Making Objects Robust

94

Lesson 94

Adding Features the Right Way — Open/Closed Principle

95

Lesson 95

Testing Classes — Writing Unit Tests for OOP Code

96

Lesson 96

Documentation for Classes — Writing Docstrings That Help

97

Lesson 97

What's Coming — Intermediate Tier Preview

98

Lesson 98

Final Assembly Part 1 — Building the Complete Showcase

99

Lesson 99

Final Assembly Part 2 — Polish, Testing, and the Complete Showcase

100

Lesson 100

Graduation — Final Exam and Complete Expense Tracker

Pyfessor

"Hi! I'm Pyfessor. Ready to s-s-s-tart our coding journey?"

Pyfessor