Porting da Python 2 a Python 3

Python nell'evoluzione dalla versione 2 alla versione 3 ha radicalmente cambiato molte parti del linguaggio.
Fra le modifiche con un impatto piú rilevante troviamo:

• la scrittura su console print
• Sollevare e Gestire eccezioni
• la divisione intera
• Unicode
• xrange

Nelle seguenti sezioni vedremo come scrivere codice che sia compatibile su entrambe le versioni.

Print è ora una funzione e per tanto vuole le parentesi tonde.

# python 2.x
print "Ciao"
 
# python 3.x
print("Ciao")

Per una semplice print, potete mettere le parentesi anche su Python 2 ed il risultato sarà identico.
Varia invece se usate una print con parti concatenate da virgola

# python 2.x
print "Ciao", " Come stati?"
>> Ciao Come stai?
 
# python 3.x
print ("Ciao", " Come stati?")
>> Ciao Come stai?

In questo caso, aggingendo le parentesi se python 2 otteniamo un risultato che è quello desiderato

# python 2.x
print ("Ciao", " Come stati?")
>> ("Ciao", "Come stai?")

Per ovviare a questo spiacevole risultato, ci viene in aiuto il modulo __future__

# python 2.x
from __future__ import print_function
 
print ("Ciao", " Come stati?")
>> Ciao Come stai?

Questa modifica è particolarmente pericolosa poiché può spesso passare inosservata (non genera un SyntaxError). Quindi si consiglia l'importazione del modulo __future__ in tutti gli script Python 2 ove sia prevista una divisione).

print 'Python', python_version()
print '3 / 2 =', 3 / 2
print '3 // 2 =', 3 // 2
print '3 / 2.0 =', 3 / 2.0
print '3 // 2.0 =', 3 // 2.0

>> Python 2.7.6
3 / 2 = 1
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0

