Introduction à la programmation orientée objet en langage Python (avec code)

Cet article vous apporte une introduction à la programmation orientée objet en langage Python (avec code), qui a une certaine valeur de référence, les amis dans le besoin peuvent référez-vous-y, j'espère que cela vous sera utile.

Orienté objet en langage Python

Programmation orientée objet, c'est-à-dire POO Pour les langages orientés objet, c'est. est souvent mentionné à des concepts tels que l'encapsulation, l'héritage et les classes.
L'origine de l'orientation objet : basée sur la philosophie selon laquelle tout est un objet, l'idée principale est d'objectiver et de modulariser nos programmes. Dans le langage Python, la classe est couramment utilisée pour nommer une classe, comme la classe Personne (. ), Étudiant de classe, etc. Il y a souvent des attributs et des comportements dans les classes. Par exemple, la classe Person a des attributs tels que le nom, la taille, le poids, etc. Ces comportements Python incluent manger, dormir, se faire des amis, etc. Grâce aux classes, nous pouvons facilement implémenter des appels ultérieurs sans avoir à réécrire certains codes répétés, ce qui améliore considérablement l'efficacité de la programmation. Par conséquent, les langages de programmation orientés objet sont actuellement largement utilisés.
L'orientation objet présente trois caractéristiques majeures : l'héritage, l'encapsulation et le polymorphisme

1 Héritage
Concept d'héritage : si une classe hérite d'une autre classe, la classe héritée est appelée une sous-classe et la classe héritée est le genre parent.
Objectif : permettre la réutilisation du code.
Compréhension : La relation entre la sous-classe et la classe parent n'est pas la relation parent-enfant dans la vie quotidienne. La relation entre la sous-classe et la classe parent est une spécialisation et une généralisation. la sous-classe est la classe parent. Classification plus détaillée. Par exemple, la classe chien hérite d'un animal, ce qui peut être compris comme un chien est un animal. Faites attention lors de la conception de l'héritage
Résultat : après l'héritage, la sous-classe a automatiquement les attributs et les méthodes de la classe parent, et la sous-classe peut. écrire ses propres attributs et méthodes uniques.Le but des méthodes est d'étendre les fonctions.Les sous-classes peuvent également remplacer les méthodes de la classe parent, qui est la réécriture des méthodes.

