Aprendizado Python [herança, encapsulamento, polimorfismo]

#Para selecionar a linguagem de programação TOP1 em seu coração#

prefácio

Já se passaram três semanas desde o último artigo [classes e objetos] do aprendizado de python . Este artigo apresentaAs três principais características da orientação a objetos - encapsulamento, herança, polimorfismo.

Para iniciantes em programação, 学习python应该是比较好入手的,文末会给大家介绍下python的一些特点，供需要学习编程语言的伙伴一个简单的参考。

Sabemos que o python é umlinguagem orientada a objetos, as três principais características da orientação a objetos sãoEncapsulamento, herança, polimorfismo.

encapsulamento

A finalidade da embalagem

1: Encapsular dados: proteger a privacidade
2: Encapsular método: isolar a complexidade (apenas algumas interfaces são reservadas para uso externo)

Método de encapsulamento

1: Propriedades e métodos públicos

公有属性和方法可以被类的外部访问和使用, sem adicionar nenhum símbolo especial.

2: Propriedades e métodos privados

双下划线começa com

封装属性: ​​__attr​​
封装方法：​​__func​​

Em Python, você pode usar _ e __ para definir o nível de acesso de um atributo.

以_开头的属性被视为受保护的属性，即它们不应该在类外部被直接访问。但是，它们可以在类的子类和内部方法中被访问。

以__开头的属性被视为私有属性，即它们不应该在类的外部被访问。但是，它们也可以在类的内部方法中被访问。

Deve ser mencionado aqui que python não fará nada com os atributos protegidos em python. Por exemplo, vejamos o seguinte exemplo:

Mas de acordo com as regras em python, não podemos acessar propriedades ou métodos protegidos em uma classe de fora da classe.

Ainda neste exemplo, o que acontece se acessarmos propriedades privadas fora da classe?

Vemos que para propriedades privadas, se quisermos acessá-las fora da classe, AttributeErrorum erro será gerado.

3: decorador de propriedade e decorador de método

属性装饰器é uma função especial que pode ser usada para modificar como as propriedades são acessadas. Em Python, podemos usar decoradores @property e @propertyname.setter para definir propriedades 访问器和修改器.

O decorador @property é usado para definir o acessador da propriedade , que define a propriedade como uma propriedade somente leitura. Quando o código externo tenta modificar esta propriedade, umExceção AttributeError。

O decorador @property name.setter é usado para definir um modificador para uma propriedade , que permite que o código externo modifique o valor dessa propriedade. Quando o código externo tenta ler esta propriedade, umExceção AttributeError。

方法装饰器

O decorador de métodos é utilizado para decorar o método da classe, sua função é adicionar algumas funções adicionais ao método sem alterar a definição do método original, como verificação de permissão, cache, etc.
Decoradores de métodos comuns são decoradores estáticos @staticmethod; decoradores de métodos de classe @classmethod

A seguir, uma introdução detalhada ao encapsulamento de propriedades e métodos privados.Os decoradores em python serão apresentados em outro artigo.

Implementação de encapsulamento

propriedades do pacote

#封装age属性
class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age  #不希望age在类外部被使用
    # 使age可以在类内部被调用
    def show(self):
        print('我的名字:',self.name,'；我的年龄:',self.__age)
stu=Student('tom',10)
stu.show()
#我的名字: tom ；我的年龄: 10

# 在类外调用name  和 age
print('我的名字:',stu.name)
#我的名字: tom

print('我的年龄:',stu.age)  #出现报错AttributeError: 'Student' object has no attribute 'age'

Então, como devemos chamar esse atributo encapsulado de idade? Aqui podemos introduzir uma dir()visãoAtributos de método disponíveis para objetos de instância：

print('实例对象stu可以使用的方法属性有:',dir(stu))   #包含  _Student__age
print('我的年龄是:',stu._Student__age)

Método de encapsulamento

Semelhante ao atributo encapsulation, adicione antes do método que precisa ser encapsulado dentro da classe双下划线 “__”

Da mesma forma, se quisermos 调用封装后的方法, como devemos fazer:

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age  #不希望age在类外部被使用
    # 使age可以在类内部被调用
    def __show(self):
        print('我的名字:',self.name,'；我的年龄:',self.__age)
stu=Student('tom',10)
stu._Student__show()

Pode ser visto a partir disso:
o encapsulamento do Python não é no verdadeiro sentido de que não pode ser chamado externamente. É diferente de linguagens como java e PHP. Se o Python for usado 调用封装的属性或方法, ele precisa ser adicionado antes de métodos e atributos _类名.

Então, como as propriedades e métodos em python ainda podem ser chamados após serem encapsulados, qual é o significado do encapsulamento?

O objetivo do encapsulamento é ocultar os detalhes de implementação da classe e expor apenas as interfaces necessárias para uso externo. Se uma propriedade ou método for exposto como acessível, ele se tornará vulnerável a ataques e abusos. Por exemplo, se um __init__()método de uma classe pode aceitar qualquer número de parâmetros, qualquer um pode construir um objeto malicioso e chamar esse método.
Ao definir propriedades ou métodos como privados, garantimos que apenas objetos dentro da classe possam acessá-los. 这有助于保护类的实现细节，防止不必要的干扰和错误。Além disso, o encapsulamento também ajuda a melhorar a capacidade de manutenção e reutilização do código, pois pode ocultar os detalhes de implementação da classe,使代码更加清晰和易于理解。

Encapsulamento de classes pai e filho

子类的封装属性以及方法不会覆盖父类的封装属性或方法

# 子类封装的方法或属性不会覆盖父类的方法或属性
class A:
    __name = 'A'   # 变形为_A__name
    def get_x(self):
        print('父类A:',self.__name)


class A1(A):       # A1 继承了 A 的方法和属性
    __name='我是父类A的子类A1'  #变形为_A1__name
    def __say(self):
        print('这是子类A1的实例方法')
# A1的实例对象
obj = A1()
# 调用父类A的实例方法
obj.get_x()   #父类: A

resumo

Do exemplo acima obtemos:

类的封装不是真正意义上的“私有化”，而是一个语法上的变形
类的封装属性或方式，其实在定义阶段就已经进行了语法上的变形
类的调用阶段，再进行封装语法已经没有任何用处了

herdar

O significado de herança

O mecanismo de herança em python é frequentemente usado 创建和现有类功能类似的新类, ou novas classes precisam apenas adicionar alguns membros (atributos e métodos) com base nas classes existentes, mas não desejam copiar diretamente o código de classe existente para a nova classe. Quer dizer,Quando precisamos reutilizar classes, podemos usar esse mecanismo de herança para conseguir.

Implementação herdada

Em Python,A classe que implementa a herança é chamada de subclasse, e a classe que é herdada é chamada de classe pai;

Quando uma subclasse herda a classe pai, você só precisa colocar a classe pai (pode ser múltipla) entre parênteses após a subclasse ao definir a subclasse:

class 类名(父类1, 父类2, ...)：
    #类定义部分

Em python, se uma classe não especifica herdar uma determinada classe, a classe de objeto é herdada por padrão., vejamos este exemplo:

# 编写Person类，以及继承Person类的两个子类Student和Teacher
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('姓名:',self.name,'年龄:',self.age)
# Student类
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
# Teacher 类
class Teacher(Person):
    def  __init__(self,name,age,teach_year):
        super().__init__(name,age)
        self.teach_year=teach_year
# 创建学生对象和教师对象
stu1=Student('小明',17,1001)
teacher1=Teacher('张丽',30,6)   
stu1.info()
teacher1.info()
'''
姓名: 小明 年龄: 17
姓名: 张丽 年龄: 30
'''

A relação de herança neste exemplo não é complicada. Uma classe Person é definida e nenhuma classe é especificada para herdar da classe objeto por padrão (a classe objeto é a classe pai de todas as classes em Python, ou seja, é uma classe pai direta ou uma classe pai indireta); Em seguida, defina duas subclasses da classe Person: a classe Student e a classe Teacher, que herdam a classe Person, respectivamente.

substituição de método

Se a subclasse estiver insatisfeita com um atributo ou método herdado da classe pai, ela pode reescrevê-lo (corpo do método) na subclasse; o método reescrito da subclasse pode ser reescrito chamando o método substituído no método da classe pai super().xxx() :

class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('名字:',self.name,'年龄:',self.age)
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    #方法重写
    def info(self):
        super().info()  #调用父类的info()
        print('学号是：',self.stu_no)
