深入理解python面向对象_转：Python3 面向对象，较为深入的两个理解

一，

1. 类的声明和创建

对于 Python 函数来说，声明与定义类没什么区别，因为他们是同时进行的，定义(类体)紧跟在声明(含 class 关键字的头行[header line])和可选(但总是推荐使用)的文档字符串后面。同时，所有的方法也必须同时被定义。

请注意 Python 并不支持纯虚函数(像 C++)或者抽象方法(如在 JAVA 中)，这些都强制程序员在子类中定义方法。作为替代方法，你可以简单地在基类方法中引发 NotImplementedError 异常，这样可以获得类似的效果。

2. 有关类的属性

(1)查看类的属性

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

python

>>> class HaHa:

"""Haha to you!"""

variable1 = "Good"

variable2 = "Nice"

def change(self):

self.variable1 = "Bad"

>>> dir(HaHa)

['__doc__', '__module__', 'change', 'variable1', 'variable2']

>>> HaHa.__dict__

{'variable1': 'Good', '__module__': '__main__', 'variable2': 'Nice', '__doc__': 'Haha to you!', 'change': }

1

2

3

4

5

6

7

8

9

10

11

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

(2)类的特殊属性

C.__name__      类Ｃ的名字(字符串)

C.__doc__       类Ｃ的文档字符串

C.__bases__     类Ｃ的所有父类构成的元组

C.__dict__      类Ｃ的属性

C.__module__    类Ｃ定义所在的模块(1.5 版本新增)

C.__class__     实例Ｃ对应的类(仅新式类中)

1

2

3

4

5

6

3. 对象

(1)Understanding __new__ and __init__

Understanding __new__ and __init__

(2)__del__()方法

有一个相应的特殊解构器(destructor)方法名为__del__()。然而，由于 Python 具有垃圾对象回收机制(靠引用计数)，这个函数要直到该实例对象所有的引用都被清除掉后才会执行。

Python 中的解构器是在实例释放前提供特殊处理功能的方法，它们通常没有被实现，因为实例很少被显式释放。

要注意，解构器只能被调用一次，一旦引用计数为 0，则对象就被清除了。

总结：

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

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

如果你有一个循环引用或其它的原因，让一个实例的引用逗留不去， 该对象的__del__()可能永远不会被执行。

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

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

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

如果你定义了__del__()，并且实例是某个循环的一部分，垃圾回收器将不会终止这个循环——你需要自已显式调用 del。

(3)跟踪对象

Python 没有提供任何内部机制来跟踪一个类有多少个实例被创建了，或者记录这些实例是些什么东西。如果需要这些功能，你可以显式加入一些代码到类定义或者__init__()和__del__()中去。最好的方式是使用一个静态成员来记录实例的个数。 靠保存它们的引用来跟踪实例对象是很危险的，因为你必须合理管理这些引用，不然，你的引用可能没办法释放(因为还有其它的引用)！

class InstCt(object):

count = 0 # count is class attr

def __init__(self): # increment count

InstCt.count += 1

def __del__(self): # decrement count

InstCt.count -= 1

def howMany(self): # return count

return InstCt.count

>>> a = InstTrack()

>>> b = InstTrack()

>>> b.howMany()

2

>>> a.howMany()

2

>>> del b

>>> a.howMany()

1

>>> del a

>>> InstTrack.count

0

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

(4)类、实例的其它内建函数

issubclass() 布尔函数判断一个类是另一个类的子类或子孙类。它有如下语法：issubclass(sub, sup)

isinstance() 布尔函数在判定一个对象是否是另一个给定类的实例时，非常有用。它有如下语法：isinstance(obj1, obj2)

hasattr(), getattr(),setattr(), delattr()这些函数顾名思义，不做解释。

4. 静态方法和类方法

有两种方式声明静态方法和类方法：

使用staticmethod()和 classmethod()内建函数

class TestStaticMethod:

def foo():

print 'calling static method foo()'

foo = staticmethod(foo)

class TestClassMethod:

def foo(cls):

print 'calling class method foo()'

print 'foo() is part of class:', cls.__name__

foo = classmethod(foo)

1

2

3

4

5

6

7

8

9

10

使用装饰器

class TestStaticMethod:

@staticmethod

def foo():

print 'calling static method foo()'

class TestClassMethod:

@classmethod

def foo(cls):

print 'calling class method foo()'

print 'foo() is part of class:', cls.__name__

1

2

3

4

5

6

7

8

9

10

静态方法和类方法的区别：

静态方法没有cls参数，所以它既不能访问实例变量，也不能访问类变量。

5. 继承

(1)__bases__类属性

我们可以通过此属性获得父类的信息。语法:ClassName.__bases__

(2)方法覆盖(overriding)

Code example :

>>> class Parent(object):

def foo(self):

print 'Parent foo'

>>> class Son(Parent):

def foo(self):  # 父类的foo方法被覆盖

print 'Son foo'

>>> son = Son()

>>> son.foo()

