def gcd(a,b):

        if a%b == 0:

            return b

        else:

            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):

        c = gcd(self.p,self.q)

        return '%s/%s' % (self.p/c,self.q/c)

    __repr__ = __str__

r1 = Rational(1, 2)

r2 = Rational(1, 4)

print r1 + r2

print r1 - r2

print r1 * r2

print r1 / r2

class Fib(object):

    def __init__(self, num):

        self.num = num

        self.fibo = [0,1]

        i = 2

        while i < self.num:

            self.fibo.append(self.fibo[i-2] + self.fibo[i-1])

            i = i + 1

    def __str__(self):

        return str(self.fibo)

    def __len__(self):

        return len(self.fibo)

f = Fib(10)

print f

print len(f)

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

print filter(lambda x: x[0]!='_', dir(p))

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

举个例子，Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服务器运行模式有 多进程ForkingMixin 和 多线程ThreadingMixin两种。

import json

class Students(object):

    def __init__(self,str):

        self.str = str

    def read(self):

        return self.str

s = Students('["Tim", "Bob", "Alice"]')

print json.load(s)

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

由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可

一定要用 super(Student, self).__init__(name, gender) 去初始化父类，否则，继承自 Person 的 Student 将没有 name 和 gender。

函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。

通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count

filter()函数中有两个参数，第一个参数应该是bool类型，s if len(s.strip())>0这样返回的是一个s，不是bool类型。

p1.get_grade = types.MethodType(fn_get_grade, p1, Person)

class Person(object):

    __count = 0

    def __init__(self, name):

        self.name = name

        Person.__count += 1

        print Person.__count

p1 = Person('Bob')

p2 = Person('Alice')

try:

    print Person.__count

except AttributeError:

    print 'attributeerror'

当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

class Person(object):

    pass

p1 = Person()

p1.name = 'Bart'

p2 = Person()

p2.name = 'Adam'

p3 = Person()

p3.name = 'Lisa'

L1 = [p1, p2, p3]

L2 = sorted(L1,key=lambda x:x.name)

print L2[0].name

print L2[1].name

print L2[2].name

import os

import os.path as p

print p.isdir(r'F:\SoftWare')

print p.isfile(r'F:\test.txt')

sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

3.版本：

sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])

参数说明：

• iterable -- 可迭代对象。

• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

返回重新排序的列表。