python协程--yield和yield from

news2025/1/14 18:16:48

字典为动词“to yield”给出了两个释义：产出和让步。对于 Python 生成器中的 yield 来说，这两个含义都成立。yield item 这行代码会产出一个值，提供给 next(...) 的调用方；此外，还会作出让步，暂停执行生成器，让调用方继续工作，直到需要使用另一个值时再调用 next()。调用方会从生成器中拉取值。

从句法上看，协程与生成器类似，都是定义体中包含 yield 关键字的函数。可是，在协程中，yield 通常出现在表达式的右边（例如，datum = yield），可以产出值，也可以不产出----yield 关键字后面没有表达式。协程可能会从调用方接收数据，调用方使用 .send(datum) 方法把数据提供给协程。

一：生成器如何进化成协程

自python中加入yield关键字后，又经过了一系列的演化：

yield 关键字可以在表达式中使用（a = yield b）；

生成器 API 中增加了.send(value) 方法（生成器的调用方可以使用 .send(...) 方法发送数据，发送的数据会成为生成器函数中 yield 表达式的值）；

PEP 342 添加了 .throw(...) 和 .close() 方法（前者的作用是让调用方抛出异常，在生成器中处理；后者的作用是终止生成器）；

因此，生成器可以作为协程使用。协程是指一个过程，这个过程与调用方协作，产出由调用方提供的值。

协程最近的演进来自 Python 3.3实现的“PEP 380—Syntax for Delegating to a Subgenerator”（https://www.python.org/dev/peps/pep-0380/）。PEP 380 对生成器函数的句法做了两处改动：

生成器可以返回一个值；以前如果在生成器中给 return 语句提供值，会抛出 SyntaxError 异常；

新引入了 yield from 句法，使用它可以把复杂的生成器重构成小型的嵌套生成器，省去了之前把生成器的工作委托给子生成器所需的大量样板代码。

二：用作协程的生成器的基本行为

协程可以身处四个状态中的一个。当前状态可以使用inspect.getgeneratorstate(...) 函数确定，该函数会返回下述字符串中的一个。

GEN_CREATED：等待开始执行；

GEN_RUNNING：解释器正在执行（只有在多线程应用中才能看到这个状态）；

GEN_SUSPENDED：在 yield 表达式处暂停；

GEN_CLOSED：执行结束；

         一个简单的例子如下；

>>> def simple_coro2(a):
...     print('-> Started: a =', a)
...     b = yield a
...     print('-> Received: b =', b)
...     c = yield a + b
...     print('-> Received: c =', c)
...
>>> my_coro2 = simple_coro2(14)
>>> from inspect import getgeneratorstate
>>> getgeneratorstate(my_coro2)
'GEN_CREATED'
>>> next(my_coro2)
-> Started: a = 14
14
>>> getgeneratorstate(my_coro2)
'GEN_SUSPENDED'
>>> my_coro2.send(28)
-> Received: b = 28
42
>>> my_coro2.send(99)
-> Received: c = 99
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> getgeneratorstate(my_coro2)
'GEN_CLOSED' 

最先调用 next(my_coro2) 函数这一步通常称为“预激”（prime）协程（即，让协程向前执行到第一个 yield 表达式，准备好作为活跃的协程使用）。

关键的一点是，协程在 yield 关键字所在的位置暂停执行。在赋值语句中，=右边的代码在赋值之前执行。因此，对于 b = yield a 这行代码来说，等到客户端代码再激活协程时才会设定 b 的值。

simple_coro2 协程的执行过程分为 3 个阶段，如下图所示：

 

三：使用协程计算移动平均值

下面是一个计算移动平均值的协程：

def averager():
    total = 0.0
    count = 0
    average = None
    while True:
        term = yield average
        total += term
        count += 1
        average = total/count

>>> coro_avg = averager()
>>> next(coro_avg)   #调用 next 函数，预激协程
>>> coro_avg.send(10)
10.0
>>> coro_avg.send(30)
20.0
>>> coro_avg.send(5)
15.0

这个无限循环表明，只要调用方不断把值发给这个协程，它就会一直接收值，然后生成结果。仅当调用方在协程上调用 .close() 方法，或者没有对协程的引用而被垃圾回收程序回收时，这个协程才会终止。

