Expliquer les fondements de base orientés objet de Python

Tutoriel vidéo PythonLa colonne présente le noyau de base orienté objet

Recommandations d'apprentissage gratuites associées : Tutoriel vidéo Python

Introduction à l'orientation objet

Python from It a été conçu dès le début comme un langage orienté objet, et de ce fait, il est facile de créer des classes et des objets en Python. Si vous n'avez jamais été exposé aux langages de programmation orientés objet, vous devrez peut-être d'abord comprendre certaines fonctionnalités de base des langages orientés objet et former un concept de base orienté objet dans votre esprit. Cela vous aidera à apprendre Python. plus facilement. Programmation orientée objet.

• Python est un langage de programmation orienté objet
• La simple compréhension du langage dit orienté objet est que toutes les opérations du langage sont effectuées via des objets
• Orienté procédure
• Orienté processus signifie décomposer notre programme en étapes une par une, et compléter le programme en faisant abstraction de chaque étape
• Cette méthode d'écriture ne convient souvent que pour une seule fonction , si vous souhaitez implémenter d'autres fonctions, la réutilisabilité est souvent faible
• Cette méthode de programmation symbolise la pensée humaine et est plus facile à écrire
• 1. Maman met des vêtements et des chaussures et sort
• 2. Maman fait du vélo électrique
• 3. Maman met le vélo électrique devant le supermarché
• 4. Maman achète une pastèque
• 5. Maman passe à la caisse
• 6. Maman fait du vélo électrique la maison
• 7. L'enfant mange de la pastèque en rentrant à la maison
• Le langage de programmation orienté objet se concentre sur les objets plutôt que sur les processus. Pour l'orienté objet, tout est un objet
• Le. La méthode ci-dessus peut être utilisée par la mère de l'enfant pour que les enfants achètent des melons pour résoudre le problème
• L'idée de programmation orientée objet enregistre toutes les fonctions dans les objets correspondants. Si vous souhaitez utiliser une certaine fonction, recherchez simplement l'objet correspondant directement <.> • Cette méthode de codage est plus facile à lire, et facile à maintenir et à réutiliser. Cependant, le processus d'écriture n'est pas conforme à la pensée conventionnelle et l'écriture est relativement gênante

• Caractéristiques de base de l'orientation objet

Classe : utilisée pour décrire une collection d'objets avec les mêmes propriétés et méthodes. Il définit les propriétés et méthodes communes à chaque objet de la collection. Les objets sont des instances de classes.
• Variables de classe : les variables de classe sont publiques dans tout l'objet instancié. Les variables de classe sont définies dans la classe et en dehors du corps de la fonction. Les variables de classe ne sont généralement pas utilisées comme variables d'instance.
• Attributs de données : variables de classe ou variables d'instance, utilisées pour traiter les données liées aux classes et à leurs objets d'instance.
• Réécriture de méthode : si la méthode héritée de la classe parent ne peut pas répondre aux besoins de la sous-classe, elle peut être réécrite. Ce processus est appelé remplacement de méthode, également appelé réécriture de méthode.
• Variables locales : Les variables définies dans les méthodes n'agissent que sur la classe de l'instance actuelle.
• Variables d'instance : Dans la déclaration d'une classe, les attributs sont représentés par des variables. Ces variables sont appelées variables d'instance et sont déclarées dans la déclaration de classe mais en dehors des autres méthodes membres de la classe.
• Héritage : Une classe dérivée hérite des champs et des méthodes d'une classe de base. L'héritage permet également à un objet d'une classe dérivée d'être traité comme un objet de classe de base. Par exemple, il existe une telle conception : un objet de type Dog est dérivé de la classe Animal, qui simule la relation "est-un" (par exemple, Dog est un animal).
• Instanciation : Créer une instance d'une classe, un objet spécifique de la classe.
• Objet : Une instance d'une structure de données définie par une classe. Les objets incluent deux données membres (variables de classe et variables d'instance) et des méthodes.

