Résumé des points de connaissances sur la programmation orientée objet Python

Python est depuis le début un langage orienté objet. De ce fait, il est facile de créer des classes et des objets en Python. L'article suivant vous présentera en détail les points de connaissances sur la programmation orientée objet Python. Les amis dans le besoin peuvent s'y référer.

Avant-propos

Si vous n'avez jamais été exposé aux langages de programmation orientés objet auparavant, vous devrez peut-être d'abord comprendre certaines fonctionnalités de base des langages orientés objet et former un objet de base - langage de programmation orienté dans votre esprit, qui vous aidera à apprendre plus facilement la programmation orientée objet en Python.

Apprenons ensuite la programmation orientée objet en Python.

Classes et instances

Une classe est la définition d'un objet, et une instance est le "objet réel", qui stocke les informations spécifiques de l'objet défini dans la classe.

Conventions de dénomination des classes, des attributs et des méthodes

Les noms de classes commencent généralement par une lettre majuscule. Il s'agit d'une convention standard et peut vous aider à identifier les classes, notamment lors de l'instanciation (qui ressemble parfois à des appels de fonction). De plus, les attributs de données (variables ou constantes) doivent ressembler aux noms de valeurs de données, et les noms de méthodes doivent indiquer le comportement de l'objet ou de la valeur correspondant.

Une autre façon de l'exprimer est la suivante : les valeurs des données doivent utiliser des noms comme noms, et les méthodes doivent utiliser des prédicats (verbes plus objets). L'élément de données est l'objet sur lequel opérer, et la méthode doit indiquer quelle opération le programmeur souhaite effectuer sur l'objet.

Dans la classe définie, suivez grossièrement cette ligne directrice, avec des valeurs de données comme "nom", "téléphone" et "e-mail" et des comportements comme "updatePhone" et "updateEmail". Ceci est souvent appelé « MixedCase » ou « camelCase ». La spécification Python recommande d'utiliser la notation camel avec des traits de soulignement, par exemple "update_phone", "update_email". Les classes doivent également être nommées avec soin, par exemple "AddrBookEntry", "RepairShop", etc. sont de bons noms.

class AddrBookEntry(object):

 def __init__(self, name, phone, email):
 self.name = name
 self.phone = phone
 self.email = email

 def update_phone(self, phone):
 self.phone = phone

 def update_email(self. email):
 self.email = email

Classes de nouveau style et classes de style ancien

La plus grande différence entre les classes de nouveau style et les déclarations de classe classiques est que toutes les classes de nouveau style doivent hériter d'au moins une classe parent. S'il n'y a pas de classe dont hériter, la classe d'objet peut être héritée. L'objet est la « mère de toutes les classes » et se situe au sommet de toutes les structures d'héritage de classe. S'il n'y a pas de sous-classement direct ou indirect d'un objet, alors une classe classique est définie. Autrement dit, si aucune classe parent n’est spécifiée ou si la classe de base sous-classée n’a pas de classe parent, une classe classique est créée.

Les classes définies dans Python3 sont des classes de nouveau style par défaut. Pour définir une classe de nouveau style dans Python2, vous devez hériter d'un objet ou d'une classe de nouveau style.

auto variable

Les méthodes de classe n'ont qu'une seule différence particulière par rapport aux fonctions ordinaires, c'est-à-dire qu'elles doivent avoir un premier nom de paramètre supplémentaire, mais vous n'êtes pas obligé de le faire lors de l'appel cette méthode. Attribuez ce paramètre et Python fournira cette valeur. Cette variable particulière fait référence à l'objet lui-même et, par convention, son nom est self. Bien que vous puissiez donner n'importe quel nom à ce paramètre, il est fortement recommandé d'utiliser le nom self, et les autres noms sont obsolètes. La méthode

__init__()

__init__() est similaire à un constructeur de classe, mais n'est pas réellement un constructeur. Une fois que Python a créé une instance, il appelle la méthode __init__() pendant le processus d'instanciation. Lorsqu'une classe est instanciée, vous pouvez définir des comportements supplémentaires, tels que la définition de valeurs initiales ou l'exécution d'un code de diagnostic préliminaire. Cela se fait principalement après. une instance est créée, l'appel d'instanciation effectue certaines tâches ou paramètres avant de renvoyer l'instance.

Méthodes liées et non liées

En Python, les méthodes d'accès à une classe sont accessibles directement via des instances ou directement via des classes. Cependant, Python exige strictement que les méthodes ne puissent pas être appelées sans instance. Cette restriction est ce que Python décrit comme une liaison, où une méthode doit être liée (à une instance) pour être appelée directement. Les méthodes non liées peuvent être appelées, mais l'objet instance doit être explicitement donné pour garantir que l'appel réussit. Cependant, qu'elles soient liées ou non, les méthodes sont des propriétés inhérentes à la classe dans laquelle elles existent, même si elles sont presque toujours appelées via des instances. Les méthodes de classe en Python sont également des objets. On peut simplement comprendre que les méthodes accessibles directement via les classes sont appelées « méthodes non liées », tandis que les méthodes accessibles via les instances sont appelées « méthodes liées » :

