__call__（self,friend）其实就是实现实力对象能够像函数一样调用，此例中我们实例了一个对象，p，由于class类中，定义了__call__函数，所以之后可以像调用函数一样来调用实例对象p

动态语言的多态和静态语言c++等多态含义不太一样，c++中的多态就是参数数量和类型不同的方法就是不同方法，而动态语言中的多态其实值的是方法的寻找过程，即向右找到类（或者单件类），在类中找不到的话再找父类，一直在祖先链中找到或者找不到为止，先找到的就被调用：

Python的新版本会引入新的功能，但是，实际上这些功能在上一个老版本中就已经存在了。要“试用”某一新的特性，就可以通过导入__future__模块的某些功能来实现。

Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：

>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3

要在Python 2.7中引入3.x的除法规则，导入__future__的division：

>>> from __future__ import division
>>> print 10 / 3
3.3333333333333335

当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到__future__中，以便旧的代码能在旧版本中测试新特性

在Python 3.x中，字符串统一为unicode，不需要加前缀 u，而以字节存储的str则必须加前缀 b。利用__future__的unicode_literals在Python 2.7中编写unicode字符串。

• 使用from __future__ import unicode_literals将把Python 3.x的unicode规则带入Python 2.7中。

  参考代码:

  from __future__ import unicode_literals
  s = 'am I an unicode?'
  print isinstance(s, unicode)

利用ImportError错误，我们经常在Python中动态导入模块：

try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO

上述代码先尝试从cStringIO导入，如果失败了（比如cStringIO没有被安装），再尝试从StringIO导入。这样，如果cStringIO模块存在，则我们将获得更快的运行速度，如果cStringIO不存在，则顶多代码运行速度会变慢，但不会影响代码的正常执行。

try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句。

from math import pow, sin, log

这样，可以直接引用 pow, sin, log 这3个函数，但math的其他函数没有导入进来

>>> pow(2, 10)
1024.0
>>> sin(3.14)
0.0015926529164868282

如果使用import导入模块名，由于必须通过模块名引用函数名，因此不存在冲突：

import math, logging
print math.log(10)   # 调用的是math的log函数logging.log(10, 'something')   # 调用的是logging的log函数

如果使用 from...import 导入 log 函数，势必引起冲突。这时，可以给函数起个“别名”来避免冲突：

from math import log
from logging import log as logger   # logging的log现在变成了loggerprint log(10)   # 调用的是math的log
logger(10, 'import from logging')   # 调用的是logging的log

包下面必须有init.py文件加以区别目录

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

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

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

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

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

read(t)//记得这里传入参数

方法也是一个属性,可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法：p1.get_grade()=types.MethodType(fn_get_grade,p1,Preson) 

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
        self.get_grade = lambda: 'A'

p1 = Person('Bob', 90)
print p1.get_grade
print p1.get_grade()

直接把 lambda 函数赋值给 self.get_grade 和绑定方法有所不同，函数调用不需要传入 self，但是方法调用需要传入 self。

绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

类的属性也可动态添加或修改

以双下划线开头的属性无法被外部访问，"__xxx__"除外。

class Person(object):
    def __init__(self,name,gender,birth,**kw):
        self.name = name
        self.gender = gender
        self.birth = birth
        for k, v in kw.iteritems():
            setattr(self, k, v)
xiaoming = Person('Xiao Ming', 'Male', '1990-1-1', job='Student')
print xiaoming.name
print xiaoming.job

输出为 Xiao Ming
      Student
定义关键字参数用 **kw

类属性和实例属性名字冲突时

可见，当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。可见，千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。

请把上节的 Person 类属性 count 改为 __count，再试试能否从实例和类访问该属性。

• ?不会了怎么办

• 把count改为私有__count，这样实例变量在外部无法修改__count

前面的1和2输出分别是Person在创建Bob和Alice对象的时候调用了__init__方法里面的print 输出的，当创建完对象，调用最下面的那个print时，由于这个print是在外部，所以无法调用内部私有的__count，所以报错