Python Learning notes Summary (III) class

First, class simple introduction
1. Introduction
Class is the primary tool for Python object-oriented programming (OOP), which creates objects that are defined by class using class statements.
Class and module differences, classes are statements, and modules are files.
Classes and instances
Example: represents the specific element in the program domain.
A class is a factory for a production instance, which is like a record with "data", and a class is a "program" that processes these records.
The class is an instance project, and the properties of the class provide the behavior (data and function [method]), and all instances that are generated from the class inherit the properties of the class.
An instance of a class can pass: an instance. property, instance. Method, gets the properties of the class and the method call. Class supports inheritance, When we use Object.attribute this way for objects produced by class statements, this expression launches the search in Python-Search the object connection tree, search for the subclass to which the object belongs, and then search for multiple superclass inherited by the subclass until it finds the object that attribute first appears.
Super class, subclass. Subclasses inherit the superclass, or they can redefine the superclass's variable names at lower positions in the tree, overriding the behavior of the superclass definition (methods)
class method Invocation, which is the function property attached to the class.
Writing a class tree
Constructs some trees and objects using class statements and class notes. Simple overview:
* Each class statement generates a new class object
* A new instance object is generated each time the class is called
* instances are automatically connected to the class that created the instances
* Class is connected to its superclass by listing the superclass in parentheses in the class header. Their left-to-right order determines the order in the tree.
Class C2:
Class C3:
Class C1 (C2,C3):
....
I1=C1 ()
I2=C2 ()
The example here is multiple inheritance, which means that in the class number, the class has more than one superclass, in Python, if the parentheses in the class statement
There are more than one superclass (like the C1 here), their left-to-right order determines the order of the superclass search.
Properties attached to instances belong only to those instances, but properties attached to the class are shared by all subclasses and their instances.
* Attributes are usually added in class statements through assignment statements, not embedded in the DEF statement of the function.
* Attributes are usually in a class and are added to an instance by assigning a special argument (that is, self) passed to the function. 【*】
class provides behavior for an instance through a function, because such nested DEF assigns a variable name to the class, and the actual effect is to add the attribute to the
Class object, which can be inherited by all instances and subclasses.
>>> class T:
... def setname (self,who):
... self.name=who
...
>>> i1=t ()
>>> i1.setname (' Diege ')
>>> Print I1.name
Diege
First Special parameter: self.
This parameter provides the reference value of the instance being processed.
Because a class is a factory of multiple instances, those methods usually automatically pass in the parameter self whenever you need to remove or set properties for a particular instance that is being processed by a method call.
When a method assigns a value to the Self property, it creates or modifies the property within the instance of the bottom of the class tree, because the automatically references the instance being processed. Self is equivalent to the instance itself.
__init__ Constructor method
In the above example, the T class does not append the name attribute to the instance until the SetName method is called. In fact, invoking i1.setname before referencing I1.name
An undefined variable name error is generated. If a class wants to make sure that a variable name such as name is set in its instance, this property is usually populated at construction time.
>>> class T:
... def __init__ (self,who):
... self.name=who
>>> i1=t (' Diege ')
>>> Print I1.name
Diege
Once written and inherited, Python automatically invokes a method named __init__ each time an instance is generated from the class. The new instance will pass in the self parameter of the __init__ as usual,
Any value that is listed in parentheses becomes the second and subsequent argument. The effect is to initialize the instance when the instance is created, rather than the extra method call.
This does not have to call an additional method implementation before the instance property is obtained, __init__ is quite initialized, the default meaning.
The __init__ constructor method implicitly passes in a new instance, in addition to any parameters that explicitly pass in the name of the class. T (' Diege '), implicitly passed in self (the self represents a new instance)
T (' Diege ') creates a new object (instance object), I1 an assignment statement referencing the object, and obtains the Name property of the object by I1.name.
OOP for code reuse
OOP is code reuse: decomposing code, minimizing the redundancy of the Code, and customizing the current code to write programs rather than modifying the code on the ground or starting from scratch.
2. Basic code Writing
Class supports the generation of multiple objects, inheritance of namespaces, operator overloading
1), class produces multiple instance objects
Two types of objects in the Python OOP model: Class objects and instance objects.
The class object provides the default behavior, which is the factory of the instance object. Instance objects are the actual objects that the program handles: each has a separate namespace. The class object comes as far as the statement, while the instance comes to the call. Each time a class is called, a new instance of the class is obtained.
A, class object provides default behavior
b, the instance object is the concrete element
2), class through inheritance to customize
A, class through inheritance to customize
B, class is a property inside a module
3), class can intercept Python operators

