函数生成器python,函数生成器desmos

Python生成器简介

Python 中的 yield 关键字鲜为人知，但是作用却很大，正是因为有了yield，才有了Python生成器。

在尼玛等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供网站设计、做网站网站设计制作按需开发,公司网站建设,企业网站建设,成都品牌网站建设,网络营销推广,外贸网站制作,尼玛网站建设费用合理。

yield 是 Python 的关键字，它用于从函数返回而不破坏其局部变量的状态，并且在调用该函数时，从最后一个 yield 语句开始执行。任何包含 yield 关键字的函数都称为生成器。

Python 中的 yield 关键字的作用类似于 Python 中的 return 语句，不同之处在于：

yield的优点

yield的缺点

Python 可以使用括号() 创建生成器

更多时候，我们使用 yield 关键字创建生成器

下面这个生成器，前4次调用它时，返回的是0-3这几个特殊值，第5次调用它时返回一个10-20之间的随机整数。

更多时候，生成器可以返回无限的值。

注意 generator() 函数返回的是一个生成器对象，要想获取它的值，可以像上面那样在迭代器中取出它的值，我们也可以显式的调用next函数获取值。

Python | yield Keyword - GeeksforGeeks：

python生成器是怎么使用的

生成器(generator)概念

生成器不会把结果保存在一个系列中，而是保存生成器的状态，在每次进行迭代时返回一个值，直到遇到StopIteration异常结束。

生成器语法

生成器表达式：通列表解析语法，只不过把列表解析的[]换成()

生成器表达式能做的事情列表解析基本都能处理，只不过在需要处理的序列比较大时，列表解析比较费内存。

Python

gen = (x**2 for x in range(5))

gen

generator object genexpr at 0x0000000002FB7B40

for g in gen:

... print(g, end='-')

...

0-1-4-9-16-

for x in [0,1,2,3,4,5]:

... print(x, end='-')

...

0-1-2-3-4-5-

生成器函数：在函数中如果出现了yield关键字，那么该函数就不再是普通函数，而是生成器函数。

但是生成器函数可以生产一个无线的序列，这样列表根本没有办法进行处理。

yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator。

下面为一个可以无穷生产奇数的生成器函数。

Python

def odd():

n=1

while True:

yield n

n+=2

odd_num = odd()

count = 0

for o in odd_num:

if count =5: break

print(o)

count +=1

当然通过手动编写迭代器可以实现类似的效果，只不过生成器更加直观易懂

Python

class Iter:

def __init__(self):

self.start=-1

def __iter__(self):

return self

def __next__(self):

self.start +=2

return self.start

I = Iter()

for count in range(5):

print(next(I))

题外话：生成器是包含有__iter()和next__()方法的，所以可以直接使用for来迭代，而没有包含StopIteration的自编Iter来只能通过手动循环来迭代。

Python

from collections import Iterable

from collections import Iterator

isinstance(odd_num, Iterable)

True

isinstance(odd_num, Iterator)

True

iter(odd_num) is odd_num

True

help(odd_num)

Help on generator object:

odd = class generator(object)

| Methods defined here:

| __iter__(self, /)

| Implement iter(self).

| __next__(self, /)

| Implement next(self).

......

看到上面的结果，现在你可以很有信心的按照Iterator的方式进行循环了吧！

在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。

yield 与 return

在一个生成器中，如果没有return，则默认执行到函数完毕时返回StopIteration；

Python

def g1():

... yield 1

...

g=g1()

next(g) #第一次调用next(g)时，会在执行完yield语句后挂起，所以此时程序并没有执行结束。

next(g) #程序试图从yield语句的下一条语句开始执行，发现已经到了结尾，所以抛出StopIteration异常。

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration

如果遇到return,如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

Python

def g2():

... yield 'a'

... return

... yield 'b'

...

g=g2()

next(g) #程序停留在执行完yield 'a'语句后的位置。

'a'

next(g) #程序发现下一条语句是return，所以抛出StopIteration异常，这样yield 'b'语句永远也不会执行。

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration

如果在return后返回一个值，那么这个值为StopIteration异常的说明，不是程序的返回值。

生成器没有办法使用return来返回值。

Python

def g3():

... yield 'hello'

... return 'world'

...

g=g3()

next(g)

'hello'

next(g)

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration: world

生成器支持的方法

Python

help(odd_num)

Help on generator object:

odd = class generator(object)

| Methods defined here:

......

| close(...)

| close() - raise GeneratorExit inside generator.

| send(...)

| send(arg) - send 'arg' into generator,

| return next yielded value or raise StopIteration.

| throw(...)

| throw(typ[,val[,tb]]) - raise exception in generator,

| return next yielded value or raise StopIteration.

......

close()

手动关闭生成器函数，后面的调用会直接返回StopIteration异常。

Python

def g4():

... yield 1

... yield 2

... yield 3

...

g=g4()

next(g)

g.close()

next(g) #关闭后，yield 2和yield 3语句将不再起作用

Traceback (most recent call last):

File "stdin", line 1, in module

StopIteration

send()

生成器函数最大的特点是可以接受外部传入的一个变量，并根据变量内容计算结果后返回。

这是生成器函数最难理解的地方，也是最重要的地方，实现后面我会讲到的协程就全靠它了。

Python

def gen():

value=0

while True:

receive=yield value

if receive=='e':

break

value = 'got: %s' % receive

g=gen()

print(g.send(None))

print(g.send('aaa'))

print(g.send(3))

print(g.send('e'))

执行流程：

通过g.send(None)或者next(g)可以启动生成器函数，并执行到第一个yield语句结束的位置。此时，执行完了yield语句，但是没有给receive赋值。yield value会输出初始值0注意：在启动生成器函数时只能send(None),如果试图输入其它的值都会得到错误提示信息。

通过g.send(‘aaa’)，会传入aaa，并赋值给receive，然后计算出value的值，并回到while头部，执行yield value语句有停止。此时yield value会输出”got: aaa”，然后挂起。

通过g.send(3)，会重复第2步，最后输出结果为”got: 3″

当我们g.send(‘e’)时，程序会执行break然后推出循环，最后整个函数执行完毕，所以会得到StopIteration异常。

最后的执行结果如下：

Python

got: aaa

got: 3

Traceback (most recent call last):

File "h.py", line 14, in module

print(g.send('e'))

StopIteration

throw()

用来向生成器函数送入一个异常，可以结束系统定义的异常，或者自定义的异常。

throw()后直接跑出异常并结束程序，或者消耗掉一个yield，或者在没有下一个yield的时候直接进行到程序的结尾。

Python

def gen():

while True:

try:

yield 'normal value'

yield 'normal value 2'

print('here')

except ValueError:

print('we got ValueError here')

except TypeError:

break

g=gen()

print(next(g))

print(g.throw(ValueError))

print(next(g))

print(g.throw(TypeError))

输出结果为：

Python

normal value

we got ValueError here

normal value

normal value 2

Traceback (most recent call last):

File "h.py", line 15, in module

print(g.throw(TypeError))

StopIteration

解释：

print(next(g))：会输出normal value，并停留在yield ‘normal value 2’之前。

由于执行了g.throw(ValueError)，所以会跳过所有后续的try语句，也就是说yield ‘normal value 2’不会被执行，然后进入到except语句，打印出we got ValueError here。然后再次进入到while语句部分，消耗一个yield，所以会输出normal value。

print(next(g))，会执行yield ‘normal value 2’语句，并停留在执行完该语句后的位置。

g.throw(TypeError)：会跳出try语句，从而print(‘here’)不会被执行，然后执行break语句，跳出while循环，然后到达程序结尾，所以跑出StopIteration异常。

下面给出一个综合例子，用来把一个多维列表展开，或者说扁平化多维列表)

Python

def flatten(nested):

try:

#如果是字符串，那么手动抛出TypeError。

if isinstance(nested, str):

raise TypeError

for sublist in nested:

#yield flatten(sublist)

for element in flatten(sublist):

#yield element

print('got:', element)

except TypeError:

