小编Han*_*ave的帖子

在 Zig（当前使用 0.7.1）中，假设由于某种原因您没有任何好的方法来设计resume对于每个suspend. 是否有任何支持的方法可以在运行时检测给定的帧是否已执行完成？

// overly simplistic example designed to illustrate the problem
pub fn main() void {
    var frame = async amain(2);
    resume frame;
    resume frame;

    // panic/UB -- resume async function which already returned
    // 
    // we would prefer to have some kind of check which could allow
    // us to detect at runtime that the following resumption is illegal
    resume frame;
}

fn amain(ubound: i32) void {
    var i: i32 = 0;
    while …

我有一个方形矩阵D(目前表示为一个形状为numpy的阵列(572,572)),似乎对应于沿大致圆柱形物体表面的点之间的成对距离.即,该值D[i,j]对应于沿该空心圆柱体表面的任何路径的最小长度.如何构建这些572个点的三维(或n维)嵌入欧几里德空间,以保留那些测地距离？

目前的尝试

局部线性嵌入和isomap等算法能够采用成对测地距离的矩阵并输出嵌入,以便成对的欧氏距离与原始测地线相同.虽然这通常不是同一个任务,但是在输出碰巧接近某个维度的超立方体的情况下,实际发生了所需的变换(考虑瑞士卷),因为嵌入本身就是一个流形,因此欧几里德距离对应于测地线距离.

对于像气缸这样稍微复杂的物体,情况并非如此.通过将测地距离视为欧几里德,期望圆柱上的对映点被映射到彼此远离期望的位置,并且相应的全局优化问题将经常导致分支结构,其中分支的末端对应于最远的对映点,放大气缸随机采样中的小扰动.通常,这些算法的天真应用似乎并不能解决手头的问题.

另一种有点富有成效(虽然昂贵)的方法是一种粗暴的蒙特卡罗技术.我从具有不同参数的管状物体中生成随机样本,直到我找到一组参数生成与我的类似的测地距离矩阵,直到排列(通过求解将该距离矩阵转换为采矿和测试的线性系统处理效率不是太低)查看结果是否接近排列矩阵).然后通过找到与上述近置换矩阵最接近的置换矩阵来执行从我的572点到保持成对距离的对象的近似最佳映射.

这会产生合理的结果,但它预先假定数据的形状并且非常昂贵.我已经执行了一些更明显的优化,比如使用小的随机样本而不是整个数据集,并使用基于梯度的技术进行参数估计,但更通用的技术会很好.

注意事项

这个问题当然没有一个独特的解决方案.即使假设可以通过有限均匀采样在3空间中明确地识别流形,也只是压缩圆柱体产生具有相同测地线和不同欧氏距离的形状(因此不同的嵌入).这不会比LLE和Isomap产生不同的解决方案更让我困扰,我会对任何合理的答案都很好.

关于从有限样本中唯一地识别流形,为了论证,我可以很好地使用来自包中dist_matrix_的拟合Isomap类的属性scikit-learn而没有任何特殊参数来找到测地线.这是一个不必要的MDS步骤,但它并不是非常昂贵,而且开箱即用.然后我们想要一个嵌入,它最小化原始测地距离矩阵和dist_matrix_属性之间的frobenius距离.

如果我做了一个模块，我想作为在Python 3运行在Python 2相同，有一吨的选项包括six，futures，和2to3。如果更改的数量很少，那么这些工具中的每一个都有足够的怪癖，我倾向于只为我的模块实际使用的少数不兼容功能编写兼容接口。

实现这一点的合理标准方法是使用简单的版本检查。

import module_bar

if sys.version_info >= (3,):
    uniformly_named_foo = module_bar.py3_thing
else:
    uniformly_named_foo = module_bar.py2_thing

是否有任何奇怪的情况sys.version_info不会正确报告？过去，我已经被格式错误的路径、配置、安装、修改以及诸如此类的东西所困扰，以至于我觉得这不是我应该信任的事情。

当我们深入研究它时，我真正关心的是是否实现了特定功能。在 Web 开发中，嗅探用户代理通常被认为是一种不好的做法。相反，应该尽最大努力确定某个特定功能是否正在使用中。根据功能的不同，有很多方法可以实现这一点。

if hasattr(module_bar, 'py3_thing'):
    uniformly_named_foo = module_bar.py3_thing
else:
    uniformly_named_foo = module_bar.py2_thing

在我的机器上，第二条路线慢两倍（对于一次性操作来说，额外的几百纳秒并不重要），但它似乎没有任何其他主要缺点。还是有优势？是否存在第二种方法会成功而第一种方法会失败的 Python 安装？

给定一组左节点和右节点，以及它们之间的边（二分图），我需要支持从左节点集到连接到左侧任何内容的右节点子集的快速查找。

如果图形非常稀疏或密集，这很容易。下面是一个示例邻接表实现，它将支持connected_endpoints()稀疏图上的快速调用。O(len(input) * len(result))然而，对于中等数量的连接，尽管涉及的数据大小表明可能存在解决方案，但中间计算看起来像是这样O(len(input) + len(result))。

是否存在一种数据结构可以相对快速地支持这 3 个操作（或类似的操作）——添加/删除可能为 O(1)，连接边搜索为 O(in+out)，给出或采用多对数因子？

from typing import *
from collections import defaultdict

A = TypeVar('A')
B = TypeVar('B')

class Graph(Generic[A, B]):
    def __init__(self):
        self.edges = defaultdict(set)
    
    def set_edge(self, start: A, end: B):
        """Desired: Amortized O(1)"""
        self.edges[start].add(end)
    
    def unset_edge(self, start: A, end: B):
        """Desired: Amortized O(1)"""
        s = self.edges[start]
        s.discard(end)
        if not s:
            self.edges.pop(start, None)

    def connected_endpoints(self, start: Set[A]) -> Set[B]:
        """Desired: Amortized O(len(start) + len(<return>))"""
        empty = …

假设我们有一个要进行猴子补丁的类以及一些我们想对其进行猴子补丁的可调用对象。

class Foo:
  pass

def bar(*args):
  print(list(map(type, args)))

class Baz:
  def __call__(*args):
    print(list(map(type, args)))
baz = Baz()

def wrapped_baz(*args):
  return baz(*args)

Foo.bar = bar
Foo.baz = baz
Foo.biz = wrapped_baz

Foo().bar()  # [<class '__main__.Foo'>]
Foo().baz()  # [<class '__main__.Baz'>]
Foo().biz()  # [<class '__main__.Baz'>, <class '__main__.Foo'>]

即使baz是可调用的，它也不会绑定到Foo()两个函数bar和的实例wrapped_baz。由于Python是鸭子式语言，因此给定可调用类型在对象机制的行为中起着举足轻重的作用，这似乎很奇怪。

并不是说包装可调用对象不一定是坏方法，还有其他方法可以将可调用对象适当地绑定到Foo实例吗？这是CPython实现的一个怪癖，还是语言规范的一部分描述了观察到的行为？

据我了解，目的是同时asyncio.gather运行其参数，并且当协程执行等待表达式时，它为事件循环提供了安排其他任务的机会。考虑到这一点，我惊讶地发现以下代码片段忽略了.asyncio.gather

import asyncio                                                             
  
async def aprint(s):
    print(s)

async def forever(s):
    while True:
        await aprint(s)

async def main():
    await asyncio.gather(forever('a'), forever('b'))

asyncio.run(main())

async def forever(s):
    while True:
        await aprint(s)
        await asyncio.sleep(1.)

async def forever(s):
    while True:
        await aprint(s)
        await asyncio.sleep(0.)