一，
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: est.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)
如上，使用了静态方法（函数），然而方法体中并没使用（也不能使用）类或实例的属性（或方法）。若要获得当前时间的字符串时，并不一定需要实例化对象，此时对于静态方法而言，所在类更像是一种名称空间。
其实，我们也可以在类外面写一个同样的函数来做这些事，但是这样做就打乱了逻辑关系，也会导致以后代码维护困难。
以上就是我对Python的实例方法，类方法和静态方法之间的区别和作用的简要阐述。