Python dask.delayed.delayed用法及代码示例

用法: dask.delayed.delayed(obj='__no__default__', name=None, pure=None, nout=None, traverse=True)

包装函数或对象以生成 Delayed 。

Delayed 对象充当它们包装的对象的代理，但对它们的所有操作都是通过在内部构建一个 dask 图来懒惰地完成的。

参数：

obj：对象: 要包装的函数或对象
name：字符串或哈希，可选: 在包装对象的基础图中使用的键。默认为散列内容。请注意，这只会影响此调用所包装的对象的名称延迟，并且不是延迟函数调用的输出 - 用于该用途dask_key_name=如下所述。

注意

由于此 name 用作任务图中的键，因此您应确保它唯一标识 obj 。如果您想提供一个仍然唯一的说明性名称，请将说明性名称与 array_like 的 dask.base.tokenize() 结合起来。有关更多信息，请参见任务图。
pure：布尔型，可选: 指示调用生成的Delayed 对象是否是纯操作。如果为 True，则对调用的参数进行散列以生成确定性键。如果未提供，则默认检查全局 delayed_pure 设置，如果未设置则回退到 False。
nout：整数，可选: 调用生成的 Delayed 对象返回的输出数。如果提供，则调用的Delayed 输出可以迭代到nout 对象中，从而允许对结果进行解包。默认情况下，Delayed 对象的迭代会出错。请注意，nout=1 期望 obj 返回长度为 1 的元组，因此对于 nout=0 , obj 应该返回一个空元组。
traverse：布尔型，可选: 默认情况下，dask 会遍历内置的 python 集合，寻找传递给 delayed 的 dask 对象。对于大型集合，这可能很昂贵。如果 obj 不包含任何 dask 对象，请设置 traverse=False 以避免执行此遍历。

例子：

应用于延迟执行的函数：

>>> from dask import delayed
>>> def inc(x):
...     return x + 1

>>> inc(10)
11

>>> x = delayed(inc, pure=True)(10)
>>> type(x) == Delayed
True
>>> x.compute()
11

可以用作装饰器：

>>> @delayed(pure=True)
... def add(a, b):
...     return a + b
>>> add(1, 2).compute()
3

delayed 还接受可选关键字 pure 。如果为 False，则后续调用将始终产生不同的 Delayed 。这对于非纯函数(例如 time 或 random )很有用。

>>> from random import random
>>> out1 = delayed(random, pure=False)()
>>> out2 = delayed(random, pure=False)()
>>> out1.key == out2.key
False

如果你知道一个函数是纯函数(输出只取决于输入，没有全局状态)，那么你可以设置 pure=True 。这将尝试对输出应用一致的名称，但如果失败，将退回到 pure=False 的相同行为。

>>> @delayed(pure=True)
... def add(a, b):
...     return a + b
>>> out1 = add(1, 2)
>>> out2 = add(1, 2)
>>> out1.key == out2.key
True

而不是设置pure作为可调用的属性，您还可以使用delayed_pure环境。请注意，这会影响称呼而不是创建可调用的：

>>> @delayed
... def mul(a, b):
...     return a * b
>>> import dask
>>> with dask.config.set(delayed_pure=True):
...     print(mul(1, 2).key == mul(1, 2).key)
True
>>> with dask.config.set(delayed_pure=False):
...     print(mul(1, 2).key == mul(1, 2).key)
False

默认情况下，调用延迟对象的结果的键名是通过散列参数确定的。要显式设置名称，可以在调用函数时使用dask_key_name 关键字：

>>> add(1, 2)   
Delayed('add-3dce7c56edd1ac2614add714086e950f')
>>> add(1, 2, dask_key_name='three')
Delayed('three')

请注意，假定具有相同键名的对象具有相同的结果。如果您明确设置名称，您应该确保您的键名对于不同的结果是不同的。

>>> add(1, 2, dask_key_name='three')
Delayed('three')
>>> add(2, 1, dask_key_name='three')
Delayed('three')
>>> add(2, 2, dask_key_name='four')
Delayed('four')

delayed 也可以应用于对象以使对它们的操作变得惰性：

>>> a = delayed([1, 2, 3])
>>> isinstance(a, Delayed)
True
>>> a.compute()
[1, 2, 3]

如果pure=True，则延迟对象的键名默认为散列，如果pure=False(默认)，则随机生成。要显式设置名称，您可以使用name 关键字。为确保 key 是唯一的，您还应该包含标记化的值，或者以其他方式确保它是唯一的：

>>> from dask.base import tokenize
>>> data = [1, 2, 3]
>>> a = delayed(data, name='mylist-' + tokenize(data))
>>> a  
Delayed('mylist-55af65871cb378a4fa6de1660c3e8fb7')

延迟结果充当底层对象的代理。支持许多运算符：

>>> (a + [1, 2]).compute()
[1, 2, 3, 1, 2]
>>> a[1].compute()
2

方法和属性访问也有效：

>>> a.count(2).compute()
1

请注意，如果方法不存在，直到运行时才会抛出错误：

>>> res = a.not_a_real_method() 
>>> res.compute()  
AttributeError("'list' object has no attribute 'not_a_real_method'")

“Magic” 方法(例如运算符和属性访问)被假定为纯方法，这意味着后续调用必须返回相同的结果。此行为不能通过delayed 调用覆盖，但可以使用如下所述的其他方式进行修改。

要调用不纯的属性或运算符，您需要在带有 pure=False 的延迟函数中使用它：

>>> class Incrementer:
...     def __init__(self):
...         self._n = 0
...     @property
...     def n(self):
...         self._n += 1
...         return self._n
...
>>> x = delayed(Incrementer())
>>> x.n.key == x.n.key
True
>>> get_n = delayed(lambda x: x.n, pure=False)
>>> get_n(x).key == get_n(x).key
False

相反，默认情况下假定方法是不纯的，这意味着后续调用可能会返回不同的结果。要假设纯度，请设置 pure=True 。这允许共享任何中间值。

>>> a.count(2, pure=True).key == a.count(2, pure=True).key
True

与函数调用一样，方法调用也尊重全局 delayed_pure 设置并支持 dask_key_name 关键字：

>>> a.count(2, dask_key_name="count_2")
Delayed('count_2')
>>> import dask
>>> with dask.config.set(delayed_pure=True):
...     print(a.count(2).key == a.count(2).key)
True

相关用法

注：本文由纯净天空筛选整理自dask.org大神的英文原创作品 dask.delayed.delayed。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。