Python基础：17类和实例之一_python 类的先声明后定义-CSDN博客

本文链接：https://blog.csdn.net/gqtcgq/article/details/46415927

1：类通常在一个模块的顶层进行定义。对于Python来说，声明与定义类是同时进行的。

2：类属性仅与其类相绑定，类数据属性仅当需要有更加“静态”数据类型时才变得有用，这种属性是静态变量。它们表示这些数据是与它们所属的类绑定的，不依赖于任何类实例。类似于Java或C++中在一个变量声明前加上static 关键字。

3：方法，比如下面，类MyClass 中的myNoActionMethod 方法，仅仅是一个作为类定义一部分定义的函数。（这使得方法成为类属性）。这表示myNoActionMethod 仅应用在MyClass 类型的对象（实例）上。

class MyClass(object):

def myNoActionMethod(self):

pass

>>> mc = MyClass()

>>>mc.myNoActionMethod()

任何像函数一样对myNoActionMethod 自身的调用都将失败：

>>>myNoActionMethod()

Traceback (innermost last):

File "<stdin>",line 1, in ?

myNoActionMethod() NameError:myNoActionMethod

引发了NameError 异常，因为在全局名字空间中，没有这样的函数存在。

甚至由类调用此方法也失败了。

>>>MyClass.myNoActionMethod()

Traceback (innermost last):

File"<stdin>", line 1, in ?

MyClass.myNoActionMethod()

TypeError: unbound method must be called with class instance 1st argument

这是因为，Python 严格要求，没有实例，方法是不能被调用的。这种限制即Python所描述的绑定概念(binding)，在此，方法必须绑定（到一个实例）才能直接被调用。

然而，不管是否绑定，方法都是它所在的类的固有属性，即使它们几乎总是通过实例来调用的。

4：要知道一个类有哪些属性，有两种方法。最简单的是使用dir()内建函数。另外是通过访问类的字典属性__dict__，这是所有类都具备的特殊属性之一。例子：

class MyClass(object):

'MyClass class definition'

myVersion = '1.1'

def showMyVersion(self):

print MyClass.myVersion

>>> dir(MyClass)

['__class__', '__delattr__','__dict__', '__doc__','__getattribute__', '__hash__', '__init__','__module__','__new__', '__reduce__', '__reduce_ex__','__repr__','__setattr__', '__str__', '__weakref__', 'myVersion','showMyVersion']

>>> MyClass.__dict__

>>> printMyClass.__dict__

{'showMyVersion':<function showMyVersion at 0x59370>,'__dict__': <attribute '__dict__'of 'MyClass' objects>,'myVersion': '1.1','__weakref__': <attribute'__weakref__' of 'MyClass' objects>, '__doc__':'MyClassclass definition'}

注意，dir返回的结果，除了包含类自身的属性之外，还包括所有父类的属性。而__dict__则只包含类本身的属性。类的__dict__是只读的，不可更新的。

dir的结果包含了__dict__。

dir()返回的仅是属性的一个名字列表，而__dict__返回的是一个字典，它的键(keys)是属性名，键值(values)是相应的属性对象的数据值。

内建的vars()函数接受类对象作为参数，返回类的__dict__属性的内容。

5：对任何类Ｃ，都具有特殊属性：

C.__name__	类Ｃ的名字（字符串）
C.__doc__	类Ｃ的文档字符串
C.__bases__	类Ｃ的所有父类构成的元组
C.__dict__	类Ｃ的属性
C.__module__	类Ｃ定义所在的模块（1.5 版本新增）
C.__class__	实例Ｃ对应的类（仅新式类中）

根据上面定义的类MyClass，有如下结果：

>>>MyClass.__name__

'MyClass'

>>> MyClass.__doc__

'MyClass class definition'

>>> MyClass.__bases__

(<type 'object'>,)

>>> print MyClass.__dict__

{'__doc__': None, 'myVersion': 1, 'showMyVersion': <functionshowMyVersion at 950ed0>, '__module__': '__main__'}

>>> MyClass.__module__

'__main__'

>>> MyClass.__class__

<type 'type'>

__name__是给定类的字符名字。一些内建的类型也有这个属性。可以使用类型对象的__name__属性来取得相应的字符串名。如下例示：

>>> stype = type('Whatis your quest?')

>>> stype

<type'string'>

>>> stype.__name__

'str'

>>>

>>> type(3.14159265)

>>>type(3.14159265).__name__

'float'

__doc__是类的文档字符串，与函数及模块的文档字符串相似，必须紧随头行（header line）后的字符串。文档字符串不能被派生类继承，也就是说派生类必须含有它们自己的文档字符串。

