Question

我正在编写一个提供一个函数并需要初始化步骤的模块，但由于某些限制我需要在第一次调用时初始化，所以我在python中寻找合适的习惯用法，这样我就可以摆脱它有条件的。

#with conditional
module.py
initialized = False
def function(*args):
   if not initialized: initialize()
   do_the_thing(*args)

我想用这样的东西摆脱那种条件（它不起作用）：

#with no conditional
module.py
def function(*args):
   initialize()
   do_the_thing(*args)
   function = do_the_thing

我意识到我不能只在模块中使用名称并在运行时更改它们，因为使用from module import function的模块永远不会受到模块内function=other_fun的影响。
那么，有没有任何pythonic成语可以正确的方式做到这一点？

Answer 1

没什么特别的方式（我在这里发布的方法，这可能是最好的方法）：

<强> module.py：

def initialize():
    print('initialize')
def do_the_thing(args):
    print('doing things',args)
def function(args):
    _function(args)
def firsttime(args):
    global _function
    initialize()
    do_the_thing(args)
    _function=do_the_thing
_function=firsttime

这个想法很简单：你只需添加一个间接层。 function始终致电_function，但_function首先指向firsttime，然后永远指向do_the_thing。

<强> test.py：

from module import function
function(1)
function([2,3])

运行test.py yield

initialize
('doing things', 1)
('doing things', [2, 3])

我的第一个想法是使用生成器，但是，正如Triptych指出的那样，如果使用生成器，则无法将args传递给函数。所以......

这是一种使用协程的方法（与生成器不同，它允许你发送args - 以及从协同程序接收值）：

<强> module.py：

def coroutine(func):
    # http://www.dabeaz.com/coroutines/index.html
    def start(*args,**kwargs):
        cr = func(*args,**kwargs)
        cr.next()
        return cr
    return start

def initialize():
    print('initialize')

def do_the_thing(*args, **kwargs):
    print('doing things', args, kwargs)
    return ('result', args)

@coroutine
def _function():
    args, kwargs = (yield)
    initialize()
    while True:
        args, kwargs = (yield do_the_thing(*args, **kwargs))
_function = _function().send
def function(*args, **kwargs):
    # This is purely to overcome the limitation that send can only accept 1 argument
    return _function((args,kwargs))

运行

print(function(1, x = 2))
print(function([2, 3]))

产量

initialize
('doing things', (1,), {'x': 2})
('result', (1,))
('doing things', ([2, 3],), {})
('result', ([2, 3],))

Answer 2

我对此的看法：你不应该这样做。

如果您需要具有“初始化步骤”和正常工作模式的“功能”，则需要一个类实例。不要试图变得聪明，未来的代码读者会因此而讨厌你：）

# module.py

class ThingDoer(object):
    def __init__(self):
        # initialize

    def do_the_thing(self, *args):
        # ...

Answer 3

您也可以使用装饰器，如果您有几个初始化函数，它可能会更灵活：

import functools    

def initialize(initialize_function):
    def wrap(fn):
        fn.initialized = False
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            if not fn.initialized:
                initialize_function()
                fn.initialized = True
            return fn(*args, **kwargs)
        return wrapper
    return wrap

def initialize_first_fn():
    print('first function initalized')

def initialize_second_fn():
    print('second function initalized')

@initialize(initialize_first_fn)
def first_fn(*args):
   print(*args)

@initialize(initialize_second_fn)
def second_fn(*args):
   print(*args)


>>>first_fn('initialize', 'please')
first function initalized
initialize please
>>> first_fn('it works')
it works
>>> second_fn('initialize', 'please')
second function initalized
initialize please
>>> second_fn('it also works')
it also works

（需要根据您的需要进行改进）

在Python中更改函数实现

3 个答案: