book

Mastering Python Design Patterns - Third Edition

Name: Mastering Python Design Patterns - Third Edition
ISBN: 9781837639618

by Kamon Ayeva, Sakis Kasampalis

May 2024

Intermediate to advanced

296 pages

6h 32m

English

Packt Publishing

Read now

Unlock full access

Mastering Python Design Patterns
ContributorsAbout the authorsAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedMost of the code has been automatically formattedThe code snippets in the book’s pages may be shortenedOther conventionsGet in touchShare your thoughtsDownload a free PDF copy of this book
Part 1: Start with Principles
Chapter 1: Foundational Design Principles
Technical requirementsFollowing the Encapsulate What Varies principleWhat does it mean?BenefitsTechniques for achieving encapsulationAn example – encapsulating using polymorphismAn example – encapsulating using a propertyFollowing the Favor Composition Over Inheritance principleWhat does it mean?BenefitsTechniques for compositionAn example – compose a car using the engineFollowing the Program to Interfaces, Not Implementations principleWhat does it mean?BenefitsTechniques for interfacesAn example – different types of loggerAn example – different types of logger, now using ProtocolsFollowing the Loose Coupling principleWhat does it mean?BenefitsTechniques for loose couplingAn example – a message serviceSummary
Chapter 2: SOLID Principles
Technical requirementsSRPAn example of software design following the SRPOCPAn example of design following the OCPLSPAn example of design following the LSPISPAn example of design following the ISPDIPAn example of design following the ISPSummary
Part 2: From the Gang of Four
Chapter 3: Creational Design Patterns
Technical requirementsThe factory patternThe factory methodThe abstract factory patternThe builder patternReal-world examplesComparison with the factory patternUse cases for the builder patternImplementing the builder patternThe prototype patternReal-world examplesUse cases for the prototype patternImplementing the prototype patternThe singleton patternReal-world examplesUse cases for the singleton patternImplementing the singleton patternShould you use the singleton pattern?The object pool patternReal-world examplesUse cases for the object pool patternImplementing the object pool patternSummary
Chapter 4: Structural Design Patterns
Technical requirementsThe adapter patternReal-world examplesUse cases for the adapter patternImplementing the adapter pattern – adapt a legacy classImplementing the adapter pattern – adapt several classes into a unified interfaceThe decorator patternReal-world examplesUse cases for the decorator patternImplementing the decorator patternThe bridge patternReal-world examplesUse cases for the bridge patternImplementing the bridge patternThe facade patternReal-world examplesUse cases for the facade patternImplementing the facade patternThe flyweight patternReal-world examplesUse cases for the flyweight patternImplementing the flyweight patternThe proxy patternReal-world examplesUse cases for the proxy patternImplementing the proxy pattern – a virtual proxyImplementing the proxy pattern – a protection proxyImplementing the proxy pattern – a remote proxyImplementing the proxy pattern – a smart proxySummary
Chapter 5: Behavioral Design Patterns
Technical requirementsThe Chain of Responsibility patternReal-world examplesUse cases for the Chain of Responsibility patternImplementing the Chain of Responsibility patternThe Command patternReal-world examplesUse cases for the Command patternImplementing the Command patternThe Observer patternReal-world examplesUse cases for the Observer patternImplementing the Observer patternThe State patternReal-world examplesUse cases for the State patternImplementing the State patternThe Interpreter patternReal-world examplesUse cases for the Interpreter patternImplementing the Interpreter patternThe Strategy patternReal-world examplesUse cases for the Strategy patternImplementing the Strategy patternThe Memento patternReal-world examplesUse cases for the Memento patternImplementing the Memento patternThe Iterator patternUse cases for the Iterator patternImplementing the Iterator patternThe Template patternReal-world examplesUse cases for the Template patternImplementing the Template patternOther behavioral design patternsSummary
Part 3: Beyond the Gang of Four

Chapter 6: Architectural Design Patterns
Technical requirementsThe MVC patternReal-world examplesUse cases for the MVC patternImplementing the MVC patternThe Microservices patternReal-world examplesUse cases for the Microservices patternImplementing the microservices pattern – a payment service using gRPCImplementing the microservices pattern – an LLM service using LanarkyThe Serverless patternReal-world examplesUse cases for the Serverless patternImplementing the Serverless patternThe Event Sourcing patternReal-world examplesUse cases for the Event Sourcing patternImplementing the event sourcing pattern – the manual wayImplementing the Event Sourcing pattern – using a libraryOther architectural design patternsSummary
Chapter 7: Concurrency and Asynchronous Patterns
Technical requirementsThe Thread Pool patternReal-world examplesUse cases for the Thread Pool patternImplementing the Thread Pool patternThe Worker Model patternReal-world examplesUse cases for the Worker Model patternImplementing the Worker Model patternThe Future and Promise patternReal-world examplesUse cases for the Future and Promise patternImplementing the Future and Promise pattern – using concurrent.futuresImplementing the Future and Promise pattern – using asyncioThe Observer pattern in reactive programmingReal-world examplesUse cases for the Observer pattern in reactive programmingImplementing the Observer pattern in reactive programmingOther concurrency and asynchronous patternsSummary
Chapter 8: Performance Patterns
Technical requirementsThe Cache-Aside patternReal-world examplesUse cases for the cache-aside patternImplementing the cache-aside patternThe Memoization patternReal-world examplesUse cases for the memoization patternImplementing the memoization patternThe Lazy Loading patternReal-world examplesUse cases for the lazy loading patternImplementing the lazy loading pattern – lazy attribute loadingImplementing the lazy loading pattern – using cachingSummary
Chapter 9: Distributed Systems Patterns
Technical requirementsThe Throttling patternReal-world examplesUse cases for the Throttling patternImplementing the Throttling patternThe Retry patternReal-world examplesUse cases for the Retry patternImplementing the Retry patternThe Circuit Breaker patternReal-world examplesUse cases for the Circuit Breaker patternImplementing the Circuit Breaker patternOther distributed systems patternsSummary
Chapter 10: Patterns for Testing
Technical requirementsThe Mock Object patternReal-world examplesUse cases for the Mock Object patternImplementing the Mock Object patternThe Dependency Injection patternReal-world examplesUse cases for the Dependency Injection patternImplementing the Dependency Injection pattern – using a mock objectImplementing the Dependency Injection pattern – using a decoratorSummary
Chapter 11: Python Anti-Patterns
Technical requirementsCode style violationsTools for fixing coding style violationsIndentationMaximum line length and blank linesImportsNaming conventionsCommentsWhitespace in expressions and statementsCorrectness anti-patternsUsing the type() function for comparing typesMutable default argumentAccessing a protected member from outside a classMaintainability anti-patternsUsing a wildcard importLBYL versus EAFPOverusing inheritance and tight couplingUsing global variables for sharing data between functionsPerformance anti-patternsNot using .join() to concatenate strings in a loopUsing global variables for cachingSummary
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare your thoughtsDownload a free PDF copy of this book

Content preview from Mastering Python Design Patterns - Third Edition

2 SOLID Principles

In the world of software engineering, principles and best practices are the backbone of a robust, maintainable, and efficient code base. In the previous chapter, we introduced the foundational principles every developer needs to follow.

In this chapter, we continue exploring design principles, focusing on SOLID, an acronym coined by Robert C. Martin, representing a set of five design principles he proposed, aimed at making software more understandable, flexible, and maintainable.

In this chapter, we’re going to cover the following main topics:

Single responsibility principle (SRP)
Open-closed principle (OCP)
Liskov substitution principle (LSP)
Interface segregation principle (ISP)
Dependency inversion principle (DIP)

By ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Python: Master the Art of Design Patterns

Publisher Resources

ISBN: 9781837639618

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Mastering Python Design Patterns - Third Edition

by Kamon Ayeva, Sakis Kasampalis

2

SOLID Principles

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.