小编ffe*_*rri的帖子

我想限制matplotlib中的X和Y轴,但是对于特定的子图.我可以看到subplot图本身没有任何axis属性.我想要例如只改变第二个情节的限制!

import matplotlib.pyplot as plt
fig=plt.subplot(131)
plt.scatter([1,2],[3,4])
fig=plt.subplot(132)
plt.scatter([10,20],[30,40])
fig=plt.subplot(133)
plt.scatter([15,23],[35,43])
plt.show()

我正在尝试运行这个程序

import cv2
import time

cv.NamedWindow("camera", 1)

capture = cv.CaptureFromCAM(0)

while True:
    img = cv.QueryFrame(capture)
    cv.ShowImage("camera", img)
    if cv.WaitKey(10) == 27:
        break
cv.DestroyAllWindows()

但是我遇到了numpy的问题,我正在使用pyschopy和opencv.我一直遇到的问题是这个错误报告:

RuntimeError:针对API版本7编译的模块,但此版本的numpy为6

Traceback(最近一次调用最后一次):

文件"C:\ Users\John\Documents\EyeTracking\Programs\GetImage.py",第1行,in

import cv2

Run Code Online (Sandbox Code Playgroud)

ImportError:numpy.core.multiarray无法导入

我在psychopy文件夹中有numpy-1.6.1-py2.7,我只是弄错了什么是错的？

编辑(删除的答案)

以下命令

pip install -U numpy 

有助于解决问题: could not load numpy.core.multiarray.

我有一个C标头作为C ++库的一部分。

此C标头仅由C编译器或extern "C" { ... }块内的C ++编译器编译才有意义，否则将发生未解决的链接错误。

我想添加一个块，例如：

#ifdef __cplusplus
#error "Compiling C bindings with C++ (forgot 'extern \"C\"'?)"
#endif

在C标头中，但不幸的__cplusplus是，宏也是在一个extern "C" { ... }块中定义的。

还有另一种方法可以正确检测这种情况吗？

我正在为我的存储库中的 README 文件使用 Markdown。

相对链接适用于同一个 repo 中的文件。

但我想链接子模块中的文件（以便显示与子模块相同的版本）。

用例如下：我在external/fancy-lib. 在我的存储库的 README.md 中，我想添加"please refer to fancy-lib's [README](external/fancy-lib/README.md) for info about the required packages"，但它生成了一个不存在的链接。

从fancy-lib 的存储库中添加到fancy-lib 的自述文件的链接将指向HEAD，它并不总是与我的存储库中包含的版本相同。另一方面，每次子模块更新到新版本（git pull）时手动更新链接是维护的负担。

任何解决方法？

无法找到更好地标题的方法,随意纠正.

我是Python的新手,目前正在尝试使用该语言.我注意到所有内置类型都不能与其他成员一起扩展.我想例如each在list类型中添加一个方法,但那会不可能.我意识到它是出于效率原因而设计的,并且大多数内置类型都是用C实现的.

好吧,我发现重写此行为的原因之一是定义一个新类,该类扩展list但不执行任何操作.然后我可以将变量分配list给那个新类,每次我想实例化一个新列表时,我都会使用list构造函数,就像它用来创建原始list类型一样.

class MyList(list):
    def each(self, func):
       for item in self:
           func(item)
list = MyList

my_list = list((1,2,3,4))
my_list.each(lambda x: print(x))

输出:

1
2
3
4

当然,这个想法可以通过定义获取构建类型的方法并返回扩展该类型的类来概括.此外,原始list变量可以保存在另一个变量中以保持对它的访问.

我现在面临的唯一问题是,当你list通过它的文字形式(即[1,2,3,4])实例化它时,它仍将使用原始列表构造函数(或者它是什么？).有没有办法覆盖这种行为？如果答案是否定的,您是否知道其他一些方法可以让用户扩展内置类型？(就像javascript允许扩展内置原型).

我发现内置插件的这种限制(无法向其添加成员)是Python的一个缺点,使其与其他用户定义的类型不一致......总的来说我真的很喜欢这种语言,我真的不明白为什么这样绝对是必要的.

