PLU | Design Patterns With Python (2016 EN)

Discussion in 'Programming' started by Kanka, Dec 2, 2019.

  1. Kanka

    Kanka Well-Known Member Loyal User

    Messages:
    10,085
    Likes Received:
    261
    Trophy Points:
    83
    [​IMG]

    Company: Pluralsight
    Author: Gerald Britton
    Full Title: Design Patterns With Python
    Year: 2016
    Language: English
    Genre: Educational: Programming
    Skill Level: Intermediate
    Price: -
    -
    Files: MP4 (+ Exercise Files, Subtitles .SRT)
    Time: 01:57:03
    Video: AVC, 1280 x 720 (1.778) at 15.000 fps, 200 kbps
    Audio: AAC at 75 Kbps, 2 channels, 44.1 KHz



    This course will introduce you to eight classic software design patterns and how they can be implemented in Python to help you create programs that are professional, extendable, and maintainable.

    At the core of professional programming practice is a thorough knowledge of software design patterns. In this course, Design Patterns with Python, you will learn eight classic patterns and how to implement them in Python. You will learn how to recognize problems that are solvable using design patterns, how to implement them professionally, and how they can be used to make your programs easier to write, easier to read, and easier to maintain. When you're finished with this course, you will have a better understanding of the elements of reusable object-oriented software design, which will help you as you move beyond simple scripts to complex systems built in Python. Software required: A Python interpreter in the 2.7 series or the 3.5 series and a Python-aware integrated development environment (IDE).


    Lessons:
    1. Course Overview
    01. Course Overview
    2. Introduction to Design Patterns
    02. Overview
    03. What are Design Patterns?
    04. Object-oriented Programming Fundamentals
    05. Interfaces in Python
    3. Design Patterns with Python
    06. Overview and Motivating Example
    07. Demo 1: Initial Attempt
    08. Problems Discovered and Introduction to the Strategy Pattern
    09. Demo 2: Using the Strategy Pattern
    10. Demo 3: Variations
    11. Summary
    4. The Observer Pattern
    12. Overview and Motivating Example
    13. Demo 1: Initial Attempt and Introduction to Wing IDE
    14. Structure of the Observer Pattern
    15. Demo 2: Using the Observer Pattern and One Subtle Bug
    16. Demo 3: Fixing the Bug with Python Context Managers
    17. Summary
    5. The Command Pattern
    18. Overview and Motivating Example
    19. Demo 1: Initial Attempt and Introduction to PyCharm
    20. Structure of the Command Pattern
    21. Demo 2: Using the Command Pattern
    7. The Singleton Pattern
    22. Introduction to Singleton
    23. Demo 1: Logger Example and Introduction to Visual Studio Code
    24. Demo 2: Building a Singleton Base Class
    25. Demo 3: Singleton as a Meta Class
    26. Demo 4: The MonoState Mini-pattern
    27. Summary
    8. The Builder Pattern
    28. Introduction to the Builder Pattern
    29. The Computer Builder: Too Many Parameters!
    30. The Computer Builder: Exposing the Attributes
    31. The Computer Builder: Encapsulation
    32. The Computer Builder: Ordering
    33. Applying the Builder Pattern
    34. Summary
    9. The Factory Pattern
    35. Introduction to the Factory Pattern
    36. Demo 1: Building Car Objects
    37. Demo 2: The Simple Factory Pattern
    38. Demo 3: The Full Factory Pattern
    39. Summary
    10. The Abstract Factory Pattern
    40. Introduction to the Abstract Factory Pattern
    41. Demo 1: Car Manufacturers
    42. Demo 2: The Abstract Factory Pattern
    43. Summary
    11. The Null Pattern
    44. Introduction to the Null Pattern
    45. Demo
    46. Summary
    12. Course Summary
    47. Design Patterns Covered
    48. Summary of Summaries


    -------------
     

Share This Page