#print('here')

yield nested

L=['aaadf',[1,2,3],2,4,[5,[6,[8,[9]],'ddf'],7]]

for num in flatten(L):

print(num)

如果理解起来有点困难，那么把print语句的注释打开在进行查看就比较明了了。

总结

按照鸭子模型理论，生成器就是一种迭代器，可以使用for进行迭代。

第一次执行next(generator)时，会执行完yield语句后程序进行挂起，所有的参数和状态会进行保存。再一次执行next(generator)时，会从挂起的状态开始往后执行。在遇到程序的结尾或者遇到StopIteration时，循环结束。

可以通过generator.send(arg)来传入参数，这是协程模型。

可以通过generator.throw(exception)来传入一个异常。throw语句会消耗掉一个yield。可以通过generator.close()来手动关闭生成器。

next()等价于send(None)

闲话python 45: 浅谈生成器yield

生成器似乎并不是一个经常被开发者讨论的语法，因此也就没有它的大兄弟迭代器那么著名。大家不讨论它并不是说大家都已经对它熟悉到人尽皆知，与之相反，即使是工作多年的开发者可能对生成器的运行过程还是知之甚少。这是什么原因导致的呢？我猜想大概有以下几点原因： (1)运行流程不同寻常，(2)日常开发不需要，(3)常常将生成器与迭代器混淆。生成器的运行流程可以按照协程来理解，也就是说返回中间结果，断点继续运行。这与我们通常对于程序调用的理解稍有差异。这种运行模式是针对什么样的需求呢？一般而言，生成器是应用于大量磁盘资源的处理。比如一个很大的文件，每次读取一行，下一次读取需要以上一次读取的位置为基础。下面就通过代码演示具体看看生成器的运行机制、使用方式以及与迭代器的比较。

什么是生成器？直接用文字描述可能太过抽象，倒不如先运行一段代码，分析这段代码的运行流程，然后总结出自己对生成器的理解。

从以上演示可以看出，这段代码定义了一个函数，这个函数除了yield这个关键字之外与一般函数并没有差异，也就是说生成器的魔法都是这个yield关键字引起的。第一点，函数的返回值是一个生成器对象。上述代码中，直接调用这个看似普通的函数，然后将返回值打印出来，发现返回值是一个对象，而并不是普通函数的返回值。第二点，可以使用next对这个生成器对象进行操作。生成器对象天然的可以被next函数调用，然后返回在yield关键字后面的内容。第三，再次调用next函数处理生成器对象，发现是从上次yield语句之后继续运行，直到下一个yield语句返回。

生成器的运行流程确实诡异，下面还要演示一个生成器可以执行的更加诡异的操作：运行过程中向函数传参。

返回生成器和next函数操作生成器已经并不奇怪了，但是在函数运行过程中向其传参还是让人惊呆了。调用生成器的send函数传入参数，在函数内使用yield语句的返回值接收，然后继续运行直到下一个yield语句返回。以前实现这种运行流程的方式是在函数中加上一个从控制台获取数据的指令，或者提前将参数传入，但是现在不用了，send方式使得传入的参数可以随着读取到的参数变化而变化。

很多的开发者比较容易混淆生成器和迭代器，而迭代器的运行过程更加符合一般的程序调用运行流程，因此从亲进度和使用熟悉度而言，大家对迭代器更有好感。比如下面演示一个对迭代器使用next方法进行操作。

从以上演示来看，大家或许会认为迭代器比生成器简单易用得太多了。不过，如果你了解迭代器的实现机制，可能就不会这么早下结论了。python内置了一些已经实现了的迭代器使用确实方便，但是如果需要自己去写一个迭代器呢？下面这段代码就带大家见识以下迭代器的实现。

在python中，能被next函数操作的对象一定带有__next__函数的实现，而能够被迭代的对象有必须实现__iter__函数。看了这么一段操作，相信大家对迭代器实现的繁琐也是深有体会了，那么生成器的实现是不是会让你觉得更加简单易用呢？不过千万别产生一个误区，即生成器比迭代器简单就多用生成器。在实际开发中，如果遇到与大量磁盘文件或者数据库操作相关的倒是可以使用生成器。但是在其他的任务中使用生成器难免有炫技，并且使逻辑不清晰而导致可读性下降的嫌疑。这大概也能解释生成器受冷落的原因。不过作为一个专业的开发者，熟悉语言特性是分内之事。

