Comment Python gère-t-il int et long?

Est-ce que quelqu'un sait comment Python gère en interne les types int et long?

• Choisit-il le bon type de manière dynamique?
• Quelle est la limite pour un int?
• J'utilise Python 2.6, est-ce différent des versions précédentes?

Comment dois-je comprendre le code ci-dessous?

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

Mettre à jour:

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

intet longont été "unifiées" quelques versions en arrière . Avant cela, il était possible de déborder un int à travers des opérations mathématiques.

3.x a encore avancé cela en éliminant complètement long et en n'ayant que int.

• Python 2 : sys.maxintcontient la valeur maximale qu'un int Python peut contenir.
  • Sur un Python 2.7 64 bits, la taille est de 24 octets. Vérifiez avec sys.getsizeof().
• Python 3 : sys.maxsizecontient la taille maximale en octets qu'un int Python peut avoir.
  • Ce sera des gigaoctets en 32 bits et des exaoctets en 64 bits.
  • Un int aussi grand aurait une valeur similaire à 8 à la puissance de sys.maxsize.

Ce PEP devrait aider.

En fin de compte, vous ne devriez vraiment pas avoir à vous en soucier dans les versions python> 2.4

Sur ma machine:

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

Python utilise des entiers (entiers signés 32 bits, je ne sais pas si ce sont des entiers C sous le capot ou non) pour les valeurs qui tiennent dans 32 bits, mais passe automatiquement en longs (nombre arbitrairement grand de bits - c'est-à-dire bignums) pour quoi que ce soit plus grand. Je suppose que cela accélère les choses pour les valeurs plus petites tout en évitant les débordements avec une transition transparente vers les bignums.

Intéressant. Sur ma boîte 64 bits (i7 Ubuntu):

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

Je suppose que cela augmente jusqu'à 64 bits sur une machine plus grande.

Python 2.7.9 favorise automatiquement les nombres. Pour un cas où l'on n'est pas sûr d'utiliser int () ou long ().

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

Python 2 définira automatiquement le type en fonction de la taille de la valeur. Vous trouverez ci-dessous un guide des valeurs maximales.

La valeur Max de l'Int par défaut dans Python 2 est 65535, tout ce qui est au-dessus sera long

Par exemple:

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

Dans Python 3, le type de données long a été supprimé et toutes les valeurs entières sont gérées par la classe Int. La taille par défaut de Int dépendra de l'architecture de votre CPU.

Par exemple:

• Systèmes 32 bits, le type de données par défaut pour les entiers sera «Int32»
• Systèmes 64 bits, le type de données par défaut pour les entiers sera «Int64»

Les valeurs min / max de chaque type se trouvent ci-dessous:

• 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]

Si la taille de votre Int dépasse les limites mentionnées ci-dessus, python changera automatiquement son type et allouera plus de mémoire pour gérer cette augmentation des valeurs min / max. Là où dans Python 2, il se convertirait en `` long '', il se convertit maintenant simplement en la taille suivante de Int.

Exemple: Si vous utilisez un système d'exploitation 32 bits, la valeur maximale d'un Int sera 2147483647 par défaut. Si une valeur de 2147483648 ou plus est affectée, le type sera changé en Int64.

Il existe différentes façons de vérifier la taille de l'int et son allocation de mémoire. Remarque: dans Python 3, l'utilisation de la méthode intégrée type () retournera toujours <class 'int'>quelle que soit la taille Int que vous utilisez.

Depuis python 3.x, les libries d'entiers unifiés sont encore plus intelligentes que les anciennes versions. Sur ma boîte (i7 Ubuntu), j'ai obtenu ce qui suit,

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

Pour plus de détails sur la mise en œuvre, reportez-vous aux Include/longintrepr.h, Objects/longobject.c and Modules/mathmodule.cfichiers. Le dernier fichier est un module dynamique (compilé dans un fichier so). Le code est bien commenté à suivre.

Juste pour continuer avec toutes les réponses qui ont été données ici, en particulier @James Lanes

la taille du type entier peut être exprimée par cette formule:

plage totale = (système 2 ^ bits)

limite inférieure = - (système 2 ^ bits) * 0,5 limite supérieure = ((système 2 ^ bits) * 0,5) - 1

Il les gère parce que intetlong sont des définitions de classe frères. Ils ont des méthodes appropriées pour +, -, *, /, etc., qui produiront des résultats de la classe appropriée.

Par exemple

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

Dans ce cas, la classe inta une __mul__méthode (celle qui implémente *) qui crée un longrésultat si nécessaire.