Son foo

1

2

3

4

5

6

7

8

9

10

11

12

13

被覆盖了的父类方法可以通过super()函数在子类中调用.

Code Example :

>>> class NewSon(Parent):

def foo(self):

super(NewSon, self).foo()

>>> new_son = NewSon()

>>> new_son.foo()

Parent foo

1

2

3

4

5

6

7

8

注意：

子类覆盖父类的__init__()方法后，如果你想调用父类的此方法，你必须显示调用！Python默认不会帮我们做这件事。

(3)多重继承

方法解释顺序(MRO)

经典类采用的是深度优先算法(python2.2之前)，而新式类采用的是广度优先算法。因为在新式类中使用深度优先，会出现菱形效应。

假设我们有如下继承结构的类：

这里写图片描述

左边为经典类情况下，右边为新式类情况下。在新式类下B，C都继承自object类。

在新式类(右边继承结构)中采用旧的深度优先算法，假设在D的实例d中调用foo()方法，对于此方法的搜索顺序是D->B->A->C；采用广度优先算法，搜索顺序为D->B->C-A。因为D继承了B、C,多数情况下我们更希望首先搜索的是C而不是A，因为假设A、C中都有foo()方法时，你可能觉得A中的foo()方法太过通用了。很典型的就是__init__()方法。

(4)从标准类派生

比如你想从float类派生出一个子类，这都是很常见的需求。下面看两个例子：

继承float类

>>> class RoundFloat(float):

...     def __new__(cls, val):

...             return super(RoundFloat, cls).__new__(cls, round(val, 2))

...

>>> RoundFloat(1.5955)

1.6

1

2

3

4

5

6

我们派生了一个可以自动四舍五入到两位小数的RoundFloat类。

继承dict类

>>> class SortedKeyDict(dict):

...     def keys(self):

...             return sorted(super(SortedKeyDict, self).keys())

...

>>> dict1 = SortedKeyDict((('wang', 1), ('jiang', 2), ('guo', 3), ('han', 4)))

>>> dict1.keys()  # 排序了

['guo', 'han', 'jiang', 'wang']

>>> [key for key in dict1]  # 散列顺序

['guo', 'jiang', 'wang', 'han']

1

2

3

4

5

6

7

8

9

6. 特殊方法定制类

Python中有很多特殊方法，它们是以__开头和结尾的。使用它们可以实现：

模拟标准类型

重载操作符

1

2

3

4

5

6

7. 私有化

Python 为类元素(属性和方法)的私有性提供初步的形式。由双下划线开始的属性在运行时被“混淆”(mixin)，所以直接访问是不允许的。

混淆会在名字前面加下划线和类名。比如，以例NumStr类中的 self.__num 属性为例，被“混淆”后，用于访问这个数据值的标识就变成了self._NumStr__num。把类名加上后形成的新的“混淆”结果将可以防止在祖先类或子孙类中的同名冲突。

8. 包装和授权

(1)包装(wrapping)

定义：

对一个已存在的对象进行包装，不管它是数据类型，还是一段代码，可以是对一个已存在的对象，增加新的，删除不要的，或者修改其它已存在的功能。你可以包装任何类型作为一个类的核心成员，以使新对象的行为模仿你想要的数据类型中已存在的行为，并且去掉你不希望存在的行为。

包装类：

你可以包装类，但是实际上没有必要。因为你完全可以通过派生实现相同的效果。

(2)授权

简介：

授权是包装的一个特性，采用已存在的功能以达到最大限度的代码重用。包装一个类型通常是对已存在的类型的一些定制。授权的过程，即是所有更新的功能都是由新类的某部分来处理，但已存在的功能就授权给已存在的对象的默认属性。

实现授权：

实现授权的关键点就是覆盖__getattr__()方法，在代码中包含一个对 getattr()内建函数的调用。特别地，调用 getattr()以得到默认对象属性(数据属性或者方法)并返回它以便访问或调用。特殊方法__getattr__()的工作方式是， 当搜索一个属性时， 任何局部对象首先被找到 (定制的对象)。如果搜索失败了，则__getattr__()会被调用，然后调用 getattr()得到一个对象的默认行为。

我们来实现一个包装文件对象的例子：

>>> class UpperFile(object):

...     def __init__(self, fn, mode='r', buf=-1):

...             self.file = open(fn, mode, buf)

...     def __str__(self):

...             return str(self.file)

...     def __repr__(self):

...             return '%s' % self.file

...     def write(self, line):

...             self.file.write(line.upper())

...     def __getattr__(self, attr):

...             return getattr(self.file, attr)

...

>>> f = UpperFile(r'C:\test.txt', 'w')

>>> f.write('abcde')

>>> f.close()

>>> f

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

我们包装了open()函数返回的文件对象。改写了write()方法。当使用包装后的类实例化的对象调用write()方法时，使用的是修改的方法；当调用close()方法时，因为我们并没有改动此方法，则授权给原始文件对象，调用它的close()方法。

