转：Python3 面向对象，较为深入的两个理解-CSDN博客

一，

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': <function change at 0x02A9A930>}

    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
<open file 'C:\\test.txt', mode 'w' at 0x029F1D88>

    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 "<stdin>", line 1, in <module>
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 实例方法、类方法、静态方法的区别与作用

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

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

实例方法

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

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

类方法

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

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

静态方法

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

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

实例方法

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

类方法

使用装饰器@classmethod。

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

如下场景：

假设我有一个学生类和一个班级类，想要实现的功能为：
执行班级人数增加的操作、获得班级的总人数；
学生类继承自班级类，每实例化一个学生，班级人数都能增加；
最后，我想定义一些学生，获得班级中的总人数。

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

class ClassTest(object):
    __num = 0

    @classmethod
    def addNum(cls): cls.__num += 1 @classmethod def getNum(cls): return cls.__num # 这里我用到魔术方法__new__，主要是为了在创建实例的时候调用累加方法。 def __new__(self): ClassTest.addNum() return super(ClassTest, self).__new__(self) class Student(ClassTest): def __init__(self): self.name = '' a = Student() b = Student() print(ClassTest.getNum())

静态方法

使用装饰器@staticmethod。

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

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

import time

class TimeTest(object):
    def __init__(self, hour, minute, second): self.hour = hour self.minute = minute self.second = second @staticmethod def showTime(): return time.strftime("%H:%M:%S", time.localtime()) print(TimeTest.showTime()) t = TimeTest(2, 10, 10) nowTime = t.showTime() print(nowTime)