Page d'accueil de l'auteur : Programming Compass Brève introduction
de l'auteur : développement de projets Java, développement de conceptions de fin d'études, arrangement technologique d'entretien, partage Favoris, j'aime , ne vous perdez pas et suivez l'auteur, c'est bien. Obtenez l'articlele code source
Apprentissage avancé de Python
1. Classes et objets
1.1 Présentation orientée objet
L'abréviation anglaise de Orienté Objet est OO, qui est une idée de conception. Depuis que le concept orienté objet a été proposé dans les années 1960, il s'est développé en une idée de programmation relativement mature et est progressivement devenu le concept actuel de développement logiciel. champ.
L'objet (Objet) en mode orienté objet fait généralement référence à l'objet existant dans le monde objectif. Cet objet est unique et les objets sont différents et ont leurs propres caractéristiques. Chaque objet a sa propre loi de mouvement et son état interne. ; Objets peuvent être liés et interagir les uns avec les autres. Un objet peut aussi être une chose abstraite. Les objets sont généralement divisés en parties statiques et parties dynamiques. La partie statique fait référence à certains attributs de l'objet lui-même et la partie dynamique fait référence à certaines actions effectuées par l'objet.
Une classe est un support pour encapsuler des objets et décrit les objets en définissant des attributs et des méthodes communs. Par exemple, les êtres humains (Personne) ont leurs propres attributs tels que le nom, l'âge, la taille, le poids, etc., et peuvent également manger, dormir, s'asseoir, marcher, etc., et utiliser des classes pour les décrire. Vous pouvez utiliser des classes créer des attributs et des formes différents : l'objet spécifique, c'est-à-dire l'individu.
Trois caractéristiques de la programmation orientée objet : l'encapsulation, l'héritage et le polymorphisme.
1.2 Définition et utilisation des classes
En Python, les classes sont définies à l'aide du mot-clé class :
Class ClassName:
'''帮助信息'''
statement
Exemple : Si vous ne savez pas comment écrire le code lors de la définition de la classe, vous pouvez utiliser pass pour définir un code vide (espace réservé)
Class Person:
pass
Créez une instance de la classe :
instancename = ClassName(parameterList)
Lors de la définition d'une classe, une méthode '_init_()' est généralement créée automatiquement, ce qui équivaut à la méthode de construction en Java, et elle est automatiquement exécutée lors de la création d'un objet instance. Il doit contenir un paramètre self, qui est utilisé pour faire référence à ses propres propriétés et méthodes, et d'autres paramètres peuvent également être ajoutés. Lorsqu'elle n'a qu'un seul paramètre, lors de l'utilisation de la classe pour l'instanciation, il n'est pas nécessaire de transmettre le paramètre.
Exemple:
#定义类
class Geese:
'''大雁类'''
def __init__(self):
print("我是大雁类")
wildGoose = Geese()
Dans la méthode '_init_()', certains paramètres peuvent également être personnalisés :
Exemple:
#定义类
class Geese:
'''大雁类'''
def __init__(self,beak,wing,claw):
print("我是大雁类,我有以下特征：")
print(beak)
print(wing)
print(claw)
beak = '喙的基部较高，长度和高度基本一致'
wing_1 = '翅膀长而尖'
claw_1 = '爪子是噗状的'
wildGoose = Geese(beak,wing_1,claw_1)
1.3 Créer des membres de la classe et y accéder
Les membres d'une classe sont principalement composés de méthodes d'instance et de données membres. Une fois les membres de la classe créés dans la classe, ils sont accessibles via l'instance de la classe.
1. Créez une méthode d'instance et accédez-y :
Une méthode d'instance est une fonction définie dans une classe. Elle doit contenir un paramètre self, et il doit être le premier. La syntaxe est la suivante :
def functionname(self,parameterlist)
block
Une fois la méthode d'instance définie, elle peut être appelée par le nom de l'instance :
instancename.functionname(parameterlist)
2. Créez des données membres et accédez-y :
Les données membres sont des variables définies dans une classe, c'est-à-dire des attributs. Selon l'emplacement de la définition, elle est divisée en attributs de classe et attributs d'instance.
Les attributs de classe font référence aux attributs définis dans la classe et en dehors du corps de la fonction. Les attributs de classe peuvent être partagés et accessibles par toutes les instances. Accessible par nom de classe ou nom d'instance.
Exemple:
#定义类 类属性
class Geese:
'''大雁类'''
beak = '喙的基部较高，长度和高度基本一致'
wing = '翅膀长而尖'
claw = '爪子是噗状的'
def __init__(self):
print("我是大雁类,我有以下特征：")
print(Geese.beak)
print(Geese.wing)
print(Geese.claw)
wildGoose = Geese()
L'attribut d'instance fait référence à l'attribut défini dans la méthode de la classe, qui n'agit que sur l'instance actuelle. Les attributs d'instance ne sont accessibles que par nom d'instance, pas par nom de classe.
Exemple:
#定义类 实例属性
class Geese:
'''大雁类'''
def __init__(self):
self.beak = '喙的基部较高，长度和高度基本一致'
self.wing = '翅膀长而尖'
self.claw = '爪子是噗状的'
print("我是大雁类,我有以下特征：")
print(self.beak)
print(self.wing)
print(self.claw)
wildGoose = Geese()
Les attributs de l'instance sont également accessibles en modifiant le nom de l'instance :
#定义类
class Geese:
'''大雁类'''
def __init__(self,beak,wing,claw):
self.neck = '脖子较长'
print(self.neck)
wildGoose = Geese()
wildGoose1 = Geese()
wildGoose1.neck = '脖子没有天鹅长'
print('wildGoose的脖子:',wildGoose.neck)
print('wildGoose1的脖子:',wildGoose1.neck)
1.4 Restrictions d'accès
Afin de garantir que les attributs et méthodes définis dans la classe ne sont pas accessibles en externe, Python fournit _ foo avec un seul trait de soulignement, _ _ foo avec un double trait de soulignement et _ foo_ avec des soulignements au début et à la fin pour restreindre l'accès. foo Un attribut ou un nom d'accès pour cette époque.
_ foo _ : Indique la définition d'un accès spécial, tel que la méthode d'initialisation _ _init _ _
_ foo : commencer par un seul trait de soulignement signifie que les membres protégés (protégés) définis ne sont accessibles que via la classe et ses sous-classes. Mais vous ne pouvez pas utiliser "from module import *" pour importer.
Exemple:
#访问限制
class Swan:
'''天鹅类'''
_neck_swan = '天鹅的脖子很长' #定义保护类型属性
def __init__(self):
print("__init__():"+Swan._neck_swan) #在实例访问中访问私有属性
swan = Swan() #创建Swan类的实例
print("直接访问：",swan._neck_swan) # 保护属性可以通过实例名访问
_ _foo : les doubles traits de soulignement représentent les membres de type privé (privé). Seules les méthodes de la classe sont autorisées à accéder, pas via les instances. Mais il est accessible via « nom de l'instance. nom de la classe_nom du membre ».
Exemple:
#访问限制 私有属性
class Swan:
'''天鹅类'''
__neck_swan = '天鹅的脖子很长' #定义私有类型属性
def __init__(self):
print("__init__():"+Swan._neck_swan) #在实例访问中访问私有属性
swan = Swan() #创建Swan类的实例
print("加入类名：",swan._Swan__neck_swan) #私有属性，可以通过 “实例名.类名__xxx" 方式访问
print("直接访问：",swan._neck_swan) # 私有属性不可以通过实例名访问
1.5 Propriétés
En python, vous pouvez convertir une méthode en propriété via @property, afin de réaliser la propriété utilisée pour le calcul. Une fois la méthode convertie en attribut, la méthode est accessible directement via le nom de la méthode sans ajouter une paire de parenthèses "()", ce qui peut rendre le code plus concis.
@property
def methodname(self):
block
* methodname :方法名
* self:必要参数，表示类的实例
* block: 方法体
Exemple:
#定义属性
class Rect:
def __init__(self,width,height):
self.width = width #矩形的宽
self.height = height #矩形的高
@property #将方法转换为属性
def area(self): #计算机矩形的面积的方法
return self.width*self.height #返回矩形面积
rect = Rect(800,600) #创建类的实例
print("面积为:",rect.area) #输出属性的值
En Python, par défaut, les attributs ou instances de classe créés peuvent être modifiés en dehors de la classe. Si vous souhaitez l'empêcher d'être en dehors du corps de la classe
Il peut être modifié en dehors de la classe et il peut être défini comme privé, mais après l'avoir défini comme privé, sa valeur ne peut pas être obtenue en dehors de la classe. Ainsi, si vous souhaitez créer une propriété qui peut être lue mais non modifiée, vous pouvez utiliser @property pour implémenter une propriété en lecture seule.
Exemple:
#创建只读属性
class TVShow:
def __init__(self,show):
self.__show = show
@property #将方法转换为属性
def show(self): #定义show()方法
return self.__show #返回私有属性的值
tvshow = TVShow("正在播放 青春无悔") #创建类的实例
print("默认：",tvshow.show) #获取属性值
Mais si vous souhaitez modifier la valeur de show, une erreur sera signalée :
tvshow.show = '正在播放 大决战'
print("修改后：",tvshow.show)
Erreur:
AttributeError: can't set attribute
1.6 Héritage
L'héritage peut permettre la réutilisation du code, et en même temps, la relation entre les classes peut être redressée grâce à l'héritage.
class ClassName(baseclasslist):
'''类的帮助信息''' #类文档字符串
statement #类体
* baseclasslist:用于指定要继承的基类，可以有多个，类名之间用 ，号分隔，如果不指定，将使用所有Python对象的根类object.
Réécriture de méthode : Les membres de la classe de base seront hérités par la classe dérivée. Lorsqu'une méthode de la classe de base n'est pas entièrement applicable à la classe dérivée, il est nécessaire de remplacer la méthode de la classe parent dans la classe dérivée.
Exemple:
#继承
class Fruit:
color = '绿色'
def harvest(self,color):
print("水果是:"+color+"的！")
print("水果已经收获.....")
print("水果原来是："+Fruit.color+"的！")
class Orange(Fruit):
color = "橙色"
def __init__(self):
print("\n 我是橘子")
def harvest(self,color):
print("橘子是"+color+"的！")
print("橘子已经收获....")
print("橘子原来是："+Fruit.color+"的！")
orange = Orange()
orange.harvest("黄色")
L'appel de la méthode _ _init _ _ de la classe de base doit être appelé via super() :
#调用父类的__init__方法
class Fruit:
def __init__(self,color="绿色 "):
Fruit.color = color
def harvest(self):
print("水果原来是： "+Fruit.color+"的！")
class Apple(Fruit):
def __init__(self):
super().__init__()
print("我是苹果")
apple = Apple()
apple.harvest()