调用 next(coro_avg) 函数后，协程会向前执行到yield 表达式，产出 average 变量的初始值——None，因此不会出现在控制台中。此时，协程在 yield 表达式处暂停，等到调用方发送值。coro_avg.send(10) 那一行发送一个值，激活协程，把发送的值赋给 term，并更新 total、count 和 average 三个变量的值，然后开始 while 循环的下一次迭代，产出 average 变量的值，等待下一次为term 变量赋值。

四：预激协程的装饰器

如果不预激，那么协程没什么用。调用 my_coro.send(x) 之前，记住一定要调用next(my_coro)。为了简化协程的用法，有时会使用一个预激装饰器。

下面就是一个预激装饰器的例子（Python3）：

from functools import wraps

def coroutine(func):
    @wraps(func)
    def primer(*args,**kwargs):
        gen = func(*args,**kwargs)
        next(gen)
        return gen
    return primer    

@coroutine
def averager2():
    total = 0.0
    count = 0
    average = None
    while True:
        term = yield average
        total += term
        count += 1
        average = total/count

>>> coro_avg = averager()
>>> from inspect import getgeneratorstate
>>> getgeneratorstate(coro_avg)
'GEN_SUSPENDED'
>>> coro_avg.send(10)
10.0
>>> coro_avg.send(30)
20.0
>>> coro_avg.send(5)
15.0

注意，使用 yield from 句法调用协程时，会自动预激。

五：终止协程和异常处理

协程中未处理的异常会向上冒泡，传给 next 函数或 send 方法的调用方（即触发协程的对象）。

>>> from coroaverager1 import averager
>>> coro_avg = averager()
>>> coro_avg.send(40)
40.0
>>> coro_avg.send(50)
45.0
>>> coro_avg.send('spam')
Traceback (most recent call last):
...
TypeError: unsupported operand type(s) for +=: 'float' and 'str'
>>> coro_avg.send(60)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

由于在协程内没有处理异常，协程会终止。如果试图重新激活协程，会抛出StopIteration 异常。

从 Python 2.5 开始，客户代码可以在生成器对象上调用两个方法：throw 和 close，显式地把异常发给协程。

1：generator.throw(exc_type[, exc_value[, traceback]])

使生成器在暂停的 yield 表达式处抛出指定的异常。如果生成器处理了抛出的异常，代码会向前执行到下一个 yield 表达式，而产出的值会成为调用 generator.throw方法得到的返回值。如果生成器没有处理抛出的异常，异常会向上冒泡，传到调用方的上下文中。

         2：generator.close()

使生成器在暂停的 yield 表达式处抛出 GeneratorExit 异常。如果生成器没有处理这个异常，或者抛出了 StopIteration 异常（通常是指运行到结尾），调用方不会报错。如果收到 GeneratorExit 异常，生成器一定不能产出值，否则解释器会抛出RuntimeError 异常。生成器抛出的其他异常会向上冒泡，传给调用方。

         示例如下：

class DemoException(Exception):
    """为这次演示定义的异常类型。"""
    
def demo_exc_handling():
    print('-> coroutine started')
    while True:
        try:
            x = yield
        except DemoException:
            print('*** DemoException handled. Continuing...')
        else:
            print('-> coroutine received: {!r}'.format(x))
    raise RuntimeError('This line should never run.')
    
>>> exc_coro = demo_exc_handling()
>>> next(exc_coro)
-> coroutine started
>>> exc_coro.send(11)
-> coroutine received: 11
>>> exc_coro.send(22)
-> coroutine received: 22

>>> exc_coro.throw(DemoException)
*** DemoException handled. Continuing...
>>> getgeneratorstate(exc_coro)
'GEN_SUSPENDED'

>>> exc_coro.close()
>>> from inspect import getgeneratorstate
>>> getgeneratorstate(exc_coro)
'GEN_CLOSED'

六：让协程返回值

在Python2中，生成器函数中的return不允许返回附带返回值。在Python3中取消了这一限制，因而允许协程可以返回值：

from collections import namedtuple
Result = namedtuple('Result', 'count average')

def averager():
    total = 0.0
    count = 0
    average = None
    while True:
        term = yield
        if term is None:
            break
        total += term
        count += 1
        average = total/count
    return Result(count, average)
    
>>> coro_avg = averager()
>>> next(coro_avg)
>>> coro_avg.send(10)
>>> coro_avg.send(30)
>>> coro_avg.send(6.5)
>>> coro_avg.send(None)
Traceback (most recent call last):
...
StopIteration: Result(count=3, average=15.5)

