类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return 'I am a Person, my name is %s' % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def whoAmI(self):
        return 'I am a Teacher, my name is %s' % self.name

在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：

def who_am_i(x):
    print x.whoAmI()

p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')

who_am_i(p)
who_am_i(s)
who_am_i(t)

运行结果：

I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice

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

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

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

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

函数isinstance()可以判断一个变量的类型，既可以用在Python内置的数据类型如str、list、dict，也可以用在我们自定义的类，它们本质上都是数据类型。

>>> isinstance(s, Person)
True    # s是Person类型>>> isinstance(s, Student)
True    # s是Student类型>>> isinstance(s, Teacher)
False   # s不是Teacher类型

python中继承一个类

如果已经定义了Person类，需要定义新的Student和Teacher类时，可以直接从Person类继承：

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

定义Student类时，只需要把额外的属性加上，例如score：

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

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

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

**是关键字参数，**ab,**mp....类似dic,Map

for k,v in xx.items() 用于遍历

由于Python的动态特性，json.load()并不一定要从一个File对象读取内容。任何对象，只要有read()方法，就称为File-like Object，都可以传给json.load()。

Python中的@property

1: get、set方法是用来干什么用的？对类中的属性进行获取与赋值，并在赋值是做一些限制。

2：get、set方法用什么弊端？访问起来不如直接访问属性方便。s.score与s.getScore比较。

3：用@property来解决2中提到的弊端。

 @property
    def score(self):
        return self.__score
    @score.setter
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score

第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品。

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

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

Python中的数据类型转换

1：float转换为int--> int(1.23) = 1

2:  int转换为float--> float(1) = 1.0

3: 一个int类型的数和float类型的数运算后得到的结果是个float类型的数

Python中的数学运算

1：取两个数的最大公约数

def gcd(a, b):

    if b == 0:

        return a

    return gcd(b,a % b)

2：两个整数的商一定是有理数

Python中__cmp__()函数

Python中有内置的比较函数__cmp__()，但是在对一组类进行排序时，需要对函数进行重写，提过出特殊的方法

调用sorted（）函数时会调用特殊方法__cmp__()，按照默认的cmp比较函数排序

Python 的__cmp__() 方法

1：在比较方法内有<和>两个比较符号，只要是返回-1的，就满足比较符号前边的排在前边，后边的排在后边，而返回1的，就满足比较符号前边的排在后边。

Python的__str__()与__repr__()

1:__str__() 用于显示给用户；__repr__() 用于显示给开发人员。这两个是关联的，实现其中一个必须实现另一个。

Python的特殊方法

1：特殊方法定义在class中

2：不需要直接调用，Python中的一些函数或者操作符会调用到特殊方法。

3：只需定义用到的特殊方法。

4：有关联性的特殊方法若实现了其中一个就必须全部实现（如getattr、setattr、deletattr）

capitalize() 首字母大写，其余全部小写

upper() 全转换成大写

lower() 全转换成小写

title()  标题首字大写，如"i love python".title()  "I love python"