Maison > développement back-end > Tutoriel Python > Programmation orientée objet Python - Élémentaire

Programmation orientée objet Python - Élémentaire

王林
Libérer: 2023-04-11 23:58:05
avant
1937 Les gens l'ont consulté

Avant-propos

Orienté objet : utiliser le concept d'objets (entités) pour construire des modèles et simuler le monde objectif afin d'analyser, de concevoir et de mettre en œuvre des logiciels. La programmation orientée objet (POO en abrégé) est une méthode de conception et de programmation qui résout la réutilisation de logiciels. Elle décrit des données et des états d'application de fonctionnement et de logique similaires dans le système logiciel sous forme de classes et d'objets. le système logiciel pour améliorer l'efficacité du développement de logiciels.

La programmation orientée objet est un concept extrêmement important en Python.

1. Orienté objet et orienté processus

1. Deux types de méthodes de développement et de conception de logiciels

  1. Programmation orientée processus : selon la logique métier de haut en bas, encapsuler le code fonctionnel qui doit être utilisé dans fonctions, en se concentrant sur les étapes et les processus de développement, le code typique est le langage C (se concentrer sur le processus)
  2. Programmation orientée objet : classer et encapsuler les fonctions ou les fonctions requises, en se concentrant sur la classe et la fonction spécifiques pour implémenter la fonction, le le code typique est Java, C++ et d'autres langages (Suivez les résultats)

2. Termes associés orientés objet

  • Classe (Classe) : utilisé pour décrire une collection d'objets avec les mêmes propriétés et méthodes. et les méthodes communes à chaque objet de la collection. Les objets sont des instances de classes.
  • Instance : également appelé objet. Grâce à la méthode d'initialisation définie par la classe, elle reçoit une valeur spécifique et devient une « entité de chair et de sang ».
  • 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.
  • Membres 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.
  • Méthode : Fonction définie dans la classe.
  • 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.
  • Méthode statique : Une méthode qui peut être exécutée par une classe sans instanciation.
  • Méthodes de classe : les méthodes de classe sont des méthodes qui opèrent sur la classe elle-même en tant qu'objet.

Trois fonctionnalités majeures de l'orientation objet :

  • Encapsulation : enveloppez l'implémentation interne, rendez-la transparente vers l'extérieur et fournissez un mécanisme pour appeler l'interface API.
  • Héritage : c'est-à-dire qu'une classe dérivée hérite des variables et des méthodes de la classe parent (classe de base).
  • Polymorphisme : traité de différentes manières selon le type d'objet.

2. Classes et objets

1. Objets

Les objets sont au cœur de la programmation orientée objet, afin de définir de manière abstraite un groupe d'objets avec des caractéristiques et des comportements communs. formé

2. Classe

1) Concept

Une classe est un type de chose. L'objet est l'implémentation spécifique de ce type de chose. Les classes ont les mêmes attributs et comportements

2) La composition d'une classe

.
  • Nom de la classe : le nom de la classe
  • Attributs : Caractéristiques des choses
  • Méthodes : Que faire spécifiquement

3) Abstraction

Les objets ayant des attributs et des comportements identiques ou similaires peuvent être abstraits dans une classe

4) Classification des classes

Créez une classe en utilisant le mot-clé de classe, avec le nom de la classe, puis des parenthèses, avec l'objet entre parenthèses, une telle classe est appelée une classe de nouveau style, elle peut également être sans parenthèses et sans l'objet ; entre parenthèses, une telle classe est appelée classe classique.

# 新式类 
class Meeting2(object): 
pass 
# 经典类 
class Meeting2: 
pass
Copier après la connexion

5) Créer un objet

A = Meeting1() 
B
Copier après la connexion

6) self

