I have a text file /etc/default/foo which contains one line:


In my python script, I need to reference the variable FOO.

What is the simplest way to "source" the file /etc/default/foo into my python script, same as I would do in bash?

. /etc/default/foo
  • Why not use a configuration parser?
    – aderchox
    Nov 18, 2021 at 9:43

7 Answers 7


Same answer as @jil however, that answer is specific to some historical version of Python.

In modern Python (3.x):


replaces execfile('filename') from 2.x

  • 3
    Shoudn't one use a context manager (with open…) for this to ensure that the file handle gets cleaned up correctly? Jan 18, 2021 at 15:13
  • @MartinUeding Sounds like a good practice to me. Also a lot of extra typing though ;) I'll try to update the answer with such an example.
    – Hack-R
    Sep 27, 2021 at 16:00

You could use execfile:


But please be aware that this will evaluate the contents of the file as is into your program source. It is potential security hazard unless you can fully trust the source.

It also means that the file needs to be valid python syntax (your given example file is).

  • Of course, this is usually a really bad idea unless you have complete control over your input data (in which case, go for it, I guess).
    – larsks
    Apr 30, 2016 at 19:18
  • It's not a bad answer (it is allowable) but the usual caveats should be there.
    – Harlin
    Apr 30, 2016 at 19:28
  • 11
    Python3 version: exec(open("/etc/default/foo").read()) stackoverflow.com/questions/436198/…
    – user1170868
    May 12, 2017 at 4:39

If you know for certain that it only contains VAR="QUOTED STRING" style variables, like this:

FOO="some value"

Then you can just do this:

>>> with open('foo.sysconfig') as fd:
...   exec(fd.read())

Which gets you:

>>> FOO
'some value'

(This is effectively the same thing as the execfile() solution suggested in the other answer.)

This method has substantial security implications; if instead of FOO="some value" your file contained:

os.system("rm -rf /")

Then you would be In Trouble.

Alternatively, you can do this:

>>> with open('foo.sysconfig') as fd:
...   settings = {var: shlex.split(value) for var, value in [line.split('=', 1) for line in fd]}

Which gets you a dictionary settings that has:

>>> settings
{'FOO': ['some value']}

That settings = {...} line is using a dictionary comprehension. You could accomplish the same thing in a few more lines with a for loop and so forth.

And of course if the file contains shell-style variable expansion like ${somevar:-value_if_not_set} then this isn't going to work (unless you write your very own shell style variable parser).

  • Why is exec() any more a security risk than import? If your file contains something like os.system("rm -rf /"), then aren't you doomed even if you used import?
    – Tim Mak
    Oct 9, 2020 at 5:54

Keep in mind that if you have a "text" file with this content that has a .py as the file extension, you can always do:

import mytextfile


Of course, this assumes that the text file is syntactically correct as far as Python is concerned. On a project I worked on we did something similar to this. Turned some text files into Python files. Wacky but maybe worth consideration.

  • 1
    I think by wacky, you mean "generally accepted practice as seen in e.g. Django's settings.py mechanism for doing configuration"; this also has the benefits that you can do simple (or not so simple) calculations to build up strings etc. using the same python syntax as the rest of your program :-P
    – Foon
    Apr 30, 2016 at 19:52

Just to give a different approach, note that if your original file is setup as

export FOO=/path/to/foo

You can do source /etc/default/foo; python myprogram.py (or . /etc/default/foo; python myprogram.py) and within myprogram.py all the values that were exported in the sourced' file are visible in os.environ, e.g

import os

There are a couple ways to do this sort of thing.

  • You can indeed import the file as a module, as long as the data it contains corresponds to python's syntax. But either the file in question is a .py in the same directory as your script, either you're to use imp (or importlib, depending on your version) like here.

  • Another solution (that has my preference) can be to use a data format that any python library can parse (JSON comes to my mind as an example).

/etc/default/foo :


And in your python code :

import json

with open('/etc/default/foo') as file:
    data = json.load(file)
    FOO = data["FOO"]
    ## ...

This way, you don't risk to execute some uncertain code...

You have the choice, depending on what you prefer. If your data file is auto-generated by some script, it might be easier to keep a simple syntax like FOO="path/to/foo" and use imp.

Hope that it helps !


The Solution

Here is my approach: parse the bash file myself and process only variable assignment lines such as:


Here is the code:

import shlex

def parse_shell_var(line):
    Parse such lines as:
        FOO="My variable foo"

    :return: a tuple of var name and var value, such as
        ('FOO', 'My variable foo')
    return shlex.split(line, posix=True)[0].split('=', 1)

if __name__ == '__main__':
    with open('shell_vars.sh') as f:
        shell_vars = dict(parse_shell_var(line) for line in f if '=' in line)

How It Works

Take a look at this snippet:

        shell_vars = dict(parse_shell_var(line) for line in f if '=' in line)

This line iterates through the lines in the shell script, only process those lines that has the equal sign (not a fool-proof way to detect variable assignment, but the simplest). Next, run those lines into the function parse_shell_var which uses shlex.split to correctly handle the quotes (or the lack thereof). Finally, the pieces are assembled into a dictionary. The output of this script is:

{'MOO': '/dont/have/a/cow', 'FOO': 'my variable foo', 'BAR': 'My variable bar'}

Here is the contents of shell_vars.sh:

FOO='my variable foo'
BAR="My variable bar"
echo $FOO


This approach has a couple of advantages:

  • It does not execute the shell (either in bash or in Python), which avoids any side-effect
  • Consequently, it is safe to use, even if the origin of the shell script is unknown
  • It correctly handles values with or without quotes

This approach is not perfect, it has a few limitations:

  • The method of detecting variable assignment (by looking for the presence of the equal sign) is primitive and not accurate. There are ways to better detect these lines but that is the topic for another day
  • It does not correctly parse values which are built upon other variables or commands. That means, it will fail for lines such as:


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.