13lambda_yield_yieldfrom_coroutine-乐山大橙子建站

新闻中心

这里有您想知道的互联网营销解决方案

13lambda_yield_yieldfrom_coroutine

成都创新互联公司网站建设服务商，为中小企业提供成都网站建设、成都网站制作服务，网站设计，网站托管维护等一站式综合服务型公司，专业打造企业形象网站，让您在众多竞争对手中脱颖而出成都创新互联公司。

匿名函数...1

生成器generator：...2

生成器函数：...2

生成器应用：...5

coroutine协程：...6

匿名函数

匿名，即没有名字，没有名字的函数；

python借助lambda表达式构建匿名函数；

格式：

lambda 参数列表: 表达式

参数列表不需要小括号；

冒号是用来分割参数列表和表达式的；

不需要使用return，表达式的值就是匿名函数的返回值；

lambda表达式只能写在一行上，被称为单行函数；

用途，高阶函数传参时，使用lambda表达式，往往能简化代码；

例：

In [2]: lambda x: x**2

Out[2]: >

In [3]: (lambda x: x**2)(4) #调用

Out[3]: 16

In [4]: foo=lambda x,y:(x+y)**2 #不推荐这么用

In [5]: foo(2,1)

Out[5]: 9

In [6]: def foo(x,y): #如果复杂时，建议使用普通函数

...: return (x+y)**2

...: foo(2,1)

...:

Out[6]: 9

In [7]: lst=['a',2,1]

In [8]: lst.sort(key=str) #高阶函数，str为函数

In [9]: lst

Out[9]: [1, 2, 'a']

In [10]: lambda :0 #无参函数，返回常数0

Out[10]: >

In [11]: (lambda x,y=3:x+y)(5)

Out[11]: 8

In [12]: (lambda x,y=3: x+y)(5,6)

Out[12]: 11

In [13]: (lambda x,*,y=30: x+y)(5)

Out[13]: 35

In [14]: (lambda x,*,y=30: x+y)(5,y=10)

Out[14]: 15

In [15]: (lambda *args:(x for x in args))(*range(5)) #生成器，惰性求值

Out[15]: .. at 0x7f892ccaca40>

In [16]: (lambda *args: [x for x in args])(*range(5)) #列表解析，立即求值

Out[16]: [0, 1, 2, 3, 4]

In [18]: (lambda *args: {x+2 for x in args})(*range(5))

Out[18]: {2, 3, 4, 5, 6}

In [20]: [x for x in (lambda *args: map(lambda x: x+1,args))(*range(5))] #高阶函数

Out[20]: [1, 2, 3, 4, 5]

In [22]: [x for x in (lambda *args: map(lambda x: (x+1,args),args))(*range(5))]

Out[22]:

[(1, (0, 1, 2, 3, 4)),

(2, (0, 1, 2, 3, 4)),

(3, (0, 1, 2, 3, 4)),

(4, (0, 1, 2, 3, 4)),

(5, (0, 1, 2, 3, 4))]

生成器generator：

生成器指的是生成器对象，可以由生成器表达式得到，也可以使用yield关键字得到一个生成器函数，调用这个函数得到一个生成器对象；

库函数中有大量使用；

生成器表达式和生成器函数能够生成生成器对象；

生成器函数：

函数中包含yield语句的函数，返回生成器对象；

生成器对象，是一个可迭代对象，是一个迭代器；

生成器对象，是延迟计算，惰性求值的；

普通的函数在调用后，会立即执行完毕，但生成器函数可使用next()多次执行；

生成器函数等价于生成器表达式，只不过生成器函数更加复杂；

生成器函数，核心：让出；

在生成器函数中，使用多个yield语句，执行一次后会暂停执行，把yield表达式的值返回；

再次执行会执行到下个yield语句；

return语句依然可以终止函数运行，但return语句的返回值不能被获取到，生成器函数中一般不加return语句；

return会导致无法继续获取下一个值，抛StopIteration异常；

如果函数没有显式的return语句，如果生成器函数执行到结尾一样会抛StopIteration异常；

包含yield语句的生成器函数，生成生成器对象时，生成器函数的函数体不会立即执行；

next(generator)会从函数的当前位置向后执行到之后碰到的第一个yield语句，会弹出值，并暂停函数执行，next()可理解为拨一下转一次；

再次调用next()，和上一条一样的处理过程，当没有元素时可给缺省值next(g,'End')，防止抛异常；

没有多余的yield语句能被执行，继续调用next()，会抛StopIteration异常；

例：

In [23]: def inc():

...: for i in range(5):

...: yield i #出现yield就是生成器函数

...:

In [24]: type(inc)

Out[24]: function