Le premier paramètre de la méthode de classe doit être self (c'est self par convention, il peut aussi s'agir d'autres noms), et il n'a pas besoin d'être transmis en appelant. self représente une instance d'une classe

3. Obtenez ou ajoutez des attributs d'objet

Il existe une classe nommée meeting comme suit Dans la classe, les attributs tels que le nom, l'âge, le sexe, l'adresse et l'attaque sont initialisés et deux méthodes. l'introduction et l'attaque sont définies :

class Meeting(object):
"""meeting类的类描述"""

def __init__(self, name, age, sex, address, attack):
"""构造函数"""
self.name = name
self.age = int(age)
self.sex = sex
self.address = address
self.attack = int(attack)

def introduction(self):
print("姓名:{}".format(self.name))
print("年龄:{}".format(self.age))
print("性别:{}".format(self.sex))
print("地址:{}".format(self.address))

def attacked(self):
print(f"{self.name}正在向您发起攻击,攻击力为{self.attack}!")

def foreign_fun():
print("我是外部函数")
Copier après la connexion

1.hasattr-Vérifiez si l'objet contient l'attribut ou la méthode spécifié

Utilisation :

hasattr(object,name)

Fonction : Vérifiez si l'objet contient l'attribut ou la méthode spécifié

Valeur de retour : renvoie vrai s'il existe, sinon L'existence renvoie faux

# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)

# 获取Meeting对象中是否存在name属性
print(hasattr(Meeting, "name"))# True
# 获取Meeting对象中是否存在mobile属性
print(hasattr(Meeting, "mobile"))# False
# 获取Meeting对象中是否存在attacked方法
print(hasattr(Meeting, "attacked"))# True
Copier après la connexion

2.getattr-Obtenir la valeur de l'attribut spécifié dans l'objet

Utilisation :

getattr(object,name[,default])

Fonction : Obtenez la valeur de l'attribut spécifié dans l'objet

Valeur de retour : S'il existe, renvoyez la valeur de l'attribut ; s'il n'existe pas, renvoyez le contenu spécifié

# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)

# 获取Meeting对象中name属性的属性值
print(getattr(Meeting, "name"))# 张三
# 获取Meeting对象中kills属性或方法的值,若不存在则返回指定内容
print(getattr(Meeting, "kills", "未找到kills方法或属性"))# 未找到kills方法或属性
# 获取Meeting对象中attacked方法,返回值为函数地址
print(getattr(Meeting, "attacked"))
# 使用getattr方法可以直接调用Meeting对象中的方法
f = getattr(Meeting, "attacked")
f()
Copier après la connexion

Le résultat de l'impression est le suivant :

Programmation orientée objet Python - Élémentaire

3.setattr-为object对象的name属性设置指定value

用法:

setattr(object,name,value)

作用:为object对象的指定属性设置指定value

返回值:

# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)

# 将对象中name属性的值改为“刘德华”
setattr(Meeting, "name", "刘德华")
# 获取对象中name的属性值
print(getattr(Meeting, "name"))# 刘德华
# 将对象外部的名为foreign_fun的方法引入对象内部,并重新命名为“new_foreign_fun”
setattr(Meeting, "new_foreign_fun", foreign_fun)
# 获取对象中是否存在foreign_fun的属性或方法,返回值为True或False
print(hasattr(Meeting, "foreign_fun"))# False
# 获取对象中是否存在new_foreign_fun的属性或方法,返回值为True或False
print(hasattr(Meeting, "new_foreign_fun"))# True
Copier après la connexion

打印结果如下:

Programmation orientée objet Python - Élémentaire

四、魔法方法

1.__init__() 构造函数

__init__()方法是Python中一种特殊的方法,被称为构造函数或初始化方法,当创建这个类的实例时就会调用该方法。

class Meeting(object):
"""meeting类的类描述"""

def __init__(self, name, age, sex, address, attack):
"""构造函数"""
self.name = name
self.age = int(age)
self.sex = sex
self.address = address
self.attack = int(attack)

C = Meeting("张三", 20, "男", "南京", 108)
print(C.name)# 张三
print(C.address)# 南京
Copier après la connexion

2.__del__() 析构函数

当删除对象时,Python解释器会默认调用一个方法__del__(),相当于unittest框架中的tearDown()函数

def __del__(self): 
"""析构函数""" 
print("%s攻击结束" % (self.name)) 
Copier après la connexion

每调用一次对象,都会执行一次__del__()方法

Programmation orientée objet Python - Élémentaire

3.引用计数

D = Meeting("张三", 20, "男", "南京", 108)
# 计算当前实例引用计数,D引用一次,sys.getrefcount(D)引用一次
print(sys.getrefcount(D))# 2
Copier après la connexion

D对象的引用计数为2次,一次是D引用,一次是sys.getrefcount所引用的

4.__str()__字符串函数

__str__方法需要返回一个字符串,当做这个对象的描述信息,当使用print输出对象的时候,只要定义了__str__(self)方法,那么就会打印这个方法返回的数据

def __str__(self):
"""字符串函数"""
return "我是Meeting类的字符串描述"
# __str__():字符串函数,定义__str__()方法时,打印对象,打印的是__str__()方法的返回值,否则打印类的内存地址
print(D)# 我是Meeting类的字符串描述
Copier après la connexion
  • 未定义__str__()方法时,打印对象,打印的是Meeting类的内存地址:<__main__.Meeting object at0x014A7748>
  • 定义了__str__()方法后,打印对象,打印的是__str__()方法的返回值:我是Meeting类的字符串描述

五、Python的内置属性

1.__dict__:获取类的属性

获取类的属性,包含一个字典,由类的数据属性组成

# __dict__:获取类的属性,返回值为字典类型 
print(D.__dict__) 
# {'name': '张三', 'age': 20, 'sex': '男', 'address': '南京', 'attack': 108} 
Copier après la connexion

2.__doc__:获取类的文档字符串

class Meeting(object): 
 """meeting1类的类描述""" 
 
# __doc__:获取类的文档字符串 
print(D.__doc__) # meeting1类的类描述 
Copier après la connexion

3.__name__:获取类名

# __name__:获取类名 
print(Meeting.__name__) # Meeting 
Copier après la connexion

4.__module__:类定义所在的模块

类的全名是'__main__.clssName',如果类位于一个导入模块mymod中,那么className.__module__等于mymod

from common.http_requests import HttpRequests
# __module__:类定义所在的模块
print(Meeting.__module__)# __main__
print(HttpRequests.__module__)# common.http_requests
Copier après la connexion

Meeting类的路径为__main__,而从common文件的http_requests文件中导入了HttpRequests类,打印其路径,则为common.http_requests

5.__bases__:获取类的所有父类构成元素

获取类的所有父类构成元素(包含了一个由所有父类元素组成的元组)。例如下面有一个Song类,其继承了父类Music,则获取到的Song类的所有父类构成元素为:(,)

class Music(object):
pass

class Song(Music):
pass

print(Song.__bases__)# (<class '__main__.Music'>,)
Copier après la connexion

小结

本篇文章我们介绍了面向对象的相关概念,下面来简单总结一下:

面向对象相关概念:

  • 类和对象:类是一类事物,对象即是这一类事物的具体实现,类具有相同的属性和行为;
  • 类的组成:类名、属性、方法
  • 带object的为新式类,不带object的为经典类

获取或添加对象属性:

  • hasattr:检查对象是否包含指定属性或方法
  • getattr:获取对象中指定属性的属性值
  • setattr:为object对象的name属性设置指定value

魔法方法:

  • __init__() 构造函数:又叫初始化方法,用来初始化一些成员变量
  • __del__() 析构函数:每调用一次对象,都会执行一次__del__()方法,相当于Unittest框架中的tearDown
  • __str()__字符串函数:返回一个字符串,当做这个对象的描述信息

Python内置属性:

  • __dict__:获取类的属性,返回值为字典类型
  • __doc__:获取类的文档字符串
  • __name__:获取类名
  • __module__:类定义所在的模块
  • __bases__:获取类的所有父类构成元素,返回类型为元组

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!

Étiquettes associées:
source:51cto.com
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal