python:porting_python_2_to_pyton_3 [APressato.Com]

Questa pagina è in sola lettura. Puoi visualizzare il sorgente, ma non puoi modificarlo. Contatta l'amministratore se pensi che ci sia un errore.
====== Porting da Python 2 a Python 3  ====== 



===== Differenze con impatto maggiore =====
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 =====
Print è ora una funzione e per tanto vuole le parentesi tonde.

<code python>
# python 2.x
print "Ciao"

# python 3.x
print("Ciao")
</code>

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
<code python>
# python 2.x
print "Ciao", " Come stati?"
>> Ciao Come stai?

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

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

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

Per ovviare a questo spiacevole risultato, ci viene in aiuto il modulo **<nowiki>__future__</nowiki>**

<code python>
# python 2.x
from __future__ import print_function

print ("Ciao", " Come stati?")
>> Ciao Come stai?
</code>

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

==== Python 2 ====
<code python>
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
</code>

<code python>
>> Python 2.7.6
3 / 2 = 1
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0
</code>

==== Python 3 ====
<code python>
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)
</code>

<code python>
>> Python 3.4.1
3 / 2 = 1.5
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0
</code>

==== Python 2 e 3 ====
<code python>
# Python 2 and 3
from __future__ import division

assert 3 / 2 == 1.5
</code>

===== Long integers =====
In Python 3, il tipo ''//int//'' corrisponde come implementazione al vecchio tipo ''//long//'', quindi ''//int//'' e ''//long//'' diventano equivalenti.

==== Python 2 ====
<code python>
bigint = 1L

if isinstance(bigint, (int, long)):
    ...    
</code>

==== Python 3 ====
<code python>
bigint = 1

if isinstance(bigint, int):
    ...    
</code>

==== Python 2 e 3 ====
<WRAP center round important 60%>
**ATTENZIONE:** A Python 3 da fastidio la '' 'L' '' quindi in Python 2 sarà necessario modificare il codice come mostrato di seguito.
</WRAP>

<code python>
from builtins import int
bigint = int(1)

if isinstance(bigint, int):             # matches both int and long on Py2
    ...
</code>
===== Octal constants =====
<code python>
0644     # Python 2 only
0o644    # Python 2 and 3
</code>
===== Backtick repr =====
<code python>
`x`      # Python 2 only

repr(x)  # Python 2 and 3
</code>


===== Unicode (text) string literals e Byte-string literals =====
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.

==== Python 2 ====
<code python>
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'>
</code>

==== Python 3 ====
<code python>
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
</code>

==== Python 2 e 3 ====
<code python>
# 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'
</code>

===== xrange =====
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''.



===== Sollevare Eccezioni =====
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.

==== Python 2 ====
<code python>
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
</code>

==== Python 3 ====
<code python>
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
</code>

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



===== Sollevare Eccezioni (TraceBack) =====
==== Python 2 ====
<code python>
traceback = sys.exc_info()[2]
raise ValueError, "dodgy value", traceback
</code>

==== Python 3 ====
<code python>
raise ValueError("dodgy value").with_traceback()
</code>

==== Python 2 e 3 ====
<code python>
# 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"))
</code>


===== Gestire Eccezioni =====
In Python 3 ora è obbligatoria la keyword //**as**//.
==== Python 2 ====
<code python>
try:
    ...
except ValueError, e:
    ...
</code>

==== Python 3 ====
<code python>
try:
    ...
except ValueError as e:
    ...
</code>

==== Python 2 e 3 ====
Python 2 supporta la sintassi di Python 3.

<code python>
try:
    ...
except ValueError as e:
    ...
</code>
===== La funzione next() ed il metodo .next() =====
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''.

==== Python 2 ====
<code python>
my_generator = (letter for letter in 'abcdefg')

next(my_generator)
>> 'a'

my_generator.next()
>> 'b'
</code>

==== Python 3 ====
<code python>
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'
</code>

==== Python 2 e 3 ====
La soluzione è utilizzare sempre la funzione //**next()**//.
===== Variabili For-loop e perdita del namespace globale =====

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

==== Python 2 ====
<code python>
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
</code>

==== Python 3 ====
<code python>
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
</code>
===== Comparazione fra tipi unorderable =====
InPython 3 il tentativo di comparare due entità non ordinabili restituisce un ''TypeError''.

==== Python 2 ====
<code python>
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
</code>

==== Python 3 ====
<code python>
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'
</code>
===== Analisi degli input dell'utente tramite input() =====
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()**//.

==== Python 2 ====
<code python>
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'>
</code>
 