发送 None 会终止循环，导致协程结束，返回结果。一如既往，生成器对象会抛出StopIteration 异常。异常对象的 value 属性保存着返回的值。

注意，return 表达式的值会偷偷传给调用方，赋值给 StopIteration 异常的一个属性。这样做有点不合常理，但是能保留生成器对象的常规行为——耗尽时抛出StopIteration 异常。如果需要接收返回值，可以这样：

>>> try:
...    coro_avg.send(None)
... except StopIteration as exc:
...    result = exc.value
...
>>> result
Result(count=3, average=15.5)

获取协程的返回值要绕个圈子，可以使用Python3.3引入的yield from获取返回值。yield from 结构会在内部自动捕获 StopIteration 异常。这种处理方式与 for 循环处理 StopIteration 异常的方式一样。对 yield from 结构来说，解释器不仅会捕获 StopIteration 异常，还会把value 属性的值变成 yield from 表达式的值。

七：使用yield from

yield from 是 Python3.3 后新加的语言结构。在其他语言中，类似的结构使用 await 关键字，这个名称好多了，因为它传达了至关重要的一点：在生成器 gen 中使用 yield from subgen() 时，subgen 会获得控制权，把产出的值传给 gen 的调用方，即调用方可以直接控制 subgen。与此同时，gen 会阻塞，等待 subgen 终止。

yield from 可用于简化 for 循环中的 yield 表达式。例如：

>>> def gen():
... for c in 'AB':
...     yield c
... for i in range(1, 3):
...     yield i
...
>>> list(gen())
['A', 'B', 1, 2]

可以改为

>>> def gen():
...     yield from 'AB'
...     yield from range(1, 3)
...
>>> list(gen())
['A', 'B', 1, 2]

yield from x 表达式对 x 对象所做的第一件事是，调用 iter(x)，从中获取迭代器。因此，x 可以是任何可迭代的对象。

如果 yield from 结构唯一的作用是替代产出值的嵌套 for 循环，这个结构很有可能不会添加到 Python 语言中。

yield from 的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来，这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中添加大量处理异常的样板代码。有了这个结构，协程可以通过以前不可能的方式委托职责。

PEP 380 使用了一些yield from使用的专门术语：

委派生成器：包含 yield from <iterable> 表达式的生成器函数；

子生成器：从 yield from 表达式中 <iterable> 部分获取的生成器；

调用方：调用委派生成器的客户端代码；

        

下图是这三者之间的交互关系：

 

委派生成器在 yield from 表达式处暂停时，调用方可以直接把数据发给子生成器，子生成器再把产出的值发给调用方。子生成器返回之后，解释器会抛出StopIteration 异常，并把返回值附加到异常对象上，此时委派生成器会恢复。

         下面是一个求平均身高和体重的示例代码：

from collections import namedtuple

Result = namedtuple('Result', 'count average')

# 子生成器
def averager():
    total = 0.0
    count = 0
    average = None
    while True:
        # main 函数发送数据到这里 
        print("in averager, before yield")
        term = yield
        if term is None: # 终止条件
            break
        total += term
        count += 1
        average = total/count

    print("in averager, return result")
    return Result(count, average) # 返回的Result 会成为grouper函数中yield from表达式的值


# 委派生成器
def grouper(results, key):
     # 这个循环每次都会新建一个averager 实例，每个实例都是作为协程使用的生成器对象
    while True:
        print("in grouper, before yield from averager, key is ", key)
        results[key] = yield from averager()
        print("in grouper, after yield from, key is ", key)


# 调用方
def main(data):
    results = {}
    for key, values in data.items():
        # group 是调用grouper函数得到的生成器对象
        group = grouper(results, key)
        print("\ncreate group: ", group)
        next(group) #预激 group 协程。
        print("pre active group ok")
        for value in values:
            # 把各个value传给grouper 传入的值最终到达averager函数中；
            # grouper并不知道传入的是什么，同时grouper实例在yield from处暂停
            print("send to %r value %f now"%(group, value))
            group.send(value)
        # 把None传入groupper，传入的值最终到达averager函数中，导致当前实例终止。然后继续创建下一个实例。
        # 如果没有group.send(None)，那么averager子生成器永远不会终止，委派生成器也永远不会在此激活，也就不会为result[key]赋值
        print("send to %r none"%group)
        group.send(None)
    print("report result: ")
    report(results)


# 输出报告
def report(results):
    for key, result in sorted(results.items()):
        group, unit = key.split(';')
        print('{:2} {:5} averaging {:.2f}{}'.format(result.count, group, result.average, unit))


data = {
    'girls;kg':[40, 41, 42, 43, 44, 54],
    'girls;m': [1.5, 1.6, 1.8, 1.5, 1.45, 1.6],
    'boys;kg':[50, 51, 62, 53, 54, 54],
    'boys;m': [1.6, 1.8, 1.8, 1.7, 1.55, 1.6],
}

if __name__ == '__main__':
    main(data) 

grouper 发送的每个值都会经由 yield from 处理，通过管道传给 averager 实例。grouper 会在 yield from 表达式处暂停，等待 averager 实例处理客户端发来的值。averager 实例运行完毕后，返回的值绑定到 results[key] 上。while 循环会不断创建 averager 实例，处理更多的值。

外层 for 循环重新迭代时会新建一个 grouper 实例，然后绑定到 group 变量上。前一个 grouper 实例（以及它创建的尚未终止的 averager 子生成器实例）被垃圾回收程序回收。

代码结果如下：

create group:  <generator object grouper at 0x7f34ce8458e0>
in grouper, before yield from averager, key is  girls;kg
in averager, before yield
pre active group ok
send to <generator object grouper at 0x7f34ce8458e0> value 40.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 41.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 42.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 43.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 44.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 54.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> none
in averager, return result
in grouper, after yield from, key is  girls;kg
in grouper, before yield from averager, key is  girls;kg
in averager, before yield

create group:  <generator object grouper at 0x7f34ce845678>
in grouper, before yield from averager, key is  girls;m
in averager, before yield
pre active group ok
send to <generator object grouper at 0x7f34ce845678> value 1.500000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845678> value 1.600000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845678> value 1.800000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845678> value 1.500000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845678> value 1.450000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845678> value 1.600000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845678> none
in averager, return result
in grouper, after yield from, key is  girls;m
in grouper, before yield from averager, key is  girls;m
in averager, before yield

create group:  <generator object grouper at 0x7f34ce845620>
in grouper, before yield from averager, key is  boys;kg
in averager, before yield
pre active group ok
send to <generator object grouper at 0x7f34ce845620> value 50.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845620> value 51.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845620> value 62.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845620> value 53.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845620> value 54.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845620> value 54.000000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce845620> none
in averager, return result
in grouper, after yield from, key is  boys;kg
in grouper, before yield from averager, key is  boys;kg
in averager, before yield

create group:  <generator object grouper at 0x7f34ce8458e0>
in grouper, before yield from averager, key is  boys;m
in averager, before yield
pre active group ok
send to <generator object grouper at 0x7f34ce8458e0> value 1.600000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 1.800000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 1.800000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 1.700000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 1.550000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> value 1.600000 now
in averager, before yield
send to <generator object grouper at 0x7f34ce8458e0> none
in averager, return result
in grouper, after yield from, key is  boys;m
in grouper, before yield from averager, key is  boys;m
in averager, before yield
report result: 
 6 boys  averaging 54.00kg
 6 boys  averaging 1.68m
 6 girls averaging 44.00kg
 6 girls averaging 1.58m

这个试验想表明的关键一点是，如果子生成器不终止，委派生成器会在yield from 表达式处永远暂停。如果是这样，程序不会向前执行，因为 yield from（与 yield 一样）把控制权转交给客户代码（即，委派生成器的调用方）了。

八：yield from的意义

把迭代器当作生成器使用，相当于把子生成器的定义体内联在 yield from 表达式中。此外，子生成器可以执行 return 语句，返回一个值，而返回的值会成为 yield from 表达式的值。

PEP 380 在“Proposal”一节（https://www.python.org/dev/peps/pep-0380/#proposal）分六点说明了 yield from 的行为。这里几乎原封不动地引述，不过把有歧义的“迭代器”一词都换成了“子生成器”，还做了进一步说明。上面的示例阐明了下述四点：

子生成器产出的值都直接传给委派生成器的调用方（即客户端代码）；

使用 send() 方法发给委派生成器的值都直接传给子生成器。如果发送的值是None，那么会调用子生成器的 __next__() 方法。如果发送的值不是 None，那么会调用子生成器的 send() 方法。如果子生成器抛出 StopIteration 异常，那么委派生成器恢复运行。任何其他异常都会向上冒泡，传给委派生成器；

生成器退出时，生成器（或子生成器）中的 return expr 表达式会触发StopIteration(expr) 异常抛出；

yield from 表达式的值是子生成器终止时传给 StopIteration 异常的第一个参数。

yield from 的具体语义很难理解，尤其是处理异常的那两点。在PEP 380 中阐述了 yield from 的语义。还使用伪代码（使用 Python 句法）演示了 yield from 的行为。

若想研究那段伪代码，最好将其简化，只涵盖 yield from 最基本且最常见的用法：yield from 出现在委派生成器中，客户端代码驱动着委派生成器，而委派生成器驱动着子生成器。为了简化涉及到的逻辑，假设客户端没有在委派生成器上调用throw(...) 或 close() 方法。而且假设子生成器不会抛出异常，而是一直运行到终止，让解释器抛出 StopIteration 异常。上面示例中的脚本就做了这些简化逻辑的假设。

下面的伪代码，等效于委派生成器中的 RESULT = yield from EXPR 语句（这里针对的是最简单的情况：不支持 .throw(...) 和 .close() 方法，而且只处理 StopIteration 异常）：

_i = iter(EXPR) 
try:
    _y = next(_i)
except StopIteration as _e:
    _r = _e.value
else:
    while 1:
        _s = yield _y
    try:
        _y = _i.send(_s)
    except StopIteration as _e:
        _r = _e.value
        break
RESULT = _r

但是，现实情况要复杂一些，因为要处理客户对 throw(...) 和 close() 方法的调用，而这两个方法执行的操作必须传入子生成器。此外，子生成器可能只是纯粹的迭代器，不支持 throw(...) 和 close() 方法，因此 yield from 结构的逻辑必须处理这种情况。如果子生成器实现了这两个方法，而在子生成器内部，这两个方法都会触发异常抛出，这种情况也必须由 yield from 机制处理。调用方可能会无缘无故地让子生成器自己抛出异常，实现 yield from 结构时也必须处理这种情况。最后，为了优化，如果调用方调用 next(...) 函数或 .send(None) 方法，都要转交职责，在子生成器上调用next(...) 函数；仅当调用方发送的值不是 None 时，才使用子生成器的 .send(...) 方法。

         下面的伪代码，是考虑了上述情况之后，语句：RESULT = yield from EXPR的等效代码：

_i = iter(EXPR)
try:
    _y = next(_i)
except StopIteration as _e:
    _r = _e.value
else:
    while 1:
        try:
            _s = yield _y
        except GeneratorExit as _e:
            try:
                _m = _i.close
            except AttributeError:
                pass
            else:
                _m()
            raise _e
        except BaseException as _e:
            _x = sys.exc_info()
            try:
                _m = _i.throw
            except AttributeError:
                raise _e
            else:
                try:
                    _y = _m(*_x)
                except StopIteration as _e:
                    _r = _e.value
                    break
        else:
            try:
                if _s is None:
                    _y = next(_i)
                else:
                    _y = _i.send(_s)
            except StopIteration as _e:
                _r = _e.value
                break
RESULT = _r

         上面的伪代码中，会预激子生成器。这表明，用于自动预激的装饰器与 yield from 结构不兼容。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/117644.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Web应用怎样获取Access Token？

Web应用怎样获取Access Token？

1.在联盟创建服务器应用 参考文档&#xff1a;开发准备 2.获取用户级Access Token 2.1 获取code 参考文档&#xff1a;接入华为帐号获取凭证 2.1.1 先按照跳转链接进行配置url https://oauth-login.cloud.huawei.com/oauth2/v3/authorize? response_typecode& acces…
阅读更多...
docker（七）容器监控（CAdvisor+InfluxDB+Granfana）

docker（七）容器监控（CAdvisor+InfluxDB+Granfana）

docker可能会运行多个容器&#xff0c;一个宿主机上有多个容器时&#xff0c;需要监控容器的&#xff1a;CPU使用率&#xff0c;内存使用率&#xff0c;网络状态&#xff0c;磁盘空间等数据。 一、docker stats docker stats命令可以监控以下数据&#xff1a; 数据是实时的&…
阅读更多...
FFmpeg简单使用：过滤器 ---- 视频过滤2