print('Python', python_version())
print('3 / 2 =', 3 / 2)
print('3 // 2 =', 3 // 2)
print('3 / 2.0 =', 3 / 2.0)
print('3 // 2.0 =', 3 // 2.0)

>> Python 3.4.1
3 / 2 = 1.5
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0

# Python 2 and 3
from __future__ import division
 
assert 3 / 2 == 1.5

In Python 3, il tipo int corrisponde come implementazione al vecchio tipo long, quindi int e long diventano equivalenti.

bigint = 1L
 
if isinstance(bigint, (int, long)):
    ...    

bigint = 1
 
if isinstance(bigint, int):
    ...    

from builtins import int
bigint = int(1)
 
if isinstance(bigint, int):             # matches both int and long on Py2
    ...

0644     # Python 2 only
0o644    # Python 2 and 3

`x`      # Python 2 only
 
repr(x)  # Python 2 and 3

In Python 2 esistono due diversi tipi stringa:

• ASCII str()
• UNICODE unicode()

Ma non esiste la stringa di byte.
Ora, in Python 3, tutte le stringhe sono Unicode (utf-8), in aggiunta abbiamo due nuove classi: byte e bytearrays.

print 'Python', python_version()
 
>> Python 2.7.6
 
print type(unicode('Questa è come una stringa di Python3'))
 
>> <type 'unicode'>
 
print type(b'il tipo byte non esiste')
 
>> <type 'str'>
 
print 'Queste due stringe sono' + b' dello stesso tipo'
 
>> Queste due stringe sono dello stesso tipo
 
print type(bytearray(b'Stranamente però esiste il bytearray'))
 
>> <type 'bytearray'>

print('Python', python_version())
print('ora le stringhe sono utf-8 \u03BCnico\u0394é!')
 
>> Python 3.7.3
   strings are now utf-8 μnicoΔé!
 
print('Python', python_version(), end="")
print(' ha', type(b' il tipo bytes'))
 
>> Python 3.7.3 ha <class 'bytes'>
 
print('e Python', python_version(), end="")
print(' ha anche ', type(bytearray(b'bytearrays')))
 
>> e Python 3.7.3 ha anche <class 'bytearray'>
 
'Ora cercare di sommare una stringa' + b' ed un bytes provoca errore.'
 
>> Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    'Ora cercare di sommare una stringa' + b' ed un bytes provoca errore.'
TypeError: can only concatenate str (not "bytes") to str

# Byte-String
# Python 2 and 3: byte-strings as strings.
from builtins import str
a = u'abc'
b = b'def'
c = b.decode()
assert isinstance(a, str) and isinstance(c, str)
# ...
 
# Unicode: Alternative 1
# Python 2 and 3
s1 = u'The Zen of Python'
s2 = u'きたないのよりきれいな方がいい\n'
 
# Unicode: Alternative 2
# Python 2 and 3
from __future__ import unicode_literals    # rende tutte le stringhe unicode
 
s1 = 'The Zen of Python'
s2 = 'きたないのよりきれいな方がいい\n'

Poichè xrange() è generalmente più veloce di range(), in Python 3 range() è implementata come xrange() mentre quest'ultima è stata rimossa.
Questo lo rende efficientissimo su iterazioni 1-time, mentre su iterazioni multiple perde un po' di efficienza perchè, ogni volta, la generazione viene rifatta da zero.
In Python 3, la chiamata alla funzione xrange() genera un NameError.

Mentre Python 2 accetta sia la sintassi “vecchia” che la “nuova”, Python 3 genera un SyntaxError se non l'argomento non viene messo tra parentesi.

raise IOError, "file error"
 
>> Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    raise IOError, "file Error"
IOError: file Error
 
raise IOError("file error")
 
>> Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    raise IOError("file Error")
IOError: file Error

raise IOError, "file error"
 
>> SyntaxError: invalid syntax
 
raise IOError("file error")
 
>> Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    raise IOError("file error")
OSError: file error

Poichè Python 2 supporta la sintassi con le parentesi è buona cosa scrivere le raise con tale sintassi anche in Python 2.

traceback = sys.exc_info()[2]
raise ValueError, "dodgy value", traceback

raise ValueError("dodgy value").with_traceback()

# Python 2 e 3: Alternativa 1
from future.utils import raise_
 
traceback = sys.exc_info()[2]
raise_(ValueError, "dodgy value", traceback)
 
#...
#...
 
# Python 2 e 3: Alternativa 2
from future.utils import raise_with_traceback
 
raise_with_traceback(ValueError("dodgy value"))

In Python 3 ora è obbligatoria la keyword as.

try:
    ...
except ValueError, e:
    ...

try:
    ...
except ValueError as e:
    ...

Python 2 supporta la sintassi di Python 3.

try:
    ...
except ValueError as e:
    ...

Mentre in Python 2.7 per ottenere l'elemento successivo di un generatore è possibile usare sia la funzione next() che il metodo .next(), il Python 3 è presente solo la funzione ed un eventuale chiamata al metodo genera un'eccezione di tipo AttributeError.

my_generator = (letter for letter in 'abcdefg')
 
next(my_generator)
>> 'a'
 
my_generator.next()
>> 'b'

my_generator = (letter for letter in 'abcdefg')
 
next(my_generator)
>> 'a'
 
my_generator.next()
>> Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    my_generator.next()
AttributeError: 'generator' object has no attribute 'next'

La soluzione è utilizzare sempre la funzione next().

In Python 3 non avviene più la perdita del namespace globale.

i = 1
print 'before: i =', i
 
>> before: i = 1
 
print 'comprehension: ', [i for i in range(5)]
 
>> comprehension:  [0, 1, 2, 3, 4]
 
print 'after: i =', i
 
>> after: i = 4

i = 1
print('before: i =', i)
 
>> before: i = 1
 
print('comprehension:', [i for i in range(5)])
 
>> comprehension:  [0, 1, 2, 3, 4]
 
print('after: i =', i)
 
>> after: i = 1

InPython 3 il tentativo di comparare due entità non ordinabili restituisce un TypeError.

print "[1, 2] > 'foo' = ", [1, 2] > 'foo'
 
>> [1, 2] > 'foo' =  False
 
print "(1, 2) > 'foo' = ", (1, 2) > 'foo'
 
>> (1, 2) > 'foo' =  True
 
print "[1, 2] > (1, 2) = ", [1, 2] > (1, 2)
 
>> [1, 2] > (1, 2) =  False

print("[1, 2] > 'foo' = ", [1, 2] > 'foo')
 
>> Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    print("[1, 2] > 'foo' = ", [1, 2] > 'foo')
TypeError: '>' not supported between instances of 'list' and 'str'
 
print("(1, 2) > 'foo' = ", (1, 2) > 'foo')
 
>> Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    print("(1, 2) > 'foo' = ", (1, 2) > 'foo')
TypeError: '>' not supported between instances of 'tuple' and 'str'
 
print("[1, 2] > (1, 2) = ", [1, 2] > (1, 2))
 
>> Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    print("[1, 2] > (1, 2) = ", [1, 2] > (1, 2))
TypeError: '>' not supported between instances of 'list' and 'tuple'

In Python 2 la funzione input() cercava di determinare il tipo dell'input inserito (a volte causando problemi perchè gestiva la stringa di input come se fosse codice Python).
In Python 3 questo comportamento è stato corretto ed ora input() restituisce sempre una stringa.
Per lo stesso comportamento in Python 2 è necessario chiamare la funzione raw_input().

my_input = input('enter a number: ')
 
>> enter a number: 123
 
type(my_input)
 
>> <type 'int'>
 
my_input = raw_input('enter a number: ')
 
>> enter a number: 123
 
type(my_input)
>> <type 'str'>

my_input = input('enter a number: ')
 
>> enter a number: 123
 
type(my_input)
>> <class 'str'>

Come abbiamo già visto nella sezione xrange, alcune funzioni e metodi restituiscono oggetti iterabili in Python 3, anziché liste come in Python 2.
Poichè solitamente vengono ciclati una sola volta, questo cambiamento consente di salvare memoria.
Tuttavia, con una perdita di efficienza, è anche possibile, a differenza dei generatori, scorrere più volte se necessario.
E per quei casi in cui abbiamo davvero bisogno degli oggetti list, possiamo semplicemente convertire l'oggetto iterabile in una lista tramite la funzione list().

print range(3)
 
>> [0, 1, 2]
 
print type(range(3))
 
>> <type 'list'>

print(range(3))
 
>> range(0, 3)
 
print(type(range(3)))
 
>> <class 'range'>
 
print(list(range(3)))
 
>> [0, 1, 2]

Funzioni e metodi comunemente usati che non restituiscono più elenchi in Python 3:

• zip()
• map()
• filter()
• Metodo .keys() dei dizionari
• Metodo .values() dei dizionari
• Metodo .items() dei dizionari

Python 3 ha adottato il modo ormai standard di arrotondare i decimali quando si ottiene un pareggio (.5) alle ultime cifre significative.
Ora, in Python 3, i decimali vengono arrotondati al numero pari più vicino.
Purtroppo questo comportamento non è workaround-abile … il che significa che bisogna tenerne conto.

round(15.5)
 
>> 16.0
 
round(16.5)
 
>> 17.0

round(15.5)
 
>> 16
 
round(16.5)
 
>> 16

heights = {'Fred': 175, 'Anne': 166, 'Joe': 192}

for key in heights.iterkeys():
    ...

for key in heights:
    ...

for value in heights.itervalues():
    ...

#Opzione 0: Sconsigliata
for value in heights.values():    # Maggiore consumo di memoria in Py2
    ...

# Opzione 1
from builtins import dict
 
heights = dict(Fred=175, Anne=166, Joe=192)
for key in heights.values():    # efficiente in Py2 e Py3

# Opzione 2
from builtins import itervalues
 
for key in itervalues(heights):
    ...

for (key, value) in heights.iteritems():
    ...

# Opzione 1
for (key, value) in heights.items():    # inefficiente in Py2
    ...

# Opzione 2
from future.utils import viewitems
 
for (key, value) in viewitems(heights):   # si compporta come un set
    ...

# Opzione 3
from future.utils import iteritems
 
for (key, value) in iteritems(heights):
    ...

keylist = heights.keys()
assert isinstance(keylist, list)

keylist = list(heights)
assert isinstance(keylist, list)

heights = {'Fred': 175, 'Anne': 166, 'Joe': 192}
valuelist = heights.values()
assert isinstance(valuelist, list)

# Opzione 1
valuelist = list(heights.values())    # inefficiente in Py2

# Opzione 2
from builtins import dict
 
heights = dict(Fred=175, Anne=166, Joe=192)
valuelist = list(heights.values())

# Opzione 3
from future.utils import listvalues
 
valuelist = listvalues(heights)

# Opzione 4
from future.utils import itervalues
 
valuelist = list(itervalues(heights))

# Opzione 1
itemlist = list(heights.items())    # inefficiente in Py2

# Opzione 2
from future.utils import listitems
 
itemlist = listitems(heights)

# Opzione 3
from future.utils import iteritems
 
itemlist = list(iteritems(heights))

supponiamo che il package abbia struttura:

mypackage/
    __init__.py
    submodule1.py
    submodule2.py

dove il modulo submodule1.py contenga il seguente codice:

# Python 2 only:
import submodule2
 
# Python 2 and 3:
from . import submodule2
 
# Python 2 and 3:
# To make Py2 code safer (more like Py3) by preventing
# implicit relative imports, you can also add this to the top:
from __future__ import absolute_import

# Python 2 only
f = open('myfile.txt')
data = f.read()              # as a byte string
text = data.decode('utf-8')
 
# Python 2 and 3: alternative 1
from io import open
f = open('myfile.txt', 'rb')
data = f.read()              # as bytes
text = data.decode('utf-8')  # unicode, not bytes
 
# Python 2 and 3: alternative 2
from io import open
f = open('myfile.txt', encoding='utf-8')
text = f.read()    # unicode, not bytes

# Python 2 only:
assert reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) == 1+2+3+4+5
 
 
# Python 2 and 3:
from functools import reduce
 
assert reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) == 1+2+3+4+5

# Python 2 only:
f = file(pathname)

# Python 2 and 3:
f = open(pathname)
 
# But preferably, use this:
from io import open
f = open(pathname, 'rb')   # if f.read() should return bytes
# or
f = open(pathname, 'rt')   # if f.read() should return unicode text

# Python 2 only:
exec 'x = 10'
 
# Python 2 and 3:
exec('x = 10')

# Python 2 only:
g = globals()
exec 'x = 10' in g
 
# Python 2 and 3:
g = globals()
exec('x = 10', g)

# Python 2 only:
l = locals()
exec 'x = 10' in g, l
 
# Python 2 and 3:
exec('x = 10', g, l)

# Python 2 only:
execfile('myfile.py')
 
 
# Python 2 and 3: alternative 1
from past.builtins import execfile
 
execfile('myfile.py')
 
 
# Python 2 and 3: alternative 2
exec(compile(open('myfile.py').read()))
 
 
# This can sometimes cause this:
#     SyntaxError: function ... uses import * and bare exec ...
# See https://github.com/PythonCharmers/python-future/issues/37

# Python 2 only:
assert unichr(8364) == '€'
 
# Python 3 only:
assert chr(8364) == '€'
 
# Python 2 and 3:
from builtins import chr
assert chr(8364) == '€'

