小编Nei*_*l G的帖子

#include <boost/ptr_container/ptr_vector.hpp>
#include <iostream>

using namespace std;
using namespace boost;

struct A {
    ~A() { cout << "deleted " << (void*)this << endl; }
};

int main() {
    ptr_vector<A>   v;
    v.push_back(new A);
    A   *temp = &v.front();
    v.release(v.begin());
    delete temp;
    return 0;
}

输出:

deleted 0x300300
deleted 0x300300
c(6832) malloc: *** error for object 0x300300: double free

Run Code Online (Sandbox Code Playgroud)

如何将我的对象类型的Python列表传递给ClassName接受vector<ClassName>？的C++函数？

我找到的最好的是这样的:例子.不幸的是,代码崩溃了,我似乎无法弄清楚原因.这是我用过的东西:

template<typename T>
void python_to_vector(boost::python::object o, vector<T>* v) {
    try {
      object iter_obj = object(handle<>(PyObject_GetIter(o.ptr())));
      return;
      for (;;) {
          object obj = extract<object>(iter_obj.attr("next")());
          // Should launch an exception if it cannot extract T
          v->emplace_back(extract<T>(obj));
      }
    } catch(error_already_set) {
        PyErr_Clear();
        // If there is an exception (no iterator, extract failed or end of the
        // list reached), clear it and exit the function
        return;
    }
}

是否有一种Pythonic方法来封装一个惰性函数调用,在第一次使用该函数时f(),它调用一个先前绑定的函数,g(Z)并在连续调用时f()返回一个缓存值？

请注意,记忆可能不是一个完美的选择.

我有:

f = g(Z)
if x:
     return 5
elif y:
     return f
elif z:
     return h(f)

代码可以工作,但是我想重组它,这样g(Z)只有在使用该值时才会调用它.我不想改变它的定义g(...),并且Z缓存有点大.

编辑:我认为这f必须是一个功能,但情况可能并非如此.

在这个问题中,我定义了一个包含上下文管理器的上下文管理器.完成此嵌套最简单的正确方法是什么？我最后打电话来self.temporary_file.__enter__()了self.__enter__().但是,self.__exit__我很确定我必须调用self.temporary_file.__exit__(type_, value, traceback)finally块,以防引发异常.如果出现问题,我应该设置type_,value和traceback参数self.__exit__吗？我检查过contextlib,但找不到任何实用程序来帮助解决这个问题.

来自问题的原始代码:

import itertools as it
import tempfile

class WriteOnChangeFile:
    def __init__(self, filename):
        self.filename = filename

    def __enter__(self):
        self.temporary_file = tempfile.TemporaryFile('r+')
        self.f = self.temporary_file.__enter__()
        return self.f

    def __exit__(self, type_, value, traceback):
        try:
            try:
                with open(self.filename, 'r') as real_f:
                    self.f.seek(0)
                    overwrite = any(
                        l != real_l
                        for l, real_l in it.zip_longest(self.f, real_f))
            except IOError:
                overwrite = True
            if overwrite:
                with open(self.filename, 'w') as real_f:
                    self.f.seek(0) …

如何在Python 3中绘制模块依赖关系？我发现了蛇食,但它似乎只适用于Python 2.

生成器表达式和生成器函数之间是否存在性能差异？

In [1]: def f():
   ...:     yield from range(4)
   ...:

In [2]: def g():
   ...:     return (i for i in range(4))
   ...:

In [3]: f()
Out[3]: <generator object f at 0x109902550>

In [4]: list(f())
Out[4]: [0, 1, 2, 3]

In [5]: list(g())
Out[5]: [0, 1, 2, 3]

In [6]: g()
Out[6]: <generator object <genexpr> at 0x1099056e0>

我问,因为我想决定如何决定如何使用这两者.有时发电机功能更清晰,然后选择很明确.我问的是代码清晰度没有明显的选择.

给出x = C.f之后:

class C:
    def f(self):
        pass

我会打电话给谁x回来C？

我能做的最好的是exec解析部分x.__qualname__,这是丑陋的:

exec('d = ' + ".".join(x.__qualname__.split('.')[:-1]))

对于一个用例,想象一下我想要一个装饰器来添加super对它应用的任何方法的调用.那个只给出函数对象的装饰器怎么能把类带到super(???下面)？

def ensure_finished(iterator):
    try:
        next(iterator)
    except StopIteration:
        return
    else:
        raise RuntimeError

def derived_generator(method):
    def new_method(self, *args, **kwargs):
        x = method(self, *args, **kwargs)
        y = getattr(super(???, self), method.__name__)\
            (*args, **kwargs)

        for a, b in zip(x, y):
            assert a is None and b is None
            yield

        ensure_finished(x)
        ensure_finished(y)

    return new_method

什么是数值最稳定的计算方法:

log[(wx * exp(x) + wy * exp_y)/(wx + wy)]

重量在哪里wx, wy > 0？

如果没有权重,这个函数logaddexp可以在Python中用NumPy实现,如下所示:

tmp = x - y
return np.where(tmp > 0,
                x + np.log1p(np.exp(-tmp)),
                y + np.log1p(np.exp(tmp)))

我应该如何将其推广到加权版本？

如何with在Python中通过多行传播long 子句？现在,我有

    with self.context_manager_one(some, parameters, that, are, passed) \
            as return_value_one, \
            self.context_manager_two(self.p, slice(None), None) \
            as return_value_two:

我想按照谷歌的Python风格指南,它禁止反斜杠线延续.

我想在返回代理对象的类上创建某种描述符.索引时,代理对象检索对象的成员并将索引应用于它们.然后它返回总和.

例如,

class NDArrayProxy:

    def __array__(self, dtype=None):
        retval = self[:]
        if dtype is not None:
            return retval.astype(dtype, copy=False)
        return retval


class ArraySumProxy(NDArrayProxy):

    def __init__(self, arrays):
        self.arrays = arrays

    @property
    def shape(self):
        return self.arrays[0].shape

    def __getitem__(self, indices):
        return np.sum([a[indices]
                       for a in self.arrays],
                      axis=0)

当我将实际数组作为成员变量时,此解决方案工作正常:

class CompartmentCluster(Cluster):

    """
    Base class for cluster that manages evidence.
    """

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self.variable_evidence = ArraySumProxy([])

class BasicEvidenceTargetCluster(CompartmentCluster):

    # This class variable creates a Python object named basic_in on the
    # class, which implements …