One approach is editing the bytecode of the function. This is a very advanced technique, and is also very fragile. So, don't use this for production code!

That said, there is a module out there which implements precisely the kind of editing you want. It's called bytecodehacks, first released on April 1, 2000 (yes, it was an April Fools' joke, but a completely functional one). A slightly later edition (from 2005) works fine on my install of Python 2.7.6; grab it from CVS and run setup.py as usual. (Don't use the April2000 version; it won't work on newer Pythons).

bytecodehacks basically implements a number of utility routines that make it possible to edit the bytecode of a section of code (a function, module, or even just a single block within a function). You can use it to implement macros, for example. For the purposes of modifying a function, the inline tool is probably the most useful.

Here's how you would implement reverse_fn using bytecodehacks:

from bytecodehacks.inline import inline

def reverse_fn(f):
    def g(x):
        # Note that we use a global name here, not `f`.
        return _f(-x)
    return inline(g, _f=f)

That's all! inline takes care of the dirty business of "inlining" the function f into the body of g. In effect, if f(x) was return 2*x, then the return from reverse_fn(f) would be a function equivalent to return 2*(-x) (which would not have any function calls in it).

Now, one limitation of bytecodehacks is that the variable renaming (in extend_and_rename in inline.py) is somewhat stupid. So, if you apply reverse_fn 1000 times in a row, you will get a huge slowdown as the local variable names will begin to explode in size. I'm not sure how to fix this, but if you do, it will substantially improve the performance for functions that are repeatedly inlined.

Generally, I think it wouldn't be proper to use version 1 and version 2 in your python code because normally* it would throw an UnboundLocalError: local variable referenced before assignment error. For example, try running this code:

def version_1():
    """ no parameters & no return statements """
    nums = [num**2 for num in nums]


def version_2():
    """ no parameters """
    nums = [num**2 for num in nums]
    return nums


nums = [2,3]
version_1()
version_2()

Versions 3 and 4 are good in this regard since they introduce parameters, but the third function wouldn't change anything (it would change your local variable within a function but the adjustments wouldn't take place globally since they never leave a local scope).

def version_3(nums):
    """ no return """
    nums = [num**2 for num in nums] # local variable

nums = [2,3] # global variable
version_3(nums)
# would result in an error
assert version_3(nums) == [num**2 for num in nums]

Since version 4 has a return statement, the adjustments made within a local scope would take place.

def version_4(nums):
    nums = [num**2 for num in nums]
    return nums

new_nums = version_4(nums)
assert new_nums == [num**2 for num in nums]

# but original `nums` was never changed
nums

So, I believe version_4 to be the best practice.

*normally - in terms of general python functions; with pandas objects, it's different: all four functions will result in a variable specifically called dataframe being changed in place (which you wouldn't want to do usually):

def version_1():
    dataframe.iat[0,0] = 999 

def version_2():
    dataframe.iat[0,0] = 999 
    return dataframe

dataframe = pd.DataFrame({"values" : [1,2,3,4,5]})
version_1()
dataframe
dataframe = pd.DataFrame({"values" : [1,2,3,4,5]})
version_2()
dataframe

Both of the functions would throw NameError if your variable is called differently; try running your first or second function without defining dataframe object beforehand (use df as a variable name for example):

# restart your kernel - `dataframe` object was never defined
df = pd.DataFrame({"values" : [1,2,3,4,5]})
version_1()
version_2()

With version_3 and version_4, you'd expect different results.

def version_3(dataframe):
    dataframe.iat[0, 0] = 999

def version_4(dataframe):
    dataframe.iat[0, 0] = 999 
    return dataframe

df = pd.DataFrame({"values" : [1,2,3,4,5]})
version_3(df) 
df

df = pd.DataFrame({"values" : [1,2,3,4,5]})
version_4(df)
df

But the results are the same: your original dataframe will be changed in place.

To avoid it, don't forget to make a copy of your dataframe:

def version_4_withcopy(dataframe):
    df = dataframe.copy()
    df.iat[0, 0] = 999 
    return df

dataframe = pd.DataFrame({"values" : [1,2,3,4,5]})
new_dataframe = version_4_withcopy(dataframe)
dataframe
new_dataframe

This is handled in python by returning.

def appendFlag(target, value):
   target += value
   target += " "
   return target

you can use it like this:

m = appendFlag(m,"ok")

you can even return several variables like this:

def f(a,b):
   a += 1
   b += 1
   return a,b

and use it like this:

a,b = f(4,5)

I´ve done it with regex, could be done with less code but my intention is readable

import re

def split_by_upper(input_string):
    pattern = r'[A-Z][a-z]*'
    matches = re.findall(pattern, input_string)
    if (matches):
        output = matches[0]
        for word in matches[1:]:
            output += ' ' + word[0].lower() + word[1:]
        return output
    else:
        return input_string


print(split_by_upper("ThisIsMyChar"))
>> split_by_upper() -> "This is my char"

If you wish to be sure of what you are getting from R, you can also indicate that you wish to use the function in the R package 'stats':

from rpy2.robjects.packages import importr
from rpy2.robjects.vectors import FloatVector

stats = importr('stats')

p_adjust = stats.p_adjust(FloatVector(pvalue_list), method = 'BH')