Wie verwaltet Python int und long?

Weiß jemand, wie Python intern int und long-Typen verwaltet?

• Wählt es dynamisch den richtigen Typ?
• Was ist die Grenze für ein int?
• Ich verwende Python 2.6. Ist es anders als in früheren Versionen?

Wie soll ich den folgenden Code verstehen?

>>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

Aktualisieren:

>>> print type(0x7fffffff)
<type 'int'>
>>> print type(0x80000000)
<type 'long'>

intund longwurden vor ein paar Versionen "vereinheitlicht" . Zuvor war es möglich, ein Int durch Math Ops zu überlaufen.

3.x hat dies weiter vorangetrieben, indem es long insgesamt eliminiert und nur int hat.

• Python 2 : sys.maxintEnthält den Maximalwert, den ein Python-Int enthalten kann.
  • Auf einem 64-Bit-Python 2.7 beträgt die Größe 24 Byte. Überprüfen Sie mit sys.getsizeof().
• Python 3 : sys.maxsizeEnthält die maximale Größe in Bytes, die ein Python-Int haben kann.
  • Dies sind Gigabyte in 32 Bit und Exabyte in 64 Bit.
  • Ein so großes int hätte einen Wert ähnlich 8 hoch der Potenz von sys.maxsize.

Dieser PEP sollte helfen.

Fazit ist, dass Sie sich in Python-Versionen> 2.4 wirklich keine Sorgen machen müssen

Auf meiner Maschine:

>>> print type(1<<30)
<type 'int'>
>>> print type(1<<31)
<type 'long'>
>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'long'>

Python verwendet Ints (32-Bit-Ganzzahlen mit Vorzeichen, ich weiß nicht, ob es sich um C-Ints unter der Haube handelt oder nicht) für Werte, die in 32-Bit passen, wechselt jedoch automatisch für alles zu Longs (beliebig große Anzahl von Bits - dh Bignums) größer. Ich vermute, dass dies die Dinge für kleinere Werte beschleunigt und gleichzeitig Überläufe mit einem nahtlosen Übergang zu Bignums vermeidet.

Interessant. Auf meiner 64-Bit-Box (i7 Ubuntu):

>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'int'>

Vermutlich werden auf einem größeren Computer bis zu 64-Bit-Ints angezeigt.

Python 2.7.9 fördert automatisch Zahlen. Für einen Fall, in dem man sich nicht sicher ist, int () oder long () zu verwenden.

>>> a = int("123")
>>> type(a)
<type 'int'>
>>> a = int("111111111111111111111111111111111111111111111111111")
>>> type(a)
<type 'long'>

Python 2 legt den Typ automatisch basierend auf der Größe des Werts fest. Eine Anleitung mit Maximalwerten finden Sie unten.

Der Maximalwert des Standard-Int in Python 2 ist 65535, alles, was darüber liegt, ist lang

Beispielsweise:

>> print type(65535)
<type 'int'>
>>> print type(65536*65536)
<type 'long'>

In Python 3 wurde der lange Datentyp entfernt und alle ganzzahligen Werte werden von der Int-Klasse behandelt. Die Standardgröße von Int hängt von Ihrer CPU-Architektur ab.

Beispielsweise:

• 32-Bit-Systeme Der Standarddatentyp für Ganzzahlen ist "Int32".
• 64-Bit-Systeme Der Standarddatentyp für Ganzzahlen ist "Int64".

Die Min / Max-Werte der einzelnen Typen finden Sie unten:

• Int8: [-128,127]
• Int16: [-32768,32767]
• Int32: [-2147483648,2147483647]
• Int64: [-9223372036854775808,9223372036854775807]
• Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
• UInt8: [0,255]
• UInt16: [0,65535]
• UInt32: [0,4294967295]
• UInt64: [0,18446744073709551615]
• UInt128: [0,340282366920938463463374607431768211455]

Wenn die Größe Ihres Int die oben genannten Grenzwerte überschreitet, ändert Python automatisch seinen Typ und weist mehr Speicher zu, um diese Erhöhung der Min / Max-Werte zu bewältigen. Wo es in Python 2 in 'long' konvertiert wird, wird es jetzt nur noch in die nächste Größe von Int konvertiert.

Beispiel: Wenn Sie ein 32-Bit-Betriebssystem verwenden, beträgt Ihr Maximalwert für ein Int standardmäßig 2147483647. Wenn ein Wert von 2147483648 oder höher zugewiesen wird, wird der Typ in Int64 geändert.

Es gibt verschiedene Möglichkeiten, die Größe des int und seine Speicherzuordnung zu überprüfen. Hinweis: In Python 3 gibt die Verwendung der integrierten type () -Methode immer zurück, <class 'int'>unabhängig von der Größe, die Sie verwenden.

Ab Python 3.x sind die einheitlichen Integer-Bibliotheken noch intelligenter als ältere Versionen. Auf meiner (i7 Ubuntu) Box habe ich folgendes:

>>> type(math.factorial(30))
<class 'int'>

Einzelheiten zur Implementierung finden Sie in den Include/longintrepr.h, Objects/longobject.c and Modules/mathmodule.cDateien. Die letzte Datei ist ein dynamisches Modul (kompiliert zu einer solchen Datei). Der Code ist gut kommentiert, um zu folgen.

Nur um mit allen Antworten fortzufahren, die hier gegeben wurden, insbesondere @James Lanes

Die Größe des Integer-Typs kann durch folgende Formel ausgedrückt werden:

Gesamtbereich = (2 ^ Bit-System)

untere Grenze = - (2 ^ Bit-System) * 0,5 obere Grenze = ((2 ^ Bit-System) * 0,5) - 1

Es verwaltet sie, weil intund longGeschwister Klassendefinitionen sind. Sie haben geeignete Methoden für +, -, *, / usw., die Ergebnisse der entsprechenden Klasse liefern.

Beispielsweise

>>> a=1<<30
>>> type(a)
<type 'int'>
>>> b=a*2
>>> type(b)
<type 'long'>

In diesem Fall verfügt die Klasse intüber eine __mul__Methode (die * implementiert), die longbei Bedarf ein Ergebnis erstellt .