Python 3 学习——函数扩展and迭代器生成器装饰器

Python 学习的第九小节

 写此博客 是为了激励自己，并且将自己的心得以及遇到的问题与人分享

一、学习笔记

　　1. 高阶函数

　　　　函数名可以作为函数参数输入 、可以进行赋值、还可以作为返回值。

　　2.作用域

　　　　在Python中，只有模块、类以及函数才会引入新的作用域，其它的代码块（if  try  for）是不会引入新的作用域。

　　3.递归函数

　　关于阶层的递归函数：

def fact(n):
    if n ==1 :
        return 1
    return n * fact(n-1)

print(fact(2))

　　特点：1.调用自身函数　　2.有一个结束条件　　3.每进入更深一层递归时，问题规模相比上次要有所减少。

　　但凡是递归可以写的程序，循环都可以解决。递归的效率在一定情况下非常低。

　　4.内置函数

　　　　重点：

　　　　　　filter( 函数名字 , 序列 ) ---------------注意map 与 filter 的区别

　　　　　　　　遍历序列的元素，每个元素进入函数里面，可以起到一个过滤器的作用。不会改变元素，最多就是过滤。

　　　　　　map( 函数名字，序列 )

　　　　　　　　遍历序列的元素，每个元素进入函数中，可以对元素进行一个处理。

　　　　　　reduce( 函数名字，序列 )

　　　　　　　　调用之前要加------------ from  functools  import  reduce 

　　　　　　　　reduce 的结果就是一个值。

　　　　　　lamda  ------------匿名函数 

　　　　　　　　lamda  参数 : 代码块

　　　　　　　　函数式编程用的多，可以用在reduce 这类配合进行使用。

　　5.闭包

　　　　定义：如果在一个内部函数中，对在外部作用域的变量（但不是在全局作用域中）进行引用，这就叫做闭包。

def outer():
    x = 10　　　　　　　　　　　　　　　　　　　　　　　　　　定义函数时的环境
    def inner():#条件一  inner就是内部函数　　 　　　　　　函数块
        print(x)#条件二  外部环境的一个变量　　　　　　　　 
    return inner()#结论  内部函数inner就是一个闭包

　　　　关于闭包：闭包 = 函数快 + 定义函数时的环境 

　　6.装饰器（重点!!!）

　　　　遵守开放封闭原则：对修改封闭，对扩展开放。

　　　　装饰器的作用就是为已经存在的对象添加额外的功能。

#author:"LFD"
#date: 2018/3/27
import time

def show_time(f):  #装饰器函数
    def inner():
        start = time.time()
        f()
        end = time.time()
        print('spend %s' % (end - start))
    return inner()

@show_time
def foo():
    print('liufeiduo')
    time.sleep(2)
@show_time
def bar():
    print('chengjunfei')
    time.sleep(3)

# foo=show_time(foo)
#
# bar = show_time(bar)

　　　　功能函数加参数

import time
# 加法器 并且计算加法器运行的时间。
def show_time(f):  #装饰器函数
    def inner(*x,**y):
        start = time.time()
        f(*x,**y)
        end = time.time()
        print('spend %s' % (end - start))
    return inner

@show_time
def add(*args):
    sums = 0
    for i in args:
        sums += i
    print(sums)
    time.sleep(1)

add(1,2,3,4,5)

　　　　装饰器参数

#author:"LFD"
#date: 2018/3/27
import time

# 装饰器加参数
def logger(flag=' '):

    def show_time(f):  #装饰器函数
        def inner(*x,**y):
            start = time.time()
            f(*x,**y)
            end = time.time()
            print('spend %s' % (end - start))
            if flag == ' ':    #当logger参数为空时，打印日志记录。不为空时则不打印。
                print('日志记录')
        return inner
    return show_time

@logger(' ')  # @show_time  
def add(*args):
    sums = 0
    for i in args:
        sums += i
    print(sums)
    time.sleep(1)

add(1,2,3,4,5)    

　　　7.列表生成式

def f(n):
    return n**3

a = [y for y in range(10)]
b = [f(x) for x in range(10)]  #列表生成器可以使用函数进行生成

print(a)
print(b)

 　　　8.生成器

　　　　生成器就是一个可迭代对象（ Iterable ）

s = (x for x in range(3))
#
# print(s)
#
# print(next(s)) #等价于s._next_()  in Py2: s.next()
# print(next(s))
#
# print(next(s))

for i in s:
    print(i)

　　　生成器一共有两种创建方式：

　　　　　①就是上面那种小括号的形式

　　　　　②yield 的方式 

　　　　　　生成器本质上就是一个函数，但跟函数具有区别。

def foo():
    print('ok')
    yield 1  # 只要有yield的就是生成器对象
#    return 1
    print('ok2')
    yield 2

foo()  # 生成器对象
g = foo()
next(g) # 调用生成器对象
next(g)

for i in foo():　　#会将yield也打印出来 也就是下面的1 和 2 。
    print(i)
--------------
ok
ok2
ok
1
ok
2
--------------　　

　　　　注意：生成器在创建的时候就已经决定了能计算出来的个数，调用next 的次数超过这个值就会报StopIteration 　　　　

　　　　什么是可迭代对象：

　　　　　内部具有 _Iter_ 方法的都是可迭代对象。列表、元组、字典、字符串都是可迭代对象。

　　　　　yield 有一个保持状态的作用。

　　9.send 方法

　　　　send 比 next 多一个功能，向函数体中传值，向yield 前面的变量传一个值。

send():
    
    f().send(None) #等价于next(f())

　　10.迭代器

　　　　生成器都是迭代器，迭代器不一定都是生成器。

　　　　什么是迭代器：

　　　　　　①有 iter 方法　　②有 next 方法

l = [1,2,34,5]
d = iter(l)
print(d) #<list_iterator object at 0x000001D9FFF09438>

print(next(d))
 
# for 循环做了三件事：
#   1.调用可迭代对象的iter 方法返回一个迭代器对象。
#   2.通过一个while循环不断的调用迭代器的next 方法。
#   3.处理StopIteration异常。
for i in [1,2,34,5]:　　一般都是通过for i in Iterable 进行取值
    iter([1,2,34,5])

二、心得

　　Python中的函数有着更多的方法作用，感觉功能强大但需要去发掘，装饰器也是起到了丰富其功能，使其可以用更短的代码做更多的事，装饰器的作用需要继续去体会，要代码量的上升才可以对它的了解更加深入。掌握Python的内置函数，通过内置函数缩短自己的代码行数。生成器以及迭代器两者的关系还没有弄透，以及如何搭配使用，实现更加复杂的功能还要进行多次实验。