espero lo más negativo para el pitón es -maxint-1valor más negativo para el pitón
que esperan tener -2, hará desbordamiento de enteros.
from sys import maxint
maximum_int = maxint
minimum_int = -maxint - 2
# 2147483647
# -2147483649
print maximum_int
print minimum_int
Aún. Se muestra el resultado correcto y se muestra un valor que es más negativo que -maxint-1.
¿Puedo saber por qué?
Aquí se puede ver el resultado es promovido a una larga
>>> from sys import maxint
>>> type(-maxint)
<type 'int'>
>>> type(-maxint-1)
<type 'int'>
>>> type(-maxint-2)
<type 'long'>
>>>
nota de que la convención habitual de valores con signo es tener un número más negativa que positiva, por lo que en este caso -2147483648 sigue siendo un int
Python autopromotes int valores que se desbordan a long, que no tiene otro límite que la memoria disponible.
En Python, int s se auto-promocionará a long (bigint).
Python implementa el concepto de Biging, el tipo se llama long. El tamaño es prácticamente ilimitado.
Si realmente quieres el valor más negativo para python, float ('- inf') funciona bien.
Python promueve un desbordamiento de int a una precisión arbitraria larga que está limitada solo por la memoria disponible.
Se puede ver la promoción con este código:
import struct
from sys import maxint
maximum_int = maxint
minimum_int = -maxint-1
big_minus = -maxint-(maxint*maxint)
big_plus=maxint*maxint*maxint
def platform():
return struct.calcsize("P") * 8
def bit_length(x):
s=bin(x)
s=s.lstrip('-0b')
return len(s)
print
print 'running in ', platform(), ' bit mode...'
print 'maxint: ', maximum_int, ' bits: ', bit_length(maximum_int)
print 'minint: ', minimum_int, ' bits: ', bit_length(minimum_int)
print 'a big minus: ', big_minus, ' bits: ', bit_length(big_minus)
print 'big_plus: ', big_plus, ' bits: ', bit_length(big_plus)
print
Correr bajo Python 32 bits, aquí es el retorno:
running in 32 bit mode...
maxint: 2147483647 bits: 31
minint: -2147483648 bits: 32
a big minus: -4611686016279904256 bits: 62
big_plus: 9903520300447984150353281023 bits: 93
Bajo 64 Python bits:
running in 64 bit mode...
maxint: 9223372036854775807 bits: 63
minint: -9223372036854775808 bits: 64
a big minus: -85070591730234615856620279821087277056 bits: 126
big_plus: 784637716923335095224261902710254454442933591094742482943 bits: 189
Curiosamente , en Python 2.7 en mi sistema, la promoción a una larga sucede cuando coacces maxint a un flotador. Parece que la conversión a un flotante es equivalente a maxint + 1. En mi sistema: 'int (float (sys.maxint)) == 9223372036854775808L == sys.maxint + 1' da' True'. – hobs
Para la conversión flotante o -maxint: 'int (float (-sys.maxint)) == -9223372036854775808' y' int (float (-sys.maxint)) == -sys.maxint - 1' son ambos 'True '. ¡Así que ten cuidado cuando forces maxint a un flotador! – hobs
@hobs. Esto se debe a la precisión limitada de los flotadores (~ 15 dígitos decimales). –