Core Python Programming (2nd Edition)

# impter.py #
#############
import imptee
imptee.show()
imptee.foo = 123
print 'foo from impter:', imptee.foo
imptee.show()
Once we make the update and change our references accordingly, we now have achieved the desired
effect.
foo from imptee: abc
foo from impter: 123
foo from imptee: 123
12.5.5. Back to the __future__
Back in the days of Python 2.0, it was recognized that due to improvements, new features, and current
feature enhancements, certain significant changes could not be implemented without affecting some
existing functionality. To better prepare Python programmers for what was coming down the line, the
__future__ directives were implemented.
By using the from-import statement and "importing" future functionality, users can get a taste of new
features or feature changes enabling them to port their applications correctly by the time the feature
becomes permanent. The syntax is:
from __future__ import new_feature
It does not make sense to import __future__ so that is disallowed. (Actually, it is allowed but does not
do what you want it to do, which is enable all future features.) You have to import specific features
explicitly. You can read more about __future__ directives in PEP 236.
12.5.6. Warning Framework
Similar to the __future__ directive, it is also necessary to warn users when a feature is about to be
changed or deprecated so that they can take action based on the notice received. There are multiple
pieces to this feature, so we will break it down into components.
The first piece is the application programmer's interface (API). Programmers have the ability to issue
warnings from both Python programs (via the warnings module) as well as from C [via a call to
PyErr_Warn()].
Another part of the framework is a new set of warning exception classes. Warning is subclassed directly
from Exception and serves as the root of all warnings: UserWarning, DeprecationWarning, SyntaxWarning,