Classes non liées Méthode : il n'y a pas de soi

<.>Faire référence à une méthode via la classe renvoie un objet méthode indépendant. Pour l'appeler, vous devez fournir explicitement une instance comme premier argument.

2. Méthodes d'instance liées : il existe un self

qui renvoie un objet de méthode lié via la méthode d'accès à l'instance. Python lie automatiquement une instance à la méthode, nous n'avons donc pas besoin de transmettre un paramètre d'instance lors de son appel.

Exemple :

class Test:
 def func(self, message):
 print message

object1 = Test()
x = object1.func
x("绑定方法对象，实例是隐藏的")

t = Test.func
t(object1, "未绑定方法对象，需要传递一个实例")
# t("未绑定方法对象，需要传递一个实例") # 错误的调用

Attributs de classe et attributs d'instance

类属性仅是与类相关的数据值，和实例属性不同，类属性和实例无关。这些值像静态成员那样被引用，即使在多次实例化中调用类，它们的值都保持不变。不管如何，静态成员不会因为实例而改变它们的值，除非实例中显式改变它们的值。 实例属性与类属性的比较，类似于自动变量和静态变量，但这只是笼统的类推。在你对自动变量和静态变量还不是很熟的情况下，不要深究这些。

类和实例都是名字空间。类是类属性的名字空间，实例则是实例属性的。

可采用类来访问类属性，如果实例没有同名的属性的话，也可以用实例来访问。

私有化

Python并不直接支持私有方式，而要靠程序员自己把握在外部进行特性修改的时机。

为了让方法或者特性变为私有（从外部无法访问），只要在它的名字前面加上双下划线即可。由双下划线 __ 开始的属性在运行时被“混淆”，所以直接访问是不允许的。

实际上，在 Python 带有双下划线的属性或方法并非正真意义上的私有，它们仍然可以被访问。在类的内部定义中，所有以双下划线开始的名字都被“翻译”成前面加上单下划线和类名的形式：

>>> class TestObj(object):
... __war = "world"
... 
... def __init__(self):
...  self.__har = "hello"
...  
... def __foo(self):
...  print(self.__har + self.__war)
...  
... 
... 
>>> t = TestObj()
>>> dir(t)
['_TestObj__foo', '_TestObj__har', '_TestObj__war', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getat
tribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__
', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
>>> t.__war
Traceback (most recent call last):
 File "<input>", line 1, in <module>
 t.__war
AttributeError: 'TestObj' object has no attribute '__war'
>>> t.__har
Traceback (most recent call last):
 File "<input>", line 1, in <module>
 t.__har
AttributeError: 'TestObj' object has no attribute '__har'
>>> t.foo()
Traceback (most recent call last):
 File "<input>", line 1, in <module>
 t.foo()
AttributeError: 'TestObj' object has no attribute 'foo'
>>> t._TestObj__war
'world'
>>> t._TestObj__har
'hello'
>>> t._TestObj__foo()
helloworld

__slots__ 类属性

正常情况下，当我们定义了一个 class，创建了一个 class 的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。在 Python 中默认用字典来存储实例的属性。

示例：

>>> class A():
... pass
... 
>>> a = A()
>>> a.name = "huoty"
>>> a.age = 25
>>> print a.name
huoty
>>> print a.age
25
>>> a.__dict__
{'age': 25, 'name': 'huoty'}

字典位于实例的“心脏” 。 __dict__属性跟踪所有实例属性。举例来说，你有一个实例 inst，它有一个属性 foo，那使用 inst.foo 来访问它与使用 inst.__dict__['foo'] 来访问是一致的。

字典会占据大量内存，如果你有一个属性数量很少的类，但有很多实例，那么正好是这种情况。为内存上的考虑，可以使用 __slots__ 属性来替代 __dict__ 。

， __slots__ 是新式类的特性。基本上， __slots__ 是一个类变量，由一序列对象组成，由所有合法标识构成的实例属性的集合来表示。它可以是一个列表，元组或可迭代对象。也可以是标识实例能拥有的唯一的属性的简单字符串。任何试图创建一个其名不在 __slots__ 中的名字的实例属性都将导致 AttributeError 异常：

>>> class SlotedClass(object):
... __slots__ = ("foo", "bar")
... 
... 
>>> c = SlotedClass()
>>> c.foo = 42
>>> c.bar = "hello"
>>> c.goo = "don't think so"
Traceback (most recent call last):
 File "<input>", line 1, in <module>
AttributeError: 'SlotedClass' object has no attribute 'goo'

这种特性的主要目的是节约内存。其副作用是某种类型的"安全",它能防止用户随心所欲的动态增加实例属性。带 __slots__ 属性的类定义不会存在 __dict__ 了（除非你在 __slots__ 中增加 __dict__ 元素）。

更多关于Python面向对象编程的知识点总结相关文章请关注PHP中文网！