Python全栈开发-Day4-Python基础4

本节内容

1. 匿名函数
2. 装饰器
3. 列表生成式、迭代器&生成器
4. 内置函数
5. Json & pickle 数据序列化

1. 匿名函数 

匿名函数就是不需要显式的指定函数

1 2 3 4 5 6 7 8

#这段代码 def calc(n):     return n**n print(calc(10))   #换成匿名函数 calc = lambda n:n**n #n为匿名函数的形参 print(calc(10)) # calc（10）为匿名函数的调用方式

即匿名函数，不需要def的定义模式，直接用赋值符号+lambda就可以定义匿名函数。

匿名函数只能处理一些简单的运算，类似列表生成式和生成器。如果内部逻辑稍微复杂一点，就不能运行了，只能用正常函数定义了。

匿名函数主要是和其它函数搭配使用：

1 2 3

res = map(lambda x:x**2,[1,5,7,4,8]) for i in res:     print(i)

输出

1
25
49
16
64

示例：

　　calc = lambda x ：x*3#虽然这是匿名函数，没有函数名，但感觉calc类似于函数名，x为形参，lambda≈def

　　calc(3)　　#如果calc约等于函数名，则调用时，也是用calc()

　　 lambda x ：x*3  #这一部分叫做匿名函数。

 

 

2、装饰器

定义：装饰器本质就是函数。功能是装饰其他函数，就是为其他函数添加附加功能。又名：语法糖。

原则：

　　1、不能修改被装饰函数的源代码（使用场景：正在上线运行的程序，在不下线修改的前提下，增添新功能）

　　2、不能修改被装饰函数的调用方式（同上）

　　以上两点总结为一点：装饰器对被它装饰的函数是完全透明的，即该函数的使用者并不知道这个函数发生了改变。

示例：

　　import time

　　def timmer(func):  #这个是装饰器

　　　　def warpper(*args,**kwargs):　　#*args和**kwargs是用来防止原函数被传递参数用的。

　　　　　　start_time=time.time()

　　　　　　func(args,kwargs)

　　　　　　stop_time=time.time()

　　　　　　print('the func run time is %s' %(stop_time-start_time))

　　　　return warpper

　　@timmer　　#装饰器的调用，@+装饰器名     @timmer和test1=timmer(test1)意义一样。

　　def test1():  #这是原函数 

　　　　time.sleep(3)

　　　　print('in the test1')

　　@timmer　　# test2=timmer(test2)  

　　def test2(name):

　　　　print('test2:',name)

　　test1()

　　test2('gavin')　　#其实此时的test2()=warpper(),所以如果原调用方式给原函数传递参数的话，需要在内嵌函数的里层函数中设置参数组*args，**kwargs。

最高级语法糖示例：

import time
user,passwd = 'gavin','abc123'
def auth(auth_type):
    print("auth func:",auth_type)
    def outer_wrapper(func):　　#装饰器的外层
        def wrapper(*args, **kwargs):　　#装饰器的内层
            print("wrapper func args:", *args, **kwargs)
            if auth_type == "local":
                username = input("Username:").strip()
                password = input("Password:").strip()
                if user == username and passwd == password:
                    print("33[32;1mUser has passed authentication33[0m")
                    res = func(*args, **kwargs)  #home【注意】：加了装饰器后，原函数调用相当于调用了装饰器内层，如果原函数需要返回值，需要在这把原函数返回值保存
                    print("---after authenticaion ")
                    return res　　　　　　　　　　　#home【注意】：被保存的原函数执行结果，在内层函数的最后用return返回，这样就相当于返还给了原函数的调用地方。
                else:
                    exit("33[31;1mInvalid username or password33[0m")
            elif auth_type == "ldap":
                print("搞毛线ldap,不会。。。。")

        return wrapper
    return outer_wrapper

def index():
    print("welcome to index page")
@auth(auth_type="local") # home = wrapper()
def home():
    print("welcome to home  page")
    return "from home"　　#以home为例，这里home函数有返回值。

@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs  page")

index()
print(home()) #wrapper()　　#【注意】：home函数的返回值，在这里被使用。所以需要在装饰器的内层的结尾处加入return函数。
bbs()

实现装饰器知识储备：

　　1、函数即“变量”

　　2、高阶函数

　　3、嵌套函数

高阶函数 + 嵌套函数 => 装饰器

1、函数即"变量"

　　x=1　　#变量名为x，在内存中对应的数据为1

　　def test():　　#这是函数的定义式

　　　　pass

 　　所以函数即“变量”类似于

　　test = ‘函数体’　　#就是‘函数体’是在内存空间的数据，函数名test是函数体的门牌号。

　　python的内存回收机制是解释器做的，有一个叫做‘引用计数’的概念。即统计某个内存中的值被引用的次数。

当引用计数值为0时，即某个内存中对应的数据没有对应的“门牌号”时，内存回收机制就会把对应内存数据清空。

　　x = 1

　　del x　　#这个del删除的不是内存地址中的1，而是删除了x这个门牌号。内存中的1是python自带的内存回收机制中的‘引用计数’刷新时，发现1这个内存数据没有引用，被内存回收机制清除的。

2、高阶函数

　　满足下面两个条件之一就可以称之为高阶函数：

　　　　1）把一个函数名当做实参传递给另外一个函数。（在不修改被装饰函数源代码的情况下，为其增加新的功能）

　　　　2）返回值中包含函数名（不改变被修饰函数的调用方式）

3、嵌套函数

　　定义：在一个函数体内再用def 去定义另外一个函数。如果在一个函数体内，没用def 声明新的函数，只是调用了其他的函数，不叫做函数的嵌套。

　　

局部作用域和全局作用域的访问顺序

1 2 3 4 5 6 7 8 9 10 11

