万本电子书0元读

万本电子书0元读

顶部广告

Learning Python Design Patterns - Second Edition电子书

售       价:¥

6人正在读 | 0人评论 6.2

作       者:Chetan Giridhar

出  版  社:Packt Publishing

出版时间:2016-02-15

字       数:43.0万

所属分类: 进口书 > 外文原版书 > 电脑/网络

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
Leverage the power of Python design patterns to solve real-world problems in software architecture and designAbout This BookUnderstand the structural, creational, and behavioral Python design patternsGet to know the context and application of design patterns to solve real-world problems in software architecture, design, and application developmentGet practical exposure through sample implementations in Python v3.5 for the design patterns featuredWho This Book Is ForThis book is for Software architects and Python application developers who are passionate about software design. It will be very useful to engineers with beginner level proficiency in Python and who love to work with Python 3.5What You Will LearnEnhance your skills to create better software architectureUnderstand proven solutions to commonly occurring design issuesExplore the design principles that form the basis of software design, such as loose coupling, the Hollywood principle and the Open Close principle among othersDelve into the object-oriented programming concepts and find out how they are used in software applicationsDevelop an understanding of Creational Design Patterns and the different object creation methods that help you solve issues in software developmentUse Structural Design Patterns and find out how objects and classes interact to build larger applicationsFocus on the interaction between objects with the command and observer patternsImprove the productivity and code base of your application using Python design patternsIn DetailWith the increasing focus on optimized software architecture and design it is important that software architects think about optimizations in object creation, code structure, and interaction between objects at the architecture or design level. This makes sure that the cost of software maintenance is low and code can be easily reused or is adaptable to change. The key to this is reusability and low maintenance in design patterns.Building on the success of the previous edition, Learning Python Design Patterns, Second Edition will help you implement real-world scenarios with Python’s latest release, Python v3.5.We start by introducing design patterns from the Python perspective. As you progress through the book, you will learn about Singleton patterns, Factory patterns, and Fa?ade patterns in detail. After this, we’ll look at how to control object access with proxy patterns. It also covers observer patterns, command patterns, and compound patterns.By the end of the book, you will have enhanced your professional abilities in software architecture, design, and development.Style and approachThis is an easy-to-follow guide to design patterns with hands-on examples of real-world scenarios and their implementation in Python v3.5. Each topic is explained and placed in context, and for the more inquisitive, there are more details on the concepts used.
目录展开

Learning Python Design Patterns Second Edition

Table of Contents

Learning Python Design Patterns Second Edition

Credits

Foreword

About the Author

About the Reviewer

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Introduction to Design Patterns

Understanding object-oriented programming

Objects

Classes

Methods

Major aspects of object-oriented programming

Encapsulation

Polymorphism

Inheritance

Abstraction

Composition

Object-oriented design principles

The open/close principle

The inversion of control principle

The interface segregation principle

The single responsibility principle

The substitution principle

The concept of design patterns

Advantages of design patterns

Taxonomy of design patterns

Context – the applicability of design patterns

Patterns for dynamic languages

Classifying patterns

Creational patterns:

Structural patterns

Behavioral patterns

Summary

2. The Singleton Design Pattern

Understanding the Singleton design pattern

Implementing a classical Singleton in Python

Lazy instantiation in the Singleton pattern

Module-level Singletons

The Monostate Singleton pattern

Singletons and metaclasses

A real-world scenario – the Singleton pattern, part 1

A real-world scenario – the Singleton pattern, part 2

Drawbacks of the Singleton pattern

Summary

3. The Factory Pattern – Building Factories to Create Objects

Understanding the Factory pattern

The Simple Factory pattern

The Factory Method pattern

Implementing the Factory Method

Advantages of the Factory method pattern

The Abstract Factory pattern

Implementing the Abstract Factory pattern

The Factory method versus Abstract Factory method

Summary

4. The Façade Pattern – Being Adaptive with Façade

Understanding Structural design patterns

Understanding the Façade design pattern

A UML class diagram

Façade

System

Client

Implementing the Façade pattern in the real world

The principle of least knowledge

Frequently asked questions

Summary

5. The Proxy Pattern – Controlling Object Access

Understanding the Proxy design pattern

A UML class diagram for the Proxy pattern

Understanding different types of Proxies

A virtual proxy

A remote proxy

A protective proxy

A smart proxy

The Proxy pattern in the real world

Advantages of the Proxy pattern

Comparing the Façade and Proxy patterns

Frequently asked questions

Summary

6. The Observer Pattern – Keeping Objects in the Know

Introducing Behavioral patterns

Understanding the Observer design pattern

A UML class diagram for the Observer pattern

The Observer pattern in the real world

The Observer pattern methods

The pull model

The push model

Loose coupling and the Observer pattern

The Observer pattern – advantages and disadvantages

Frequently asked questions

Summary

7. The Command Pattern – Encapsulating Invocation

Introducing the Command pattern

Understanding the Command design pattern

A UML class diagram for the Command pattern

Implementing the Command pattern in the real world

Design considerations

Advantages and disadvantages of Command patterns

Frequently asked questions

Summary

8. The Template Method Pattern – Encapsulating Algorithm

Defining the Template Method pattern

Understanding the Template Method design pattern

A UML class diagram for the Template Method pattern

The Template Method pattern in the real world

The Template Method pattern – hooks

The Hollywood principle and the Template Method

The advantages and disadvantages of the Template Method pattern

Frequently asked questions

Summary

9. Model-View-Controller – Compound Patterns

An introduction to Compound patterns

The Model-View-Controller pattern

Model – knowledge of the application

View – the appearance

Controller – the glue

A UML class diagram for the MVC design pattern

The MVC pattern in the real world

Modules

Benefits of the MVC pattern

Frequently asked questions

Summary

10. The State Design Pattern

Defining the State design pattern

Understanding the State design pattern

Understanding the State design pattern with a UML diagram

A simple example of the State design pattern

The State design pattern with v3.5 implementation

Advantages/disadvantages of the State pattern

Summary

11. AntiPatterns

An introduction to AntiPatterns

Software development AntiPatterns

Spaghetti code

Golden Hammer

Lava Flow

Copy-and-paste or cut-and-paste programming

Software architecture AntiPatterns

Reinventing the wheel

Vendor lock-in

Design by committee

Summary

Index

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部