==== Python 3 ====
<code python>
my_input = input('enter a number: ')

>> enter a number: 123

type(my_input)
>> <class 'str'>
</code>
===== Restituire Oggetti Iterabili al posto si Liste =====
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()**//.

==== Python 2 ====
<code python>
print range(3)

>> [0, 1, 2]

print type(range(3))

>> <type 'list'>
</code>

==== Python 3 ====
<code python>
print(range(3))

>> range(0, 3)

print(type(range(3)))

>> <class 'range'>

print(list(range(3)))

>> [0, 1, 2]
</code>

** 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

===== Variazione del comportamento della funzione Round =====
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.

==== Python 2 ====
<code python>
round(15.5)

>> 16.0

round(16.5)

>> 17.0
</code>

==== Python 3 ====
<code python>
round(15.5)

>> 16

round(16.5)

>> 16
</code>
===== Custom class behaviour =====

===== Dictionaries =====

<code python>
heights = {'Fred': 175, 'Anne': 166, 'Joe': 192}
</code>

==== Scorrere le chiavi / i valori / gli elementi di un dizionario ====
=== Le chiavi ===
== Python 2 ==
<code python>
for key in heights.iterkeys():
    ...
</code>

== Python 2 e 3 ==
<code python>
for key in heights:
    ...
</code>

=== I Valori ===
== Python 2 ==
<code python>
for value in heights.itervalues():
    ...
</code>

== Python 2 e 3 ==
<code python>
#Opzione 0: Sconsigliata
for value in heights.values():    # Maggiore consumo di memoria in Py2
    ...
</code>

<code python>
# Opzione 1
from builtins import dict

heights = dict(Fred=175, Anne=166, Joe=192)
for key in heights.values():    # efficiente in Py2 e Py3
</code>

<code python>
# Opzione 2
from builtins import itervalues

for key in itervalues(heights):
    ...
</code>

=== Gli Elementi ===
== Python 2 ==
<code python>
for (key, value) in heights.iteritems():
    ...
</code>

== Python 2 e 3 ==
<code python>
# Opzione 1
for (key, value) in heights.items():    # inefficiente in Py2
    ...
</code>

<code python>
# Opzione 2
from future.utils import viewitems

for (key, value) in viewitems(heights):   # si compporta come un set
    ...
</code>

<code python>
# Opzione 3
from future.utils import iteritems

for (key, value) in iteritems(heights):
    ...
</code>

==== Chiavi/Valori/Elementi di un Dizionario come Lista ====
=== Chiavi ===
== Python 2 ==
<code python>
keylist = heights.keys()
assert isinstance(keylist, list)
</code>
== Python 2 e 3 ==
<code python>
keylist = list(heights)
assert isinstance(keylist, list)
</code>

=== Valori ===
== Python 2 ==
<code python>
heights = {'Fred': 175, 'Anne': 166, 'Joe': 192}
valuelist = heights.values()
assert isinstance(valuelist, list)
</code>
== Python 2 e 3 ==
<code python>
# Opzione 1
valuelist = list(heights.values())    # inefficiente in Py2
</code>

<code python>
# Opzione 2
from builtins import dict

heights = dict(Fred=175, Anne=166, Joe=192)
valuelist = list(heights.values())
</code>

<code python>
# Opzione 3
from future.utils import listvalues

valuelist = listvalues(heights)
</code>

<code python>
# Opzione 4
from future.utils import itervalues

valuelist = list(itervalues(heights))
</code>

=== Elementi ===
== Python 2 e 3 ==
<code python>
# Opzione 1
itemlist = list(heights.items())    # inefficiente in Py2
</code>

<code python>
# Opzione 2
from future.utils import listitems

itemlist = listitems(heights)
</code>

<code python>
# Opzione 3
from future.utils import iteritems

itemlist = list(iteritems(heights))
</code>

===== Imports relativi ad un package =====

supponiamo che il package abbia struttura:

<file>
mypackage/
    __init__.py
    submodule1.py
    submodule2.py
</file>

dove il modulo //submodule1.py// contenga il seguente codice:
<code python>
# 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
</code>
===== Altre variazioni ai builtins =====
==== File IO con open() ====
<code python>
# 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
</code>

==== reduce() ====
<code python>
# 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
</code>

==== file() ====
<code python>
# Python 2 only:
f = file(pathname)
</code>

<code python>
# 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
</code>

==== exec ====
<code python>
# Python 2 only:
exec 'x = 10'

# Python 2 and 3:
exec('x = 10')
</code>

<code python>
# Python 2 only:
g = globals()
exec 'x = 10' in g

