Mastering Python Design Patterns

Mastering Python Design Patterns

Instructor: Packt - Course Instructors

Access provided by Chitkara University Enterprise

11 modules

Gain insight into a topic and learn the fundamentals.

Intermediate level

Recommended experience

2 weeks to complete

at 10 hours a week

Flexible schedule

Learn at your own pace

11 modules

Gain insight into a topic and learn the fundamentals.

Intermediate level

Recommended experience

2 weeks to complete

at 10 hours a week

Flexible schedule

Learn at your own pace

What you'll learn

Apply Gang of Four patterns effectively in Python
Explore architectural and concurrency patterns for optimized code
Develop modular, decoupled systems with efficient dependency management

Skills you'll gain

Tools you'll learn

Python Programming

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

11 assignments

Taught in English

See how employees at top companies are mastering in-demand skills

Learn more about Coursera for Business

logos of Petrobras, TATA, Danone, Capgemini, P&G and L'Oreal

There are 11 modules in this course

Mastering Python design patterns is an essential skill for any developer focused on building scalable and maintainable software. This course dives deep into classic and modern design patterns, offering developers the knowledge to enhance the structure and functionality of Python applications. Understanding design patterns helps in crafting efficient, flexible, and reusable code, a must-have skill in today’s software development landscape.

Throughout this course, learners will master key design principles and implement them through real-world examples. The course provides a hands-on approach, allowing learners to directly apply each pattern in practical projects. You'll work through coding exercises that progressively build your ability to design Python applications with clean architecture. What makes this course stand out is its emphasis on both traditional design patterns like those from the Gang of Four (GoF) and newer, modern patterns. You'll get not just the theory, but practical insights into using these patterns in Python, ensuring that your code is both effective and optimized for real-world challenges. This course is perfect for Python developers who already have a foundation in object-oriented programming and want to deepen their knowledge of software architecture. Whether you're an intermediate developer or looking to advance your career as a software architect, this course will provide the skills you need to level up.

In this section, we explore core design principles including encapsulation, composition, interfaces, and loose coupling to build maintainable and scalable software in Python.

What's included

2 videos2 readings1 assignment

In this section, we explore the SOLID principles, including SRP, OCP, LSP, ISP, and DIP, focusing on their application in Python to improve code maintainability and flexibility.

What's included

1 video3 readings1 assignment

In this section, we explore creational design patterns in Python, focusing on factory, singleton, and prototype patterns to enhance object creation and management in software development.

What's included

1 video6 readings1 assignment

1 video Total 1 minute

Creational Design Patterns - Overview Video 1 minute

6 readings Total 120 minutes

Introduction 10 minutes
Implementing the Factory Method Pattern 20 minutes
Should You Use the Factory Method Pattern 20 minutes
The Builder Pattern 20 minutes
The Prototype Pattern 20 minutes
The Singleton Pattern 30 minutes

1 assignment Total 10 minutes

Creational Design Patterns Exploration 10 minutes

In this section, we explore structural design patterns to enhance code organization and functionality. Key concepts include adapter, decorator, and bridge patterns for flexible and maintainable software solutions.

What's included

1 video10 readings1 assignment

1 video Total 1 minute

Structural Design Patterns - Overview Video 1 minute

10 readings Total 120 minutes

Introduction 10 minutes
Implementing the Adapter Pattern Adapt Several Classes into a Unified Interface 10 minutes
The Decorator Pattern 20 minutes
The Bridge Pattern 10 minutes
The Facade Pattern 5 minutes
Implementing the Facade Pattern 10 minutes
The Flyweight Pattern 5 minutes
Implementing the Flyweight Pattern 10 minutes
The Proxy Pattern 10 minutes
Implementing the Proxy Pattern Protection Proxy 30 minutes

1 assignment Total 10 minutes

Structural Design Patterns in Software Development 10 minutes

In this section, we explore behavioral design patterns to enhance software interaction and flexibility. Key concepts include Chain of Responsibility, Command, and Observer patterns for improved system design.

What's included

1 video12 readings1 assignment

1 video Total 1 minute

Behavioral Design Patterns - Overview Video 1 minute

12 readings Total 170 minutes

Introduction 30 minutes
The Command Pattern 20 minutes
The Observer Pattern 20 minutes
The State Pattern 5 minutes
Implementing the State Pattern 20 minutes
The Interpreter Pattern 20 minutes
The Strategy Pattern 5 minutes
Implementing the Strategy Pattern 10 minutes
The Memento Pattern 10 minutes
The Iterator Pattern 10 minutes
The Template Pattern 10 minutes
Other Behavioral Design Patterns 10 minutes

1 assignment Total 10 minutes

Behavioral Design Patterns in Software Development 10 minutes

In this section, we will learn architectural patterns like MVC, microservices, and event sourcing for scalable system design.

What's included

1 video4 readings1 assignment

In this section, we explore concurrency and asynchronous patterns, including thread pools, worker models, and futures, to enhance application performance and responsiveness in real-world systems.

What's included

1 video5 readings1 assignment

1 video Total 1 minute

Concurrency and Asynchronous Patterns - Overview Video 1 minute

5 readings Total 60 minutes

Introduction 10 minutes
The Worker Model Pattern 10 minutes
The Future and Promise Pattern 10 minutes
Implementing the Future and Promise Pattern Using Concurrent Futures 10 minutes
The Observer Pattern in Reactive Programming 20 minutes

1 assignment Total 10 minutes

Concurrency and Asynchronous Programming Fundamentals 10 minutes

In this section, we explore performance patterns like Cache-Aside, Memoization, and Lazy Loading to optimize application speed, memory usage, and resource efficiency in real-world systems.

What's included

1 video3 readings1 assignment

In this section, we explore throttling, retry, and circuit breaker patterns to manage resource usage, handle failures, and improve system stability in distributed environments.

What's included

1 video2 readings1 assignment

In this section, we examine Mock Object and Dependency Injection patterns to improve test reliability, code reusability, and maintainability in software development.

What's included

1 video3 readings1 assignment

In this section, we examine Python anti-patterns, focusing on code style, correctness, maintainability, and performance to improve code quality and long-term project sustainability.