Änderungen von Python 2 zu Python 3.0

zunaechst

Dieser Artikel ist der 9. Tagesartikel von Python Part 2 Adventskalender 2015.

Ich beschloss zu schreiben

Ich habe Python vor vier Jahren zum ersten Mal geschrieben und dachte, es sei eine sehr gute Sprache, deshalb habe ich immer einfachen Code in Python geschrieben. Das erste, was ich schrieb, war Python 2.7, aber als ich es mir ansah, gab es etwas namens Python 3, und ich mochte neue Dinge. Als ich wirklich anfing zu lernen, benutzte ich Python 3.3. Also wusste ich nicht viel über das 2. System und ich hielt es nicht für notwendig, die alten zu lernen (obwohl das 2. System zu dieser Zeit das Hauptsystem war). Aber. Es gab verschiedene Probleme, wie die Bibliothek von 2 Serien, die 3 Serien nicht unterstützte, und sie wurde in 2 Serien geschrieben und ich musste sie selbst durch 3 Serien ersetzen.

Wie auch immer, ich habe mich entschlossen, beim Lernen die Unterschiede zwischen dem 2. und 3. System zu untersuchen. (Abgesehen von der Tatsache, dass es ungefähr 7 Jahre her ist, seit das 3. System herauskam ...) (Abgesehen von der Tatsache, dass andere wundervolle Leute wundervolle Artikel schreiben ... (T_T))

Bevor Sie zum Hauptthema kommen ...

――Wenn ich anfing zu schreiben, dachte ich, ich würde den Fortschritt von Python2 zu Python3.5 schreiben, aber da es bis Python3.0 ziemlich lang wurde, ist der Fortschritt von Python3.0 zu Python3.5 ein separater Artikel. Schreiben.

• Die Version, in der Sie den Code ausgeführt haben, ist oben links geschrieben.
• Für diejenigen, die etwas über Python wissen. Wenn Sie es ein wenig berührt haben, ist es wahrscheinlich in Ordnung!
• Der Unterstrich, der plötzlich im Code erscheint, speichert das vorherige Ausführungsergebnis.

Python3

>>> 1+1
2
>>> _
2
>>> 2+3
5
>>> _ -3
2
>>> type(_)
<class 'int'>
>>> _
<class 'int'>

Na dann ist es ziemlich lang (lacht) Geben wir unser Bestes!

Python2 -> Python3.0

Änderungen von Anweisung zu Funktion drucken

Python2

>>> print 'Hello'
Hello

Python3

>>> print('Hello')
Hello

Die Definition in Python3 scheint so zu sein.

def print(*args, sep=' ', end='\n', file=None)

Ich frage mich, ob ich Probleme habe, wenn ich versuche, den Taple anzuzeigen.

Python2

>>> print ('item1', 'item2')
('item1', 'item2')

Python3

>>> print ('item1', 'item2')
item1 item2
>>> print(('item1', 'item2'), )
('item1', 'item2')

Gibt Ansichten und Iteratoren anstelle von Listen zurück

Ansichten ist Nanno Kocha. Nun, Sie können das Ergebnis sehen.

Diktiermethoden, Schlüssel, Elemente, Werte geben Ansichten zurück

Python2

>>> d = {"key1": "value1"}
>>> d.keys()
['key1']
>>> type(_)
<type 'list'>
>>> d.values()
['value1']
>>> d.items()
[('key1', 'value1')]

Python3

>>> d = {"key1": "value1"}
>>> d.keys()
<dict_keys object at 0x7f0da5268e18>
>>> type(_)
<class 'dict_keys'>
>>> d.values()
<dict_values object at 0x7f0da5268e18>
>>> d.items()
<dict_items object at 0x7f0da3a44638>

In Python2 ist alles eine Liste, und in Python3 wird es als Objekt wie "dict_keys" zurückgegeben. Dies ist ein iterierbares Objekt, das Sie wahrscheinlich Ansichten nennen.

Wenn Sie es als Liste in Python3 möchten, schließen Sie es mit list () ein.

Python3

>>> list(d.keys())
['key1']

Abschaffung von Diktiermethoden, Iterkeys, Iteritems, Itervalues

Python2