# Python 2 and 3:
g = globals()
exec('x = 10', g)
</code>

<code python>
# Python 2 only:
l = locals()
exec 'x = 10' in g, l

# Python 2 and 3:
exec('x = 10', g, l)
</code>

==== execfile() ====
<code python>
# 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
</code>

==== unichr() ====
<code python>
# Python 2 only:
assert unichr(8364) == '€'

# Python 3 only:
assert chr(8364) == '€'

# Python 2 and 3:
from builtins import chr
assert chr(8364) == '€'
</code>

==== intern() ====
<code python>
# 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')
</code>

==== apply() ====
<code python>
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)
</code>

==== chr() ====
<code python>
# 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'
</code>

==== cmp() ====
<code python>
# 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
</code>

==== reload() ====
<code python>
# Python 2 only:
reload(mymodule)


# Python 2 and 3
from imp import reload
reload(mymodule)
</code>

===== Standard library =====
==== dbm modules ====
<code python>
# 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)
</code>

==== commands / subprocess modules ====
<code python>
# 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
</code>

==== subprocess.check_output() ====
<code python>
# 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
</code>

==== Collections: Counter and OrderedDict ====
<code python>
# 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
</code>

==== StringIO module ====
<code python>
# 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
</code>

==== http module ====
<code python>
# 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
</code>

==== xmlrpc module ====
<code python>
# Python 2 only:
import DocXMLRPCServer
import SimpleXMLRPCServer

# Python 2 and 3 (after ``pip install future``):
import xmlrpc.server
</code>

<code python>
# Python 2 only:
import xmlrpclib

# Python 2 and 3 (after ``pip install future``):
import xmlrpc.client
</code>

==== html escaping and entities ====
<code python>
# 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
</code>

==== html parsing ====
<code python>
# 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
</code>

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

<code python>
# Python 2 only:
from urlparse import urlparse
from urllib import urlencode
from urllib2 import urlopen, Request, HTTPError
</code>

<code python>
# Python 3 only:
from urllib.parse import urlparse, urlencode
from urllib.request import urlopen, Request
from urllib.error import HTTPError
</code>

<code python>
# 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
</code>

<code python>
# 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
</code>

<code python>
# 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
</code>

<code python>
# 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
</code>

==== Tkinter ====
<code python>
# 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
</code>

==== socketserver ====
<code python>
# Python 2 only:
import SocketServer

# Python 2 and 3 (after ``pip install future``):
import socketserver
</code>

==== copy_reg, copyreg ====
<code python>
# Python 2 only:
import copy_reg

# Python 2 and 3 (after ``pip install future``):
import copyreg
</code>

==== configparser ====
<code python>
# Python 2 only:
from ConfigParser import ConfigParser

# Python 2 and 3 (after ``pip install configparser``):
from configparser import ConfigParser
</code>

==== queue ====
<code python>
# Python 2 only:
from Queue import Queue, heapq, deque

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

==== repr, reprlib ====
<code python>
# Python 2 only:
from repr import aRepr, repr

# Python 2 and 3 (after ``pip install future``):
from reprlib import aRepr, repr
</code>

==== UserDict, UserList, UserString ====
<code python>
# 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
</code>

==== itertools: filterfalse, zip_longest ====
<code python>
# 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
</code>



===== Python-Modernize =====

==== Scopo del progetto ====
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:

<code bash>
python-modernize -w example.py
</code>

Il sito Web del progetto è disponibile su [[https://github.com/python-modernize/python-modernize|GitHub]] e il nome del progetto PyPI è [[https://pypi.python.org/pypi/modernize|modernize]]

==== Una nota sulla gestione delle stringhe ====
  * 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 **<nowiki>__future__</nowiki>** 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.

==== Preparazione ====
Dal prompt dei comandi lanciare
<code bash>
pip --install modernize
</code>
Al termine dell'installazione avrete a disposizione l'eseguibile **python-modernize**

==== Batch di conversione ====
<code batch>
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))
</code>


===== PyCharm e Cross-compatibilità =====
{{:python:annotazione_2020-01-12_230840.png?400|}}

===== Fonti =====
  - [[http://python-future.org/compatible_idioms.html]]
  - [[https://www.geeksforgeeks.org/important-differences-between-python-2-x-and-python-3-x-with-examples/]]
  - [[https://sebastianraschka.com/Articles/2014_python_2_3_key_diff.html]]
  - [[https://python-modernize.readthedocs.io/en/latest/]]
python/porting_python_2_to_pyton_3.txt · Ultima modifica: 2020/01/22 18:01 da apressato
Torna su