L'idée de programmation orientée objet (POO) est principalement conçue pour la conception de logiciels à grande échelle. La programmation orientée objet encapsule les données et les méthodes liées aux données d'exploitation dans des objets et organise le code et les données d'une manière plus proche de la pensée humaine, rendant le programme plus évolutif et plus lisible, améliorant ainsi considérablement l'efficacité de la programmation.

　　　　　　　Python adopte pleinement la pensée orientée objet et est un véritable langage de programmation orienté objet. Il prend entièrement en charge les fonctions de base orientées objet, telles que l'héritage, le polymorphisme, l'encapsulation, etc.
En Python, tout est objet. Par exemple, les types de données, les fonctions, etc. sont tous des objets.

• Python prend en charge plusieurs paradigmes de programmation tels que la programmation orientée processus, orientée objet et fonctionnelle. Différences entre l'orienté objet et l'orienté processus :

Similitudes : Les deux sont des manières de penser à la résolution de problèmes et des manières d'organiser le code
Différences :
Pensée orientée procédure : La programmation orientée processus accorde plus d'attention au « flux logique du programme » et est une sorte d'« exécuteur » "Réfléchir, adapté à l'écriture de programmes à petite échelle.
Pensée orientée objet : L'orientation objet se préoccupe davantage de « la relation entre les objets dans le logiciel » et correspond davantage au mode de pensée des gens. Il s'agit d'un « concepteur ». la réflexion est adaptée à l’écriture de programmes à grande échelle. L'orientation objet peut nous aider à comprendre et à analyser l'ensemble du système d'un point de vue macro.
Cependant, les micro-opérations spécifiques à la partie implémentation (c'est-à-dire chaque méthode) doivent encore être traitées avec une approche orientée processus. L'orienté processus et l'orienté objet sont complémentaires l'un de l'autre, et l'orienté objet ne peut être séparé de l'orienté processus.
Pensée orientée objet Lorsque vous rencontrez des problèmes complexes, recherchez d'abord les noms du problème (plus orientés processus, recherchez les verbes), puis déterminez lesquels de ces noms peuvent être utilisés comme classes, puis déterminer en fonction des besoins du problème. Les attributs et méthodes de classe déterminent la relation entre les classes.

2. Classe

• Créer une classe

• Ce que nous apprenons actuellement, ce sont les objets intégrés de Python, mais tous les objets intégrés ne répondent pas à nos besoins, nous devons donc souvent personnaliser certains objets pendant le développement
• La classe d'éléments List est simplement comprise comme équivalente à un dessin, dans le résumé du programme, nous devons créer des objets basés sur des classes.
  Une classe est le dessin d'un objet
• Nous appelons également un objet une instance d'une classe
• Si plusieurs objets sont créés via une classe, nous appelons ces objets une classe d'objets
• Une classe est aussi un objet. Une classe est un objet utilisé pour créer des objets
• Vous pouvez ajouter des variables à l'objet. Les variables dans l'objet sont appelées attributs. Nom de l'attribut = Valeur de l'attribut

class MyClass():
    pass

Les classes sont abstraites, également appelées « modèles d'objet ». Nous devons créer un objet instance de la classe via le modèle de classe, puis nous pouvons utiliser les fonctions définies par la classe.
En Python, les objets Python comprennent plusieurs parties :

• Instanciation d'objet

mc = MyClass()mc1 = MyClass()mc2 = MyClass()mc3 = MyClass()

Donc, nous devons définir la méthode constructorinit(), qui attribuera des propriétés d'objet à l'objet que nous définissons. La méthode constructeur est utilisée pour effectuer "l'initialisation de l'objet instance", c'est-à-dire qu'une fois l'objet créé, les propriétés pertinentes de l'objet actuel sont initialisées et il n'y a aucune valeur de retour. Les points clés de

init() sont les suivants :

Le nom est fixe et doit être : init()
Le premier paramètre est fixe et doit être : soi. self fait référence à l'objet instance qui vient d'être créé.
Le constructeur est généralement utilisé pour initialiser les attributs d'instance de l'objet instance. Par exemple, dans l'exemple 1, les attributs d'instance sont initialisés : nom et son
Le constructeur est appelé via le "nom de classe (liste de paramètres) ". Après l'appel, l'objet créé est renvoyé à la variable correspondante. Par exemple : cat = Animal('Little Flower','Meow Meow')
Méthode __init __() : Initialiser l'objet créé. L'initialisation fait référence à : "Attribuer des valeurs aux attributs de l'instance"
__new __( ) : utilisée pour créer des objets, mais nous n'avons généralement pas besoin de redéfinir cette méthode.
Si nous ne définissons pas la méthode __init__, le système fournira une méthode __init__ par défaut. Si nous définissons la méthode __init__ avec des paramètres, le système ne crée pas de méthode __init__ par défaut.
Remarque :
Self en Python est équivalent au pointeur self en C++, et au mot-clé this en JAVA et C#. En Python, self doit être le premier paramètre du constructeur, et le nom peut être modifié arbitrairement. Mais suivez généralement la convention et appelez-la vous-même.
3. Définition de la classe

• Les classes et les objets sont des abstractions de choses dans la vie réelle
• Les choses contiennent deux parties
• 1. Les données ( propriété)
• 2. Comportement (méthode)
• Objet de la méthode d'appel. Nom de la méthode ()
• Différence entre appel de commodité et appel de fonction : s'il s'agit d'un appel de fonction, il y a plusieurs paramètres formels lors de l'appel, plusieurs paramètres réels seront transmis. S'il s'agit d'un appel de méthode, un paramètre est passé par défaut, la méthode doit donc avoir au moins un paramètre formel
• Dans le bloc de code de classe, on peut définir des variables et des fonctions
• Les variables deviendront des propriétés publiques de l'instance de classe, toutes Cette instance est accessible sous la forme d'object.property name
• La fonction deviendra une méthode publique de l'instance de classe, et toutes les instances de cette classe sont accessibles sous la forme d'object.method nom

class Person():
    name = '奥特曼'
    def speak(w):
        print('我能说话')a = Person()b = Person()a.name = '葫芦娃'print(a.name)print(b.name)print(a.speak())print(b.speak())

4. Paramètre soi

• 属性和方法

• 类中定义的属性和方法都是公共的，任何该类实例都可以访问
• 属性和方法的查找流程
• 当我们调用一个对象的属性时，解析器会现在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错
• 类对象和实例对象中都可以保存属性(方法)
• 如果这个属性(方法)是所以的实例共享的，则应该将其保存到类对象中
• 如果这个属性(方法)是摸个实例独有的。则应该保存到实例对象中
• 一般情况下，属性保存到实例对象中 而方法需要保存到类对象中

• self

方法是从属于实例对象的方法。实例方法的定义格式如下：
　
　　　　def 方法名(self ,[形参列表])：
　　　　　　函数体

方法的调用格式如下：
　　　　对象.方法名([实参列表]) 要点：

定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。 调用实例方法时，不需要也不能给 self
传参。self 由解释器自动传参 函数和方法的区别

都是用来完成一个功能的语句块，本质一样。 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点。
直观上看，方法定义时需要传递 self，函数不需要。 实例对象的方法调用本质： alt

类中其他操作：

dir(obj)可以获得对象的所有属性、方法 obj.dict 对象的属性字典 pass 空语句，相当于占位符。
isinstance（对象,类型） 判断“对象”是不是“指定类型”。

class Person():

    def speak(self):
        print('你好我是%s' % self.name)

    def read(self):
        passa = Person()b = Person()a.name = '葫芦娃'b.name = '奥特曼'a.speak()b.speak()结果：
C:\Users\giser\AppData\Local\Programs\Python\Python37\python.exe D:/pycharm/pythonbasic/day09.py
你好我是葫芦娃
你好我是奥特曼

Process finished with exit code 0

                 

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!