>>> d.iterkeys()
<dictionary-keyiterator object at 0x7f5b586155d0>
>>> type(_)
<type 'dictionary-keyiterator'>

Python3

>>> d.iterkeys()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'iterkeys'

Es ist natürlich, nicht wahr? Die Schlüssel geben den Iterator zurück.

Zuordnung, Filterfunktion gibt Iterator zurück

Python2

>>> f1 = lambda x : x + 1
>>> f2 = lambda x : x%2 == 0
>>> l = [1, 2, 3]
>>> map(f1, l)
[2, 3, 4]
>>> type(_)
<type 'list'>
>>> filter(f2, l)
[2]
>>> type(_)
<type 'list'>

Python3

>>> iter_check = lambda obj : hasattr(obj, '__iter__') and hasattr(obj, '__next__')
>>> isIterable = lambda obj : hasattr(obj, '__iter__')
>>> f1 = lambda x : x + 1
>>> f2 = lambda x : x%2 == 0
>>> l = [1, 2, 3]
>>> map(f1, l)
<map object at 0x7f0da5261950>
>>> map_obj = _
>>> type(map_obj)
<class 'map'>
>>> iter_check(map_obj)
True
>>>
>>> filter(f2, l)
<filter object at 0x7f0da52619d0>
>>> filter_obj = _
>>> type(filter_obj)
<class 'filter'>
>>> iter_check(filter_obj)
True

Sie müssen sich nicht zu viele Sorgen um den Inhalt des Lambda machen (lacht) Mit dieser Funktion können Sie überprüfen, ob es sich um ein iterierbares Objekt oder einen Iterator handelt. In Python2 wird eine Liste zurückgegeben, und in Python3 wird ein Iterator zurückgegeben.

Die Python3-Bereichsfunktion gibt ein Iteratorobjekt zurück (xrange in Python2). xrange wird abgeschafft

Python2

>>> iter_check = lambda obj : hasattr(obj, '__iter__') and hasattr(obj, '__next__')
>>> isIterable = lambda obj : hasattr(obj, '__iter__')
>>> type(range(1,10))
<type 'list'>
>>> type(xrange(1,10))
<type 'xrange'>
>>> iter_check(xrange(1,10))
False
>>> isIterable(xrange(1,10))
True

Python3

