Specs: Python 2.7
I'm working on a project that has several modules, I want to activate some features from the __future__ module in all of them. I would like to import all the features I need on one module, and then import that single module to every other, and have those features be active in all of them, or something to that effect.
I tried:
[A.py]
from __future__ import division
[B.py]
import A
print(1/2)
Running B.py the division was still integer. I tried:
[A.py]
print(1/2)
[B.py]
from __future__ import division
import A
Running B.py gave the same result. With both previous examples I also tried switching 'import A' by 'from A import *' with the same results.
I searched Google for a while, and found the best description about how the __future__ module works, obviously enough, on the Python documentation. There I could only find the assurance the features would be active in the module they were imported to, without any mention of how to do it globally.
So I'd like to know if there is a way of doing this, either the way I described, or creating some sort of runtime configuration file, or through some other means.
Best Answer
There's no way to do this in-language; you really can't make
__future__
imports global in this sense. (Well, you probably can replace the normalimport
statements with something complicated aroundimp
or something. See the Future statement documentation and scroll down to "Code compiled by…" But anything like this is almost certainly a bad idea.)The reason is that
from __future__ import division
isn't really a normal import. Or, rather, it's more than a normal import. You actually do get a name calleddivision
that you can inspect, but just having that value has no effect—so passing it to other modules doesn't affect those modules. On top of the normal import, Python has special magic that detects__future__
imports at the top of a module, or in the interactive interpreter, and changes the way your code is compiled. See future for the "real import" part, and Future statements for the "magic" part, if you want all the details.And there's no configuration file that lets you do this. But there is a command-line parameter:
This has the same effect as doing a
from __future__ import division
everywhere.You can add this to the
#!
lines, oralias pyfuturediv='python -Qnew'
(or evenalias python='python -Qnew'
) in your shell, or whatever, which maybe as good as a configuration file for your purposes.But really, if you want to make sure module B gets new-style division, you probably should have the
__future__
declaration in B in the first place.Or, of course, you could just write for Python 3.0+ instead of 2.3-2.7. (Note that some of the core devs were against having command-line arguments, because "the right way to get feature X globally is to use a version of Python >= feature X's MandatoryRelease".) Or use
//
when you mean//
.Another possibility is to use six, a module designed to let you write code that's almost Python 3.3 and have it work properly in 2.4-2.7 (and 3.0-3.2). For example, you don't get a
print
function, but you do get aprint_
function that works exactly the same. You don't get Unicode literals, but you getu()
fake literals—which, together with a UTF-8 encoding declaration in the source, is almost good enough. And it provides a whole lot of stuff that you can't get from__future__
as well—StringIO
andBytesIO
,exec
as a function, thenext
function, etc.If the problem is that you have 1000 source files, and it's a pain to edit them all, you could use
sed
, or use3to2
with just the option that fixes division, or…