Key points to learn in this chapter:
Object oriented is to solve the maintainability of the system, extensibility, reusability, we further consider, why the object-oriented to solve the system maintainability, extensibility, reusability?
The historical reasons for object-oriented generation include the following two points:
1, the computer is to help people solve the problem, but the computer is a machine, he will only follow the code written by people, step by step implementation, and finally get the results, so no matter how complicated the program, the computer can always easily cope. Structured programming is the code that is written according to the computer's thinking, but when people see such complex logic, they cannot maintain and extend it.
2, the structural design is to function as the goal to design the structural application system, this practice led us to design the program, we have to the object of the real world to map to a functional module composed of the solution space, this conversion process, the departure from the people to observe and solve the basic idea of the problem.
Visible structure design in the design of the system, can not solve the problem of reuse, maintenance, extension, but also lead to logic is too complex, the code is difficult to understand. So people think, can let the computer directly simulate the reality of the environment, with the human problem-solving ideas, habits, steps to design the appropriate application? Such a program, when people read it, will be easier to understand, and do not need to put the real world and the program of the world back and forth between the conversion.
At the same time, it is found that the object of existence in the real world is the protagonist in the problem domain. The so-called object refers to the objective entity and the subjective abstract concept, which has attributes and behaviors, and the object is stable, the behavior is unstable, and the object has all kinds of relations, so the object-oriented programming, the system will be more stable than the behavior-oriented programming. In the face of frequent changes in demand, the change is often behavior, and the object generally does not need to change, so we encapsulate the behavior, so that the change only need to change the behavior, the main structure remains stable.
So the object-oriented is produced.
But how is the system maintainability, extensibility and reusability embodied in the object-oriented?
First look at the three main features of object-oriented:
Encapsulation: To find the change and encapsulate it, you can modify or extend the changed parts of the package without affecting the other parts, which is the basis of all design patterns, that is, package changes, so the role of encapsulation, it solves the scalability of the program.
Inheritance: Subclass inherits the parent class, can inherit the parent class's method and the property, realizes the polymorphism as well as the code reuse, therefore also solves the system reusability and the expansibility. But inheritance destroys encapsulation because he is open to subclasses, and modifying the parent class causes all subclasses to change, so inheritance is somewhat disruptive to the system's extensibility, so inheritance needs to be used with caution. Only a definite is-a relationship can be used, while inheriting in the process of program development, rather than using inheritance at the beginning of programming, many object-oriented developers abuse inheritance, resulting in later code can not solve the changes in demand. Therefore, it is an important experience in object-oriented development to prioritize the use of combinations rather than inheritance.
Polymorphism: Many different implementations of interfaces are polymorphic. Interface is the abstraction of behavior, just mentioned in the encapsulation, find the change part and encapsulate it, but after encapsulation, how to adapt to the next change? This is exactly what the interface does, and the main purpose of the interface is to provide generic processing services for unrelated classes, which we can imagine. For example, a bird can fly, but Superman can fly, by flying this interface, we can let birds and Superman, both realize this interface, which realizes the system maintainability, extensibility.
Therefore, object-oriented can realize the system maintainability, extensibility and reusability that people pursue. Object-oriented is a kind of programming idea, at first, "object-oriented" refers to the design method of encapsulation, inheritance, polymorphism and so on, but the object-oriented thought already involves all aspects of software development, such as subdivision for object-oriented analysis (OOA), Object-oriented design (OOD), Object-oriented Programming implementation (OOP)
Use the class statement to create a new class, followed by the name of the class and ending with a colon, as in the following example:
The class ClassName: 'class help info' # class docstring Class_suite # class body
#! The/usr/bin/python
# -* -coding: utf-8 -*-
The class the Employee:
'base class for all employees'
EmpCount = 0
Def __init__ (self, the name, salary) :
The self. The name = name
Self. Salary = salary
The Employee. EmpCount + = 1
Def displayCount (self) :
Print ("Total Employee %d" % employee.empcount)
Def displayEmployee (self) :
Print ("Name: ", self.name, ", Salary: ", self.salary)
To create an instance of a class, you can use the name of the class and accept the arguments through the __init__ method.
"Create the first object of the Employee class"
Emp1 = the Employee (" Zara ", 2000)
"Create a second object of the Employee class"
Emp2 = the Employee (" Manni ", 5000)
3. Access Properties
You can use the dot (.) To access the properties of the object. Access the class variable using the name of the following class:
emp1.displayEmployee() emp2.displayEmployee() print("Total Employee %d" % Employee.empCount)
Complete Example:
#! The/usr/bin/python
# -* -coding: utf-8 -*-
The class the Employee:
'base class for all employees'
EmpCount = 0
Def __init__ (self, the name, salary) :
The self. The name = name
Self. Salary = salary
The Employee. EmpCount + = 1
Def displayCount (self) :
Print ("Total Employee %d" % employee.empcount)
Def displayEmployee (self) :
Print ("Name: ", self.name, ", Salary: ", self.salary)
"Create the first object of the Employee class"
Emp1 = the Employee (" Zara ", 2000)
"Create a second object of the Employee class"
Emp2 = the Employee (" Manni ", 5000)
Emp1. DisplayEmployee ()
Emp2. DisplayEmployee ()
Print ("Total Employee %d" % employee.empcount)
Execute the above code to output the result as follows:
Name : Zara ,Salary: 2000 Name : Manni ,Salary: 5000 Total Employee 2
You can add, remove, and modify the properties of the class as follows:
Emp1.age = 7 # add an 'age' attribute Emp1.age = 8 # modify the 'age' attribute Del emp1. Age # removes the 'age' attribute
You can also access properties by using the following functions:
4. Python built-in class propertiesHasattr (emp1, 'age') # returns True if the 'age' attribute exists. Getattr (emp1, 'age') # returns the value of the 'age' attribute Setattr (emp1, 'age', 8) # add attribute 'age' with a value of 8 Delattr (empl, 'age') # delete attribute 'age'
The python built-in class property invocation instance is as follows:
#! The/usr/bin/python
# -* -coding: utf-8 -*-
The class the Employee:
'base class for all employees'
EmpCount = 0
Def __init__ (self, the name, salary) :
The self. The name = name
Self. Salary = salary
The Employee. EmpCount + = 1
Def displayCount (self) :
Print ("Total Employee %d" % employee.empcount)
Def displayEmployee (self) :
Print ("Name: ", self.name, ", Salary: ", self.salary)
Print (" Employee. __doc__ : "and the Employee. __doc__)
Print (" Employee. __name__ : ", the Employee __name__)
Print (" Employee. __module__ : ", the Employee __module__)
Print (" Employee. __bases__ : ", the Employee __bases__)
Print (" Employee. __dict__ : ", the Employee __dict__)
Execute the above code to output the result as follows:
5. destructor------Python object DestructionEmployee. S doc__: base class for all employees The Employee. __name__ : the Employee The Employee. __module__ : __main__ The Employee. __bases__ : () <function displaycount="" at="" 0x10a939c80="">, 'empCount' : 0, 'displayEmployee' : <function displayemployee="" at="" 0x10a93caa0="">, 's doc__' :</function></function> '\xe6\x89\x80\xe6\x9c\ x910 \x9a\ x9a\ x9a\ x9a\ x9f\xba\xe7\ XBB', 's}
Like the Java language, Python uses a simple technique of reference counting to track objects in memory.
Inside Python is a record of how many references each object in use has.
An internal tracking variable, called a reference counter.
When the object is created, a reference count is created, and when the object is no longer needed, that is, the reference count of the object becomes 0 o'clock, and it is garbage collected. However, recycling is not "immediate", and the interpreter uses the garbage object to reclaim the memory space at the appropriate time.
A = 40 # creates an object <40> B = a # adds references, <40>'s count C = [b] # adds references. <40> counts Del a # reduces the count of references <40> B = 100 # reduces the count of references <40> C [0] = -1 # reduces the count of references <40>
The garbage collection mechanism not only targets objects with a reference count of 0, but can also handle circular references. Circular references refer to two of objects referencing each other, but no other variables refer to them. In this case, using only the reference count is not enough. The Python garbage collector is actually a reference counter and a cyclic garbage collector. As a supplement to the reference count, the garbage collector also pays attention to objects that are allocated a large amount (and those that are not destroyed by reference counting). In this case, the interpreter pauses to attempt to clean up all unreferenced loops.
#! The/usr/bin/python # -* -coding: utf-8 -*- The class Point: Def s init__(self, x=0, y=0): Self. X = x Self. Y = y Def __del__ (self) : Class_name = self. The magic __class__. __name__ Print (class_name, "destroy ") Pt1 = Point () Pt2 = pt1 The pt3 = pt1 Print (id(pt1), id(pt2), id(pt3)) # print the id of the object Del pt1 Del pt2 Del pt3
The results of the above example operation are as follows:
3083401324 3083401324 3083401324Point Destruction
Note: typically you need to define a class in a separate file
One of the main benefits of object-oriented programming is the reuse of code, and one way to implement this reuse is through inheritance mechanisms. Inheritance can be fully understood as a type and subtype relationship between classes.
What to note: Inherit the syntax class derived class name ( base class name )://... The base class name is written in parentheses, and the base class is specified in the tuple at the time the class is defined.
Some of the characteristics of inheritance in Python:
If more than one class is listed in an inheritance tuple, it is called "Multiple inheritance."
Grammar:
The declarations of derived classes, like their parent class, inherit the list of base classes followed by the class name, as follows:
#! _ * _coding: utf-8 _ _
# __author__ : "Alex Li"
The class SchoolMember (object) :
Members = 0 # the initial school population is 0
Def __init__ (self, name, age) :
The self. The name = name
The self. The age = age
Def tell (self) :
pass
Def enroll (self) :
Register ' ' ' ' ' '
SchoolMember. Members + = 1
Print (" \ [033 32; 1 mnew member [% s] is enrolled, now there are [% s] members. \ [0 033 m "% (self. The name, SchoolMember. Members))
Def __del__ (self) :
Destructor method
Print ("\033[31;1mmember [%s] is dead!\033[0m" %self.name)
The class the Teacher (SchoolMember) :
Def __init__ (self, name, age, course, salary) :
The self, super (the Teacher) __init__ (name, age)
The self. The course = of course
Self. Salary = salary
Self. Enroll ()
Def would (self) :
Lecture method
Print ("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course, 's12'))
Def tell (self) :
Self-introduction method
MSG = 'Hi, my name is [%s], works for [%s] as a [%s] teacher! ' ' '% (self. The name, "Oldboy", the self. The course)
Print (MSG)
The class Student (SchoolMember) :
Def __init__ (self, name, age, grade, sid) :
The self, super (Student) __init__ (name, age)
Self. Grade = grade
Self. Sid = sid
Self. Enroll ()
Def tell (self) :
Self-introduction method
MSG = ' ' 'Hi, my name is [% s], I' m studying [% s] in [% s]! ' ' '% (self. The name, the self. The grade, "Oldboy")
Print (MSG)
If __name__ = = "__main__" :
T1 = the Teacher (" Alex, "22" Python ", 20000).
T2 = the Teacher (" TengLan ", 29, "Linux", 3000).
S1 = Student("Qinghua", 24,"Python S12",1483)
S2 = Student("SanJiang", 26,"Python S12",1484)
T1. Would ()
T2. Would ()
T1. Tell ()
7. Class properties and MethodsPrivate properties of the class
__private_attrs: Two underscores begin with, declaring that the property is private and cannot be used outside of the class or accessed directly. self.__private_attrswhen used in methods inside a class.
Inside the class, using the DEF keyword, you can define a method for a class that differs from a generic function definition, which must contain the parameter self, and is the first argument
__private_method: Two underscores, declares that the method is a private method and cannot be called outside of a class. Calling Self.__private_methods inside a class
#! The/usr/bin/python # -* -coding: utf-8 -*- The class JustCounter: S secretcount = 0 # private variable PublicCount = 0 # expose variables Def count (self) : Self. __secretCount + = 1 Self. PublicCount + = 1 Print (self. __secretCount) Counter = JustCounter () Counter. The count () Counter. The count () Print (counter. PublicCount) Print (counter.s secretcount) # error, instance cannot access private variable
Python includes the class name by changing its name:
1 2 2 Traceback (most recent call last): File "test.py", line 17, in <module></module> Print counter. With an error, the instance cannot access the private variable AttributeError: JustCounter instance has no attribute 's' s' s' s' s' s' s' s
Python does not allow instantiated classes to access private data, but you can use object._classname__attrname to access properties and replace the following code with the last line of code:
.......... print Counter._justcounter__secretcount (.....)
Execute the above code and execute the result as follows:
8. Polymorphic1222
Before you talk about polymorphism, first a section of code:
The class Person (object) :
Def __init__ (self, name, sex) :
The self. The name = name
Self. Sex = sex
Def print_title (self) :
If self. Sex = = "male" :
Print (" man ")
Elif self. Sex = = "female" :
Print (" woman ")
Class Child(Person): # Child inherits Person
Def print_title (self) :
If self. Sex = = "male" :
Print (" boy ")
Elif self. Sex = = "female" :
Print (" girl ")
May = Child (" May ", "female")
Peter = Person (" Peter ", "male")
Print (May) name, May. Sex, Peter. The name, Peter. Sex)
May. Print_title ()
Peter. Print_title ()
When both the subclass and the parent class have the same Print_title () method, the subclass's Print_title () overrides the Print_title () of the parent class, and the subclass's Print_title () is called when the code runs.
In this way, we gain another benefit of inheritance: polymorphism .
The advantage of polymorphism is that when we need to pass in more subclasses, such as new teenagers, grownups, etc., we only need to inherit the person type, and the Print_title () method can not rewrite (that is, use person). can also be overridden by a unique. This is the meaning of polymorphism. The caller simply calls, regardless of the details, and when we add a subclass of person, just make sure the new method is written correctly without having to control the original code. This is the famous "opening and shutting" principle:
Advancing Python "sixth chapter": Python's Advanced Application (iii) object-oriented programming
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
