小编wil*_*ill的帖子

所以我有一个页面已经绘制了一个力导向图,就像这里显示的那样.

这很好.我从这里使用JS ,通过一些调整将节点分散得更好.

这些或多或少是唯一的区别:

d3.json("force.json", function(json) {
  var force = d3.layout.force()
      .gravity(0.1)
      .charge(-2000)
      .linkDistance(1)
      .linkStrength(0.1)
      .nodes(json.nodes)
      .links(json.links)
      .size([w, h])
      .start();

减少链接强度似乎使链接更像弹簧,因此它变得类似于经常使用的Fruchterman和Reingold技术.这种方法效果很好,但仅适用于相当小的图形.对于较大的图形,交叉的数量正在上升 - 正如人们所预料的那样,但它所依赖的解决方案通常远非最佳.我不是在寻找获得最佳解决方案的方法,我知道这非常困难.我只是希望它有一些粗略的添加,试图强制线和节点分开.

有没有办法在链接之间以及节点之间添加排斥？我不熟悉D3力的工作方式,我似乎无法找到任何说这可能的东西......

我有一个QScrollArea小部件,它从空开始;

它有一个垂直布局,一个QGridLayout和一个垂直间隔,以保持在顶部,并防止它在整个滚动区域上伸展;

在程序的其他地方,有一个QTextEdit,当它被改变时,其内容扫描"种类"元素,然后它们被添加到QGridLayout.已经除去的任何物种元素也被除去.这个位有效;

我一直打开垂直滚动条,所以当它出现时它不会位于那里的其他东西之上.请注意,尽管不需要,滚动条已经大于滚动框.

这就是问题.滚动区域似乎是预设的,我无法更改它.如果我向QGridLayout添加更多行,则滚动区域的大小不会增加.

相反,它保持相同的大小,并挤压QGridLayout,使它看起来很丑陋(起初);

然后添加更多它变得无法使用;

请注意,滚动条仍然与之前的图像大小相同.前两个图像来自Qt Designer,后续的3个来自程序运行.

如果我调整窗口大小以使QScrollArea增长,那么我看到:

指示滚动区域内的某些布局未正确调整大小.

我的问题是; 当我在QGridLayout中添加和删除时,我需要做什么才能使窗口小部件的可滚动区域动态调整大小？

如果我有两个长度相同的数组 - 比如说a和b

a = [4,6,2,6,7,3,6,7,2,5]

b = [6,4,6,3,2,7,8,5,3,5]

通常,我会这样做:

for i in range(len(a)):
    print a[i] + b[i]

而不是像这样的东西:

i=0
for number in a:
    print number + b[i]
    i += 1

因为我更喜欢与所使用的方法保持一致.

我知道zip,但我从不使用它.这是为什么zip做的？

将

for pair in zip(a,b):
    print pair[0] + pair[1]

做pythonic的方式吗？

我使用的是QSqlTableModel和QTableView查看SQLite数据库表.

我想让表每隔一秒自动刷新一次(它不会是一个非常大的表 - 几百行).我可以这样做 - 就像这样:

QTimer *updateInterval = new QTimer(this);
updateInterval->setInterval(1000);
updateInterval->start();
connect(updateInterval, SIGNAL(timeout()),this, SLOT(update_table()));

...

void MainWindow::update_table()
{
    model->select(); //QSqlTableModel*
    sqlTable->reset(); //QTableView*
}

但是这会删除我的任何选择,因此选择只持续一秒钟.这很烦人,因为GUI中的另一个窗格取决于所选择的内容.如果未选择任何内容,则会重置为解释启动页面.

然后我尝试了一种有点hacky的方法,它获取所选的行号,重置表,然后选择该行.但这也不起作用,因为所选行可以根据对表的添加来上移或下移.

我知道其他班级都有dataChanged()信号,这是理想的.

你们中的任何人都知道如何刷新表以反映数据库的更改(从命令行使用或程序的其他实例)并保持当前选择？

我知道我可以从当前选择中获取数据,然后在重置后搜索同一行然后重新选择它,但这似乎是一个适得其反的问题.

编辑:当前尝试解决方案:

void MainWindow::update_table()
{    

    QList<QModelIndex> selection = sqlTable->selectionModel()->selection().indexes();
    QList<int> selectedIDs;
    bool somethingSelected = true;

    for(QList<QModelIndex>::iterator i = selection.begin(); i != selection.end(); ++i){
        int col = i->column();
        QVariant data = i->data(Qt::DisplayRole);

    if(col == 0) {
            selectedIDs.append(data.toInt());
        }
    }

    if(selectedIDs.empty()) somethingSelected = false; …

这有什么问题？从客观和功能的角度来看？

import sys

class EncapsulationClass(object):

  def __init__(self):
    self.privates = ["__dict__", "privates", "protected", "a"]
    self.protected = ["b"]

    print self.privates

    self.a = 1
    self.b = 2
    self.c = 3
    pass

  def __getattribute__(self, name):
    if sys._getframe(1).f_code.co_argcount == 0:
      if name in self.privates:
        raise Exception("Access to private attribute \"%s\" is not allowed" % name)
      else:
        return object.__getattribute__(self, name)
    else:
      return object.__getattribute__(self, name)

  def __setattr__(self, name, value):
    if sys._getframe(1).f_code.co_argcount == 0:
      if name in self.privates:
        raise Exception("Setting private attribute \"%s\" is not allowed" % name) …

我正在尝试使用 lambda 函数来快速测试事物，但我正与它撞墙。我不知道为什么事情没有像（我觉得）应该的那样工作。

这正如我所期望的那样工作：

double(*example)(double) = [](double S)->double {return std::max(1-100/S, 0.0) * LogNormal(S, 100, 0.25); };
NewtonCotes(lowerBound, upperBound, example, intervals, order)

然而，这不会：

double(*example)(double) = [K](double S)->double {return std::max(1 - K / S, 0.0) * LogNormal(S, 100, 0.25); };

给出错误：

错误：不存在从“lambda []double(double S)->double”到“double(*)(double)”的合适转换函数。

我不明白为什么在捕获列表中添加一些东西会改变这里发生的事情。不过，我对 C++ 中的 lambdas 还很陌生，所以可能在某处犯了一个愚蠢的错误......

我需要做什么才能让它发挥作用？我已经看到一些人注意到智能感知中存在一个错误，并且像这样的事情应该可以工作，尽管这是一个略有不同的问题（至少我认为它们不完全匹配）。我也在使用 VS2013，而不是 2011 年提到的那个 bug。

我遇到的问题是,我需要从XYZ固定轴旋转转换为关于Z的欧拉旋转,然后是X',然后是Z''.

以下是相关的矩阵:

X:

Y:

Z:

结合,如Rz(psi)Ry(phi)Rx(theta)= Rxyz(theta,phi,psi); 他们给:

Rxyz:

和我想要的欧拉角特定惯例的旋转矩阵; 这是:

欧拉:

所以我最初的计划是比较矩阵元素,并提取我想要的角度; 我想出了这个(最后的实际当前代码):

但这在几种情况下不起作用.当Cos(theta)Cos(phi)== 1时最明显的是; 从那以后,Cos(beta)= 1,因此Sinβ= 0.其中Sin(beta)是代码中的s2.只有当Cos(theta)和cos(phi)= +/- 1时才会发生这种情况.

所以我马上就可以排除可能出现的情况;

当theta或phi = 0,180,360,540,...时,则Cos(θ)和Cos(phi)为+/- 1;

所以我只需要对这些案件做不同的事情;

我最终得到了这段代码:

public static double[] ZXZtoEuler(double ?, double ?, double ?){

    ? *= Math.PI/180.0;
    ? *= Math.PI/180.0;
    ? *= Math.PI/180.0;

    double ? = -1;
    double ? = -1;
    double ? = -1;

    double c2 = Math.cos(?) * Math.cos(?);

    ? = Math.acos(r(c2));

    if(eq(c2,1) || eq(c2,-1)){
        if(eq(Math.cos(?),1)){
            if(eq(Math.cos(?),1)){
                ? = 0.0;
                ? = ?;
            }else if(eq(Math.cos(?),-1)){ …

我有两个列表,x和y,我想要排序x并通过x排序的排列来置换y.例如,给定

x = [4, 2, 1, 3]
y = [40, 200, 1, 30]

我想得到

x_sorted = [1,2,3,4]
y_sorted = [1, 200, 30, 40]

正如过去的问题所讨论的,解决这个问题的一个简单方法是

x_sorted, y_sorted = zip(*sorted(zip(x,y)))

这是我的问题:最快的方法是什么？

我有三种方法来完成任务.

import numpy as np
x = np.random.random(1000)
y = np.random.random(1000)

方法1:

x_sorted, y_sorted = zip(*sorted(zip(x,y))) #1.08 ms 

方法2:

foo = zip(x,y)
foo.sort()
zip(*foo)       #1.05 ms

方法3;

ind = range(1000)
ind.sort(key=lambda i:x[i])
x_sorted = [x[i] for i in ind]
y_sorted = [y[i] for i in ind]  #934us

有没有比上述三种方法更快的执行方法？

其他问题.

1. 为什么方法2不比方法1快,尽管它使用排序方法？
2. 如果我单独执行方法2,它会更快.在IPython终端中, …

在任何人说"重复的问题"之前,请继续阅读,这与其他问题不同.

所以,当我运行我的小程序;

python numbers.py

哪里

$ file `which python`
/usr/bin/python: symbolic link to 'python2.7'

$ file `which python2.7`
/usr/bin/python2.7: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]=0x623b662458af705775fcbd2576ca06eaa82bc482, stripped

我正在使用matplotlib版本1.2;

/usr/local/lib/python2.7/dist-packages/matplotlib-1.2.0-py2.7-linux-x86_64.egg/

我已经尝试了几种方法来使它工作;

from matplotlib import pyplot as plt
import matplotlib.pyplot as plt

它们都不起作用.他们都给出了同样的错误;

$ python numbers.py
Traceback (most recent call last):
  File "numbers.py", line 1, in <module>
    import matplotlib.pyplot as plt
  File "/usr/local/lib/python2.7/dist-packages/matplotlib-1.2.0-py2.7-linux-x86_64.egg/matplotlib/pyplot.py", line 26, in <module>
    from matplotlib.figure import Figure, figaspect …

python中是否有内部处理传递给__getitem_ _自变量的参数，并自动将start:stop:step构造转换为切片的工具？

这是我的意思的示范

class ExampleClass(object):

  def __getitem__(self, *args):
    return args

  def __call__(self, *args):
    return args

  def randomMethod(self, *args):
    return args


a = ExampleClass()

#this works
print a[3:7:2, 1:11:2]

#syntax error on the first colon
print a.randomMethod(3:7:2, 1:11:2)
print a(3:7:2, 1:11:2)

#these work
print a.randomMethod(slice(3,7,2), slice(1,11,2))
print a(slice(3,7,2), slice(1,11,2))

难道仅仅是为实例解释搜索start:stop:step里面[]掉出来，并为slice(start, stop, step)？该文档只是说：

方括号（下标）表示法在内部使用切片对象

这是我无法更改其行为的python内部位之一吗？是否有可能使其他函数使用start:stop:step速记的切片对象？*

*我看到了另一个问题，可以在方括号之外使用python的切片符号吗？，但这只是使用自定义类完成的，我可以轻松做到。我想要的是一种start:stop:step无需包装即可使用的方法。

边注：

这也表明内部的所有参数[...]都打包到a中tuple，就好像它在执行[*args]->一样__getitem__(args)。 …