Números de Python, conversión de tipos y matemáticas

Números de Python, conversión de tipos y matemáticas

En este artículo, aprenderá sobre los diferentes números utilizados en Python, cómo convertir de un tipo de datos a otro y las operaciones matemáticas admitidas en Python.

Tipo de datos numéricos en Python

Python admite números enteros, números de coma flotante y números complejos. Se definen como int , float y complex clases en Python.

Los números enteros y los puntos flotantes están separados por la presencia o ausencia de un punto decimal. Por ejemplo, 5 es un número entero mientras que 5.0 es un número de coma flotante.

Los números complejos se escriben en la forma, x + yj , donde x es la parte real y y es la parte imaginaria.

Podemos usar el type() función para saber a qué clase pertenece una variable o un valor y isinstance() función para verificar si pertenece a una clase en particular.

Veamos un ejemplo:

a = 5

print(type(a))

print(type(5.0))

c = 5 + 3j
print(c + 3)

print(isinstance(c, complex))

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado:

<class 'int'>
<class 'float'>
(8+3j)
True

Si bien los números enteros pueden tener cualquier longitud, un número de punto flotante es preciso solo hasta 15 lugares decimales (el lugar 16 es inexacto).

Los números con los que tratamos todos los días son del sistema numérico decimal (base 10). Pero los programadores de computadoras (generalmente programadores integrados) necesitan trabajar con sistemas numéricos binarios (base 2), hexadecimales (base 16) y octales (base 8).

En Python, podemos representar estos números colocando adecuadamente un prefijo antes de ese número. La siguiente tabla enumera estos prefijos.

Sistema numérico	Prefijo
Binario	'0b' o '0B'
Octubre	'0o' o '0O'
Hexadecimal	'0x' o '0X'

Aquí hay algunos ejemplos

# Output: 107
print(0b1101011)

# Output: 253 (251 + 2)
print(0xFB + 0b10)

# Output: 13
print(0o15)

Cuando ejecute el programa, la salida será:

107
253
13

---

Conversión de tipo

Podemos convertir un tipo de número en otro. Esto también se conoce como coerción.

Operaciones como la suma y la resta obligan a los números enteros a flotar implícitamente (automáticamente), si uno de los operandos es flotante.

>>> 1 + 2.0
3.0

Podemos ver arriba que 1 (entero) se convierte en 1.0 (flotante) para sumar y el resultado también es un número de punto flotante.

También podemos usar funciones integradas como int() , float() y complex() para convertir entre tipos explícitamente. Estas funciones pueden incluso convertir cadenas.

>>> int(2.3)
2
>>> int(-2.8)
-2
>>> float(5)
5.0
>>> complex('3+5j')
(3+5j)

Al convertir de flotante a entero, el número se trunca (se eliminan las partes decimales).

---

Decimal Python

La clase flotante integrada de Python realiza algunos cálculos que pueden sorprendernos. Todos sabemos que la suma de 1.1 y 2.2 es 3.3, pero parece que Python no está de acuerdo.

>>> (1.1 + 2.2) == 3.3
False

¿Qué está pasando?

Resulta que los números de coma flotante se implementan en el hardware de la computadora como fracciones binarias, ya que la computadora solo entiende binario (0 y 1). Por esta razón, la mayoría de las fracciones decimales que conocemos no se pueden almacenar con precisión en nuestra computadora.

Tomemos un ejemplo. No podemos representar la fracción 1/3 como un número decimal. Esto dará 0,33333333... que es infinitamente largo y solo podemos aproximarlo.

Resulta que la fracción decimal 0.1 dará como resultado una fracción binaria infinitamente larga de 0.000110011001100110011... y nuestra computadora solo almacena un número finito.

Esto solo se aproximará a 0.1 pero nunca será igual. Por lo tanto, es la limitación del hardware de nuestra computadora y no un error en Python.

>>> 1.1 + 2.2
3.3000000000000003

Para superar este problema, podemos usar el módulo decimal que viene con Python. Mientras que los números de punto flotante tienen una precisión de hasta 15 lugares decimales, el módulo decimal tiene una precisión configurable por el usuario.

Veamos la diferencia:

import decimal

print(0.1)

print(decimal.Decimal(0.1))

Salida

0.1
0.1000000000000000055511151231257827021181583404541015625

Este módulo se utiliza cuando queremos realizar cálculos decimales como aprendimos en la escuela.

También conserva el significado. Sabemos que 25,50 kg es más preciso que 25,5 kg, ya que tiene dos decimales significativos en comparación con uno.

from decimal import Decimal as D

print(D('1.1') + D('2.2'))

print(D('1.2') * D('2.50'))

Salida

3.3
3.000

Observe los ceros finales en el ejemplo anterior.

Podríamos preguntar, ¿por qué no implementar Decimal? cada vez, en lugar de flotar? La razón principal es la eficiencia. Las operaciones de punto flotante se llevan a cabo más rápido que Decimal operaciones.

¿Cuándo usar Decimal en lugar de float?

Generalmente usamos Decimal en los siguientes casos.

• Cuando estamos haciendo aplicaciones financieras que necesitan una representación decimal exacta.
• Cuando queremos controlar el nivel de precisión requerido.
• Cuando queremos implementar la noción de lugares decimales significativos.

---

Fracciones de Python

Python proporciona operaciones que involucran números fraccionarios a través de su fractions módulo.

Una fracción tiene un numerador y un denominador, los cuales son números enteros. Este módulo es compatible con la aritmética de números racionales.

Podemos crear objetos Fraction de varias maneras. Vamos a echarles un vistazo.

import fractions

print(fractions.Fraction(1.5))

print(fractions.Fraction(5))

print(fractions.Fraction(1,3))

Salida

3/2
5
1/3

Al crear Fraction de float , podríamos obtener algunos resultados inusuales. Esto se debe a la representación imperfecta de los números binarios de coma flotante, como se explicó en la sección anterior.

Afortunadamente, Fraction nos permite instanciar con una cadena también. Esta es la opción preferida cuando se usan números decimales.

import fractions

# As float
# Output: 2476979795053773/2251799813685248
print(fractions.Fraction(1.1))

# As string
# Output: 11/10
print(fractions.Fraction('1.1'))

Salida

2476979795053773/2251799813685248
11/10

Este tipo de datos admite todas las operaciones básicas. Estos son algunos ejemplos.

from fractions import Fraction as F

print(F(1, 3) + F(1, 3))

print(1 / F(5, 6))

print(F(-3, 10) > 0)

print(F(-3, 10) < 0)

Salida

2/3
6/5
False
True

---

Python Matemáticas

Python ofrece módulos como math y random para realizar distintas operaciones matemáticas como trigonometría, logaritmos, probabilidad y estadística, etc.

import math

print(math.pi)

print(math.cos(math.pi))

print(math.exp(10))

print(math.log10(1000))

print(math.sinh(1))

print(math.factorial(6))

Salida

3.141592653589793
-1.0
22026.465794806718
3.0
1.1752011936438014
720

Aquí está la lista completa de funciones y atributos disponibles en el módulo matemático de Python.

import random

print(random.randrange(10, 20))

x = ['a', 'b', 'c', 'd', 'e']

# Get random choice
print(random.choice(x))

# Shuffle x
random.shuffle(x)

# Print the shuffled x
print(x)

# Print random element
print(random.random())

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado. (Los valores pueden ser diferentes debido al comportamiento aleatorio)

18
e
['c', 'e', 'd', 'b', 'a']
0.5682821194654443

Aquí está la lista completa de funciones y atributos disponibles en el módulo aleatorio de Python.