小编hal*_*fak的帖子

我似乎无法使用鼻子测试框架来识别文件结构中测试脚本下面的模块.我已经设置了一个最简单的例子来演示这个问题.我将在下面解释.

这是包文件结构:

./__init__.py
./foo.py
./tests
   ./__init__.py
   ./test_foo.py

foo.py包含:

def dumb_true():
    return True

tests/test_foo.py包含:

import foo

def test_foo():
    assert foo.dumb_true()

两个init .py文件都是空的

如果我nosetests -vv在主目录(foo.py所在)中运行,我得到:

Failure: ImportError (No module named foo) ... ERROR

======================================================================
ERROR: Failure: ImportError (No module named foo)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/usr/lib/python/site-packages/nose-0.11.1-py2.6.egg/nose/loader.py", line 379, in loadTestsFromName
    addr.filename, addr.module)
  File "/usr/lib/python/site-packages/nose-0.11.1-py2.6.egg/nose/importer.py", line 39, in importFromPath
    return self.importFromDir(dir_path, fqname)
  File "/usr/lib/python/site-packages/nose-0.11.1-py2.6.egg/nose/importer.py", line 86, in importFromDir
    mod = load_module(part_fqname, fh, filename, desc)
  File …

似乎在生成器表达式(test1)周围使用[]表现得比将它放在list()(test2)中要好得多.当我只是将列表传递给list()以进行浅拷贝(test3)时,速度就不存在了.为什么是这样？

证据:

from timeit import Timer

t1 = Timer("test1()", "from __main__ import test1")
t2 = Timer("test2()", "from __main__ import test2")
t3 = Timer("test3()", "from __main__ import test3")

x = [34534534, 23423523, 77645645, 345346]

def test1():
    [e for e in x]

print t1.timeit()
#0.552290201187


def test2():
    list(e for e in x)

print t2.timeit()
#2.38739395142

def test3():
    list(x)

print t3.timeit()
#0.515818119049

机器:64位AMD,Ubuntu 8.04,Python 2.7(r27:82500)

我正试图利用PostgreSQL中的多列btree索引在两个表之间执行恼人的连接.

               Table "revision_main"
     Column     |          Type          | Modifiers 
----------------+------------------------+-----------
 revision_id    | integer                | 
 page_id        | integer                | 

Indexes:
    "revision_main_pkey" UNIQUE, btree (revision_id)
    "revision_main_cluster_idx" btree (page_id, "timestamp") CLUSTER

此表包含Wiki中页面的修订版(约3亿行).我的表中有更多的列,但是我已经放弃了这个例子,因为它们无关紧要.

               Table "revert"
       Column       |  Type   | Modifiers 
--------------------+---------+-----------
 page_id            | integer | 
 revision_id        | integer | 
 reverted_to        | integer | 
Indexes:
    "revert_page_between_idx" btree (page_id, reverted_to, revision_id) CLUSTER

该表包含恢复修订版(约2200万行).如果已恢复修订,则该revision_id将在revision_main表中有一行,其revision_id将在reverted_to和revision_id之间,并共享相同的page_id.(如果你很好奇,请参阅http://en.wikipedia.org/wiki/Wikipedia:Revert.)

加入这两个表以获得恢复的修订似乎很简单.这是我提出的:

explain SELECT
    r.revision_id,
    rvt.revision_id
FROM revision_main r
INNER JOIN revert rvt 
    ON r.page_id = rvt.page_id 
    AND r.revision_id > rvt.reverted_to
    AND r.revision_id …

当我使用自定义可调用类作为包装器时,我正在努力挑选包装函数.

我有一个可调用的类"Dependee",它使用成员变量"depends_on"跟踪包装函数的依赖关系.我想使用装饰器来包装函数,并且还能够修改生成的包装函数.

所以我定义了我的dependee类.注意functools.update_wrapper的使用.

>>> class Dependee:
...     
...     def __init__(self, func, depends_on=None):
...         self.func = func
...         self.depends_on = depends_on or []
...         functools.update_wrapper(self, func)
...         
...     def __call__(self, *args, **kwargs):
...         return self.func(*args, **kwargs)
... 

然后我定义我的装饰器,它将返回Dependee包装类的一个实例.

>>> class depends:
...     
...     def __init__(self, on=None):
...         self.depends_on = on or []
...     
...     def __call__(self, func):
...         return Dependee(func, self.depends_on)
... 

这是一个包装函数的示例.

>>> @depends(on=["foo", "bar"])
... def sum(x, y): return x+y
... 

成员变量似乎是可访问的.

>>> print(sum.depends_on)
['foo', 'bar']

我可以按预期调用该函数.

>>> print(sum(1,2)) …