>>> type(range(1,10))
<class 'range'>
>>> type(iter(range(1,10)))
<class 'range_iterator'>
>>> xrange(1,10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'xrange' is not defined

In Python 3 gibt range ein iterierbares Objekt anstelle einer Liste zurück. Und xrange ist verstorben. Kette

Die Zip-Funktion gibt den Iterator zurück

Python2

>>> zip([1,2,3], [2,3,4])
[(1, 2), (2, 3), (3, 4)]
>>> type(_)
<type 'list'>

Python3

>>> zip([1,2,3], [2,3,4])
<zip object at 0x7f0da3a40cf8>
>>> iter_check(_)
True

Python3 gibt einen Iterator zurück.

Auftragsvergleich

Der Vergleichsoperator (<,>, <=,> =) löst einen TypeError aus, wenn seine Operanden keine natürliche Reihenfolge haben.

Python2

>>> 1 < 'a'
True
>>> 0 > None
True
>>> len <= len
True
>>> None < None
False

Python3

>>> 1 < 'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()
>>> 0 > None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() > NoneType()
>>> len <= len
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: builtin_function_or_method() <= builtin_function_or_method()
>>> None < None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: NoneType() < NoneType()

Ich wusste das zum ersten Mal. Python2 ist schrecklich ... Python3 löst jedoch Ausnahmen aus, sodass es sicher ist!

Die sortierte Funktion und die Sortiermethode der Liste verwenden nicht mehr das cmp-Argument, das eine Vergleichsfunktion ergibt

Die Definition in Python2 lautet wie folgt sorted(iterable[, cmp[, key[, reverse]]]) s.sort([cmp[, key[, reverse]]])

Die Definition in Python 3 lautet wie folgt sorted(iterable[, key][, reverse]) sort(*, key=None, reverse=None)

Das cmp-Argument ist weg. Außerdem muss das Argument der Sortiermethode der Liste in Python3 als Schlüsselwortargument übergeben werden.

Die cmp-Funktion ist veraltet und die Methode __cmp__ wird nicht mehr unterstützt

Dies ist kein Beispiel, nicht wahr? Bitte verwenden Sie zum Sortieren die Methode __lt__.

Über ganze Zahlen

Grundsätzlich wurde long in int umbenannt (verhält sich aber ähnlich wie der alte lange Typ)

Python2

>>> type(10**100)
<type 'long'>

Python3

>>> type(10**100)
<class 'int'>

Es wird in Python als int-Typ behandelt.

Ausdrücke wie 1/2 geben einen Float-Typ zurück. Verwenden Sie einen Ausdruck wie 1/2/2, wenn Sie weniger als ein paar Punkte abschneiden

Python2

>>> 1/2
0
>>> type(1/2)
<type 'int'>

Python3

>>> type(1/2)
<class 'float'>
>>> 1//2
0
>>> type(1//2)
<class 'int'>

Wenn Sie mit Python3 teilen und mit int zurückkehren möchten, verwenden Sie den Operator //.

Die Konstante sys.maxint wurde entfernt, da für Ganzzahlen keine Obergrenze festgelegt ist

Python2

>>> sys.maxint
9223372036854775807

Python3

>>> sys.maxint
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'maxint'

Es wurde gelöscht.

Die lange Ganzzahl-Repr-Methode endet nicht mit L.

Python2

>>> 10**20
100000000000000000000L

Python3

>>> 10**20
100000000000000000000

L ist in Python3 nicht am Ende.

Acht-Liter-Literal geändert von Notation wie 0720 zu Notation wie 0o720

Python2

>>> 0720
464
>>> 0o720
464

Python3

>>> 0720
  File "<stdin>", line 1
    0720
       ^
SyntaxError: invalid token
>>> 0o720
464

Ist dies eine einheitliche Form für Notationen wie 0x und 0b?

Zu Text und Daten anstelle von Unicode und 8bit

Der gesamte Text in Unicode

Wie der Titel schon sagt. Dies machte das vorherige Unicode-Textliteral "u" ... "unbrauchbar.

Python2

>>> u"unicode"
u'unicode'

Python3

>>> u"unicode"
  File "<stdin>", line 1
    u"unicode"
             ^
SyntaxError: invalid syntax

Text ist vom Typ str, Daten vom Typ bytes

Python3

>>> type("test")
<class 'str'>
>>> type(b"test")
<class 'bytes'>

Verwenden Sie "b" ... "für binäre Datenliterale.

Senden Sie TypeError, wenn Sie Text und Daten mischen

Python2

>>> "str" + b"bytes"
'strbytes'

Python3

>>> "str" + b"bytes"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'bytes' object to str implicitly

Python2 Ernsthaft ... (2. Mal) Es ist so eine verrückte Sache. .. Python3 ist falsch!

Explizite Konvertierung zwischen Text und Daten

Python3

>>> "str".encode()
b'str'
>>> bytes("str", "utf-8")
b'str'
>>> 
>>> b"bytes".decode()
'bytes'
>>> str(b"bytes", "utf-8")
'bytes'

Es ist eine Konvertierung zwischen str und Bytes. Nun, es gibt viele Artikel über das Codieren und Decodieren in Python. Bitte beziehen Sie sich darauf.

Backslashes werden unverändert in rohen Zeichenfolgen interpretiert

Python2

>>> print(ur"\u20ac")
€

Python3

>>> print(r"\u20ac")
\u20ac

Ich sage nicht, dass Python2 es ernst meint, aber hey! Es ist ein Gefühl. Ich mag keine rohen Saiten! Nun, es kann Zeiten geben, in denen Sie dieses Verhalten wünschen, aber das Verhalten von Python 3 ist besser.

Abstrakte Klasse namens basestring entfernt

Python2

>>> str.__base__
<type 'basestring'>
>>> bytes.__base__
<type 'basestring'>

Python3

>>> str.__base__
<class 'object'>
>>> bytes.__base__
<class 'object'>

In Python2 gab es eine abstrakte Klasse namens basestring. Dies bedeutet, dass der Typ str und bytes durch Vererbung erstellt wurden. In Python3 wird jede Klasse direkt definiert.

Zusammenfassung der Syntaxänderungen

Funktionsanmerkung hinzufügen

Python3

>>> def f(a: "int_value", b: "int_value default value one" = 1) -> "added_value":
...   return a+b
... 
>>> f.__annotations__
{'a': 'int_value', 'b': 'int_value default value one', 'return': 'added_value'}

Sie können Funktionsargumenten Anmerkungen hinzufügen und Werte zurückgeben. Im obigen Beispiel handelt es sich nur um eine Zeichenfolge. Da Sie jedoch einen Ausdruck schreiben können, können Sie "1 + 1", "int" usw. schreiben.

Python3

>>> i=2
>>> j=3
>>> def f(a: i*j, b: i+j) -> 1+1:
...  return a+b
... 
>>> f.__annotations__
{'a': 6, 'b': 5, 'return': 2}
>>> i=10
>>> j=10
>>> f.__annotations__
{'a': 6, 'b': 5, 'return': 2}

Der Ausdruck wird ausgewertet, wenn die Funktion definiert ist. Es ist natürlich, nicht wahr? ..

Nur-Schlüsselwort-Argumente

Python3

>>> def f(a, *, b):
...   return a+b
... 
>>> def g(*, a, b):
...   return a*b
... 
>>> f(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes exactly 1 positional argument (2 given)
>>> f(1, b=2)
3
>>> g(1, b=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: g() takes exactly 0 non-keyword positional arguments (1 given)
>>> g(a=1, b=2)
2
>>> g(b=1, a=2)
2

Sie können das Sternchen "*" verwenden, um die danach aufgeführten Argumente auf Schlüsselwortargumente zu beschränken. Es gibt nur sehr wenige japanische Dokumente. Als ich sie zum ersten Mal sah, war ich in Schwierigkeiten (lacht).

Sie können Schlüsselwortargumente nach der Liste der Basisklassen in der Klassendefinition übergeben

Python3

>>> class MClass(type):
...  def __new__(cls, name, bases, namespace, **kwds):
...   result = type.__new__(cls, name, bases, dict(namespace))
...   result.members = tuple(namespace)
...   return result
...  def __init__(self, *args, **kargs):
...   print("args: " + str(args))
...   print("kargs: " + str(kargs))
... 
>>> class A(object, metaclass=MClass, a=1, b=2, c=3):
...   def one(self): pass
... 
args: ('A', (<class 'object'>,), {'__module__': '__main__', 'one': <function one at 0x7f62d071c408>})
kargs: {'a': 1, 'c': 3, 'b': 2}

Das ist ein bisschen schwer ... Auf jeden Fall können Sie nach der Basisklasse Schlüsselwortargumente erhalten. Der Typ kann jedoch keine Schlüsselwortargumente empfangen. Sie müssen daher eine eigene Metaklasse erstellen, damit Sie sie empfangen können. .. (MClass ist das)

nichtlokale Aussage

Python3

>>> def counter(init=0):
...  def cntup():
...   nonlocal init
...   init+=1
...   return init
...  return cntup
...
>>> c = counter()
>>> c()
1
>>> c()
2
>>> c()
3

Die nichtlokale Anweisung ermöglicht es dem angegebenen Bezeichner, auf eine Variable im nächsthöheren Bereich zu verweisen. Kurz gesagt, ist es eine Schließung? Im Beispiel wird das Argument init der Zählerfunktion durch eine nichtlokale Anweisung referenziert. In Python2 konnte ich es nicht ohne Verwendung von Liste usw. tun, aber in Python3 kann ich es präzise schreiben. (Wenn Sie nur darauf verweisen möchten, benötigen Sie in Python2 keine nicht lokalen oder Listen. Sie benötigen diese, wenn Sie an Variablen im äußeren Bereich binden.)

Python3

>>> c.__closure__
(<cell at 0x7f62d071d5c8: int object at 0x7a3e20>,)
>>> c.__closure__[0].cell_contents
3

Übrigens können Sie auf diese Weise auf den Verschluss verweisen.

Erweitertes iterierbares Auspacken

Python3

>>> a, *rest, b = range(5)
>>> a
0
>>> rest
[1, 2, 3]
>>> b
4

Nach dem Auspacken von a und b in Ruhe wird der Überschuss als Liste ausgepackt. Dieser Rest kann als leere Liste entpackt werden.

Python3

>>> a, *rest, b = range(2)
>>> a
0
>>> rest
[]
>>> b
1

es ist wunderbar···.

Geänderte Syntax

Ausnahmefangsyntax

Python2

>>> try:
...  raise Exception("test")
... except Exception, e:
...  print "catch exception!"
... 
catch exception!

Python3

>>> try:
...  raise Exception("test")
... except Exception as e:
...  print("catch exception!")
... 
catch exception!

Das Komma wurde in das Schlüsselwort as geändert.

Neue Syntax für Raise-Anweisungen

Python3

>>> try:
...  raise Exception("test")
... except Exception as e:
...  raise RuntimeError("catch exception!") from e
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: test

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: catch exception!

Die from-Klausel wurde hinzugefügt, damit Sie eine Kette von Ausnahmen darstellen können. Außerdem scheint es implizit zu funktionieren, wenn in der Ausnahmeklausel eine Ausnahme ausgelöst wird.

Python3

>>> try:
...  1/0
... except Exception as e:
...  raise RuntimeError("raise exception.")
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: int division or modulo by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: raise exception.

Richtig, Falsch sind reservierte Wörter

Python2

>>> True = 0
>>> False = 1
>>> True
0
>>> False
1
>>> True and True
0

Python3

>>> True=0
  File "<stdin>", line 1
SyntaxError: assignment to keyword
>>> False=1
  File "<stdin>", line 1
SyntaxError: assignment to keyword

Grusel! !! Nun, Sie können es normalerweise durch Wahr, Falsch ersetzen! Ich nicht.

Änderungen der Metaklassensyntax

Python2

>>> class M(type):
...  pass
... 
>>> class C:
...  __metaclass__ = M
... 
>>> C.__class__
<class '__main__.M'>

Python3

>>> class M(type):
...  pass
... 
>>> class C(metaclass=M):
...  pass
... 
>>> C.__class__
<class '__main__.M'>

In Python2 wird die Variable \ _ \ _ metaclass \ _ \ _ übergeben, und in Python3 wird die Basisklasse angegeben und als Schlüsselwortargument übergeben. Python3 unterstützt keine Methoden wie Python2.

Was ich hier zum ersten Mal gelernt habe, war, dass in Python2 die Klasse Objekte explizit erben musste, aber mithilfe einer Metaklasse kann eine Klasse erstellt werden, die Objekte erbt. Das war's!

Python2

>>> class A:
...  pass
... 
>>> A.__bases__
()
>>> class C:
...  __metaclass__ = type
... 
>>> C.__bases__
(<type 'object'>,)

Auslassungspunkte können überall als primitiver Ausdruck verwendet werden

Python3

>>> ...
Ellipsis
>>> def e():
...  ...

Kürzung. (Ich habe nichts zu sagen ...)

Operation gelöscht

Es wurde gelöscht, also fahren wir fort.

Tapple-Argumente entpacken

Python2

>>> def foo(a, (b,c)):
...  return a+b+c
... 
>>> t = 2,3
>>> foo(1, t)
6

Python3

>>> def foo(a, (b,c)):
  File "<stdin>", line 1
    def foo(a, (b,c)):
               ^
SyntaxError: invalid syntax

Es ist schwer zu lesen ... In Python3 werde ich von der ersten Zeile an wütend.

Über Rückzitate

Python2

>>> i = 123
>>> `i`
'123'

Python3

>>> i=123
>>> `i`
  File "<stdin>", line 1
    `i`
    ^
SyntaxError: invalid syntax

Anscheinend wurde die Methode \ _ \ _ repr \ _ \ _ aufgerufen.

Über exec

Python2

>>> exec "print('python2')"
python2
>>> exec("print('python2')")
python2

Python3

>>> exec "print('python3')"
  File "<stdin>", line 1
    exec "print('python3')"
                          ^
SyntaxError: invalid syntax
>>> exec("print('python3')")
python3

In Python2 war es eine exec-Anweisung. Funktionsnotation ist auch in Ordnung. In Python3 ist es kein reserviertes Wort mehr und bleibt eine Funktion.

<> Operator

Python2

>>> 1 <> 2
True
>>> 1 <> 1
False

Python3

>>> 1 <> 2
  File "<stdin>", line 1
    1 <> 2
       ^
SyntaxError: invalid syntax

! = Ist es nicht okay?

Rund ums Wörtliche

Python2

>>> u"python2"
u'python2'
>>> 100L
100L

Python3

>>> u"python3"
  File "<stdin>", line 1
    u"python3"
             ^
SyntaxError: invalid syntax
>>> 100L
  File "<stdin>", line 1
    100L
       ^
SyntaxError: invalid syntax

Das habe ich oben schon erwähnt.

Über vom Modulimport * außer der obersten Ebene

Python2

>>> from sys import *
>>> def f():
...  from os import *
... 
<stdin>:1: SyntaxWarning: import * only allowed at module level

Python3

>>> from sys import *
>>> def f():
...  from os import *
... 
  File "<stdin>", line 1
SyntaxError: import * only allowed at module level

Die Warnung wurde in Fehler geändert. Warum hat Python 2 mit Warnung aufgehört ...

Andere Änderungen

Operatoren und spezielle Methoden

! = Gibt das Gegenteil von == zurück (wenn == nicht implementiert zurückgibt)

Python2

>>> class C:
...  def __init__(self, a):
...   self.a = a
...
...  def __eq__(self, other):
...   return self.a == other.a
...
>>> a = C(1)
>>> b = C(1)
>>> c = C(2)
>>> a == b
True
>>> a == c
False
>>> a != b
True
>>> a != c
True

Python3

>>> class C:
...  def __init__(self, a):
...   self.a = a
...
...  def __eq__(self, other):
...   return self.a == other.a
...
>>> a = C(1)
>>> b = C(1)
>>> c = C(2)
>>> a == b
True
>>> a != b
False
>>> a == c
False
>>> a != c
True

Das war ein wenig überraschend. Python! ! = Implementiert __ne__ () nicht, vergleicht also, ob die Objekte gleich sind. Das Ergebnis ist True, da a, b und c alle unterschiedlich sind. Ich habe mich gefragt, ob ich einen Attributfehler bekommen würde ... Es war eine Geschichte, die man mit ein wenig Nachdenken verstehen kann.

Von ungebundenen Methoden zum Funktionsobjekt

Python2

>>> class C:
...  def f(self):
...   pass
...
>>> C.f
<unbound method C.f>

Python3

>>> class C:
...  def f(self):
...   pass
...
>>> C.f
<function f at 0x100a35270>

Ja. Python3 wird nur als Funktion behandelt. Die ungebundene Methode ist wahrscheinlich eine Methode, die nicht an eine Instanz gebunden ist. Python3 ist einfacher und verständlicher

Der Methodentyp __getslice__ () wird gelöscht, und das Slice-Objekt wird an den Methodentyp __getitem__ () übergeben.

Python2

>>> class C:
...  def __getslice__(self, i, j):
...   print i, j
...   raise NotImplementedError()
...
>>> a = C()
>>> a[0:2]
0 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in __getslice__
NotImplementedError

Python3

>>> class C:
...  def __getitem__(self, obj):
...   print(obj)
...   print(type(obj))
...   raise NotImplementedError()
...
>>> a = C()
>>> a[0:2]
slice(0, 2, None)
<class 'slice'>
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in __getitem__
NotImplementedError

• getslice
• setslice
• delslice

Aber

• getitem
• setitem
• delitem

Wird jetzt stattdessen aufgerufen und Slice-Objekte werden jetzt übergeben. Ich habe es im Beispiel nicht implementiert, aber Sie können sehen, dass das Slice-Objekt als Argument übergeben wird.

Die Methode next () wurde in __next__ () umbenannt

Python2

>>> class C:
...  def __iter__(self):
...   return self
...
...  def next(self):
...   return 0
...
>>> a = C()
>>> i = iter(a)
>>> next(i)
0
>>> i.next()
0

Python3

>>> class C:
...  def __iter__(self):
...   return self
...
...  def __next__(self):
...   return 0
...
>>> a = C()
>>> i = iter(a)
>>> next(a)
0
>>> i.__next__()
0

Es hat sich geändert, so dass "next ()" von "next ()" aufgerufen wird.

__oct __ () und __hex __ () wurden entfernt und __index __ () sollte verwendet werden

Python2

>>> class C:
...  def __oct__(self):
...   return "07"
...
...  def __hex__(self):
...   return "0x7"
...
>>> a = C()
>>> hex(a)
'0x7'
>>> oct(a)
'07'

Python3

>>> class C:
...  def __index__(self):
...   return 7
...
>>> a = C()
>>> hex(a)
'0x7'
>>> oct(a)
'0o7'

__oct__ () und __hex __ () sind Methoden, die eine Zahl in eine Zeichenfolge konvertieren und zurückgeben, aber __index__ () gibt nur eine Zahl zurück. Danach konvertiert Python es in gut. Python3 ist wunderbar ~. (Das Beispiel gibt eine Konstante zurück, aber bitte vergib mir ...)

__nonzero__ () wurde in __bool__ () umbenannt

Python2

>>> class C:
...  def __nonzero__(self):
...   return True
...
>>> a = C()
>>> bool(a)
True

Python3

>>> class C:
...  def __bool__(self):
...   return True
...
>>> a = C()
>>> bool(a)
True

Wie haben Sie sich für den Namen __nonzero__ () entschieden? In Python 3 wird __bool__ () aufgerufen. Einfach zu verstehen.

Builtins

Hinzufügung von "super ()"

Python3

>>> class SuperClass:
...  pass
... 
>>> class SubClass(SuperClass):
...  def findSuperClass(self):
...   print("call super(): ", super())
...   print("call super(SubClass, self)", super(SubClass, self))
...
>>> i = SubClass()
>>> i.findSuperClass()
call super():  <super: <class 'SubClass'>, <SubClass object>>
call super(SubClass, self) <super: <class 'SubClass'>, <SubClass object>>

super () kann ohne Argumente aufgerufen werden und wählt automatisch die entsprechende Klasse und Instanz für Sie aus. Die Verarbeitung ist dieselbe wie bei einem Argument.

raw_input () umbenannt ininput ()

Python3

>>> input()
test
'test'

input () liest eine Zeile aus der Standardeingabe und gibt die Zeichenfolge ohne Zeilenumbrüche zurück. Wenn Sie "input ()" in Python2 ausführen möchten, können Sie dies mit "eval (input ())" tun.

Zusammenfassung

In stumpfem Python 3

--print wird eine Funktion Die Methode --keys, items, values gibt iterierbare Objekte zurück

• Die Standardzeichenfolge ist Unicode und der Typ ist "str" --xrange wird zum Bereich

Ich denke, dass es fast kein Problem gibt, wenn Sie sich an die Gegend erinnern.

Es gibt auch einige Änderungen, die ich in diesem Artikel ausgelassen habe, aber ich habe ungefähr 10% des Nischeninhalts entfernt, den ich für nicht sehr wichtig hielt. Wenn Sie wissen möchten, lesen Sie bitte Was ist neu in Python 3.0 (runder Wurf).

Am Ende

Als ich den Artikel schrieb, war ich überrascht, dass Python2 von Fallen abhängig war. Ich bin froh, dass ich es selbst aus Python 3 gemacht habe (lacht)

Und wenn Sie noch nicht von Python 2 gewechselt sind, können Sie diese Gelegenheit nutzen, um sich daran zu erinnern und zu Python 3 zu wechseln, und Sie werden ein glückliches Python-Leben haben (lacht). (Obwohl es viele zusammenfassende Artikel wie Python 2 bis 3 gibt)

Wie ich zu Beginn geschrieben habe, werde ich den Fortschritt von Python 3.0 zu Python 3.5 in einem anderen Artikel schreiben. Der Fortschritt von Python 3.0 zu Python 3.5 erfolgt am 16. des Python Part 2 Adventskalenders.

Wenn Sie irgendwelche seltsamen Punkte, Fehler oder bessere Dinge zu tun haben, kommentieren Sie bitte!

Morgen ist frei und 11. ist @FGtatsuro!

** Dann hab ein gutes Python3-Leben! !! ** ** **