小编Cam*_*son的帖子

我开始认为这是不可能的,但无论如何我想问.

我想测试我的一个ES6模块以特定方式调用另一个ES6模块.使用Jasmine这非常容易 -

应用代码:

// myModule.js
import dependency from './dependency';

export default (x) => {
  dependency.doSomething(x * 2);
}

和测试代码:

//myModule-test.js
import myModule from '../myModule';
import dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    spyOn(dependency, 'doSomething');

    myModule(2);

    expect(dependency.doSomething).toHaveBeenCalledWith(4);
  });
});

什么与Jest相当？我觉得这是一件非常简单的事情,但我一直在试图弄清楚我的头发.

我最接近的import是用requires 替换s,并在测试/函数内移动它们.这些都不是我想要做的事情.

// myModule.js
export default (x) => {
  const dependency = require('./dependency'); // yuck
  dependency.doSomething(x * 2);
}

//myModule-test.js
describe('myModule', () => {
  it('calls the …

最近我和一位非编码人员就国际象棋电脑的可能性进行了讨论.我不太懂理论,但想想我已经足够了解.

我认为不存在确定性的图灵机总是在国际象棋中获胜或陷入僵局.我认为,即使你搜索了玩家1/2移动的所有组合的整个空间,计算机在每一步决定的单一动作都是基于启发式的.基于启发式,它不一定能击败对手可以做的所有动作.

相反,我的朋友认为,如果计算机永远不会做出"错误"动作,那么计算机将永远胜出或结合(但是你定义了吗？).然而,作为一名采用CS的程序员,我知道即使你的好选择 - 给予明智的对手 - 也会迫使你最终做出"错误"的动作.即使你知道所有事情,你的下一步行动也是贪婪地匹配启发式.

大多数国际象棋计算机都试图将可能的最终游戏与正在进行的游戏相匹配,这本质上是一个动态的编程追溯.同样,有问题的最后阶段是可以避免的.

编辑:嗯......看起来我在这里乱了一些羽毛.非常好.

再考虑一下,似乎解决像国际象棋这样的有限游戏没有理论上的问题.我认为国际象棋比跳棋更复杂,因为胜利不一定是数字耗尽,而是通过配偶.我最初的断言可能是错误的,但我认为我已经指出了一些尚未得到令人满意的证明(正式).

我想我的思想实验是,无论何时树中的分支被采用,那么算法(或记忆路径)必须找到对手移动的任何可能分支的配偶路径(不进行交配).在讨论之后,我会购买比我们可能梦想的更多的内存,所有这些路径都可以找到.

默认的webpack CLI输出对我来说太冗长了.一旦我从我的一个文件导入React,输出就会爆炸,显示所有正在打包的块(？):

webpack result is served from /
content is served from /Users/me/myproject
Hash: aaaf5afc6582f3222f55
Version: webpack 1.12.14
Time: 1175ms
   Asset    Size  Chunks             Chunk Names
index.js  677 kB       0  [emitted]  main
chunk    {0} index.js (main) 643 kB [rendered]
    [0] ./src/app.js 574 bytes {0} [built] [1 error]
    [1] ./~/react/react.js 56 bytes {0} [built]
    [2] ./~/react/lib/React.js 1.49 kB {0} [built]
    [3] ./~/react/lib/ReactDOM.js 3.71 kB {0} [built]
    [4] ./~/process/browser.js 2.06 kB {0} [built]

...

  [155] ./~/fbjs/lib/mapObject.js 1.47 kB {0} [built]
  [156] ./~/react/lib/onlyChild.js 1.21 …

我的应用程序允许用户创建和删除Site对象.我使用session.add()和实现了这个session.delete().然后,我有"保存"和"重置"是呼叫按钮session.commit()和session.rollback().

如果我添加一个新的Site,然后保存/提交它,然后删除它,一切正常.但是,如果我尝试在保存之前从会话中删除对象,则会出现"非持久性"错误.

码:

self.newSite = Site('foo')
self.session.add(self.newSite)
print self.session.new
self.session.delete(self.newSite)

输出:

IdentitySet([<Site('foo')>])

Traceback (most recent call last):
  File "C:\Program Files\Eclipse\dropins\plugins\org.python.pydev.debug_2.2.1.2011071313\pysrc\pydevd_comm.py", line 744, in doIt
    result = pydevd_vars.evaluateExpression(self.thread_id, self.frame_id, self.expression, self.doExec)
  File "C:\Program Files\Eclipse\dropins\plugins\org.python.pydev.debug_2.2.1.2011071313\pysrc\pydevd_vars.py", line 375, in evaluateExpression
    result = eval(compiled, updated_globals, frame.f_locals)
  File "<string>", line 1, in <module>
  File "C:\Python27\Lib\site-packages\sqlalchemy\orm\session.py", line 1245, in delete
    mapperutil.state_str(state))
InvalidRequestError: Instance '<Site at 0x1ed5fb0>' is not persisted

我理解这里发生了什么,但我不确定我应该做什么.

是否有其他方法可以从会话中删除尚未持久化的对象？或者我应该session.flush()在尝试删除之前调用,以防我要删除的对象尚未刷新？

如果是后者,那么如何 …

tl; dr:我想预测文件复制完成.考虑到开始时间和当前进度,有哪些好的方法？

首先,我知道这根本不是一个简单的问题,预测未来很难做好.对于上下文,我试图预测长文件副本的完成.

目前的方法:

目前,我正在使用一个我自己提出的相当天真的公式:(ETC代表估计的完成时间)

ETC = currTime + elapsedTime * (totalSize - sizeDone) / sizeDone

这是基于这样的假设,即要复制的剩余文件将以迄今为止的平均复制速度进行,这可能是也可能不是一个现实的假设(在这里处理磁带存档).

• PRO: ETC将逐渐变化,并随着过程接近完成而变得越来越准确.
• CON:它对意外事件没有很好的反应,例如文件副本卡住或快速加速.

另一个想法:

我的下一个想法是记录最后n秒(或分钟,因为这些档案应该花费数小时)的进度,并且只做以下事情:

ETC = currTime + currAvg * (totalSize - sizeDone)

这与第一种方法相反:

• PRO:如果速度变化很快,ETC将快速更新以反映当前的状况.
• CON:如果速度不一致,ETC可能会跳转很多.

最后

我想起了我在大学所做的控制工程课程,其目标主要是试图让系统对突然变化做出快速反应,但不是不稳定和疯狂.

话虽如此,我能想到的另一个选择是计算上述两者的平均值,也许是通过某种加权:

• 如果副本具有相当一致的长期平均速度,即使它在本地跳跃一点,也可以对第一种方法进行加权.
• 如果复制速度不可预测,则更多地对第二种方法进行加权,并且可能会长时间加速/减速,或者长时间停止.

我真正要求的是:

• 我给出的两种替代方法.
• 是否以及如何组合几种不同的方法来获得最终预测.

原始情况:

我正在处理的应用程序将在特定文件已添加数据并准备好读取时接收来自另一个应用程序的通知.目前我有这样的事情:

class Foo(object):
    def __init__(self):
        self.myFile = open("data.txt", "r")
        self.myFile.seek(0, 2) #seeks to the end of the file

        self.mainWindow = JFrame("Foo",
                                 defaultCloseOperation = JFrame.EXIT_ON_CLOSE,
                                 size = (640, 480))
        self.btn = JButton("Check the file", actionPerformed=self.CheckFile)
        self.mainWindow.add(self.btn)
        self.mainWindow.visible = True

    def CheckFile(self, event):
        while True:
            line = self.myFile.readline()
            if not line:
                break
            print line

foo = Foo()

最终,当在套接字上收到某个消息时,将触发CheckFile().目前,我正在从JButton触发它.

尽管程序中的任何其他位置都没有触及该文件,并且我没有with在文件上使用该文件,但是ValueError: I/O operation on closed file当我尝试readline()它时,我仍然继续使用该文件.

初步解决方案

在试图弄清楚文件何时被关闭时,我将我的应用程序代码更改为:

foo = Foo()
while True:
    if foo.myFile.closed == True: …

我的问题的症状几乎完全匹配这个问题:更改的静态文件被裁剪/填充到新的大小并提供旧的 - Fedora

每当我更改静态文件(例如.js和.css)时,这些更改都不会显示在服务文件中.但是,如果我的更改导致文件更改长度,则服务文件确实与新长度匹配:

• 如果我从静态文件中的任何位置删除字符,那么最后会通过那么多字符修剪服务文件.
• 如果我将字符添加到静态文件中的任何位置,那么服务文件将在末尾填充许多 (即U + FFFD)字符.

链接答案无法解决我的问题的原因是我没有使用Apache.我正在为Heroku编写一个Python Web应用程序,所以我使用的是gunicorn和Flask(因此也是Werkzeug).链接的答案说,在Apache中禁用sendfile解决了这个问题,所以我尝试将'USE_X_SENDFILE'变量设置为False,如此页面,但它没有帮助.我还将'SEND_FILE_MAX_AGE_DEFAULT'设置为1以进一步尝试防止某种缓存发生,这也没有帮助.

如果不是很明显,我真的不太了解配置Web服务器,所以在用完相关的Google点击后,我不知道是什么原因造成的.救命？

 class Person():
    pass;
 def say_hi(self):
    print 'hii'

 me=Person()
 me.say_hi=say_hi
 me.say_hi()

是不是在python中自动传递了self参数？为什么调用me.say_hi()给出堆栈跟踪？

Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: say_hi() takes exactly 1 argument (0 given)

试图在Python中设置一些基本的套接字代码(好吧,Jython,但我不认为这与此相关).

import socket
class Foo(object):
    def __init__(self):
        #some other init code here

        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect("localhost", 2057)
        s.send("Testing 1,2,3...")
        data = s.recv()
        s.close()
        print data

它告诉我:

    s.connect("localhost", 2057)
  File "<string>", line 1, in connect
TypeError: connect() takes exactly 2 arguments (3 given)

Run Code Online (Sandbox Code Playgroud)

我觉得一些非常简单的感觉就是盯着我看,但我不知道我做错了什么.

我有两张桌子,SystemVariables和VariableOptions.SystemVariables应该是不言自明的,并VariableOptions包含所有变量的所有可能选择.

VariableOptions有一个外键,variable_id它指出哪个变量是一个选项.SystemVariables有一个外键,choice_id它指出哪个选项是当前选择的选项.

我已经利用use_alteron choice_id和post_updateon SystemVariables' choice关系绕过了循环关系.但是,我想添加一个额外的数据库约束,以确保它choice_id是有效的(即它指的是一个引用它的选项).

假设sysVar代表SystemVariables表中的一行,我需要的逻辑基本上是:

VariableOptions[sysVar.choice_id].variable_id == sysVar.id

但我不知道如何使用SQL,声明式或任何其他方法构造这种约束.如果有必要,我可以在应用程序级别验证这一点,但如果可能的话,我想在数据库级别进行验证.我正在使用Postgres 9.1.

这可能吗？