Différences et modifications de la syntaxe entre python2 et python3

Presque tous les programmes Python 2 nécessitent des modifications pour fonctionner correctement dans un environnement Python 3. Pour simplifier ce processus de conversion, Python 3 est livré avec un script pratique appelé 2to3 (Utility Script), qui prend vos fichiers source de programme Python 2 en entrée, puis les transforme automatiquement en forme de Python 3.

• #### La phrase print

Dans Python 2, print est une phrase. Tout ce que vous voulez exprimer, vous pouvez le faire en le plaçant après le mot-clé print. Dans Python 3, print () est une fonction. Comme d’autres fonctions, print () nécessite que vous lui transmettiez ce que vous voulez exprimer sous forme d’arguments.

Notes	Python 2	Python 3
①	print	print()
②	print 1	print(1)
③	print 1,2	print(1,2)
④	print 1,2,	print(1,2,end=’ ‘)
⑤	print >>sys.stderr,1,2,3	print(1,2,3, file=sys.stderr)

1. Pour la sortie d’une ligne blanche, il faut faire appel à un print sans paramètre ().
2. Pour produire une valeur distincte, il est nécessaire d’utiliser cette valeur comme un paramètre de print (). 3 ◦ Pour la sortie, utilisez deux valeurs séparées par un espace, avec deux arguments appelés print ((() ◦ Dans Python 2, si vous utilisez une virgule ((,) comme fin de la phrase print, elle séparera les résultats de la sortie par un espace, puis en sortira un espace suivant ((trailing space), sans retour de voiture ((carriage return)). Dans Python 3, le même effet peut être obtenu en transmettant end=’ ‘ comme un paramètre de mot-clé à print ((). Le paramètre d’end est défini par défaut comme ‘\n’, donc le caractère de retour de voiture peut être supprimé à la fin en redéfinissant la valeur du paramètre d’end. 5 Dans Python 2, vous pouvez rediriger la sortie vers un pipeline en utilisant la syntaxe <

• #### Chaînes de caractères Unicode

Python 2 dispose de deux types de chaînes:Chaînes de caractères UnicodeetUne chaîne non-UnicodeIl n’y a qu’un seul type dans Python 3:Chaînes de caractères Unicode。

Notes	Python 2	Python 3
①	u’PapayaWhip’	‘PapayaWhip’
②	ur’PapayaWhip\foo’	r’PapayaWhip\foo’

Les chaînes Unicode de Python 2 sont des chaînes ordinaires dans Python 3, car les chaînes Python 3 sont toujours en Unicode. Une chaîne de caractères Unicode raw ((raw string) (() utilise une chaîne de caractères qui n’est pas traduite automatiquement par Python.“) a également été remplacé par des chaînes ordinaires, car dans Python 3, toutes les chaînes originales sont encodées en Unicode。

• #### Fonctions globales en Unicode

Python 2 a deux fonctions globales qui peuvent forcer la conversion d’objets en chaînes: unicode ((() qui convertit les objets en chaînes Unicode, et str ((() qui convertit les objets en chaînes non Unicode. Python 3 n’a qu’un seul type de chaînes, les chaînes Unicode, donc la fonction str ((() peut faire tout le travail.La fonction unicode (() n’existe plus dans Python 3.)

Notes	Python 2	Python 3
①	unicode(anything)	str(anything)

• #### Longueur de forme

Python 2 dispose des types int et long pour les nombres non flottants. La valeur maximale du type int ne peut pas dépasser sys.maxint, et cette valeur maximale est relative à la plate-forme. On peut définir les entiers longs en ajoutant un L à la fin du nombre, ce qui est évidemment plus large que la portée numérique indiquée par le type int.

Pour en savoir plus: PEP 237: Unifier la longueur entière et l’intégrité.

Notes	Python 2	Python 3
①	x = 1000000000000L	x = 1000000000000
②	x = 0xFFFFFFFFFFFFL	x = 0xFFFFFFFFFFFF
③	long(x)	int(x)
④	type(x) is long	type(x) is int
⑤	isinstance(x,long)	isinstance(x,int)

Les entiers décimaux longs de Python 2 sont remplacés par des entiers ordinaires en chiffres décimaux de Python 3. Les entiers longs à seize chiffres de Python 2 sont remplacés par des entiers ordinaires à seize chiffres de Python 3. Dans Python 3, les types longs et entiers n’existent plus.Il n’y a plus de fonction naturelle long (). Pour forcer la conversion d’une variable en un entier, on peut utiliser la fonction int ().。 Vérifiez si une variable est entière, obtenez son type de données et comparez-la à une variable int du type ((non long)). Vous pouvez également utiliser la fonction insinstance (()) pour vérifier le type de données; pour souligner encore une fois, utilisez int, plutôt que long, pour vérifier le type d’entier ≠ long.

• #### <> Comparer les opérateurs

Python 2 prend en charge <> comme synonyme de !=. Python 3 prend en charge seulement !=, il n’est plus supporté <>.

Notes	Python 2	Python 3
①	if x <> y:	if x != y:
②	if x <> y<> z:	if x != y!= z:

1/ Faire une simple comparaison 2, une comparaison entre trois valeurs relativement complexes.

• #### Méthode de la classe dictionnaire has_key()

Dans Python 2, le has d’un objet de dictionnaire_la méthode de test pour savoir si le dictionnaire contient une clé spécifique. Cette méthode n’est plus supportée par Python 3. Vous devez utiliserinOpérateur

Notes	Python 2	Python 3
①	a_dictionary.has_key(‘PapayaWhip’)	‘PapayaWhip’ in a_dictionary
②	a_dictionary.has_key(x) or a_dictionary.has_key(y)	x in a_dictionary or y in a_dictionary
③	a_dictionary.has_key(x or y)	(x or y) in a_dictionary
④	a_dictionary.has_key(x + y)	(x + y) in a_dictionary
⑤	x + a_dictionary.has_key(y)	x + (y in a_dictionary)

1, la forme la plus simple. 2, l’opérateur or a une priorité inférieure à celle de l’opérateur in, il n’y a donc pas besoin d’ajouter des parenthèses. 3, d’autre part, pour la même raison, la priorité de or est inférieure à celle de in, ce qui nécessite l’ajout d’un parenthèses。(Note: le code ici est complètement différent de celui de la ligne précédente。Python interprète d’abord x or y, et obtient le résultat x(si x est vrai dans le contexte de Boolean) ou y。Python vérifie ensuite si ce résultat est a_Une clé de dictionary。) 4, l’opérateur in a une priorité inférieure à l’opérateur +, donc cette forme de code n’a pas besoin d’être encadrée par des parenthèses, mais 2 à 3 est ajouté. 5. Cette forme doit être entre parenthèses, car in a une priorité inférieure à +。

• #### Une méthode de classe de dictionnaire qui renvoie une liste

Dans Python 2, les valeurs de retour de nombreuses méthodes de classe dictionnaire sont des listes. Les méthodes les plus couramment utilisées contiennent des clés, des éléments et des valeurs. Dans Python 3, les valeurs de retour de toutes les méthodes ci-dessus sont modifiées en vue dynamique. Dans certains contextes, ce changement n’a pas d’impact.

Notes	Python 2	Python 3
①	a_dictionary.keys()	list(a_dictionary.keys())
②	a_dictionary.items()	list(a_dictionary.items())
③	a_dictionary.iterkeys()	iter(a_dictionary.keys())
④	[i for iin a_dictionary.iterkeys()]	[i for iin a_dictionary.keys()]
⑤	min(a_dictionary.keys())	no change

Le code de cette façon est efficace, mais il est moins efficace pour utiliser des vues. Vous devriez vérifier le code après la conversion pour voir si vous avez vraiment besoin d’une liste, peut-être que les vues peuvent faire la même chose. 2 , c’est une autre vue de la conversion de la méthode de () à la liste. La conversion de la méthode de () à la valeur de () est la même. 3 , il n’y a plus de support pour les keys () en Python 3 . Si nécessaire, utilisez iter () pour convertir la valeur de retour de keys () en un iterateur . 4, 2to3 est capable d’identifier la méthode iterkeys () utilisée dans le partage de listes, puis de la convertir en une méthode keys () de Python 3 sans avoir besoin d’utiliser un itérateur supplémentaire () pour emballer sa valeur de retour). 5 2to3 reconnaît également que les retours de la méthode keys (()) sont immédiatement transmises à une autre fonction qui parcourt la séquence entière, de sorte qu’il n’est pas nécessaire de convertir les retours de keys (() en une liste. Au contraire, la fonction min (() est heureuse de parcourir la vue. Ce processus est également efficace pour min ((), max ((), sum ((), list ((), tuple ((), set ((), sorted ((), any (() et all (().

• #### Modules renommés ou réorganisés

De Python 2 à Python 3, certains modules de la bibliothèque standard ont été renommés. D’autres modules interdépendants ont été regroupés ou réorganisés pour rendre cette association plus logique.

• http Dans Python 3, plusieurs modules HTTP associés sont regroupés en un seul paquet, http.

Notes	Python 2	Python 3
①	import httplib	import http.client
②	import Cookie	import http.cookies
③	import cookielib	import http.cookiejar
④	import BaseHTTPServer import SimpleHTTPServer import CGIHttpServer	import http.server

Le module http.client implémente une bibliothèque sous-jacente qui peut être utilisée pour demander des ressources HTTP et analyser les réponses HTTP. Le module http.cookies fournit une interface Python pour accéder aux cookies envoyés par le Set-Cookie via l’en-tête HTTP Les navigateurs les plus courants stockent les cookies sur le disque sous forme de fichiers, qui peuvent être manipulés par le module http.cookiejar. Le module http.server implémente un serveur HTTP de base

• urllib Python 2 possède quelques modules pour analyser, encoder et extraire les URL, mais ces modules s’entre-couvrent comme des trous de souris. Dans Python 3, ces modules sont reconstruits et regroupés en un seul paquet, urllib.

Notes	Python 2	Python 3
①	import urllib	import urllib.request urllib.parse,urllib.error
②	import urllib2	import urllib.request urllib.error
③	import urlparse	import urllib.parse
④	import robotparser	import urllib.robotparser
⑤	from urllib import FancyURLopener from urllib import urlencode	from urllib.request import FancyURLopener from urllib.parse import urlencode
⑥	from urllib2 import Request from urllib2 import HTTPError	from urllib.request import Request from urllib.error import HTTPError

Auparavant, le module urllib de Python 2 possédait une variété de fonctions, dont urlopen () pour extraire des données, mais il était également utile de diviser l’URL en ses composants: les fonctions splitype () et splituser (). Dans le nouveau package urllib, ces fonctions sont organisées de manière plus logique. 2to3 modifiera l’appel de ces fonctions pour s’adapter au nouveau schéma de nommage. Dans Python 3, les anciens modules d’urllib2 ont été intégrés dans le package urllib. De plus, vos préférences d’urllib2 seront intégrées dans le module urllib de Python 3, comme build_Les méthodes opener, objet de requête, HTTPBasicAuthHandler et les amis. Le module urllib.parse de Python 3 contient toutes les fonctions de résolution du module urlparse de Python 2. Le module urllib.robotparse est utilisé pour analyser le fichier robots.txt. La classe FancyURLopener, qui gère les redirections HTTP et les autres codes d’état, est toujours en vigueur dans le module urllib.request de Python 3. La fonction △urlencode ((() a été transférée dans urllib.parse. L’objet Request est toujours valide dans urllib.request, mais des constantes comme HTTPError ont été transférées dans urllib.error. Ai-je mentionné que 2to3 réécrit aussi vos appels à fonctions ? Par exemple, si vous importez le module urllib dans votre code Python 2 et que vous appelez la fonction urllib.urlopen (()) pour obtenir des données, 2to3 modifie à la fois l’instruction d’import et l’appel à fonctions.

Notes	Python 2	Python 3
①	import urllib print urllib.urlopen(’http://diveintopython3.org/‘).read()	import urllib.request, urllib.parse, urllib.error print(urllib.request.urlopen(’http://diveintopython3.org/‘).read())

• dbm Tous les clones de DBM sont désormais regroupés dans un seul paquet, le dbm. Si vous avez besoin d’une variante spécifique de l’un d’entre eux, par exemple GNUDBM, vous pouvez importer le module correspondant dans le paquet.

Notes	Python 2	Python 3
①	import dbm	import dbm.ndbm
②	import gdbm	import dbm.gnu
③	import dbhash	import dbm.bsd
④	import dumbdbm	import dbm.dumb
⑤	import anydbm import whichdb	import dbm

• xmlrpc XML-RPC est une méthode de niveau léger pour exécuter des appels RPC à distance via le protocole HTTP. Certaines bibliothèques d’implémentations de client XML-RPC et de serveur XML-RPC sont désormais regroupées en un paquet indépendant, xmlrpc.

Notes	Python 2	Python 3
①	import xmlrpclib	import xmlrpc.client
②	import DocXMLRPCServer import SimpleXMLRPCServer	import xmlrpc.server

• #### Autres modules

Notes	Python 2	Python 3
①	try: 　　import cStringIO as StringIO except ImportError: 　　import StringIO	import io
②	try: 　　import cPickle as pickle except ImportError:　 　　import pickle	import pickle
③	import _builtin_	import builtins
④	import copy_reg	import copyreg
⑤	import Queue	import queue
⑥	import SocketServer	import socketserver
⑦	import ConfigParser	import configparser
⑧	import repr	import reprlib
⑨	import commands	import subprocess

1, dans Python 2, vous faites généralement ceci, essayez d’abord d’importer cStringIO comme alternative à StringIO, et si cela échoue, importez StringIO. Ne faites pas cela dans Python 3; le module io vous aidera à gérer cette affaire. Il trouvera la méthode d’implémentation la plus rapide disponible, puis l’utilisera automatiquement. Dans Python 2, l’importation de la mise en œuvre la plus rapide de Pickle est également une méthode utile similaire à celle ci-dessus. Dans Python 3, le module Pickle le fait automatiquement pour vous, alors ne le faites plus. 3, le module builtins contient les fonctions globales, les classes et les constantes utilisées dans tout le langage Python. La redéfinition d’une fonction dans le module builtins signifie la redéfinition de cette fonction globale partout. Cela semble puissant, mais c’est aussi effrayant. 4, le module copyreg a ajouté la prise en charge du module pickle pour les types personnalisés par l’utilisateur définis dans le langage C. Le module de queue permet de mettre en place une file d’attente multi-producteur, multi-consommateur. 6 Les modules socketserver fournissent des classes de base générales pour la mise en œuvre de divers types de serveurs sockets. Le module configparser est utilisé pour analyser les fichiers de configuration de type INI. 8, le module reprlib ré-implémente la fonction intégrée repr (), et ajoute un contrôle sur la longueur de la chaîne de caractères avant qu’elle ne soit coupée. Le module de sous-processus vous permet de créer des sous-processus, de les connecter à votre pipeline et de récupérer leurs valeurs de retour.

• Importation relative dans le paquet

Un paquet est une entité composée d’un ensemble de modules associés. Pour obtenir des références réciproques de modules dans le même paquet, vous utilisez import foo ou from foo import Bar. L’interpréteur Python 2 recherche foo.py dans le répertoire actuel, puis dans le chemin de recherche Python ((sys.path).

Supposons que vous ayez plusieurs fichiers dans le même répertoire:

chardet/ | +–init.py | +–constants.py | +–mbcharsetprober.py | +–universaldetector.py

Supposons maintenant qu’universaldetector.py ait besoin d’importer constants.py dans son intégralité, et qu’il ait besoin d’importer une classe de mbcharsetprober.py en plus. Que feriez-vous ?

Notes	Python 2	Python 3
①	import constants	from .import constants
②	from mbcharsetprober import MultiByteCharSetProber	from .mbcharsetprober import MultiByteCharsetProber

1. Lorsque vous devez importer un module entier depuis une autre partie du pack, utilisez la nouvelle syntaxe from.import. Le point (..) indique le chemin relatif entre le fichier actuel (universaldetector.py) et le fichier que vous voulez importer (constants.py). Dans cet exemple, les deux fichiers se trouvent dans le même répertoire, donc une seule phrase est utilisée.
2. Pour importer une classe ou une fonction spécifique directement dans l’espace de noms de votre module à partir d’un autre module, ajoutez le chemin relatif au nom du module à importer et supprimez la dernière barre oblique ((slash)). Dans cet exemple, mbcharsetprober.py et universaldetector.py sont dans le même répertoire, donc le nom du chemin relatif est un point. Vous pouvez également importer depuis le répertoire parent ((from .. import anothermodule) ou dans le sous-répertoire.

• #### La méthode de l’incarneur (next)

Dans Python 2, l’itérateur a une méthode next () pour retourner le prochain élément de la séquence. Cela a également été le cas dans Python 3, mais il existe maintenant une nouvelle fonction globale next () qui utilise un itérateur comme paramètre.

Notes	Python 2	Python 3
①	anIterator.next()	next(anIterator)
②	a_function_that_returns_an_iterator().next()	next(a_function_that_returns_an_iterator())

|③|class A:
　　def next(self):
　　pass|class A:
　　def next(self):
　　pass｜ |④|class A:
　　def next(self, x, y):
　　pass|no change | |⑤|next = 42
for an_iterator in a_sequence_of_iterators:
　　an_iterator.next()|next = 42
for an_iterator in a_sequence_of_iterators:
　　an_iterator.next() | Dans le cas le plus simple, vous n’appelez plus la méthode next (() d’un iterateur, mais vous passez l’iterateur lui-même comme paramètre à la fonction globale next (() . 2. si vous avez une fonction qui retourne une valeur de l’incarnation, appelez cette fonction et transmettez le résultat en tant qu’argument à la fonction next (). Les scripts 2 à 3 sont suffisamment intelligents pour effectuer cette conversion correctement. 3 Si vous définissez votre propre classe, et que vous l’utilisez comme un iterateur, dans Python 3, vous pouvez définir des méthodes spéciales en utilisant les classes de Python.next() pour le réaliser. 4. Si vous définissez une classe qui contient une ou plusieurs paramètres, ne la bougez pas lors de l’exécution de 2 à 3. Cette classe ne peut pas être utilisée comme un iterateur car sa méthode next (). 5, c’est un peu compliqué. Si vous avez une variable locale appelée next, elle a une priorité plus élevée dans Python 3 que la fonction globale next (((). Dans ce cas, vous devez appeler une méthode spéciale de l’inventeur.next() pour obtenir le prochain élément de la séquence。(ou, vous pouvez aussi reconstituer le code pour que le nom de la variable locale ne soit pas next, mais 2to3 ne le fera pas pour vous。)

• #### Filtre de fonction globale

Dans Python 2, la méthode filter() renvoie une liste obtenue en testant chaque élément d’une séquence avec une fonction qui renvoie une valeur True ou False. Dans Python 3, la fonction filter() renvoie un iterateur qui n’est plus une liste.

Notes	Python 2	Python 3
①	filter(a_function, a_sequence)	list(filter(a_function, a_sequence))
②	list(filter(a_function, a_sequence))	no change
③	filter(None, a_sequence)	[i for iin a_sequence if i]
④	for i in filter(None, a_sequence):	no change
⑤	[i for iin filter(a_function, a_sequence)]	no change

1, dans le cas le plus simple, 2to3 utilise une fonction list () pour emballer filter () et la fonction list () parcourt ses paramètres et retourne une liste [2]. 2, cependant, si l’appel filter () a déjà été traité par le paquet list () 2to3 ne le fait plus, car dans ce cas, il est indifférent de savoir si la valeur de retour de filter () est un iterateur. Pour traiter la grammaire particulière de filter ((None, …), 2 à 3 transforme cette invocation de syntaxiquement équivalente en analyse de liste. 4. Comme le cycle for parcourt toute la séquence, il n’est pas nécessaire d’effectuer d’autres modifications. 5, comme ci-dessus, aucune modification n’est nécessaire, car l’analyse de la liste parcourt toute la séquence, et même si le filtre () renvoie un iterateur, il peut toujours fonctionner correctement comme le filtre () précédent qui renvoie la liste.

• #### Carte des fonctions globales

Comme pour le filtre, la fonction map () renvoie désormais un iterateur. Dans Python 2, elle renvoie une liste.

Notes	Python 2	Python 3
①	map(a_function,‘PapayaWhip’)	list(map(a_function,‘PapayaWhip’))
②	map(None,‘PapayaWhip’)	list(‘PapayaWhip’)
③	map(lambda x: x+1,range(42))	[x+1for x in range(42)]
④	for i in map(a_function, a_sequence):	no change
⑤	[i for iin map(a_function,a_sequence)]	no change

1 , similaire au traitement de filter ((), dans le cas le plus simple, 2to3 utilise une fonction list (() pour emballer l’appel map (() }} . 2, pour une syntaxe spéciale map ((None, …) comme pour filter ((None, …) 2to3 le convertit en un appel équivalent à celui utilisé par list (() 3, si le premier argument de map () est une fonction lambda, 2to3 le convertit équivalemment en résolution de liste. 4 Pour un cycle for qui traverse toute la séquence, aucune modification n’est nécessaire. 5/ Encore une fois, il n’y a pas besoin de faire de modifications ici, car le partage de la liste parcourt toute la séquence, et même si le retour de map () est un iterateur plutôt qu’une liste, il fonctionnera normalement.

• #### La fonction globale réduire

Dans Python 3, la fonction réduce () a été supprimée de l’espace de noms global et est maintenant placée dans le module fucntools.

Notes	Python 2	Python 3
①	reduce(a, b, c)	from functools import reduce reduce(a, b, c)

• #### La fonction globale apply ()

Python 2 a une fonction globale appelée apply (), qui utilise une fonction f et une liste[a, b, c] comme paramètre, renvoie la valeur f ((a, b, c) . Vous pouvez également appeler cette fonction directement, en ajoutant un astérisque ((*Pour faire la même chose, on lui passe des arguments. Dans Python 3, la fonction apply () n’existe plus; il faut utiliser la notation d’astérisque.

Notes	Python 2	Python 3
①	apply(a_function, a_list_of_args)	a_function(*a_list_of_args)
②	apply(a_function, a_list_of_args, a_dictionary_of_named_args)	a_function(*a_list_of_args,**a_dictionary_of_named_args)
③	apply(a_function, a_list_of_args+ z)	a_function(*a_list_of_args+ z)
④	apply(aModule.a_function, a_list_of_args)	aModule.a_function(*a_list_of_args)

1, la forme la plus simple, peut être obtenue par une liste de paramètres comme[a, b, c]), ajouter un astérisque avant d’appeler la fonction. C’est l’équivalent de la fonction apply (() de Python 2. Dans Python 2, la fonction apply (() peut en fait avoir 3 arguments: une fonction, une liste d’arguments, un dictionnaire de noms d’arguments. Dans Python 3, vous pouvez ajouter un astérisque avant la liste d’arguments), ajouter deux astérisques avant les arguments de nommage du dictionnaire ((**Le gouvernement a décidé d’envoyer un message de soutien à l’opposition. 3, l’opérateur + est utilisé ici comme une fonction de la liste de connexions qui a plus de priorité que l’opérateur, il n’est donc pas nécessaire d’ajouter des parenthèses supplémentaires autour de a_list_of_args + z. 4, le script 2 à 3 est suffisamment intelligent pour convertir les appels compliqués apply (), y compris les appels à des fonctions dans le module d’importation.

• #### Fonction globale interne

Dans Python 2, vous pouvez utiliser la fonction interne () pour définir la fonction interne sur une chaîne de caractères afin d’optimiser les performances. Dans Python 3, la fonction interne () est transférée dans le module sys.

Notes	Python 2	Python 3
①	intern(aString)	sys.intern(aString)

• #### Une instruction exec

Tout comme la fonction print devient une fonction dans Python 3, la fonction exec fait de même. La fonction .exec () utilise une chaîne de caractères contenant du code Python comme paramètre, puis l’exécute comme une expression ou une expression.

Notes	Python 2	Python 3

|①|exec codeString|exec(codeString) |②|exec codeString in a_global_namespace|exec(codeString, a_global_namespace)| |③|exec codeString in a_global_namespace, a_local_namespace|exec(codeString, a_global_namespace,a_local_namespace)| 1, dans sa forme la plus simple, puisque exec (() est maintenant une fonction plutôt qu’une phrase, 2to3 entourera ce code sous forme de chaîne de caractères avec des parenthèses。 2 Les expressions exec de Python 2 peuvent spécifier un espace de noms, et le code s’exécute dans cet espace privé composé d’objets globaux. Python 3 a aussi cette fonctionnalité; il suffit de passer cet espace de noms comme deuxième paramètre à la fonction exec (). 3/ Plus étonnant encore, l’instruction exec de Python 2 peut également spécifier un espace de noms local (par exemple, une variable déclarée dans une fonction). Dans Python 3, la fonction exec () a également cette fonction.

• #### La déclaration execfile

Comme les précédentes instructions d’exécuter, les instructions d’exécuter dans Python 2 peuvent utiliser des chaînes de caractères comme pour exécuter du code Python. Contrairement aux instructions d’exécuter dans un fichier, les instructions d’exécuter dans un fichier ont été supprimées dans Python 3. Si vous souhaitez vraiment exécuter du code Python dans un fichier (mais que vous ne souhaitez pas l’importer), vous pouvez le faire en ouvrant ce fichier, en lisant ce qu’il contient, puis en appelant la fonction compile (global) pour forcer l’interpréteur Python à compiler le code, puis en appelant la nouvelle fonction exec (global).

Notes	Python 2	Python 3
①	execfile(‘a_filename’)	exec(compile(open(‘a_filename’).read(),‘a_filename’,‘exec’))

• #### repr (avec des guillemets)

Dans Python 2, pour obtenir une expression en chaîne d’un objet quelconque, il y a une façon d’envelopper l’objet dans des contre-indications comme ((xDans Python 3, cette capacité existe toujours, mais vous ne pouvez plus utiliser de rétrocitation pour obtenir cette chaîne de caractères. Vous devez utiliser la fonction globale repr ().

Notes	Python 2	Python 3
①	`x`	repr(x)
②	`‘PapayaWhip’ + `2``	repr(‘PapayaWhip’+ repr(2))

1. N’oubliez pas que x peut être n’importe quoi: une classe, une fonction, un module, un type de données de base, etc. 2, dans Python 2, les rétrocitations peuvent être emboîtées, ce qui donne cette expression déroutante (mais efficace). 2to3 est suffisamment intelligent pour transformer cet appel emboîté en une fonction repr ().

• #### Je ne sais pas.

La syntaxe de capture des anomalies a quelque peu changé de Python 2 à Python 3.

Notes	Python 2	Python 3
①	try: 　　import mymodule except　ImportError, e 　　pass	try: 　　import mymodule except ImportError as e: 　　pass
②	try: 　　import mymodule except (RuntimeError, ImportError), e 　　pass	try: 　　import　mymodule except (RuntimeError, ImportError) as e: 　　pass
③	try: 　　import mymodule except ImportError: 　　pass	no change
④	try: 　　import mymodule except: 　　pass	no change

1, par rapport à Python 2 qui ajoute une virgule après le type d’exception, Python 3 utilise un nouveau mot-clé, as。 2. le mot-clé as peut également être utilisé pour capturer plusieurs types d’anomalies en même temps. 3. si vous avez une exception mais que vous ne vous souciez pas d’accéder à l’objet d’exception lui-même, la syntaxe de Python 2 et de Python 3 est la même. De même, si vous utilisez une méthode de sauvegarde (fallback) pour capturer toutes les exceptions, la syntaxe de Python 2 et Python 3 est la même. 5/ Lorsque vous importez des modules (ou dans la plupart des autres cas), vous ne devriez absolument pas utiliser cette méthode (voir le fallback ci-dessus). Sinon, le programme risque de capturer des anomalies comme KeyboardInterrupt (interrompre le programme si l’utilisateur appuie sur Ctrl-C), ce qui rend le débogage plus difficile.

• #### La phrase “raise”

Dans Python 3, la syntaxe des exceptions personnalisées a été légèrement modifiée.

Notes	Python 2	Python 3
①	raise MyException	unchanged
②	raise MyException,‘error message’	raise MyException(‘error message’)
③	raise MyException,‘error message’, a_traceback	raise MyException(‘errormessage’).with_traceback(a_traceback)
④	raise ‘error message’	unsupported

1° émettre des exceptions sans message d’erreur personnalisé par l’utilisateur, sous cette forme la plus simple, la grammaire n’a pas été modifiée; 2 Lorsque vous voulez lancer une exception avec un message d’erreur personnalisé par l’utilisateur, la modification est évidente. Python 2 utilise une virgule pour séparer la classe d’exception de l’erreur; Python 3 transmet l’erreur à la classe d’exception en tant que paramètre. Python 2 prend en charge une grammaire plus complexe pour lancer une exception avec une rétroaction personnalisée par l’utilisateur. Vous pouvez également le faire dans Python 3, mais la grammaire est complètement différente. 4 Dans Python 2, vous pouvez lancer une exception sans classe d’exception, avec un seul message d’exception. Dans Python 3, cette forme n’est plus prise en charge. 2to3 vous avertira qu’il ne peut pas corriger automatiquement cette syntaxe.

• #### Throw de la génératrice

Dans Python 2, le générateur dispose d’une méthode de lancement (throw)). L’appel a_generator.throw () lance une exception lorsque le générateur est suspendu, puis renvoie la valeur suivante obtenue par la fonction de générateur. Dans Python 3, cette fonctionnalité est toujours disponible, mais avec une grammaire légèrement différente.

Notes	Python 2	Python 3
①	a_generator.throw(MyException)	no change
②	a_generator.throw(MyException,‘error message’)	a_generator.throw(MyException(‘error message’))
③	a_generator.throw(‘error message’)	unsupported

1, dans sa forme la plus simple, le générateur lance des exceptions sans message d’erreur personnalisé par l’utilisateur. Dans ce cas, il n’y a pas de changement de syntaxe de Python 2 à Python 3. 2. Si le générateur lance une exception avec un message d’erreur personnalisé par l’utilisateur, vous devez transmettre ce message d’erreur à la classe d’exception pour l’installer. 3 Python 2 prend également en charge les exceptions qui ne renvoient que des messages d’exception. Python 3 ne prend pas en charge cette syntaxe et 2to3 affiche un message d’avertissement vous indiquant que vous devez corriger manuellement ce code.

• #### La fonction globale xrange ()

Dans Python 2, il y a deux façons d’obtenir un nombre dans une certaine plage: range (), qui renvoie une liste, et range (), qui renvoie un iterateur. Dans Python 3, range (), qui renvoie un iterateur, et xrange (), qui n’existe plus.

Notes	Python 2	Python 3
①	xrange(10)	range(10)
②	a_list = range(10)	a_list = list(range(10))
③	[i for iin xrange(10)]	[i for iin range(10)]
④	for i in range(10):	no change
⑤	sum(range(10))	no change

1, dans le cas le plus simple, 2 à 3 convertit simplement xrange () en range () [2]. Si votre code Python 2 utilise range (), 2to3 ne sait pas si vous avez besoin d’une liste, ou si un iterateur fonctionne aussi. Par précaution, 2to3 risque de faire une erreur, puis d’utiliser list () pour forcer la conversion de la valeur de retour de range (). Si la liste contient une fonction xrange (), il n’est pas nécessaire de convertir sa valeur de retour en une liste, car la liste fonctionne de la même manière pour l’incarnation. 4, de même, le cycle for peut aussi agir sur l’incarnation, donc rien ne change ici. 5, la fonction sum ((() fonctionne sur l’incarneur, donc 2to3 n’a pas modifié ici. Comme pour les méthodes de classe dictionnaire qui renvoient une valeur en tant que vue ((view) et non plus en tant que liste, cela s’applique également à min (((), max (((), sum (((), list (((), tuple (((), set (((), sorted (((), any (((), all ((().

• #### Les fonctions globales (raw_input) et (input)

Python 2 a deux fonctions globales qui sont utilisées pour demander des entrées à l’utilisateur dans la ligne de commande. La première est appelée input (), qui attend que l’utilisateur tape une expression Python (), puis renvoie le résultat (). La seconde est appelée raw_input (), et ce que l’utilisateur tape renvoie ce qu’il a écrit ().

Notes	Python 2	Python 3
①	raw_input()	input()
②	raw_input(‘prompt’)	input(‘prompt’)
③	input()	eval(input())

1, la forme la plus simple, raw_input (() est remplacée par input (()) [2]. 2 Dans Python 2, la fonction raw_input (() peut spécifier un pointeur comme paramètre. Si vous souhaitez vraiment demander à un utilisateur de saisir une expression Python, vous pouvez calculer le résultat en appelant la fonction input () et transmettre la valeur retournée à eval () [2].

• #### Propriété de la fonction

Dans Python 2, le code d’une fonction donne accès aux propriétés spéciales de la fonction elle-même. Dans Python 3, ces propriétés spéciales ont été renommées pour plus de cohérence.

Notes	Python 2	Python 3
①	a_function.func_name	a_function._name_
②	a_function.func_doc	a_function._doc_
③	a_function.func_defaults	a_function._defaults_
④	a_function.func_dict	a_function._dict_
⑤	a_function.func_closure	a_function._closure_
⑥	a_function.func_globals	a_function._globals_
⑦	a_function.func_code	a_function._code_

1、name l’attribut ((originalfunc_name) contient le nom de la fonction。 2、doc attribut ((originalfuncdoc) contient la chaîne de fichiers que vous avez définie dans le code source de la fonction ((docstring) 3、defaultsattributs (originalfunc_defaults) est un sous-groupe qui conserve les valeurs par défaut des paramètres. 4、dictattribute ((originalfunc_dict) est un espace de noms qui prend en charge les attributs de fonctions arbitraires。 5、closureattribut (original function_closure) est un sous-groupe composé d’objets de cellule qui contient la liaison d’une fonction à une variable libre. 6、globalsattribut ((originalfunc_globals) est une référence à l’espace de noms global du module, dans lequel la fonction elle-même est définie. 7、codeattribut (originalfunc_code) est un objet de code qui représente un corps de fonctions compilé.

• #### Les méthodes d’entrée/sortie

Dans Python 2, les objets de fichier ont une méthode xreadlines () qui renvoie un iterateur qui lit une ligne de fichier à la fois. Cela est particulièrement utile dans le cycle for. En fait, les versions ultérieures de Python 2 ont ajouté cette fonctionnalité aux objets de fichier eux-mêmes.

Dans Python 3, la méthode xreadlines (()) n’est plus disponible. 2 à 3 peut résoudre des situations simples, mais certains cas marginaux nécessitent une intervention manuelle.

Notes	Python 2	Python 3
①	for line in a_file.xreadlines():	for line in a_file:
②	for line in a_file.xreadlines(5):	no change (broken)

1, si vous avez précédemment appelé xreadlines sans paramètre (), 2to3 le convertit en objet de fichier lui-même. Dans Python 3, le code après cette conversion peut faire la même chose: lire une ligne de fichier une fois, puis exécuter le corps de la boucle for. 2 Si vous avez déjà utilisé un argument ((numéro de lignes lues à chaque fois)) pour appeler xreadlines ((), 2to3 ne peut pas effectuer la conversion de Python 2 vers Python 3 pour vous, et votre code échouera de la manière suivante: AttributeError: ‘_io.TextIOWrapper’ object has no attribute ‘xreadlines’。 Vous pouvez manuellement changer les xreadlines en readlines pour que le code puisse fonctionner sous Python 3。 La méthode readline renvoie l’éditeur dans Python 3, donc elle est moins efficace que les xreadlines dans Python 2。

• #### Une fonction lambda qui utilise des sous-groupes plutôt que des arguments multiples

Dans Python 2, vous pouvez définir une fonction lambda anonyme, qui est en fait capable de recevoir plusieurs arguments en spécifiant le nombre d’éléments d’un sous-groupe d’arguments. En fait, l’interpréteur de Python 2 décompose ce sous-groupe en arguments nommés, et vous pouvez ensuite les référencer dans la fonction lambda. Dans Python 3, vous pouvez toujours transmettre un sous-groupe en tant qu’argument de la fonction lambda, mais l’interpréteur de Python ne le résoudra pas en arguments nommés.

Notes	Python 2	Python 3
①	lambda (x,): x+ f(x)	lambda x1: x1[0]+f(x1[0])
②	lambda (x, y): x+f(y)	lambda x_y: x_y[0]+f(x_y[1])
③	lambda (x,(y,z)): x+ y+ z	lambda x_y_z: x_y_z[0]+x_y_z[1][0]+ x_y_z[1][1]
④	lambda x, y, z: x+y + z	unchanged

1, si vous avez déjà défini une fonction lambda qui utilise un sous-groupe contenant un élément comme argument, dans Python 3, elle sera convertie en un sous-groupe contenant x1[La fonction lambda de référence de 0]。x1 est générée automatiquement par le script 2to3 en fonction des paramètres de nommage du métamorphe d’origine。 2, la fonction lambda qui utilise comme paramètre un sous-groupe de deux éléments (x, y) est convertie en x_y, qui a deux paramètres de position, soit x_y[0] et x_y[1]。 Les scripts 2 à 3 peuvent même traiter les lambda de la fonction utilisant les paramètres de nommage de la matrice comme paramètres. Le code résultant est un peu difficile à lire, mais il fonctionne de la même manière sous Python 3 que le code original sous Python 2. 4. Vous pouvez définir des fonctions lambda utilisant plusieurs paramètres. Si aucune parenthèse n’est entourée d’un paramètre, Python 2 le traite comme une fonction lambda contenant plusieurs paramètres; dans ce corps de fonctions lambda, vous faites référence à ces paramètres par leur nom, comme dans d’autres types de fonctions. Cette syntaxe est toujours valable dans Python 3.

• #### Attributs de méthode spéciale

Dans Python 2, les méthodes de classe peuvent accéder à la définition de leur objet de classe (class object) ou à l’objet de méthode (method object) lui-même. Im_self est l’objet d’instance de la classe; im_func est l’objet de fonction, im_class est la classe elle-même. Dans Python 3, ces propriétés ont été renommées pour suivre les conventions de nommage des autres propriétés.

Notes	Python 2	Python 3
①	aClassInstance.aClassMethod.im_func	aClassInstance.aClassMethod._func_
②	aClassInstance.aClassMethod.im_self	aClassInstance.aClassMethod._self_
③	aClassInstance.aClassMethod.im_class	aClassInstance.aClassMethod._self_._class_

• #### nonzero méthode spéciale

Dans Python 2, vous pouvez créer vos propres classes et les rendre utilisables dans un contexte booléen. Par exemple, vous pouvez instancier cette classe et utiliser cet objet d’instance dans une expression if. Pour ce faire, vous définissez unnonzero() méthode, qui renvoie True ou False, cette méthode est appelée lorsque l’objet de l’instance est dans un contexte Boolean. Dans Python 3, vous pouvez toujours faire la même chose, mais le nom de cette méthode particulière devientbool()。

Notes	Python 2	Python 3

|①|class A:
　　def nonzero(self):
　　pass|class A:
　　def bool(self):
　　pass |②|class A:
　　def nonzero(self, x, y):
　　pass|no change| 1. Python 3 appelle un objet de classe lorsqu’il est utilisé dans un contexte Booleanbool_Ce n’est pas vrai.nonzero()。 2 Cependant, si vous avez défini une variable qui utilise deux paramètresnonzero__() méthode, les scripts 2 à 3 supposeront que la méthode que vous avez définie a d’autres utilisations et ne modifieront donc pas le code.

• #### Type octogénique

La syntaxe de définition des nombres octal est légèrement modifiée entre Python 2 et Python 3.

Notes	Python 2	Python 3
①	x = 0755	x = 0o755

• #### sys.maxint

La constante de sys.maxint n’est plus précise depuis que l’intégralité longue et l’intégralité grande ont été regroupées. Mais comme cette valeur est toujours utile pour détecter la capacité d’une plate-forme particulière, elle a été conservée par Python 3 et renommée sys.maxsize.

Notes	Python 2	Python 3
①	from sys importmaxint	from sys importmaxsize
②	a_function(sys.maxint)	a_function(sys.maxsize)

1, maxint est devenu maxsize [2]. 2 Tous les fichiers de sys.maxint ont été modifiés en sys.maxsize.

• #### Fonction globale appelée

Dans Python 2, vous pouvez utiliser la fonction globale callable (()) pour vérifier si un objet est invocable (callable, par exemple une fonction). Dans Python 3, cette fonction globale est supprimée. Pour vérifier si un objet est invocable, vous pouvez vérifier une méthode spéciale.__call_La présence de ____

Notes	Python 2	Python 3
①	callable(anything)	hasattr(anything,’_call_’)

• #### La fonction globale (zip)

Dans Python 2, la fonction globale zip() peut utiliser n’importe quelle séquence comme paramètre et renvoie une liste composée de sous-modules. La première sous-module contient le premier élément de chaque séquence; la deuxième sous-module contient le deuxième élément de chaque séquence; elle passe ensuite vers le bas. Dans Python 3, zip() renvoie un iterateur, pas une liste.

Notes	Python 2	Python 3
①	zip(a, b, c)	list(zip(a, b, c))
②	d.join(zip(a, b, c))	no change

Dans sa forme la plus simple, vous pouvez restaurer la fonction précédente de la fonction zip en appelant le retour de la fonction enveloppée de list (zip), qui parcourt l’incarnation de la fonction zip, puis renvoie la liste des résultats. Dans un environnement contextuel où tous les éléments de la séquence sont déjà parcourus (comme par exemple ici avec l’appel de la méthode join), l’éditeur de retour zip fonctionne normalement. Les scripts 2 à 3 détectent ces situations et ne modifient pas votre code.

• #### Erreur standard

Dans Python 2, StandardError est la classe de base de toutes les autres exceptions intégrées à l’exception de StopIteration, GeneratorExit, KeyboardInterrupt et SystemExit. Dans Python 3, StandardError a été supprimé et remplacé par Exception.

Notes	Python 2	Python 3
①	x =StandardError()	x =Exception()
②	x =StandardError(a, b, c)	x =Exception(a, b, c)

• #### Constantes dans le module types

Dans le module types, une variété de constantes vous aide à déterminer le type d’un objet. Dans Python 2, il contient les constantes qui représentent tous les types de données de base, comme dict et int. Dans Python 3, ces constantes ont été supprimées.

Notes	Python 2	Python 3
	types.UnicodeType	str
	types.StringType	bytes
	types.DictType	dict
	types.IntType	int
	types.LongType	int
	types.ListType	list
	types.NoneType	type(None)
	types.BooleanType	bool
	types.BufferType	memoryview
	types.ClassType	type
	types.ComplexType	complex
	types.EllipsisType	type(Ellipsis)
	types.FloatType	float
	types.ObjectType	object
	types.NotImplementedType	type(NotImplemented)
	types.SliceType	slice
	types.TupleType	tuple
	types.TypeType	type
	types.XRangeType	range

types.StringType est mappé en octets plutôt qu’en str, car en Python 2, a sequence of bytes est en fait une séquence d’octets codés avec un certain type de caractères.

• #### Instance de la fonction globale

isinstance() est une fonction qui vérifie si un objet est une instance d’une classe ou d’un type spécifique. Dans Python 2, vous pouvez transmettre un sous-ensemble composé de types à une instance, et si l’objet est de n’importe quel type de l’ensemble, la fonction renvoie True. Dans Python 3, vous pouvez toujours le faire, mais il n’est pas recommandé de transmettre un type deux fois comme argument.

Notes	Python 2	Python 3
	isinstance(x,(int,float,int))	isinstance(x,(int,float))

• #### type de données basestring

Python 2 a deux types de chaînes: les chaînes codées en Unicode et les chaînes non codées en Unicode. Mais il y a en fait un autre type, le basestring. C’est un type de données abstrait, une superclasse des types str et unicode.

Notes	Python 2	Python 3
	isinstance(x, basestring)	isinstance(x, str)

• #### Module itertools

Python 2.3 introduit le module itertools, qui définit les variantes de la fonction globale zip (), map (), filter (), dont le type de retour est l’incarnation et non la liste. Dans Python 3, ces fonctions ont été supprimées, car le type de retour de ces fonctions globales est l’incarnation.

Notes	Python 2	Python 3
①	itertools.izip(a, b)	zip(a, b)
②	itertools.imap(a, b)	map(a, b)
③	itertools.ifilter(a, b)	filter(a, b)
④	from itertools import imap, izip, foo	from itertools import foo

1, utilisez la fonction global zip () au lieu d’itertools.izip () 2/ Utiliser map () au lieu d’itertools.imap () 3 ,itertools.ifilter() est devenu un filtre ((() 4, le module itertools existe toujours dans Python 3, mais il ne contient plus les fonctions qui ont été transférées dans l’espace de noms global. Les scripts 2to3 sont suffisamment intelligents pour supprimer les importations qui ne sont plus utiles, tout en préservant l’intégrité des autres importations.

• #### sys.exc_type, sys.exc_value, sys.exc_traceback

Pour traiter les anomalies, il y a trois variables dans le module sys auxquelles vous pouvez accéder: sys.exc_type, sys.exc_value, sys.exc_traceback. En fait, ces variables existaient déjà à l’époque de Python 1.) À partir de Python 1.5, il n’est plus recommandé d’utiliser ces trois variables en raison de la sortie de sys.exc_info, un sous-ensemble qui contient tous les trois éléments ci-dessus.

Notes	Python 2	Python 3
	sys.exc_type	sys.exc_info()[0]
	sys.exc_value	sys.exc_info()[1]
	sys.exc_traceback	sys.exc_info()[2]

• #### Décomposition de la liste par unité

Dans Python 2, si vous devez écrire une analyse de liste d’éléments en travers, vous n’avez pas besoin d’ajouter de parenthèses autour de la valeur de l’élément. Dans Python 3, ces parenthèses sont nécessaires.

Notes	Python 2	Python 3
	[i for iin 1,2]	[i for iin(1,2)]

• #### La fonction os.getcwdu ()

Python 2 a une fonction appelée os.getcwd() qui renvoie le répertoire de travail actuel comme une chaîne de caractères non encodée en Unicode. Comme les systèmes de fichiers modernes peuvent gérer des noms de répertoire encodés en caractères géométriques, Python 2.3 a introduit la fonction os.getcwdu() qui renvoie les caractères encodés en Unicode du répertoire de travail actuel. Dans Python 3, comme il n’y a qu’un seul type de chaîne de caractères, vous n’avez besoin que de getos.cwd().

Notes	Python 2	Python 3
	os.getcwdu()	os.getcwd()

• #### Une méta-classe

Dans Python 2, vous pouvez définir des paramètres de métaclasse dans la déclaration de la classe, ou définir un niveau de classe spécifique.metaclass attributs, pour créer des sous-classes.__metaclass_L’attribut _ a été supprimé.

Notes	Python 2	Python 3
①	class C(metaclass=PapayaMeta): 　　pass	unchanged
②	class Whip: 　　_metaclass_ = PapayaMeta	class Whip(metaclass=PapayaMeta): 　　pass
③	class C(Whipper, Beater): 　　_metaclass_ = PapayaMeta	class C(Whipper,Beater,metaclass=PapayaMeta): 　　pass

1. Déclarer les paramètres de la méta-classe lors de la déclaration de la classe, ce qui est valable dans Python 2 et Python 3, ils sont les mêmes.
2. Déclare dans la définition de la classe que l’attribut metaclass est valide dans Python 2, mais n’est plus valide dans Python 3. 3, 2 à 3 permet de construire une déclaration de classe valide même si la classe hérite de plusieurs classes parentes.

• #### À propos du style de code

Les correctifs suivants ne sont pas de véritables correctifs. C’est-à-dire qu’ils ne concernent que le style du code, pas l’essence du code. Mais les développeurs de Python ont un intérêt particulier à ce que le style du code soit aussi cohérent que possible. Pour cela, il existe un manuel officiel décrivant le style du code Python.

• #### La valeur littérale de set est la valeur littérale de set.

Dans Python 2, la seule façon de définir un ensemble de valeurs littérales est d’appeler set{a_sequence}. Cela fonctionne toujours dans Python 3, mais la nouvelle notation littérale: parenthèses majuscules {} est une méthode plus claire. Cette méthode fonctionne aussi bien que les ensembles vides, car les dictionnaires marquent aussi les ensembles vides avec des parenthèses majuscules, de sorte que {} représente un dictionnaire vide plu