多态：针对一个方法，不同对象调用产生不同结果，可灵活多变

注意，只有object类首字母才不是大写

实例对象除了是本身类的对象，也是继承的 父类的对象。可用isinstance(对象名，类名）来判断

class Foo(object):
def func(self):
pass
#实例化
obj = Foo()
# 执行方式一:调用的func是方法
obj.func() #func 方法
# 执行方式二：调用的func是函数
Foo.func(123) # 函数

1. 实例方法也是属性(可用dir(xxx)查询所有属性进行验证），也是对象，不加（）调用时是对象，加（）为方法调用

    2.types.MethodType() 把一个函数变为一个方法：

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

import time
def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kw):
            t1 = time.time()
          
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
            print 'call %s() in %f %s' % (f.__name__, t, unit)
            return f(*args, **kw)
        return wrapper
    return perf_decorator
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

装饰器的理解

class Fib(object):

    def __init__(self, num):

        a, b, L = 0, 1, []

        for n in range(num):

            L.append(a)

            a, b = b, a + b

        self.num = L

    def __str__(self):

        return str(self.num)

    def __len__(self):

        return len(self.num)

f = Fib(10)

print f

print len(f)

下一步学习：

IO:文件和Socket

多任务：进程和线程

数据库

Web开发

python中 __call__

在Python中，函数其实是一个对象：

>>> f = abs >>> f.__name__ 'abs' >>> f(-123) 123

由于 f 可以被调用，所以，f 被称为可调用对象。

所有的函数都是可调用对象。

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

我们把 Person 类变成一个可调用对象：

class Person(object):     def __init__(self, name, gender):         self.name = name         self.gender = gender     def __call__(self, friend):         print 'My name is %s...' % self.name         print 'My friend is %s...' % friend

现在可以对 Person 实例直接调用：

>>> p = Person('Bob', 'male') >>> p('Tim') My name is Bob... My friend is Tim...

单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。

任务

假设Person类通过__slots__定义了name和gender，请在派生类Student中通过__slots__继续添加score的定义，使Student类可以实现name、gender和score 3个属性。

• ?不会了怎么办

• Student类的__slots__只需要包含Person类不包含的score属性即可。

  参考代码:

  class Person(object):
      __slots__ = ('name', 'gender')
      def __init__(self, name, gender):
          self.name = name
          self.gender = gender
  
  class Student(Person):
      __slots__ = ('score',)
      def __init__(self, name, gender, score):
          super(Student, self).__init__(name, gender)
          self.score = score
  
  s = Student('Bob', 'male', 59)
  s.name = 'Tim'
  s.score = 99
  print s.score

python中 __slots__

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

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

顾名思义，__slots__是指一个类允许的属性列表：

class Student(object):     __slots__ = ('name', 'gender', 'score')     def __init__(self, name, gender, score):         self.name = name         self.gender = gender         self.score = score

现在，对实例进行操作：

>>> s = Student('Bob', 'male', 59) >>> s.name = 'Tim' # OK >>> s.score = 99 # OK >>> s.grade = 'A' Traceback (most recent call last):   ... AttributeError: 'Student' object has no attribute 'grade'

__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存。

class Student(object):

    def __init__(self, name, score):

        self.name = name

        self.__score = score

    @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

    @property

    def grade(self):

        if self.score < 60:

            return 'C'

        if self.score < 80:

            return 'B'

        return 'A'

s = Student('Bob', 59)

print s.grade

s.score = 60

print s.grade

s.score = 99

print s.grade

python中 @property

考察 Student 类：

class Student(object):     def __init__(self, name, score):         self.name = name         self.score = score

当我们想要修改一个 Student 的 scroe 属性时，可以这么写：

s = Student('Bob', 59) s.score = 60

但是也可以这么写：

s.score = 1000

显然，直接给属性赋值无法检查分数的有效性。

如果利用两个方法：

class Student(object):     def __init__(self, name, score):         self.name = name         self.__score = score     def get_score(self):         return self.__score     def set_score(self, score):         if score < 0 or score > 100:             raise ValueError('invalid score')         self.__score = score

这样一来，s.set_score(1000) 就会报错。

这种使用 get/set 方法来封装对一个属性的访问在许多面向对象编程的语言中都很常见。

但是写 s.get_score() 和 s.set_score() 没有直接写 s.score 来得直接。

有没有两全其美的方法？----有。

因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：

class Student(object):     def __init__(self, name, score):         self.name = name         self.__score = score     @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装饰后的副产品。

现在，就可以像使用属性一样设置score了：

>>> s = Student('Bob', 59) >>> s.score = 60 >>> print s.score 60 >>> s.score = 1000 Traceback (most recent call last):   ... ValueError: invalid score

说明对 score 赋值实际调用的是 set方法。

python中类型转换

Rational类实现了有理数运算，但是，如果要把结果转为 int 或 float 怎么办？

考察整数和浮点数的转换：

>>> int(12.34) 12 >>> float(12) 12.0

如果要把 Rational 转为 int，应该使用：

r = Rational(12, 5) n = int(r)

要让int()函数正常工作，只需要实现特殊方法__int__():

class Rational(object):     def __init__(self, p, q):         self.p = p         self.q = q     def __int__(self):         return self.p // self.q

结果如下：

>>> print int(Rational(7, 2)) 3 >>> print int(Rational(1, 3)) 0

同理，要让float()函数正常工作，只需要实现特殊方法__float__()。

任务

请继续完善Rational，使之可以转型为float。

• ?不会了怎么办

• 将self.p转型为float类型，再作除法就可以得到float：

  float(self.p) / self.q

  参考代码:

  class Rational(object):     def __init__(self, p, q):         self.p = p         self.q = q     def __int__(self):         return self.p // self.q     def __float__(self):         return float(self.p) / self.q print float(Rational(7, 2)) print float(Rational(1, 3))