FFmpeg简单使用：过滤器 ---- 视频过滤2

1. 简介 FFmpeg filter提供了很多⾳视频特效处理的功能&#xff0c;⽐如视频缩放、截取、翻转、叠加等。 其中定义了很多的filter&#xff0c;例如以下常⽤的⼀些filter。 scale&#xff1a;视频/图像的缩放 overlay&#xff1a;视频/图像的叠加 crop&#xff1a;视频/图像的裁…
阅读更多...
新建unity项目

新建unity项目

在此处点击新项目按钮&#xff0c;建立新的项目。 选择对应的项目模板和项目名称&#xff0c;位置。 项目新建会花费几分钟到十几分钟的时间。 新建完项目打开后就可以进入到unity引擎中。 新建项目会默认创建一个场景&#xff0c;场景保存在Assets--> Scenes中&#xff0c;…
阅读更多...
服务器，只有“鞋盒”大小

服务器，只有“鞋盒”大小

上期,我们谈到了边缘端的远中近分类法,并介绍了戴尔科技集团最新发布的“远边缘”服务器PowerEdge XR4000。今天我们来继续说说这款服务器的奥秘。 　　 　　服务器,只有“鞋盒”大小 　　 　　PowerEdge XR4000代表了戴尔继续致力于边缘创新的承诺,它的大小只与鞋盒差不多,是P…
阅读更多...
Java 集合有哪些内容？

Java 集合有哪些内容？

今天我们就来简单的了解下java中的集合&#xff0c;有了解过得朋友都知道&#xff0c;也都用过&#xff0c;比如说做常用的List&#xff0c;还有Set、Map&#xff0c;而且像List和Set都是用于存储单列数据的集合&#xff0c;他们的父接口都是Conllection&#xff0c;List的特点…
阅读更多...
hyperf中的缓存之CacheEvict

hyperf中的缓存之CacheEvict

在开发中难免会遇到要批量删除一些缓存&#xff0c;hyperf的注解中提供了关于缓存的几个注解如下 Cacheable 生成缓存的&#xff0c;根据你的返回值生成缓存 参数($prefix, $value, $ttl, $listener, $offset, $group, $collect) CachePut 更新缓存 参数($prefix, $value, …
阅读更多...
MS 训练笔记【1】：nnUNet

MS 训练笔记【1】：nnUNet

文章目录前言1. 安装2. 训练与测试2.1. 数据处理2.1.1. 整理数据路径2.1.2. 设置 nnFormer 读取文件的路径2.1.3. 数据集预处理2.2. 训练2.2.1. 训练代码2.2. 预测总结前言 nnUNet是德国癌症研究中心的工程师编写的框架&#xff0c;迄今为止依旧在维护和更新。本文主要记载 nn…
阅读更多...
FBX模型

FBX模型

概览 fbx文件&#xff0c;一般是导出给unity使用的模型文件。 如下图所示&#xff0c;建立一个models目录&#xff0c;然后右击&#xff0c;选择 imoprt new asserts 即可导入这些文件。 展示如下&#xff0c;Mesh定义了形状。 铅笔也是同理&#xff0c;只不过铅笔有自己的贴图…
阅读更多...
尚医通-前端列表（十一）

尚医通-前端列表（十一）

目录&#xff1a; &#xff08;1&#xff09;搭建前端环境 &#xff08;2&#xff09;目录结构和登录改造 &#xff08;3&#xff09;医院设置前端-列表 &#xff08;1&#xff09;搭建前端环境 vue-element-admin 简介 vue-element-admin是基于element-ui 的一套后台管理系…
阅读更多...
计算机系统基础实验 - 数的机器级表示

计算机系统基础实验 - 数的机器级表示

实验1 数的机器级表示 实验序号&#xff1a;1 实验名称&#xff1a;数的机器级表示 适用专业&#xff1a;软件工程 学时数&#xff1a;2学时 一、实验目的 1.熟练掌握无符号整数的机器级表示 2.熟练掌握有符号整数的机器级表示 3.熟练掌握浮点数的机器级表示 二、实验要求 …
阅读更多...
WORDPRESS WOOCOMMERCE购物网站安装AB跳转支付插件接口的教程