到此，关于生成器的讨论就结束了。本文的notebook版本文件在github上的cnbluegeek/notebook仓库中共享，欢迎感兴趣的朋友前往下载。

Python中如何使生成器函数来用元组返回一个字符串大写字母个数和小写字母个数？

#如何使生成器函数来用元组返回一个字符串大写字母个数和小写字母个数

def getUorL(s):

# [A-Z]是匹配内容，str是待匹配的对象

rtn = f"大写字母个数： {len(re.findall('[A-Z]',s))}"

yield rtn

# [a-z]是匹配内容，str_是待匹配的对象

rtn = f"小写字母个数： {len(re.findall('[a-z]',s))}"

yield rtn

str = "10ABC23sD~45ffe67e;oo++"

#第一次返回大写

g = getUorL(str)

print(next(g))

#第二次返回小写

print(next(g))

Python 函数 - 返回生成器

如果函数要返回一系列结果，我们常见的方法就是将结果放到一份列表中，然后返回给调用者。比如下面的函数，返回字符串中每个单词的首字母在真个字符串中的索引：

运行结果：

上述的结果完全符合我们的预期，但 get_word_index 函数不够简洁。下面我们尝试使用生成器来实现：

运行结果：

改写之后，不仅运行结果符合要求，由于不需要和 result 列表交互，函数也变得非常简洁。下面我们就来详细学习下生成器吧~

生成器是指使用 yield 表达式的函数，调用生成器函数时，它并不会真的运行，而是会返回迭代器。每次在这个迭代器上面调用内置的 next 函数时，迭代器就会把生成器推进到下一个 yield 表达式那里。生成器传给 yield 的值均会由迭代器返回给调用者。

此外，如果输入量非常大，使用列表作为返回值，那么程序就有可能耗尽内存并崩溃。相反，使用生成器之后，则可以应对任意长度的输入数据。

例如，下面这个生成器函数可以获取文件中单词的索引，而不管文件内容多大，该函数执行时消耗的内存，只由单行的文本长度决定：

其中 test_generator.txt 中的内容如下：

运行结果：

下面这句话特别重要：生成器函数返回的迭代器，是由状态的，及调用者不应该反复使用它。我们那 word_index_iter 来说明：

如果想重复调用，请将其封装成容器：

运行结果：

关于上述自定义容器的实现原理，我的另外一篇文章做了详细介绍，链接奉上：

Python中生成器的理解？

9.10. 生成器

Generator 是创建迭代器的简单而强大的工具。它们写起来就像是正规的函数，需要返回数据的时候使用 yield 语句。每次 next() 被调用时，生成器回复它脱离的位置（它记忆语句最后一次执行的位置和所有的数据值）。以下示例演示了生成器可以很简单的创建出来:

前一节中描述了基于类的迭代器，它能作的每一件事生成器也能作到。因为自动创建了 __iter__() 和 __next__() 方法，生成器显得如此简洁。

另一个关键的功能在于两次执行之间，局部变量和执行状态都自动的保存下来。这使函数很容易写，而且比使用 self.index 和 self.data 之类的方式更清晰。

除了创建和保存程序状态的自动方法，当发生器终结时，还会自动抛出 StopIteration 异常。综上所述，这些功能使得编写一个正规函数成为创建迭代器的最简单方法。

前一节中描述了基于类的迭代器，它能作的每一件事生成器也能作到。因为自动创建了 __iter__() 和 __next__() 方法，生成器显得如此简洁。

本文名称：函数生成器python,函数生成器desmos
文章网址：https://www.cdcxhl.com/article40/dsgpgho.html

成都网站建设公司_创新互联，为您提供电子商务、网站设计公司、营销型网站建设、动态网站、小程序开发、网站建设

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容