Sinking deeper and deeper in this EOL rabbit hole I noticed that things are just not true about the statements on python3statement.org. The statement is that Python 3 is needed “to simplify our code and take advantage of the many new features”. First of all: new features can be backported to Python 2.7. And modules improved in Python 3 can also be improved in Python 2.7. The new-features-statement about Python 3 is false.
Nonsense. You are looking at the wrong thing. Look at the viewpoint of Python developers: Anytime they backport something into Python2, they have to do extra work, and they end up with roughly twice as much code or code churn: the same feature has to be there twice. This is the exact opposite of simplicity. Keeping Python2 around and updated adds complexity, and it adds extra work. The Python developers have decided that the extra work is not worth it
TO THEM. Therefore they will stop doing it. And I fully support them, because that decision is not capricious, it is sensible from an engineering point of view, and it had sufficient warning.
The print function is the most widely known change in Python 3. If you look in to the print function the code is not made more simple in Python 3.
First, you are looking at it again from the wrong point of view. This is mostly about the complexity of the Python infrastructure (the thing the python developers worry about), not the complexity of your code.
Second:
In Python 3 you have to code more to get the same output.
...
Print in Python 2:
code: print 'Python', python_version()
...
Print in Python 3:
code: print('Python', python_version())
Other than one traililng closing paren, it is the same amount of code. You replaced one space (the one between the keyword "print" and the argument list) with an opening paren, which doesn't change either the complexity nor the amount of code (if measured in characters or lines), and you had to add one closing paren, which is a tiny addition to the amount of code.
But think about what you get: a simpler language, with one fewer keywords. From a developer viewpoint, every keyword adds having to think about the syntax, having to consider special cases (like what does a trailing comma mean, how do line breaks in parameter lists work). From a python implementor viewpoint, one fewer keyword simplifies the parser considerably.
Furthermore: that particular change (of adding parens around the argument list of print) actually causes developers nearly no work, since 2to3 handles it perfectly. The real work of the Python3 transition is elsewhere, for example in the bytes versus strings area (which was a very good change and way overdue, but one that can not be handled automatically).
What a fool I must be to believe that live is simpler now with Python 3.
You want simple? BASIC still exists. You want productive?