Python - basic object-oriented concepts

Python uses classes and objects to perform object-oriented programming (OOP).

The main purpose of object-oriented is to improve the reusability of programs. The reason we got into object-oriented programming so early is that the entire concept of Python is based on objects. Understanding OOP is the key to further learning Python.

The following is an understanding of object-oriented, based on classification.

Similar objects are classified into categories

In human cognition, things are classified according to similar attributes and the categories are named. For example, the common attribute of birds is that they have feathers and produce offspring by laying eggs. Any particular bird is based on the prototype of a bird.

Object-oriented simulates the above human cognitive process. In the Python language, to sound cool, we call the "things" mentioned above objects.

First define birds

class Bird(object):
    have_feather = True
    way_of_reproduction  = 'egg'

We define a category (class), which is Bird. In the statement block belonging to this analogy, we define two variables, one is feathers (have_feather) and the other is the way of reproduction (way_of_reproduction). These two variables correspond to the attributes we just mentioned. We will not explain the parentheses and their contents for the time being, marking it as question 1.

Suppose I raise a chick called summer. It is an object, and it belongs to birds. Use the previously defined class:

summer = Bird()
print summer.way_of_reproduction

Create an object through the first sentence, and explain that summer is an object in the category bird. Summer has the class attribute of bird, and the reference to the attribute is through object.property ( object.attribute).

Poor summer, you are just a hairy egg product, so delicate.

Action

In daily cognition, when we identify categories through attributes, we sometimes distinguish categories based on what this thing can do. For example, birds move. In this way, the bird is distinguished from the category of house. These actions will bring certain results, such as movement leading to position changes.

Some such "behavior" attributes are methods. In Python, methods are described by defining functions inside the class.

class Bird(object):
    have_feather = True
    way_of_reproduction = 'egg'
    def move(self, dx, dy):
        position = [0,0]
        position[0] = position[0] + dx
        position[1] = position[1] + dy
        return position
summer = Bird()
print 'after move:',summer.move(5,8)

We have redefined the category of birds. Bird has a new method attribute, which is the method move that represents movement. (I admit that this method is silly. You can define a more interesting method after reading the next lecture)

(There is a self in its parameters, which is to facilitate us to refer to the object itself. The first parameter of the method It must be self, regardless of whether it is used. The content about self will be expanded in the next lecture)

The other two parameters, dx, dy, represent the distance moved in the x and y directions. The move method will eventually return the calculated position.

When we finally called the move method, we only passed the two parameters dx and dy, and there was no need to pass the self parameter (because self is only for internal use).

My summer is ready to run.

Subcategories

The category itself can be further subdivided into subcategories

For example, birds can be further divided into chickens, wild geese, and orioles.

In OOP, we express the above concepts through inheritance.

class Chicken(Bird):
    way_of_move = 'walk'
    possible_in_KFC = True
class Oriole(Bird):
    way_of_move = 'fly'
    possible_in_KFC = False
summer = Chicken()
print summer.have_feather
print summer.move(5,8)

The newly defined Chicken class adds two attributes: way of movement (way_of_move), which may be found in KFC (possible_in_KFC)

When defining the class, the parentheses are Bird. This shows that Chicken is a subclass of Bird, that is, Chicken inherits from Bird. Naturally, Bird is the parent class of Chicken. Chicken will enjoy all the attributes of Bird. Although I only declared that summer is a chicken class, it enjoys the attributes of the parent class through inheritance (whether it is the variable attribute have_feather or the method attribute move)

The newly defined Oriole (Oriole) class also inherits from birds. When you create an oriole object, the object automatically has the properties of the bird.

Through the inheritance system, we can reduce repeated information and repeated statements in the program. If we define two classes separately without inheriting from birds, we must enter the attributes of birds into the definitions of chicken and oriole classes respectively. The entire process can become tedious, therefore, object orientation improves the reusability of the program.

(Back to question 1, the object in the brackets. When the brackets are object, it means that this class has no parent class (the end))

Classify various things to understand the world, starting from human ancestors , we are practicing this cognitive process. Object-oriented is in line with human thinking habits. The so-called process-oriented, that is, executing one statement before executing the next one, is more of machine thinking. Through object-oriented programming, we can express complex ideas in our thinking more conveniently.

Summary

Category things according to attributes (classify objects as classes)

Method is an attribute that represents actions

Use inheritance to illustrate the parent class-subclass relationship. Subclasses automatically have all the properties of the parent class.

self represents the object created based on the class definition.

Create an object: object name = class name()

Reference the attributes of the object: object.attribute