Isinstance and Issubclass
Isinstance (obj,cls) checks if obj is an object of class CLS
Class Foo (object): passobj = Foo () print (Isinstance (obj, Foo)) # True
Issubclass (sub, super) check if the sub class is a derived class of super class
Class Foo (object): passclass Bar (Foo): passprint (Issubclass (Bar,foo)) # True
Two secondary processing standard type (packing)
Packaging: Python provides standard data types and a rich set of built-in methods, but in many scenarios we need to customize our own data types based on standard data types.
New/rewritten method, which uses the inheritance/derivation knowledge we just learned (other standard types can be processed two times in the following way)
Class List: #继承list所有的属性, you can also derive your own new, such as Append and mid def append (self,p_object): if Isinstance (P_object, int): raise TypeError (' must is int ') super (). Append (p_object) @property def mid (self): ' Add your own property ' index = len (self)//2 return self[index]l=list ([1,2,3,4]) print (L) l.append (5) print (L) # l.append (' 1111111 ') #报错, the Int type print (L.MID) must #其余的方法都继承list的l. Insert (0,-123) print (L) l.clear () print (L)
__getattr__ and __getattribute__
Object.__getattr__ (self, name)
When attribute is not found in the general position, GetAttr is called, returning a value or Attributeerror exception.
Import Timeclass filehandle: def __init__ (self,filename,mode= ' R ', encoding= ' Utf-8 '): Self.file=open ( filename,mode,encoding=encoding) def write (self,line): t=time.strftime ('%y-%m-%d%T ') Self.file.write ('%s%s '% (t,line)) def __getattr__ (self, item): print (' Execute __getattr__item%s '%item) Return GetAttr (Self.file,item) f1=filehandle (' B.txt ', ' w+ ') f1.write (' Hello ') f1.seek (0) # Execute __getattr__item seekprint ( F1.read ()) # executed __getattr__item read 2018-06-11 21:04:32 Hello F1.close () # Execute __getattr__item Close
F1.xxxxxx #不存在的属性访问, triggering __getattr__
object.__getattribute__ (self, name)
is called unconditionally, accessing properties through an instance. If __getattr__ () is defined in class, __getattr__ () is not called (unless the call is displayed or the Attributeerror exception is thrown)
Class Foo: def __init__ (self,x): self.x=x def __getattribute__ (self, item): print (' I'll do it regardless of whether it exists) ' F1=foo (f1.x) # no matter if it exists, I will execute the f1.xxxxxx # no matter if it exists, I will execute it
Both appear
Class Foo: def __init__ (self,x): self.x=x def __getattr__ (self, item): print (' Executed by Me ') # return Self.__dict__[item] def __getattribute__ (self, item): print (' I will do whatever it is ') raise Attributeerror (' Haha ') f1=foo () f1.xf1.xxxxxx#------output-----------No matter whether it exists or not, I will execute the execution is I regardless of existence, I will execute is I # when __getattribute__ and __ GETATTR__ exists at the same time, only __getattrbute__ is executed unless __getattribute__ throws an exception during execution Attributeerror
Descriptor (__GET__,__SET__,__DELETE__)
What is the 1 descriptor: The descriptor is essentially a new class, in which at least one of the __get__ (), __set__ (), __delete__ () is implemented, which is also known as the Descriptor Protocol __get__ ():
When a property is called, __set__ () is triggered: When a property is assigned a value, __delete__ () is triggered when the property is deleted with Del
Define a descriptor
#_ *_coding:utf-8_*___author__ = ' Linhaifeng ' class Foo: #在python3中Foo是新式类, it implements three methods, this class is called a descriptor def __get__ (self , instance, owner): Pass def __set__ (self, instance, value): pass def __delete__ (self, Instance): Pass
What is a 2 descriptor for: The function of the descriptor is to proxy the properties of another class (the descriptor must be defined as a class attribute of the class and cannot be defined in the constructor)
Intro: the instance generated by the Descriptor class performs property operations and does not trigger execution of three methods
Class Foo: def __get__ (self, instance, owner): print (' Trigger get ') def __set__ (self, instance, value): Print (' trigger set ') def __delete__ (self, Instance): print (' trigger delete ') #包含这三个方法的新式类称为描述符, the invocation/assignment/deletion of the property by the instance generated by this class , and does not trigger these three methods F1=foo () f1.name= ' Egon ' F1.namedel f1.name# doubt: When, where, will trigger the execution of these three methods
Descriptor application
#描述符Strclass str:def __get__ (self, instance, owner): print (' Str call ') def __set__ (self, instance, value): Print (' str settings ... ') def __delete__ (self, Instance): Print (' str delete ... ') #描述符Intclass int:def __get__ (self, instance, owner): print (' Int call ') def __set__ (self, instance, value): Print (' int set ... ') def __delete__ (self, Instance): print (' int delete ... ') class People:name=str () Age=int () def __init__ (self,name,age): #name被Str类代理, age is represented by int class, Self.name=name self.age=age# where? : A class attribute that is defined as another class # when? : And see the following demo p1=people (' Alex ') #描述符Str的使用p1. Namep1.name= ' Egon ' del p1.name# descriptor int using P1.agep1.age=18del p1.age# Let's just look at what happened. Print (p1.__dict__) print (people.__dict__) #补充print (Type (p1) = = people) #type (obj) is to see which class the obj is instantiated by, print (Type p1). __dict__ = = people.__dict__) # Output str settings ... int set ... STR calls STR settings ... STR delete ... int calls int setting ... int delete ... {} {' __module__ ': ' __main__ ', ' name ': <__main__. Str object at 0x0000000014b0a470>, ' age ': <__main__. Int objECT at 0x0000000014b0a7b8>, ' __init__ ': <function people.__init__ at 0x0000000014b2e1e0>
' __dict__ ': <attribute ' __dict__ ' of ' people ' objects>, ' __weakref__ ': <attribute ' __weakref__ ' of ' People ' Obje Cts>, ' __doc__ ': none}truetrue
Descriptor uses
As we all know, Python is a weakly typed language, that is, there are no type restrictions on the assignment of parameters, and we implement the type limiting function by descriptor mechanisms.
class typed:def __init__ (self,name,expected_type): Self.name=name Self.expected_type=expected_type def __get__ (self, instance, owner): print (' Get---> ', instance,owner) If instance is None:return self return instance.__dict__[self.name] def __set__ (self, instance, Valu E): Print (' Set---> ', instance,value) if not isinstance (value,self.expected_type): Raise Typeerr Or (' expected%s '%str (Self.expected_type)) Instance.__dict__[self.name]=value def __delete__ (self, Instance): Print (' Delete---> ', instance) Instance.__dict__.pop (Self.name) class people:name=typed (' name ', str) age =typed (' name ', int) salary=typed (' name ', float) def __init__ (self,name,age,salary): Self.name=name self. Age=age self.salary=salary# P1=people (123,18,3333.3) # p1=people (' Egon ', ' ', 3333.3) p1=people (' Egon ', 18,3333)
Decorator for class: no reference
def decorate (CLS): print (' class adorners start running------> ') return cls@decorate #无参:P eople=decorate (People) class People: def __init__ (self,name,age,salary): self.name=name self.age=age self.salary=salaryp1= People (' Egon ', 18,3333.3)
Decorator for class: parametric
def typeassert (**kwargs): def decorate (CLS): print (' class adorner starts running------> ', Kwargs) return CLS Return Decorate@typeassert (name=str,age=int,salary=float) #有参: 1. Run the Typeassert (...) The returned result is decorate, at which point the parameters are passed to Kwargs 2.people=decorate (People) class people: def __init__ (self,name,age,salary): Self.name=name self.age=age self.salary=salaryp1=people (' Egon ', 18,3333.3)
Implemented through reflection and adorners
Class Typed:def __init__ (self,name,expected_type): Self.name=name self.expected_type=expected_type de F __get__ (Self, instance, owner): print (' Get---> ', instance,owner) If instance is None:return Self return instance.__dict__[self.name] def __set__ (self, instance, value): Print (' Set---> ', instance, Value) if not Isinstance (value,self.expected_type): Raise TypeError (' expected%s '%str (Self.expected_typ e) Instance.__dict__[self.name]=value def __delete__ (self, Instance): print (' Delete---> ', instance) Instance.__dict__.pop (Self.name) def typeassert (**kwargs): Def decorate (CLS): Print (' class decorators start running------> ', K Wargs) for Name,expected_type in Kwargs.items (): SetAttr (cls,name,typed (name,expected_type)) Retu RN CLS return Decorate@typeassert (name=str,age=int,salary=float) #有参: 1. Run Typeassert (...) The returned result is decorate, at which point the parameters are passed to Kwargs 2.people=decorate (people) CLPeople:def __init__ (self,name,age,salary): Self.name=name self.age=age Self.salary=salaryprin T (people.__dict__) p1=people (' Egon ', 18,3333.3)
__setitem__,__getitem__,__delitem__
Class Foo: def __init__ (self,name): self.name=name def __getitem__ (self, item): Print (self.__dict_ _[item]) def __setitem__ (self, Key, value): self.__dict__[key]=value def __delitem__ (self, key): Print (' del Obj[key], I execute ') self.__dict__.pop (key) def __delattr__ (self, item): print (' Del Obj.key, I execute ') Self.__dict__.pop (item)
#通过字典方式访问f1 =foo (' sb ') f1[' age ']=18f1[' age1 ']=19del f1.age1del f1[' age ']f1[' name ']= ' Alex ' Print (f1.__dict__)
__str__,__repr__,__format__
Changing the object's string display __str__,__repr__
Self-Customizing formatted string __format__
format_dict={' nat ': ' {obj.name}-{obj.addr}-{obj.type} ', #学校名-school address-school type ' TNA ': ' {obj.type}:{obj.name}:{obj.addr} ', # School Type: School name: School address ' tan ': ' {obj.type}/{obj.addr}/{obj.name} ', #学校类型/school address/School name}class school:def __init__ (SELF,NAME,ADDR, Type): Self.name=name self.addr=addr self.type=type def __repr__ (self): Return ' School (%s,% s) '% (SELF.NAME,SELF.ADDR) def __str__ (self): return ' (%s,%s) '% (SELF.NAME,SELF.ADDR) def __format__ (self, fo RMAT_SPEC): # If Format_spec if not format_spec or Format_spec not in format_dict:format_spec= ' n At ' Fmt=format_dict[format_spec] return Fmt.format (obj=self) s1=school (' oldboy1 ', ' Beijing ', ' private ') print (' from repr: ', repr (S1)) print (' From str: ', str (S1)) print (S1) # call __str__#-----Output Result-----------# from Repr:school (oldboy1, Beijing) # from S TR: (Oldboy1, Beijing) # (oldboy1, Beijing) ' str function or print function--->obj.__str__ () repr or interactive interpreter--->obj.__repr__ () if __str__ is not defined, then the __repr__ is used instead of the output note: The return value of both methods must be a string, noThe exception ' Print (Format (S1, ' Nat ')) print (Format (S1, ' TNA ')) print (Format (S1, ' Tan ')) #----- Output-----------oldboy1-BEIJING-Private private: oldboy1: Beijing private/Beijing/oldboy1
Slots
What is 1.__slots__: A class variable, a variable value can be a list, a tuple, or an iterative object, or a string (meaning that all instances have only one data attribute) 2. Introduction: Using points to access attributes is the __dict__ property dictionary that accesses a class or object ( The dictionary of the class is shared, and each instance is independent) 3. Why use __slots__: A dictionary consumes a lot of memory, if you have a class with very few attributes, but there are many instances, in order to save memory you can use __slots__ to replace instances of __dict__ when you define __slots After __, __SLOTS__ will use a more compact internal representation for the instance. Instead of defining a dictionary for each instance, the instance is constructed from a small, fixed-size array, similar to a tuple or list. The attribute names listed in __slots__ are internally mapped to the specified small label for this array. A bad place to use __slots__ is that we can no longer add new properties to the instance, only those that are defined in __slots__. 4. Note: Many of the features of __slots__ depend on common dictionary-based implementations. In addition, classes that define __SLOTS__ no longer support some common class features, such as multiple inheritance. In most cases, you should only define __slots__ on classes that are often used as data structures, such as millions of instance objects in a program that need to create a class. A common misconception about __slots__ is that it can be used as an encapsulation tool to prevent users from adding new properties to an instance. Although the use of __slots__ can achieve this goal, but this is not its original intention. More is used as a memory optimizer tool. "' f1=student () F1.name = ' Al ' # Binding property ' name ' F1.age = 2 # binding attribute ' age ' Print (f1.__slots__) # F1 no longer have __dict__print (f1.__dict__) # Error F1.score = 99 # Error class Student: __slots__=[' name ', ' Age ']f1=student () f1.name= ' Alex ' F1.age=18print (f1.__slots__) # [' Name ', ' Age ']f2=student () f2.name= ' Egon ' F2.age=19print (f2.__slots__) # [' Name ', ' Age ']print (student.__dict__) #f1与f2There is no attribute dictionary __dict__, unified return to __slots__ tube, save memory
__next__ and __iter__ implementing an iterator protocol
Simple analog range, plus step
Class Range: def __init__ (self,n,stop,step): self.n=n self.stop=stop self.step=step def __ Next__ (self): if SELF.N >= self.stop: raise stopiteration X=SELF.N self.n+=self.step return X def __iter__ (self): return selffor i in Range (1,7,2): # print (i)
Fibonacci sequence
Class Fib: def __init__ (self,x): self._a=0 self._b=1 self.x = x self.n = 0 def __iter__ (self) : return self def __next__ (self): if SELF.N >= self.x: raise Stopiteration self._a,self._b= Self._b,self._a + self._b SELF.N + = 1 return Self._af1=fib () print (f1.__next__ ()) print (Next (F1)) while True: Try: print (Next (F1)) except stopiteration: Pass
__doc__
The description of the class, which cannot be inherited
Class Foo: ' I am description info ' passclass Bar (Foo): passprint (foo.__doc__) # I am description message print (bar.__doc__) # None This property cannot be inherited to subclasses
__module__ and __class__
__MODULE__ represents the object of the current operation in that module
__CLASS__ represents the class of the object that is currently being manipulated
Class C: def __init__ (self): self.name = ' Alex ' obj = C () print (obj.__module__) # output __main__, i.e.: Output module print ( obj.__class__) # output <class ' __main__. C ';, i.e.: Output class
__del__
destructor, which automatically triggers execution when the object is freed in memory.
Note: If the resulting object is just a Python program-level (user-level), then there is no need to define __del__, and if the resulting object will also initiate system calls to the operating system,
That is, if an object has both user-level and kernel-level resources, such as (opening a file and creating a database link), the system resource must be reclaimed while the object is purged, which is __del__.
Class Foo: def __del__ (self): print (' Execute Me ') F1=foo () del f1print ('-------> ') #输出结果执行我啦------->
__enter__ and __exit__
We know we can write this when we manipulate the file object.
With open (' a.txt ') as F: ' code block '
The above is called the context Management Protocol, the WITH statement, in order for an object to be compatible with the WITH statement, the __enter__ and __exit__ methods must be declared in the class of the object.
Class Open: def __init__ (self,name): self.name=name def __enter__ (self): print (' Appear with statement, object's __ Enter__ is triggered, a return value is assigned to the variable ' declared as ') # return self def __exit__ (self, exc_type, Exc_val, EXC_TB): print (' Execute me when the code block is finished executing with (' a.txt ') as F: print (' =====> code block ') # Print (f,f.name) #------------ The output-------A with statement appears, the object's __enter__ is triggered, and a return value is assigned to the variable =====> the as declaration. Execute code block with code block execute me when it's finished.
The three parameters in __exit__ () represent exception types, outliers, and trace information, and the code block in the WITH statement has an exception, and the code after it cannot be executed
Class Open: def __init__ (self,name): self.name=name def __enter__ (self): print (' Appear with statement, object's __ Enter__ is triggered, a return value is assigned to the variable ' declared as ') def __exit__ (self, exc_type, Exc_val, EXC_TB): print (execute me when the block of code in with is finished executing) print (Exc_type) print (exc_val) print (EXC_TB) with Open (' a.txt ') as F: print (' =====> Execute code block ') Raise Attributeerror (' * * * fire, fire-fighting * * *) print (' 0 ' *100) #-------------------------------> will not execute # print (f , f.name) #------------output-------# The WITH statement appears, the object's __enter__ is triggered, and the return value is assigned to the variable # declared by the as Declaration # =====> execution code block # with the code block executed when the execution is complete. <class ' Attributeerror ' ># * * * fire, Fire ah ***# <traceback object at 0x00000000126eab48>
If the __exit () return value is true, then the exception is emptied, as if nothing had happened, and the statement with the following is executed normally
Class Open: def __init__ (self,name): self.name=name def __enter__ (self): print (' Appear with statement, object's __ Enter__ is triggered, a return value is assigned to the variable ' declared as ') def __exit__ (self, exc_type, Exc_val, EXC_TB): print (execute me when the block of code in with is finished executing) print (exc_type) print ( exc_val) print (EXC_TB) return truewith Open (' a.txt ') as F: print (' = = = = Execute code block ') raise Attributeerror (' * * * fire, fire, fight * * *) print (' 0 ' *10) #-------------------------------> will execute # #-- -----------Output------------------# The WITH statement appears, the object's __enter__ is triggered, and the return value is assigned to the variable # declared by the as Declaration # =====> execution code block # with the code block executed when the execution of my AH # <class ' Attributeerror ' ># * * * fire, Fire ah ***# <traceback object at 0x00000000126eab88>
# 0000000000
Analog Open
Class Open: def __init__ (self,file_name,mode,encoding= ' utf-8 '): self.file_name=file_name self.mode = Mode self.encoding = Encoding def __enter__ (self): print (' Enter ') self.f = open (Self.file_name, self.mode,encoding=self.encoding) return SELF.F def __exit__ (self, exc_type, Exc_val, EXC_TB): print (" Exit ") Self.f.close () return True def __getattr__ (self, item): print (' Executed by me ') return GetAttr (SELF.F, item) with Open (' Test.txt ', ' W ') as F: f.write (' Aadddda ')
-
The purpose of using the WITH statement is to put the code block in with, and with the end, the cleanup work is done automatically without manual intervention
-
In a programming environment where you need to manage resources such as files, network connections, and locks, you can customize the mechanism for automatically releasing resources in __exit__, which is useful if you don't have to deal with the problem.
__call__
The object is appended with parentheses to trigger execution.
Note: The execution of the construction method is triggered by the creation object, that is: Object = class name (), and the execution of the __call__ method is triggered by parentheses after the object, i.e.: Object () or Class () ()
Class Foo: def __init__ (self): pass def __call__ (self, *args, **kwargs): print (' __call__ ') obj = Foo () # Execute __init__obj () # Execute __call__
Python Magic method