L'éditeur suivant vous apportera un exemple d'explication des attributs, des méthodes, de l'encapsulation et de l'héritage basés sur les classes python3. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Venez jeter un œil avec l'éditeur
Classes Python
Les classes en Python fournissent toutes les fonctions de base de la programmation orientée objet : les classes Le mécanisme d'héritage autorise plusieurs classes de base.Une classe dérivée peut remplacer n'importe quelle méthode de la classe de base et la méthode peut appeler la méthode du même nom dans la classe de base.
Les objets peuvent contenir n'importe quelle quantité et n'importe quel type de données.
Les classes Python sont similaires aux classes C++, fournissant l'encapsulation de classe, l'héritage, l'héritage multiple, les constructeurs et les destructeurs.
En python3, la classe parent de niveau supérieur de toutes les classes est la classe d'objet. Semblable à Java, si la classe parent n'est pas écrite lors de la définition de la classe, la classe d'objet est sa classe parent directe.
Définition de classe
Le format syntaxique de la définition de classe est le suivant :
class ClassName: <statement-1> . . . <statement-N>
Objet de classe : après avoir créé une classe, vous pouvez accéder et modifier ses attributs et méthodes via le nom de la classe.
Objet d'instance : une fois la classe instanciée, vous pouvez utiliser ses attributs et ajouter dynamiquement des attributs à l'objet instance (similaire au javascript) sans affecter les objets de classe.
Attributs de la classe
Vous pouvez utiliser le point (.) pour accéder aux attributs de l'objet
Vous peut également utiliser les fonctions suivantes. Moyens d'accéder aux attributs :
getattr(obj, name[, default]) : accéder aux attributs d'un objet
hasattr(obj,name) : vérifier si un l'attribut existe
setattr(obj,name,value) : définit un attribut. Si l'attribut n'existe pas, un nouvel attribut sera créé
delattr(obj, name) : Supprimer l'attribut
Attribut de classe intégré Python
__dict__ : Attributs de la classe (contient un dictionnaire, composé des attributs de données de la classe)
__doc__ : Chaîne de documentation de la classe
__name__ : Classe name
__module__ : Le module où se trouve la définition de la classe (le nom complet de la classe est '__main__.className', si la classe est située dans un module importé mymod, alors className.__module__ est égal à mymod )
__bases__ : Tous les éléments de classe parent de la classe (Contient un tuple composé de toutes les classes parents)
class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__Méthodes de la classe
Au sein de la classe, vous pouvez utiliser le mot-clé def pour définir une méthode pour la classe Différente de la définition générale de la fonction, la méthode de classe doit contenir le paramètre self, qui est le premier paramètre.
Méthodes propriétaires de la classe :
__init__ constructeur, qui est appelé lors de la génération de l'objet
__del__ destructeur, qui est utilisé lors de la libération de l'objet. object.>
__repr__ Imprimer, convertir__setitem__Attribuer une valeur en fonction de l'index__getitem__Obtenir la valeur en fonction de l'index__len__Obtenir la longueur__cmp__Opération de comparaison__call__ appel de fonction__add__addition opération__sub__subtraction opération__mul__multiplication opération__p__division Operation __mod__ Reste opération __pow__ Square La méthode __init__() est une méthode spéciale, appelée constructeur ou méthode d'initialisation d'une classe, cette méthode est appelée lorsqu'une instance de cette classe est créée, similaire au constructeur en C++ . Remplacez simplement la méthode __init__() dans votre classe personnalisée.class Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# ice<🎜. >
MéthodeMéthode d'instance : ne peut être appelée que via l'instance. Le premier paramètre défini de la méthode d'instance ne peut être qu'une référence à l'instance elle-même
<🎜. >
Méthode de classe : Pour définir une méthode de classe, utilisez le décorateur @classmethod. Le premier paramètre défini est une référence à l'objet de classe, qui peut être utilisé directement via la classe ou l'instance.
class Myclass:
def foo(self):
print(id(self),'foo')
a=Myclass()#既然是实例对象，那就要创建实例
a.foo()#输出类里的函数地址
print(id(a))#输出类对象的地址
#结果地址一样
Méthode statique : définissez une méthode statique à l'aide du décorateur @staticmethod. Il n'y a pas de paramètres requis par défaut. 🎜>
class Myclass:
@classmethod#类装饰器
def foo2(cls):
print(id(cls),'foo2')
#类对象，直接可以调用，不需要实例化
print(id(Myclass),'yy')
Myclass.foo2()#直接可以调用
Encapsulation de classe
class Myclass:
@staticmethod#静态方法
def foo3():
print('foo3')
Myclass.foo3()#没有参数
a.foo3()
#结果foo3Python utilise des noms de variables pour distinguer les autorisations d'accès des attributs et des méthodes. les autorisations sont équivalentes à c++ et java Les attributs privés de la classe public : __private_attrs : commençant par deux traits de soulignement, déclare que l'attribut est privé et ne peut être utilisé ou directement accessible en dehors de la classe. Lors de l'utilisation de self.__private_attrs dans une méthode à l'intérieur d'une classe.
Méthodes privées de la classe : __private_method : Commençant par deux traits de soulignement, il est déclaré que la méthode est une méthode privée et ne peut pas être appelée en dehors de la classe. Appel de self.__private_methods
à l'intérieur d'une classe Bien que python ne permette pas aux classes instanciées d'accéder aux données privées, les attributs sont accessibles en utilisant object._className__attrName. En fait, l'implémentation de la privatisation interne de Python change simplement l'attribut attrName en _className__attrName
Héritage de classe
class Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456L'un des principaux avantages apportés par la programmation orientée objet est la réutilisation du code, et l'un des moyens de parvenir à cette réutilisation passe par le mécanisme d'héritage. L'héritage peut être complètement compris comme la relation de type et de sous-type entre les classes. 需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。 在python中继承中的一些特点： 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__() 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。 如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。 语法： 派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。 多态 如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法 python3.3 类与继承 小例 hon中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。 对象可以包含任意数量和类型的数据。 python类与c++类相似，提供了类的封装，继承、多继承，构造函数、析构函数。 在python3中，所有类最顶层父类都是object类，与java类似，如果定义类的时候没有写出父类，则object类就是其直接父类。 类定义 类定义语法格式如下： 类对象：创建一个类之后，可以通过类名访问、改变其属性、方法 实例对象：类实例化后，可以使用其属性，可以动态的为实例对象添加属性(类似javascript)而不影响类对象。 类的属性 可以使用点(.)来访问对象的属性 也可以使用以下函数的方式来访问属性： getattr(obj, name[, default]) : 访问对象的属性 hasattr(obj,name) : 检查是否存在一个属性 delattr(obj, name) : 删除属性 Python内置类属性 __dict__ : 类的属性（包含一个字典，由类的数据属性组成） __doc__ :类的文档字符串 __name__: 类名 __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod） __bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组） 类的方法 在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数。 类的专有方法： __init__ 构造函数，在生成对象时调用 __del__ 析构函数，释放对象时使用 __repr__ 打印，转换 __setitem__按照索引赋值 __getitem__按照索引获取值 __len__获得长度 __cmp__比较运算 __call__函数调用 __add__加运算 __sub__减运算 __mul__乘运算 __p__除运算 __mod__求余运算 __pow__称方 __init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法，与c++中构造函数类似。只需在自定义的类中重写__init__()方法即可。 析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__del__方法运行： 类的封装 python通过变量名命名来区分属性和方法的访问权限，默认权限相当于c++和java中的public 类的私有属性： __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。 类的私有方法：__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods 虽然python不允许实例化的类访问私有数据，但可以使用 object._className__attrName 访问属性。其实python内部私有化的实现只是将attrName属性变为了_className__attrName而已 类的继承 面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。 需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。 在python中继承中的一些特点： 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__() 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。 如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。 语法： 派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。 多态 如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法 python3.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!class Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))Copier après la connexionclass ClassName:
<statement-1>
.
.
.
<statement-N>
Copier après la connexionCopier après la connexion
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__Copier après la connexionCopier après la connexionclass Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# iceCopier après la connexionCopier après la connexionclass Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456Copier après la connexionCopier après la connexionclass Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))Copier après la connexion
site officiel d'okex
Quel équipement est nécessaire pour la diffusion en direct de Douyin ?
processus d'affichage Linux
Comment calculer les frais de traitement du remboursement du chemin de fer 12306
Comment créer un clone WeChat sur un téléphone mobile Huawei
Comment afficher les procédures stockées dans MySQL
Dernières tendances des prix du Bitcoin
fichier nh
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
