I want to create a package which should be compatible to Python 2.7 and Python 3.3. The logic should exist only once.
How do you normally represent the programming logic - in Python 2.7 or Python 3.3? Or do you choose a different way?
EDIT: How this issue is handled in the core?
You do it by quite simply only using those bits of the language that is the same, and by having conditions or exception handling during other parts.
This is harder or easier depending on what your software do, and what versions of Python you need to support. By supporting just Python 2.6, 2.7 and 3.3 it becomes relatively simple.
Exactly how you do it is not answerable in a question on SO, because there is a lot to it.
I recommend you check out this book: http://python3porting.com/ , especially the chapter "Supporting Python 2 and 3 without 2to3 conversion" and the Appendices, that has loads of examples of how to solve most incompatibilities.
The six library may also be useful.
I tend to use a number of __future__ imports (which are, presumably, safely ignored in Python 3), and the occasionaly try except for some import statements. In addition, I define a stringtype for basestring / str compatibility. Just depending on what I need per module.
For example:
from __future__ import absolute_import
from __future__ import unicode_literals
from __future__ import division
from __future__ import print_function
try:
import ConfigParser as cfgparser
except ImportError:
import configparser as cfgparser
try:
stringtype = basestring
except NameError:
stringtype = str
I think the six package already does this, so that may be another good option.
from io import open gives you strictly the Python 3 open builtin (with, among other things, its platform-independent meaning of binary vs text files).
ConfigParser import isn't always there). It serves more as an example than as a complete answer, which I thought may be useful to get someone started. For a more complete answer, the porting howto Martijn has pointed out does contain most of that info (it mentions six as well).
unicode_literals future module mainly because of the regressions with other modules/3rd-party libs I've encountered as stated in the futures doc. Its a lot of trouble to fix. A more cautious approach, such as using the u'' prefix is preferable. I upvoted because of the boilerplate.
2to3converts Python 2.x code to Python 3 code that isn't backwards-compatible with Python 2.7.