9. 新式类的高级特性

(1)工厂函数

在python中，所有的内建转换函数都是工厂函数。当这些函数被调用时，实际上是对相应的类型实例化。

类型测试：

使用

isinstance(obj, int)

1

也可以使用

isinstance(obj, (int, bool))

1

检测obj是否是int或者bool类型。

但要注意：尽管 isinstance()很灵活，但它没有执行“严格匹配”比较—-如果 obj 是一个给定类型的实例或其子类的实例，也会返回 True。但如果想进行严格匹配，你仍然需要使用 is 操作符:

type(obj) is int

1

(2)__slots__类属性

__dict__属性跟踪所有实例属性，以字典格式存储(属性名为key，属性值为value)。字典会占据大量内存，如果你有一个属性数量很少的类，但有很多实例，那么正好是这种情况。为内存上的考虑，用户现在可以使用__slots__属性来替代__dict__。

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

Code Example :

>>> class SlottedClass(object):

...     __slots__ = ('foo', 'bar')

...

>>> c = SlottedClass()

>>> c.foo = 12

>>> c.xx = 12

Traceback (most recent call last):

File "", line 1, in

AttributeError: 'SlottedClass' object has no attribute 'xx'

1

2

3

4

5

6

7

8

9

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

(3)特殊方法__getattribute__()

请注意，这个方法不是上面我们在授权中提到的__getattr__()方法。

当有属性被访问时，不管这个属性会不会被找到，__getattribute__()函数都会被调用。

如果类同时定义了__getattribute__()及__getattr__()方法,除非明确从__getattribute__()调用，或__getattribute__()引发了 AttributeError 异常,否则后者不会被调用。

如果你将要在__getattribute__()中访问这个类或其祖先类的属性，请务必小心。因为其实你是在__getattribute__()中调用__getattribute__()，你将会进入无穷递归。

(4)描述符

关于描述符，请移步这里：Python描述符

(5)元类：Metaclasses 和__metaclass__

在python中，类其实也是对象，它由元类创建。典型的应用场景是：ORM。这里不详细展开，你可以参见：

深刻理解Python中的元类(metaclass)

二，

Python中至少有三种比较常见的方法类型，即实例方法，类方法、静态方法。它们是如何定义的呢？如何调用的呢？它们又有何区别和作用呢？且看下文。

首先，这三种方法都定义在类中。下面我先简单说一下怎么定义和调用的。(PS：实例对象的权限最大。)

实例方法

定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法(也可以传类的属性和方法)；

调用：只能由实例对象调用。

类方法

定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法(不能传实例的属性和方法)；

调用：实例对象和类对象都可以调用。

静态方法

定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；

调用：实例对象和类对象都可以调用。

实例方法

简而言之，实例方法就是类的实例能够使用的方法。这里不做过多解释。

类方法

使用装饰器@classmethod。

原则上，类方法是将类本身作为对象进行操作的方法。假设有个方法，且这个方法在逻辑上采用类本身作为对象来调用更合理，那么这个方法就可以定义为类方法。另外，如果需要继承，也可以定义为类方法。

如下场景：

假设我有一个学生类和一个班级类，想要实现的功能为：

执行班级人数增加的操作、获得班级的总人数；

学生类继承自班级类，每实例化一个学生，班级人数都能增加；

最后，我想定义一些学生，获得班级中的总人数。

思考：这个问题用类方法做比较合适，为什么？因为我实例化的是学生，但是如果我从学生这一个实例中获得班级总人数，在逻辑上显然是不合理的。同时，如果想要获得班级总人数，如果生成一个班级的实例也是没有必要的。

classClassTest(object):

__num =0

@classmethod

defaddNum(cls):

cls.__num += 1@classmethod

defgetNum(cls):

return cls.__num

#这里我用到魔术方法__new__，主要是为了在创建实例的时候调用累加方法。

def __new__(self):

ClassTest.addNum()

return super(ClassTest, self).__new__(self)

classStudent(ClassTest):

def __init__(self):

self.name = ''a =Student()

b =Student()

print(ClassTest.getNum())

静态方法

使用装饰器@staticmethod。

静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。

譬如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数。

importtime

classTimeTest(object):

def __init__(self, hour, minute, second):

self.hour =hour

self.minute =minute

self.second =second

@staticmethod

defshowTime():

return time.strftime("%H:%M:%S", time.localtime())

print(TimeTest.showTime())

t = TimeTest(2, 10, 10)

nowTime =t.showTime()

print(nowTime)

如上，使用了静态方法(函数)，然而方法体中并没使用(也不能使用)类或实例的属性(或方法)。若要获得当前时间的字符串时，并不一定需要实例化对象，此时对于静态方法而言，所在类更像是一种名称空间。

其实，我们也可以在类外面写一个同样的函数来做这些事，但是这样做就打乱了逻辑关系，也会导致以后代码维护困难。

以上就是我对Python的实例方法，类方法和静态方法之间的区别和作用的简要阐述。