当待排序列表的元素由多字段构成时，我们可以通过sorte参数key来制定我们根据那个字段对列表元素进行排序。 
　　key=lambda 元素: 元素[字段索引] 
　　例如：想对元素第二个字段排序，则 
           　　key=lambda x: x[1]  

也就是整个可以改为print(sorted(['bob','about', 'Zoo', 'Credit'], key = lambda x: x.upper()))

import math

print(filter(lambda x : math.sqrt(x)%1==0, range(1,101)))

python3里边 map()和filter()输出都是一个可以迭代的对象，不是一个List，如果要print出来就必须强行变成list()

python3里边没有reduce（），调用需要在前边先引入functools模块

#from functools import reduce

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中，函数也是对象，对象和函数的区别并不显著。函数也可以看作为一个对象，对象创建的时候就会调用__call__方法，就是这个时候传进去的friend不是类的属性 所以不会有self.friend=friend

对于对象而言  最重要的是属性和方法  属性区分开对象  而方法也可以看成是属性的一种调用函数时你是知道调用函数用来干什么 而调用对象你要指出让这个对象干什么  也就是调用方法可以说函数就是一种方法  只是不从属于对象本节的调用对象实际上是通过call特殊函数包装  看起来像是调用对象  实际上还是调用对象的方法只是这个方法比较特殊

python中 __slots__

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

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

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

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

任务

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

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

  参考代码:

  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):
  
          self.score = score
  
  s = Student('Bob', 'male', 59)
  s.name = 'Tim'
  s.score = 99
  print s.score

为什么设置两个装饰器名称？

property是“属性”的意思，@property就是把实例方法当做属性调用的语法。set是“设置”的意思，setter就是“设置器”。@score.setter就是给这个类下的score属性重新设定值的时候，调用这个方法。

按实际的用法，如果一个语句是s.score，就是要获取属性，所以python会直接找@property这个装饰器下面有没有score这个方法，有就直接调用了。如果另一个语句是s.score = 99，这就是要设置属性，python就会去找@score.setter这个装饰器，并运行下面的方法。

@property就是把实例方法当做属性调用的语法,你看下面是直接print s.grade，相当于调用了grade这个属性，所以用@property

把方法装饰成属性，然后在调用的时候，用当作属性直接调用

装饰器：

不用装饰器调用set、get方法需要对象.方法名，用了装饰器可以直接对象.属性名直接调用属性

任务

如果没有定义set方法，就不能对“属性”赋值，这时，就可以创建一个只读“属性”。

请给Student类加一个grade属性，根据 score 计算 A（>=80）、B、C（<60）。

• 用 @property 修饰 grade 的 get 方法即可实现只读属性。

  参考代码:

  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
        
    def score(self):
        return self.__score
    
    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))

def cmp(x1,x2):

    if(x1 ? x2):

        return -1 sorted中的-1表示 x1 应该排在 x2 前边

    if(x1 ? x2):

        return 1 sorted中的1表示 x1 应该排在 x2 后边

闭包:像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。