This workshop is intended for developers with some Python experience. The course covers all Design Patterns as described by Gang of Four.

At this workshop you will learn:

  • What are the principles of well designed object-oriented code?
  • When should you use design patterns?
  • How to apply design patterns in practice?
  • How to write object-oriented code in Python?
  • What are the relations between different design patterns?
  • And much, much more.

Course Syllabus

  1. Object Oriented Programming in Python
    1. Properties and Descriptors
    2. Special Methods
    3. Static and Class Methods
    4. Class and Instance Attributes
    5. Inheriting from Immutable and Builtin Types
    6. Multiple Inheritance
    7. Method Resolution Order
    8. Mixins
    9. Metaclasses
    10. Monkey Patching
    11. Duck Typing
    12. Idioms and Good Practices
  2. SOLID – We discuss SOLID principles that makes code easier to read and maintain. This part is supplemented with exercises showing how to apply (and how not to do this) SOLID in Python. This will be helpful in the second step of each iteration in TDD (as well as BDD), that is writing production code.
  3. Theory of Object Oriented Programming
    1. Four Tenets of OOP: Abstraction, Encapsulation, Polimorphism and Inheritance
    2. Object vs Interface vs Class
    3. Abstract Base Classes
    4. Association vs Aggregation vs Composition vs Inheritance
  4. Introduction to Design Patterns
    1. Classification
    2. Design Patterns Objectives
  5. Creational Patterns
    1. Singleton
    2. Factory Method
    3. Abstract Factory
    4. Prototype
    5. Builder
  6. Structural Patterns
    1. Adapter
    2. Decorator
    3. Composite
    4. Proxy
    5. Facade
    6. Flyweight
    7. Bridge
  7. Behavioral Patterns
    1. Template Method
    2. Strategy
    3. State
    4. Chain of Responsibility
    5. Command
    6. Memento
    7. Observer
    8. Visitor
    9. Mediator
    10. Iterator
Close Menu