yield 订阅
Yield的功能将控制权转移给其它图形对象,包括非PowerBuilder对象。该函数检测消息队列,如果有消息,就把消息取出。利用该函数可以在执行耗时较长的操作时把控制权转让给其它应用。 展开全文
Yield的功能将控制权转移给其它图形对象,包括非PowerBuilder对象。该函数检测消息队列,如果有消息,就把消息取出。利用该函数可以在执行耗时较长的操作时把控制权转让给其它应用。
信息
形    式
yield return ;
外文名
Yield
返回值
Boolean
在 iterator 
用作方法、运算符或访问器的体
Yield语法
Yield()Boolean返回值。如果在消息队列中提取到了消息,那么函数返回TRUE,否则返回FALSE。用法正常情况下,PowerBuilder应用程序在执行一段代码(比如函数或事件处理程序)的过程中不响应用户的操作。对耗时短暂的代码段来说,这种处理方式没有什么不妥的地方,但是,如果某个代码段的执行耗时较长,应用程序又希望为用户提供更多的控制权,那么需要在这段代码中插入Yield()函数,让用户能够进行其它操作,特别在循环执行的代码中更应该如此。应用程序执行Yield()函数后,如果发现消息队列中存在消息,它将允许对象处理这些消息,处理之后,继续Yield()函数后面代码的执行。因此,代码中插入Yield()函数将降低应用程序的运行效率。---------------------------------------------------------------------------------------------------------------------------------------------------------yield(C# 参考)在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。它的形式为下列之一:yield return ;yield break;备注 :计算表达式并以枚举数对象值的形式返回;expression 必须可以隐式转换为迭代器的 yield 类型。yield 语句只能出现在 iterator 块中,该块可用作方法、运算符或访问器的体。这类方法、运算符或访问器的体受以下约束的控制:不允许不安全块。方法、运算符或访问器的参数不能是 ref 或 out。yield 语句不能出现在匿名方法中。当和 expression 一起使用时,yield return 语句不能出现在 catch 块中或含有一个或多个 catch 子句的 try 块中。在下面的示例中,迭代器块(这里是方法 Power(int number,int power))中使用了 yield 语句。当调用 Power 方法时,它返回一个包含数字幂的可枚举对象。注意 Power 方法的返回类型是 IEnumerable(一种迭代器接口类型)。
收起全文
精华内容
下载资源
问答
  • python中yield的用法详解——最简单,最清晰的解释

    万次阅读 多人点赞 2019-04-02 13:29:31
    首先我要吐槽一下,看程序的过程中遇见了yield这个关键字,然后百度的时候,发现没有一个能简单的让我懂的,讲起来真TM的都是头头是道,什么参数,什么传递的,还口口声声说自己的教程是最简单的,最浅显易懂的,我...

    首先我要吐槽一下,看程序的过程中遇见了yield这个关键字,然后百度的时候,发现没有一个能简单的让我懂的,讲起来真TM的都是头头是道,什么参数,什么传递的,还口口声声说自己的教程是最简单的,最浅显易懂的,我就想问没有有考虑过读者的感受。

    接下来是正题:

    首先,如果你还没有对yield有个初步分认识,那么你先把yield看做“return”,这个是直观的,它首先是个return,普通的return是什么意思,就是在程序中返回某个值,返回之后程序就不再往下运行了。看做return之后再把它看做一个是生成器(generator)的一部分(带yield的函数才是真正的迭代器),好了,如果你对这些不明白的话,那先把yield看做return,然后直接看下面的程序,你就会明白yield的全部意思了:

    def foo():
        print("starting...")
        while True:
            res = yield 4
            print("res:",res)
    g = foo()
    print(next(g))
    print("*"*20)
    print(next(g))

    就这么简单的几行代码就让你明白什么是yield,代码的输出这个:

    starting...
    4
    ********************
    res: None
    4

    我直接解释代码运行顺序,相当于代码单步调试:

    1.程序开始执行以后,因为foo函数中有yield关键字,所以foo函数并不会真的执行,而是先得到一个生成器g(相当于一个对象)

    2.直到调用next方法,foo函数正式开始执行,先执行foo函数中的print方法,然后进入while循环

    3.程序遇到yield关键字,然后把yield想想成return,return了一个4之后,程序停止,并没有执行赋值给res操作,此时next(g)语句执行完成,所以输出的前两行(第一个是while上面的print的结果,第二个是return出的结果)是执行print(next(g))的结果,

    4.程序执行print("*"*20),输出20个*

    5.又开始执行下面的print(next(g)),这个时候和上面那个差不多,不过不同的是,这个时候是从刚才那个next程序停止的地方开始执行的,也就是要执行res的赋值操作,这时候要注意,这个时候赋值操作的右边是没有值的(因为刚才那个是return出去了,并没有给赋值操作的左边传参数),所以这个时候res赋值是None,所以接着下面的输出就是res:None,

    6.程序会继续在while里执行,又一次碰到yield,这个时候同样return 出4,然后程序停止,print函数输出的4就是这次return出的4.

     

    到这里你可能就明白yield和return的关系和区别了,带yield的函数是一个生成器,而不是一个函数了,这个生成器有一个函数就是next函数,next就相当于“下一步”生成哪个数,这一次的next开始的地方是接着上一次的next停止的地方执行的,所以调用next的时候,生成器并不会从foo函数的开始执行,只是接着上一步停止的地方开始,然后遇到yield后,return出要生成的数,此步就结束。

    ****************************************************************************************************************************************

    def foo():
        print("starting...")
        while True:
            res = yield 4
            print("res:",res)
    g = foo()
    print(next(g))
    print("*"*20)
    print(g.send(7))

    再看一个这个生成器的send函数的例子,这个例子就把上面那个例子的最后一行换掉了,输出结果:

    starting...
    4
    ********************
    res: 7
    4

    先大致说一下send函数的概念:此时你应该注意到上面那个的紫色的字,还有上面那个res的值为什么是None,这个变成了7,到底为什么,这是因为,send是发送一个参数给res的,因为上面讲到,return的时候,并没有把4赋值给res,下次执行的时候只好继续执行赋值操作,只好赋值为None了,而如果用send的话,开始执行的时候,先接着上一次(return 4之后)执行,先把7赋值给了res,然后执行next的作用,遇见下一回的yield,return出结果后结束。

     

    5.程序执行g.send(7),程序会从yield关键字那一行继续向下运行,send会把7这个值赋值给res变量

    6.由于send方法中包含next()方法,所以程序会继续向下运行执行print方法,然后再次进入while循环

    7.程序执行再次遇到yield关键字,yield会返回后面的值后,程序再次暂停,直到再次调用next方法或send方法。

     

     

     

    这就结束了,说一下,为什么用这个生成器,是因为如果用List的话,会占用更大的空间,比如说取0,1,2,3,4,5,6............1000

    你可能会这样:

    for n in range(1000):
        a=n

    这个时候range(1000)就默认生成一个含有1000个数的list了,所以很占内存。

    这个时候你可以用刚才的yield组合成生成器进行实现,也可以用xrange(1000)这个生成器实现

    yield组合:

    def foo(num):
        print("starting...")
        while num<10:
            num=num+1
            yield num
    for n in foo(0):
        print(n)

    输出:

    starting...
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

     xrange(1000):

    for n in xrange(1000):
        a=n

     其中要注意的是python3时已经没有xrange()了,在python3中,range()就是xrange()了,你可以在python3中查看range()的类型,它已经是个<class 'range'>了,而不是一个list了,毕竟这个是需要优化的。 

                                                                                                     谢谢大家

    如果你感觉对你有帮助,你的赞赏是对我最大的支持!

    展开全文
  • yield

    2019-11-22 15:58:45
    yield功能: 1) 类似return作用, 返回值 2) 暂停迭代,直到调用下一个next()方法 3) 函数调用时返回生成器对象 一句话: 带有yield的函数是生成器,生成器是迭代器.生成器的生成和函数的调用差不多,但是只有对生成器...

    yield功能:

    1) 类似return作用, 返回值

    2) 暂停迭代,直到调用下一个next()方法

    3) 函数调用时返回生成器对象

    一句话: 带有yield的函数是生成器,生成器是迭代器.生成器的生成和函数的调用差不多,但是只有对生成器使用next()方法时,代码才会执行.在执行的过程中,每遇到yield语句就发生中断, 并返回一个迭代值. 下次执行时从yield的下一个语句开始.看起来就像函数执行过程中被yield中断了很多次,每次中断通过yield返回当前迭代值.

    实例:

    可以看到,我们生成了生成器,并使用next()方法来调用生成器.函数在初次运行遇到yield语句产生了中断,并返回当前迭代值6.

    当我们再次使用next()方法调用生成器时,函数在yield中断的的下一句继续执行,即res的赋值语句,因为6已经被yield返回了,所以res的赋值为none.函数再次遇到yield语句时发生中断并返回当前迭代值6.

    注意: 在for循环里面会自动调用next()

    使用yield来读取文件的方法:

    直接对文件对象调用read()方法,会导致不可预测的内存占用. 比较好的方法是使用固定长度的缓冲区来读取文件的内容.

     

     

    展开全文
  • yieldyield*

    千次阅读 2019-11-08 15:44:57
    yield yield 关键字用来暂停和恢复一个生成器函数(function*) 举例: function* gen(index) { while (index < 2) { yield index++; } } const iterator = gen(0); console.log(iterator.next().value); ...

    yield

    yield 关键字用来暂停和恢复一个生成器函数(function*

    举例:

    function* gen(index) {
        while (index < 2) {
            yield index++;
        }
    }
    
    const iterator = gen(0);
    
    console.log(iterator.next().value);
    console.log(iterator.next().value);
    console.log(iterator.next().value);
    // 0
    // 1
    // undefined
    

    语法:

    [rv] = yield [expression];
    
    • expression:从生成器函数中返回的值。如果省略,则返回undefined
    • rv:检索传递给生成器的next()方法的可选值,以恢复其执行。

    yield关键字使 生成器函数 暂停执行,yield关键字后面的表达式的值 返回给生成器的调用者。可以理解成是一个基于生成器的版本的return关键字。(It can be thought of as a generator-based version of the return keyword.)

    yield只能从直接包含它的生成器函数中调用。不能从嵌套函数或回调中调用它。

    yield关键字会导致对生成器的next()方法的调用,这个方法会返回具有两个属性valuedone的IteratorResult对象。value属性是对yield后面跟的表达式求值的结果,当done值为false时,表示生成器函数尚未完全完成。

    一旦遇到 yield 表达式,生成器的代码执行就会暂停,直到生成器的 next() 方法再次被调用。每次调用生成器的next()方法时,生成器都会恢复执行,直到遇到以下情况:

    • yield,遇到yield导致生成器再次暂停执行并返回生成器的新值。 下一次调用next()方法时,在yield之后紧接着的语句将继续执行。
    • **throw **,用于从生成器中抛出异常。它完全停止了生成器的执行。当异常抛出时,通常情况下,在调用者中恢复执行。
    • 生成器函数迭代完毕,在这种情况下,生成器执行结束,并且IteratorResult给调用者返回value属性的值是undefineddone属性为true
    • 遇到 return 语句。在这种情况下,生成器执行结束,并将IteratorResult返回给调用者,其value属性的值是return语句后面表达式的值的,done属性 为true

    如果给生成器中的next()方法传递参数,则该值将成为生成器当前yield操作返回的值。

    在整个生成器代码运行中,yield操作符,以及向Generator.prototype.next()方法中传递一个参数指定起始值,生成器提供了强大的控制作用。。。

    举例:
    下面的代码声明了一个 生成器函数

    function* countName(){
        let name = ['happy','chen','666'];
        for (let i = 0; i < name.length; i++) {
            yield name[i];
        }
    }
    

    一旦生成器函数已定义,可以通过构造一个迭代器来使用它:

    function* countName(){
        let name = ['happy','chen','666'];
        for (let i = 0; i < name.length; i++) {
            yield name[i];
        }
    }
    
    let nameIterator = countName();
    console.log(nameIterator.next());
    console.log(nameIterator.next());
    console.log(nameIterator.next());
    console.log(nameIterator.next());
    // { value: 'happy', done: false }
    // { value: 'chen', done: false }
    // { value: '666', done: false }
    // { value: undefined, done: true }
    

    yield*

    yield* 表达式用于委托给另一个generator 或可迭代对象。

    语法:

     yield* [[expression]];
    
    • expression:返回一个可迭代对象的表达式。

    yield* 表达式迭代操作数,并产生它返回的每个值。yield* 表达式本身的值是当迭代器关闭时返回的值(即done为true时)。

    举例:

    委托给其他生成器

    以下代码中,g1() yield 出去的每个值都会在 g2() 的 next() 方法中返回,就像那些 yield 语句是写在 g2() 里一样。(values yielded by g1() are returned from next() calls just like those which are yielded by g2().)

    function* g1() {
        yield 2;
        yield 3;
        yield 4;
    }
    
    function* g2() {
        yield 1;
        yield* g1();
        yield 5;
    }
    
    let iterator = g2();
    
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    // { value: 1, done: false }
    // { value: 2, done: false }
    // { value: 3, done: false }
    // { value: 4, done: false }
    // { value: 5, done: false }
    // { value: undefined, done: true }
    

    委托给其他可迭代对象

    除了生成器对象这一种可迭代对象,yield* 还可以 yield 其它任意的可迭代对象,比如说数组、字符串、arguments 对象等等。(Besides generator objects, yield* can also yield other kinds of iterables, e.g. arrays, strings or arguments objects.)

    function* g3() {
        yield* ['happy', 'chen'];
        yield* 'is';
        yield* Array.from(arguments);
    }
    
    let iterator = g3('a', 'Front-end', 'development', 'engineer');
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    // { value: 'happy', done: false }
    // { value: 'chen', done: false }
    // { value: 'i', done: false }
    // { value: 's', done: false }
    // { value: 'a', done: false }
    // { value: 'Front-end', done: false }
    // { value: 'development', done: false }
    // { value: 'engineer', done: false }
    // { value: undefined, done: true }
    

    yield* 表达式的值

    yield 是一个表达式*,不是语句,所以它会有自己的值

    function* g4(){
        yield* [5,2,0];
        return '可达鸭';
    }
    
    let result;
    
    function* g5(){
        result = yield* g4();
    }
    
    let iterator = g5();
    
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    console.log(iterator.next());
    
    console.log(result);
    // { value: 5, done: false }
    // { value: 2, done: false }
    // { value: 0, done: false }
    // { value: undefined, done: true }
    
    // 可达鸭
    
    
    展开全文
  • yieldyield from

    2018-10-04 18:13:00
    yieldyield from yield 通过yield返回的是一个生成器,yield既可以产出值又可以生成值,yield可以用next()来启动生成器,同时可以用send向生成器传递值;在初次启动生成器时,需调用next()或send...

    yield与yield from

    yield

     通过yield返回的是一个生成器,yield既可以产出值又可以生成值,yield可以用next()来启动生成器,同时可以用send向生成器传递值;在初次启动生成器时,需调用next()或send(None)来激活生成器,一个yield对应一个send或next(),当send或next()个数超过yield个数时,会抛出StopIteration

     1 def gen_yield():
     2     value = yield 1
     3     print(value)
     4     value = yield 2
     5     print(value)
     6     value = yield 3
     7     print(value)
     8     return "end"
     9 
    10 
    11 gen = gen_yield()
    12 
    13 print(next(gen))
    14 print(gen.send("a"))
    15 print(gen.send("b"))
    16 print(gen.send("c"))

     next(gen)激活生成器yield 1,返回1,并将生成器挂起;gen.send("a")会将"a"传递给value = yield 1,此时value="a",打印出a,返回2,将生成器挂起;gen.send("b")将"b"传递给value = yield 2,此时value="b",打印"b"并返回3,将生成器挂起;gen.send("c")将"c"传递给value = yield 3,此时value="c",打印"c",由于后面没有生成器了,会抛出StopIteration异常。

    1
    a
    2
    b
    3
    c
    Traceback (most recent call last):
        print(gen.send("c"))
    StopIteration: end

     

    close()/throw() 关闭/暂停 生成器

     1 def gen_yield():
     2     try:
     3         yield "a"
     4     except StopIteration:
     5         pass
     6     yield "b"
     7     yield "c"
     8     return "end"
     9 
    10 
    11 gen = gen_yield()
    12 
    13 print(next(gen))
    14 gen.close()
    15 print(111)
    16 print(next(gen))

    close()是关闭生成器,当生成器执行了close()方法后,即使做了异常处理,与yield相关的语句不会再执行。

    throw()相当于中断、暂停生成器,通过throw()抛出异常后,当异常处理后生成器会执行下一个yield,下一个yield之后的上长期不再受throw()影响。

     1 def gen_yield():
     2     try:
     3         yield "a"
     4     except Exception:
     5         pass
     6     yield "b"
     7     yield "c"
     8     return "end"
     9 
    10 
    11 gen = gen_yield()
    12 
    13 print(next(gen))
    14 print(gen.throw(Exception))
    15 print(111)
    16 print(next(gen))

    result:

    a
    b
    111
    c

     

    yield from

     yield from类似于yield,但yield from后面必须接一个可迭代的对象,返回该迭代对象的iter,yield则直接返回接受的对象

    def gen_yield(iterable):
        yield iterable
    
    
    def gen_yield_from(iterable):
        yield from iterable
    
    
    for value in gen_yield([1, 2, 3]):
        print("yield:{}".format(value))
    for value in gen_yield_from([1, 2, 3]):
        print("yield from:{}".format(value))
    result:
    yield
    :[1, 2, 3] yield from:1 yield from:2 yield from:3

    yield from会在调用方与子生成器之间建立双向通道,即yield from后可以接受一个生成器函数,调用方通过send可以直接传递数据给子生成器,同时yield from可以接受子生成器返回的数据

     1 def gen_yield():
     2     """
     3     子生成器
     4     :return: 
     5     """
     6     nums = []
     7     i = 1
     8     while i < 4:
     9         n = yield i
    10         print("receive {}".format(n))
    11         i += 1
    12         nums.append(n)
    13     return nums
    14 
    15 
    16 def gen_yield_from():
    17     val = yield from gen_yield()
    18     return val
    19 
    20 
    21 gen_value_list = [100, 200, 300]
    22 # 调用方
    23 gen = gen_yield_from()
    24 # send(None) 激活生成器
    25 print("yield return {}".format(gen.send(None)))
    26 j = 0
    27 while j < 3:
    28     try:
    29         print("yield return {}".format(gen.send(gen_value_list[j])))
    30     except StopIteration as e:
    31         print(e)
    32     j += 1
    gen激活生成器后会通过send发送数据,数据会直接传递给子生成器gen_yield
    执行结果
    yield return 1
    receive 100
    yield return 2
    receive 200
    yield return 3
    receive 300
    [100, 200, 300]
    posted @ 2018-10-04 18:13 Harvard_Fly 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • JS_Yield JS yield原始学习
  • yieldyield from

    千次阅读 2019-12-01 23:14:04
    yield 带有 yield 的函数不再是一个普通函数,而是一个生成器generator 把生成器当作管道 def add_A(seq): for item in seq: yield item + '-A' def add_B(seq): for item in seq: yield item + '-B' def ...
  • yieldyield from

    2018-02-26 15:23:00
    yieldyield from 1、yield使用 1)函数中使用yield,可以使函数变成生成器。一个函数如果是生成一个数组,就必须把数据存储在内存中,如果使用生成器,则在调用的时候才生成数据,可以节省...
  • yield关键字

    2020-12-28 15:31:16
    MDN关于yield关键字的解释: Theyieldkeyword is used to pause and resume a generator function (function*orlegacy generator function).
 // yield关键字用来暂停和恢复一个生成器函数((function*或遗留的...
  • yield return 和 yield break

    2019-09-24 16:19:36
    //yield return返回类型必须为IEnumerable、IEnumerable<T>、IEnumerator或IEnumerator<T>。 static IEnumerator<int> yieldTest() //yield return 返回IEnumerator { yield ret...
  • 姓名:曾国强学号:19021210984转载自https://blog.csdn.net/qq_27825451/article/details/85244237【嵌牛导读】【嵌牛正文】一...yield from 是yield的升级改进版本,如果将yield理解成“返回”,那么yield from就...
  • yieldyield * 的区别

    2019-09-28 17:33:39
    yield表达式的值,是下一个iter.next的参数值 yield*表达式的值,是yield*后的iterable在done为true时的value值。 yield * 的使用: function* outer() { yield 'open' yield inner() yield 'close'}...
  • 参考文献:Python中的yield - CSDN博客一、生成器generator1.列表:mylist 2.生成器mygen两者区别:列表是[],生成器是()二、生成器用法mygen三、yield的注意点1.当函数含有yield,会被系统默认为是一个生成器2.执行...
  • yield含义

    2020-02-27 17:32:49
    1.带有 yield 的函数不再是一个普通函数,而是一个生成器generator,可用于迭代,工作原理同上。 2.yield 是一个类似 return 的关键字,迭代一次遇到yield时就返回yield后面的值。重点是:下一次迭代时,从上一次...
  • yield return 和yield break

    2019-10-04 11:56:55
    1.return 会销毁函数的局部变量,下次调用的时候又会产生新的值 2.yield 当退出函数的时候,变量人然存在,函数下次调用的时候变量仍然存在。 "yield break"用来表明迭代结束,跳出迭代 反对 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,432
精华内容 14,172
热门标签
关键字:

yield