# Python 2 only:
intern('mystring')
 
 
# Python 3 only:
from sys import intern
intern('mystring')
 
 
# Python 2 and 3: alternative 1
from past.builtins import intern
intern('mystring')
 
 
# Python 2 and 3: alternative 2
from six.moves import intern
intern('mystring')
 
 
# Python 2 and 3: alternative 3
from future.standard_library import install_aliases
install_aliases()
from sys import intern
intern('mystring')
 
 
# Python 2 and 3: alternative 4
try:
    from sys import intern
except ImportError:
    pass
intern('mystring')

args = ('a', 'b')
kwargs = {'kwarg1': True}
 
 
# Python 2 only:
apply(f, args, kwargs)
 
 
# Python 2 and 3: alternative 1
f(*args, **kwargs)
 
 
# Python 2 and 3: alternative 2
from past.builtins import apply
apply(f, args, kwargs)

# Python 2 only:
assert chr(64) == b'@'
assert chr(200) == b'\xc8'
 
 
# Python 3 only: option 1
assert chr(64).encode('latin-1') == b'@'
assert chr(0xc8).encode('latin-1') == b'\xc8'
 
 
# Python 2 and 3: option 1
from builtins import chr
 
assert chr(64).encode('latin-1') == b'@'
assert chr(0xc8).encode('latin-1') == b'\xc8'
 
 
# Python 3 only: option 2
assert bytes([64]) == b'@'
assert bytes([0xc8]) == b'\xc8'
 
 
# Python 2 and 3: option 2
from builtins import bytes
 
assert bytes([64]) == b'@'
assert bytes([0xc8]) == b'\xc8'

# Python 2 only:
assert cmp('a', 'b') < 0 and cmp('b', 'a') > 0 and cmp('c', 'c') == 0
 
 
# Python 2 and 3: alternative 1
from past.builtins import cmp
assert cmp('a', 'b') < 0 and cmp('b', 'a') > 0 and cmp('c', 'c') == 0
 
 
# Python 2 and 3: alternative 2
cmp = lambda(x, y): (x > y) - (x < y)
assert cmp('a', 'b') < 0 and cmp('b', 'a') > 0 and cmp('c', 'c') == 0

# Python 2 only:
reload(mymodule)
 
 
# Python 2 and 3
from imp import reload
reload(mymodule)

