Pratiquement 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 utilitaire appelé 2to3, qui prend votre fichier source Python 2 comme entrée, puis le convertit automatiquement en Python 3.
Dans Python 2, print est une phrase. Tout ce que vous voulez exprimer, vous pouvez le placer juste après le mot clé print. Dans Python 3, print est une fonction. Comme pour toutes les autres fonctions, print exige que vous lui transmettiez ce que vous voulez exprimer en tant qu'argument.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | imprimer | imprimer |
| ② | imprimer 1 | imprimer le texte (1) |
| ③ | 1, 2 imprimer | Imprimé ((1,2) |
| ④ | imprimer 1, 2, | print ((1,2,end= |
| ⑤ | Il est possible d'envoyer un message à l'adresse suivante: | Il n'y a pas d'autre moyen de le faire. |
1, pour produire une ligne blanche, vous devez appeler print sans paramètres (((((((
2, Pour produire une valeur distincte, il est nécessaire de l'utiliser comme un paramètre print ().
3 ∞ Les deux valeurs séparées par un espace sont utilisées pour l'extraction et peuvent être appelées print ((() avec deux paramètres.
Dans Python 2, si vous utilisez une virgule (,) à la fin d'une phrase de print, elle sort le résultat séparé par un espace de trailing, sans retour de voiture. Dans Python 3, le même effet peut être obtenu en transmettant end =
Python 2 propose deux types de chaînes:Chaîne UnicodeetChacune de ces chaînes n'est pas en Unicode.Il n'y a qu'un seul type dans Python 3:Les chaînes Unicode。
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Je suis un homme de parole. | |
| ② | Je ne sais pas. | - Je ne sais pas. |
Les chaînes Unicode de Python 2 sont des chaînes ordinaires de Python 3, car les chaînes de Python 3 sont toujours en forme Unicode. Les chaînes de caractères originales Unicode ("raw string") ("Python ne traduit pas automatiquement l'inverse de la diagonale" en utilisant cette chaîne) ont également été remplacées par des chaînes normales, car dans Python 3, toutes les chaînes originales sont encodées en Unicode.
Python 2 dispose de deux fonctions globales qui peuvent forcer la conversion d'un objet en une chaîne: unicode ((() qui convertit l'objet en une chaîne Unicode, et str ((() qui convertit l'objet en une chaîne non Unicode. Python 3 n'a qu'un seul type de chaîne, une chaîne Unicode, donc la fonction str ((() peut effectuer toutes les fonctions.La fonction unicode ((() n'existe plus dans Python 3.)
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Unicode (tout) | Je ne sais pas. |
Python 2 a des types int et long pour les nombres non floating-point. Le maximum de type int ne peut pas dépasser sys.maxint, et ce maximum est lié à la plate-forme. On peut définir un type d'entier long en ajoutant un L à la fin du nombre. Il est évident qu'il a une gamme numérique plus large que celle indiquée par le type int.
Pour en savoir plus: PEP 237: Unifier les formes entières et les formes entières.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | x = 1000000000000L | Le montant de la garantie est calculé à partir du montant de la garantie. |
| ② | Le nombre d'heures d'essai est calculé en fonction de la fréquence de l'essai. | Le nombre d'émissions de CO2 est déterminé par la méthode suivante: |
| ③ | long ((x) | int (x) |
| ④ | type ((x) est long | type ((x) est int |
| ⑤ | estinstance ((x,long) | estinstance ((x,int) |
Les entiers décimaux en Python 2 sont remplacés par des entiers ordinaires décimaux en Python 3. Dans Python 2, l'entier à 16 chiffres est remplacé par l'entier normal à 16 chiffres dans Python 3. Dans Python 3, il n'y a plus de formes entières, donc il n'y a plus de formes entières.Les fonctions long (() n'existent plus. Pour forcer la conversion d'une variable en type entier, on peut utiliser la fonction int (().Je ne sais pas. Vérifie si une variable est de type entier, obtient son type de données et la compare à un type int (pas long). Vous pouvez également utiliser l'instance (() pour vérifier le type de données; une fois de plus, pour vérifier le type d'entiers, utilisez int, et non long.
Python 2 prend en charge <> comme synonyme de!=. Python 3 ne prend en charge que!= et ne prend plus en charge <>.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | si x <> y: | si x! = y: |
| ② | si x <> y<> z: | si x!= y!= z: |
1, simple comparaison. 2, une comparaison entre trois valeurs relativement complexes.
Dans Python 2, la méthode has_key (), utilisée pour tester si un dictionnaire contient une clé spécifique, n'est plus prise en charge par Python 3.dansL'opérateur?.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Il a un dictionnaire. | |
| ② | a_dictionary.has_key (x) ou a_dictionary.has_key (y) | x dans un dictionnaire ou y dans un dictionnaire |
| ③ | a_dictionary.has_key ((x ou y) | (x ou y) dans un dictionnaire |
| ④ | a_dictionary.has_key ((x + y) | (x + y) dans un dictionnaire |
| ⑤ | x + a_dictionary.has_key ((y) | x + (y dans un dictionnaire) |
1, la forme la plus simple.
2, l'opérateur or a une priorité inférieure à celle de l'opérateur in, il n'est donc pas nécessaire d'ajouter de parenthèses ici.
3, d'autre part, pour la même raison, la priorité de
Dans Python 2, les valeurs de retour de nombreuses méthodes de classe de dictionnaire sont des listes. Parmi les méthodes les plus couramment utilisées, il y a des clés, des éléments et des valeurs. Dans Python 3, les valeurs de retour de toutes les méthodes ci-dessus sont converties en une vue dynamique. Dans certains environnements contextuels, cette modification n'a pas d'effet.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | a_dictionnaire.clés | Liste (un dictionnaire) |
| ② | a_dictionary.items (en anglais seulement) | Liste (un dictionnaire) |
| ③ | a_dictionary.iterkeys (en anglais) | Il est temps de revenir à l'origine. |
| ④ | [i pour iin a_dictionary.iterkeys() ] | [i pour iin a_dictionary.keys() ] |
| ⑤ | Je ne sais pas comment faire. | Pas de changement |
La fonction 1, utilisant la liste (((), convertit la valeur de retour de keys ((() en une liste statique. Pour des raisons de sécurité, 2to3 peut être un erreur. Ce type de code est efficace, mais il est moins efficace pour l'utilisation de la vue. Vous devriez vérifier le code après la conversion pour voir si vous avez besoin d'une liste, peut-être que la vue peut faire la même chose. 2, c'est une autre façon de voir la conversion de la méthode ((concernant les éléments)) vers la liste. 3, Les itérkeys ne sont plus pris en charge dans Python 3. Si nécessaire, utilisez itér pour convertir la valeur de retour des keys en un iterateur. La méthode 4, 2to3 est capable de reconnaître que des itérkeys (//) sont utilisés dans la analyse de la liste, puis de les convertir en keys (//) dans Python 3 (//) sans avoir besoin d'utiliser d'iter supplémentaire (//) pour emballer la valeur de retour). La valeur de retour de la méthode 5, 2to3 qui reconnaît également les keys (()) est immédiatement transmise à une autre fonction qui parcourt toute la séquence, il n'est donc pas nécessaire de convertir la valeur de retour de keys (()) dans une liste. Au contraire, la fonction min (()) est heureuse de parcourir la vue.
De Python 2 à Python 3, certains modules de la bibliothèque standard ont été renommés. D'autres modules interconnectés ont également été regroupés ou réorganisés pour rendre cette association plus logique.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Importer le code httplib | Importer le client http.client |
| ② | Importer le cookie | Importer des cookies http. |
| ③ | importation de cookieslib | Importer le fichier http.cookiejar |
| ④ | Le serveur de baseHTTPS est un serveur de baseHTTPS. | Importer le serveur http. |
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 récupérer les cookies envoyés par l'intermédiaire de l'en-tête HTTP. Les navigateurs populaires stockent les cookies sous forme de fichiers sur le disque, qui peuvent être manipulés par le module http.cookiejar. Le module http.server implémente un serveur HTTP de base
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Importer une adresse | importation urllib.request urllib.parse,urllib.error |
| ② | Importation de l'URLlib2 | Importation du fichier urllib.request |
| ③ | Importer une adresse | Importer le fichier |
| ④ | Importer le robot parser | Importer l'urllib.robotparser |
| ⑤ | depuis urllib import FancyURLopener depuis urllib import urlencode |
depuis urllib.request import FancyURLopener depuis urllib.parse import urlencode |
| ⑥ | depuis urllib2 import Demande depuis urllib2 import HTTPError |
depuis urllib.request import Demande depuis urllib.error import HTTPError |
Auparavant, le module urllib de Python 2 possédait une variété de fonctions, y compris urlopen, qui était utilisé pour obtenir des données, et il était également utile de diviser les URL en fonctionnalités de splittype, splithost et splituser. Dans le nouveau paquet urllib, ces fonctions sont organisées de manière plus logique. Dans Python 3, les modules urllib2 précédents ont été incorporés dans le paquet urllib. Dans le même temps, dans urllib2, toutes sortes de choses que vous aimez apparaîtront dans les modules urllib de Python 3, telles que les méthodes build_opener (), les objets de demande, HTTPBasicAuthHandler et friends (). Le module urllib.parse de Python 3 contient toutes les fonctions de partage du module urlparse de Python 2. Le module urllib.robotparse analyse le fichier robots.txt. La classe FancyURLopener, qui traite les redirections HTTP et autres codes d'état, est toujours valide dans le module urllib.request de Python 3. L'objet Request est toujours valide dans urllib.request, mais des constantes telles que HTTPError ont été déplacées dans urllib.error. Ai-je mentionné que 2to3 réécrirait également vos appels à des fonctions? Par exemple, si vous importez un module urllib dans votre code Python 2 et que vous appelez la fonction urllib.urlopen))) pour obtenir des données, 2to3 modifie les phrases d'importation et les appels à des fonctions en même temps.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Le texte de l'annexe I est remplacé par le texte suivant:http://diveintopython3.org/’) lire)) | import urllib.request, urllib.parse, urllib.error print ((urllib.request.urlopen)) "http://diveintopython3.org/’) lire)) |
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | importation de données | Importation de données |
| ② | importation de gdbm | importationdbm.gnu |
| ③ | Importer dbhash | Importation dbm.bsd |
| ④ | Importer du Dumbdbm | Importation de données. |
| ⑤ | Importation de tout ce qui est | importation de données |
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Importer le fichier xmlrpclib | Importer le fichier xmlrpc.client |
| ② | Importer DocXMLRPCServer Importer SimpleXMLRPCServer |
Importer le serveur xmlrpc. |
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | essayez: importez cStringIO comme StringIO sauf ImportError: importez StringIO |
Importation |
| ② | essayez: importez cPickle en tant que cornichon sauf ImportError: importez cornichon |
les cornichons importés |
| ③ | ImporterConstruit | Importer des bâtiments |
| ④ | Importer le code | Importation de copie |
| ⑤ | file d'attente d'importation | file d'attente d'importation |
| ⑥ | Importer SocketServer | Importer le serveur de sockets |
| ⑦ | Importer le paramètre de configuration | Importer le paramètre de configuration |
| ⑧ | Le rapport annuel | import reprlib |
| ⑨ | commandes d'importation | sous-processus d'importation |
Dans Python 2, vous 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 à le faire. Dans Python 2, l'importation de l'implémentation pickle la plus rapide est également une méthode utilisable similaire à celle ci-dessus. Dans Python 3, le module pickle traite automatiquement pour vous, alors ne le faites plus. Le module de construction contient des fonctions globales, des classes et des constantes qui sont utilisées dans toute la langue Python. Une fonction dans le module de construction redéfinie signifie que cette fonction globale est redéfinie partout. Cela semble puissant, mais aussi terrible. 4, le module copyreg ajoute la prise en charge du module pickle pour les types personnalisés par les utilisateurs définis en C. Le module 5 de la queue réalise une file d'attente multi-producteur, multi-consommateur. Le module Socketserver fournit une classe de base générale pour la mise en œuvre de divers serveurs de sockets. 7, le module de configuration parser est utilisé pour analyser les profils INI-style. Le module 8 reprlib ré-implémente la fonction repr (), et ajoute des contrôles sur la longueur de la représentation de la chaîne avant son interception. Les modules de sous-processus vous permettent de créer des sous-processus, de les connecter à leurs pipelines et d'obtenir leurs valeurs de retour.
Les paquets sont des entités uniques composées d'un ensemble de modules associés. Dans Python 2, vous utilisez import foo ou from foo import Bar pour faire référence aux modules de la même palette.2解释器会先在当前目录里搜索foo.pyDans Python 3, le processus est un peu différent. Python 3 ne recherche pas d'abord le chemin actuel, il le recherche directement dans le chemin de recherche de Python. Si vous voulez importer un module dans un paquet dans un autre module, vous devez fournir explicitement le chemin relatif des deux modules.
Supposons que vous ayez le package suivant, plusieurs fichiers dans le même répertoire:
- Je ne sais pas. Je ne sais pas. À l'intérieurinit.py Je ne sais pas.+--constantes.py | +--mbcharsetprober.py Il est temps de le faire. | +--détecteur universel.py
Supposons maintenant que l'universaldetector.py nécessite l'importation de constants.py entiers，另外还需要导入mbcharsetprober.py的一个类。你会怎样做?
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | les constantes d'importation | à partir des constantes.import |
| ② | depuis mbcharsetprober import MultiByteCharSetProber | depuis.mbcharsetprober import MultiByteCharsetProber |
1, lorsque vous devez importer l'ensemble du module d'ailleurs dans le paquet, utilisez la nouvelle syntaxe from.import.universaldetector.py> > > > > > > > > > > > > > > > > > > > > > >constants.pyDans cet exemple, les deux fichiers se trouvent dans le même répertoire, donc une seule syllabe est utilisée. Vous pouvez également importer à partir du répertoire parental ((from... import anothermodule) ou du sous-répertoire. Pour importer une classe ou une fonction spécifique d'un autre module directement dans l'espace de noms de votre module, ajoutez le chemin relatif au début du module à importer et supprimez la dernière barre (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 du répertoire parent (from... import anothermodule) ou du répertoire enfant.
Dans Python 2, l'irradiateur a une méthode next (), qui permet de retourner le prochain élément de la séquence. Dans Python 3, cela fonctionne de la même manière, mais il existe maintenant une nouvelle fonction globale next (), qui utilise un iradiateur comme paramètre.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Je vais vous aider. | Je suis en train d'écrire. |
| ② | a_function_that_returns_an_iterator (().next (() est une fonction qui retourne un_iterator ()) | next ((une fonction qui renvoie un itérateur)) |
| ③ | classe A: def next ((self): passe |
classe A:Le suivant.(même): passer à côté |
| ④ | classe A: def next ((self, x, y): passe |
Pas de changement |
| ⑤ | next = 42 pour un_itérateur dans une_séquence_d'itérateurs: an_itérateur.next() |
pour un_itérateur dans une_séquence_d'itérateurs: un_itérateur._Le suivant.() |
Dans l'exemple le plus simple, vous n'appelez plus la méthode de l'intermédiaire next (), mais vous passez l'intermédiaire lui-même en tant qu'argument à la fonction globale next (). 2, si vous avez une valeur de retour qui est une fonction de l'irradiateur, appelez cette fonction et passez le résultat en tant que paramètre à la fonction next (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 3 Si vous prenez votre propre classe et que vous l'utilisez comme un iterateur, dans Python 3, vous pouvez définir des méthodes spéciales.Le suivant.Le projet a été réalisé par un groupe d'étudiants. 4, si vous définissez une classe qui contient un ou plusieurs paramètres, 2to3 ne l'exécutera pas. Cette classe ne peut pas être utilisée comme un iterateur car sa méthode next () contient des paramètres. 5, c'est un peu compliqué. Si vous avez une variable locale nommée next, dans Python 3, elle a une priorité supérieure à celle de la fonction globale next (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))Le suivant.Vous pouvez également réorganiser le code pour que la variable locale n'ait pas le nom de next, mais 2to3 ne le fera pas pour vous.
Dans Python 2, la méthode filter ((() renvoie une liste qui est obtenue en détectant chaque élément de la séquence par une fonction qui renvoie une valeur True ou False.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | filtrage ((a_function, a_sequence) | liste (filtre) (fonction, séquence) |
| ② | liste (filtre) (fonction, séquence) | Pas de changement |
| ③ | Filtre ((Aucun, une_séquence) | [i pour iin a_sequence si i] |
| ④ | pour i dans le filtre ((None, a_sequence): | Pas de changement |
| ⑤ | [i pour le filtre (une fonction, une séquence) ] | Pas de changement |
Dans le cas le plus simple, 2to3 utilise une fonction list ()) pour emballer le filtre (), et la fonction list ()) traverse ses paramètres pour retourner une liste. 2, cependant, si l'appel filter (()) a été enveloppé par list ((), 2to3 ne traite plus, car dans ce cas, il n'est pas important de savoir si la valeur de retour du filtre (()) est un iterateur. Pour traiter une syntaxe particulière telle que filter (None,...) 2to3 convertit cette appelée de manière syntaxiquement équivalente en analyse de liste. 4, puisque la boucle for traverse la séquence entière, il n'est pas nécessaire de faire d'autres modifications. 5, comme ci-dessus, aucune modification n'est nécessaire, car la liste est analysée sur toute la séquence, et même si le filtre () retourne à un iterateur, il fonctionnera toujours comme le filtre () précédent qui retourne à la liste.
Comme pour la modification de filter (), la fonction map (), qui retourne maintenant un iterateur.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Une carte (une fonction) | Liste (carte) (fonction) |
| ② | Une carte (None, |
Liste (Papaya Whip) |
| ③ | La carte (lambda x: x+1, plage (x) 42) | [x+1 pour x dans la plage ((42) ] |
| ④ | pour i dans la carte ((a_function, a_sequence): | Pas de changement |
| ⑤ | [i pour une carte (une fonction, une séquence) ] | Pas de changement |
Dans le cas le plus simple, 2to3 utilise une fonction list pour envelopper l'appel map. 2、 pour une syntaxe spécifique de map ((None,...) similaire à celle du filtre ((None,...) 2to3 la convertit en une appellation équivalente à l'utilisation de list ((( 3, si le premier paramètre de map () est une fonction lambda, 2to3 le convertit en parallèle à une liste de résolution. 4° Pour les boucles for qui traversent toute la séquence, aucune modification n'est nécessaire. 5, encore une fois, il n'est pas nécessaire d'y apporter de modifications, car la liste parcourt toute la séquence et fonctionne correctement même si la valeur de retour de map ((() est l'irradiateur et non la liste.
En Python 3, la fonction réduire (), qui a été supprimée de l'espace de noms global, est maintenant placée dans le module fucntools.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | réduire ((a, b, c) | de l'importation des outils fonctionnels réduire réduire |
Python 2 possède une fonction globale appelée apply() qui utilise une fonction f et une liste [a, b, c] comme paramètres, et qui renvoie la valeur f ((a, b, c)). Vous pouvez également faire la même chose en appelant directement cette fonction et en y ajoutant un astérisque ((*) comme paramètre passé devant la liste. Dans Python 3, la fonction apply( n'existe plus; vous devez utiliser le marquage des astérisques.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | appliquer ((a_function, a_list_of_args) | a_function ((*a_list_of_args) est une fonction |
| ② | appliquer ((une_fonction, une_liste_d'arguments, un_dictionnaire_d'arguments nommés) | a_function ((*une_liste_d'arguments,**un_dictionnaire_d'arguments nommés) |
| ③ | appliquer ((a_function, a_list_of_args+ z) | a_function ((*a_list_of_args+z) est une fonction |
| ④ | appliquer ((aModule.a_function, a_list_of_args) | aModule.a_function ((* une_liste_d'arguments) |
1, la forme la plus simple, peut être appelée en ajoutant un astérisque devant la liste d'arguments (comme [a, b, c]) ; c'est l'équivalent de la fonction apply (apply) dans Python 2. Dans Python 2, la fonction apply peut en fait contenir trois paramètres: une fonction, une liste de paramètres, un dictionnaire d'arguments nommés. Dans Python 3, vous pouvez ajouter un astérisque avant la liste de paramètres.Pour obtenir le même effet, deux astérisques sont ajoutés avant les paramètres de nom de dictionnaire. 3, l'opérateur + est utilisé ici comme une fonction de liste de connexion, et il a une priorité supérieure à l'opérateurIl n'est donc pas nécessaire d'ajouter des parenthèses supplémentaires autour de a_list_of_args + z. Les scripts 4 et 2 à 3 sont assez intelligents pour convertir des applies complexes, y compris des appels à des fonctions importées dans des modules.
Dans Python 2, vous pouvez limiter la fonction interne à une chaîne en utilisant l'action interne pour optimiser les performances. Dans Python 3, la fonction interne est transférée dans le module sys.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | interné (aString) | Sys.intern (une chaîne de caractères) |
Tout comme la phrase print devient une fonction dans Python 3, la phrase exec utilise une chaîne contenant n'importe quel code Python comme paramètre, puis l'exécute comme une phrase ou une expression exécutée. Elle est similaire àeval, mais elle est plus puissante et plus ingénieuse.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | le code execString | Je ne sais pas si c' est vrai. |
| ② | code execStriche dans l'espace de noms global | exec ((codeString, espace de noms global) |
| ③ | code execStriche dans un espace de noms global, un espace de noms local | exec ((codeString, un espace de noms global, un espace de noms local) |
1, dans sa forme la plus simple, puisque exec ((() est maintenant une fonction plutôt qu'une phrase, 2 à 3 entoure ce code en forme de chaîne de caractères par des parenthèses. 2, les statements exec de Python 2 peuvent spécifier un espace de noms, le code s'exécutera dans cet espace privé composé d'objets globaux. Python 3 a également cette fonction; vous avez juste besoin de passer cet espace de noms comme deuxième paramètre à la fonction exec (). 3, plus étonnamment, 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).
Comme pour les expressions exec précédentes, les expressions execfile de Python 2 peuvent également utiliser des chaînes comme pour exécuter du code Python; la différence est que l'exec utilise des chaînes et que l'execfile utilise des fichiers. Dans Python 3, l'expression execfile a été supprimée. Si vous voulez vraiment exécuter du code Python dans un fichier (mais que vous ne voulez pas l'importer), vous pouvez le faire en ouvrant ce fichier, en lisant son contenu, puis en appelant la fonction compile (compile) globale (Python interprète force le code à être compilé, puis appelle la nouvelle fonction exec).
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | execfile (nom du fichier) | exec ((compiler ((ouvrir (( |
Dans Python 2, pour obtenir une représentation de chaîne d'un objet quelconque, il y a une façon d'envelopper l'objet dans des contre-citations (par exemple,xUne syntaxe particulière de la fonction répr. Cette fonction existe toujours dans Python 3, mais vous ne pouvez plus l'obtenir en utilisant des contre-indications.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Je ne sais pas. | repr ((x) |
| ② | ` |
Je vous en prie, faites-moi confiance. |
1, rappelez-vous que x peut être n'importe quoi, une classe, une fonction, un module, un type de données de base, etc. ==repr== La fonction peut utiliser n'importe quel type de paramètre == Dans Python 2, les contre-citations peuvent être imbriquées, ce qui donne lieu à cette expression déroutante mais efficace. 2to3 est assez intelligent pour convertir ces appels à l'embrayage en une fonction repr.
La syntaxe de la capture des anomalies a peut-être changé de Python 2 à Python 3.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | essayez: importer le mymodule sauf ImportError, e passe |
essayez: importer le mymodule sauf ImportError comme e: passe |
| ② | essayez: importer le mymodule sauf (Erreur au moment de l'exécution, Erreur à l'importation), e passe |
essayez: importer le mymodule sauf (Erreur de temps d'exécution, Erreur d'importation) comme e: passe |
| ③ | essayez: importez le mymodule sauf ImportError: passez |
Pas de changement |
| ④ | essayez: importez le mymodule sauf: passez |
Pas de changement |
1, par rapport à Python 2 qui ajoute des virgules après les types d'exception, Python 3 utilise un nouveau mot-clé, as. Le mot-clé as peut également être utilisé pour capturer plusieurs types d'anomalies à la fois. Si vous capturez une exception, mais n'êtes pas intéressé par l'accès à l'objet d'exception lui-même, la syntaxe de Python 2 et Python 3 est la même. De même, si vous utilisez une méthode d'assurance (fallback) pour capturer toutes les exceptions, la syntaxe de Python 2 et Python 3 est la même. 5) Vous ne devriez absolument pas utiliser cette méthode lors de l'importation de modules (ou dans la plupart des autres cas), sinon le programme pourrait capturer des exceptions telles que KeyboardInterrupt (si l'utilisateur appuie sur Ctrl-C pour interrompre le programme), ce qui rendrait le débogage plus difficile.
Dans Python 3, la syntaxe des exceptions personnalisées est modifiée avec des modifications mineures.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Montez mon Exception | non modifié |
| ② | montez MonException, |
Monter monException (message d'erreur) |
| ③ | Montez MyException, |
Montez monException (message d'erreur).avec_traceback (traceback) |
| ④ | augmenter |
non supporté |
Dans sa forme la plus simple, la syntaxe n'est pas modifiée. Les modifications sont évidentes lorsque vous souhaitez supprimer une exception avec un message d'erreur personnalisé par l'utilisateur. Python 2 sépare les types d'erreur et les messages d'erreur par un comma; Python 3 transmet les messages d'erreur aux types d'erreur en tant que paramètres. Python 2 prend en charge une syntaxe plus complexe pour lancer une exception avec une trace de pile personnalisée par l'utilisateur. Vous pouvez faire la même chose avec Python 3, mais la syntaxe est complètement différente. Dans Python 2, vous pouvez jeter une exception sans classe d'exception, avec seulement un message d'exception. Dans Python 3, cette forme n'est plus prise en charge. 2to3 vous avertira qu'il ne peut pas corriger cette syntaxe automatiquement.
Dans Python 2, le générateur dispose d'une méthode throw (), qui lance une exception lorsque le générateur est suspendu, puis renvoie la valeur suivante obtenue par la fonction générateur. Dans Python 3, cette fonction est toujours disponible, mais avec une différence de syntaxe.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | A_générateur.throw ((MyException) | Pas de changement |
| ② | a_generator.throw ((MyException, |
a_generator.throw(MyException( |
| ③ | a_generator.throw (message d'erreur) | non supporté |
Dans sa forme la plus simple, le générateur lance des exceptions qui n'ont pas d'erreur personnalisée par l'utilisateur. Dans ce cas, il n'y a pas de changement de syntaxe entre Python 2 et Python 3. Si le générateur lance une exception avec un message d'erreur personnalisé par l'utilisateur, vous devez transmettre la chaîne d'erreur à la classe d'erreur pour l'instantialiser. Python 2 prend également en charge le lancement d'exceptions pour des messages d'exception uniquement. Python 3 ne prend pas en charge cette syntaxe et 2to3 affiche un message d'avertissement vous indiquant que vous devez réparer manuellement ce code.
Dans Python 2, il existe deux façons d'obtenir des nombres dans une certaine plage: range (), qui renvoie une liste, et range (), qui renvoie un iterateur. Dans Python 3, range (), qui renvoie un iterateur, xrange (), qui n'existe plus.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | xrange ((10) | une plage ((10) |
| ② | a_list = plage ()) 10) | a_list = liste (range) |
| ③ | [i pour une plage de données (i) 10) ] | [i pour la plage initiale ((10) ] |
| ④ | pour i dans la plage ((10)): | Pas de changement |
| ⑤ | Résultats de l'enquête | Pas de changement |
Dans le cas le plus simple, 2to3 convertit simplement xrange (x) en range (x). 2, si votre code Python 2 utilise range ((), 2to3 ne sait pas si vous avez besoin d'une liste ou si un iterateur fonctionne également. Par prudence, 2to3 peut envoyer une erreur, puis utiliser list (() pour forcer la conversion de la valeur de retour de range (() en type de liste. 3) Si une fonction xrange () est présente dans la liste de résolution, il n'est pas nécessaire de convertir sa valeur de retour en une liste, car la résolution de la liste est tout aussi efficace pour l'irradiateur. 4, de la même manière, le for loop fonctionne aussi sur l'intermédiaire, donc rien n'est changé ici. 5, la fonction sum () peut fonctionner sur l'irradiateur, donc 2to3 n'est pas modifié ici. Tout comme la méthode de type dictionnaire qui retourne la valeur comme vue () au lieu d'être une liste, cela s'applique également pour min (), max (), sum (), list (), tuple (), set (), sorted (), any (), all (), etc.
Python 2 a deux fonctions globales qui sont utilisées pour demander des entrées à l'utilisateur sur la ligne de commande. La première est appelée input (), qui attend que l'utilisateur entre une expression Python (et retourne le résultat). La seconde est appelée raw_input (), qui renvoie ce que l'utilisateur entre.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Il y a un problème. | les données de saisie |
| ② | Il y a un problème avec le code source. | Les données sont fournies par l'intermédiaire de l'intermédiaire de l'intermédiaire. |
| ③ | les données de saisie | Évaluation des données |
Dans sa forme la plus simple, raw_input (() est remplacé par input (()). Dans Python 2, la fonction raw_input () peut spécifier un pointeur comme paramètre. Si vous voulez vraiment demander à l'utilisateur d'entrer une expression Python, vous pouvez calculer le résultat en appelant la fonction input (), puis en transmettant la valeur de retour à eval ().
Dans Python 2, le code d'une fonction peut accéder aux propriétés particulières de la fonction elle-même. Dans Python 3, ces propriétés particulières ont été renommées pour des raisons de cohérence.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | a_function.func_name Nom de la fonction | Une fonction.Nom |
| ② | a_function.func_doc | Une fonction.Je ne sais pas. |
| ③ | a_function.func_defaults est une fonction | Une fonction.Les défauts |
| ④ | a_function.func_dict | Une fonction.- Je vous en prie. |
| ⑤ | a_function.func_closure | Une fonction.Fermeture |
| ⑥ | a_function.func_globals est une fonction | Une fonction.- Je ne sais pas. |
| ⑦ | a_function.func_code est le code | Une fonction.Le code |
1, l'attribut __name__ (original func_name) contient le nom de la fonction. L'attribut __doc__ (original funcdoc) contient une chaîne de documents (docstring) que vous avez définie dans le code source de la fonction. 3,__defaults__ est un ensemble d'éléments qui conserve les valeurs par défaut des paramètres. L'attribut __dict__ (original func_dict) est un espace de noms qui prend en charge les attributs de fonctions aléatoires. L'attribut __closure__ est un ensemble d'objets de cellule qui contient les liaisons des fonctions à des variables libres. L'attribut __globals__ est une référence à l'espace de noms global du module dans lequel la fonction elle-même est définie. L'attribut __code__ est un objet de code qui représente un corps de fonctions compilé.
Dans Python 2, les objets de fichiers ont une méthode xreadlines (), qui renvoie un iterateur, une ligne de lecture de fichier à la fois. Ceci est particulièrement utile dans le for loop. En fait, les versions ultérieures de Python 2 ont ajouté cette fonctionnalité aux objets de fichiers eux-mêmes.
Dans Python 3, les méthodes xreadlines (() ne sont plus disponibles. 2to3 peut résoudre des situations simples, mais certains cas d'extrémité nécessitent une intervention manuelle.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | pour la ligne dans a_file.xreadlines(): | pour la ligne dans un fichier: |
| ② | pour la ligne dans a_file.xreadlines(5): | Aucun changement (défait) |
1, si vous appelez xreadlines sans paramètres précédemment, 2to3 le convertira en objet du fichier lui-même. Dans Python 3, ce code peut faire la même chose: lire une ligne du fichier une fois, puis exécuter le for loop.
2, si vous avez déjà utilisé un paramètre (nombre de lignes lues) pour appeler les xreadlines (), 2to3 ne peut pas effectuer la conversion de Python 2 à Python 3 pour vous, votre code échoue comme suit: AttributeError:
Dans Python 2, vous pouvez définir une fonction lambda anonyme, qui est en fait capable de recevoir plusieurs paramètres en spécifiant le nombre d'éléments d'un groupe de composants comme paramètres. En fait, l'interpréteur de Python 2 décode ce groupe de composants en unpack en arguments nommés, puis vous pouvez les citer dans la fonction lambda par leur nom.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | LAMBDA (x,): x+ f (x) | L'expérience de l'expérience est basée sur les données fournies par les autorités compétentes. |
| ② | 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 | non modifié |
Si vous avez déjà défini une fonction lambda, elle utilise un élément contenant un élément comme paramètre. Dans Python 3, elle est convertie en une fonction lambda contenant une référence à x1[0]; x1 est un script 2 à 3 généré automatiquement en fonction des paramètres de nommage dans l'élément original. La fonction lambda est convertie en x_y en utilisant comme paramètre un ensemble de deux éléments (x, y) qui possède deux paramètres de position, x_y[0] et x_y[1]; Les scripts 3 et 2 à 3 peuvent même traiter les composants utilisant les paramètres de nommage de la chaîne comme paramètres de la fonction lambda. Le code résultant est un peu difficile à lire, mais il a le même effet sur Python 3 que le code d'origine sur Python 2. Vous pouvez définir une fonction lambda qui utilise 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 fonction lambda, vous référenciez ces paramètres par leur nom, comme vous le faites dans d'autres types de fonctions.
Dans Python 2, les méthodes de classe peuvent accéder à l'objet de classe qui définit leur classe, mais aussi à l'objet de méthode lui-même. Im_self est l'objet d'exemple de la classe; im_func est l'objet de fonction, im_class est la classe elle-même. Dans Python 3, ces attributs sont renommés pour suivre les conventions de nommage des autres attributs.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Le système de classement est un système de classement. | Une instance de classe. une méthode de classe.fonction_ |
| ② | Une classeInstance.aClassMethod.im_self | Une instance de classe. une méthode de classe.Je me suis |
| ③ | Le système de classement de la classe | Une instance de classe. une méthode de classe.Je me suis._classe_ |
Dans Python 2, vous pouvez créer vos propres classes et les rendre utilisables dans un contexte boolean. Par exemple, vous pouvez instantier cette classe et utiliser cet objet instantiel dans une if-statement.non-zéroCette méthode est appelée lorsque l'objet de l'exemple est dans le contexte de Boole. Dans Python 3, vous pouvez toujours effectuer la même fonction, mais le nom de cette méthode particulière a été changé.Je ne sais pas.()。
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | classe A:non-zéro(même): passe |
classe A:Je ne sais pas.(même): passe |
| ② | classe A:non-zéro(même, x, y): passe | Pas de changement |
1, lorsque vous utilisez un objet de classe dans le contexte de Bur, Python 3 appelle_Je ne sais pas.(), et non pasnon-zéroJe ne sais pas. Mais si vous avez une définition qui utilise deux paramètresnon-zéroLes scripts 2to3 supposent que la méthode que vous définissez a une autre utilité et ne modifie donc pas le code.
Entre Python 2 et Python 3, la syntaxe définissant le nombre octal est légèrement modifiée.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | x = 0755 | x = 0o755 |
La constante sys.maxint n'est plus exacte à cause de l'intégration des longueurs entières et entières. Mais comme cette valeur est utile pour la capacité de détecter des plates-formes spécifiques, elle est conservée par Python 3 et renommée sys.maxsize.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | depuis sys importmaxint | depuis sys importmaxsize |
| ② | a_function ((sys.maxint) est une fonction | a_function ((sys.maxsize) est une fonction |
1, maxint est devenu maxsize. 2, tous les sys.maxint sont devenus sys.maxsize.
Dans Python 2, vous pouvez utiliser la fonction globale callable (*) pour vérifier si un objet peut être appelé (callable, par exemple, une fonction). Dans Python 3, cette fonction globale est annulée.Appelez!Il y a un problème avec le fait que les gens ne soient pas d'accord.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | On peut appeler n'importe quoi. | Il n'y a rien à faire.Appelez!’) |
Dans Python 2, la fonction globale zip ((() peut utiliser n'importe quel nombre de séquences comme paramètres, elle renvoie une liste composée de composants. La première composition contient le premier élément de chaque séquence; la deuxième composition contient le deuxième élément de chaque séquence; elle est ensuite repoussée.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | zip ((a, b, c) | liste (a, b, c) |
| ② | d.join ((zip ((a, b, c)) | Pas de changement |
Dans sa forme la plus simple, vous pouvez rétablir la fonction précédente de la fonction zip en appelant la valeur de retour de la fonction list (()) enveloppant zip (()) et la fonction list (()) traverse l'irradiateur où la fonction zip (()) est retournée, puis renvoie la liste des résultats indiqués. Dans un environnement contextuel où tous les éléments de la séquence sont déjà parcourus (par exemple, l'appel de la méthode join ici), l'irrateur qui retourne zip fonctionne correctement. Les scripts 2to3 détectent ces situations et ne modifient pas votre code.
Dans Python 2, StandardError est la base de toutes les autres classes d'anomalies intégrées à l'exception de StopIteration, GeneratorExit, KeyboardInterrupt et SystemExit. Dans Python 3, StandardError a été supprimé; il est remplacé par Exception.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | x =Erreur standard() | x = Exception |
| ② | x =Erreur standard ((a, b, c) | x = Exception ((a, b, c) |
Dans le module types, il existe une variété de constantes qui vous aident à déterminer le type d'un objet. Dans Python 2, il contient des constantes qui représentent tous les types de données de base, tels que dict et int. Dans Python 3, ces constantes ont été supprimées.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| types.UnicodeType | str | |
| types.StringType | Les octets | |
| types.DictType | Le dictateur | |
| types.IntType | int | |
| types.LongType | int | |
| types.ListType | liste | |
| types.NoneType | type ((Aucun) | |
| types.BooleanType | Boole | |
| types.BufferType | vue de mémoire | |
| types.ClassType | type | |
| types.ComplexType | complexe | |
| types.EllipsisType | type ((Ellipse) | |
| types.FloatType | flottant | |
| types.ObjectType | objet | |
| types.NotImplementedType | type ((Non mis en œuvre) | |
| types.SliceType | tranche | |
| types.TupleType | tuple | |
| types.TypeType | type | |
| types.XRangeType | gamme |
types.StringType est mappé en octets, et non pas en str, parce que les chaînes de strings dans Python 2 sont en fait des séquences de bytes encodées par un certain type de caractère.
la fonction isinstance (//) vérifie si un objet est une instance d'une certaine classe (//) ou d'un type (//). Dans Python 2, vous pouvez passer à l'instance (//) un élément composé de types (//), et si l'objet est n'importe quel type de l'ensemble, la fonction retourne True (//). Dans Python 3, vous pouvez toujours le faire, mais il n'est pas recommandé de passer deux fois un type comme paramètre (//).
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| est l'instance ((x, ((int,float,int)) | est instance ((x, ((int,float)) |
Python 2 possède deux types de chaînes: les chaînes encodées en Unicode et les chaînes non encodées en Unicode. Mais il existe un autre type, basestring. Il s'agit d'un type de données abstrait, une superclasse de types str et unicode. Il ne peut pas être directement appelé ou instancié, mais vous pouvez l'utiliser comme un paramètre d'instance pour détecter si un objet est une chaîne Unicode ou une chaîne non Unicode.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| est instance ((x, base de chaîne) | estinstance ((x, str) |
Python 2.3 introduit le module itertools, qui définit les variantes (variantes) des fonctions globales zip, map et filter, dont le type de retour est l'irradiateur plutôt que la liste. Dans Python 3, ces variantes ont été supprimées car le type de retour de ces fonctions globales est l'irradiateur.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | Il est possible de modifier le code de l'appareil | zip ((a, b) |
| ② | Il s'agit d'un outil d'analyse. | carte (a, b) |
| ③ | Il est possible de modifier le code de l'appareil | Filtre (a, b) |
| ④ | depuis itertools importez imap, izip, foo | Je suis en train d'importer du foo. |
1, utilisez la fonction zip ((() globale au lieu d'itertools.izip ((()). 2、 Utilisez map (en anglais) plutôt que itertools.imap (en anglais). 3,itertools.ifilter ((() est devenu un filtre ((()). 4, le module itertools existe toujours dans Python 3, il ne contient que des fonctions qui ont été déplacées dans l'espace de noms global. Les scripts 2to3 sont assez intelligents pour supprimer les phrases d'importation qui ne sont plus utiles tout en conservant l'intégrité des autres phrases d'importation.
Pour traiter les exceptions, il y a trois variables auxquelles vous pouvez accéder dans le module sys: sys.exc_type, sys.exc_value, sys.exc_traceback. En fait, elles existaient à l'époque de Python 1.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| sys.exc_type | sys.exc_info (())[0] | |
| sys.exc_value | sys.exc_info (()) [1] | |
| sys.exc_traceback est le nom de la base de données | sys.exc_info (() [2] |
Dans Python 2, si vous avez besoin d'écrire une analyse de liste traversant un élément, vous n'avez pas besoin d'ajouter de parenthèses autour des valeurs du élément.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| [i pour 1,2] | [i pour iin(1,2)] |
Python 2 possède une fonction appelée os.getcwd (), qui renvoie le répertoire de travail actuel sous forme d'une chaîne de caractères non encodée en Unicode. Puisque les systèmes de fichiers modernes sont capables de traiter les noms de répertoire encodés en caractères, Python 2.3 introduit la fonction os.getcwdu (), qui renvoie le répertoire de travail actuel sous forme de chaîne encodée en Unicode.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| Je suis désolé. | Je ne sais pas. |
Dans Python 2, vous pouvez créer une classe en définissant les paramètres de la méta-classe dans la déclaration de la classe, ou en définissant une propriété spéciale de niveau de classe. Dans Python 3, l'attribut __metaclass__ a été supprimé.
| Nom de l'entreprise | Python 2 | Python 3 |
|---|---|---|
| ① | classe C ((metaclass=PapayaMeta): passe |
non modifié |
| ② | classe Whip: _Je ne sais pas.= PapayeMeta |
classe Whip (méta-classe): |
| ③ | Classe C (Bateur de coups de fouet):Je ne sais pas.= PapayeMeta | Classe C ((Whipper,Beater,metaclass=PapayaMeta): passe |
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, dans la définition de la classe, déclarer que l'attribut __metaclass__ est valide en Python 2, mais qu'il n'est plus valide en Python 3. 3, 2to3 permet de construire une déclaration de classe valide, même si cette classe hérite de plusieurs classes mères.
Les correctifs énumérés ci-dessous ne sont pas vraiment des correctifs; c'est-à-dire qu'ils ne concernent que le style du code et n'ont rien à voir avec la nature du code. Mais les développeurs de Python sont très intéressés à rendre le style du code aussi homogène que possible. Pour cela, il existe un manuel officiel dédié qui décrit le style du code Python.
Dans Python 2, la seule façon de définir un ensemble de valeurs littérales est d'appeler set a_sequence. Dans Python 3, cela reste valable, mais l'utilisation d'une nouvelle notation littérale: parenthèses majuscules est une méthode plus claire. Cette méthode fonctionne en dehors des ensembles vides, car le dictionnaire utilise également des parenthèses majuscules, de sorte que {} indique un dictionnaire vide, et non un ensemble vide.
Les scripts 2to3 ne réparent pas par défaut les valeurs set() littérales. Pour activer cette fonction, spécifiez le paramètre -f set_literal lors de l'appel à la ligne de commande 2to3.
| Nom de l'entreprise | Avant | Après |
|---|---|---|
| ensemble (([1,2,3]) | {1,2,3} | |
| Série (série 1, 2, 3) | {1,2,3} | |
| ensemble (([i pour iin a_sequence]) | {i pour l'intérieur d'une_ séquence} |
Les objets Python implémentés en C peuvent exporter une interface tampon qui permet à d'autres codes Python de lire et d'écrire directement sur un bloc de mémoire.
Les scripts 2to3 ne réparent pas la fonction buffer par défaut. Pour activer cette fonction, spécifiez le paramètre -f buffer lors de l'appel à la ligne de commande 2to3.
| Nom de l'entreprise | Avant | Après |
|---|---|---|
| x = tampon (y) | x = vue de mémoire (y) |
Bien que Python ait des exigences très strictes en matière d'espaces pour l'indentation et l'outdenting, il est libre d'utiliser les espaces dans d'autres aspects de Python. Dans les listes, les composants, les ensembles et les dictionnaires, les espaces peuvent apparaître devant ou derrière les virgules, ce qui n'a pas de mauvais effet. Cependant, le manuel de style de code Python indique qu'il ne peut pas y avoir d'espace avant les virgules et qu'il devrait y avoir un espace après les virgules.
Le script 2to3 ne répare pas les espaces autour des virgules par défaut. Pour activer cette fonction, spécifiez l'argument -f wscomma lors de l'appel à la ligne de commande 2to3.
| Nom de l'entreprise | Avant | Après |
|---|---|---|
| a, b | a, b | |
| - Je ne sais pas. | {a: b} |
Beaucoup de conventions ont été établies dans la communauté Python. Certaines sont comme while 1: loop, qui remonte à Python 1.
Les scripts 2to3 ne corrigent pas ces conventions par défaut. Pour activer cette fonction, spécifiez le paramètre -f idioms lors de l'appel à la ligne de commande 2to3.
| Nom de l'entreprise | Avant | Après |
|---|---|---|
| alors que 1: do_stuff() |
alors que True: do_stuff() |
|
| type ((x) == T | estinstance ((x, T) | |
| type ((x) est T | estinstance ((x, T) | |
| a_liste = liste ((a_séquence) | a_list = trié ((a_sequence) | |
| a_list.sort ()) | Je ne peux pas faire ça. | |
| Je ne peux pas faire ça. |
Traduit deLe blogue du CSDN
Il s'agit d'un article sur la façon de convertir du code Python 2.x en code Python 3.x. Comment convertir du code Python 2.x en code Python 3.x
Ce n'est pas nécessaire de dire grand-chose si cela ne concerne que quelques fonctions, comme print, etc.
Vous pouvez modifier le code vous-même.
La version 2.x de Python, comme Python 2.7.2 que j'ai installé, est livrée avec des outils utiles après le téléchargement et l'installation de Windows.
其中一个叫做2to3.pyLe code de Python 2.x est converti en code de Python 3.x.
Il est situé dans le répertoire racine des installations Python\Python27\Tools\Scripts\2to3.py
【如何利用2to3.py, implémenter le code de Python 2.x et le transformer en code de Python 3.x Par exemple, j'ai un scénario Python pour Python 2.x:
D:\tmp\tmp_dev_root\python\python2_to_python3\34563264_données de_site.py
Maintenant, nous voulons le convertir en code Python 3.x.
Il est possible d'ouvrir le cmd de windows, de le localiser sous le script à convertir et de l'exécuter.
D:\tmp\WordPress\DevRoot\Python27\Outils\Scripts\2to3.py -w 34563264_données_du_site.py
Si la conversion est réussie, l'exécution correspondante est:
D:\tmp\tmp_dev_root\python\python2_to_python3>D:\tmp\WordPress\DevRoot\Python27\Tools\Scripts\2to3.py -w 34563264_data_from_site.py
RefactoringTool: Skipping implicit fixer: buffer
RefactoringTool: Skipping implicit fixer: idioms
RefactoringTool: Skipping implicit fixer: set_literal
RefactoringTool: Skipping implicit fixer: ws_comma
RefactoringTool: Refactored 34563264_data_from_site.py
--- 34563264_data_from_site.py (original)
+++ 34563264_data_from_site.py (refactored)
@@ -18,7 +18,7 @@
import time;
import codecs;
import logging;
-import urllib;
+import urllib.request, urllib.parse, urllib.error;
from datetime import datetime,timedelta;
from optparse import OptionParser;
from string import Template,replace;
@@ -90,7 +90,7 @@
foundPhone = eachItemSoup.find(attrs={"class":"phone"});
logging.debug("foundPhone=%s", foundPhone);
if(foundPhone):
- foundPhoneUni = unicode(foundPhone);
+ foundPhoneUni = str(foundPhone);
logging.debug("foundPhoneUni=%s", foundPhoneUni);
# case 1:
#<p class="phone"><strong>phone:</strong> 800.206.7886<br />
@@ -122,7 +122,7 @@
foundWeb = eachItemSoup.find(attrs={"class":"web"});
logging.debug("foundWeb=%s", foundWeb);
if(foundWeb):
- foundWebUni = unicode(foundWeb);
+ foundWebUni = str(foundWeb);
logging.debug("foundWebUni=%s", foundWebUni);
# <p class="web"><strong>e-mail:</strong> <a href="#">sales@cinesysinc.com</a><br />
@@ -151,7 +151,7 @@
foundAddr = eachItemSoup.find(attrs={"class":"addr"});
logging.debug("foundAddr=%s", foundAddr);
if(foundAddr):
- foundAddrUni = unicode(foundAddr);
+ foundAddrUni = str(foundAddr);
# <p class="addr">
# <strong>address:</strong> 740 SW 21st Ave, Suite #310<br />
RefactoringTool: Files that were modified:
RefactoringTool: 34563264_data_from_site.py
À ce stade, vous pouvez voir l'original 3456264_data_from_site.py, qui est devenu une version de Python 3.x.
FangBei est là.Python 2 est utilisé par botvs?
Le petit rêveLe serveur de retouche de BotVS utilise la version 2.7 de Python, qui est prise en charge pour les plates-formes BotVS Python 2 et Python 3.