In [25]: type(inc())

Out[25]: generator

In [26]: x=inc()

In [27]: type(x)

Out[27]: generator

In [28]: next(x)

Out[28]: 0

In [29]: for n in x:

...: print(n)

...:

In [30]: for n in x:

...: print(n) #x在上个for中已迭代完

...:

In [39]: y=(i for i in range(2))

In [40]: type(y)

Out[40]: generator

In [41]: next(y)

Out[41]: 0

In [42]: next(y)

Out[42]: 1

In [43]: next(y)

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

StopIteration Traceback (most recent call last)

in ()

----> 1 next(y)

StopIteration:

例：

In [44]: def gen():

...: print('line1')

...: yield 1

...: print('line2')

...: yield 2

...: print('line3')

...: return 3

...:

In [45]: next(gen())

line1

Out[45]: 1

In [46]: next(gen())

line1

Out[46]: 1

In [47]: g=gen()

In [48]: next(g)

line1

Out[48]: 1

In [49]: next(g)

line2

Out[49]: 2

In [50]: next(g)

line3

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

StopIteration Traceback (most recent call last)

in ()

----> 1 next(g)

StopIteration: 3

In [51]: g=gen()

In [52]: next(g)

line1

Out[52]: 1

In [53]: next(g)

line2

Out[53]: 2

In [54]: next(g,'End') #没有元素，给缺省值

line3

Out[54]: 'End'

In [55]: next(g,'End')

Out[55]: 'End'

无限循环：

例：

defcounter():
    i =0
   while True:
        i +=1
       yieldi

definc(c):
       returnnext(c)

c = counter()
print(inc(c))
print(inc(c))
print(inc(c))

##############

defcounter2():
    i =0
   while True:
        i +=1
       yieldi

definc2():
    c = counter()
   returnnext(c)

print(inc2())   #1
print(inc2())   #1
print(inc2())   #1，每次都创建生成器对象

生成器应用：

计数器：

definc():
   defcounter():
        i =0
       while True:
            i +=1
           yieldi
    c = counter()
   return lambda:next(c)  #相当于如下三行，闭包，用到了外层函数的自由变量c,lambda表达式是匿名函数，return返回的是一个匿名函数
    #def _inc():
        #return next(c)
    #return _inc
foo = inc()
print(foo())
print(foo())

处理递归问题：

deffib():
    x =0
   y =1
   while True:
       yieldy
        x,y = y,x+y

foo=fib()
foriinrange(5):
   print(next(foo))

for_inrange(100):
   print(next(foo))
#print(next(foo))

coroutine协程：

生成器的高级用法；

比进程、线程轻量级；

是在用户空间调度函数的一种实现；

python3 asyncio就是协程实现，已加入到标准库；

python3.5使用async、await关键字直接原生支持协程；

协程调度器实现思路，有2个生成器A、B，next(A)后，A执行到了yield语句暂停，然后去执行next(B)，B执行到yield语句也暂停，然后再次调用next(A)，再调用next(B)，周而复始，就实现了调度效果；可引入调度的策略来实现切换的方式；

协程是一种非抢占式调度；

yield from语句：

python3.3出现的新语法；

yield from iterrable是for item in iterable: yield item形式的语法糖，从可迭代对象中一个个拿元素；

例：

In [56]: def inc():

...: for x in range(1000):

...: yield x

...:

In [57]: def inc():

...: yield from range(1000)

...:

In [58]: foo=inc()

In [59]: next(foo)

Out[59]: 0

In [60]: next(foo)

Out[60]: 1

例：

In [68]: def counter(n):

...: yield from range(n)

...:

In [69]: def inc(n):

...: yield from counter(n)

...:

In [70]: foo=inc(10)

In [71]: next(foo)

Out[71]: 0

In [72]: next(foo)

Out[72]: 1

习题：

1、把一个字典扁平化flat；

源字典：{'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

2、实现base64编码，要求自己实现算法；

3个8bit字节3*8-->转化为4个6bit字节4*6，之后在6bit的前面补两0，形成8bit一个字节的形式，如果剩下的字符不是3个字节，则用0填充，输出字符使用=，因此编码后输出的文本末尾可能会出现1个或2个=；

编码大小为2**6=64;

每一段当作一个8bit看它的值，这个值就是base64编码表的索引值，找到对应字符，再取3个字节，同样处理，直到最后；

例：

abc对应的ascii为：0x61,0x62,0x63，十进制为97,98,99

01100001 01100010 01100011

011000 010110 001001 100011

00011000 00010110 00001001 00100011

24 22 9 35

末尾处理：

正好3个字节，处理方法同上；

剩1个字节或2个字节，用0补满3个字节；

补0的字节用=表示；

大小端模式：

大端模式（Big-endian），是指数据的高字节，保存在内存的低地址中，而数据的低字节，保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；

小端模式（Little-endian），是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致；

在C语言中，默认是小端（但在一些对于单片机的实现中却是基于大端，比如Keil 51C），Java是平台无关的，默认是大端；在网络上传输数据普遍采用的都是大端；

In [48]: b=int.from_bytes('abc'.encode(),'big')

In [49]: b

Out[49]: 6382179

In [50]: hex(b)

Out[50]: '0x616263'

In [52]: b=int.from_bytes('abc'.encode(),'little')

In [53]: hex(b)

Out[53]: '0x636261'

In [54]: type(b)

Out[54]: int

In [55]: import base64

In [56]: base64.b64encode('abc'.encode())

Out[56]: b'YWJj'

i18n（其来源是英文单词internationalization的首末字符i和n，18为中间的字符数）是“国际化”的简称。在资讯领域，国际化(i18n)指让产品（出版物，软件，硬件等）无需做大的改变就能够适应不同的语言和地区的需要。对程序来说，在不修改内部代码的情况下，能根据不同语言及地区显示相应的界面。在全球化的时代，国际化尤为重要，因为产品的潜在用户可能来自世界的各个角落。通常与i18n相关的还有L10n（“本地化”的简称）。

3、求2个字符串的最长公共子串；

1、

src = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

target = {}

def flatmap(src,prefix=''):

for k,v in src.items():

if isinstance(v,(dict)):

flatmap(v,prefix=prefix+k+'.')

else:

target[prefix+k] = v

flatmap(src)

print(target)

#####################

src = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

def flatmap(src,dst=None,prefix=''):

if dst == None:

dst = {}

for k,v in src.items():

if isinstance(v,(dict)):

flatmap(v,dst,prefix=prefix+k+'.') #recursion调用

else:

dst[prefix+k] = v

return dst

flatmap(src)

注：

用户输入的判断，这些代码通常比业务逻辑代码长好几倍，健壮的代码无论怎么运行都不会意外崩溃；

一般不说明的情况下，都不会改源数据（源列表、源字典等）；

能否不暴露给外界内部的dst；

能否函数就提供一个参数源字典，返回一个新的扁平化字典；

递归时要把目标字典的引用传递多层，如何处理；

########################

src = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

def flatmap(src):

def _flatmap(src,dst,prefix=''):

for k,v in src.items():

if isinstance(v,(dict)):

_flatmap(v,dst,prefix=prefix+k+'.')

else:

dst[prefix+k] = v

dst = {}

_flatmap(src,dst)

return dst

flatmap(src)

注：

不关心_flatmap函数内部如何实现，如内部用的数据结构、临时对象、算法等，只关心调用后返回的结果；

#######################

src = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

def flatmap(src):

def _flatmap(src,dst,prefix=''):

for k,v in src.items():

key = prefix + k

if isinstance(v,(dict)):

_flatmap(v,dst,key+'.')

else:

dst[key] = v

dst = {}

_flatmap(src,dst)

return dst

flatmap(src)

2、

import string

import base64

alphabet = b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'

#teststr = 'abcd'

# teststr = 'abc'

teststr = 'ManMa'

def base(src):

ret = bytearray()

length = len(src)

r = 0

for offset in range(0,length,3):

if offset + 3 <= length:

triple = src[offset:offset+3]

else:

triple = src[offset:]

r = 3 - len(triple)

triple = triple + '\x00' * r

#print(triple,r)

b = int.from_bytes(triple.encode(),'big')

#print(hex(b))

for i in range(18,-1,-6):

if i == 18:

index = b >> i

else:

index = b >> i & 0x3F

ret.append(alphabet[index])

for i in range(1,r+1):

ret[-i] = 0x3D

return bytes(ret)

print(base(teststr))

print('*' * 50)

print(base64.b64encode(teststr.encode()))

注：

alphabet = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'

3、

def findit(str1,str2):

length = len(str1)

for sublen in range(length,0,-1):

for start in range(0,length-sublen+1):

substr = str1[start:start+sublen]

if str2.find(substr) != -1:

print('substrlen={}'.format(substr))

return substr

s1 = 'abcd'

s2 = 'abcefgd'

s3 = '123a'

print(findit(s1,s2)) #传参时要注意，str1为短字串，str2为长字串

print(findit(s1,s3))

网页名称：13lambda_yield_yieldfrom_coroutine
本文路径：http://lswzjz.com/article/ghgsoh.html

新闻中心

匿名函数

生成器generator：

生成器函数：

生成器应用：

coroutine协程：

其他资讯