Est-ce que quelqu'un sait comment Python gère en interne les types int et long?
Comment devrais-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'>
int
et long
étaient "unifiés" quelques versions en arrière . Avant cela, il était possible de déborder d'un int avec des opérations mathématiques.
3.x a encore avancé cela en éliminant totalement int et ne plus avoir que longtemps.
sys.maxint
contient la valeur maximale qu'un int Python peut contenir .sys.getsizeof()
.sys.maxsize
contient la taille maximale en octets qu'un int Python peut être .sys.maxsize
.Ce PEP devrait aider.
En bout de ligne, vous ne devriez vraiment pas avoir à vous en soucier dans les versions Python> 2.4
Intéressant. Sur ma boîte 64 bits (Ubuntu i7):
>>> print type(0x7FFFFFFF)
<type 'int'>
>>> print type(0x7FFFFFFF+1)
<type 'int'>
Je suppose qu’il passe au 64 bits sur une machine plus grande.
Python 2.7.9 promeut automatiquement les nombres . Dans le cas où l’on ne sait pas utiliser int () ou long ().
>>> a = int("123")
>>> type(a)
<type 'int'>
>>> a = int("111111111111111111111111111111111111111111111111111")
>>> type(a)
<type 'long'>
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 ints (entiers signés sur 32 bits, je ne sais pas s'ils sont cachés sous le capot ou non) pour les valeurs qui entrent dans 32 bits, mais bascule automatiquement sur des bits longs plus grand. Je suppose que cela accélère les choses pour des valeurs plus petites tout en évitant les débordements avec une transition transparente vers les bignums.
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 maximale de l'Int par défaut dans Python 2 est 65535, toute valeur supérieure pouvant être longue
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épend de votre architecture de processeur.
Par exemple:
Les valeurs min/max de chaque type peuvent être trouvées ci-dessous:
Si la taille de votre int dépasse les limites mentionnées ci-dessus, python modifiera automatiquement son type et allouera plus de mémoire pour gérer cette augmentation des valeurs min/max. Où, dans Python 2, il serait converti en "long", il ne fait maintenant que passer à la taille suivante de Int.
Exemple: Si vous utilisez un système d'exploitation 32 bits, votre valeur maximale d'un Int sera 2147483647 par défaut. Si une valeur égale ou supérieure à 2147483648 est attribuée, le type devient Int64.
Il existe différentes manières de vérifier la taille de l'int et son allocation de mémoire ..__ Remarque: En Python 3, l'utilisation de la méthode type () intégrée renvoie toujours <class 'int'>
, quelle que soit la taille de Int.
À partir de python 3.x, les bibliothèques d’entiers unifiées sont encore plus intelligentes que les anciennes versions. Sur ma boîte (i7 Ubuntu), j'ai ce qui suit:
>>> type(math.factorial(30))
<class 'int'>
Pour plus de détails sur l'implémentation, reportez-vous aux fichiers Include/longintrepr.h, Objects/longobject.c and Modules/mathmodule.c
. Le dernier fichier est un module dynamique (compilé dans un fichier so). Le code est bien commenté à suivre.
Juste pour continuer à 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 car int
et long
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 int
a une méthode __mul__
(celle qui implémente *) qui crée un résultat long
lorsque requis.