Variables de classe de base de Python et variables d'instance

Principes de base de Python - Variables de classe et variables d'instance

écrites devant

Sauf indication contraire, ce qui suit est basé sur Python3

Outline :

1. Variables de classe et variables d'instance

Dans le didacticiel Python, les variables de classe et les variables d'instance sont décrites comme ceci :

D'une manière générale, les variables d'instance sont destinées aux données uniques à chaque instance et les variables de classe sont destinées aux attributs et méthodes partagés par toutes les instances de la classe :

D'une manière générale, les variables d'instance sont pour chaque instance des données uniques , tandis que les variables de classe sont des propriétés et des méthodes partagées par toutes les instances de la classe.

En fait, je préfère les appeler attributs de classe et attributs d'instance, mais le mot variable est devenu un nom habituel dans les langages de programmation. Un exemple normal est :

class Dog:

    kind = 'canine'         # class variable shared by all instancesdef __init__(self, name):self.name = name    # instance variable unique to each instance

Dans la classe Dog, les attributs de classe kind sont partagés par toutes les instances, les attributs d'instance name sont partagés par chacune Dog Unique ; à l'instance.

2. Objets de classe et objets d'instance

2.1 Tout dans les objets de classe

Python est un objet ; une fois la définition de la classe terminée, un objet de classe sera défini. dans la portée actuelle. Le nom de la classe fait référence au nom de l'objet de classe. Par exemple,

class Dog:pass

définira le nom Dog dans la portée actuelle, pointant vers l'objet de classe Dog.

Opérations prises en charge par les objets de classe :
En général, les objets de classe ne prennent en charge que deux opérations :

1. L'instanciation instance_name = class_name() est ; instancié, et l'opération d'instanciation crée une instance de cette classe.

2. référence d'attribut ; utilisez class_name.attr_name pour référencer les attributs de classe.

2.2 Objet instance

L'objet instance est le produit de l'instanciation d'un objet de classe. L'objet instance ne prend en charge qu'une seule opération :

1. Référence d'attribut ; de la même manière que la référence d'attribut d'objet de classe, utilisez instance_name.attr_name.

Selon une pensée strictement orientée objet, tous les attributs devraient être des instances et les attributs de classe ne devraient pas exister. Ensuite, dans Python, puisque la liaison d'attribut de classe ne devrait pas exister, seule la définition de fonction est laissée dans la définition de classe.

Le tutoriel Python dit également la même chose à propos des définitions de classe :

En pratique, les instructions à l'intérieur d'une définition de classe seront généralement des définitions de fonctions, mais d'autres instructions sont autorisées, et parfois utiles .

En pratique, les instructions dans les définitions de classe sont généralement des définitions de fonctions, mais d'autres instructions sont autorisées et parfois utiles.

Les autres déclarations mentionnées ici font référence aux déclarations contraignantes des attributs de classe.

3. Liaison d'attributs

Lors de la définition d'une classe, ce que nous appelons habituellement la définition d'attributs est en fait divisé en deux aspects :

1. Liaison d'attributs de classe

2. Liaison d'attribut d'instance

Il est plus précis d'utiliser le mot liaison s'il s'agit d'un objet de classe ; toujours un objet d'instance, et les propriétés existent toutes en fonction de l'objet.

La liaison d'attribut dont nous parlons nécessite d'abord un objet variable pour effectuer l'opération de liaison. Utilisez la méthode de

objname.attr = attr_value

pour l'objet objname Liaison. propriété attr.

Il existe deux situations :

1. Si l'attribut attr existe déjà, l'opération de liaison fera pointer le nom de l'attribut vers le nouvel objet

2. S'il n'existe pas, ajoutez un nouvel attribut à l'objet, et vous pourrez référencer le nouvel attribut plus tard.

3.1 Liaison d'attributs de classe

En tant que langage dynamique, les objets de classe et les objets d'instance peuvent lier n'importe quel attribut au moment de l'exécution. Par conséquent, la liaison des attributs de classe se produit à deux endroits : Python

1. lorsque la classe est définie

2. à tout moment de l'exécution ;

L'exemple suivant illustre la période pendant laquelle la liaison des attributs de classe se produit :

class Dog:

    kind = 'canine'Dog.country = 'China'print(Dog.kind, ' - ', Dog.country) # output: canine  -  Chinadel Dog.kindprint(Dog.kind, ' - ', Dog.country) # AttributeError: type object 'Dog' has no attribute 'kind'

Dans la définition de classe, la liaison des attributs de classe La méthode de

n'est pas utilisée. C'est un cas particulier. Elle est en fait équivalente à la méthode de liaison des attributs utilisant les noms de classe plus tard. objname.attr = attr_valueComme il s'agit d'un langage dynamique, des attributs peuvent être ajoutés et supprimés au moment de l'exécution.

3.2 Liaison d'attribut d'instance

Comme la liaison d'attribut de classe, la liaison d'attribut d'instance se produit également à deux endroits :

1. Lorsque la classe est définie ;

2. N'importe quelle étape pendant l'exécution.

Exemple :

class Dog:def __init__(self, name, age):self.name = nameself.age = age

dog = Dog('Lily', 3)
dog.fur_color = 'red'print('%s is %s years old, it has %s fur' % (dog.name, dog.age, dog.fur_color))# Output: Lily is 3 years old, it has red fur

