Python: Tipos numéricos

Los tipos de datos numéricos en Python son inmutables, por tanto, si intentamos modificar su valor se destruirá el objeto y se creará otro nuevo con el nuevo valor.

x = 20
print (id(x))
x = 30
print (id(x))

Al ejecutar la primera vez la función id(x) obtendremos la dirección de memoria del objeto x. La segunda vez que se ejecuta obtendremos un valor distinto. Esto se debe a que hemos intentado modificar el valor del objeto (x=30), pero al tratarse de un dato numérico (inmutable) Python destruye el objeto e instancia otro con el nuevo valor, por tanto, la primera x y la segunda son objetos diferentes.

Los tipos numéricos en Python son:

  • Enteros
  • Booleans
  • Reales
  • Decimales
  • Fracciones
  • Complejos

Vamos a ver cada uno en detalle a continuación.

Tipo entero (int)

Cualquier número sin decimales positivo, negativo o 0. Este tipo no tiene límite de tamaño. El límite lo establece la memoria.

Algunos ejemplos de enteros válidos en Python son: 25, -7, 0, 3560, -54

n1 = 25
n2 = -7
n3 = 0
n4 = 3560
n5 = -54

print (type(n1))
print (type(n2))
print (type(n3))
print (type(n4))
print (type(n5))

Al ejecutar la función type() pasándole como parámetro cualquiera de los objetos declarados (n1, n2, n3, n4 o n5) obtendremos esta salida:

<class 'int'&gt;

En ningún momento hemos indicado que se trata de enteros, pero Python es capaz de determinar el tipo a partir del valor del dato. Ocurre con todos los tipos.

Tipo boolean (bool)

El tipo boolean es un tipo lógico. Sólo permite dos valores: True (verdadero) y False (falso). True y False son palabras reservadas y deben escribirse de esa forma para poder ser utilizadas como valores boolean.

a = True
b = False
print (type(a))
print (type(b))

Al ejecutar la función type() pasándole como parámetro los objetos a o b obtendremos este resulado:

<class 'bool'&gt;

Es un subtipo del tipo entero, por lo que podremos hacer conversiones entre ambos teniendo en cuenta esta equivalencia:

  • True: Cualquier entero distinto de 0
  • False: 0
x = 20
y = 0
a = bool(x)
b = bool(y)

La función bool() convierte el dato entero que recibe como parámetro a boolean.

El objeto a será de tipo boolean y tomará valor True puesto que x es un dato entero y tiene valor distinto de 0.

En el caso de b, también será de tipo boolean, pero tomará valor False ya que y tiene valor 0.

La conversión también se puede hacer en sentido inverso:

a = True
b = False
x = int(a)
y = int(b)

En este caso se utiliza la función int() para hacer la conversión de boolean a entero. El valor True siempre se convierte a 1 y el valor False a 0. Por tanto, x tomará valor 1 e y tomará valor 0.

Tipo real (float)

El tipo real representa los datos con punto flotante, es decir, con decimales. Están compuestos de signo, exponente y mantisa (mantisa * 10^exp) y ocupan 64 bits en memoria.

Algunos ejemplos de reales válidos en Python son: 7.0, 3.1416, -3.4, 0.1e-3

n = 7.0
pi = 3.1416
x = -3.4
a = 0.1e-3

print(type(n))
print(type(pi))
print(type(x))
print(type(a))

El resultado de ejecutar la función type con los objetos del ejemplo (pi, x o a) es:

<class 'float'&gt;

Tipo decimal (Decimal)

Este tipo de dato también permite trabajar con punto flotante, pero aporta mayor precisión. Es interesante su uso cuando trabajamos con datos que sean sensibles a perdida de precisión en la parte decimal, como por ejemplo dinero.

Para poder utilizarlo es necesario importarlo añadiendo la siguiente instrucción al principio del código:

from decimal import Decimal

Los objetos de este tipo se instancian usando la función Decimal(‘valor punto flotante’) a la que se le pasa un valor en punto flotante encerrado entre comillas.

x = Decimal('3.76')
print(type(x)

La ejecución de la función type(), en este caso, nos devolverá:

<class 'decimal.Decimal'&gt;

Tipo fracción (Fraction)

Este tipo representa fracciones compuestas por numerador y denominador (num/deno).

Algunos ejemplos de fracciones válidas son: 10/6, 7/2, 20/14

Para poder utilizarlo es imprescindible importarlo en la parte superior del código:

from fractions import Fraction

Los objetos de tipo fracción se instancian utilizando la función Fraction(n,d) que recibe como parámetros el numerador y el denominador separados con una coma.

f = Fraction (5,7)
print(type(f))

En el ejemplo 5 es el numerador y 7 el denominador, por tanto, la fracción sería 5/7.

La ejecución de la función type() con este tipo de dato devuelve:

<class 'fractions.Fraction'&gt;

Este tipo siempre almacena el mínimo término que es calculado de forma automática.

x = Fraction(12,6)
print(x.numerator)
print(x.denominator)

Podemos acceder de forma independiente al numerador y al denominador usando los atributos numerator y denominator respectivamente. En el ejemplo x.numerator devolverá 2 y x.denominator devolverá 1 puesto que se ha calculado el mínimo termino.

Tipo complejo (complex)

Python también dispone de un tipo de dato especifico para trabajar con datos de tipo complejo, es decir, datos compuestos por una parte real y otra imaginaria (a + bj, a: parte real, b: parte imaginaria terminada en j).

Algunos datos válidos en Python de este tipo son: 4+3j, 6.3+6j

c1 = (4 + 3j)
c2 = (6.3 + 6j)
print(type(c1))
print(type(c2))

La ejecución de la función type() devuelve esto:

<class 'complex'&gt;

Los objetos de este tipo tienen dos atributos, real e imag, que nos permiten acceder por separado a la parte real y a la parte imaginaria respectivamente. Ambos son de tipo punto flotante.

c = (4 + 3j)
print(c.real)
print(c.imag)

La salida de este ejemplo será 4.0 para c.real y 3.0 para c.imag.

0 comentarios sobre “Python: Tipos numéricos

Agrega el tuyo

Deja una respuesta

Subir ↑