Python (quatro) orientado a objetos

1. Objeto

1. O que é um objeto ?

Um objeto é uma área de memória dedicada ao armazenamento de dados. Os objetos podem armazenar vários dados (como números, booleanos, códigos, etc.).

• O objeto consiste em três partes:

  ①A identificação do objeto (id)
  ②O tipo do objeto (tipo)
  ③O valor do objeto (valor)

2. Ideias de programação

Python é uma linguagem de programação orientada a objetos.

• Orientado ao processo: Orientado ao processo refere-se a decompor a lógica do nosso programa passo a passo, o que fazer primeiro
• Orientado a objetos : Orientado a objetos refere-se a atribuir nossos programas a objetos para operar, o que você faz?

Em segundo lugar, a classe (classe)

(1) Definição de uma classe

1. O que é uma aula ?

Definir uma classe é definir um modelo para essa classe de objetos e definir suas propriedades e métodos. As classes também são objetos.

2. Atributos e métodos de classe

• As variáveis ​​se tornarão propriedades da instância da classe e todas as instâncias da classe poderão acessar as propriedades na forma de object.property name
• A função se tornará o método da instância da classe , e todas as instâncias da classe podem chamar o método na forma de object.methodname ()

(2) Criar uma classe

1, a estrutura básica da classe

class 类名([父类]) :#class关键字来声明一个类

    公共的属性...

    # 对象的初始化方法，类的构造方法
    def __init__(self,...):
        ...

    # 其他的方法    
    def method_1(self,...):
        ...

    def method_2(self,...):
        ...

2. Construtor de classe (método mágico) _ init _

3. self no método da classe

• Toda vez que o método é chamado, o analisador passará automaticamente o primeiro argumento, o primeiro parâmetro é a classe de chamadao próprio objeto de instância, portanto, pelo menos um parâmetro formal deve ser definido no método . Geralmente, chamaremos esse parâmetro de self.

• Self só existe em métodos de classe, funções independentes não precisam carregar self. self é necessário ao definir um método de uma classe, embora não seja necessário passar os parâmetros correspondentes ao chamá-lo.

• Você pode vincular várias propriedades de um objeto a self. self.val = val, que significa atribuir o valor do parâmetro externo val ao atributo de instância val do objeto de instância atual da classe Myclass.

• self não é uma palavra-chave de python, e pode ser nomeado por outros nomes, mas por uma questão de especificação e fácil compreensão dos leitores, é recomendado usar self.

• Se você não adicionar self, significa que é um atributo da classe (pode ser referenciado por "class name.variable name"), e adicionar self significa que é um atributo de uma instância da classe (pode ser referenciado por "nome da instância.nome da variável" ).

class Person:
    def say_hello(a):#方法每次被调用时，解析器都会自动传递第一个实参
        print('a参数：'.rjust(9,' '),a)#第一个参数，就是调用方法的对象本身，也就是类的实例本身

p1 = Person()#创建实例p1
print('实例对象p1：',p1)
p1.say_hello()

print('*'*100)
p2 = Person()#创建实例p2
print('实例对象p2：',p2)
p2.say_hello()

class Human():
    val = '哈哈哈'#类的属性，公共的属性
    def __init__(self,val = '我是人类'):#类的初始化方法，注意：构造方法的返回值必须是"None"
        self.val = val #通过self向类实例中初始化属性

    def yellow_people(self,val = '我是黄种人'):#类的方法（函数）
        self.val = val 
        self.val1 = '我自豪'
        return self.val,self.val1#多个返回值

    def white_people(self,val = '我是白种人'):
        self.val = val 
        return self.val

print(Human.val)#Human是一个类，通过Human.val（类名.变量名）可以引用类的属性，输出：哈哈哈
print(Human().val)#Human()创建了一个类的实例，val变量加了self，表示类的实例Human()的一个属性，通过Human().val（实例名.变量名）引用，输出：我是人类
print(Human().yellow_people())

Compreensão de si mesmo em python

3. Encapsulamento, Herança, Polimorfismo

As três principais características da orientação a objetos:
Encapsulamento: para garantir a segurança dos dados
no objeto Herança: para garantir a extensibilidade do objeto
Polimorfismo: para garantir a flexibilidade do programa

(1) Encapsulamento

Encapsulamento, como o nome indica, é encapsular o conteúdo em algum lugar e, em seguida, chamar o conteúdo de encapsulado em algum lugar.
Para o encapsulamento orientado a objeto, na verdade é usar o construtor para encapsular o conteúdo no objeto e, em seguida, obter o conteúdo encapsulado direta ou indiretamente por meio do objeto.

(2) Herança

Uma nova classe é formulada com base em uma classe, que pode não apenas herdar as propriedades e métodos da classe original, mas também adicionar novas propriedades e métodos. A classe original é chamada de classe pai e a nova classe é chamada de classe filha.

# 定义一个类 Animal（动物），这个类中需要三个方法：run() sleep() bark()
class Animal:
    def run(self):
        print('动物会跑~~~')

    def sleep(self):
        print('动物睡觉~~~')

    def bark(self):
        print('动物嚎叫~~~')

# 有一个类，能够实现我们需要的大部分功能，但是不能实现全部功能
# 如何能让这个类来实现全部的功能呢？
#   ① 直接修改这个类，在这个类中添加我们需要的功能
#       - 修改起来会比较麻烦，并且会违反OCP原则
#   ② 直接创建一个新的类
#       - 创建一个新的类比较麻烦，并且需要大量的进行复制粘贴，会出现大量的重复性代码
#   ③ 直接从Animal类中来继承它的属性和方法
#       - 继承是面向对象三大特性之一
#       - 通过继承我们可以使一个类获取到其他类中的属性和方法
#       - 在定义类时，可以在类名后的括号中指定当前类的父类（超类、基类、super）
#           子类（衍生类）可以直接继承父类中的所有的属性和方法
#
#  通过继承可以直接让子类获取到父类的方法或属性，避免编写重复性的代码，并且也符合OCP原则
#   所以我们经常需要通过继承来对一个类进行扩展
class Dog(Animal):
    def bark(self):
        print('汪汪汪~~~')

    def run(self):
        print('狗跑~~~~')

class Hashiqi(Dog):
    def fan_sha(self):
        print('我是一只傻傻的哈士奇')

d = Dog()
h = Hashiqi()

d.run()#多态
d.sleep()#继承
d.bark()#多态
h.fan_sha()

(3) Polimorfismo

Quando a subclasse e a superclasse tiverem o mesmo método, o método da subclasse substituirá o método da superclasse, e esse código sempre chamará o método da subclasse em tempo de execução, que é polimorfismo.

Quatro, vários métodos orientados a objetos

(1) Método estático ( @staticmethod )

(2) Método de classe (@classmethod)

(3) Método de propriedade (@property)

class Person:
    def __init__(self,name,age):
        self._name = name
        self._age = age

    # property装饰器，用来将一个get方法，转换为对象的属性
    # 添加为property装饰器以后，我们就可以像调用属性一样使用get方法
    # 使用property装饰的方法，必须和属性名是一样的
    @property    
    def name(self):
        print('get方法执行了~~~')
        return self._name

    # setter方法的装饰器：@属性名.setter
    @name.setter    
    def name(self , name):
        print('setter方法调用了')
        self._name = name        

    @property
    def age(self):
        return self._age

    @age.setter    
    def age(self , age):
        self._age = age   

        

p = Person('猪八戒',18)

p.name = '孙悟空'
p.age = 28

print(p.name,p.age)

Cinco, orientação a objetos avançada

6. Módulos e pacotes

Referências:
1. Python orientado a objetos (quatro)
2. Explicação abrangente e detalhada orientada a objetos Python