Il y a deux particularités à propos des instances de classe : Python

1. Exécuté lors de l'instanciation__init__

2. Lorsqu'une instance appelle une méthode, l'objet instance est passé comme premier paramètrePython

Par conséquent, le

dans la méthode __init__ est l'objet instance lui-même, voici self, instruction dog

self.name = nameself.age = age

以及后面的语句

dog.fur_color = 'red'

为实例dog增加三个属性name, age, fur_color。

4. 属性引用

属性的引用与直接访问名字不同，不涉及到作用域。

4.1 类属性引用

类属性的引用，肯定是需要类对象的，属性分为两种：

1. 数据属性

2. 函数属性

数据属性引用很简单，示例：

class Dog:

    kind = 'canine'Dog.country = 'China'print(Dog.kind, ' - ', Dog.country) # output: canine  -  China

通常很少有引用类函数属性的需求，示例：

class Dog:

    kind = 'canine'def tell_kind():print(Dog.kind)
        
Dog.tell_kind() # Output: canine

函数tell_kind在引用kind需要使用Dog.kind而不是直接使用kind，涉及到作用域，这一点在我的另一篇文章中有介绍：Python进阶 - 命名空间与作用域

4.2 实例属性引用

使用实例对象引用属性稍微复杂一些，因为实例对象可引用类属性以及实例属性。但是实例对象引用属性时遵循以下规则：

1. 总是先到实例对象中查找属性，再到类属性中查找属性；

2. 属性绑定语句总是为实例对象创建新属性，属性存在时，更新属性指向的对象。

4.2.1 数据属性引用

示例1：

class Dog:

    kind = 'canine'country = 'China'def __init__(self, name, age, country):self.name = nameself.age = ageself.country = country

dog = Dog('Lily', 3, 'Britain')print(dog.name, dog.age, dog.kind, dog.country)# output: Lily 3 canine Britain

类对象Dog与实例对象dog均有属性country，按照规则，dog.country会引用到实例对象的属性；但实例对象dog没有属性kind，按照规则会引用类对象的属性。

示例2：

class Dog:

    kind = 'canine'country = 'China'def __init__(self, name, age, country):self.name = nameself.age = ageself.country = country

dog = Dog('Lily', 3, 'Britain')print(dog.name, dog.age, dog.kind, dog.country) # Lily 3 canine Britainprint(dog.__dict__) # {'name': 'Lily', 'age': 3, 'country': 'Britain'}dog.kind = 'feline'print(dog.name, dog.age, dog.kind, dog.country) # Lily 3 feline Britainprint(dog.__dict__) 
print(Dog.kind) # canine 没有改变类属性的指向# {'name': 'Lily', 'age': 3, 'country': 'Britain', 'kind': 'feline'}

使用属性绑定语句dog.kind = 'feline'，按照规则，为实例对象dog增加了属性kind，后面使用dog.kind引用到实例对象的属性。

这里不要以为会改变类属性Dog.kind的指向，实则是为实例对象新增属性，可以使用查看__dict__的方式证明这一点。

示例3，可变类属性引用：

class Dog:
    
    tricks = []def __init__(self, name):self.name = namedef add_trick(self, trick):self.tricks.append(trick)

d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')print(d.tricks) # ['roll over', 'play dead']

语句self.tricks.append(trick)并不是属性绑定语句，因此还是在类属性上修改可变对象。

4.2.2 方法属性引用

与数据成员不同，类函数属性在实例对象中会变成方法属性。

先看一个示例：

class MethodTest:def inner_test(self):print('in class')def outer_test():print('out of class')

mt = MethodTest()
mt.outer_test = outer_testprint(type(MethodTest.inner_test))  # <class &#39;function&#39;>print(type(mt.inner_test))          #<class &#39;method&#39;>print(type(mt.outer_test))          #<class &#39;function&#39;>

可以看到，类函数属性在实例对象中变成了方法属性，但是并不是实例对象中所有的函数都是方法。

Python tutorial中这样介绍方法对象：

When an instance attribute is referenced that isn’t a data attribute, its class is searched. If the name denotes a valid class attribute that is a function object, a method object is created by packing (pointers to) the instance object and the function object just found together in an abstract object: this is the method object. When the method object is called with an argument list, a new argument list is constructed from the instance object and the argument list, and the function object is called with this new argument list.

引用非数据属性的实例属性时，会搜索它对应的类。如果名字是一个有效的函数对象，Python会将实例对象连同函数对象打包到一个抽象的对象中并且依据这个对象创建方法对象：这就是被调用的方法对象。当使用参数列表调用方法对象时，会使用实例对象以及原有参数列表构建新的参数列表，并且使用新的参数列表调用函数对象。

那么，实例对象只有在引用方法属性时，才会将自身作为第一个参数传递；调用实例对象的普通函数，则不会。
所以可以使用如下方式直接调用方法与函数：

mt.inner_test()
mt.outer_test()

除了方法与函数的区别，其引用与数据属性都是一样的

5. 最佳实践

虽然Python作为动态语言，支持在运行时绑定属性，但是从面向对象的角度来看，还是在定义类的时候将属性确定下来。

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!