我正在开发一个文档测试框架——基本上是 PDF 的单元测试。测试是由框架定义的类实例的（修饰的）方法，它们在运行时被定位和实例化，并且调用这些方法来执行测试。
我的目标是减少编写测试的人需要关注的古怪 Python 语法的数量，因为这些人可能是也可能不是 Python 程序员，甚至根本不是程序员。所以我希望他们能够为方法编写“def foo():”而不是“def foo(self):”，但仍然能够使用“self”来访问成员。
在一个普通的程序中，我认为这是一个可怕的想法，但在像这样的特定领域语言的程序中，它似乎值得一试。
我已经通过使用装饰器成功地从方法签名中消除了 self （实际上，因为我已经在测试用例中使用了装饰器，所以我只是将它放入其中），但是“self”并没有引用测试用例方法。
我考虑过为 self 使用全局，甚至想出一个或多或少可行的实现，但我宁愿污染尽可能小的命名空间，这就是为什么我更愿意将变量直接注入测试用例方法的本地命名空间。有什么想法吗？
我对这个问题的接受答案非常愚蠢，但我才刚刚开始。这是一个更好的方法。这只是经过很少的测试，但它有利于演示正确的方法来做这件不合适的事情。它肯定适用于 2.6.5。我没有测试任何其他版本，但没有硬编码操作码，因此它应该与大多数其他 2.x 代码一样可移植。
add_self可以用作装饰器，但这会破坏目的（为什么不只输入'self'？）从我的其他答案中调整元类来应用此功能会很容易。
import opcode
import types
def instructions(code):
"""Iterates over a code string yielding integer [op, arg] pairs
If the opcode does not take an argument, just put None in the second part
"""
code = map(ord, code)
i, L = 0, len(code)
extended_arg = 0
while i < L:
op = code[i]
i+= 1
if op < opcode.HAVE_ARGUMENT:
yield [op, None]
continue
oparg = code[i] + (code[i+1] << 8) + extended_arg
extended_arg = 0
i += 2
if op == opcode.EXTENDED_ARG:
extended_arg = oparg << 16
continue
yield [op, oparg]
def write_instruction(inst):
"""Takes an integer [op, arg] pair and returns a list of character bytecodes"""
op, oparg = inst
if oparg is None:
return [chr(op)]
elif oparg <= 65536L:
return [chr(op), chr(oparg & 255), chr((oparg >> 8) & 255)]
elif oparg <= 4294967296L:
# The argument is large enough to need 4 bytes and the EXTENDED_ARG opcode
return [chr(opcode.EXTENDED_ARG),
chr((oparg >> 16) & 255),
chr((oparg >> 24) & 255),
chr(op),
chr(oparg & 255),
chr((oparg >> 8) & 255)]
else:
raise ValueError("Invalid oparg: {0} is too large".format(oparg))
def add_self(f):
"""Add self to a method
Creates a new function by prepending the name 'self' to co_varnames, and
incrementing co_argcount and co_nlocals. Increase the index of all other locals
by 1 to compensate. Also removes 'self' from co_names and decrease the index of
all names that occur after it by 1. Finally, replace all occurrences of
`LOAD_GLOBAL i,j` that make reference to the old 'self' with 'LOAD_FAST 0,0'.
Essentially, just create a code object that is exactly the same but has one more
argument.
"""
code_obj = f.func_code
try:
self_index = code_obj.co_names.index('self')
except ValueError:
raise NotImplementedError("self is not a global")
# The arguments are just the first co_argcount co_varnames
varnames = ('self', ) + code_obj.co_varnames
names = tuple(name for name in code_obj.co_names if name != 'self')
code = []
for inst in instructions(code_obj.co_code):
op = inst[0]
if op in opcode.haslocal:
# The index is now one greater because we added 'self' at the head of
# the tuple
inst[1] += 1
elif op in opcode.hasname:
arg = inst[1]
if arg == self_index:
# This refers to the old global 'self'
if op == opcode.opmap['LOAD_GLOBAL']:
inst[0] = opcode.opmap['LOAD_FAST']
inst[1] = 0
else:
# If `self` is used as an attribute, real global, module
# name, module attribute, or gets looked at funny, bail out.
raise NotImplementedError("Abnormal use of self")
elif arg > self_index:
# This rewrites the index to account for the old global 'self'
# having been removed.
inst[1] -= 1
code += write_instruction(inst)
code = ''.join(code)
# type help(types.CodeType) at the interpreter prompt for this one
new_code_obj = types.CodeType(code_obj.co_argcount + 1,
code_obj.co_nlocals + 1,
code_obj.co_stacksize,
code_obj.co_flags,
code,
code_obj.co_consts,
names,
varnames,
'<OpcodeCity>',
code_obj.co_name,
code_obj.co_firstlineno,
code_obj.co_lnotab,
code_obj.co_freevars,
code_obj.co_cellvars)
# help(types.FunctionType)
return types.FunctionType(new_code_obj, f.func_globals)
class Test(object):
msg = 'Foo'
@add_self
def show(msg):
print self.msg + msg
t = Test()
t.show('Bar')
aaronasterling 的解决方案的小升级（我没有足够的声誉来评论它）：
def wrap(f):
@functools.wraps(f)
def wrapper(self,*arg,**kw):
f.func_globals['self'] = self
return f(*arg,**kw)
return wrapper
但是如果为不同的实例递归调用 f 函数，这两种解决方案都将无法预测，因此您必须像这样克隆它：
import types
class wrap(object):
def __init__(self,func):
self.func = func
def __get__(self,obj,type):
new_globals = self.func.func_globals.copy()
new_globals['self'] = obj
return types.FunctionType(self.func.func_code,new_globals)
class C(object):
def __init__(self,word):
self.greeting = word
@wrap
def greet(name):
print(self.greeting+' , ' + name+ '!')
C('Hello').greet('kindall')
这是一个单行方法装饰器，它似乎可以在不修改标记为 Read-only 的 Callable types* 的任何特殊属性的情况下完成这项工作：
# method decorator -- makes undeclared 'self' argument available to method
injectself = lambda f: lambda self: eval(f.func_code, dict(self=self))
class TestClass:
def __init__(self, thing):
self.attr = thing
@injectself
def method():
print 'in TestClass::method(): self.attr = %r' % self.attr
return 42
test = TestClass("attribute's value")
ret = test.method()
print 'return value:', ret
# output:
# in TestClass::method(): self.attr = "attribute's value"
# return value: 42
请注意，除非您采取预防措施来防止它，否则该功能的副作用eval()可能是它会自动添加一些条目 - 例如__builtin__对键下模块的引用__builtins__- 自动dict传递给它。
@kendall：根据您对容器类中的方法如何使用它的评论（但暂时忽略其他变量的注入） - 以下是您正在做的事情吗？我很难理解框架和用户编写的内容之间是如何划分的。对我来说，这听起来像是一个有趣的设计模式。
# method decorator -- makes undeclared 'self' argument available to method
injectself = lambda f: lambda self: eval(f.func_code, dict(self=self))
class methodclass:
def __call__():
print 'in methodclass::__call__(): self.attr = %r' % self.attr
return 42
class TestClass:
def __init__(self, thing):
self.attr = thing
method = injectself(methodclass.__call__)
test = TestClass("attribute's value")
ret = test.method()
print 'return value:', ret
# output
# in methodclass::__call__(): self.attr = "attribute's value"
# return value: 42
诀窍是将“自我”添加到f.func_globals. 这适用于python2.6。我真的应该安装其他版本来测试这样的东西。对不起代码墙，但我介绍了两种情况：使用元类和装饰器。对于你的用例，我认为元类更好，因为这个练习的重点是保护用户免受语法的影响。
import new, functools
class TestMeta(type):
def __new__(meta, classname, bases, classdict):
for item in classdict:
if hasattr(classdict[item], '__call__'):
classdict[item] = wrap(classdict[item])
return type.__new__(meta, classname, bases, classdict)
def wrap(f):
@functools.wraps(f)
def wrapper(self):
f.func_globals['self'] = self
return f()
return wrapper
def testdec(f):
@functools.wraps(f)
def wrapper():
return f()
return wrapper
class Test(object):
__metaclass__ = TestMeta
message = 'You can do anything in python'
def test():
print self.message
@testdec
def test2():
print self.message + ' but the wrapper funcion can\'t take a self argument either or you get a TypeError'
class Test2(object):
message = 'It also works as a decorator but (to me at least) feels better as a metaclass'
@wrap
def test():
print self.message
t = Test()
t2 = Test2()
t.test()
t.test2()
t2.test()
这可能是装饰器的一个用例——你给他们一小组乐高积木来构建功能，复杂的框架东西通过管道@testcase或类似的管道输入。
编辑：您没有发布任何代码，所以这将是粗略的，但他们不需要编写方法。他们可以编写没有“self”的普通函数，你可以使用我链接的文章中的这个例子中的装饰器：
class myDecorator(object):
def __init__(self, f):
print "inside myDecorator.__init__()"
f() # Prove that function definition has completed
def __call__(self):
print "inside myDecorator.__call__()"
@myDecorator
def aFunction():
print "inside aFunction()"