Second, class statement
General form
Class <name> (Superclass,...):
Data=value
def mothod (self,...):
Self.member=value
Within a class statement, any assignment statement produces a class attribute.
Classes are almost namespaces, which are tools that define variable names (attributes) and export data and logic to clients.
How do you get a namespace from a class statement? The process is as follows.
Just like a module file, a statement in the body of a class statement establishes a property. When Python executes the class statement (not the calling class)
All statements within its principal are executed from beginning to end. In this process, the assignment operation creates the variable name in the scope of the class, which becomes the corresponding
The properties in the class object. Because, classes are like modules and functions:
* Just like a function. The class statement is scoped, and the variable name is created by an embedded assignment statement, which exists within the local scope.
* Just like the variable name within the module, the variable name that is assigned within the class statement becomes a property in the class object.
Class is a compound statement, and any kind of statement can be in its body: print, =,if,def, and so on. When the class statement itself runs, all of the classes within the class statement
Statement executes. Variable names that are assigned within a class statement create class properties, while inline DEF statements create class methods, and other assignment statements can also make properties.
Class Top-level assignment statements define properties that can be used to manage information across all instances.
Third, the method
method calls need to pass through an instance, typically called by an instance.
Instance.method (Arg ...)
This is automatically translated into the following form of the class method function call:
Class.method (Instance,args ...)
Class inherits the search process through Python to find out where the method name resides.
The first argument of a class method is often called self. This parameter provides a hook for the method, which returns the principal of the call, that is, the instance object:
The first argument self needs to be clear
The existence of this variable name will let you make it clear that the script uses the instance property name instead of the variable name in the local scope or global scope
1. Call the constructor of super class
As with other properties, the ___init__ method is found by inheritance. In other words, when constructed, Python will find and invoke only one __init__ (the lowest of the tree). If you want to ensure that the constructor of the subclass also executes the logic of the superclass constructor (enabling the superclass's build code), it is generally necessary to manually explicitly call the superclass's __init__ method through the subclass (called by the superclass name name, manually passed to the self instance: superclass.__init__ ( Self,...) )。
Class Super:
def __init__ (self,x):
.... Default code ...
Class Sub (Super):
def __init__ (self,x,y):
Super.__init__ (self,x) # # #还是有用到的地方.
... custom code ...
If you really want to run the constructor of the superclass and make the appropriate modifications, you can only call it this way: Without such a call, the subclass would completely replace (overwrite) the superclass's constructor, or the subclass would completely inherit the superclass's constructor method without setting the __init__ constructor (__init__ Method is also inherited).
2, the other method calls possible.
This pattern of invoking a method through a class (a method that calls a class in a class (not necessarily its own)) is an extension of the inherited method behavior (rather than a complete substitution).
3. Inheritance
Namespace tools like class statements focus on supporting variable name inheritance. This extends some of the mechanisms and roles for property inheritance. In Python, inheritance occurs when you perform a point-number operation on an object, and it involves a search property definition tree (one or more namespaces). Each time an expression in obecj.attr form is used (OBJECJ is an instance or class object), Python searches the namespace tree from beginning to end, starting with the object and finding the first attr. This includes a reference to the Self property in the method. Because a lower definition in a tree overrides a higher definition, inheritance forms the basis of exclusivity.
4. Construction of attribute Tree
namespace tree constructs and the way in which variable names are filled, usually:
The "*" Instance property is generated by an assignment operation to the Self property within the method.
The "*" Class property is generated from the top-level statement (Assignment statement) in the class statement.
The "*" hyperlink is generated by listing classes in parentheses in the first line of the class statement.
5. Appropriation of inheritance Method-overload-callback
The inheritance tree search pattern becomes the best way to make the system proprietary. Because inheritance first looks for the variable name in the subclass and then finds the superclass, the subclass can redefine the properties of the superclass to replace the default behavior. The system is made into the class hierarchy, and then the external subclass is added to extend it, instead of modifying the existing logic in place.
The concept of redefining inherited variable names leads to a variety of proprietary techniques.
Callback techniques are used when subclasses redefine a method and call the same method of superclass to implement some of the functions of this subclass method.
This implements the default behavior, in other words, Sub.mothod only expands the behavior of Super.mothod, rather than completely replacing him.
6. Abstract class
An abstract class is a class that invokes a method, but does not inherit or define the method, but rather expects the method to be filled by subclasses. When the behavior is unpredictable, you have to wait until the more specific subclass is written, and you can generalize the class in this way. This "blank" code structure is generally the framework of OOP software. From the point of view of the delegate method, the superclass in this example is sometimes referred to as an abstract class-that is, the partial behavior of a class is provided by its subclasses by default. If the expected method is not defined in the subclass, when the inheritance search fails, Python throws an exception for the definition, variable name. The writer of the class occasionally uses an Assert statement to make the seed class more obvious or to throw a built-in exception notimplementederror
Class Super:
Def method (self):
Print "in Super.method"
def delegate (self):
Self.action ()
Class Provider (Super):
def action (self):
Print "in Provider.method"
The class has a special attribute __name__ class name, just like the module has the name of the __name__ property module. Class, a string that defaults to the class name in the line of the class header.
Four, operator overloading
Key concepts of overloading
* Operator overloading allows the class to intercept regular Python operations.
* Class can overload all Python expression operations.
* Classes can be overloaded with printing, function calls, attribute point number operations, and so on.
* Overloading makes a class instance behave like a built-in type.
* Overloads are implemented by providing a class method that provides a special name.
If the class provides methods for some special names, Python automatically calls these methods when the class instance appears in an expression about the operation.
1. Common operator overloading methods
Method overload Call
__init__ constructor Method Object establishment: X=class ()
__del__ destructor Method Object retraction
__add__ operator + x+y,x+=y
__sub__ operator-X-y,x-=y
__OR__ operator |    (bit or) X| Y x|=y
__repr__,__str__ printing, converting print X "__str__", repr (x), str (x)
__call__ function call X ()
__getattr__ Point number Operation x.undefined
__setattr__ Property Assignment Statement X.any=value
__GETITEM__ index Operation X[key], for loops and other iterators without __iter__
__SETITEM__ Index Assignment Statement X[key]=value
__len__ length Len (X), Truth test
__cmp__ comparison X==y,x
__lt__ Specific comparison x<y (or else __cmp__)
__eq__ Specific comparison x==y (or else __cmp__)
__radd__ Left add + noninstance + X
__iadd__ field (Enhanced) addition x+=y (or else __add__)
__ITER__ iterative environment for loops, tests, lists, mappings, and more
The names of all overloaded methods have two underscore characters before and after them, so that the variable names defined in the same class are distinguished from each other. The mapping of a particular method name to an expression or an operation is predefined by the Python language.
All operator overloading methods are selected: If a method is not written, the defined class does not support the operation. Most overloaded methods are used only in high-level programs that require objects to behave as if they were built-in functions. However, the __init__ construction method often appears in most classes.
__GETITEM__ Intercept Index operations
The __getitem__ method intercepts the index operation of the instance. When instance x appears in an index operation such as X[i], Python invokes the __getitem__ method inherited by this instance.
(if any), the X is passed as the first argument, and the index value within the parentheses is passed to the second argument
2, __iter__ and _getitem__ implementation iterations
The For loop is performed from 0 to a larger index value, and the sequence is repeatedly indexed until an out-of-bounds exception is detected.
__getitem__ can also be a way of overloading iterations in Python, and if this method is defined, the for loop invokes the class's __getitem__ each time it loops
Any class that supports a for loop also automatically supports all of Python's iterative environments, including member relationship test in, list parsing, built-in function map, list and tuple assignment operations, and type construction methods that automatically call __GETITEM__ (if defined). Today, all iteration environments in Python try the __iter__ method first, and then try to __getitem__. If an object does not support an iterative protocol, an index operation is attempted.
From a technical point of view, the iterative environment is implemented by invoking the built-in function iter to try to find the __iter__ method, and this method should return an iterator object.
If provided, Python repeats the next method of invoking the iterator object until the stopiteration exception occurs. If the __iter__ method is not found
, Python uses the __getitem__ mechanism to repeat the index by offset as before, until the Indexerror exception is thrown.
The iterator object is the instance self, because the next method is part of the class. In more complex scenarios, iterator objects can be defined as individual classes or objects, have their own state information, and support multiple iterations of the same data. Signaled by the Python raise statement that the iteration ended. The __iter__ object explicitly preserves state information during the call. So the versatility is more specific than __getitem__. __iter__ iterators are more complex and difficult to use than __getitem__. Iterators are used to iterate, not random, index operations. In fact, the iterator does not overload an index expression at all.
The __iter__ mechanism is the implementation of all other iterative environments seen in __getitem__ (membership testing, type constructors, sequence assignment operations). Unlike __getitem__, the __iter__ loops only once, not multiple times, and then becomes empty after the loop, creating a new iterator object each time a new loop is created.
3. Other common operator overloads
__del__ is the destructor
Whenever an instance is generated, the __init__ constructor method is called whenever the instance space is retracted to execute the __del__ method
__SETATTR__ will intercept all assignment statements, usually not.
__repr__,__str__ printing, converting print X, repr (x), str (x)
__call__ Intercept Call: If defined, Python will run the __call__ method for the instance by applying a function call expression.
When you need to write an interface for a function's API, __call__ becomes very useful: this can be written to follow the required function to invoke the interface object.
Iv. namespaces: The full content
The dot and no-dot variables are handled in different ways, and some scopes are used to initialize the object namespace.
* The variable name (for example, X) of the no-dot operation corresponds to the scope
* The attribute name of the dot, such as object. X) uses the namespace of the object.
* Some scopes Initialize objects ' namespaces (modules and classes)
1, simple variable name: If the assignment is not a global variable
A simple operation name without a dot follows the function legb scope rule:
Assignment Statement (x=value)
Make variable name local variable: Creates or alters the variable name x within the current scope unless it is declared to be a global variable. An assignment statement, such as within a function.
Reference (X)
Searches for the variable name x within the current scope, followed by any and all nested functions, then searches in the current global scope, and finally in the built-in scope.
2. Attribute name: Object namespace
The attribute name of a point number refers to the properties of a particular object and follows the rules of the module and class. In terms of class and instance objects, reference rules increase the process of inheriting the search.
An assignment statement (object. X=value)
The property name X is created or modified within the namespace of the object that performed the dot operation, and has no other effect. A search for an inheritance tree occurs only when a property reference is not a property assignment operation
Reference (object. X
In the case of class-based objects, the property name x is searched within the object, followed by all the readable classes on it (using the inheritance search process). For objects that are not class-based, such as modules, the X is read directly from the object (possibly attributes include, variable name, function, Class).
3. Namespaces: Assigning locations to classify variable names
In Python, the place to assign variable names is quite important: this completely determines the scope or object in which the variable name resides. The example summarizes the concept of namespaces.
# Vim manynames.py
x=11 #模块属性 Global
def f ():
There is no x in the print x #函数 (local) scope, the nested function does not have an X variable, and the current global scope (within the namespace of the module) has, showing the global
def g ():
X=22 #定义本地作用域变量X
Print x #搜索函数 (local) in-scope variable X, with printing
Class C:
X=33 #定义的类属性, Class namespace
def m (self):
X=44 #貌似在这里没有什么意义
Self. X=55 #定义类实例的属性, Instance namespace
If __name__== ' __main__ ':
Print X #打印模块属性 Results 11
F () #调用f (), F () returns the module global variable x 11
G () #调用g (), g () returns the local variable x 22 in the function
Print X #打印 module global variables, module properties 11

Obj=c () #调用类的方法产生实例
Print obj. X #打印实例的属性X x inherits the properties of the class, so it is 33

OBJ.M () #实例调用类的m方法,
Print obj. X #显示这个X属性 because the previous step m method sets the instance's attribute x to 55
# python manynames.py
11
11
22
11
33
55
Scopes are always determined by the location of the assignment statements in the source code and are never affected by their import relationships. A property is like a variable that is not present until the value is assigned.
Rather than before the assignment. Typically, you create an instance property by assigning a value within the class's __init__ constructor method.
In general, you should not let each variable use the same variable name within the script.
4. Namespace Dictionaries
The namespace of the module is actually implemented in the form of a dictionary and can be shown by the built-in property __dict__. The same is true for class and instance objects: attribute point number operations
The interior of the dictionary is the index operation, and attribute inheritance is actually a dictionary of search links. In fact, instances and class objects are just a dictionary of links in Python.
>>> class Super ():
... def hello (self):
... self.data1= ' Diege '
...
>>> class Sub (Super):
... def hola (self):
... self.data2= ' eggs '
...
When you make an instance of a subclass, the instance begins with an empty namespace dictionary, but a link points to its class, allowing the inheritance search to follow.
In fact, the inheritance tree can be seen in special properties that you can view. The instance has a __class__ property linked to its class, and the class has a __base__ property.
is the tuple, which contains connections to higher classes of superclass.
>>> X=sub ()
>>> x.__dict__
{}
>>> x.__class__
<class __main__. Sub at 0x2850353c>
>>> Y=super ()
>>> y.__dict__
{}
>>> y.__class__
<class __main__. Super at 0x285034ac>
>>> sub.__bases__
(<class __main__. Super at 0x285034ac>,)
>>> super.__bases__
()
When a class assigns a value to the Self property, it fills in the instance object. That is, the property ends up in the instance's property namespace dictionary, not the class.
The namespace of the instance object holds the data, which varies with the instance, and self is the hook into its namespace.
>>> Y=sub ()
>>> X.hello ()
>>> x.__dict__
{' data1 ': ' Diege '}
>>> X.hola ()
>>> x.__dict__
{' data1 ': ' Diege ', ' data2 ': ' Eggs '}
>>> sub.__dict__
{' __module__ ': ' __main__ ', ' __doc__ ': None, ' Hola ': <function hola at 0x284954c4>}
>>> super.__dict__
{' __module__ ': ' __main__ ', ' hello ': <function hello at 0x28495f0c>, ' __doc__ ': None}
>>> Sub.__dict__.keys (), Super.__dict__.keys ()
([' __module__ ', ' __doc__ ', ' Hola '], [' __module__ ', ' hello ', ' __doc__ '])
>>> y.__dict__
{}
Y is the 2nd instance of this class. The dictionary of Instant X has been populated with assignment statements within the method, and Y is also an empty namespace dictionary. Each instance has a separate namespace dictionary, one that is empty at first, and can be logged and the other instances of the same class in the namespace dictionary properties, completely different properties.
Because the property is actually a Python dictionary key, there are two ways to read it and assign it: by a point number, or by a key index operation.
>>> x.data1,x.__dict__[' data1 ']
(' Diege ', ' Diege ')
>>> x.data3= ' Lily '
>>> x.__dict__
{' data1 ': ' Diege ', ' data3 ': ' Lily ', ' data2 ': ' Eggs '}
>>> dir (X)
[' __doc__ ', ' __module__ ', ' data1 ', ' data2 ', ' data3 ', ' hello ', ' Hola ']
>>> dir (Sub)
[' __doc__ ', ' __module__ ', ' hello ', ' Hola ']
>>> dir (Super)
[' __doc__ ', ' __module__ ', ' hello ']
Assigning a value to an instance affects only the instance and does not affect the class and superclass of the instance
5. Namespace Connection
__class__ and __bases__ These properties allow you to view the inheritance hierarchy within your program code. You can use him to show the class tree.

V. Class design
1. Python and OOP
Python and OOP implementations can be summarized as three concepts.
Inherited
Inheritance is based on property lookups in Python (in x.name expressions)
Polymorphic
In X.method methods, the meaning of method depends on the type of X (Class)
Packaging
Method and operator implementation behavior, data hiding by default is a convention
Class and inheritance: is a "one" relationship (is a)
From the programmer's point of view, inheritance is initiated by the attribute point number operation, which triggers the search for the variable names in the instance, class, and any superclass.
From the designer's point of view, inheritance is a way of defining a collection's membership: A class defines a set of content properties that can be inherited and customized by a more specific collection (subclass).
The inheritance of subclasses and superclass is a 1-to-1 relationship
Classes and combinations: "Have a" relationship (has a)
From the programmer's point of view, the composition is designed to embed other objects inside the container object and implement the Container method.
For designers, a combination is another way to represent a relationship in a problem domain.
But a combination is not a member of a collection, but a component, and a part of the whole.
The combination also reflects a relationship between components, often referred to as "having a" relationship. In Python, a "combination" (aggregation) refers to an inline object collection body.
Class and sustainability
Sustainability: Keep the data persistent, save the data in a file or database, and keep it.
The pickle and shelve modules and class instances work well together and are stored on the hard disk in a single step.
The pickle mechanism converts an in-memory object into a serialized byte stream, which can be saved in a file.
The shelve automatically pickle the object to generate the key read database, and this database exports a dictionary-like interface.
Pickle
>>> pickle.dump (obj.server,file) #写入
>>> objread=pickle.load (file) #读取
Shelve
>>> dbase=shelve.open (' datafile ')
>>> dbase[' key ']=obj.server write
>>> shtest=shelve.open (' datafile ')
>>> shtest[' name '] #读取 \
2. OOP and delegation
The so-called delegate, usually refers to the controller object embedded other objects, and the operation request to those objects. The controller is responsible for the management work.
In Python, a delegate is usually implemented as a __getattr__ hook method, because this method intercepts the read of a nonexistent property, and the wrapper class (the proxy Class) can use __getattr__ to forward any read to the wrapped object. The wrapper class package has an interface that is included with the object. And you can also add other operations.
Class wrapper:
def __init__ (Self,object):
Self.wrapped=object
def __getattr__ (self,attrname): #__getattr__点号运算, here overloads the built-in GetAttr method to print the method that passed in to the class and pass the property request to the object, using the object's default method. Commissioned
print ' Trace: ', attrname
Return GetAttr (Self.wrapped,attrname)
3. Multiple inheritance
In the class statement, more than one superclass can be listed in the first line of parentheses. When you do this, you are using so-called multiple inheritance: classes and their instances inherit the variables of all the superclass listed. When searching for properties, Python searches from left to right for the superclass in the first row of the class until the match is found.
In general, multiple inheritance is a good way to simulate objects that belong to more than one set, such as a person who can be an engineer, a writer, or a musician. Because, you can inherit the attributes of these collections.
The most common user of multiple inheritance is a common method for "mixed" superclass. These types of superclass are generally called mixed classes: They provide methods that can be added to the application class by inheritance.
Each instance has a built-in __class__ property that references the class it inherits from, and each class has a __name__ property that uses the variable name in the first row, so self.__class__.__name__ is the name of the class that takes out the instance
>>> x.__class__.__module__
' Trac '
>>> x.__module__
' Trac
Instead, use self.__module__ or self.__class__.__module__ to remove the name of the instance reference module.
4. Class is the object: The factory of the generic object
A class is an object, so it can be easily passed in a program and saved in a database structure. You can also pass a class to a function that produces any kind of object. Such functions are occasionally called factories in the field of OOP design.
Factory-style functions or program code are handy in some cases because they allow us to remove and pass in classes that are not hardcoded in the program code beforehand. In fact, these classes may not yet exist when writing programs. Abstract class.
>>> def factory (Aclass,*args):
... return apply (Aclass,args)
...
This defines an object generator function called factory. It expects to pass in a class object (any object is a row) and one or more parameters of the class constructor. This function uses apply to call the function and return the instance.
5. Method is object: bound or unbound
A method is also an object, much like a function. Class methods can have instances or classes to read. In fact, there are two ways of Python.
Unbound class Method object: No self
The Unboud method object is passed back by the operation of the class by a number of points to obtain the function properties of the class. When the method is called, the instance object must be explicitly provided as the first parameter.
To bind an instance method object:
The self+ function returns a bound (bound) method object by using the full operation of the instance to get the function properties of the class. Python automatically hits instances and functions in the binding method object
Package, so you do not have to pass the instance to invoke the method. Instance already owns the method.
Both of these methods are full-featured objects that can be passed around, remain in the list, and so on. Both require an instance of the first parameter (that is, the value of self) when executing.
6. Classes and modules
It's all namespaces.
Module
* is a data/logic suite
* Written by Python file or C extension
* By importing using
Class
* Implementation of new objects
* Created by class statement
* by calling Use
* Always present in the module.
class supports features not supported by other modules. For example, operator overloading, producing multiple instances, and inheritance.

Python Learning notes Summary (III) class