Manipulación y conversión de tipos numéricos en Python
Resumen
Aprende a manejar números en Python con precisión: identifica tipos con type, convierte con float, int y complex, y genera aleatorios con random.randrange. Con estos fundamentos evitarás pérdidas de datos por truncado y entenderás por qué el límite superior no se incluye.
¿Qué tipos de números en Python y cómo identificarlos?
Python trabaja con enteros, flotantes y complejos. Los enteros y flotantes aceptan valores positivos y negativos, y los complejos usan la letra j para la parte imaginaria. La función type permite verificar el tipo exacto.
Enteros y flotantes: positivos y negativos.
Complejos: parte real y parte imaginaria con j.
Verificación de tipo con type.
Nombres en inglés: integer, float y complex.
# Tipos numéricos y verificación x = 1 # entero y = 2.5 # flotante z = 5 + 1j # complejo (parte real 5, parte imaginaria 1j) print(type(x)) # <class 'int'> print(type(y)) # <class 'float'> print(type(z)) # <class 'complex'>
¿Cómo se representan los complejos en Python?
La parte real se escribe normal y la imaginaria con j.
Ejemplos válidos: 5 + 1j, -5 - 1j.
Se aceptan combinaciones con signos positivos y negativos.
¿Cómo castear números sin perder datos?
El casteo obliga a una variable a comportarse como otro tipo. Pasar de entero a flotante agrega la parte decimal .0. Pasar de flotante a entero trunca el valor, lo cual puede ser riesgoso si trabajas con datos sensibles.
# Entero a flotante: agrega .0 x = 1 xf = float(x) print(type(xf)) # <class 'float'> print(xf) # 1.0 # Flotante a entero: trunca y = 2.5 ye = int(y) print(type(ye)) # <class 'int'> print(ye) # 2 # cuidado: se pierde la parte decimal
¿Qué precauciones tomar al convertir tipos?
De float a int se pierde información por truncado.
Evita castear a entero si el decimal importa.
Verifica con type antes y después del casteo.
¿Cómo trabajar con complejos y convertir desde int o float?
Se puede convertir de entero y flotante a complejo usando complex. La parte imaginaria se completa con 0j por defecto. El camino inverso (de complejo a entero o flotante) no está disponible.
La parte imaginaria agregada es 0j cuando no se especifica.
¿Cómo generar números aleatorios con random?
Para obtener números aleatorios, importa el módulo random y usa random.randrange. El límite superior no se incluye: randrange(1, 10) devuelve valores entre 1 y 9.
import random print(random.randrange(1, 10)) # entero aleatorio entre 1 y 9
¿Qué debes recordar de randrange?
Incluye el inicio, excluye el fin.
Ejecuta varias veces para ver resultados distintos.
Útil para aplicaciones como juegos que requieren aleatoriedad.
¿Te quedó alguna duda o tienes un caso de uso concreto? Cuéntalo en los comentarios y probamos el código juntos.
La función randint y randrange son parte del módulo random en Python, pero tienen diferencias clave.
randint(a, b): genera un número entero aleatorio entre a y b, incluyendo ambos extremos. Por ejemplo, randint(1, 10) puede devolver cualquier número desde 1 hasta 10.
randrange(start, stop[, step]): genera un número entero aleatorio entre start y stop, pero stop no está incluido. También puedes especificar un step para definir un intervalo. Por ejemplo, randrange(1, 10, 2) devolverá un número impar entre 1 y 9.
Ambas funciones son útiles dependiendo de cómo necesites restringir la aleatoriedad en tu código.
¡Espectacular aporte, super claro y suma al curso, gracias!
gracias por la info.
¿Cuándo se utiliza el casteo en programación?
El casteo (o casting) se usa cuando:
Hay incompatibilidad de tipos: Por ejemplo, una función espera un entero pero tienes un flotante.
Se necesita precisión o truncamiento: Convertir un decimal a entero para eliminar decimales.
Se trabaja con estructuras de datos genéricas: Como listas o arreglos que almacenan objetos de diferentes tipos.
Se realiza interoperabilidad entre lenguajes o sistemas: Por ejemplo, convertir datos entre JSON (texto) y tipos nativos como enteros o booleanos.
📌 ¿POR QUÉ EXISTEN LOS NÚMEROS COMPLEJOS? (EXPLICACIÓN CON PLASTILINA)
La forma más fácil de entender esto es aceptar una verdad incómoda:
👉 Los números normales no alcanzaban para describir el mundo real.
Los números enteros y flotantes solo viven en una línea recta:
-5 —— -2 —— 0 —— 2 —— 5
Sirven para contar cosas:
dinero
edad
cantidad
distancia en una sola dirección
Pero el mundo real no se mueve solo en línea recta.
🧠 EL PROBLEMA REAL QUE TENÍAN
Hay cosas que:
vibran
giran
suben y bajan
se adelantan y se atrasan
oscilan (como el sonido, la electricidad, las ondas)
Con números normales eso se vuelve un infierno de fórmulas.
Entonces los matemáticos dijeron:
“Necesitamos otra dimensión numérica”
🧱 LA IDEA CLAVE (PLASTILINA PURA)
En vez de una línea, imaginemos un plano:
↑
|(imaginario)|——— ———0——— ———→
||(real) ↓
eje horizontal → números normales (reales)
eje vertical → números imaginarios
Un número complejo vive en ese plano, no en una línea.
🔥 ¿QUÉ ES LA FAMOSA j?
La jNO es una letra común.
La j significa:
👉 “muévete en la dirección imaginaria”
Por definición:
j² = -1
Eso no es poesía.
Es una regla matemática fija.
z =3+2j
Eso significa:
3 → muévete 3 pasos a la derecha
2j → muévete 2 pasos hacia arriba
Resultado: un punto en el plano.
No es un número “raro”.
Es posición + dirección en un solo objeto.
⚠️ POR QUÉ NO SE PUEDE PASAR A INT O FLOAT
Pregunta clave:
¿Cómo conviertes “derecha + arriba” en solo “derecha”?
No se puede sin perder información.
Por eso Python NO permite:
int(3+2j)
Python no adivina.
Prefiere fallar que dañar datos.
🧠 ENTONCES, ¿PARA QUÉ SIRVEN?
Los números complejos existen para:
electricidad ⚡
sonido 🎧
señales 📡
gráficos 🎮
física
simulaciones
IA y procesamiento de datos
En todos esos casos importa:
cuánto
hacia dónde
en qué fase
Todo eso junto no cabe en un número normal.
🎯 FRASE FINAL PARA CERRAR (GUÁRDALA)
Los números complejos existen porque el mundo no se mueve en una sola dimensión.
No son un invento raro.
Son una solución elegante a un problema real.
Excelente información, gracias!
import random
#una especie de juego ruleta
num = random.randrange(1,21)print(f"El numero random es: {num}")if num >=15:print("WIN!!!")else:print("LOSE :(")
Me gusto el ejercicio que hiciste y te copie la idea. Así siendo principiante en Python aprendo un poco
import random
Numerogandor= random.randrange(1,21)print("Bienvenido al juego de adivinar el numero")print("tu numero es "+str(Numerogandor))ifNumerogandor==13:print("Felicidades, has ganado el juego")else:print("Lo siento, intenta de nuevo")
Porqué se usa j y no otra letra?
Python utiliza la letra j para representar la unidad imaginaria porque sigue la convención de la ingeniería eléctrica, donde se prefiere la j para evitar confusiones con la i, que suele usarse para representar la corriente.
se puede usar otra letra?
No, en Python debes usar obligatoriamente la letra j para definir la parte imaginaria de un número complejo. Si intentas usar otra letra como la "i", el intérprete no la reconocerá como un número y arrojará un error de sintaxis.
💻📢 RANDRANGE VS RANDINT
Con random y los valores vistos pude generar un juego de "La guerra" o la carta mas alta
import random as rn
#La carta mas alta:cartas =list(range(1,14))*4usuario1 = rn.choice(cartas)usuario2 = rn.choice(cartas)if usuario1 > usuario2:print("El usuario 1 gana con la carta:", usuario1," la carta del usuario2 fue", usuario2)elif usuario2 > usuario1:print("El usuario 2 gana con la carta:", usuario2," la carta del usuario1 fue", usuario1)
Buenisimo, te felicito, imagino la complejidad en que ese juego puede convertirse
Python trabaja con enteros, flotantes y complejos. Los enteros y flotantes aceptan valores positivos y negativos, y los complejos usan la letra j para la parte imaginaria. La función type permite verificar el tipo exacto.
Enteros y flotantes: positivos y negativos.
Complejos: parte real y parte imaginaria con j.
Verificación de tipo con type.
Nombres en inglés: integer, float y complex.
¿Cómo se representan los complejos en Python?
La parte real se escribe normal y la imaginaria con j.
Ejemplos válidos: 5 + 1j, -5 - 1j.
Se aceptan combinaciones con signos positivos y negativos.
¿Cómo se representan los complejos en Python?
La parte real se escribe normal y la imaginaria con j.
Ejemplos válidos: 5 + 1j, -5 - 1j.
Se aceptan combinaciones con signos positivos y negativos.
Me aventuré a crear un pequeño dado.
Al "lanzarlo", éste genera un número al azar del 1 al 6:
Una algoritmo básico para encontrar el tercer ángulo de un triángulo:
import random as rnd
ang1 = rnd.randint(1,90)ang2 = rnd.randint(1,89)TOTAL_GRADOS=180angulo_restante =TOTAL_GRADOS- ang1 - ang2
print("Ángulos generados:", ang1, ang2)print("Ángulo restante:", angulo_restante)print("TEST: Suma de ángulos = 180°:", ang1 + ang2 + angulo_restante ==TOTAL_GRADOS)
x =1y =2.5z = 1j
#Type sirve para conocer el tipo de dato de una variable
print(type(x))print(type(y))print(type(z))#El output esperado es:#<class'int'>#<class'float'>#<class'complex'>#Viene del igles "integer" que significa entero,"float" que significa flotante y "complex" que significa complejo.positivo=5.5negativo =-5.5imaginario =5+ 1j
imaginario2 =-5- 1j
xf =float(x) #Convertir el entero x a un número de punto flotante
print(xf) #Output esperado:1.0print(type(xf)) #Output esperado:<class'float'>ye =int(y) #Convertir el número de punto flotante y a un entero
print(ye) #Output esperado:2print(type(ye)) #Output esperado:<class'int'>#Nota importante:Al convertir un número de punto flotante a un entero, se pierde la parte decimal.Por ejemplo, al convertir 2.5 a un entero, el resultado es 2, no 3.Esto se debe a que la conversión a entero trunca la parte decimal en lugar de redondear.#Podemos convertir un número complejo a un número de punto flotante utilizando la función abs(), que devuelve la magnitud del número complejo.La magnitud se calcula utilizando la fórmula sqrt(real^2+ imag^2), donde real es la parte real del número complejo e imag es la parte imaginaria.magnitud=abs(imaginario) #Calcular la magnitud del número complejo
print(magnitud) #Output esperado:5.0990195135927845#Pero no podemos convertir un número complejo a un entero directamente.entero=5flotante =5.5enterocomplejo =complex(entero) #Convertir el entero a un número complejo
flotantecomplejo =complex(flotante) #Convertir el número de punto flotante a un número complejo
print(enterocomplejo) #Output esperado:(5+0j)print(type(enterocomplejo)) #Output esperado:<class'complex'>print(flotantecomplejo) #Output esperado:(5.5+0j)}print(type(flotantecomplejo)) #Output esperado:<class'complex'>#Números aleatorios
#Los números aleatorios son números que se generan de manera impredecible y sin un patrón específico.EnPython, podemos generar números aleatorios utilizando el módulo random.Este módulo proporciona varias funciones para generar números aleatorios, como random(),randint(),randrange(), entre otras.import random
print(random.randrange(1,10)) #Generar un número aleatorio entre 1 y 9(el límite superior no se incluye)
Data Types
Funcionamiento de randrange
random.randrange(stop): Genera un número entero aleatorio entre () (incluido) y stop (excluido).
random.randrange(start, stop): Genera un número entero aleatorio entre start (incluido) y stop (excluido).
random.randrange(start, stop, step): Genera un número entero aleatorio entre start (incluido) y stop (excluido), pero solo considera los números que están a un step de distancia entre sí.
Ejemplos
random.randrange(10): Devuelve un número aleatorio entre 0 y 9.
random.randrange(5, 15): Devuelve un número aleatorio entre 5 y 14.
random.randrange(0, 100, 10): Devuelve un número de la lista [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
random.randrange(5, 27, 4): Devuelve un número de la lista [5, 9, 13, 17, 21, 25]
\# ============================================================\# TYPECONVERSION(TYPECASTING)INPYTHON\# ============================================================\# Python allows converting values from one data type to another.\# This process is called "type casting" or "type conversion".
\#
\# Conversions are done using built-in functions like:
\#
\# int()\# float()\# str()\# bool()\# list()\# tuple()\# set()
\#
\# Syntax:\# new\_value = target\_type(value)
\#
\# Example:\# number =int("10")\# ============================================================\# ============================================================\# 1.CONVERTINGBETWEENNUMERICTYPES\# ============================================================\# ------------------------------------------------------------\# INT->FLOAT\# Converts a whole number into a decimal number.\# Python simply adds ".0"\# ------------------------------------------------------------integer\_number =10float\_number =float(integer\_number)print("INT to FLOAT:")print("Original:", integer\_number,type(integer\_number))print("Converted:", float\_number,type(float\_number))\# ------------------------------------------------------------\# FLOAT->INT\# Removes the decimal part(does NOT round, it truncates).\# ------------------------------------------------------------decimal\_number =9.87integer\_result =int(decimal\_number)print("\nFLOAT to INT:")print("Original:", decimal\_number,type(decimal\_number))print("Converted:", integer\_result,type(integer\_result))\# ------------------------------------------------------------\# INT->STRING\# Useful when you want to display numbers as text
\# ------------------------------------------------------------age =25age\_text =str(age)print("\nINT to STRING:")print("Original:", age,type(age))print("Converted:", age\_text,type(age\_text))\# ------------------------------------------------------------\# STRING->INT\# Works only if the string contains numeric characters
\# ------------------------------------------------------------number\_text ="100"number\_int =int(number\_text)print("\nSTRING to INT:")print("Original:", number\_text,type(number\_text))print("Converted:", number\_int,type(number\_int))\# Exampleof an INVALID conversion
\# Uncommentingthis would cause an error:
\#
\# text ="hello"\# number =int(text)
\#
\# Error:\# ValueError: invalid literal forint()\# ============================================================\# 2.CONVERTINGTOFLOAT\# ============================================================\# Strings containing decimal numbers can be converted to float
decimal\_text ="3.14"pi =float(decimal\_text)print("\nSTRING to FLOAT:")print("Original:", decimal\_text,type(decimal\_text))print("Converted:", pi,type(pi))\# ============================================================\# 3.CONVERTINGVALUESTOBOOLEAN\# ============================================================\# Boolean conversion follows specific rules.\# Python evaluates whether a value is "truthy" or "falsy".print("\nBOOLEAN CONVERSION:")print(bool(1)) # True(non-zero numbers are True)print(bool(0)) # Falseprint(bool("")) # False(empty string)print(bool("Hello")) # Trueprint(bool(\[])) # False(empty list)print(bool(\[1,2])) # True\# ============================================================\# 4.CONVERTINGBETWEENCOLLECTIONTYPES\# ============================================================\# ------------------------------------------------------------\# LIST->TUPLE\# ------------------------------------------------------------numbers\_list = \[1,2,3,4]numbers\_tuple =tuple(numbers\_list)print("\nLIST to TUPLE:")print("Original:", numbers\_list,type(numbers\_list))print("Converted:", numbers\_tuple,type(numbers\_tuple))\# ------------------------------------------------------------\# TUPLE->LIST\# ------------------------------------------------------------colors\_tuple =("red","blue","green")colors\_list =list(colors\_tuple)print("\nTUPLE to LIST:")print("Original:", colors\_tuple,type(colors\_tuple))print("Converted:", colors\_list,type(colors\_list))\# ------------------------------------------------------------\# LIST->SET\# Removes duplicate values automatically
\# ------------------------------------------------------------numbers\_with\_duplicates = \[1,2,2,3,3,4]unique\_numbers =set(numbers\_with\_duplicates)print("\nLIST to SET (removes duplicates):")print("Original:", numbers\_with\_duplicates)print("Converted:", unique\_numbers)\# ============================================================\# 5.CONVERTINGTOSTRING\# ============================================================\# Almost any data type can be converted to a string.value=500value\_str =str(value)print("\nCONVERTING TO STRING:")print("Original:", value,type(value))print("Converted:", value\_str,type(value\_str))\# Examplewith list
data = \[1,2,3]data\_str =str(data)print("\nLIST to STRING:")print(data\_str,type(data\_str))\# ============================================================\# 6.IMPORTANTNOTESABOUTTYPECONVERSION\# ============================================================\# 1.Some conversions may cause data loss.\# Example:\# float -> int removes decimal values.\# 2.Some conversions are invalid and will raise errors.\# Example:\# int("hello")\# 3.Python does not automatically convert types in many cases.\# Example:\# number =10\# text ="5"\# result = number + text # This would cause an error
\# Correct approach:number =10text ="5"result = number +int(text)print("\nExample fixing type mismatch:")print(result)\# ============================================================\# ENDOFTYPECONVERSIONEXAMPLES\# ============================================================print("\nType conversion examples completed.")
entero=5glotante =5.5enteroComplejo =complex(entero)flotanteComplejo =complex(glotante)print(enteroComplejo)print(type(enteroComplejo))print(flotanteComplejo)print(type(flotanteComplejo))#Numeros aleatorios se importa la libreria random
#Sirve para generar numero aleatorias, por ejemplo en juegos.import random
print(random.randrange(1,10)) #Output:Numero aleatorio entre 1 y 9
No puedes convertir directamente un número complejo a un tipo int o float porque los números complejos tienen una parte imaginaria que no tiene un equivalente directo en los tipos numéricos reales. Python no sabe cómo descartar o interpretar esa parte imaginaria para ajustarla a un número real.
x = 1
y = 2.5
z = 3 + 4j
print(type(x))
print(type(y)) #determina el tipo de dato
print(type(z))
positivo = 5.5
negativo = -3.2
imaginario = 2 + 3j
xf = float(x) #el flotante le agrega una parte decimal al entero
print(type(xf))
print(xf)
ye = int(y) #el entero elimina la parte decimal del flotante
print(type(ye))
print(ye)
entero = 5
flotante = 4.4
enteroComplejo = complex(entero) #convierte el entero a complejo
flotanteComplejo = complex(flotante) #convierte el flotante a complejo
print(enteroComplejo)
print(flotanteComplejo)
print(type(enteroComplejo))
print(type(flotanteComplejo))
import random
print(random.randrange(1, 10)) #genera un numero aleatorio entre 1 y 9
