3

I have a file with the contents

a = 24
b = 1.2

def test(x, y):
    return x + y

I would like to parse this file to retrieve the information that

  • it contains the two variables a and b,
    • their values,
  • it contains a function called test
    • which has two input arguments and
    • which returns their sum.

(I would like to use this info to create another file.)

How to do that?

What I have tried

I can parse it with Python 3 using

global_vars = {}
local_vars = {}
namespace = {}
with open(args.infile) as f:
    code = compile(f.read(), args.infile, 'exec')
    exec(code, global_vars, local_vars)

after which I get

testfunction = local_vars['test']

There are a couple of things I can find out about test from the testfunction object, for example the names of variables and the byte code via

testfunction.func_code.co_varnames
testfunction.func_code.co_code

However, I don't know where to go from here.

Improve this question
4
  • What exactly are you trying to achieve? Commented Jun 23, 2015 at 21:36
  • I would like to use the information I'm getting from this to create a C++ file with equivalent information that fits into a certain C++ framework. I didn't include that information because I think it leads too far. Commented Jun 23, 2015 at 21:38
  • 2
    If you want a form of the Python code that can be translated to another language, why not use the abstract syntax tree? There's a module for that: ast. Commented Jun 23, 2015 at 21:41
  • I didn't know that module. Thanks for the hint, I'll check it out! Commented Jun 23, 2015 at 21:43

1 Answer 1

Reset to default
4

Let's say your file is named x.py.

You can import it, and use dir() to see what's inside it:

>>> import x
>>> dir(x)
['__builtins__', '__cached__', '__doc__', '__file__',
 '__loader__', '__name__', '__package__', '__spec__',
 'a', 'b', 'test']

Get rid of the underscore junk:

>>> [obj for obj in dir(x) if not obj.startswith('__')]
['a', 'b', 'test']

Pretty ordinary stuff:

>>> x.a
24
>>> x.b
1.2

Type inspection:

>>> type(x.a)
<class 'int'>
>>> type(x.b)
<class 'float'>
>>> type(x.test)
<class 'function'>

or, since you know those variables by their name (str):

>>> type(getattr(x, 'a'))
<class 'int'>
>>> type(getattr(x, 'b'))
<class 'float'>
>>> type(getattr(x, 'test'))
<class 'function'>

Inspect functions:

>>> import inspect
>>> s=inspect.signature(x.test)
>>> s.parameters
mappingproxy(OrderedDict([('x', <Parameter at 0x1080d09d8 'x'>), ('y', <Parameter at 0x1080db5a0 'y'>)]))
>>> list(s.parameters.keys())
['x', 'y']
>>> s.parameters['x'].kind
<_ParameterKind: 'POSITIONAL_OR_KEYWORD'>
>>> s.parameters['x'].default
<class 'inspect._empty'>

For more info, check docs about Python's inspect module.

The only thing you can't do with compiled bytecode is analyze the body of the function (the code).

If you need that, probably you want to parse the file, instead of interpret it. Have a look at Python's parser ast module.

On the other hand, if you are interested in the value of variables, the code to generate their value can be arbitrarily complex (example: a, b = ((lambda x: x*(x-2))(6), 0.1*12)), so it is easier to interpret the code and then read the variable's value.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

parser is outdated, ast seems more appropriate.

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.