Shulou(Shulou.com)06/03 Report--

This article will explain in detail the example analysis of Python object-oriented programming oop for you. The editor thinks it is very practical, so I share it for you as a reference. I hope you can get something after reading this article.

OOP full name Object Oriented Programming

That is, object-oriented programming, there is such a strange name, because the concept does not come out of thin air, but relative to the term "process-oriented programming".

To understand what is process-oriented, we should start with the earliest original programming that is neither object-oriented nor process-oriented.

Ancient times

In the earliest days of programming, programs were simply executed sequentially:

Print ("dosometing") a=int (input ()) b=int (input ()) result=a+bprint ("{} + {} = {}" .format) print ("dosomething")

This involves a problem: if a part of the code needs to be executed repeatedly, such as the above code that enters two numbers and prints the result, what if you need to execute this logic again? do you want to write it again?

Some languages, such as C, do this:

Print ("dosometing") a=int (input ()) b=int (input ()) result=a+bprint ("{} + {} = {}" .format ("dosomething") goto 2

Here is only python pseudo code to represent the C language writing, this code can not really be executed.

The C language can use the Goto statement to disrupt the logic of the compiler "executing code sequentially" and force the compiler to jump to a specified line of code to execute the code.

It seems to solve the problem, but this brings another problem. Frequent use of Goto statements will break the most basic rule of "sequential execution of code" and greatly reduce the readability and maintainability of the code, not to mention other programmers to read such code, even the author himself will probably have a headache every few months.

So there is process-oriented programming.

Process oriented programming

Process-oriented mainly solves the problem of "code reuse" above, encapsulating the code snippet that needs to be reused into a function, which can be reused as long as you make a simple function call:

Def input_and_print (): a = int (input ()) b = int (input ()) result = ahumb print ("{} + {} = {}" .format (a, b, result)) print ("dosometing") input_and_print () print ("dosomething") input_and_print ()

It seems that the problem has been solved, and it's not a big problem. This is certainly true if all we have to solve is the pediatric problem of "input two numbers add up and output one result", but the world of programming is obviously not that simple.

Suppose we need to use a program to simulate a "simple" beverage machine. If it is process-oriented programming, it might be written as follows:

STATUS_READY = 0STATUS_COINED = 1def coin (now_status): if now_status = = STATUS_READY: print ("throw in a coin") return STATUS_COINED else: print ("already put in a coin") return now_statusdef get_drink (now_status): if now_status = = STATUS_COINED: print ("spit out a bottle of drink") return STATUS_READY Else: print ("Please put in the coin first") return now_statusmachine_status = STATUS_READYmachine_status = get_drink (machine_status) machine_status = coin (machine_status) machine_status = get_drink (machine_status)

It seems that this code is not bad, but there are still many problems, for example, because the function cannot save the "state", we can only set a variable machine_status outside the function to represent the state of the beverage machine, and pass it as an argument every time the function is called.

This has two disadvantages:

The function representing the function of the beverage machine and the data representing the status of the beverage machine are separated, both of which are supposed to be part of the beverage machine, but now they are two unrelated parts.

Function has no way to directly modify the state of the beverage machine (not at all, of course, such as using global, or passing in an object parameter, but these unconventional methods are not discussed here).

In order to solve these problems, there is object-oriented programming.

Object oriented programming

Let's look at how to write a beverage machine if it's object-oriented programming:

From enum import Enumfrom enum import Enumclass MachineStatus (Enum): READY=1 COINED=2class DrinkMachine: def _ init__ (self)-> None: self.status=MachineStatus.READY def coin (self): if self.status= = MachineStatus.READY: print ("throw in a coin") self.status= MachineStatus.COINED elif self.status= = MachineStatus.COINED: print ("already cast" Insert a coin ") else: print (" unknown error ") def get_drink (self): if self.status= = MachineStatus.COINED: print (" spit out a drink ") self.status=MachineStatus.READY elif self.status= = MachineStatus.READY: print (" Please drop a coin first ") else: Print ("unknown error") dm = DrinkMachine () dm.get_drink () dm.coin () dm.get_drink ()

As you can see, the concept of "beverage machine" is now a whole, including the state and functions provided by the beverage machine, and the state change of the beverage machine is also completely encapsulated in the object, and the "user" does not have to worry about the state change. just call the object's method as needed.

What is OOP?

Now let's go back to the title, what is OOP, in fact, object is not a programming-specific concept, just as design patterns come from architecture, objects are also a concept from the real world.

In the real world, we do a thing, often around a thing entity, such as driving out, you first have a car, four tires, an engine, a car filled with gas, this is a real thing. Corresponding to the OOP, it is like the data that makes up the object. The functions provided by this car, such as carrying people, pulling goods and driving, are all functions provided by the car. The corresponding OOP is the method owned by the object. This is obviously a way of thinking in line with human habits, that is, thinking around things (objects).

Process-oriented is not so in line with human common sense, it only focuses on the process (function), that is, as long as it can carry people or pull goods, it does not pay much attention to whether you are using a private car or a tank.

Therefore, OOP is a method of thinking and solving problems borrowed from the programming field, which is a kind of idea, and encapsulation, inheritance and polymorphism are the means and technical details to realize this idea.

This is the end of this article on "sample Analysis of Python object-oriented programming oop". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.