Soweit nicht anders angegeben, basiert das Folgende auf Python3
Gliederung:
Im Python-Tutorial werden Klassenvariablen und Instanzvariablen wie folgt beschrieben:
Im Allgemeinen gelten Instanzvariablen für Daten, die für jede Instanz eindeutig sind, und Klassenvariablen für Attribute und Methoden, die von allen Instanzen der Klasse gemeinsam genutzt werden:
Im Allgemeinen handelt es sich bei Instanzvariablen um für jede Instanz eindeutige Daten , während Klassenvariablen Eigenschaften und Methoden sind, die von allen Instanzen der Klasse gemeinsam genutzt werden.
Tatsächlich nenne ich sie lieber Klassenattribute und Instanzattribute, aber das Wort Variable ist in Programmiersprachen zu einem gebräuchlichen Namen geworden. Ein normales Beispiel ist:
class Dog:
kind = 'canine' # class variable shared by all instancesdef __init__(self, name):self.name = name # instance variable unique to each instance In der Klasse Dog werden Klassenattribute kind von allen Instanzen gemeinsam genutzt; Instanzattribute name werden von allen Dog gemeinsam genutzt zur Instanz.
Python ist ein Objekt; nachdem die Klassendefinition abgeschlossen ist, wird ein Klassenobjekt definiert im aktuellen Bereich. Der Klassenname bezieht sich auf den Namen des Klassenobjekts. Beispielsweise definiert
class Dog:pass
den Namen Dog im aktuellen Bereich und zeigt auf das Klassenobjekt Dog.
Von Klassenobjekten unterstützte Operationen:
Im Allgemeinen unterstützen Klassenobjekte nur zwei Operationen:
Instanziierungsverwendung instance_name = class_name() ist instanziiert, und die Instanziierungsoperation erstellt eine Instanz dieser Klasse.
Attributreferenz; verwenden Sie class_name.attr_name, um auf Klassenattribute zu verweisen.
Instanzobjekt ist das Produkt der Klassenobjektinstanziierung. Instanzobjekt unterstützt nur eine Operation:
Attributreferenz; verwenden Sie auf die gleiche Weise wie die Klassenobjektattributreferenz instance_name.attr_name.
Nach streng objektorientiertem Denken sollten alle Attribute Instanzen sein und Klassenattribute sollten nicht existieren. Dann bleibt in Python nur die Funktionsdefinition in der Klassendefinition übrig, da die Klassenattributbindung nicht existieren sollte.
Dasselbe sagt das Python-Tutorial auch über Klassendefinitionen:
In der Praxis handelt es sich bei den Anweisungen innerhalb einer Klassendefinition normalerweise um Funktionsdefinitionen, aber auch andere Anweisungen sind zulässig und manchmal nützlich .
In der Praxis sind die Anweisungen in einer Klassendefinition normalerweise Funktionsdefinitionen, aber auch andere Anweisungen sind zulässig und manchmal nützlich.
Die anderen hier erwähnten Anweisungen beziehen sich auf die Bindungsanweisungen von Klassenattributen.
Bei der Definition einer Klasse wird das, was wir normalerweise als definierende Attribute bezeichnen, tatsächlich in zwei Aspekte unterteilt:
Klassenattributbindung
Instanzattributbindung
Es ist genauer, das Wort Bindung zu verwenden; ob es sich um ein Klassenobjekt handelt immer noch ein Instanzobjekt, und die Eigenschaften existieren alle basierend auf dem Objekt.
Die Attributbindung, über die wir sprechen, erfordert zunächst ein veränderliches Objekt, um den Bindungsvorgang auszuführen. Verwenden Sie die Methode
objname.attr = attr_value
für das Objekt objname Bindung Eigentum attr.
Es gibt zwei Situationen:
Wenn das Attribut attr bereits vorhanden ist, verweist die Bindungsoperation den Attributnamen auf das neue Objekt; >
Python
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'Da es sich um eine dynamische Sprache handelt, können Attribute zur Laufzeit hinzugefügt und gelöscht werden. objname.attr = attr_value
3.2 Instanzattributbindung
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
Python
__init__
Python
-Methode das Instanzobjekt selbst, hier ist __init__, Anweisung selfdog
以及后面的语句
dog.fur_color = 'red'
为实例dog增加三个属性name, age, fur_color。
属性的引用与直接访问名字不同，不涉及到作用域。
类属性的引用，肯定是需要类对象的，属性分为两种：
数据属性
函数属性
数据属性引用很简单，示例：
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进阶 - 命名空间与作用域
使用实例对象引用属性稍微复杂一些，因为实例对象可引用类属性以及实例属性。但是实例对象引用属性时遵循以下规则：
总是先到实例对象中查找属性，再到类属性中查找属性；
属性绑定语句总是为实例对象创建新属性，属性存在时，更新属性指向的对象。
示例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)并不是属性绑定语句，因此还是在类属性上修改可变对象。
与数据成员不同，类函数属性在实例对象中会变成方法属性。
先看一个示例：
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 'function'>print(type(mt.inner_test)) #<class 'method'>print(type(mt.outer_test)) #<class 'function'>
可以看到，类函数属性在实例对象中变成了方法属性，但是并不是实例对象中所有的函数都是方法。
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()
除了方法与函数的区别，其引用与数据属性都是一样的
虽然Python作为动态语言，支持在运行时绑定属性，但是从面向对象的角度来看，还是在定义类的时候将属性确定下来。
Das obige ist der detaillierte Inhalt vonPython-Grundlagenklassenvariablen und Instanzvariablen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
