Comprendre la classe et l'objet en Python3 (exemple de code)

Le contenu de cet article porte sur la compréhension des classes et des objets en Python3 (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. .

Qu'est-ce qu'une classe ?
Une classe est un concept abstrait qui fait généralement référence à des choses composées de nombreux individus similaires et présentant des caractéristiques communes. Par exemple, la classe est une voiture
, et cette voiture comprend différents modèles
Qu'est-ce qu'un objet
Une chose spécifique dans la classe. Par exemple, la Wuling Shenche S (la blague sur le fait de tuer la GTR en quelques secondes dans les virages est encore fraîche dans ma mémoire) est l'incarnation de la classe automobile
Il y a d'abord les classes, puis il y a les objets

Comprendre les classes et les objets

def eating():
    print("吃草")
    
def walking():
    print("走路")

eating()
walking()
#(输出)    吃饭
        走路
    
#这样的话，别人也可以调用你写的函数，但是调用eating() 并不能清除的了解到到底是谁 “吃饭”，
#所以我们输入一个name来明确是谁在吃草。

def eating(name):
    print(name,"吃饭")
eating("zhuozi")            #调用函数
#(输出)zhuozi 吃草

#Mais vous constaterez qu'il est logiquement un peu inapproprié d'utiliser zhuozi pour manger, même si c'est grammaticalement bien,

#Nous allons donc faire une classification et diviser. "manger" dans Une classe est divisée en une catégorie, qui est une catégorie, nous la marquons donc, classe Personne :
#Pourquoi le P majuscule est utilisé pour la distinguer des classes des fonctions intégrées de Python. -dans les noms de classe sont tous des lettres minuscules (vous pouvez ctrl + bouton gauche de la souris pour cliquer sur la fonction intégrée pour afficher)

class Person:            #这样我们就将eating封装到了Person这个类里面
                        #只要是Person这一类别的都可以进行下面的行为（eating）
    def eating(name):
        print(name,"吃饭")
        
zhangsan = Person()        #这里就不能像以前一样用eating去调用了，因为只有Person这一类的才能就行eating这个行为
                        #所以我们就要先将zhansan定义为Person这一类    
zhangsan.eating()        #然后才能让张三进行吃草这种行为
#(输出)<__main__.Person object at 0x000001D2CCC21160> 吃饭

lisi = Person()            #lisi也要吃饭，那继续定义lisi 是person 类 他可以吃饭
lisi.eating()            #lisi就可以吃饭了
#(输出)<__main__.Person object at 0x000001BCC6BF1198> 吃饭

#打印的一个地址，一个类的地址 object（翻译就是对象）就表示 lisi是这个类的对象
#lisi 就是 Person这个类 实例化的对象。

Avant de manger (nom) : le nom peut être vu comme qui mange, et l'exigence stricte de la grammaire ici est d'utiliser self pour représenter qui mange. Donc comme suit :

class Person:
    def eating(self):
        print(self,"吃饭")

class Person:
    pass
========
list  这里我们ctrl + 鼠标左键点击pycharm 里面书写的list，如图：

On peut voir que les noms de classe des fonctions intégrées sont tous en minuscules, et la classe que nous avons utilisée auparavant (nom de la liste) .append() est également l'appel de la fonction sous la classe dont nous parlons maintenant. Le nom de l'objet entre parenthèses est self et le nom de la liste est l'objet instancié.

Syntaxe

class 类名(父类列表)：        #类名和变量名称的命名是一样的，类名首字母要大写，
                            #用来区别是否是内置函数自带的类
    类体
    
数据属性                        #类的共同属性，名字，性别，干什么的，等等

方法属性                        #这个类共同都有的功能，跑，跳，计算，记录等等

class Person:
    pass

zhangsan = Person()                #张三是Person实例化的对象，所以要开辟一个内存来存储，
                                #即将zhangsan变量名指向这个内存地址
print(zhangsan)
#(输出)<__main__.Person object at 0x00000194D8D28400>

既然实例化对象后开辟了内存，我们就要在里面进行一个存储

On peut voir que les identifiants des deux objets instanciés sont différents

class Person:
    pass

zhangsan = Person()
zhangsan.name = "zhangsan"                #给这个实例化的对象附一个名字
print(zhangsan)
#(输出)<__main__.Person object at 0x0000018DF6598400>

print(zhangsan.name)                    #打印出这个对象的名字
#(输出)zhangsan

zhangsan对象名 指向  内存，内存里面有一个属性name，而name指向zhangsan这个名字  两个zhngsan 不一样啊
zhangsan（类的对象名字）  -- 》内存 （name）----》zhangsan（对象的属性）

lisi = Person()                    #再实例化一个对象
lisi.name = "xiaolong"
print(lisi.name)    
print(id(lisi.name))            
lisi = Person()
lisi.name = "xiaolong"

print(id(zhangsan))
#(输出)2070146453856
print(lisi.name)
#(输出)xiaolong
print(id(lisi.name))
#(输出)2070146521264

Voici le nommage Espace règles :

Chaque fois qu'un objet est instancié, il occupera une mémoire de stockage distincte du système si aucun traitement spécial n'est effectué.

class Person:
    pass

zhangsan = Person()                    
zhangsan.name = "zhangsan"
zhangsan.sex = "男"
zhangsan.age = 19
zhangsan.hight = 175

lisi = Person()
lisi .name = "xiaolong"
lisi .sex = "女"
lisi .age = 29
lisi .hight = 170
#两个内容的创建方式相同啊，只是内容不同，那么我们写一个函数来进行这种重复性的操作，

class Person:
    def __init__(self, name, sex, age, hight):
        self.name = name        zhangsan.name = name
        self.sex = sex            zhangsan.name = sex
        self.age = age            zhangsan.name = age
        self.hight = hight        zhangsan.name = hight
#self 是为了规范明确是谁调用了，所以相当于将zhangsan这个对象传给了self。
#而后面self之后的name, sex, age, hight 就是所要传入的"zhangsan" "男"19 175 信息
#zhangsan = Person()                
#zhangsan.name = "zhangsan"
#zhangsan.sex = "男"
#zhangsan.age = 19
#zhangsan.hight = 175

这样我们就不用再像上面一样传入了
zhangsan = Person("zhangsan","男","19",175)
print(zhangsan.name)
#(输出)zhangsan

init : est une fonction spéciale qui existe dans le système lorsque nous instancions un objet (zhangsan = Person("zhangsan","male","19. ",175)), l'objet instancié par défaut est utilisé pour appeler cette fonction. def init(self, name, sex, age, hight) :Le nom de l'objet self est zhangsan avant le signe égal,
et le nom, le sexe, l'âge, la taille correspondent à "zhangsan" ,"Homme","19",175

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!