Item 22: Prefer Helper Classes Over Bookkeeping with Dictionaries and Tuples
- Avoid making dictionaries with values that are other dictionaries or long tuples;
- Use namedtuple for lightweight, immutable data containers before you need the flexibility of a full class;
- Move your bookkeeping code to use multiple helper classes when your internal state dictionaries get complicated;
- Avoid making dictionaries with values that are other dictionaries or long tuples;
Item 23: Accept Functions for Simple Interfaces Instead of Classes
- Instead of defining and instantiating classes, functions are often all you need for simple interfaces between components in Python;
- References to functions and methods in Python are first class, meaning they can be used in expressions like any other type;
- The __call__ special method enables instances of a class to be called like plain Python functions;
- When you need a function to maintain state, consider defining a class that provides the __call__ method instead of defining a stateful closure.
Item 24: Use @classmethod Polymorphism to Construct Objects Generically
- Python only supports a single constructor per class, the __init__ method;
- Use @classmethod to define alternative constructors for your classes；
- Use class method polymorphism to provide generic ways to build and connect concrete subclasses.
Item 25: Initialize Parent Classes with super
- Python’s standard method resolution order (MRO) solves the problems of superclass initialization order and diamond inheritance;
- Always use the super built-in function to initialize parent classes.
Item 26: Use Multiple Inheritance Only for Mix-in Utility Classes
- Avoid using multiple inheritance if mix-in classes can achieve the same outcome;
- Use pluggable behaviors at the instance level to provide per-class customization when mix-in classes may require it;
- Compose mix-ins to create complex functionality from simple behaviors.
Item 27: Prefer Public Attributes Over Private Ones
- Private attributes aren’t rigorously enforced by the Python compiler;
- Plan from the beginning to allow subclasses to do more with your internal APIs and attributes instead of locking them out by default;
- Use documentation of protected fields to guide subclasses instead of trying to force access control with private attributes;
- Only consider using private attributes to avoid naming conflicts with subclasses that are out of your control.
Item 28: Inherit from collections.abc for Custom Container Types
- Inherit directly from Python’s container types (like list or dict) for simple use cases;
- Beware of the large number of methods required to implement custom container types correctly;
- Have your custom container types inherit from the interfaces defined in collections.abc to ensure that your classes match required interfaces and behaviors.
Effective Python(3): Classes and Inheritance
原文：http://www.cnblogs.com/luckysimple/p/5176897.html
