小编apa*_*ara的帖子

当谈到在Python生成XML数据,还有我经常看到推荐的两个库:LXML和ElementTree的

据我所知,这两个库彼此非常相似.它们似乎都具有类似的模块名称,使用指南和功能.甚至导入语句也非常相似.

 # Importing lxml and ElementTree
import lxml.etree
import xml.etree.ElementTree

Python的库lxml和ElementTree库之间有什么区别？

众所周知，至少在该类具有非POD成员时，在实施分配操作员时必须防止自我分配。通常它是（或等效于）：

Foo& operator=(const Foo& other)
{
  if (&other == this)
     return *this;
  ... // Do copy
}

不自动插入自我分配保护的原因是什么？是否存在用例中自我分配完成一些琐碎且实际有用的事情？

Foo& operator=(const Foo& other)
{
  if (&other == this)
  {
    // Do something non-trivial
  }
  else
  {
    // Do copy
  }
  return *this;
}

现在总结答案和讨论

看起来非平凡的自我分配永远不会真正有用。提出的唯一选择是放置一个assert，以便检测一些逻辑错误。但是也有像a = std::min(a, b)这样的非常合理的自我分配案例，因此，即使此选项也是非常可疑的。

但是，平凡的自我分配有两种可能的实现方式：

1. 如果不采取任何措施&other == this。始终可以工作，尽管由于额外的分支可能会对性能产生负面影响。但是在用户定义的赋值运算符中，几乎必须始终明确进行测试。
2. 将每个成员复制到自己。这是默认情况下完成的操作。如果成员也使用默认的赋值运算符，则它可能会更快，因为它不需要额外的分支。

我仍然不明白为什么C ++标准不能在用户定义的赋值运算符中保证这一点&other != this。如果不希望分支，请使用默认运算符。如果要重新定义操作员，则仍然需要进行一些测试...

我发现，numpy.sin当参数大小小于等于8192且大于8192时，行为会有所不同。性能和返回的值都不同。有人可以解释这种影响吗？

例如，让我们计算sin（pi / 4）：

x = np.pi*0.25
for n in range(8191, 8195):
    xx = np.repeat(x, n)
    %timeit np.sin(xx)
    print(n, np.sin(xx)[0])

64.7 µs ± 194 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
8191 0.7071067811865476
64.6 µs ± 166 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
8192 0.7071067811865476
20.1 µs ± 189 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
8193 0.7071067811865475
21.8 …

请考虑以下程序：

using System;

public interface IFoo
{
    void DoFoo();
}

public class Bar: IFoo
{
    public void DoFoo() => Console.WriteLine("BAR!");
}

public class Baz: Bar, IFoo
{
    void IFoo.DoFoo() => Console.WriteLine("baz!");
}

class Program
{
  static void Main()
  {
    Baz baz = new Baz();
    baz.DoFoo();
    
    IFoo foo = baz;
    foo.DoFoo();
    
    Bar bar = baz;
    bar.DoFoo();
    
    IFoo foobar = bar;
    foobar.DoFoo();
  }
}

它给出了以下输出，我个人以我的 C++ 背景认为这是非常意外的：

BAR!
baz!
BAR!
baz!

, IFoo在声明中包含Baz似乎是实质性的，因为否则void IFoo.DoFoo()无法编译。

有人可以解释一下这里发生了什么（特别是最后一行）吗？在现实生活中应该怎样防止此类行为呢？是否应该完全避免从同一接口实现，或者是否有其他一些规则来避免出现问题？

更新：

看起来这里的主要问题不是“多重继承”（实际上并不是真正的多重继承），而是在 …