Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Local import statements in Python

I think putting the import statement as close to the fragment that uses it helps readability by making its dependencies more clear. Will Python cache this? Should I care? Is this a bad idea?

def Process():     import StringIO     file_handle=StringIO.StringIO('hello world')     #do more stuff  for i in xrange(10): Process() 

A little more justification: it's for methods which use arcane bits of the library, but when I refactor the method into another file, I don't realize I missed the external dependency until I get a runtime error.

like image 425
Dustin Getz Avatar asked Nov 09 '09 04:11

Dustin Getz


People also ask

What are the three types of import statement in Python?

There are generally three groups: standard library imports (Python's built-in modules) related third party imports (modules that are installed and do not belong to the current application) local application imports (modules that belong to the current application)

What is import in Python with example?

A file is considered as a module in python. To use the module, you have to import it using the import keyword. The function or variables present inside the file can be used in another file by importing the module. This functionality is available in other languages, like typescript, JavaScript, java, ruby, etc.


2 Answers

The other answers evince a mild confusion as to how import really works.

This statement:

import foo 

is roughly equivalent to this statement:

foo = __import__('foo', globals(), locals(), [], -1) 

That is, it creates a variable in the current scope with the same name as the requested module, and assigns it the result of calling __import__() with that module name and a boatload of default arguments.

The __import__() function handles conceptually converts a string ('foo') into a module object. Modules are cached in sys.modules, and that's the first place __import__() looks--if sys.modules has an entry for 'foo', that's what __import__('foo') will return, whatever it is. It really doesn't care about the type. You can see this in action yourself; try running the following code:

import sys sys.modules['boop'] = (1, 2, 3) import boop print boop 

Leaving aside stylistic concerns for the moment, having an import statement inside a function works how you'd want. If the module has never been imported before, it gets imported and cached in sys.modules. It then assigns the module to the local variable with that name. It does not not not modify any module-level state. It does possibly modify some global state (adding a new entry to sys.modules).

That said, I almost never use import inside a function. If importing the module creates a noticeable slowdown in your program—like it performs a long computation in its static initialization, or it's simply a massive module—and your program rarely actually needs the module for anything, it's perfectly fine to have the import only inside the functions in which it's used. (If this was distasteful, Guido would jump in his time machine and change Python to prevent us from doing it.) But as a rule, I and the general Python community put all our import statements at the top of the module in module scope.

like image 131
Larry Hastings Avatar answered Sep 21 '22 06:09

Larry Hastings


Please see PEP 8:

Imports are always put at the top of the file, just after any module comments and docstrings, and before module globals and constants.

Please note that this is purely a stylistic choice as Python will treat all import statements the same regardless of where they are declared in the source file. Still I would recommend that you follow common practice as this will make your code more readable to others.

like image 37
Andrew Hare Avatar answered Sep 21 '22 06:09

Andrew Hare