2.1.4 Tipos numéricos

Hay cuatro tipos numéricos: enteros normales, enteros largos, números en coma flotante y números complejos. Los enteros normales (denominados también enteros) se implementan usando long en C, lo que les da, al menos, 32 bits de precisión. Los enteros largos no tienen un límite de precisión. Los números en coma flotante se implementan usando double en C. No se puede hacer ninguna suposición sobre su precisión salvo que se conozca la máquina y el compilador con los que se trabaja.

Los números complejos tienen parte real e imaginaria, implementadas ambas con double en C. Para extraer las dos partes de un número complejo z, se usa z.real y z.imag.

Los números se crean mediante constantes numéricas literales o como resultado de funciones y operadores internos. Las constantes literales enteras (incluidos los números hexadecimales y octales) sin aditivos generan enteros simples. Las constantes literales enteras con un sufijo "L" o "l" generan enteros largos (¡se prefiere "L" porque "1l" se parece demasiado a once!). Las constantes literales numéricas que contengan un punto decimal (formato sajón) o un exponente generan números de punto flotante. Si se termina un número en "j" o "J" se genera un número complejo.

Python tiene soporte completo para aritmética mixta: cuando un operador aritmético binario tiene operandos de tipos numéricos diferentes, el operando de tipo ``más pequeño'' se promueve al tipo del otro, donde entero es menor que entero largo, que es menor que coma flotante, que es menor que complejo. Las comparaciones entre números de diferentes tipos utilizan la misma regla^2.3. Se pueden utilizar las funciones int(), long(), float(), y complex() para forzar los números a un tipo específico.

Todos los tipos numéricos soportan las siguientes operaciones, por orden de prioridad ascendente (las operaciones que comparten casilla tienen la misma prioridad y todas las operaciones numéricas tienen una prioridad mayor que las operaciones de comparación):

Operación Resultado Notas

x + y suma de x e y
x - y resta de x e y
x * y producto de x e y
x / y cociente de x e y (1)
x % y resto de x / y
-x x negado
+x x sin cambios
abs(x) valor absoluto o magnitud de x
int(x) x convertido a entero (2)
long(x) x convertido a entero largo (2)
float(x) x convertido a coma flotante
complex(re,im) valor complejo de parte real re, y parte imaginaria im. im vale cero si no se indica.
c.conjugate() conjugado del complejo c
divmod(x, y) el par (x / y, x % y) (3)
pow(x, y) x elevado a y
x ** y x elevado a y

Operación	Resultado	Notas
`x + y`	suma de `x` e `y`
`x - y`	resta de `x` e `y`
`x * y`	producto de `x` e `y`
`x / y`	cociente de `x` e `y`	(1)
`x % y`	resto de `x / y`
`-x`	`x` negado
`+x`	`x` sin cambios
`abs(x)`	valor absoluto o magnitud de `x`
`int(x)`	`x` convertido a entero	(2)
`long(x)`	`x` convertido a entero largo	(2)
`float(x)`	`x` convertido a coma flotante
`complex(re,im)`	valor complejo de parte real `re`, y parte imaginaria `im`. `im` vale cero si no se indica.
`c.conjugate()`	conjugado del complejo `c`
`divmod(x, y)`	el par `(x / y, x % y)`	(3)
`pow(x, y)`	`x` elevado a `y`
`x ** y`	`x` elevado a `y`

Notas:

(1): En la división de enteros (normales o largos), el resultado es un entero. El resultado siempre se redondea hacia : 1/2 da 0, (-1)/2 da -1, 1/(-2) da -1 y (-1)/(-2) da 0. Hay que resaltar que el resultado es un entero largo si alguno de los operandos es un entero largo, independientemente del valor numérico.
(2): La conversión de coma flotante a entero (normal o largo) puede hacerse mediante redondeo o truncamiento, como en C. Consultar en las funciones floor() y ceil() del módulo math detalles sobre conversiones bien definidas.
(3): Ver en la sección , ``Funciones internas'' la descripción completa.

Footnotes

... regla ^2.3: Por eso la lista [1, 2] se considera igual que [1.0, 2.0] y del mismo modo para las tuplas.

Subsections

2.1.4.1 Operaciones a nivel de bit sobre enteros

Ver Sobre este documento... para obtener información sobre sugerencias.