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。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。