La différence entre les versions Python2.x et 3.x
La version 3.0 de Python est souvent appelée Python 3000, ou Py3k en abrégé. Il s'agit d'une mise à niveau majeure par rapport aux versions précédentes de Python.
Afin de ne pas alourdir trop de charge, Python 3.0 n'a pas été conçu dans un souci de compatibilité descendante.
De nombreux programmes conçus pour les versions antérieures de Python ne peuvent pas fonctionner correctement sur Python 3.0.
Afin de prendre en charge les programmes existants, Python 2.6 est une version de transition qui utilise essentiellement la syntaxe et les bibliothèques de Python 2.x. Elle envisage également la migration vers Python 3.0 et permet l'utilisation de certains Python 3.0. syntaxe et fonctions.
À moins que l'environnement d'exécution ne puisse installer Python 3.0 ou que le programme lui-même utilise une bibliothèque tierce qui ne prend pas en charge Python 3.0. Les bibliothèques tierces qui ne prennent actuellement pas en charge Python 3.0 incluent Twisted, py2exe, PIL, etc.
La plupart des bibliothèques tierces travaillent dur pour être compatibles avec la version Python 3.0. Même si Python 3.0 ne peut pas être utilisé immédiatement, il est recommandé d'écrire un programme compatible avec Python 3.0 puis de l'exécuter en utilisant Python 2.6 ou Python 2.7.
Les changements dans Python 3.0 concernent principalement les aspects suivants :
fonction print
L'instruction print a disparu et est remplacée par la fonction print(). Python 2.6 et Python 2.7 prennent partiellement en charge cette forme de syntaxe d'impression. Dans Python 2.6 et Python 2.7, les trois formes suivantes sont équivalentes :
print "fish"
print ("fish") #注意print后面有个空格
print("fish") #print()不能带有任何其它参数Cependant, Python 2.6 prend en charge la nouvelle syntaxe print() :
from __future__ import print_function
print("fish", "panda", sep=', ')Unicode
Python 2 a le type ASCII str(), unicode() est séparé, pas de type octet.
Maintenant, dans Python 3, nous avons enfin des chaînes Unicode (utf-8), et une classe d'octets : byte et bytearrays.
Étant donné que les fichiers de code source Python3.X utilisent l'encodage utf-8 par défaut, cela rend le code suivant légal :
>>> 中国 = 'china' >>>print(中国) china
Python 2.x
>>> str = "我爱北京天安门" >>> str '\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8' >>> str = u"我爱北京天安门" >>> str u'\u6211\u7231\u5317\u4eac\u5929\u5b89\u95e8'
Python 3.x
>>> str = "我爱北京天安门" >>> str '我爱北京天安门'
Opération de division
La division en Python est très haut de gamme par rapport à d'autres langages et a un ensemble de règles très compliquées. La division en Python a deux opérateurs, / et //
Tout d'abord, /division :
En python 2.x, /division est comme la plupart des langages que nous connaissons avec, comme Java et C sont similaires. Le résultat de la division entière est un entier et la partie décimale est complètement ignorée. La division en virgule flottante conservera la partie décimale et obtiendra un résultat en virgule flottante.
En python 3.x/division ne fait plus cela pour la division entre entiers, le résultat sera également un nombre à virgule flottante.
Python 2.x :
>>> 1 / 2 0 >>> 1.0 / 2.0 0.5
Python 3.x :
>>> 1/2 0.5
Quant à la //division, cette division est appelée division d'étage, et le résultat de la division sera être effectué automatiquement. Opération de sol cohérente dans Python 2.x et Python 3.x.
python 2.x:
>>> -1 // 2 -1
python 3.x:
>>> -1 // 2 -1
Notez que la partie décimale n'est pas supprimée, mais l'opération au sol est effectuée si vous le souhaitez. interceptez la partie décimale, alors vous devez utiliser la fonction trunc du module mathématique
python 3.x:
>>> import math >>> math.trunc(1 / 2) 0 >>> math.trunc(-1 / 2) 0
Exception
La gestion des exceptions a également changé légèrement en Python 3. Dans Python 3, nous utilisons maintenant as comme mot-clé. La syntaxe pour détecter les exceptions dans
est modifiée de sauf exc, var à sauf exc as var.
Utilisez la syntaxe except (exc1, exc2) comme var pour intercepter plusieurs catégories d'exceptions en même temps. Python 2.6 prend déjà en charge les deux syntaxes.
1. À l'ère 2.x, tous les types d'objets peuvent être lancés directement. À l'ère 3.x, seuls les objets qui héritent de BaseException peuvent être lancés.
2. L'instruction raise 2.x utilise des virgules pour séparer le type d'objet lancé et les paramètres 3.x annule cette étrange méthode d'écriture et appelle directement le constructeur pour lancer l'objet.
À l'ère 2.x, les exceptions dans le code représentent non seulement des erreurs de programme, mais font aussi souvent des choses que les structures de contrôle ordinaires devraient faire. Dans 3, on peut voir à partir de .x que le concepteur a rendu les exceptions plus spécifiques. Ce n'est que lorsque des erreurs se produisent qu'elles peuvent être traitées avec des instructions de capture d'exception.
xrange
Dans Python 2, l'utilisation de xrange() pour créer des objets itérables est très populaire. Par exemple : boucle for ou compréhension de liste/ensemble/dictionnaire.
Cela se comporte un peu comme un générateur (c'est-à-dire une "évaluation paresseuse"). Mais ce xrange-iterable est infini, ce qui signifie que vous pouvez parcourir l'infini.
En raison de son évaluation paresseuse, la fonction xrange() est plus rapide que range() si vous devez la parcourir une seule fois (comme une boucle for). Cependant, plutôt que d’effectuer une itération une fois, il n’est pas recommandé d’itérer plusieurs fois car le générateur repart de zéro à chaque fois.
Dans Python 3, range() est implémenté comme xrange() afin qu'une fonction xrange() dédiée n'existe plus (dans Python 3, xrange() lève une exception nommée).
import timeit n = 10000 def test_range(n): return for i in range(n): pass def test_xrange(n): for i in xrange(n): pass
Python 2
print 'Python', python_version() print '\ntiming range()' %timeit test_range(n) print '\n\ntiming xrange()' %timeit test_xrange(n) Python 2.7.6 timing range() 1000 loops, best of 3: 433 µs per loop timing xrange() 1000 loops, best of 3: 350 µs per loop
Python 3
print('Python', python_version())
print('\ntiming range()')
%timeit test_range(n)
Python 3.4.1
timing range()
1000 loops, best of 3: 520 µs per looprrreeReprésentation littérale octale
Le nombre octal doit être écrit sous la forme 0o777, la forme originale 0777 ne peut pas être utilisé ; le binaire doit être écrit sous la forme 0b111.
Une nouvelle fonction bin() est ajoutée pour convertir un entier en chaîne binaire. Python 2.6 prend déjà en charge les deux syntaxes.
Dans Python 3.x, il n'y a qu'une seule façon de représenter un littéral octal, qui est 0o1000.
python 2.x
print(xrange(10)) --------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-5-5d8f9b79ea70> in <module>() ----> 1 print(xrange(10)) NameError: name 'xrange' is not defined
python 3.x
>>> 0o1000 512 >>> 01000 512
opérateur d'inégalité
Il existe deux opérateurs d'inégalité dans Python 2.x. il y a deux façons d'écrire != et <>
Dans Python 3.x, <> est supprimé, et il n'y a qu'une seule façon d'écrire !=. habitude d'utiliser <>
L'expression repr ``
Le backtick `` dans Python 2.x est équivalent au rôle de la fonction repr
Cela a été supprimé dans Python 3.x. Cette façon d'écrire permet uniquement l'utilisation de la fonction repr. Est-ce fait pour rendre le code plus clair ? Cependant, je pense qu'il existe très peu d'opportunités d'utiliser repr. Elle n'est généralement utilisée que lors du débogage. La plupart du temps, la fonction str est toujours utilisée pour décrire des objets avec des chaînes.
>>> 01000 File "<stdin>", line 1 01000 ^ SyntaxError: invalid token >>> 0o1000 512
Plusieurs modules ont été renommés (selon PEP8)
| 旧的名字 | 新的名字 |
|---|---|
| _winreg | winreg |
| ConfigParser | configparser |
| copy_reg | copyreg |
| Queue | queue |
| SocketServer | socketserver |
| repr | reprlib |
Le module StringIO est désormais fusionné dans le nouveau module io. Les nouveaux modules md5, gopherlib et autres ont été supprimés. Python 2.6 prend déjà en charge le nouveau module io.
httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, Cookie, cookielib sont fusionnés dans le package http.
L'instruction exec est annulée, ne laissant que la fonction exec(). Python 2.6 prend déjà en charge la fonction exec().
5. Type de données
1) Py3.X a supprimé le type long, et il n'y a désormais qu'un seul type entier - int, mais il se comporte comme la version 2.X. long
2) Un nouveau type bytes est ajouté, correspondant à la chaîne d'octets de la version 2.X. La méthode de définition d'un littéral bytes est la suivante :
def sendMail(from_: str, to: str, title: str, body: str) -> bool: pass
objet str et objet bytes. peuvent être utilisées. Les méthodes encode() (str -> bytes) ou .decode() (bytes -> str) se convertissent.
>>> b = b'china' >>> type(b) <type 'bytes'>
3) Les méthodes .keys(), .items et .values() de dict renvoient des itérateurs, tandis que les iterkeys() et autres fonctions précédentes ont été abandonnées. Sont également supprimés les dict.has_key(), remplacez-le par in.
