Summary of today's content
- Object specific functions
- Dynamic and static method
- Inheritance of three characteristics of object-oriented
- The essence of inheritance
- Search order of data and methods
- Classic and new
- Derived method
Object specific functions
1. We can't really realize the unique methods for objects:
(1) If it is in the overall situation, it is not unique;
(2) Public if in class
There is a feature in python, which is equivalent to the unique method of the object, that is, the functions defined in the class are bound to the object by default.
2. Take a chestnut
class Person: h_type = 'human beings' def __init__(self, name): # Let objects have unique data self.name = name # Functions defined in classes are called methods def eat(self): # A method that is common to multiple objects is also a method that is unique to multiple objects. When called, the object will be passed in as the first parameter print('%s Cooking'%self.name) def others(self,a,b): print('others Ha ha ha') p1 = Person('jason') p1.eat() # eat(p1) # jason is cooking p2 = Person('kevin') p2.eat() # eat(p2) # kevin is cooking # How to understand the word binding p3 = Person('oscar') Person.eat(p3) # oscar is cooking p1 = Person('jason') p1.others(1, 2) # others hahaha Person.others(p1,1,2) # others hahaha
Dynamic and static method
There are three types of dynamic and static methods, mainly for functions written in class body code
1. Methods bound to objects;
(1) Directly write in the class body code;
(2) Object call will automatically pass the object as the first parameter;
(3) Class call passes several arguments as long as there are several formal parameters.
class Student: school = 'Tsinghua University' # Methods bound to objects def run(self): # self is used to receive objects print('Old six, run quickly!!!', self) stu1 = Student()
2. Methods bound to classes:
The call of class will automatically pass the class as the first parameter
class Student: school = 'Tsinghua University' # Methods bound to objects def run(self): # self is used to receive objects print('Old six, run quickly!!!', self) @classmethod # Methods bound to classes def eat(cls): # cls is used to receive classes print('Six, you are really talented', cls) stu1 = Student() # Call methods bound to classes Student.eat() # Class call will automatically pass the class as the first parameter >eat (student) ''' Six, you are really talented <class '__main__.Student'>''' stu1.eat() # Object call will automatically pass the class that generates the object as the first parameter >eat (student) '''Six, you are really talented <class '__main__.Student'>'''
3. Static method (ordinary function)
class Student: school = 'Tsinghua University' @staticmethod # Static method def sleep(a, b): # No matter who calls it, it must follow the ordinary function parameter passing method print('Old six, go to bed') stu1 = Student() # Call static method # Class call Student.sleep(1,2) # Object call stu1.sleep(1, 2)
Inheritance of three characteristics of object-oriented
1. Three characteristics of object-oriented:
Succession; Encapsulation; polymorphic
2. Meaning of inheritance
(1) In real life, inheritance is actually used to describe the relationship between human resources
eg: the son inherits the father's property (owns all the resources of the father)
(2) In the programming world, inheritance is actually used to describe the relationship between classes
eg: class A inherits class B (having all the data and functions in class B)
3. Purpose of succession
(1) In real life, inheritance is to want to occupy others' property
eg: personal father, godfather, godmother, rich woman
(2) In the programming world, inheritance is to save code
eg: you can inherit one class or multiple classes
4. Inherited operation
class Class name (parent class): pass
(1) When defining a class, put parentheses after the class name;
(2) Fill in the class name you need to inherit in brackets;
(3) Multiple parent classes can be filled in brackets, separated by commas
Take a chestnut
# Parent class class Father: money = 1000000000 def run(self): print('Luxury car Villa') # Subclass class Son(Father): pass print(Son.money) # 1000000000 Son.run(11) # Luxury car Villa
5. Description of inherited classes
(1) We call the inherited class: parent class, base class or superclass;
(2) We call the class of inherited class: subclass or derived class;
6. Find the parent class from left to right in brackets
If you have something in yourself, don't ask for it from the parent class
class F1: name = 'from f1' class F2: name = 'from f2' class F3: name = 'from f3' class MyClass(F1,F2,F3): pass print(MyClass.name) # from f1----> from f2----> from f3
The essence of inheritance
1. Abstraction and inheritance
Abstract: extract the common data or functions of multiple classes to form a base class
Inheritance: white whoring resources in each base class from top to bottom
2. Take chestnuts for example:
class Person: def __init__(self,name,age,gender): self.name = name self.age = age self.gender = gender class Teacher(Person): def teach_course(self): print('Teacher in class') class Student(Teacher): def choice_course(self): print('Students' course selection') stu1 = Student('jason',18,'male') print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'gender': 'male'}
3. Form a contrast
Object: a combination of data and function
Class: a combination of the same data and functions of multiple objects
Parent class: a combination of the same data and functions of multiple classes
Search order of names
Hit the key!!! It mainly involves object search names, so almost all of them are:
Object's own class parent
1. Search order of names without inheritance
First search from the object itself, and then search in the class that generates the object if there is no one
Object > > > class
class Student: school = 'Tsinghua University' def choice_course(self): print('Selecting courses') stu1 = Student() print(stu1.school) # Object lookup school does not have its own namespace, so it is Tsinghua University that looks for classes stu1.school = 'Peking University' # A new school is created in its own namespace """If the object names and writes assignment symbols and data values, the operation must be in its own namespace""" print(stu1.school) # Peking University print(Student.school) # Tsinghua University
2. Search order of names in the case of single inheritance
First, find the object itself, then the class that generates the object, and then the parent classes
Object > > > class > > > parent class
eg1:
class A: name = 'from A' pass class B(A): # name = 'from B' pass class C(B): # name = 'from C' pass class MyClass(C): # name = 'from MyClass' pass obj = MyClass() # obj.name ='I'm sleepy!!! ' print(obj.name) '''from A'''
As long as the object is involved, look up the name almost back to the beginning and look it up in turn
eg2:
class A1: def func1(self): print('from A1 func1') def func2(self): print('from A1 func2') self.func1() # obj.func1() class MyClass(A1): def func1(self): print('from MyClass func1') obj = MyClass() obj.func2() ''' from A1 func2 from MyClass func1 '''
3. Search order of names in the case of multiple inheritance
(1) Non diamond inheritance (it will not be summed up in a custom class)
Depth first (each branch goes to the bottom and then switches)
(2) Diamond inheritance (finally summed up to a custom class)
Breadth first (the first few branches will not go until the last branch of the last class)
Special note: you can use the class point mro() method to view the search order of the object names generated by this class
Classic and new
1. Concept description
(1) Classic class
Classes that do not inherit object or its subclasses (inherit nothing)
(2) New type
Classes that inherit object or its subclasses
2. Description in different interpreters
(1) In python3, all classes inherit object by default
That means there are only new classes in python3
(2) In python2, there are classic classes and new classes
Because classic classes have no core functions, they are directly cut off in python3
3. Recommended usage
In the future, when defining classes, if there is no parent class we want to inherit, the following writing is generally recommended:
class MyClass(object): pass
Its purpose is to be compatible with python2
Derived method
Subclasses define methods that are exactly the same as the parent class and extend this function > > >: derivation
1. Function of derivation - super() built-in attribute
class Person: def __init__(self,name,age,gender): self.name = name self.age = age self.gender = gender class Teacher(Person): def __init__(self,name,age,gender,level): super().__init__(name,age,gender) # super is specially used for subclasses to call methods of the parent class self.level = level # I added some by myself class Student(Person): pass
2. The derived instance makes some changes to the list to add data.
class MyClass(list): def append(self, value): # [] cut Hu if value == 'jason': print('jason Cannot add') # output return super().append(value) obj = MyClass() # Generate an object [] obj.append('jason') obj.append(111) obj.append(222) obj.append(333) print(obj) # [111, 222, 333] print(MyClass.mro()) # View the search order of object names generated by this class """ jason Cannot add [111, 222, 333] [<class '__main__.MyClass'>, <class 'list'>, <class 'object'>] """