class Teacher(Person):
    def __init__(self,name,age,teach_year):
        super().__init__(name,age)
        self.teach_year=teach_year
     #方法重写
    def info(self):
        super().info()#调用父类的info()
        print('教龄是：',self.teach_year)
stu1=Student('小华',17,1001)
teacher1=Teacher('赵丽',40,10)
stu1.info()
'''
名字: 小华 年龄: 17
学号是： 1001
'''
print('\n---------------教职工-------------\n')
teacher1.info()
'''
名字: 赵丽 年龄: 40
教龄是： 10
'''

Se uma classe é uma classe vazia, mas herda uma classe com métodos e propriedades, essa classe também contém os métodos e propriedades da classe pai:

class People:
    def __init__(self,name):
        self.name =name
    def say(self):
        print("People类",self.name)

class Animal:
    def __init__(self):
        self.name = Animal
    def say(self):
        print("Animal类",self.name)
#People类是Person父类中最近的父类，因此People中的name属性和say()方法会遮蔽 Animal 类中的
class Person(People, Animal):
    pass

zhangsan=Person('张三')
zhangsan.say()   # People类 张三

Pode-se ver que quando Person herda a classe People e a classe Animal ao mesmo tempo, a classe People vem primeiro, portanto, se People e Animal tiverem um método de classe com o mesmo nome, a chamada real será na classe People; também pode ser visto que,Python suporta herança múltipla。

classe de objeto

Anteriormente mencionamos:A classe de objeto é a classe pai de todas as classes, então todas as classes têm as propriedades e métodos da classe de objeto, aqui vamos dar uma olhada em alguns dos métodos desta classe.

1: A função interna dir()pode visualizar todas as propriedades do objeto especificado

2: object tem um __str__()方法, que é usado para retornar uma descrição do objeto, correspondente à função interna str(), que é frequentemente usada no método print() para nos ajudar a visualizar as informações do objeto, então nós frequentemente reescreve __str__().

A função embutida dir()

método str ()

# 定义方法再输出实例对象
class Student():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    # 进行方法重写
    def __str__(self):
        return '名字是{},年龄是{}'.format(self.name,self.age)  #格式化字符串
stu=Student('luky',18)
print(stu,type(stu)) #默认调用__str__()方法，返回的类型就是该方法的内容
# 名字是luky,年龄是18 <class '__main__.Student'>

polimorfismo

Python é uma linguagem dinâmica e sua característica mais óbvia é que, ao usar variáveis, não há necessidade de especificar tipos de dados específicos para elas. Isso levará a uma situação em que a mesma variável pode ser atribuída a diferentes objetos de classe sucessivamente.

class Animal:
    def say(self):
        print("赋值的是Animal类的实例对象")
class Plant:
    def say(self):
        print("赋值的是Plant类的实例对象")
a = Animal()
a.say()
# 赋值的是Animal类的实例对象

a = Plant()
a.say()
# 赋值的是Plant类的实例对象

Neste exemplo, vemos que a pode ser atribuído a objetos da classe Animal e da classe Plant sucessivamente, mas isso não é polimorfismo. O recurso polimórfico de uma classe também deve atender aos dois pré-requisitos a seguir:

1: Herança: polimorfismo deve ocorrer entre subclasses e classes pai;

2: Reescrita: A subclasse substitui o método da classe pai.

No entanto, como uma linguagem dinâmica, python não precisa se preocupar com o relacionamento de herança da classe, mas apenas se alguns métodos de atributos são definidos na classe. Vamos escrever o exemplo acima novamente:

class Animal:
    def say(self):
        print("调用的是 Animal 类的say方法")
class Plant(Animal):
    def say(self):
        print("调用的是 Plant 类的say方法")
class People(Animal):
    def say(self):
        print("调用的是 People类的say方法")
a = Animal()
a.say()
# 调用的是 Animal 类的say方法

a = Plant()
a.say()
# 调用的是 Plant 类的say方法

a = People()
a.say()
# 调用的是 People类的say方法

Pode-se ver que tanto a classe Plant quanto a classe People herdam a classe Animal, e cada uma reescreve o método say() da classe pai. Pode ser visto nos resultados da execução que quando a mesma variável a executa o mesmo método say(), já que a realmente representa objetos de instância de diferentes classes, a.say() não chama o método say() na mesma classe , que é o polimorfismo.

