生成器 生成器函数

本质就是迭代器.
一个一个的创建对象
创建生成器的方式:
1. 生成器函数
2. 通过生成器表达式来获取生成器
3. 类型转换(看不到)

生成器函数 (重点)
生成器函数中包含 yield , 返回数据和return差不多.
return会立即结束这个函数的执行
yield 可以分段的执行一个函数

生成器函数在执行的时候返回生成器. 而不是直接执行此函数

能向下执行的两个条件:
__next__(), 执行到下一个yield
send(), 执行到下一个yield, 给上一个yield位置传值

所有的生成器都是迭代器都可以直接使用for循环
都可以使用list()函数来获取到生成器内所有的数据

生成器中记录的是代码而不是函数的运行
def func():
print("我的天哪 ")

yield "宝宝"

gen = func() # 创建生成器. 此时运行会把生成器函数中的代码记录在内存
当执行到__next__(), 运行此空间中的代码, 运行到yield结束.

优点: 节省内存, 生成器本身就是代码. 几乎不占用内存
特点: 惰性机制, 只能向前. 不能反复

# def func():
#     print("我叫周润发")
#     return "林志玲"   # return在函数中表示返回的意思
#
#
# ret = func()
# print("返回值是", ret)

# 函数中包含了yield, 此函数就是生成器函数
# 大坑: 生成器函数运行之后. 产生一个生成器. 而不是运行函数
# def func():
#     print("我叫周润发")
#     yield "林志玲"   # yield表示返回. 不会终止函数的执行
#     print("宝宝干嘛去了??")
#     yield "宝宝回来了"
#     print("宝宝你在干嘛?")
#     # yield "没了"
#
# ret = func() # 执行函数, 此时没有运行函数.
# # # 此时我们拿到的是生成器
# # print("返回值是", ret) # <generator生成器 object func at 0x0000000009E573B8>
#
# # 执行到下一个yield
# print(ret.__next__()) # 第一次执行__next__此时函数才开始执行
# print(ret.__next__()) # 执行到下一个yield
# print(ret.__next__()) # StopIteration

# 买衣服, JACK JONES  10000
# def buy():
#     lst = []
#     for i in range(10000):
#         lst.append("衣服%s" % i)
#     return lst
#
# lst = buy()
# print(lst)

# def buy():
#     for i in range(10000):
#         yield "衣服%s" % i
#
# gen = buy() # 生成器或者迭代器的好处: 节省内存
# # print(gen.__next__())
# # print(gen.__next__())
# # print(gen.__next__())
#
# # for yifu in gen: 迭代器. __next__()
# #     print(yifu)
#
# lst = list(gen) # 内部使用的是for循环  -> __next__()
# print(lst)

# send() -> __next__()
# send()可以给上一个yield位置传值

# def func():
#     print("韭菜盒子")
#     a = yield "韭菜鸡蛋"
#     print("a", a)
#     b = yield "韭菜西红柿"
#     print("b", b)
#     c = yield "火烧"
#     print("c", c)
#
# gen = func()
#
# print(gen.__next__()) # 第一个位置用send没有任何意义
# print(gen.send("篮球")) # 给上一个yield位置传值
# print(gen.send("足球"))

# def eat():
#      print("我吃什么啊")
#      a = yield "馒头"
#      print("a=",a)
#      b = yield "?饼"
#      print("b=",b)
#      c = yield "?菜盒?"
#      print("c=",c)
#      yield "GAME OVER"
#
# gen = eat() # 获取?成器
#
# ret1 = gen.__next__()
# print(ret1)
# ret2 = gen.send("胡辣汤")
# print(ret2)
# ret3 = gen.send("狗粮")
# print(ret3)
# ret4 = gen.send("猫粮")
# print(ret4)

  

原文地址:https://www.cnblogs.com/YangWenYu-6/p/10105564.html

时间: 2024-10-14 02:04:55

生成器 生成器函数的相关文章

Python 进阶_生成器 &amp; 生成器表达式

目录 目录 相关知识点 生成器 生成器 fab 的执行过程 生成器和迭代器的区别 生成器的优势 加强的生成器特性 生成器表达式 生成器表达式样例 小结 相关知识点 Python 进阶_迭代器 & 列表解析 生成器 带有 yield 关键字的的函数在 Python 中被称之为 generator(生成器).Python 解释器会将带有 yield 关键字的函数视为一个 generator 来处理.一个函数或者子程序都只能 return 一次,但是一个生成器能暂停执行并返回一个中间的结果 -- 这就