你如何在列表理解或eval中有多行语句？

我试图改变这段代码:

def f(x, y, b=''):
    for i in x:
        if i in y:
            y.remove(i)
            i *= 2
        b += i
    return b

进入像这样的lambda函数:

j=lambda x,y:''.join(eval('y.remove(i);i*2')if i in y else i for i in x)

两者x都是一个字符串,如'onomatopoeia'和,y是一个列表,如['o','a','o'].

但由于某种原因,它返回语法错误.有谁能解释一下？

我正在尝试使用KernelPCA将数据集的维度降低到2D(用于可视化目的和进一步的数据分析).

我尝试使用不同Gamma值的RBF内核计算KernelPCA,但结果不稳定:

(每帧的Gamma值略有不同,其中Gamma从0到1连续变化)

看起来它不是确定性的.

有没有办法稳定它/使其确定性？

用于生成转换数据的代码:

def pca(X, gamma1):
    kpca = KernelPCA(kernel="rbf", fit_inverse_transform=True, gamma=gamma1)
    X_kpca = kpca.fit_transform(X)
    #X_back = kpca.inverse_transform(X_kpca)
    return X_kpca

我在python中实现了一个观察者可观察的模式:

这是Observable类:

class Observable(object):
    def __init__(self, value):
        self.value = value
        self.observers = []

    def set(self, value):
        old = self.value
        self.value = value
        self.notifyObservers(old, self.value)

    def get(self):
        return self.value

    def addObserver(self, o):
        self.observers.append(o)

    def removeObserver(self, o):
        if o in self.observers:
            self.observers.remove(o)

    def notifyObservers(self, old, new):
        for o in self.observers:
            o.valueChanged(old, new)

这是一个观察者:

class Observer(object):
    def __init__(self, foo):
        self.foo = foo
        self.foo.addObserver(self)

    def __del__(self):
        print('Observer.__del__ called')
        self.foo.removeObserver(self)

    def valueChanged(self, old, new):
        print('foo changed from %s to %s' % (old, new))

代码按预期工作.

但是我需要将 …

如果我有一个模板类

template<typename T>
class C {
public:
    void method1() { ... }
    void method2() { ... }
    std::string method3(T &t) {
        // ...
        std::string s = t.SerializeToString();
        // ...
        return s;
    }
    // ...
};

我想专门化它，T = std::string但只改变method3(T&)（保留所有其他方法），或者更好的是，只改变 method3 的那一部分，它T = std::string会简单地变成std::string s = t;，对当前代码的影响最小（减少方法签名的重复，减少子类化），我该怎么做呢？

编辑：我正在 C++11 中开发

我正在使用具有多个线程的多个解释器，并且我尝试使用它PyThreadState_SetAsyncExc来停止脚本，但它没有效果：

void stop()
{
    PyThreadState *ts = PyThreadState_Swap(this->tstate);
    PyObject *exc = PyObject_CallObject(PyExc_Exception, Py_BuildValue("(s)", "stopped"));
    int n = PyThreadState_SetAsyncExc(this->tstate->thread_id, exc);
    if(n < 1)
        std::cerr << "Script::stop: thread not found!" << std::endl;
    PyThreadState_Swap(ts);
}

返回值为1，但线程继续运行。为什么？

完整的测试用例：

#include <Python.h>
#include <iostream>
#include <thread>

using namespace std::chrono_literals;

struct Script
{
    Script()
    {
        PyThreadState *ts = PyThreadState_Get();
        this->tstate = Py_NewInterpreter();
        PyThreadState_Swap(ts);
    }

    virtual ~Script()
    {
        if(!this->tstate) return;
        PyThreadState *ts = PyThreadState_Swap(this->tstate);
        Py_EndInterpreter(this->tstate);
        PyThreadState_Swap(ts);
    }

    void run(const char *code)
    {
        PyThreadState *ts = PyThreadState_Swap(this->tstate); …