Introduction détaillée à la programmation orientée objet Python

1. Qu'est-ce que l'orientation objet

L'orientation objet (oop) est une méthode abstraite pour comprendre le monde. Tout dans le monde peut être abstrait dans un objet, et tout est composé d'objets. Appliquée en programmation, c'est une méthode de développement de programmes qui utilise des objets comme unité de base du programme.

2. La différence entre l'orienté objet et l'orienté processus

Nous avons déjà introduit l'orienté processus. Le cœur de l'orientation processus est le mot « processus ». résoudre des problèmes. Orienté processus La méthode de conception d'un programme est comme la conception d'une chaîne de montage, qui est une façon de penser mécanique

Avantages : Les problèmes complexes sont simplifiés et rationalisés

Inconvénients : Faible évolutivité

Les principaux scénarios d'application incluent : le noyau Linux, git et le service http

Programmation orientée objet, le noyau est l'objet et l'objet est la combinaison de caractéristiques (variables) et de compétences ( fonctions).

Avantages : résoudre le problème de la mauvaise évolutivité du programme

Inconvénients : mauvaise contrôlabilité, impossible de prédire le résultat final

Le principal scénario d'application est un logiciel dont les besoins changent fréquemment, qui est, avec les utilisateurs Logiciel avec des interactions fréquentes

Il est à noter que la programmation orientée objet ne résout pas tous les problèmes, elle ne sert qu'à résoudre l'évolutivité. Bien sûr, dans les logiciels Internet d'aujourd'hui, l'évolutivité est le plus important

3. Le concept d'objets et de classes

En python, tout est un objet, et un objet doit avoir ses propres attributs, et C'est une fonctionnalité, et elle a sa propre fonction, c'est-à-dire une méthode

En Python, les fonctionnalités sont représentées par des variables et les fonctions sont représentées par des fonctions, donc l'objet est une combinaison de variables et de fonctions

et de chaque Une classe est extraite de divers objets avec les mêmes caractéristiques et fonctions. Par conséquent, une classe est une combinaison de caractéristiques et de fonctions communes d'une série d'objets

Définissons une. class avec des méthodes et Définir une fonction est quelque peu similaire :

#定义一个中国人的类class Chinese:#共同的特征country='China'#共同的技能def talk(self):print('is talking Chinese')def eat(self):print('is eating Chinese food')

De cette façon, nous avons défini une classe Remarque : 1. Utilisez le mot-clé class

. pour définir une classe. 2. Nom de la classe Généralement, la première lettre est en majuscule et il n'y a pas besoin de parenthèses avant les deux points, ce qui est différent de la définition de la fonction
3. Contrairement aux fonctions, les classes exécuteront le code dans la classe. pendant l'étape de définition

4. Les classes ont deux attributs, Les caractéristiques communes sont appelées attributs de données, et les fonctions communes sont appelées attributs de fonction

Comment générer un objet à partir de cette classe ? Instanciation :

p1=Chinese()
p2=Chinese()

On peut conclure que peu importe ce qui se passe dans le monde réel, dans un programme, il y a bien d'abord une classe, et ensuite il y a des objets

Nous avons obtenu deux objets par instanciation, mais il y a un problème. Les deux objets obtenus ont les mêmes caractéristiques et fonctions. Ce concept selon lequel tout est un objet est complètement incompatible avec cela. Les objets sont tous différents. un tel monde est intéressant

En fait, lorsque nous avons défini la classe, nous avons oublié de définir la fonction __init__() La méthode de définition correcte devrait être comme ceci :

#定义一个中国人的类class Chinese:#共同的特征country='China'#初始化def __init__(self,name,age):
        self.name=name  #每个对象都有自己的名字self.age=age    #每个对象都有自己的年龄#共同的技能def talk(self):print('is talking Chinese')def eat(self):print('is eating Chinese food')#实例化的方式产生一个对象p1=Chinese('zhang',18)

Le nom de la classe entre parenthèses est instanciation. L'instanciation déclenchera automatiquement l'exécution de la fonction __init__ Vous pouvez l'utiliser pour personnaliser vos propres caractéristiques pour chaque objet

