Python - how to abstract common starting/ending code

Question

I have a bunch of methods which all look something like this:

def myFunc():
    ...
    {initialise stuff}
    {do stuff}
    {finalise stuff}
    ...

where {initialise stuff} and {finalise stuff} are identical for each method, and {do stuff} may use variables defined in {initialise stuff}.

To avoid repetition, I'd like to put {initialise stuff} and {finalise stuff} in a separate method, which could be called from inside myFunc(). So, something like this:

def wrap(innerMethod):
    vars = {initialise stuff}
    innerMethod(vars)
    {finalise stuff}

def myFunc():
    ...
    wrap(lambda vars :
        {do stuff}
    )
    ...

Unfortunately, it seems that code blocks can't be passed as arguments in Python (unless this feature has been added in the last 2 years). Therefore, this doesn't seem to work if {do stuff} is longer than a single line. I could put {do stuff} into a separate method, but I'd rather not since:

The {do stuff} code will never be reused (it is different for each method);
It makes the program flow more confusing / less logical.

Is there another way to put {initialise stuff} and {finalise stuff} into a separate method?

This sounds like a job for either a decorator or a context manager. — user2357112, Nov 01 '21 at 20:39
So if I use a decorator, do I still have to put the `{do stuff}` in its own method? — Jordan Mitchell Barrett, Nov 01 '21 at 20:49
`{do stuff}` is kinda the part that is supposed to be _dynamic_, no? so it will have its own function but the repetitive stuff will be only decoratros — Matiiss, Nov 01 '21 at 20:53

score 0 · Answer 1 · answered Nov 01 '21 at 21:18

You can try functools.wraps and decorator:

import functools

def mywrapper(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        print("{initialize_stuff}")
        result = f(*args, **kwargs)
        print("{finalize_stuff}")
        return result
    return wrapper

@mywrapper
def myFunc():
    print("{innerMethod}")

Output:

>>> myFunc()
{initialize_stuff}
{innerMethod}
{finalize_stuff}

score 0 · Accepted Answer · edited Nov 01 '21 at 22:34

Context managers provide the best solution - thanks to @user2357112 for the suggestion.

from contextlib import contextmanager

@contextmanager
def wrap():
  {initialise stuff}
  yield {stuff-to-return-to-method}
  {finalise stuff}

def myFunc():
  with wrap() as vars:
    {do stuff}

You can even pass arguments to wrap and use them in the initialisation.

If you want {finalise stuff} to run even if the wrapped code throws an exception (which you usually do want with context managers), you should wrap the yield in a try and put the finalization in a finally:

@contextmanager
def wrap():
  {initialise stuff}
  try:
    yield {stuff-to-return-to-method}
  finally:
    {finalise stuff}

Python - how to abstract common starting/ending code

2 Answers2