Bases de Python : (sept) classes

avant-propos

       Python est un excellent langage de programmation orienté objet. En programmant dans un langage de programmation orienté objet, vous écrivez des classes qui représentent des choses et des situations dans le monde réel, et créez des objets basés sur ces classes.
       Les objets créés à partir d'une classe sont appelés instanciations.

1. Créer et utiliser des cours

La classe est expliquée avec un exemple, et l'explication est ajoutée au code sous forme de commentaires.

class Person: #关键词class 定义了一个类，类名是Persson，根据python约定，首字母大写的名称指的是类。
    """描述人的行为信息""" #文档字符串注释，描述这个类
    def __init__(self,name,age): #__init__()是一个特殊方法，有三个形参值，并且self必不可少，并且必须放在最前面
        """初始化属性name和age"""
        self.name = name #self.name 和self.age都有前缀self以self为前缀的变量可以在类中的所有方法使用（就是def xxxx使用这个变量，但是必须加前缀self）
        self.age = age #self.name和self.age 也称作属性，属性就是通过实例访问的变量

    def walk(self): #定义另一个方法，走路，
        """模拟模特收到命令时走路"""
        print(f"{
      
      self.name} is now walking!")

"""下面是使用类"""
person = Person('Mayahei',20) #python创建人的一个实例，并将这个实例赋值给变量person
print(person.name) #person此时是一个实例，我们可以通过句点法，（就是.）来访问属性
print(person.age) #同person.name

"""下面是调用类的方法，也就是def xxxx"""
person.walk() #通过实例person调用方法walk（walk就是打印模特正在走路）

Résultat courant :

2. Utiliser des classes et des instances

2.1 Affecter des valeurs par défaut aux attributs

Appelez simplement l'instruction d'affectation directement sur l'attribut.

class Person:
    """描述人的行为信息"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
        self.height = '100cm' #给属性指定默认值

    def walk(self):
        """模拟模特收到命令时走路"""
        print(f"{
      
      self.name} is now walking!")

    def print_height(self):
        """打印模特的身高"""
        print(f"模特的身高为：{
      
      self.height}")
        

"""下面是使用类"""
person = Person('Mayahei',20)

"""下面是调用类的方法，也就是def xxxx"""
person.print_height() #调用print_height方法打印模特身高

résultat de l'opération :

2.2 Modifier la valeur de l'attribut

Il existe trois façons de modifier la valeur de l'attribut, qui seront expliquées une par une ci-dessous.

2.2.1 Modifier directement la valeur de l'attribut

La modification directe de la valeur de l'attribut est l'application de l'instruction d'affectation, il suffit de connecter l'instance et l'attribut via une période.
实例.属性值
Prenons l'exemple de cet article.

person.height = '200cm' #指定的默认值为100，通过修改变为200，进而通过方法打印出来。

class Person:
    """描述人的行为信息"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
        self.height = '100cm' #给属性指定默认值

    def walk(self):
        """模拟模特收到命令时走路"""
        print(f"{
      
      self.name} is now walking!")

    def print_height(self):
        """打印模特的身高"""
        print(f"模特的身高为：{
      
      self.height}")


"""下面是使用类"""
person = Person('Mayahei',20)

"""下面是调用类的方法，也就是def xxxx"""
person.height = '200cm' #指定的默认值为100，通过修改变为200，进而通过方法打印出来。
person.print_height() #调用print_height方法打印模特身高

résultat de l'opération :

2.2.2 Modifier la valeur de la propriété par la méthode

L'essence de cette méthode est l'instruction d'affectation, mais l'instruction d'affectation est encapsulée dans la méthode, voir l'exemple suivant :

    def update_height(self,value):#define了一个新的方法，作用就是更新属性值
        """更新属性值"""
        self.height = value

class Person:
    """描述人的行为信息"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
        self.height = '100cm' #给属性指定默认值

    def print_height(self):
        """打印模特的身高"""
        print(f"模特的身高为：{
      
      self.height}")

    def update_height(self,value):#define了一个新的方法，作用就是更新属性值
        """更新属性值"""
        self.height = value


"""下面是使用类"""
person = Person('Mayahei',20)

"""下面是调用类的方法，也就是def xxxx"""
person.update_height('300cm') #调用更新属性值的方法，
person.print_height() #调用print_height方法打印模特身高

résultat de l'opération :

2.2.3 Incrémenter la valeur d'un attribut par une méthode

Il s'agit en fait d'une extension de la modification des valeurs d'attribut via des méthodes, c'est-à-dire xxx+=numberl'application dans la définition de méthodes.

    def update_height(self,value):#define了一个新的方法，作用就是更新属性值
        """更新属性值"""
        self.height += value #xxx+=number

class Person:
    """描述人的行为信息"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
        self.height = 100 #给属性指定默认值

    def print_height(self):
        """打印模特的身高"""
        print(f"模特的身高为：{
      
      self.height}cm")

    def update_height(self,value):#define了一个新的方法，作用就是更新属性值
        """更新属性值"""
        self.height += value


