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

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

考察 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了：

原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i.

上述文字说明，在未调用函数时，循环中函数的值是未定的，函数的值仍在改变。而在调用时，i的值已经由于循环结束而确定为3

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()

r=f(i) 此步过程为调用函数，因此此时函数中变量的值已经确定，哪怕i的值在循环中改变，g（）的值也不会再改变

所以下面可以得到正确的结果1，4，9

以clac_sum为例，calc_sum(1st)虽然有输入值，但是输入值被储存，没有立刻被使用，并且calc_sum返回值为一个函数，该函数可以直接使用之前所储存的值

 f = calc_sum([1, 2, 3, 4])

这个过程实际上就是把f指向lazy_sum函数

再使用f()即可使用之前输入的值了

利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。.map() 不仅仅可以处理只包含数值的 list,只要f可处理，list里的数据类型可以任意。

获取类的信息：

1、首先可以用 type() 函数获取变量的类型，它返回一个 Type 对象。

2、可以用 dir() 函数获取变量的所有属性

3、dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，就需要用 getattr() 和 setattr( )函数了

>>> getattr(s, 'name')  # 获取name属性'Bob'

类变量全实例共享

count+=1只在声明类时运行一次

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

sorted 这个函数接受这3个关键词，key表示排序的元素，比如一个人的信息，可以从名字排序，可以从年龄排序，这就是排序元素，所以设置key的话，返回字符串就行了。

返回值1，-1是详细的对比规则，写在cmp里面。一般是大于为1，小于为-1，等于为0。

reverse 是排序规则，正序为true，逆序为false。

除了可以直接使用self.name = 'xxx'设置一个属性外，还可以通过 setattr(self, 'name', 'xxx') 设置属性

class是类

适配器模式

简单工厂模式

六大原则：

迪米特法则

开闭原则

单一职责原则

里氏替换原则

接口隔离原则

依赖倒置原则

当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到__future__中，要使用新版本的特性，需要导入__future__

try:

    导入模块

except 错误名:

    导入另一模块

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

import 模块名  直接导入模块

from 模块名 import 函数、变量、类名  只导入函数、变量、类

import 模块名 as 别名  给导入的模块起别名，防止不同模块导入相同名称的函数、变量、类时，引起冲突