# Python 2 only
import anydbm
import whichdb
import dbm
import dumbdbm
import gdbm
 
# Python 2 and 3: alternative 1
from future import standard_library
standard_library.install_aliases()
 
import dbm
import dbm.ndbm
import dbm.dumb
import dbm.gnu
 
# Python 2 and 3: alternative 2
from future.moves import dbm
from future.moves.dbm import dumb
from future.moves.dbm import ndbm
from future.moves.dbm import gnu
 
# Python 2 and 3: alternative 3
from six.moves import dbm_gnu
# (others not supported)

# Python 2 only
from commands import getoutput, getstatusoutput
 
# Python 2 and 3
from future import standard_library
standard_library.install_aliases()
 
from subprocess import getoutput, getstatusoutput

# Python 2.7 and above
from subprocess import check_output
 
# Python 2.6 and above: alternative 1
from future.moves.subprocess import check_output
 
# Python 2.6 and above: alternative 2
from future import standard_library
standard_library.install_aliases()
 
from subprocess import check_output

# Python 2.7 and above
from collections import Counter, OrderedDict
 
# Python 2.6 and above: alternative 1
from future.moves.collections import Counter, OrderedDict
 
# Python 2.6 and above: alternative 2
from future import standard_library
standard_library.install_aliases()
 
from collections import Counter, OrderedDict

# Python 2 only
from StringIO import StringIO
from cStringIO import StringIO
 
# Python 2 and 3
from io import BytesIO
# and refactor StringIO() calls to BytesIO() if passing byte-strings

# Python 2 only:
import httplib
import Cookie
import cookielib
import BaseHTTPServer
import SimpleHTTPServer
import CGIHttpServer
 
# Python 2 and 3 (after ``pip install future``):
import http.client
import http.cookies
import http.cookiejar
import http.server

# Python 2 only:
import DocXMLRPCServer
import SimpleXMLRPCServer
 
# Python 2 and 3 (after ``pip install future``):
import xmlrpc.server

# Python 2 only:
import xmlrpclib
 
# Python 2 and 3 (after ``pip install future``):
import xmlrpc.client

# Python 2 and 3:
from cgi import escape
 
# Safer (Python 2 and 3, after ``pip install future``):
from html import escape
 
# Python 2 only:
from htmlentitydefs import codepoint2name, entitydefs, name2codepoint
 
# Python 2 and 3 (after ``pip install future``):
from html.entities import codepoint2name, entitydefs, name2codepoint

# Python 2 only:
from HTMLParser import HTMLParser
 
# Python 2 and 3 (after ``pip install future``)
from html.parser import HTMLParser
 
# Python 2 and 3 (alternative 2):
from future.moves.html.parser import HTMLParser

urllib è uno dei moduli più complessi da usare in compatibilità fra 2 e 3.

# Python 2 only:
from urlparse import urlparse
from urllib import urlencode
from urllib2 import urlopen, Request, HTTPError

# Python 3 only:
from urllib.parse import urlparse, urlencode
from urllib.request import urlopen, Request
from urllib.error import HTTPError

# Python 2 and 3: easiest option
from future.standard_library import install_aliases
install_aliases()
 
from urllib.parse import urlparse, urlencode
from urllib.request import urlopen, Request
from urllib.error import HTTPError

# Python 2 and 3: alternative 2
from future.standard_library import hooks
 
with hooks():
    from urllib.parse import urlparse, urlencode
    from urllib.request import urlopen, Request
    from urllib.error import HTTPError

# Python 2 and 3: alternative 3
from future.moves.urllib.parse import urlparse, urlencode
from future.moves.urllib.request import urlopen, Request
from future.moves.urllib.error import HTTPError

# Python 2 and 3: alternative 4
try:
    from urllib.parse import urlparse, urlencode
    from urllib.request import urlopen, Request
    from urllib.error import HTTPError
except ImportError:
    from urlparse import urlparse
    from urllib import urlencode
    from urllib2 import urlopen, Request, HTTPError

# Python 2 only:
import Tkinter
import Dialog
import FileDialog
import ScrolledText
import SimpleDialog
import Tix
import Tkconstants
import Tkdnd
import tkColorChooser
import tkCommonDialog
import tkFileDialog
import tkFont
import tkMessageBox
import tkSimpleDialog
import ttk
 
