我正在使用Eclipse CDT.我已经配置了"外部构建器",我自动生成Makefile.不幸的是,生成的Makefile包含绝对包含路径.我想在其他系统上使用生成的Makefile(没有安装Eclipse) - 有没有办法让Eclipse使用相对路径进入Makefile？
我已使用$ {workspace_log}在设置 - >工具设置 - > GCC C编译器 - >包含路径下配置了我的项目包含目录.
我正在尝试制作粒子轨迹的视频.但是,某种程度上我的场景永远不会更新 这是一个非常简单的例子:
from __future__ import absolute_import, division, print_function
from mayavi import mlab
import numpy as np
import math
alpha = np.linspace(0, 2*math.pi, 100)
xs = np.cos(alpha)
ys = np.sin(alpha)
zs = np.zeros_like(xs)
mlab.points3d(0,0,0)
plt = mlab.points3d(xs[:1], ys[:1], zs[:1])
@mlab.animate(delay=100)
def anim():
f = mlab.gcf()
while True:
for (x, y, z) in zip(xs, ys, zs):
print('Updating scene...')
plt.mlab_source.x[0] = x
plt.mlab_source.y[0] = y
plt.mlab_source.z[0] = z
f.scene.render()
yield
anim()
mlab.show()
如果我运行此脚本,它会显示一个包含两个点和动画GUI的窗口.它还在终端上打印连续的"正在更新场景..."消息流.但是,场景根本不显示任何移动.
我究竟做错了什么？
Python 2.7,Mayavi 4.1,VTK 5.8
我有一系列由(x,y)对组成的轨迹.我想使用样条插入这个轨迹上的点.
我该怎么做呢？使用scipy.interpolate.UnivariateSpline不起作用,因为x和y都不是单调的.我可以引入参数化(例如沿着轨迹的长度d),但是我有两个因变量x(d)和y(d).
例:
import numpy as np
import matplotlib.pyplot as plt
import math
error = 0.1
x0 = 1
y0 = 1
r0 = 0.5
alpha = np.linspace(0, 2*math.pi, 40, endpoint=False)
r = r0 + error * np.random.random(len(alpha))
x = x0 + r * np.cos(alpha)
y = x0 + r * np.sin(alpha)
plt.scatter(x, y, color='blue', label='given')
# For this special case, the following code produces the …我想出了以下代码来使用装饰器来装饰实例方法,该装饰器需要将实例本身作为参数:
from functools import wraps
def logging_decorator(tricky_instance):
def wrapper(fn):
@wraps(fn)
def wrapped(*a, **kw):
if tricky_instance.log:
print("Calling %s.." % fn.__name__)
return fn(*a, **kw)
return wrapped
return wrapper
class Tricky(object):
def __init__(self, log):
self.log = log
self.say_hi = logging_decorator(self)(self.say_hi)
def say_hi(self):
print("Hello, world!")
i1 = Tricky(log=True)
i2 = Tricky(log=False)
i1.say_hi()
i2.say_hi()
这似乎很有效,但我担心我可能忽略了这个技巧的一些无意识的副作用.我是要在脚下拍自己,还是这样安全？
请注意,我实际上并不想将其用于日志记录,这只是我能想到的最有意义的例子.
该泡菜模块文档右一开始说:
警告:pickle模块不能防止错误或恶意构造的数据.切勿取消从不受信任或未经身份验证的来源收到的数据.
然而,在限制全局变量的情况下,它似乎描述了一种使用允许对象的白名单来使unpickling数据安全的方法.
这是否意味着如果我使用RestrictedUnpickler仅允许某些"基本"类型的数据,或者是否存在此方法无法解决的其他安全问题,我是否可以安全地解开不受信任的数据？如果有,还有另一种方法可以使unpickling安全(显然代价是无法解开每个流)吗？
对于"基本类型",我的意思是:
boolstr,bytes,bytearrayint,float,complextuple,list,dict,set和frozenset请考虑以下代码:
#include <stdio.h>
#include <time.h>
#include <math.h>
// Compile with gcc -lrt -lm -o test_clock test_clock.c
#define CLOCK CLOCK_MONOTONIC
int main(int argc, char** argv) {
double temp, elapsed;
int j;
struct timespec requestStart, requestEnd, req;
// Pseudo-sleep
clock_gettime(CLOCK, &requestStart);
temp = 0;
for(j=0; j < 40; j++)
temp += sin(j);
clock_gettime(CLOCK, &requestEnd);
elapsed = ( requestEnd.tv_sec - requestStart.tv_sec ) / 1e-6
+ ( requestEnd.tv_nsec - requestStart.tv_nsec ) / 1e3;
printf("Elapsed: %lf us\n", elapsed);
// Nanosleep
clock_gettime(CLOCK, &requestStart);
req.tv_nsec = 5000; …我想使用符号版本控制和链接时优化(LTO)编译共享库.但是,只要我打开LTO,一些导出的符号就会消失.这是一个最小的例子:
首先定义函数fun的两个实现:
$ cat fun.c
#include <stdio.h>
int fun1(void);
int fun2(void);
__asm__(".symver fun1,fun@v1");
int fun1() {
printf("fun1 called\n");
return 1;
}
__asm__(".symver fun2,fun@@v2");
int fun2() {
printf("fun2 called\n");
return 2;
}
创建版本脚本以确保仅导出乐趣:
$ cat versionscript
v1 {
global:
fun;
local:
*;
};
v2 {
global:
fun;
} v1;
第一次尝试,没有LTO编译:
$ gcc -o fun.o -Wall -Wextra -O2 -fPIC -c fun.c
$ gcc -o libfun.so.1 -shared -fPIC -Wl,--version-script,versionscript fun.o
$ nm -D --with-symbol-versions libfun.so.1 | grep fun
00000000000006b0 …libidl.so.7.1的路径在ld.so.conf中,并且库也在缓存中:
$ /sbin/ldconfig -p | grep libidl.so.7.1
libidl.so.7.1 (libc6) => /opt/itt/idl71/bin/bin.linux.x86/libidl.so.7.1
但是,由于某种原因,ldd找不到它:
$ ldd _pyIDLmodule.so | grep libidl.so.7.1
libidl.so.7.1 => not found
然而,如果我明确地将路径添加到LD_LIBRARY_PATH,它的工作原理如下:
$ export LD_LIBRARY_PATH=/opt/itt/idl71/bin/bin.linux.x86_64/
$ ldd _pyIDLmodule.so | grep libidl.so.7.1
libidl.so.7.1 => /opt/itt/idl71/bin/bin.linux.x86_64/libidl.so.7.1 (0x00002b7428ee7000)
我究竟做错了什么？为什么ldd找不到图书馆？
tempfile.NamedTemporaryFile()说的描述:
如果delete为true(默认值),则文件一关闭就会被删除.
在某些情况下,这意味着在Python解释器结束后不会删除该文件.例如,在下面运行以下测试时
py.test,临时文件仍然是:
from __future__ import division, print_function, absolute_import
import tempfile
import unittest2 as unittest
class cache_tests(unittest.TestCase):
def setUp(self):
self.dbfile = tempfile.NamedTemporaryFile()
def test_get(self):
self.assertEqual('foo', 'foo')
在某种程度上这是有道理的,因为该程序从不显式关闭文件对象.对象关闭的唯一另一种方式可能是在__del__析构函数中,但是这里语言引用指出" 不保证__del__()在解释器退出时仍然存在的对象调用方法. "所以一切都与迄今为止的文件.
但是,我对此的含义感到困惑.如果不能保证在解释器出口处关闭文件对象,那么即使程序正常退出,也可能发生成功写入(缓冲)文件对象的某些数据丢失,因为它仍然在文件对象的缓冲区中,文件对象永远不会关闭？
不知何故,这对我来说似乎非常不可能和非pythonic,open()文档也不包含任何此类警告.所以我(暂时)得出结论,文件对象毕竟是保证关闭的.
但是这个魔法是如何发生的,为什么不能NamedTemporaryFile()使用相同的魔法来确保文件被删除？
编辑:请注意,我不是在谈论文件描述符(由操作系统缓冲并在程序退出时由操作系统关闭),而是关于可能实现自己缓冲的Python文件对象.
这个问题似乎在StackOverflow和其他地方经常出现,但我无法在任何地方找到一个完全令人满意的解决方案.
似乎有两种类型的常见解决方案.第一个(例如http://article.gmane.org/gmane.comp.python.general/630549)使用函数装饰器:
class SuperClass:
def my_method(self):
'''Has a docstring'''
pass
class MyClass(SuperClass):
@copy_docstring_from(SuperClass)
def my_method(self):
pass
assert SuperClass.my_method.__doc__ == MyClass.my_method._doc__
这可能是最简单的方法,但它需要至少重复一次父类名称,如果在直接祖先中找不到docstring,它也会变得更加复杂.
第二种方法使用元类或类装饰器(参见Python中的继承方法'docstrings,将父类docstring继承为__doc__属性,http ://mail.python.org/pipermail/python-list/2011-June/606043 . html),看起来像这样:
class MyClass1(SuperClass, metaclass=MagicHappeningHere):
def method(self):
pass
# or
@frobnicate_docstrings
class MyClass2(SuperClass):
def method(self):
pass
assert SuperClass.my_method.__doc__ == MyClass1.my_method._doc__
assert SuperClass.my_method.__doc__ == MyClass2.my_method._doc__
但是,使用此方法,docstring仅在创建类后设置,因此装饰器无法访问,因此以下操作无效:
def log_docstring(fn):
print('docstring for %s is %s' % (fn.__name__, fn.__doc__)
return fn
class MyClass(SuperClass, metaclass=MagicHappeningHere):
# or
#@frobnicate_docstrings
#class MyClass2(SuperClass):
@log_docstring
def method(self):
pass …