2 Encapsulation
Concept : L'encapsulation, également connue sous le nom de masquage d'informations, fait référence à l'utilisation de types de données abstraits pour encapsuler des données et des opérations basées sur des données afin qu'elles forment une entité indépendante indivisible, et les données sont protected Dans le type de données abstrait, les détails internes sont cachés autant que possible et seules certaines interfaces externes sont conservées pour les connecter avec l'extérieur. Le reste du système peut communiquer et interagir avec ce type de données abstrait uniquement via des opérations autorisées enroulées autour des données. C'est-à-dire que l'utilisateur n'a pas besoin de connaître les détails d'implémentation des méthodes internes de l'objet, mais peut accéder à l'objet selon l'interface externe (nom de l'objet et paramètres) fournie par l'objet.
Avantages : (1) Division claire du travail. Après avoir encapsulé le code pouvant implémenter une fonction spécifique dans une entité indépendante, chaque programmeur peut l'appeler en cas de besoin, réalisant ainsi une division professionnelle du travail. (2) Dissimulation d’informations et détails de mise en œuvre. En contrôlant les droits d'accès, vous pouvez masquer les informations que vous ne souhaitez pas que les programmeurs clients voient. Par exemple, si le mot de passe bancaire d'un client doit rester secret, vous pouvez uniquement développer des autorisations pour ce client.
3 Polymorphisme
Concept : Même chose, lorsque la même méthode est appelée et que les paramètres sont les mêmes, le comportement est différent.
Compréhension : les sous-classes apparaissent en tant que classes parentes, mais elles implémentent toujours leurs propres méthodes lorsqu'elles font les choses. Lorsqu'une sous-classe apparaît en tant que classe parent, elle nécessite une transformation ascendante (upcasting). La conversion ascendante est automatiquement implémentée par la JVM et est sûre, mais la transformation descendante (downcast) est dangereuse et nécessite une conversion forcée. Lorsqu'une sous-classe apparaît en tant que classe parent, ses propres propriétés et méthodes uniques ne seront pas disponibles.
La différence entre « orienté processus » et « orienté objet »
Orienté processus consiste à analyser les étapes nécessaires pour résoudre le problème, puis à utiliser des fonctions pour mettre en œuvre ces étapes étape par étape. il suffit de les appeler un par un ; l'orientation objet consiste à décomposer la transaction qui constitue le problème en objets individuels. Le but de l'établissement de l'objet n'est pas de terminer une étape, mais de décrire le comportement de quelque chose dans toute l'étape de résolution. problème.
Vous pouvez utiliser des exemples de la vie pour comprendre l'orientation processus et l'orientation objet. Par exemple, après avoir terminé un concours, l'idée de conception orientée processus est d'abord d'analyser les étapes du problème :
1. la compétition, 2. Commencez la compétition, 3. Transcendez à mi-chemin, 4. Décidez du gagnant. Mettez en œuvre chacune des étapes ci-dessus d’une manière différente.
S'il s'agit d'une idée de conception orientée objet pour résoudre le problème. La conception orientée objet résout les problèmes sous un autre angle. L'ensemble du concours peut être divisé en 1. Objets du concours 2. Règles du concours 3. Évaluation des résultats, etc.
Ce qui suit est un petit exemple pour illustrer le processus de programmation orientée objet du langage Python :

一、
#1 定义一个类，其中类名是学生
#2 学生具有的属性
#3 学生具有哪些行为
#4 具体化两个学生，实例化类型
class Student(object):
    name = " "
    age = 12
    weight = 50
    school = "wuhan university"
    def eat(self,orange):
        print("l love orange")
    def study(self):
        print("let me study!")
stu1 = Student()
stu2 = Student()
print(stu1)
print(stu2)
print(stu1.name)
print(stu1.age)
print(stu2.name)
print(stu2.age)

二、
#进一步优化：通过上面的程序我们发现他们最终输出的对象的属性一样，但是事实上他们是两个不同的学生，他们的名字，年龄并不相同，那么接下来需要做的就是给他们各自赋予各自的属性，利用类名.属性=某个值，和方法的调用一样也是类名.方法名
class Student(object):
    name = " "
    age = 12
    weight = 50
    school = "wuhan university"
    def eat(self,orange):
        print("l love orange")
    def study(self):
        print("let me study!")
stu1 = Student()
stu1.name="王"
stu1.age = 20

stu2 = Student()
stu2.name = "张"
stu2.age = 50
print(stu1)
print(stu1.name)
print(stu1.age)
print(stu2)
print(stu2.name)
三、
#进一步优化：通过第二个程序我们发现在定义对象的属性时我们还需要将所得属性命名在写一次，这样显然比价麻烦，于是有了更好的属性命名方法，我们可以使用初始化 
def __init__(self,、、、)，最后在命名属性的时候只需要在类名后面的括号中填写具体的属性值即可，大大较少了代码量。

class Student(object):
    def __init__(self,name,age,school):
        self.name = name
        self.age = age
        self.school = school
    def eat(self,orange):
        print("l love orange")
    def study(self):
        print("let me study!")
stu1 = Student("li",25,"scu")
stu2 = Student("sun",20,"wpu")
print(stu1)
print(stu2)
print(stu1.name)
print(stu1.school)
print(stu2.name)
print(stu2.school)

self représente une instance dans une classe, pas une classe lorsque cette instance appelle une méthode dans le. classe, alors ce soi appartient à cet objet, par exemple, ajoutez une méthode à Student pour vous présenter.

class Student(object):
    def __init__(self,name,age,school):
        self.name = name
        self.age = age
        self.school = school
    def eat(self,orange):
        print("l love orange")
    def study(self):
        print("let me study!")
    def intro(self):
        print("my name is{},{} years old".format(self.name,self.age))
stu1 = Student("li",25,"scu")
stu2 = Student("sun",20,"wpu")
print(stu1)
print(stu2)
print(stu1.name)
print(stu1.school)
print(stu2.name)
print(stu2.school)
intro1 = stu1.intro()
intro2 = stu2.intro()

Si vous souhaitez imprimer les attributs et autres informations de l'objet pour que le client puisse les voir, mais comme il y a trop d'attributs, il est difficile de les imprimer un par un. utilisez __str__(), comme suit :

class Student(object):
    def __init__(self,name,age,school):
        self.name = name
        self.age = age
        self.school = school
    def eat(self,orange):
        print("l love orange")
    def study(self):
        print("let me study!")
    def intro(self):
        print("my name is{},{} years old".format(self.name,self.age))
    def __str__(self):
        return "%s-%d"%(self.name,self.age)
stu1 = Student("li",25,"scu")
stu2 = Student("sun",20,"wpu")


print(stu1)

如果要是的Python中类的属性值不改变，那么在属性前加两个-,称为私有属性，private
如：
self.__money = money，不能再外面直接访问
print（stu1.__money）报错
但是在内部可以直接使用，如在方法eat中调用
如果属性名前是一个下划线，则他虽然可以在外部访问，但是约定俗成提示不要访问！！！

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!