Python 为什么内置函数必须在dask.delayed对象上引发异常？

我正在尝试使用dask API为我的特定应用程序运行DAG任务。在一个精心设计的示例中，我希望任务传递成功/失败标志，并将其用作其他任务的输入

但是，dask不允许我对延迟对象执行

\uu bool\uu

调用（

a和b

）。但它与按位布尔运算（即a&b）有何区别

为什么它被实现为不受支持？本地修复有多难

我试图深入研究源代码，但我不明白

a&b

如何成功地返回（'and'、'a'、'b'）的子图，但是

a和b

不会返回类似（'u_bool_'u 1'、'a'）、（'u_bool_'2'、'b'）、（'and'、'u_'、'u_bool_'1'、'u bool'2'）的内容

我提供了最简单的源代码，可以重新生成问题

导入dask
从时间上导入睡眠
@达斯克
def任务（x，秒）：
如果不是条件：
返回错误
睡眠（x）
返回真值
def run_graph（）：
task1_done=任务（2，真）
task2_done=任务（1，真）
task3_done=任务（1，task2_done）
全部完成=任务1完成和任务3完成
返回所有已完成的任务
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
完成=运行图（）
dask.compute（完成）

如果我们将and操作替换为&，它就可以正常工作

all_done=task1_done&task3_done

---

这在这里可能不是问题，但我想使用

all（）

和

any（）

内置函数来创建延迟标志列表，并在内部调用

\uuu bool\uuu

。

我个人不太了解Dask，但我怀疑它只是在其对象上实现了

\uu和

。这根本不会将对象转换为布尔值。这与and、or或etc不同，后者首先将对象转换为布尔值

这可以通过一个小测试类进行快速测试：

In [1]: class Test: 
    ...:     def __and__(self, other): 
    ...:         print("And called!") 
    ...:         return self 
    ...:     def __bool__(self): 
    ...:         print("Bool called!") 
    ...:         return True 
    ...:                                                                                                                                                                                                                             

In [2]: a = Test()                                                                                                                                                                                                                  

In [3]: b = Test()                                                                                                                                                                                                                  

In [4]: a & b                                                                                                                                                                                                                       
And called!
Out[4]: <__main__.Test at 0x7f5eb58f4eb8>

In [15]: a and  b                                                                                                                                                                                                                    
Bool called!
Out[5]: <__main__.Test at 0x7f5eb587e400>

[1]中的

：类测试：
…：定义和（自我、其他）：
…：打印（“并调用！”）
…返回自我
…：def_uuubool_uuu（self）：
…：打印（“Bool called！”）
…：返回True
...:                                                                                                                                                                                                                             
在[2]中：a=Test（）
在[3]中：b=测试（）
在[4]中：a&b
然后叫！
出[4]：
在[15]中：a和b
布尔打电话来了！
出[5]：

---

根据我的理解，Dask会延迟求值，因此很可能

\uuuuubool\uuuuu

会强制立即求值，而

\uuuuu和

会返回惰性对象（因为它返回的是相同类型的对象，而不是布尔值）。

谢谢，我理解这些，但是有没有办法让

返回惰性对象呢？另外，我真的不明白在dask.Delay数据结构中，所有这些都是如何工作的，因为它没有显式地实现布尔或一元运算。但它对他们很有效。@KouroshHakhamaneshi阅读它时说“应该返回假或真”。除非它返回一个即时值，否则它似乎不太可能可靠地处理所有内容。此外，与
\uuuu和
等（您知道“其他”对象是什么）不同，您对操作的上下文没有任何线索。因为我不太了解Dask本身，也许有一种更惯用的方式来做你想在Dask中做的事情？是的，我想我现在的问题是如何根据图中其他一些早期任务的结果来控制任务图的构建。这就是我想要做的。例如，如何在任务成功完成之前不启动未来任务，或者如果任务失败，则启动另一个任务，类似这样的事情。