方法
类方法@classmethod,实例方法,静态方法@staticmethod,特殊方法，__init__
形式上的区别：调用是通过类和实例进行，不能直接调用，有自己的特殊参数，如__init__有self,类方法有参数class，有自己的声明方式。
实质上的区别：类方法与类绑定，实例方法绑定实例，静态方法无绑定（和函数一样，只不过用类和实例进行调用），特殊方法某些场景会自动调用。
特殊方法
数字计算：加减乘除都是通过特殊方法来实现的，round是四舍五入。
调用方法：str()转化成字符串，len()长度，bool判断真假。
比较大小：lt是less than,le是less equal，gt是great than，ge是great equal，ne是not equal。
集合访问：setslice,getslice是切片操作，getitem，setitem是字典的item访问，contains是包含（就是if a in b）的时候用。
迭代器，属性访问，类生产，前面有说过了。
class Point(object):
def __init__(self,x,y):
self.x = float(x)
self.y = float(y)
def __sub__(self, other):
assert isinstance(other,Point)
return Point(self.x-other.x,self.y-other.y)
def __add__(self, other):
assert isinstance(other,Point)
return Point(self.x+other.x,self.y+other.y)
def __mul__(self,factor):
return Point(self.x*factor, self.y*factor)
def __div__(self,factor):
return Point(self.x/factor, self.y/factor) @property
def xy(self):
return (self.x,self.y) def __str__(self):
return "x={0},y={1}".format(self.x,self.y)
def __repr__(self):
return str(self.xy) if __name__ == '__main__': a = Point(50,60)
b = Point(30,40) print a-b
print a+b
print a*2
print a/2
a
Out[5]: (50.0, 60.0) print a
x=50.0,y=60.0
这里重载了加减乘除。python中运算符重载很方便，只要你重新写一下特殊方法。
__str__是当你调用print的时候他会自动调用__str__。
__repr__是给计算机看的，比如你输入a 他应该输出地址什么的，但是因为这里重写了repr所以他会输出我们想要的（self.x,self.y)。
继承
通过已有的类，生产新的类，新的类具有父类的属性和方法，实现代码的重用。
单一继承比较简单，就是直接继承属性和方法。
继承顺序
MRO method resolution order 方法的解析顺序。
继承顺序，经典类是深度优先，新式类是C3算法。
经典类A是优先于C的，新式类C优先于A。
class A:
a=1
b=1 class B(A):
a=2 class C(A):
a=3
b=3
c=3 class D(B,C):
pass if __name__=="__main__":
d=D()
import inspect inspect.getmro(D)
Out[15]:
(<class __main__.D at 0x07A14148>,
<class __main__.B at 0x07A140D8>,
<class __main__.A at 0x07A140A0>,
<class __main__.C at 0x07A14110>)
d.a
Out[17]: 2 d.b
Out[18]: 1 d.c
Out[19]: 3
d的a属性继承自B，b属性继承自A，c属性继承自C，如果A中已经定义了c，则C对于c属性的重写则永远都不会访问到。新式类曾经有一段时间使用深度优先，这样解决了无法访问重写的问题，但是他违背了查找的顺序性。
新式类：
class A(object):
a=1
b=1
#只要修改A（object）就好了,其他不变。
inspect.getmro(D)
Out[22]: (__main__.D, __main__.B, __main__.C, __main__.A, object)
print d.a,d.b,d.c
2 3 3
这里a属性继承自B，bc属性继承自C。并且新式类D中有mro的特殊方法，经典类没有。
D.__mro__
Out[26]: (__main__.D, __main__.B, __main__.C, __main__.A, object)
C3算法，用的是一个拓扑排序并且为了顺序性，拓扑排序的时候出现两个入度为0则取左边的。可以参考http://python.jobbole.com/85685/。
方法调用
class A:
def test(self):
print "A's test" class B(A):
def test(self):
print "B's test"
A.test(self)
class C(A):
def test(self):
print "C's test"
A.test(self) class D(B,C):
def test(self):
print "D's test"
B.test(self)
C.test(self) if __name__=="__main__":
a=D()
a.test()
D's test
B's test
A's test
C's test
A's test
为了避免父类函数被重复调用，所以有了Super。
Super是一个类，不是函数。Super只在新式类里有。super(instance,self)。
class A(object):
def test(self):
print "A's test" class B(A):
def test(self):
print "B's test"
super(B,self).test() class C(A):
def test(self):
print "C's test"
super(C,self).test() class D(B,C):
def test(self):
print "D's test"
super(D,self).test() if __name__=="__main__":
a=D()
a.test()
D's test
B's test
C's test
A's test
#只出现一次，广度优先。
多态
多态是不同类的相同方法，相同参数，不同的功能。不同的参数是重载（args,kwargs)。
Python中并不需要像java那样写好接口，规定什么属性，python是一种动态语言，参数在传入之前是无法确定参数类型的。所以python会假设存在，然后直接调用，如果没有就会报错。可以参考http://blog.csdn.net/shangzhihaohao/article/details/7065675。
Python是动态强类型语言。