因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法：

import types
...
p1 = Person('Bob', 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)

实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身。

在实例方法内部，可以访问所有实例属性

#更相减损法

def gcd(a, b):

 while a!=b :

        if a>b :  

            a-=b

    else :          

        b-=a

return a

#辗转相除法

def gcd(a, b):

    if b == 0:

        return a

    return gcd(b, a % b)

__call__相当于把()做了标识符重载，在使用类初始化对象的时候，调用类中的__init__方法，而程序中使用对象()的时候，调用类中的__call__方法，使得对象本身成为了函数。__new__： 对象的创建，是一个静态方法，第一个参数是cls。(想想也是，不可能是self，对象还没创建，哪来的self)
__init__ ： 对象的初始化， 是一个实例方法，第一个参数是self。
__call__ ： 对象可call，注意不是类，是对象。

由于Python是动态语言，任何实例在运行期都可以动态地添加属性。

如果要限制添加的属性，例如，Student类只允许添加 name、gender和score 这3个属性，就可以利用Python的一个特殊的__slots__来实现。

用了@property以后 为什么原来的方法不能用了

原来的s.get_score 为什么不能正常使用了？

首先要清楚,你的get_score 是一个实例方法, 所以调用实例方法应该 s.get_score() 

想 s.get_score  调用方法的话, 可以用property 装饰器,进行装饰,就可以用了.

这也是 ,属性和方法的区别, 属性 直接 s.score   调用,  而方法需要 s.get_score() 来进行调用哦,

类型转换：

    除法：

        1. 地板除法：用//表示，不管操作数为何种数值类型，总是会舍去小数部分，返回数字序列中比真正的商小的最接近的数字。比如 1//2 = 0, 1.0//2= 0。

2. 传统除法：用/表示，对整数之间的/，执行地板除，但对有浮点数参与的除法则执行传统意义上的除法。比如 1/2 = 0, 1.0/2=0.5。

3. 精确除法：如果你想让上面的传统除法，更"传统"，你就应该调用 from __future__ import division，这样以后/就真的变成传统意义上的传统除法了。比如，1/2=0.5, 1.0/2=0.5。

4. 注意以上讲的是针对Python 2.6+版本的，对于Python 3+，传统除法被废除了，也就是说只有地板除和精确除法，分别用//和/表示，且不用调用 from __future__ import division。

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __sub__(self, r):
        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)
    def __mul__(self, r):
        return Rational(self.p * r.p, self.q * r.q)
    #def __div__(self, r):
    #    return Rational(self.p * r.q, self.q * r.p)
    def __str__(self):
        g = gcd(self.p, self.q)
        return '%s/%s' % (self.p / g, self.q / g)
    def __truediv__(self,r):
        return Rational(self.p * r.q, self.q * r.p)

    __repr__ = __str__

r1 = Rational(1, 2)
r2 = Rational(1, 4)
print(r1 + r2)
print(r1 - r2)
print(r1 * r2)
print(r1 / r2)

python3中要用“/”要自定义__turediv__（a,b）用“//”要定义__floordiv__（a,b）方法

class Fib(object):
    __result_list = []
    def __init__(self, num):
        self.num = num
        self.fib(self.num)
    def fib(self,n):
        a ,b = 0 , 1
        while( n>0):
            self.__result_list.append(a)
            a , b = b,a+b
            n -= 1
    def __str__(self):
        return str(self.__result_list)
    def __len__(self):
        return len(self.__result_list)
f = Fib(10)
print f
print len(f)

S是这个实例的参数，当你创建这个实例的时候，def __cmp__(self, s):  表示你在调用对应方法的时候需要填写一个叫S 的参数

_cmp__是一种特殊方法 利用这个，对所需内容进行排序。例如此题。是对学生成绩先按照成绩排序由高到低，如果成绩相同就按照姓名首字母顺序进行排序。 其中要注意的是最后一行的‘-’号 。因为cmp是由低到高，加上-号就由高到底了

__str__()用于显示给用户，而__repr__()用于显示给开发人员。如果在交互式命令行下 直接敲变量 s 就会返回<main.Person object at XXX> 这样的东西如果你配置了__repr__ = __str__你交互式命令行下打print s 和 直接敲变量 s 的返回值是一样的 都是(Student: Bob,male,88)...

即写了这句话：__repr__=__str__这个在CMD窗口直接敲 函数名  不需要敲print 函数名 也可以打印出来，

class Person(object):
    def __init__(self, name, gender, **kw):
        self.name = name
        self.gender = gender
        for k, v in kw.iteritems():
            setattr(self, k, v)

p = Person('Bob', 'Male', age=18, course='Python')
print p.age
print p.course

python 中的多重继承

一个子类可以有多个父类，同时具有所继承的父类的功能

例如：A->B-D    A->C-D   类D同时继承了B 和C

D 同时继承自 B 和 C，也就是 D 拥有了 A、B、C 的全部功能。多重继承通过 super()调用__init__()方法时，A 虽然被继承了两次，但__init__()只调用一次：

多重继承的目的是从两种继承树种分别选择并继承出子类，以便功能的组合使用

这种行为称为多态。也就是说，方法调用将作用在 x 的实际类型上。s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。

class Book(object):
    def whoAmI(self):
        return 'I am a book'

这是动态语言和静态语言（例如Java）最大的差别之一。动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course

t = Teacher('Alice', 'Female', 'English')

print isinstance(t, Person)
print isinstance(t, Student)
print isinstance(t, Teacher)
print isinstance(t, object)