小编don*_*mus的帖子

我有一些代码让我感到困惑.特别是,当我尝试将某些内容添加到列表作为初始化列表时 - 它一直有效,直到我添加析构函数 - 然后它开始尝试查找复制构造函数.

这似乎并不是完全一致的行为.拿这个最小的例子:

#include <list>
int main()
{
    class MemberType
    {
    public:
        MemberType()  {}
        MemberType(MemberType&& copy) { }
    };
    struct ListItemType
    {
        MemberType x;
        ~ListItemType() {}
    };
    std::list<ListItemType> myList;
    myList.push_back({MemberType()});
    return 0;
}

这无法在GCC和VS2015中编译,因为push_back尝试访问ListItemType复制构造函数:

main()::ListItemType::ListItemType(const main()::ListItemType&)

(根据我的理解).这似乎是有道理的,因为列表push_back将复制(因为没有移动构造函数),除非这不是行为,如果您删除析构函数.注释掉析构函数,编译按预期成功.

也就是说,即使使用析构函数,以下工作也很好 - 不需要复制或移动构造函数来满足它.这对我来说似乎是一样的行为.

ListItemType foo = { MemberType() };

最后,如果删除或注释掉移动构造函数MemberType- 编译再次成功 - 意味着以下将编译.

#include <list>
int main()
{
    class MemberType
    {
    public:
        MemberType()  {}
    };
    struct ListItemType
    { …

当我尝试覆盖魔术方法__eq__,并使用super访问找到的基本方法时object,我收到一个错误.这不是一个错误,但它确实感觉像一个:

class A(object):
    def __eq__(self, other):
        return super(A, self).__eq__(other)
A() == 0

# raises AttributeError: 'super' object has no attribute '__eq__'

这是不直观的,因为object.__eq__存在,但class A(object): pass它没有.如果我没有错误__eq__地进行is检查,那么这可能是解决方法,但使用is而super不是mixin友好.在我的情况下,这条路线是可以的,但在其他情况下可能不是.

任何建议,或关于为什么这样__eq__工作的信息都会很棒.

在python中,值x并不总是被约束为等于自身.也许最着名的例子是NaN:

>>> x = float("NaN")
>>> x == x
False

现在考虑一个项目的列表.我们可能会认为两个这样的列表是相同的,只要它们包含的项目是相同的.例如:

>>> ["hello"] == ["hello"]
True

但这似乎并非如此NaN:

>>> x = float("NaN")
>>> x == x
False
>>> [x] == [x]
True

因此,这些"不相等"的项目列表是"相等的".但有时只是......特别是:

• 由相同实例组成的两个列表NaN被认为是相等的; 而
• 两个由不同实例组成的单独列表NaN不相等

注意:

>>> x = float("NaN")
>>> [x] == [x]
True
>>> [x] == [float("NaN")]
False

此一般行为也适用于其他集合类型,如元组和集合.对此有充分的理由吗？

在python中,内置集合将元素与它们具有反身性的明确假设进行比较:

在强制元素的反身性时,集合的比较假定对于集合元素x,x == x总是为真.基于该假设,首先比较元素标识,并且仅针对不同元素执行元素比较.

从逻辑上讲,这意味着对于任何列表L,L == L必须是True.鉴于此,为什么实施检查不会将评估短路？

In [1]: x = list(range(10000000))
In [2]: y = list(range(int(len(x)) // 10))
In [3]: z = [1]

# evaluation time likes O(N)
In [4]: %timeit x == x
10 loops, best of 3: 21.8 ms per loop
In [5]: %timeit y == y
100 loops, best of 3: 2.2 ms per loop
In [6]: %timeit z == z
10000000 loops, best of 3: 36.4 ns …

由于我无法找到任何关于此的文档,所以我会问这里.

如下面的代码所示,我发现oroperator(|)工作原理如下:

a = {"a": 1,"b": 2, 2: 3}
b = {"d": 10, "e": 11, 11: 12}

keys = a.keys() | b.keys()
aonce = a.keys() | a.values()
bonce = b.keys() | b.values()

for i in keys:
    print(i, end=" ")
print()
for i in aonce:
    print(i, end=" ")
print()
for i in bonce:
    print(i, end=" ")
print()

以某种顺序产生结果:

2 d 11 a b e   
3 1 2 a b   
10 e 11 12 d   

最初,我认为这些迭代是兼容的|,但类似于集合的方式.使用其他可迭代的测试(例如a …

我在更新变量方面遇到了一个不寻常的问题。我已经构建了一个简单的类对象来帮助我进行一些网络嗅探。我想做一个并行进程，它允许我运行一些网络测试并捕获使用 python 生成的流量，这样我就可以扩展程序来做一些了不起的事情。我正在使用 scapy 的嗅探功能来帮助进行界面嗅探。

Scapy 的嗅探器允许您将一个函数传递给它自己的函数，该函数允许您创建“停止嗅探”条件。在我的例子中，我已经创建了函数stop_filter，我希望通过简单地更新self.stop_sniffing实例变量来停止 Scapy sniff 函数。我在下面展示了程序输出，它显示self.stop_sniffing在 Function 中设置为 True stop，但在stop_filter. 我不知道为什么会发生这种情况，也没有想到解决方案，因为这是一个如此奇怪的问题。

如果任何有新鲜眼光的人都能看到我在这里做了什么疯狂的事情，将不胜感激！

from scapy.all import *
from multiprocessing import Process


class DatasetSniffer:
    def __init__(self, iface, local_dir='.'):
        self.iface = iface
        self.master = None
        self.local_dir = local_dir
        self.stop_sniffing = False # Never updates! why!?
        self.writer = PcapWriter(local_dir+"/master.pcap", append=True, sync=True)

    def stop_filter(self, p):
        # Note: 'p' gets passed in by Scapy function 'sniff'
        print self.stop_sniffing
        # Return 'True' to stop …

用python计算笛卡儿积非常简单.只需要使用 itertools.product

>>> source = [['a', 'b', 'c'], [1, 2, 3]]
>>> list(itertools.product(*source))
[('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 1), ('c', 2), ('c', 3)]

但我找不到相反的操作.如何[['a', 'b', 'c'], [1, 2, 3]]从产品的结果中找到来源.有谁知道通用解决方案？

我很感激任何建议.

说我有lst = [1, 2, 3],我想以相反的顺序访问最后两个元素,如[3, 2]

我如何使用切片来做到这一点？