Python Training Program TOC (18 Days, 4 Hours/Day, 4 Days/Week)

Week 1: Core Python Fundamentals

Day 1: Introduction to Python
• Overview of Python and its applications.

• Setting up the Python environment (IDEs, interpreters).

• Python syntax and semantics.
• Basic input/output operations.
• Variables and data types.
Day 2: Control Structures
• Conditional statements (if, else, elif).

• Loops (for, while).

• break, continue, and pass statements.
• Nested loops and control structures.
Day 3: Python Functions
• Defining and calling functions.

• Function arguments and return values.

• Default and keyword arguments.
• Lambda functions.
• Scope and lifetime of variables.
Day 4: Data Structures - Lists, Tuples, Sets, and Dictionaries
• Creating and manipulating lists.

• List comprehensions.
• Tuples: creation and usage.
• Sets: operations and use cases.
• Creating and using dictionaries.
• Dictionary methods.
• Nested dictionaries.
• Dictionary comprehensions.
• When to use dictionaries.

Week 2: Object-Oriented Programming and Advanced Concepts

Day 5: Introduction to Object-Oriented Programming (OOP)
 • Classes and objects.
• Attributes and methods.
• __init__ method (constructor).
• Instance variables vs class variables.
Day 6: OOP - Inheritance and Polymorphism
• Single and multiple inheritance.

• Method overriding.
• Polymorphism.
• Using super() to access parent methods.
Day 7: Encapsulation, Abstraction, and Error Handling
• Public, protected, and private attributes.

• Getter and setter methods.

• Abstract classes and methods.
• Introduction to interfaces.
• Python exception hierarchy.
• try, except, else, and finally blocks.
• Raising exceptions (raise).
• Custom exception classes.
Day 8: File Handling
• Reading and writing files.

• Working with text and binary files.

• File handling best practices.
• Using with for file management (context managers).

Week 3: Modules, Packages, and Testing Frameworks

Day 9: Modules, Packages, and Creating Python Packages
• Introduction to modules.

• Importing and using modules.

• Creating and structuring Python packages.
• Managing dependencies using requirements.txt.
• Structuring packages for large projects.
• Creating and distributing custom packages.
 • Using setuptools to package projects.
• Uploading packages to PyPI.
Day 10: Introduction and Advanced Unit Testing
• Importance of testing in software development.

• Introduction to unittest framework.

• Writing and running test cases.
• Test fixtures: setUp() and tearDown().
• Assertions in unittest.
• Testing exceptions.
• Mocking with unittest.mock.
• Running tests in command line.
• Test-driven development (TDD) concepts.
Day 11: PyTest Framework
• Introduction to PyTest.

• Writing and organizing tests using PyTest.

• PyTest fixtures.
• Parameterized tests in PyTest.

Week 4: Advanced Python Concepts and Integrating Testing Frameworks

Day 12: Iterators, Generators, and Decorators
• Working with iterators and iterable objects.

• Generators: yield and generator functions.

• Decorators: basic and advanced use cases.
• Applying decorators in real-world scenarios.
Day 13: Context Managers, Concurrency, and Asynchronous Programming
• Context managers using with statement.

• Creating custom context managers.

• Introduction to concurrency in Python.
• Threading and multiprocessing.
• Introduction to asyncio library.
• Writing coroutines and tasks.
• Event loop and asynchronous execution.
 • Real-world applications of asyncio.
Day 14: Using tox for Testing and CI Integration
• Introduction to tox.

• Setting up testing environments with tox.

• Running multiple test environments.
• Continuous Integration (CI) with tox and pytest.
Day 15: Other Testing Frameworks in Python
• Overview of nose2 and hypothesis.

• Writing property-based tests with hypothesis.

• Integrating different testing frameworks in Python projects.
• Best practices for test organization and automation.

Week 5: Python Capstone Project

Day 16: Project Setup and Introduction
• Project Overview (1 hour)

o Introduce the project: "Traffic Light Controller Simulation."

o Objectives:
▪ Simulate an embedded traffic light controller system.
▪ Implement state management and timing using Python.
o Expected Outcomes:
▪ A Python-based simulation of traffic light states (Red, Yellow, Green).
▪ Console-based interface to visualize the simulation.
• Environment Setup (1 hour)
o Install required libraries:
▪ time for delays.
▪ threading for concurrent control simulations.
o Create and structure the project directory.
• System Design (2 hours)
o Traffic Light State Machine:
▪ Define states (Red, Yellow, Green).
▪ Configure timing for each state.
 o System Behavior:
▪ Transition rules between states.
▪ Emergency mode (e.g., flashing yellow light).
o Design pseudocode for the simulation.
Day 17: Core Feature Development
• Traffic Light Simulation (2 hours)

o Implement the state machine for the traffic light.

o Use threading to handle state transitions and timing.
• Console-Based Visualization (1 hour)
o Create a visual representation in the console:
▪ Highlight active states with text formatting.
▪ Display timer for each state.
• Emergency and Manual Modes (1 hour)
o Add an emergency mode:
▪ Flash yellow light when triggered.
o Include a manual mode:
▪ Allow users to control state transitions via input.
Day 18: Testing and Enhancement
• Testing the Simulator (2 hours)

o Validate state transitions and timings using test cases.

o Simulate multiple scenarios, including emergency and manual modes.
• Project Documentation (1 hour)
o Document the following:
▪ System design and functionality.
▪ Instructions to run the simulation.
▪ Use cases and limitations.
• Presentation and Feedback (1 hour)
o Demonstrate the project simulation.
o Gather and implement feedback for further enhancement.