Nous définissons la fonction __init__, il y en a trois. paramètres entre parenthèses, mais lorsque nous instancions l’appel, nous ne transmettons que deux valeurs. Pourquoi n’y a-t-il pas d’erreur ? En effet, la fonction de self est de transmettre automatiquement l'objet lui-même au premier paramètre de la fonction __init__ lors de son instanciation. Bien sûr, self n'est qu'un nom. Le professeur Egon a dit que si vous l'écrivez aveuglément, les autres ne le pourront pas. pour le comprendre.

Attention. Ce mécanisme de transfert automatique de valeur n'est reflété que lorsqu'il est instancié. En plus de l'instanciation, une classe a également la fonction de référence d'attribut. La méthode est le nom de la classe Attribut

#引用类的数据属性print(Chinese.country)  #China#引用类的函数属性# Chinese.talk()#TypeError: talk() missing 1 required positional argument: 'self'print(Chinese.talk) #<function Chinese.talk at 0x000001BC5F13D1E0>Chinese.talk('self')    #is talking Chinese#增加属性Chinese.color='yellow'#删除属性del Chinese.color

As. Comme le montre le code d'erreur ci-dessus, le transfert automatique de valeur n'existe pas lors du référencement d'attributs

Nous avons appris le concept d'espace de noms. Définir une variable ou définir une fonction ouvrira une mémoire dans la mémoire. . Space, les classes ont également des variables définies (attributs de données) et des fonctions définies (attributs de fonction). Elles ont également des espaces de noms, qui peuvent être visualisés via la méthode .__dict__

p1=Chinese('zhang',18)print(Chinese.__dict__)#{'__module__': '__main__', 'country': 'China', '__init__': <function Chinese.__# init__ at 0x000002187F35D158>, 'talk': <function Chinese.talk at 0x000002187F35D1E0>, # 'eat': <function Chinese.eat at 0x000002187F35D268>, '__# dict__': <attribute &#39;__dict__&#39; of &#39;Chinese&#39; objects>,#  '__weakref__': <attribute &#39;__weakref__&#39; of &#39;Chinese&#39; objects>, '__doc__': None}print(p1.__dict__)#{'name': 'zhang', 'age': 18}

via. le code ci-dessus Nous connaissons les résultats affichés. Imprimez l'espace de noms de l'objet instancié et affichez uniquement ses propres attributs uniques. Si vous souhaitez trouver les attributs partagés avec d'autres objets, vous devez vous rendre dans l'espace de noms de la classe pour trouver

<.>Il y a une autre question. Il n'y a pas d'attribut de fonction dans l'espace de noms de l'objet Bien sûr, on le trouve dans la classe, mais les fonctions spécifiées par différents objets sont-elles la même fonction ?

可以看到，并不是，他们的内存地址都不一样。而且注意bound method，是绑定方法

对象本身只有数据属性，但是Python的class机制将类的函数也绑定到对象上，称为对象的方法，或者叫绑定方法。绑定方法唯一绑定一个对象，同一个类的方法绑定到不同的对象上，属于不同的方法。我们可以验证一下：

当用到这个函数时：类调用的是函数属性，既然是函数，就是函数名加括号，有参数传参数

而对象用到这个函数时，对象没有函数属性，他是绑定方法，绑定方法怎么用呢，也是直接加括号，但不同的是，绑定方法会默认把对象自己作为第一个参数

class Chinese:
    country='China'def __init__(self,name,age):
        self.name=name  
        self.age=age    def talk(self):print('%s is talking Chinese'%self.name)def eat(self):print('is eating Chinese food')

p1=Chinese('zhang',18)
p2=Chinese('li',19)
Chinese.talk(p1)    #zhang is talking Chinesep1.talk()           #zhang is talking Chinese

只要是绑定方法，就会自动传值！其实我们以前就接触过这个，在python3中，类型就是类。数据类型如list,tuple,set,dict这些，实际上也都是类，我们以前用的方法如l1.append(3),还可以这样写：l1.append(l1,3)

未完待续。。。

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!