__bases__包含了一个由所有父类组成的元组。

__dict__属性包含一个字典，由类的属性组成。访问一个类属性的时候，Python 解释器将会搜索字典以得到需要的属性。如果在__dict__中没有找到，将会在基类的字典中进行搜索。对类的修改会仅影响到此类的字典；基类的__dict__属性不会被改动的。

Python支持模块间的类继承。1.5 版本中引入了__module__，这样类名就完全由模块名所限定。看一下下面的例子：

>>> class C(object):

... pass

...

>>> C

>>>C.__module__

'__main__'

类C 的全名是“__main__.C”，比如，source_module.class_name。如果类C 位于一个导入的模块中，如mymod，像下面的：

>>> from mymod import C

>>> C

>>>C.__module__

'mymod'

最后，由于类型和类的统一性，当访问任何类的__class__属性时，将发现它就是一个类型对象的实例。对于经典类，这个属性并未定义。

>>> class test(object): pass

...

>>>test.__class__

>>>

>>> class test: pass

...

>>>test.__class__

Traceback (most recentcall last):

File "<stdin>", line 1, in<module>

AttributeError:class test has no attribute '__class__'

6：实例

类和类型在2.2 版本中就统一了，新式类如下：

>>> mc = MyClass()

>>> type(mc)

>>> type(0)

MyClass 和 int，你将会发现二者都是类型(type)：

>>>type(MyClass)

>>> type(int)

在Python2.2 版本之前，对于经典类，类是类类型，实例是实例类型。在这两个对象类型之间没有任何关系，除了实例的__class__属性引用了该类。经典类如下：

>>>type(mc)

>>> type(0)

>>>

>>>type(MyClass)

>>> type(int)

7：当类被调用，实例化的第一步是创建实例对象。一旦对象创建了，Python 检查是否实现了__init__()方法。默认情况下，如果没有定义（或覆盖）特殊方法__init__()，对实例不会施加任何特别的操作，实例化过程完毕。

如果__init__()已经被实现，那么它将被调用，实例对象作为第一个参数(self)被传递进去，像标准方法调用一样。__init__()是在解释器为你创建一个实例后调用的第一个方法，在你开始使用它之前，这一步可以让你做些准备工作。

如果定义了__init__，它不应当返回任何对象，否则，就可能出现冲突，试着返回非None 的任何其它对象都会导致TypeError 异常：

>>> class MyClass:

... def __init__(self):

... print 'initialized'

... return 1

...

>>> mc = MyClass()

initialized

Traceback (innermost last):File "<stdin>", line 1, in ?

mc = MyClass()

TypeError:__init__() should return None

__new__()“构造器”方法

与__init__()相比，__new__()方法更像一个真正的构造器。它是一个类方法，并且传入的参数是在类实例化操作时生成的。__new__()会调用父类的__new__()来创建对象（向上代理）。

__new__()必须返回一个合法的实例，__new__()和__init__()在类创建时，都传入了（相同）参数。它们的参数必须一致，否则会出错。

__del__()"解构器"方法

有一个相应的特殊解构器（destructor）方法名为__del__()。这个函数要直到该实例对象所有的引用都被清除掉后才会执行。它通常没有被实现，因为实例很少被显式释放。

举例：

class C(P):

def __init__(self):

print 'initialized'

def __del__(self):

P.__del__(self)

>>> c1 = C()

>>> c2 = c1

>>> c3 = c1

>>> id(c1), id(c2), id(c3)

(11938912, 11938912, 11938912)

>>> del c1

>>> del c2

>>> del c3

deleted

在上面的例子中，解构器是在类C 实例所有的引用都被清除掉后，才被调用的。一旦引用计数为0，则对象就被清除了。

总结：

不要忘记首先调用父类的__del__()。

调用 del x 不表示调用了x.__del__() -----它仅仅是减少x 的引用计数。

__del__()未捕获的异常会被忽略掉（因为一些在__del__()用到的变量或许已经被删除了）。

不要在__del__()中干与实例没任何关系的事情。

除非你知道你正在干什么，否则不要去实现__del__()。

8：实例属性

实例仅拥有数据属性，方法是类属性，数据属性只是与某个类的实例相关联的数据值，这些值独立于其它实例或类。当一个实例被释放后，它的属性同时也被清除了。

设置实例的属性可以在实例创建后任意时间进行，也可以在能够访问实例的代码中进行。可以能够在“运行时”创建实例属性，是Python 类的优秀特性之一。但是这样创建属性时，必须谨慎。

