小编pau*_*l23的帖子

使用元类(这里有一些其他答案),简单地使类可迭代很容易.但是我希望使一个类可迭代,并且还允许一个"基于继承迭代一个子组".我使用的一个例子:

class IterPartRegistry(type):
    def __iter__(cls):
        return iter(cls._registry)


class A(object, metaclass=IterPartRegistry):
    _registry = []
    def __init__(self, name):
        self.name = name
        self._registry.append(self)

class B(A):
    pass

class C(A):
    pass


A("A - first")
B("B - first")
B("B - second")
C("C - first")

for t in A:
    print(t.name)

print(" --- ")
for t in B:
    print(t.name)

exit()

第一个循环起作用 - 它遍历"A"的所有实例和子节点.但是,第二个循环应仅在"A"的特定子组上运行 - 那些是子项"B"的实例(或者是在线下的子项).

(如何)这可以实现最简单？通过这种方式添加更多子类需要最少量的工作/更改？

对我来说另一个令人不安的错误信息,如果我正确理解std :: bind我可以参数_1来定义一个非给定的参数吗？对？考虑以下几行:

std::function<bool(value_type, const std::string &)> 
                             func(std::bind(&Pred, _1, "name"));

这应该有用,对吗？这将用于std :: find_if()函数,因此第一个参数应该是值类型,第二个参数应该是字符串.

然而,visual studio 2010通过以下错误消息抱怨此问题:

错误C2065:'_ 1':未声明的标识符

这很奇怪,我怎么能在视觉工作室说"嘿第一个参数没有约束".Pred是一个简单的value_type, const std::string&函数,它作为参数 - 返回一个布尔值.

好吧,我现在正在重构我很久以前制作的一个课程.该类是容器类型.

许多函数可以利用类结构的优点,因此实现为成员函数.然而现在它似乎是很多看似"相同"的功能,即"查找"功能:

iterator find(ITEM)
const_iterator find(ITEM) const;
iterator find_if(ITEM, PRED)
const_iterator find_if(ITEM, PRED) const;

4个"函数"来描述几乎相同(并且每个版本的代码几乎相同).更新课程时这变得非常繁琐,我必须确保每个版本都升级.有没有办法更好地处理这些事情？类CAN中的其他一些函数可能需要2个谓词,这意味着我突然有8个函数需要管理.

我试过调用"常量版本的非常量版本",但这显然不起作用.

那么如何处理这些事情呢？只需咬紧牙关并写下来？

编辑:只是为了通知:我的数据结构类似于"树".每个"对象"包含数据(查找搜索)和带有子树的"列表".find函数在树(和子子树)的所有子树上递归递归. - 就像人们在搜索树时所期望的那样.

由于没有明确的"结束"或"开始"迭代器到这样的树,使用std :: find不会产生正确的功能.

这让我有一段时间的烦恼,但是有可能用VHDL描述类似于模板在C++中工作的实体(或者用于较小的扩展泛型吗？).只是在合成/编译过程中只保留实际的端口类型？

一个例子是多路复用器,比如我有一个4输入多路复用器,现在我有几个总线大小,我使用这个多路复用器,-4,6,7,8-.目前我为每种不同的总线大小写了一个不同的多路复用器; 但是输出只是转发的所选输入之一,因此与总线的类型相同.

这似乎过于冗余且容易出错(在正确的时间选择正确的多路复用器,使它们全部保持一致,在更改总线大小时更新它们).有没有办法参数化这个？

下面的非通用版本显示了这个想法.

entity mux_6bit_4input is
    port (  input_0 : in    std_logic_vector (5 downto 0);
        input_1 : in    std_logic_vector (5 downto 0);
        input_2 : in    std_logic_vector (5 downto 0);
        input_3 : in    std_logic_vector (5 downto 0);
        sel : in    std_logic_vector (1 downto 0);
        output  : out   std_logic_vector (5 downto 0)
    );
end entity mux_6bit_4input;

好吧，我有一个包含（相关部分）的课程：

class satellite(object):
    def __init__(self, orbit, payload=None, structural_mass=0, structural_price=0):
        self.__all_parts = []
        self.orbit = orbit
        self.payload = payload
        self.structural_mass = structural_mass
        self.structural_price = structural_price

    def __getattr__(self, item):
        found = False
        v = 0
        for i in self.__all_parts:
            t = getattr(i, item, None)
            if t is not None:
                v += t
                found = True
        if found:
            return v
        else:
            raise AttributeError(item)

基本上，我希望做的是将所有（部分）属性从“部分”传播到卫星中。即，如果我有10个零件的质量，卫星的质量就是这些零件的总和。-如果再添加一个具有储能功能的零件-我可以立即向上查找。-如果没有部件具有该属性，则该属性被认为是“不良” /“不存在”，并且会引发正常错误。

现在可以了，除了我这样做时：

s = satellite(None) #most simplistic one
ss = copy.copy(s) 

