This repository contains my solutions for the 42 Python Modules curriculum.
The Python Modules are a series of projects designed to progressively teach Python programming through themed exercises and real-world inspired scenarios. Throughout these modules, students explore Python fundamentals, object-oriented programming, data structures, file handling, package management, and advanced programming concepts.
Each module introduces new concepts while reinforcing previous knowledge through practical problem-solving challenges.
By completing these modules, I strengthened my ability to write clean, structured, and maintainable Python code, while also learning tools and practices used in real-world Python development.
Throughout the modules I learned and practiced:
- Python fundamentals and syntax
- Object-Oriented Programming (OOP)
- Exception handling and robust programming
- Data structures and data processing
- File operations and persistence
- Method overriding and polymorphism
- Python packages and import systems
- Abstract classes and software architecture
- Virtual environments and dependency management
- Data validation using Pydantic
- Advanced Python concepts such as decorators and higher-order functions
These topics are essential for fields such as:
- Backend development
- Automation and scripting
- Data engineering
- Software engineering
Each module directory contains the exercises required by the 42 Python Modules curriculum.
This module introduces the fundamentals of Python programming through practical garden-themed exercises.
Students learn how to write basic Python scripts while solving simple programming problems inspired by gardening scenarios.
Topics covered include:
- Python syntax and execution
- Variables and basic data types
- Basic program structure
- Simple problem solving with Python
Goal: Build a strong foundation in Python and understand how to write and run basic programs.
In this module, students begin learning Object-Oriented Programming (OOP) concepts by building a virtual garden system.
Through managing and interacting with digital plants, students discover how classes and objects work in Python.
Topics covered include:
- Classes and objects
- Attributes and methods
- Encapsulation
- Modeling real-world entities in code
Goal: Understand how Python uses objects and classes to organize complex programs.
This module focuses on building reliable programs by learning how to handle errors and unexpected situations.
Through the creation of a digital greenhouse monitoring system, students learn how to detect and manage failures in software systems.
Topics covered include:
- Exception handling
try/except- Custom exceptions
- Writing fault-tolerant programs
Goal: Learn how to build robust systems that continue functioning even when errors occur.
This module explores Python’s powerful data structures through a game analytics scenario.
Students work with streaming data pipelines and process information from simulated gaming environments.
Topics covered include:
- Lists
- Tuples
- Dictionaries
- Sets
- Data manipulation and organization
Goal: Learn how to efficiently store, process, and analyze structured data in Python.
This module introduces file operations through a cyberpunk-themed data archiving mission.
Students learn how to read, write, and manage files while working with digital archives.
Topics covered include:
- File reading and writing
- File streams
- Context managers (
withstatement) - Error handling during file operations
Goal: Understand how programs interact with files and store data outside of memory.
This module focuses on advanced object-oriented programming concepts.
Students build a cyberpunk messaging system while learning how objects can behave differently depending on their type.
Topics covered include:
- Method overriding
- Subtype polymorphism
- Class hierarchies
- Dynamic method behavior
Goal: Learn how polymorphism allows flexible and extensible program design.
This module explores Python’s import system and package structure through laboratory-themed experiments.
Students learn how large Python projects are organized and how modules interact with each other.
Topics covered include:
- Python packages
__init__.py- Absolute and relative imports
- Package organization
- Circular dependencies
Goal: Understand how to structure larger Python projects using modules and packages.
This module introduces abstract programming patterns through a card-game engine project.
Students implement creatures, spells, and artifacts while learning how to design flexible software architectures.
Topics covered include:
- Abstract base classes
- Interfaces
- Class hierarchies
- Reusable architecture patterns
Goal: Learn how abstraction helps structure complex systems and enforce consistent behavior across classes.
This module focuses on tools used in real-world Python development.
Through a Matrix-themed project, students learn how to manage Python environments and dependencies like a professional developer.
Topics covered include:
- Virtual environments
- Environment variables
- Dependency management
- Poetry package manager
Goal: Understand how to configure and manage Python projects in real development environments.
In this module, students work as junior data engineers in a cosmic data observatory, processing structured data from space missions.
The focus is on validating and structuring data using modern Python tools.
Topics covered include:
- Data models with Pydantic
- Field validation
- Custom validators
- Nested data structures
Goal: Learn how to create reliable data models and enforce strict validation rules in Python applications.
The final module introduces advanced Python techniques through the Function Mage Chronicles cyberpunk adventure.
Students learn how to extend and modify the behavior of functions dynamically.
Topics covered include:
- Higher-order functions
- Decorators
functools.wraps@staticmethod- Lambda functions
Goal: Understand how advanced function techniques can be used to build powerful and reusable abstractions.
This repository serves as:
- A learning record of my progress through the 42 Python Modules
- A reference for future Python projects
- A portfolio of Python programming exercises
Completing these modules helped me build a deeper understanding of Python and prepared me for more advanced topics in software development.
Emanuel Tchipoque - 7PPi
Student at 42 School (etchipoq)
Passionate about technology, software engineering, and cybersecurity.