x=0 def grandpa():     # x=1     def dad():         x=2         def son():             x=3             print x         son()     dad() grandpa()

　　

 

3.列表生成式，迭代器&生成器

列表生成式

现在有个需求，看列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],要求把列表里的每个值加1

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[i+1 for i in range(10)]，这就叫做列表生成式。还可以这么写

[func(i) for i in range(10)]　　#每次for循环后把临时变量i都传递给func（i）这个函数，这个函数执行后把结果返回到这个列表里作为其中的一个元素。

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator【定义】。

生成器的特点：

　　1、只有在调用的时候才会生成相应的数据。

　　2、只记录当前位置 

　　3、只有一个__next__()方法（在Py 3.x中是前面的写法）

生成器的生成方法1：

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

1 2 3 4 5 6

>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

>>> next(g) 0 >>> next(g) 1 >>> next(g) 4 >>> next(g) 9 >>> next(g) 16 >>> next(g) 25 >>> next(g) 36 >>> next(g) 49 >>> next(g) 64 >>> next(g) 81 >>> next(g) Traceback (most recent call last):   File "<stdin>", line 1, in <module> StopIteration

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

列表和生成器的区别：

　　列表支持下标引用

　　生成器不支持任何的下标引用和切片，无论下标是否被生成器曾经生成过。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

>>> g = (x * x for x in range(10)) >>> for n in g: ...     print(n) ... 0 1 4 9 16 25 36 49 64 81

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

生成器的生成方法2：

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

1 2 3 4 5 6 7

def fib(max):     n, a, b = 0, 0, 1     while n < max:         print(b)         a, b = b, a + b         n = n + 1     return 'done'

注意，赋值语句：

1	a, b = b, a + b

相当于：

1 2 3

t = (b, a + b) # t是一个tuple a = t[0] b = t[1]

但不必显式写出临时变量t就可以赋值。

上面的函数可以输出斐波那契数列的前N个数：

1 2 3 4 5 6 7 8 9 10 11 12

>>> fib(10) 1 1 2 3 5 8 13 21 34 55 done

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

def fib(max):
    n,a,b = 0,0,1

    while n < max:
        #print(b)
        yield  b
        a,b = b,a+b

        n += 1

    return 'done' 

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

data = fib(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13

在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

>>> g = fib(6) >>> while True: ...     try: ...         x = next(g) ...         print('g:', x) ...     except StopIteration as e: ...         print('Generator return value:', e.value) ...         break ... g: 1 g: 1 g: 2 g: 3 g: 5 g: 8 Generator return value: done

上面例子中的函数作用：

　　yield作用是保存了程序的中断状态，并且返回了生成器当前状态的值。

　　__next__()或next()的作用是只调用yield但不传值。

　　send()的作用是调用yield同时给yield传值。（这个函数在下面的例子中被使用）

还可通过yield实现在单线程的情况下实现并发运算的效果

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("gavin")

上述这种程序是异步I/O的雏形，原理是在单个线程内，多个函数或功能之间快速的互相切换，给人的感觉就是多个功能或过程并发运行。

这种方式我们称之为协程，它是存在于单线程内。

【注意】：

　　c = consumer('A')
    c2 = consumer('B')

如果consumer是函数，这两句话就是调用函数。函数会直接运行到底并返回结果。但如果consumer是生成器，这两句话只是定义生成器，函数不会运行任何一段代码。此时需要send（）或者是next（）函数进行调用。

迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

1 2 3 4 5 6 7 8 9 10 11

>>> from collections import Iterable >>> isinstance([], Iterable) True >>> isinstance({}, Iterable) True >>> isinstance('abc', Iterable) True >>> isinstance((x for x in range(10)), Iterable) True >>> isinstance(100, Iterable) False

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

【注意迭代器和可迭代对象的定义区别】：

可以直接作用于for循环的对象统称为可迭代对象：Iterable。

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

对一个对象a使用dir方法（即dir（a）），就可以看a的所有可以使用的方法。

可以使用isinstance()判断一个对象是否是Iterator对象：

1 2 3 4 5 6 7 8 9

>>> from collections import Iterator >>> isinstance((x for x in range(10)), Iterator) True >>> isinstance([], Iterator) False >>> isinstance({}, Iterator) False >>> isinstance('abc', Iterator) False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数 ：

1 2 3 4

>>> isinstance(iter([]), Iterator) True >>> isinstance(iter('abc'), Iterator) True

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

小结

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

在Python 3.x 中range（10）也是一个迭代器。

同时文件句柄或者说是文件本身也是一个迭代器

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

1 2	for x in range（6）:     pass

实际上完全等价于：

# 首先获得Iterator对象:
it = iter([0，1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

4. 内置函数　　

内置函数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii 

#compile
f = open("函数递归.py")
data =compile(f.read(),'','exec')
exec(data)


#print
msg = "又回到最初的起点"
f = open("tofile","w")
print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)


# #slice
# a = range(20)
# pattern = slice(3,8,2)
# for i in a[pattern]: #等于a[3:8:2]
#     print(i)
#
#


#memoryview
#usage:
#>>> memoryview(b'abcd')
#<memory at 0x104069648>
#在进行切片并赋值数据时，不需要重新copy原列表数据，可以直接映射原数据内存，
import time
for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = data
    while b:
        b = b[1:]
    print('bytes', n, time.time()-start)

for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = memoryview(data)
    while b:
        b = b[1:]
    print('memoryview', n, time.time()-start)

5.Json & pickle 数据序列化

参考 http://www.cnblogs.com/alex3714/articles/5161349.html

用于序列化的两个模块

• json，用于字符串 和 python数据类型间进行转换
• pickle，用于python特有的类型 和 python的数据类型间进行转换

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load