#Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。

#先导入 time 库
import time

#创建一个函数，用来打印出当前函数调用的时间
def performance(f):
    #再创建一个函数，计算函数调用前后的时间戳，计算时间戳到时间差
    #新函数 fn(*args,**kw) 里面的两个参数是用来保证任意个数的参数都能被正常调用
    def fn(*args,**kw):
        #首次获取当前计算机的时间戳
        t1 = time.time()
        #给 函数 fn（*args,**kw)的两个参数赋值
        r = f(*args,**kw)
        #第二次获取时间戳
        t2 = time.time()
        #打印 call performance() in 当前日期的时间
        #第一个中括号 {} 里面是 f.__name__，它用参数来格式化当前函数的名字
        #第二个中括号 {} 里面是 (t2 -t1) ，用第二次获取的时间减去第一次获取的时间
        print("call {}() in {}".format(f.__name__,(t2 - t1)))
        #将计算结果返回 r 变量
        return r
    #将本函数的计算方法存储起来，返回 fn() 函数，等到调用的时候再直接调用 factorial()函数就可以了
    return fn
    
#可以避免手动编写 f = decorate(f)，简化代码
@performance
#创建一个函数，因为 @performance 的语法，可以将 performance()函数的 r 返回值调用，然后进行计算
def factorial(n):
    #利用 lambda 表达式 调用 reduce()函数计算参数 x 和 y 的乘积，x 和 y 的值是 range()函数里的赋值
    return reduce(lambda x,y : x * y,range(1,n + 1))
#直接调用 factorial()函数，赋值 n 为 10，并打印计算结果    
print(factorial(10))

"""
本例题的用意在于将一个函数闭包，再嵌套在另一个函数里调用，也就是说，可以将函数调用的方法隐藏起来
"""

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

map(函数名，[列表])

upper()返回小写字母转为大写字母的字符串。

lower()返回大写字母转为小写字母的字符串。

函数运用s[0].upper() + s[1:].lower()运用切片可以指定位置

reduce(function, iterable, initializer)  
function -- 函数f，有两个参数
iterable -- 可以迭代的对象，这里是列表lst
initializer -- 可有可无，若有：从此值开始计算

f最后返回列表中数的相乘后的结果。

这章没看懂，需要再学习

3.0以上map返回的对象不再是list，所以要做强制转换

在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数,其他代码不变,只多了一行引用

from functools import reduce
def calc_prod(lst):
    def lazy_prod():
        def f(x, y):
            return x * y
        return reduce(f, lst, 1)
    return lazy_prod
f = calc_prod([1, 2, 3, 4])
print (f())

1、__name__这个系统变量显示了当前模块执行过程中的名称，如果当前程序运行在这个模块中，__name__ 的名称就是__main__如果不是，则为这个模块的名称。 

2、__main__一般作为函数的入口，类似于C语言，尤其在大型工程中，常常有if __name__ == "__main__":来表明整个工程开始运行的入口。

--------------------- 

作者：IAMoldpan 

来源：CSDN 

原文：https://blog.csdn.net/iamoldpan/article/details/78077983 

版权声明：本文为博主原创文章，转载请附上博文链接！

加个负号作用就是从大到小排序。

def count():#定义一个计算函数

    fs = []#创建一个空的列表

    for i in range(1, 4):#循环条件i从1到三

        def f():#本来想创建一个闭包的错误函数

             return i*i#返回值是i的平方

        fs.append(f)#往空列表依次增加刚刚定义的函数

    return fs#返回空的列表

 

f1, f2, f3 = count()#依次把count里面的三个函数赋给f1, f2, f3

print f1(),f2().f3()#之所以三个函数的返回值均为9是因为f1（）的调用时基于i等于3，故产生了错误的值。

 

 

 

 

 

def count():

    fs = []

    for i in range(1, 4):#以下是正确的闭包

        def f(j):#定义函数f(j)  j为形参

            def g():#定义函数g

                return j*j#返回值为j的平方

            return g   #返回值为函数g

           

           

        fs.append(f(i))#每i变化一次都往里面list里面放入一个函数g，且里面的形参至关重要为外函数的i，故每次调用f1()不会因为i已经变为三而出错

    return fs

 

f1, f2, f3 = count()

print f1(),f2(), f3()

另外应该需要注意fs.append(f())与fs.append(f)的区别

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句。

导入模块：

from<模块名>import<函数名>as<别名>；——用于函数名重复，但需要在同一个代码中调用时

from<模块名>import <函数名>；——用于函数名有重复的时候

import<函数名>；——用于函数名唯一的时候

【StringIO模块要比cStringIO运行速度慢！】

【模块__future__的某些功能可以将新版的python中的功能导入旧版使用】

1. python面向对象编程：

   (1)创建类：

    class Person(object): #(object)表示该类是从哪个类继承下来的，类名以大写字母开头
   

       example....

   (3)创建实例：

   xiaoMing=Person()

2. 创建实例属性

   实例被创建后，可以直接添加属性，并给其属性赋值：xiaoMing.name='小明'

3. 初始化实例属性：创建类时，添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上多个属性

   示例：

   

4. python访问限制：Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问；如果一个属性以"__xxx__"的形式定义，那它又可以被外部访问了，以"__xxx__"定义的属性在Python的类中被称为特殊属性，通常我们不使用；以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问

5. 创建类属性：使例属性每个实例各自拥有，互相独立，而类属性有且只有一份。因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问。对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性。由于Python是动态语言，类属性也是可以动态添加和修改的

   示例：

   

6. 类属性名与实例属性名冲突：当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

7. 定义实例方法：实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的

   调用实例方法必须在实例上调用,在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度

   示例：

   
   

8. python中方法也是属性：在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象。因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法

   示例：

   

   
   

9. 定义类方法：类中的方法分为实例方法和类方法：在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。要在class中定义类方法，需要通过标记一个 @classmethod，将方法将绑定到 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls

10. 
    

1.decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效 2.要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中 Python内置的functools可以用来自动化完成这个“复制”的任务 3. >>> import functools import functools def log(f): @functools.wraps(f) #这行代码本身也是一个装饰器，它表示了将原函数原始参数信息复制到wrapper中去 def wrapper(*args, **kw): print 'call...' return f(*args, **kw) return wrapper

# 基础知识回顾

变量和数据类型：Python 内置的基本类型（整数、浮点数、字符串、布尔值、空值）

List 和 Tuple：顺序的集合类型

条件判断和循环：控制程序流程

Dict 和 Set：根据 key 访问的集合类型

函数：定义和调用函数

切片：如何对 list 进行切片

迭代：如何用 for 循环迭代集合类型

列表生成式：如何快速生成列表

# 将要学习的内容

1. 函数式编程

2. 模块

3. 面向对象编程：面向对象的概念、属性、方法、继承、多态等

4. 定制类：利用 Python 的特殊方法定制类

# 学习目标

1. 掌握函数式编程

2. 掌握面向对象编程

3. 能够编写模块化的程序

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