Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How to modularize a Python application

Tags:

python

I've got a number of scripts that use common definitions. How do I split them in multiple files? Furthermore, the application can not be installed in any way in my scenario; it must be possible to have an arbitrary number of versions concurrently running and it must work without superuser rights. Solutions I've come up with are:

  • Duplicate code in every script. Messy, and probably the worst scheme.
  • Put all scripts and common code in a single directory, and use from . import to load them. The downside of this approach is that I'd like to put my libraries in other directory than the applications.
  • Put common code in its own directory, write a __init__.py that imports all submodules and finally use from . import to load them. Keeps code organized, but it's a little bit of overhead to maintain __init__.py and qualify names.
  • Add the library directory to sys.path and import. I tend to this, but I'm not sure whether fiddling with sys.path is nice code.
  • Load using execfile (exec in Python 3). Combines the advantages of the previous two approaches: Only one line per module needed, and I can use a dedicated. On the other hand, this evades the python module concept and polutes the global namespace.
  • Write and install a module using distutils. This installs the library for all python scripts and needs superuser rights and impacts other applications and is hence not applicable in my case.

What is the best method?

like image 340
phihag Avatar asked Feb 02 '09 00:02

phihag


People also ask

How do you modularize Python code?

Python scripts are modularized through functions, modules, and packages. Functions allow developers to reduce repetition in their code by executing the same block of code multiple times in one program. By giving the function a name, it can be reused by referencing it's name instead of rewriting the code.

How do you get reusability in Python?

And when it comes to reusing code in Python, it all starts and ends with the humble function. Take some lines of code, give them a name, and you've got a function (which can be reused). Take a collection of functions and package them as a file, and you've got a module (which can also be reused).

What do you mean by modularity Python?

Modularity refers to the concept of making multiple modules first and then linking and combining them to form a complete system (i.e, the extent to which a software/Web application may be divided into smaller modules is called modularity).


2 Answers

Adding to sys.path (usually using site.addsitedir) is quite common and not particularly frowned upon. Certainly you will want your common working shared stuff to be in modules somewhere convenient.

If you are using Python 2.6+ there's already a user-level modules folder you can use without having to add to sys.path or PYTHONPATH. It's ~/.local/lib/python2.6/site-packages on Unix-likes - see PEP 370 for more information.

like image 89
bobince Avatar answered Sep 18 '22 11:09

bobince


You can set the PYTHONPATH environment variable to the directory where your library files are located. This adds that path to the library search path and you can use a normal import to import them.

like image 28
sth Avatar answered Sep 22 '22 11:09

sth