Também podemos definir uma função fora da classe e determinar dinamicamente qual método chamar chamando a função de objetos de instância de diferentes classes:

class Flower:
    def color(self):
        print('花是五颜六色的')
class Rose(Flower):
    def color(self):
        print('玫瑰是红色的')
class Moli(Flower):
    def color(self):
        print('茉莉是白的的')
class Plant:
    def color(self):
        print('花属于植物')
# 定义一个函数
def fun(obj):
    obj.color()
# 调用函数
fun(Flower())  #花是五颜六色的
fun(Rose())   #玫瑰是红色的
fun(Moli())   #茉莉是白的的
print('-----------无任何继承关系的植物类-------\n')
fun(Plant()) #花属于植物     虽然植物类和其他定义了的类无继承关系，但是在该类中定义了color实例方法，因此会在调用时执行该方法

por isso:

Polimorfismo pode ser entendido simplesmente como: ter múltiplas formas, o que significa que mesmo que você não saiba a que tipo de objeto uma variável se refere, você ainda pode chamar um método através dessa variável; durante a operação, de acordo com o tipo de objeto referenciado por uma variável, decida dinamicamente qual método chamar no objeto.

sobre python

Python é uma linguagem de programação de alto nível amplamente utilizada em vários campos diferentes, incluindo desenvolvimento de software, ciência de dados, programação web e inteligência artificial, entre outros. Python tem muitos recursos, incluindo facilidade de aprendizado, sintaxe simples, digitação dinâmica, design orientado a objetos, programação modular, portabilidade e amplo suporte a bibliotecas de terceiros.

para iniciantes

Para iniciantes em programação,Python é mais legível, principalmente nos seguintes aspectos:

1: python usa indentação para representar um bloco de código, o que também tornará o nível de código mais distinto e fácil de se referir;
2: a sintaxe de python é relativamente simples e muitas palavras-chave são bem conhecidas pelo nome

Ao mesmo tempo, o python tem forte suporte a bibliotecas de terceiros, podemos chamar essas bibliotecas diretamente, o que melhora muito nossa eficiência de desenvolvimento.

Ferramentas usadas

O editor Python mais usado épycharm

Você mesmo pode procurar tutoriais de instalação na Internet. 这里我把我在安装过程中出现的一个路径问题提一下，希望可以提供些帮助：
Se não exibirmos os resultados da execução durante a instalação do pycharm, é basicamente porque o caminho do arquivo do interpretador python não foi colocado no editor pycharm. A solução é a seguinte:

Primeiro encontre o caminho do interpretador python:
você pode usar a linha de comando do Windows para inserir where python

Você também pode encontrar python.exe diretamente no gerenciador de recursos:

Em seguida, copie o caminho do python.exe e abra o pycharm:

Por fim, adicione o caminho ao interpretador Base do pycharm e reinicie o pycharm:

como aprender

Embora o python seja relativamente simples de começar, como outras linguagens de programação, apenas a prática pode fornecer o verdadeiro conhecimento. As explicações nos livros são relativamente obscuras, podemos encontrar alguns recursos de vídeo na Internet para assistir ( ), e temos que digitá-los sozinhos 比如B站上的python教程，大家择优选择enquanto assistimos ,一定一定Não importa qual idioma você aprenda, você precisa fazer isso sozinho. Somente quando você encontrar bugs durante a operação, poderá usar os recursos ao seu redor para resolvê-los, quando ocorre um bug, podemos 将报错信息直接粘到浏览器, porque os motivos do relatório de erro de cada pessoa são diferentes, então temos que tentar mais e pensar mais. Além disso, podemos 将我们的程序中报错的代码块直接放到GitHubverificar online se existe uma solução semelhante para o erro, ou 去询问chatgptse temos uma solução e assim por diante. Fangzheng é - desde que a mente não escorregue, sempre há mais caminhos do que dificuldades!

Além disso 多刷题, por exemplo, você pode acessar Niuke.com para encontrar perguntas,Tente pensar primeiro e depois responda de acordo com seus próprios pensamentos no editor. Se a operação falhar, você deve depurá-la e analisá-la você mesmo. Esse processo é muito importante e a chave para inferir outros casos de uma instância.

uma palavra por artigo

A luz das estrelas compensa!

Se houver alguma deficiência, obrigado por corrigir!