内建函数dir()同样还可以打印所有实例属性：

>>> class C(object):

... pass

>>> c = C()

>>> c.foo = 'roger'

>>> c.bar = 'shrubber'

>>> dir(c)

['__class__', '__delattr__','__dict__', '__doc__', '__getattribute__', '__hash__', '__init__','__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__','__str__', '__weakref__', 'bar', 'foo']

实例也有一个__dict__特殊属性（可以调用vars()并传入一个实例来获取），它是实例属性构成的一个字典：

>>>c.__dict__

{'foo': 'roger', 'bar': 'shrubber'}

dir(实例)也包含类的属性。实例的__dict__只有实例属性，它是可写的。没有类属性或特殊属性。

实例仅有两个特殊属性，对于任意对象I：

I.__class__	实例化I 的类
I.__dict__	I 的属性

现在使用类C 及其实例C 来看看这些特殊实例属性：

>>> class C(object):

... pass

...

>>> c = C()

>>> dir(c)

['__class__', '__delattr__','__dict__', '__doc__', '__format__', '__getattribute__', '__hash__','__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__','__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

>>> c.__dict__

{}

>>> c.__class__

可以看到，c 现在还没有数据属性，但我们可以添加一些再来检查__dict__属性，看是否添加成功了：

>>> c.foo = 1

>>> c.bar = 'SPAM'

>>> '%d can of %splease' % (c.foo, c.bar)

'1 can of SPAM please'

>>>c.__dict__

{'foo': 1, 'bar':'SPAM'}

对类和实例来说，尽管__dict__属性是可修改的，但还是建议你不要修改这些字典，使用熟悉的句点属性标识来访问及操作属性会更易于接受。

9：内建类型属性

内建类型也是类，对内建类型也可以使用dir()，与任何其它对象一样，可以得到一个包含它属性名字的列表：

>>> x = 3+0.14j

>>> x.__class__

>>> dir(x)

['__abs__', '__add__','__class__', '__coerce__','__delattr__', '__div__', '__divmod__', '__doc__','__eq__','__float__', '__floordiv__', '__ge__','__getattribute__','__getnewargs__', '__gt__', '__hash__', '__init__','__int__','__le__', '__long__', '__lt__', '__mod__','__mul__', '__ne__', '__neg__','__new__', '__nonzero__','__pos__', '__pow__', '__radd__', '__rdiv__','__rdivmod__','__reduce__', '__reduce_ex__', '__repr__','__rfloordiv__','__rmod__', '__rmul__', '__rpow__', '__rsub__','__rtruediv__','__setattr__', '__str__', '__sub__','__truediv__', 'conjugate', 'imag', 'real']

>>> x.imag

2.0

>>> x.real

1.0

>>> x.conjugate()

(1-2j)

试着访问__dict__会失败，因为在内建类型中，不存在这个属性：

>>> x.__dict__

Traceback (innermost last):File "<stdin>", line 1, in ?

AttributeError: __dict__

10：实例属性 vs 类属性

类属性和实例无关。这些值像静态成员那样被引用，即使在多次实例化中调用类，它们的值都保持不变。不管如何，静态成员不会因为实例而改变它们的值，除非实例中显式改变它们的值。

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

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

类属性可通过类或实例来访问。下面的示例中，类C 在创建时，带一个version 属性，这样通过类对象来访问它是很自然的了，比如，C.version。当实例c 被创建后，对实例c 而言，访问c.version 时，Python 首先会在实例中搜索名字version，然后是类，再就是继承树中的基类。本例中，version 在类中被找到了：

>>> class C(object):

... version = 1.2

...

>>> c = C()

>>>C.version

1.2

>>>c.version

1.2

>>>C.version += 0.1

>>>C.version

1.3

>>>c.version

1.3

只有当使用类引用version 时，才能更新它的值，像上面的C.version 递增语句。如果尝试在实例中设定或更新类属性会创建一个实例属性c.version，后者会阻止对类属性C.versioin 的访问，因为第一个访问的就是c.version，这样可以对实例有效地“遮蔽”类属性C.version，直到c.version 被清除掉。

从实例中访问类属性须谨慎

与通常Python 变量一样，任何对实例属性的赋值都会创建一个实例属性（如果不存在的话）并且对其赋值。如果类属性中存在同名的属性，有趣的副作用即产生。（经典类和新式类都存在）

>>> class Foo(object):

... x = 1.5

...

>>> foo = Foo()

>>> foo.x

1.5

>>> foo.x =1.7

>>> foo.x

1.7

>>> Foo.x