# Python 2 and 3 (after ``pip install future``):
import tkinter
import tkinter.dialog
import tkinter.filedialog
import tkinter.scrolledtext
import tkinter.simpledialog
import tkinter.tix
import tkinter.constants
import tkinter.dnd
import tkinter.colorchooser
import tkinter.commondialog
import tkinter.filedialog
import tkinter.font
import tkinter.messagebox
import tkinter.simpledialog
import tkinter.ttk

# Python 2 only:
import SocketServer
 
# Python 2 and 3 (after ``pip install future``):
import socketserver

# Python 2 only:
import copy_reg
 
# Python 2 and 3 (after ``pip install future``):
import copyreg

# Python 2 only:
from ConfigParser import ConfigParser
 
# Python 2 and 3 (after ``pip install configparser``):
from configparser import ConfigParser

# Python 2 only:
from Queue import Queue, heapq, deque
 
# Python 2 and 3 (after ``pip install future``):
from queue import Queue, heapq, deque

# Python 2 only:
from repr import aRepr, repr
 
# Python 2 and 3 (after ``pip install future``):
from reprlib import aRepr, repr

# Python 2 only:
from UserDict import UserDict
from UserList import UserList
from UserString import UserString
 
 
# Python 3 only:
from collections import UserDict, UserList, UserString
 
 
# Python 2 and 3: alternative 1
from future.moves.collections import UserDict, UserList, UserString
 
 
# Python 2 and 3: alternative 2
from six.moves import UserDict, UserList, UserString
 
 
# Python 2 and 3: alternative 3
from future.standard_library import install_aliases
install_aliases()
from collections import UserDict, UserList, UserString

# Python 2 only:
from itertools import ifilterfalse, izip_longest
 
# Python 3 only:
from itertools import filterfalse, zip_longest
 
# Python 2 and 3: alternative 1
from future.moves.itertools import filterfalse, zip_longest
 
# Python 2 and 3: alternative 2
from six.moves import filterfalse, zip_longest
 
# Python 2 and 3: alternative 3
from future.standard_library import install_aliases
install_aliases()
from itertools import filterfalse, zip_longest

Questa libreria è un wrapper attorno a lib2to3 che serve a rendere il codice Python 2 più moderno in ottica di portarlo su Python 3.

Il comando python-modernize funziona come 2to3. Ecco come riscrivere un singolo file:

python-modernize -w example.py

Il sito Web del progetto è disponibile su GitHub e il nome del progetto PyPI è modernize

• Di default modernize non cambia le stringhe Unicode.
  Questa è l'opzione più semplice se vuoi supportare Python 3.x e versioni successive insieme a Python 2.
• In alternativa, c'è il flag –six-unicode che avvolgerà le stringhe Unicode con la funzione helper six.u() usando il fixer contenuto in libmodernize.fixes.fix_unicode.
  Ciò è utile se si desidera supportare Python 3.1 e Python 3.2 senza grandi cambiamenti.
• L'ultima alternativa è il flag –future-unicode che importa gli unicode_literals dal modulo __future__ usando il fixer contenuto in libmodernize.fixes.fix_unicode_future.
  Ciò richiede Python 2.6 e versioni successive e richiederà di contrassegnare le bytestring con b e le stringhe native in str() o qualcosa di simile che sopravviva alla trasformazione.

Dal prompt dei comandi lanciare

pip --install modernize

Al termine dell'installazione avrete a disposizione l'eseguibile python-modernize

set mydatetime=%date:~-4%%date:~-7,2%%date:~-10,2%_%time:~0,2%%time:~3,2%%time:~6,2%
set logpath=.\Logs
set logfile=%logpath%\Migrate_%Application%_2to3_%mydatetime%.log
set RepoPath=path\to\your \web2py\applications
set Application=Your_Folder_App_Name
 
IF NOT EXIST %logpath% (
  MKDIR %logpath%
)
 
(FOR /f "delims=" %%a IN ('DIR %RepoPath%\%Application%\*.pyc /b /s') do (del %%a))
(FOR /f "delims=" %%a IN ('DIR %RepoPath%\%Application%\*.py /b /s') do (python-modernize -w %%a >> %LogFile%))
(FOR /f "delims=" %%a IN ('DIR %RepoPath%\%Application%\*.bak /b /s') do (del %%a))

1. http://python-future.org/compatible_idioms.html
2. https://www.geeksforgeeks.org/important-differences-between-python-2-x-and-python-3-x-with-examples/
3. https://sebastianraschka.com/Articles/2014_python_2_3_key_diff.html
4. https://python-modernize.readthedocs.io/en/latest/