整个过程都出错了，从而在中给出了无限递归深度错误__getattr__()。

现在检查（pycharm的调试器）向我展示了它不断使用as参数迭代getattr：

item = _satellite__all_parts 然后在该行开始下一次迭代 …

在尝试使单元测试（使用py.test）更通用时，我以编程方式生成了测试。-我有一个函数可以导出参数和在测试结束时保持不变的变量。

现在，为了保持整洁，我还希望通过测试的ID。查看pytest的官方（？）文档，我注意到：

import pytest

from datetime import datetime, timedelta

# ...

@pytest.mark.parametrize("a,b,expected", [
    pytest.param(datetime(2001, 12, 12), datetime(2001, 12, 11),
                 timedelta(1), id='forward'),
    pytest.param(datetime(2001, 12, 11), datetime(2001, 12, 12),
                 timedelta(-1), id='backward'),
])
def test_timedistance_v3(a, b, expected):
    diff = a - b
    assert diff == expected

在例子中展示了参数化的不同方法。

上面的方法正是我想要做的（给出参数以及每组参数的ID）：我的函数只会输出一个pytest.param对象列表。但是，当我运行以上代码段（或pytest.org的完整代码段）时，出现以下错误（pycharm ide也突出显示了此语法错误）：

E AttributeError: module 'pytest' has no attribute 'param'

文档是否有误？我是否缺少某些环境设置不正确的东西？

考虑一个接受/创建可能类型（例如数字）的函数；然后是另一个不接受此类型的函数。为了使其“工作”，我通过在其周围添加条件来保护不采用 Maybe-type 的函数。

一个简单的例子：

/* @flow */

export function nullOrUndefined(val: mixed): boolean {
    return val === null || val === undefined;
}

function foo(x: ?number) {
  console.log(!nullOrUndefined(x) ? addOne(x) : null);
}


function addOne(x: number) {
  return x + 1;
}

这nullOrUndefined将是一个通用的防护，我创建它是为了具有一个具有表现力的简单实用函数，因此我不必不断地在线输入“复杂”测试。

上面的功能可以工作，并且不会抛出错误。（只要foo接收到一个数字，未定义或空。

但是流程给出以下错误：

8:   console.log(!nullOrUndefined(x) ? addOne(x) : null);
                                              ^ Cannot call `addOne` with `x` bound to `x` because null or undefined [1] is incompatible with number [2].
    References:
    7: function foo(x: ?number) {
                       ^ …

使用正常的 promise，一旦当前代码停止，promise 将尽快解决。考虑以下伪代码：

const p = SomePromiseDoingLoad();
calculatethings();
await sleepPromise();
//during sleep the promise p might/will have resolved already.
await p; //awaiting just makes *sure* the promise is already executed

但是，这如何转换为像 knex 这样的查询构建器？似乎没有办法阻止承诺的执行？

const p = knex.select('*').from('table');
//p could be executed now already.
const data = await gatherDataFromWebsite();
//p most probably will have resolved??
p.limit(data.limit) // ???

上面会发生什么，以及我如何进一步防止这种情况发生？毕竟总是允许节点尽快解决承诺，所以只是链接点可以让它解决吗？

const p = knex.select('*').from('table').limit(5); 
let q = knex.select('*');
q = q.from('table');
q = q.limit(5);

或者knex在推迟执行的计划背后做了什么魔术？

假设我是基于流的类型，其类型如下：

type baseTy = { x: number, y: number, z: number}

现在我希望（对于实用程序）具有与 相同的类型baseTy，但有一个不同的属性：

type derivTy = {x: string, y: number, z: number}

显然我可以重新声明它，但是这是多余的，并且可能会在以后更新时导致问题。所以我只想定义“差异”。如何使用流类型来做到这一点？

我可以：

type derivTy = $Diff<baseTy, {x: any}> & {x: string}

然而，这看起来很冗长，并没有清楚地表明含义。有一个更好的方法吗？

嗯，我是在 C++ 环境下长大的，所以我总是很清楚什么算法适合什么。因此，当我注意到应用程序在手机上开始表现迟缓时，我立即开始研究数据结构及其表示方式。

我注意到一个非常奇怪的效果Array.includes是比 快一个数量级Set.has。尽管Set.has查找优化的潜力更大：这是使用集合的整个想法。

我的初始化代码是（此代码超出了测试时间）：

function shuffle(a) {
    for (let i = a.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [a[i], a[j]] = [a[j], a[i]];
    }
}

const arr = []
for (let i = 0; i < 1000; i+=1) {
    arr.push(i);
};

shuffle(arr);
const prebuildset=new Set(arr);

测试是：

(new Set(arr)).has(-1); //20.0 kOps/s
arr.includes(-1); //632 kOps/s
(new Set(arr)).has(0); //20.0 kOps/s
arr.includes(0); //720 kOps/s
prebuildset.has(-1); //76.7 kOps/s …