"""下面是使用类"""
person = Person('Mayahei',20)

"""下面是调用类的方法，也就是def xxxx"""
person.update_height(300) #调用更新属性值的方法，
person.print_height() #调用print_height方法打印模特身高

résultat de l'opération :

3. Héritage

       Les étudiants avec une fondation frontale ne devraient pas avoir de difficulté à comprendre cet héritage, mais vous pouvez y regarder de plus près, il n'est pas difficile de lire plus et de taper plus de code.
       Lors de l'écriture d'une classe, il n'est pas nécessaire de redéfinir, et des attributs et méthodes peuvent être ajoutés sur la base des classes existantes.

3.1 Méthode de sous-classe __init__()

• Les classes parent et enfant doivent être dans le même fichier .py
• La classe parent doit précéder la classe enfant
• Lors de la définition d'une sous-classe, le nom de la classe mère doit être écrit entre parenthèses
• La méthode de sous-classe __init__() accepte les informations requises par l'instance de la classe parent
• Appelez la fonction super(), puis utilisez la méthode dans la classe parent

Les commentaires de code sont marqués un par un :

class Person: #父类
    """描述人的行为信息"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
        self.height = 100

    def print_height(self):
        """打印模特的身高"""
        print(f"模特的身高为：{
      
      self.height}cm")

class New_Person(Person): #子类，定义子类时必须在括号内写入父类的名称----Person
    """定义一个Person子类，打印体重"""
    def __init__(self,name,age): #子类方法__init__()接受父类实例所需的信息
        super().__init__(name,age) #调用super()函数，进而使用父类中的方法


"""下面是使用类"""
new_person = New_Person('Mayahei',20)
print(f"模特的名字是：{
      
      new_person.name}")

"""下面是调用类的方法，也就是def xxxx"""
new_person.print_height() #调用父类中的方法：print_height方法打印模特身高(子类中没有这个方法)

résultat de l'opération :

3.2 Définir les propriétés et les méthodes des sous-classes

C'est-à-dire l'application de l'instruction d'affectation :

		"""给子类定义属性"""
        self.weight = 100 #给属性指定默认值,

  """给子类定义方法"""
    def print_weight(self): #新建新的方法
        """打印体重"""
        print(f"模特的体重为：{
      
      self.weight}kg!")

class Person: #父类
    """描述人的行为信息"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
        self.height = 100

    def print_height(self):
        """打印模特的身高"""
        print(f"模特的身高为：{
      
      self.height}cm")

class New_Person(Person):
    """定义一个Person子类，打印体重"""
    def __init__(self,name,age):
        super().__init__(name,age)
        """给子类定义属性"""
        self.weight = 100 #给属性指定默认值

    """给子类定义方法"""
    def print_weight(self): #新建新的方法
        """打印体重"""
        print(f"模特的体重为：{
      
      self.weight}kg!")


"""下面是使用类"""
new_person = New_Person('Mayahei',20)

"""下面是调用类的方法，也就是def xxxx"""
new_person.print_weight() #调用子类中的方法：print_weight方法打印模特体重

résultat de l'opération :

3.3 Surcharger la méthode de la classe parent

就是一个优先级的问题，在子类中创建一个和父类一样的方法，调用这个方法是，调用的是子类的方法。

résultat de l'opération :

4. Classe d'importation

可以类比导入函数学习。

Définissez d'abord un module, qui stocke spécifiquement les classes, comme illustré dans la figure suivante :

4.1 Syntaxe – 1 :

from 模块名 import 类名

Prends le mien comme exemple :

1. Importez une seule classe :

from class_0 import New_Person

2. Importez plusieurs classes :

from class_0 import New_Person, Person

3. Importez toutes les classes :

from class_0 import *

4.2 Syntaxe – 2

grammaire:

import 模块名 
#然后使用句点法调用方法

par exemple:

import class_0
"""下面是使用类"""
new_person = class_0.New_Person('Mayahei',20)
new_person.print_height()

résultat de l'opération :

ps: Si vous avez besoin d'utiliser un alias, ajoutez simplement as à la fin de l'importation,
par exemple :

from class_0 import New_Person as np