5

I am writing a module that provides one function and needs an initialization step, however due to certain restrictions I need to initialize on first call, so I am looking for the proper idiom in python that would allow me to get rid of the conditional.

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

I'd like to get rid of that conditional with something like this(it does not work): 

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

I realize that I cannot just use names in the module and change them at runtime because modules using from module import function will never be affected with a function=other_fun inside the module.
So, is there any pythonic idiom that could do this the right way?

Improve this question
2
  • google for 'python decorator' Commented Nov 5, 2011 at 12:42
  • I don't see how a decorator could do this, the conditional still remains there if you test @graphox solution, using a generator works as expected although it feels a bit weird. Commented Nov 5, 2011 at 13:12

3 Answers 3

Reset to default
8

The nothing-fancy way (of the methods I post here, this is probably the best way to do it):

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

The idea is simple: you just add a layer of indirection. function always calls _function, but _function points first at firsttime, then forever after at do_the_thing.

test.py:

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

Running test.py yields

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

My first thought was to use a generator, but, as Triptych points out, there is no way to pass args to the function if you use a generator. So...

here is a way using a coroutine (which, unlike a generator, allows you to send args to -- as well as receive values from -- the coroutine):

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))

Running

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

yields

initialize
('doing things', (1,), {'x': 2})
('result', (1,))
('doing things', ([2, 3],), {})
('result', ([2, 3],))
Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

this runs the initialize step at module load time, not at first invocation as OP requested...
@Triptych: I do not believe that is true. Have you tested it?
ah misread next as though it were next(). My bad... Still curious how you'd write to take arguments. Doesn't next have to be a zero-argument function? Seems just... weird to me.
@unutbu: this is a very cool example. I love finding another generator usage very much, thank you :)
I'm pretty sure hijacking .next like that will make Python complain if any args are sent...
|
3

My take on this: you shouldn't do this.

In case you need a "function" which has "initialization step" and normal work mode, you need a class instance. Do not try to be clever, future readers of your code would hate you for that :)

# module.py

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

    def do_the_thing(self, *args):
        # ...
Improve this answer

Comments

2

You could also use a decorator, it's maybe more flexible if you have several functions to initialize:

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

(needs to be improved depending on your needs)

Improve this answer

9 Comments

Hmm, does the wrapper code execute every call? I mean, the conditional would still be there on the second call, just evaluating to false, wouldn't it?
I'd use @functools.wraps(fn) on the def wrapper. That way the function you get back looks like the original function (first_fn, etc.). I'd probably also use a class-based decorator.
I have just tested it and indeed, the "if not initialized" still happens every call, which is what I wanted to remove. :(
pastebin.com/7j0kMWwH Check how "testing conditional" gets printed every time. It succeeds executing the initializer once, but it doesn't remove the conditional later so we still test for initialized every time although we only execute it once. As it is right now it does not do anything more than my first code chunk that actually works.
So, where's the problem? It's the goal of the decorator.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.