Python SOLID Principles and Top Design Patterns

Learn how to improve your Python code through mastery of S.O.L.I.D principles and the Top GoF Design Patterns.
Python SOLID Principles and Top Design Patterns
File Size :
2.33 GB
Total length :
5h 13m

Category

Instructor

Piotr Paweska

Language

Last update

10/2023

Ratings

4.6/5

Python SOLID Principles and Top Design Patterns

What you’ll learn

*Master* the most important and fundamental design patterns in modern Software Engineering within the *Python* ecosystem
Learn and internalize the S.O.L.I.D principles of design like seasoned *Senior Developers* do.
Get a deep understanding of the WHAT, WHY, and HOW for those *Fundamental Design Patterns*.
Get a full Architectural exposition (with UML) of each pattern as well as *real-world* scenarios with hands-on coding examples for each pattern.
Work on and complete Object Oriented *Python* assignments that will push your understanding of those patterns deeper and more fundamentally.
Learn how to *identify* the *best pattern* for the given Architectural challenge.

Python SOLID Principles and Top Design Patterns

Requirements

It is assumed that you know your way around Python. Only basic experience is required. We have a OOP refresher if you need it.
You should be able to run the Python code that is provided with the course. We will use Visual Studio Code as our IDE but you can use any IDE you like.
Access to a computer. A Mac, Windows, or a Linux based operating system is equally fine. All the tools are OS Independent.

Description

We all want to become better software developers and be able to call ourselves “Software Engineers” or “Software Architects”, but to do that you first have to master a number of design patterns.This course will put you on a track to that destination. We will teach you how to recognize when to use specific design patterns to build complex systems in a divide-and-conquer manner so that complexity is reduced and abstracted.But rather than learning all the design patterns out there, we have curated the most important, the top fundamental GoF Design Patterns for you. All of that in the context of the Object Oriented Python.We start with full understanding of the S.O.L.I.D Design Principles and how they in turn relate to those design patterns. We explain everything in the context of real-world problems as well as specific code examples.if you need a Python OOP Refresher, we have that for you. everything from classes to interfaces and abstract classes is covered. We will also show you how to code using pygame (Python Game Platform.) At the end of the course you will get to Architect a solution by coding John Conway’s Game of Life simulation which will run on your mobile device.Complex software systems are plagued with three major issues:Timelines are stretched as requirements change.Multiple developers have a hard time coordinating their efforts.Code redundancy.This in turn creates issues with maintenance and overall flexibility for adding new features. In general this means poorly designed systems that are hard to maintain and are not adaptable.One answer to all the above problems is having a proper design and architecture. Think of a skyscraper being built. There is always a high-level blueprint. This blueprint is used to show everybody involved (from architects to supply chain to construction workers to machinery scheduling etc…) what is being worked on.That way, everybody understands and follows the same vision.A blueprint has a number of commonly understood elements which repeat themselves across many projects. For example all buildings need electrical wiring and plumbing, they might need elevators, and cooling systems, and underground parking lots, and of course stairs. They also usually are connected to the electrical grid and water supply as well as… roads.All these common elements follow certain standards that have been improved over many many years and across many many projects. They are well understood and can be used almost like recipes.In Software Engineering we also have a set of elements that repeat themselves across many projects. For example all software applications need to create objects, they need to communicate state change across those objects, they need to be able traverse over collections of those objects. In other words, if you want to be a better developer then you need to become proficient in those elements that have been time-tested. In the Software Engineering world these elements are known as “Design Patterns”This course will teach students how to recognize when to use specific design patterns to build complex systems in a divide-and-conquer manner so that complexity is reduced and abstracted.This will help you to design projects in an Architectural manner before any major development happens and can be used to shorten development time and reduce maintenance costs.Design patterns are important because they are time-tested recipes or solutions to well-known software engineering problems. When creating software applications certain problems recur in a pretty predictable fashion so rather than ‘reinvent’ the wheel we will have an assortment of, if you will, wheels to choose from.We will teach you this in a slightly different manner than you probably have been taught before. We will take a practical approach (i.e. specific examples) but the power of Design Patterns comes from their ‘concept’ and we will teach you the concept of those design patterns so that you are fully able to change them and modify them to your needs. In addition we will look at how to combine all those patterns into something greater: an architecture.A well designed Architecture is this magical thing where the whole is greater than the sum of its parts.This is what we will strive to teach you.

Overview

Section 1: Introduction

Lecture 1 What are Design Patterns and why do we need them?

Lecture 2 The Design Patterns Covered in This course.

