The process of categorizing a class that has common attributes is called object-oriented .
class When defining a class , The first letter of a class name must be capitalized
1 class Person(object):
2 def __init__(self,name,age): #name,age It can be understood as the attribute of a class ;init For initialization ; The functions defined in a class are called constructors / Constructors
3 self.name=name # Instance attributes
4 self.age=age
5 print("start")
6 def __del__(self): # Cleanup operations
7 print("end")
8 def show(self): #self For the class itself , Do not omit
9 print("name:{0},age:{1}".format(self.name,self.age))
10 obj=Person(name="wuya",age=18) # To call a variable in a class 、 Methods, functions, etc , First, you need to instantiate the class ;obj It's a class Person() Instantiated object , The process of class instantiation is also the process of class initialization . The instantiation process of a class is also the process of initializing a constructor （ It's called __init__ Methods ）
11 obj.show()
12 #Person(name="wuya",age=18).show() # Call method with class name
The result of running the above code is ：
1） encapsulation
a. Instance attributes
b. Data attribute （ Variables in class ）
2） Inherit
3） polymorphic
a. Common method ： Belong to the object , Also belong to class , Can only read and write ;
b. Characteristic method ： Belong to the object , Only the read attribute is available , Methods cannot have formal arguments ;
c. Static methods ： Belong to category , Can only be called with class name , Generally, data attributes are handled by static methods
1 class Animal(object):
2 def __init__(self,age):
3 self.age=age
4 def getAge(self):
5 return self.age
6 def setAge(self,age):
7 if age>10 and age<100:
8 self.age=age # It is allowed to modify the age
9 else:
10 print(" Age error ")
11 objAnimal=Animal(age=25) # Class instantiation
12 print(objAnimal.getAge()) # Output the call result of the method to get the age
13 objAnimal.setAge(age=11) # Call the method to modify the age
14 print(objAnimal.getAge()) # Output the call result of the method to get the age
1 class Animal(object):
2 address=" The earth " # Data attribute
3 def __init__(self,age):
4 self.age=age # Instance attributes
5 # @staticmethod
6 def address(self): # Static methods , Data attributes are handled using static methods
7 return " The earth "
8 def show(self,name="*"): # Common method , read-write
9 print("it come from {0},and it's age is {1},and it's name is {2}".format(self.address(),self.age,name))
10 def func(self,**kwargs):
11 print(kwargs)
12 @property
13 def info(self): # Characteristic method , read-only （ Only output ）
14 print("hello world")
15 @property
16 def getAge(self): # Characteristic method , read-only （ Only return to ）
17 return self.age
18 objAnimal=Animal(age=30) # Class instantiation
19 objAnimal.show() # Calling normal methods
20 #objAnimal.show(name="monkey")
21 # Animal().show(name="monkey")
22 # Animal(age=10).address()
23 objAnimal.func(name="cch",age=18,city=" Xi'an ")
24 objAnimal.info # Feature method calls
25 print(Animal.address(""))
26 print(objAnimal.age)
1） Concept
Parent class （ Base class ）： Inherited class
Subclass （ Derived class ）： Inherit other classes
2）Java and Python The difference between inheritance
Java It's a single inheritance ,Python It's multi inherited
3） Inherit from the parent class of ：
a、 Variable （ Data attribute ）
b、 Instance attributes
c、 Method
3） Method rewriting
When the methods of the parent class cannot meet the needs of the child class , The subclass overrides the methods of the parent class , Then the object after subclass instantiation calls this method , Priority is given to subclass methods .
1 class Father(object):
2 address=" Xi'an "
3 def __init__(self,name,age):
4 self.name=name
5 self.age=age
6 def info(self):
7 print("this is a father's method")
8 class Son(Father):
9 def __init__(self,name,age,score):
10 Father.__init__(self,name,age) # The subclass inherits the instance property of the parent class
11 self.score=score
12 def show(self):
13 print("name is {0},and age is {1},and score is {1}".format(self.name,self.age,self.score))
14 def info(self): # The method of the parent class overrides
15 print("this is a son's method")
16 son=Son(name="wuya",age=18,score=99)
17 son.show()
18 print(son.address) # The subclass inherits the variables of the parent class （ Data attribute ）
19 son.info() # no need print,info() There is print, Function and return value , The output function is null . Subclasses override methods of the parent class , Then the object after subclass instantiation calls this method , Priority is given to subclass methods .
The result of running the above code is ：
1） From top to bottom （ Prerequisite ）：
a. Single inheritance
b. The subclass overrides the method of the parent class
2） From left to right （ Prerequisite ）： Subclasses inherit from multiple classes （ Subclasses can inherit multiple parent classes , But the parent classes must be siblings .）
3） So in Python in , be based on MRO The parsing order rule of , You'll start looking for the base class from left to right , If you find the second one ⼀ Matching attribute classes , It will stop ⽌ lookup , without , Then keep looking , Until you find a match
To the end .MRO It's really just through ⼀ individual C3 Linear algorithm to achieve , Its core idea is ：
Subclasses will be superior to parent class checking
Multiple parent classes are checked in turn according to their order in the list
If there are two legitimate choices for the next class , Only the first... Can be selected （ Linear search ）
1 class Father(object):
2 def __init__(self,name,age):
3 self.name=name
4 self.age=age
5 def funM(self):
6 print("father")
7
8 class Mother(object):
9 def funM(self):
10 print("mother")
11
12 class Son(Father,Mother): # Subclass Son Inherited two parent classes
13 def __init__(self,name,age,score):
14 Father.__init__(self,name,age) # Subclass Son Inherited the parent class Father and Mother Instance properties for
15 self.score=score
16
17 son=Son(name="ccj",age=18,score=100)
18 son.funM()
19 print(Son.mro()) # Call... With a class name mro, View the execution order of the class
The execution result of the above code is ：
1 class Person(object):
2 pass
3
4 class Father(Person):
5 def __init__(self):
6 pass
7 def funM(self):
8 print("father")
9 class Mother(object):
10 def funM(self):
11 print("mother")
12
13 class Son(Person,Father): # The child class inherits multiple parent classes that are not of the same level , The code will report an error ,z Subclasses can inherit multiple parent classes , But the parent classes must be siblings .
14 def __init__(self,score): 15 Father.__init__(self) 16 self.score=score 17 son=Son(score=90) 18 son.funM() 19 print(Son.mro())
The running result of the above code is ;
1 class Person(object):
2 pass
3
4 class Father(Person):
5 def __init__(self):
6 pass
7
8 class Mother(Person):
9 def funM(self):
10 print("mother")
11
12 class Son(Father): # There is no... In the parent class inherited by the subclass funM Method , The code will report an error
13 def __init__(self,score):
14 Father.__init__(self)
15 self.score=score
16
17 son=Son(score=99)
18 son.funM()
The running result of the above code is ：
1 class Person(object):
2 def funM(self):
3 print("person")
4
5 class Father(Person):
6 def __init__(self):
7 pass
8
9 class Mother(Person):
10 def funM(self):
11 print("mother")
12
13 class Son(Father): # The parent class of the subclass inheritance method is Father
14 def __init__(self,score):
15 Father.__init__(self)
16 self.score=score
17
18 son=Son(score=99)
19 son.funM() # Subclasses call methods , First, look up... From the subclass , Then find the inherited parent class , If you don't find , Then find the parent class of the parent class .
20 print(Son.mro())
The result of the above method is ：
python2 It's depth first ,python3 It's breadth first
1 class A:
2 def show(self):
3 print('A')
4
5 class B(A):
6 pass
7
8 class C(A):
9 def show(self):
10 print('C')
11
12 class D(B,C):
13 pass
14
15 if __name__ == '__main__':
16 obj=D()
17 obj.show() #python2 The result of the execution is A,pyhton3 The result of running in is C
Many advantages can be summarized as follows , Specific for ：
Increased continuous flexibility
Added continuous additional extensions
1 class Animal(object):
2 def talk(self):
3 print(" Animals can call ")
4
5 class Dog(object):
6 def talk(self):
7 print(" A dog barks ")
8
9 class Cat(object):
10 def talk(self):
11 print(" Cats bark, too ")
12
13 def func(animal):
14 animal.talk()
15 if __name__ == '__main__':
16 dog=Dog()
17 func(animal=dog)
The running result of the above code is ：