WORDPRESS WOOCOMMERCE购物网站安装AB跳转支付插件接口的教程

本文介绍在Wordpress Woocommerce购物系统上安装支付插件&#xff0c;并且对接《品牌出海AB跳转收单系统》的方法&#xff0c;以下是图文教程 注意本教程是采用Wordoress中文版本后台截取的图例&#xff0c;英文版本后台文字略有不同&#xff1b; 1、首先打开支付插件压缩包&…
阅读更多...
反编译python 生成的exe源码

反编译python 生成的exe源码

反编译python 生成的exe源码记录反编译exe工具使用 工具准备 – pyinstxtractor.py – uncompyle6 – sublime Text&#xff08;或者其他的二进制编辑工具&#xff09; 一、解包&#xff08;exe&#xff09; ①&#xff1a;先把下载的pyinstxtractor.py文件和需要进行反编译的…
阅读更多...
π120M60代替ADuM2210SRIZ 双通道数字隔离器 电路简单速度快

π120M60代替ADuM2210SRIZ 双通道数字隔离器 电路简单速度快

π120M60代替ADuM2210SRIZ 双通道数字隔离器 电路简单速度快。具有出色的性能特征和可靠性&#xff0c;整体性能优于光耦和基于其他原理的数字隔离器产品。传输通道间彼此独立&#xff0c;可实现多种传输方向的配置&#xff0c;可实现 5.0kV rms 隔离耐压等级和 DC 到 10Mbps 信…
阅读更多...
下载和安装MySQL官方提供的示例数据库（Employees）

下载和安装MySQL官方提供的示例数据库（Employees）

一、前言 在此之前笔者写过一篇博客《你说精通MySQL其实很菜jī&#xff08;1&#xff09;&#xff1a;你不一定会的基本技巧或知识点&#xff08;值得一看&#xff09;》&#xff0c;本文内容是从那篇博客截取出来的。我们要学习MySQL相关的技术点&#xff0c;使用官方提供的测…
阅读更多...
构造HTTP请求

构造HTTP请求

构造HTTP请求一、浏览器自己构造二、通过 form 表单构造三、通过 ajax 构造一、浏览器自己构造 1&#xff09;地址栏里写URL&#xff0c;构造出GET请求 2&#xff09;点击a标签等&#xff0c;也会构造GET请求 3&#xff09;img、link、script也会构造GET请求 二、通过 form 表…
阅读更多...
Java中的常用队列

Java中的常用队列

&#x1f3c6;今日学习目标&#xff1a; &#x1f340;Java中的常用队列 ✅创作者&#xff1a;林在闪闪发光 ⏰预计时间&#xff1a;30分钟 &#x1f389;个人主页&#xff1a;林在闪闪发光的个人主页 &#x1f341;林在闪闪发光的个人社区&#xff0c;欢迎你的加入: 林在闪闪…
阅读更多...
【Django】第二课 基于Django图书借阅管理网站平台

【Django】第二课 基于Django图书借阅管理网站平台

概念 本文在上一篇文章之上完成登录&#xff0c;图书显示&#xff0c;关键字搜索以及分页功能 登录功能实现 当用户在首页进行输入学生用户信息后&#xff0c;点击登录按钮发送请求给服务器&#xff0c;地址请求为: /toLogin/ urls.py path(toLogin/,views.toLogin), 将接…
阅读更多...
ArcGIS基础实验操作100例--实验3旋转矢量要素

ArcGIS基础实验操作100例--实验3旋转矢量要素

实验平台&#xff1a;ArcGIS 10.6 实验数据&#xff1a;请访问实验1&#xff08;传送门&#xff09; 基础编辑篇--实验3 旋转矢量要素 目录 一、实验背景 二、实验数据 三、实验步骤 &#xff08;1&#xff09;加载【旋转】工具 &#xff08;2&#xff09;旋转矢量要素 一…
阅读更多...
灵龟八法推算

灵龟八法推算

很久之前就对这个算法感兴趣了&#xff0c;但是一直没搞定&#xff0c;网上公说公的&#xff0c;婆说婆的&#xff0c;搞得你头晕眼睛花&#xff0c;最后东拼西凑研究了好久才研究出来,在这里给大家分享。 第一步&#xff0c;掏出你的老黄历&#xff0c;如果你没有老黄历问题不…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023