How to get/set local variables of a function (from outside) in Python?

Question

If I have a function (in Python 2.5.2) like:

def sample_func():
    a = 78
    b = range(5)
    #c = a + b[2] - x

My questions are:

1. How to get the local variables (a,b) of the function from outside without using locals() inside the function? (kind of reflection)
2. Is it possible to set a local variable (say x) from outside so that the commented line works? (I know it sounds weird).

Thanks in advance.

EDIT:

Everyone is asking for a use-case. But it is a weird situation. (Don't blame me, I did not create it). Here is the scenario:

1. I have an encrypted python source file containing a python function.
2. A C extension module decrypts it and builds that function in-memory.
3. A main python program first calls the C extension with that encrypted file location.
4. Then the main program calls the function that has been built in-memory (by the C extension)
5. But main program needs to know the local variables of that function (Dont ask me why, it was not me)
6. For some (damn) reason, main program needs to set a variable too (weirdest of all)

Answer 1

No. A function that isn't being run doesn't have locals; it's just a function. Asking how to modify a function's locals when it's not running is like asking how to modify a program's heap when it's not running.

You can modify constants, though, if you really want to.

def func():
    a = 10
    print a

co = func.func_code
modified_consts = list(co.co_consts)
for idx, val in enumerate(modified_consts):
    if modified_consts[idx] == 10: modified_consts[idx] = 15

modified_consts = tuple(modified_consts)

import types
modified_code = types.CodeType(co.co_argcount, co.co_nlocals, co.co_stacksize, co.co_flags, co.co_code, modified_consts, co.co_names, co.co_varnames, co.co_filename, co.co_name, co.co_firstlineno, co.co_lnotab)
modified_func = types.FunctionType(modified_code, func.func_globals)
# 15:
modified_func()

It's a hack, because there's no way to know which constant in co.co_consts is which; this uses a sentinel value to figure it out. Depending on whether you can constrain your use cases enough, that might be enough.

Answer 2

The function's locals change whenever the function is run, so there's little meaning to access them while the function isn't running.