Lecture 3 The WHY Of Software Architecture.

Lecture 4 Why use UML?

Lecture 5 Organized vs. Unorganized code.

Lecture 6 Setting Up the IDE and Python Environment

Lecture 7 *OPTIONAL*: UML Refresher.

Section 2: Python OOP *Refresher*

Lecture 8 Python OOP Refresher – Theory Part #1

Lecture 9 Python OOP Refresher – Theory Part #2

Lecture 10 Python OOP Refresher – Code Studies Part #1

Lecture 11 Python OOP Refresher – Code Studies Part #2

Lecture 12 Python OOP Refresher – Code Studies Part #3

Lecture 13 Python OOP Refresher – Code Studies Part #4

Lecture 14 Python OOP Refresher – Code Studies Part #5

Lecture 15 Python OOP Refresher – Code Studies Part #6

Lecture 16 Python OOP Refresher – Code Studies Part #7

Section 3: What makes a Great Architecture?

Lecture 17 Hallmarks of Good Architecture.

Lecture 18 S.O.L.I.D Design Principles.

Lecture 19 SOLID *Practice Session* – Single Responsibility Principle(SRP)

Lecture 20 SOLID *Practice Session* – Open/Closed Principle(OCP)

Lecture 21 SOLID *Practice Session* – Liskov Substitution Principle (LSP)

Lecture 22 SOLID *Practice Session* – Interface Separation Principle (ISP)

Lecture 23 SOLID *Practice Session* – Dependency Inversion Principle (DIP)

Section 4: Singleton Design Pattern

Lecture 24 Understanding the Singleton Pattern

Lecture 25 Singleton Pattern – Architectural Considerations Part#1 – Simple Approach

Lecture 26 Singleton Pattern – Architectural Considerations Part#2 – Using Metaclasses

Lecture 27 Singleton Pattern – Architectural Considerations Part#3 – Thread-Safety

Lecture 28 Coding Part#1 – Implementing Singleton Pattern in Python

Lecture 29 Coding Part#2 – Practical Examples of Singleton In Python

Lecture 30 Singleton Pattern Coding **Extra** Exercises

Section 5: Factory Method Design Pattern

Lecture 31 Understanding Factory Method Pattern

Lecture 32 Architectural Considerations for Factory Method Pattern

Lecture 33 Coding the Factory Method Pattern in Python

Lecture 34 Factory Method Pattern Coding **Extra** Exercises

Section 6: Builder Design Pattern

Lecture 35 Understanding Builder Design Pattern

Lecture 36 Architectural Considerations for Builder Design Pattern

Lecture 37 Coding the Builder Pattern in Python

Lecture 38 Builder Design Pattern Coding **Extra** Exercises

Section 7: Adapter Design Pattern

Lecture 39 Understanding the Adapter Design Pattern

Lecture 40 Architectural Considerations for the Adapter Pattern

Lecture 41 Coding the Adapter Pattern In Python

Lecture 42 Adapter Design Pattern Coding **Extra** Exercises

Section 8: Strategy Design Pattern

Lecture 43 Understanding the Strategy Design Pattern

Lecture 44 Architectural Consideration for the Strategy Design Pattern

Lecture 45 Coding the Strategy Design Pattern

Lecture 46 Strategy Design Pattern Coding **Extra** Exercise

Section 9: Observer Design Pattern

Lecture 47 Understanding the Observer Design Pattern

Lecture 48 Architectural Consideration for the Observer Design Pattern

Lecture 49 Coding with the Observer Pattern

Lecture 50 Observer Design Pattern Coding **Extra** Exercises

Section 10: State Design Pattern

Lecture 51 Understanding the State Design Pattern

Lecture 52 Architectural Consideration for the State Design Pattern

Lecture 53 Coding the State Design Pattern

Lecture 54 State Design Pattern Coding **Extra** Exercises

Section 11: Course Assignment – The Game of Life

Lecture 55 About John Conway’s Game Of Life Simulation

Lecture 56 A Word about the “Game of Life” Architecture

Section 12: Final Thoughts

Lecture 57 Where do you go from here?

Lecture 58 Thank you!

*Python* developers who want to learn to Design, Architect, and ultimately develop *better code*.,Developers who want to get a deep understanding of what makes GREAT *Software Architecture*.

Course Information:

Udemy | English | 5h 13m | 2.33 GB
Created by: Piotr Paweska

You Can See More Courses in the Developer >> Greetings from CourseDown.com

New Courses

Scroll to Top