【Python 生成器 匿名函数 递归 模块及包的导入 正则re】

一.生成器 1.定义 生成器(generator)是一个特殊的迭代器,它的实现更简单优雅,yield是生成器实现__next__()方法的关键.它作为生成器执行的暂停恢复点,可以对yield表达式进行赋值,也可以将yield表达式的值返回. 也就是说,yield是一个语法糖,内部实现支持了迭代器协议,同时yield内部是一个状态机,维护着挂起和继续的状态. yield的功能: 1.相当于为函数封装好__iter__和__next__ 2.return只能返回一次值,函数就终止了,而yield能返

python开发函数进阶:可迭代的&amp;迭代器&amp;生成器

一,可迭代的&可迭代对象 1.一个一个的取值就是可迭代的   iterable#str list tuple set dict#可迭代的 --对应的标志 __iter__ 2.判断一个变量是不是一个可迭代的 # print('__iter__' in dir(list))# print('__iter__' in dir([1,2,3])) 3.可迭代协议--凡是可迭代的内部都有一个__iter__方法 二,迭代器 1.将可迭代的转化成迭代器 1 #!/usr/bin/env python 2

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

【函数】02、匿名函数、生成器、高阶函数

一.匿名函数 1.定义 语法格式: lambda args:expression args:以逗号分隔的参数列表 expression:用到args中各参数的表达式 lambda定义的代码必须是合法的表达式,不能出现多条件语句(可使用if的三元表达式)和非表达式,如for和while等 lambda的首要用途是指定短小的回调函数 lambda将返回一个函数而不是将函数赋值给某变量名 In [77]: lambda x: x+1 Out[77]: <function __main__.<lamb

&lt;04day&gt;_函数嵌套--闭包函数--装饰器--迭代器--生成器

一.函数的嵌套定义 1.python函数支持嵌套 def f1(): #f1函数的定义 def f2(): #f2函数的定义 print('from f2') def f3(): #f3函数的定义 print('from f3') f2() f1() 嵌套函数--运行结果说明: 1首先调用f1()结果,f1函数为空.担保函f2函数,f2函数有内容打印并且有调用,f2函数包含f3函数,但f3函数无调用. 运行结果: 列子:多个数据之间的大小比较. #!/usr/bin/python # -*- c

python函数、装饰器、迭代器、生成器

5月21日,请假结婚,然后性格惰性来了,不怎么想看视频和笔记,性格中的弱点开始出现,开始做的不错,渐渐开始松懈,直至放弃--- 函数补充进阶 函数对象 函数的嵌套 名称空间与作用域 闭包函数 函数之装饰器 函数之迭代器 函数之生成器 内置函数 一.函数补充进阶 1.函数对象:  函数是第一类对象,即函数可以当作数据传递,它的应用形式也被称为高阶函数,函数的特性如下: a. 可以被引用 1 # def foo(): 2 # print('from foo') 3 # 4 # func = foo

装饰器、生成器、迭代器、及python中内置函数的使用

一. 装饰器 1. 装饰器的概述 (1)概述:装饰器本质就是函数,主要用来装饰其他函数,为其他函数添加附加功能. (2)使用装饰器的原则 1)不能修改被装饰的函数的源代码 2)不能修改被装饰的函数的调用方式 (3)装饰器原理:函数即"变量".高阶函数.嵌套函数 2.使用装饰器的原因 (1)传统的多个函数模块修改需要同时修改多个函数.如果函数过多,则修改不方便. 如下,如果想要在每个函数中开头结尾分别输入内容,则需要在每个函数开头结尾加入需要输出的内容. def f1():     pr

python函数递归和生成器

一.什么是递归 如果函数包含了对其自身的调用,该函数就是递归的.递归做为一种算法在程序设计语言中广泛应用,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量.例如,要计算1-9的9位数字的乘积,直观的算法是1*2*3*4*5*6*7*8*9,如果要计算1-10000的乘积,直观的算法就难于实现出,而递归就可以很简单的实现.请看示例: 1 def fact(n):#计算给定数字到一的乘积