Skip to content

Some thoughts on having both Python 2 and 3 programs

Earlier, I wrote about my qualms about using Python 3 in (work)
projects
in light of the extra burden it might
put on my co-workers if they had to work on the code. One possible
answer here is that it's possible both to use Python 3 features in
Python 2 and to write code that naturally runs unmodified under both
versions (as I did without explicitly trying to). This is true, but
there's a catch and that catch matters in this situation.

The compatibility between Python 2 and Python 3 is not symmetric.
If you write natural Python 3 code, it can often run under Python
2, sometimes with __future__ imports. However, if you write
natural Python 2 code it will not run under Python 3, unless your
code completely avoids at least print as a statement and mixing
tabs and spaces. A Python 3 programmer who knows very little about
Python 2 and who simply writes natural code can produce a program
that runs unaltered under Python 2 and can probably modify a Python
2 program without having it blow up in their face. But a Python 2
programmer who tries to work on a Python 3 program is quite possibly
going to have things explode. They could get lucky, but all it takes
is one print statement and Python 3 is complaining. This is true
even if the original Python 3 code is careful to be Python 2
compatible (it uses appropriate __future__ imports and so on).

Since there are Python 3 features that are simply not available in
Python 2 even with __future__ imports, a Python 3 programmer can
still wind up blowing up a Python 2 program. But as someone who's now
written both Python 2 and Python 3 code (including some that wound up
being valid Python 2 code too), my feeling is that you have to go at
least a bit out of your way in straightforward code to wind up doing
this. By contrast, it's very easy for a Python 2 programmer to use
Python 2 only things in code, partly because one of them (print
statements) is a long standing standard Python 2 idiom. A Python 2
programmer is relatively unlikely to produce code that also runs on
Python 3 unless they explicitly try to (which requires a number of
things, including awareness that there is even a Python 3).

So if you have part-time Python 3 programmers and some Python 2
programs, you'll probably be fine (and you can increase the odds
by putting __future__ imports into the Python 2 programs in
advance, so they're fully ready for Python 3 idioms like print() as a
function). If you have part-time Python 2 programmers and some Python 3
programs, you're probably going to have to keep an eye on things; people
may get surprises every so often. Unfortunately there's nothing you can
really do to make the Python 3 code able to deal with Python 2 idioms
like print statements.

(In the long run it seems clear that everyone is going to have to learn
about Python 3, but that's another issue and problem. I suspect that
many places are implicitly deferring it until they have no choice. I
look forward to an increasing number of 'what to know about Python 3 for
Python 2 programmers' articles as we approach 2020 and the theoretical
end of Python 2 support.)

0
sfy39587p00