🔢 Parte 1 — Números en Python (int, float, complex, etc.)

Los números son uno de los tipos de datos más utilizados en Python. Representan valores con los que puedes realizar cálculos, desde operaciones básicas hasta fórmulas científicas avanzadas.
Imagina los números como el lenguaje de las matemáticas dentro de tu código.

📊 Tipos numéricos en Python

Python maneja tres tipos principales de números:

💡 Ejemplos básicos de uso

Vamos a crear variables numéricas y observar su tipo con la función integrada type():

# Ejemplo básico
entero = 10
decimal = 3.14
complejo = 2 + 3j

print(type(entero))    # 
print(type(decimal))   # 
print(type(complejo))  # 

Python detecta automáticamente el tipo de número según su formato.
Esto se conoce como tipado dinámico: no necesitas declarar el tipo antes de usarlo.

📏 Números enteros (int)

Los enteros representan cantidades exactas sin decimales, como edades, objetos contados o años.

edad = 25
temperatura_bajo_cero = -10
poblacion_mundial = 8_000_000_000  # Los guiones bajos mejoran la legibilidad

En Python 3, los enteros no tienen límite de tamaño: pueden ser tan grandes como permita la memoria de tu ordenador.

numero_grande = 123456789012345678901234567890
print(numero_grande + 1)

Python manejará el cálculo sin problema. Esta flexibilidad lo diferencia de otros lenguajes como C o Java.

📐 Números decimales (float)

Los flotantes representan números con parte decimal, ideales para cálculos científicos, precios o mediciones.

altura = 1.75
pi = 3.14159
temperatura = 36.6

Ten en cuenta que los valores flotantes pueden tener ligeras imprecisiones debido a cómo los almacena la memoria del ordenador:

resultado = 0.1 + 0.2
print(resultado)  # 0.30000000000000004

🔎 Para comparar flotantes de forma segura, usa el módulo math:

import math

print(math.isclose(0.1 + 0.2, 0.3))  # True

⚛️ Números complejos (complex)

Los números complejos tienen una parte real y otra imaginaria, separadas por la letra j (como en matemáticas, donde se usa i).

numero = 3 + 4j
print(numero.real)  # Parte real: 3.0
print(numero.imag)  # Parte imaginaria: 4.0

Se usan en áreas como procesamiento de señales, simulaciones eléctricas y gráficos 3D.

🧮 Operaciones básicas con números

Python soporta todas las operaciones aritméticas comunes:

Ejemplo completo:

a = 7
b = 2
print(a + b)  # 9
print(a - b)  # 5
print(a * b)  # 14
print(a / b)  # 3.5
print(a // b) # 3
print(a % b)  # 1
print(a ** b) # 49

🧠 Funciones numéricas útiles

Python ofrece funciones integradas muy útiles para cálculos rápidos:

valor_absoluto = abs(-10)       # 10
redondeo = round(3.7)           # 4
redondeo_decimal = round(3.14159, 2)  # 3.14

Y con el módulo math, puedes acceder a muchas más:

import math

raiz = math.sqrt(16)          # 4.0
seno = math.sin(math.pi/2)    # 1.0
logaritmo = math.log10(100)   # 2.0

🧩 Conversión entre tipos numéricos

Python te permite convertir entre tipos numéricos fácilmente:

# De float a int (trunca el decimal)
numero = int(25.9)     # 25

# De int a float
decimal = float(25)     # 25.0

# De texto a número
edad = int("42")
precio = float("19.99")

También puedes realizar conversiones entre distintas bases numéricas:

# Binario (base 2)
binario = 0b1010  # 10 en decimal

# Octal (base 8)
octal = 0o17      # 15 en decimal

# Hexadecimal (base 16)
hexadecimal = 0xFF  # 255 en decimal

print(binario, octal, hexadecimal)

Y convertir de decimal a otras bases:

print(bin(10))  # '0b1010'
print(oct(15))  # '0o17'
print(hex(255)) # '0xff'

🎲 Números aleatorios

El módulo random permite generar números aleatorios para juegos, simulaciones o pruebas.

import random

# Número entero aleatorio entre 1 y 6 (como un dado)
dado = random.randint(1, 6)
print("Lanzamiento del dado:", dado)

# Número decimal aleatorio entre 0 y 1
probabilidad = random.random()
print("Probabilidad:", probabilidad)

# Elegir un elemento al azar de una lista
carta = random.choice(["A", "K", "Q", "J", 10])
print("Carta seleccionada:", carta)

🏁 Conclusión

Los números son la base de la programación en Python.
Dominar los tipos int, float y complex te permitirá realizar cálculos, procesar datos y automatizar tareas numéricas de cualquier nivel.
En la siguiente parte exploraremos el segundo tipo fundamental del lenguaje: las cadenas de texto (str), una herramienta esencial para procesar información escrita.

💬 Parte 2 — Cadenas (str): concatenación, slicing y métodos comunes

En Python, el texto se maneja con el tipo de dato str (cadena de caracteres).
Las cadenas son uno de los tipos más usados, ya que te permiten trabajar con nombres, mensajes, rutas de archivos, datos de usuario, etc.
Piensa en una cadena como una secuencia ordenada de letras, números y símbolos.

📝 Crear cadenas de texto

Puedes crear cadenas utilizando comillas simples, dobles o triples:

# Comillas simples
nombre = 'Javier'

# Comillas dobles
saludo = "Hola, ¿cómo estás?"

# Comillas triples: texto multilínea
descripcion = """Este es un texto
que ocupa varias
líneas"""

✅ Las comillas triples (''' o """) son útiles para escribir párrafos, documentación o cadenas largas con saltos de línea.

🔢 Acceso a caracteres (indexación)

Cada carácter dentro de una cadena tiene una posición (índice), empezando desde el 0.

palabra = "Python"

print(palabra[0])  # 'P' → primer carácter
print(palabra[1])  # 'y'
print(palabra[-1]) # 'n' → último carácter

✂️ Subcadenas (slicing)

Puedes extraer partes de una cadena usando la sintaxis:

cadena[inicio:fin:paso]

Ejemplos prácticos:

texto = "Programación"

print(texto[0:4])    # 'Prog'
print(texto[5:])     # 'amación'
print(texto[:6])     # 'Progra'
print(texto[::2])    # 'Pormcó' (toma uno sí y uno no)
print(texto[::-1])   # 'nóicamargorP' (invierte la cadena)

Este mecanismo es extremadamente útil para procesar y analizar texto.

➕ Concatenación y repetición

Python te permite unir cadenas fácilmente con el operador + y repetirlas con *:

nombre = "Javier"
mensaje = "Hola, " + nombre + "!"
print(mensaje)  # "Hola, Javier!"

repetir = "eco " * 3
print(repetir)  # "eco eco eco "

⚠️ Ojo: solo puedes concatenar cadenas con cadenas, no con números directamente.

# Esto da error:
# print("Edad: " + 30)

# Solución correcta:
print("Edad: " + str(30))

📏 Longitud de una cadena

Para saber cuántos caracteres tiene una cadena, usa la función len():

frase = "Aprendiendo Python"
print(len(frase))  # 18

🧰 Métodos más comunes de las cadenas

Las cadenas tienen muchos métodos incorporados que permiten transformarlas y analizarlas fácilmente.
Veamos los más útiles con ejemplos:

texto = "  Python es genial  "
print(texto.strip())       # "Python es genial"
print(texto.upper())       # "  PYTHON ES GENIAL  "
print(texto.lower())       # "  python es genial  "
print(texto.replace("genial", "increíble"))  # "  Python es increíble  "

🔍 Búsqueda y verificación en cadenas

Puedes buscar texto dentro de una cadena y comprobar su contenido con operadores y métodos específicos:

frase = "Aprender Python es divertido"

print("Python" in frase)   # True
print("Java" in frase)     # False
print(frase.find("Python"))  # 9 (posición inicial)
print(frase.count("e"))      # 4

🧩 Formateo de cadenas

Existen varias formas de insertar variables dentro de un texto.

1️⃣ F-strings (forma moderna y recomendada)

nombre = "Lucía"
edad = 25
print(f"Hola, me llamo {nombre} y tengo {edad} años.")

Incluso puedes realizar operaciones dentro de las llaves:

precio = 19.99
print(f"Precio con IVA: {precio * 1.21:.2f}€")  # "Precio con IVA: 24.19€"

2️⃣ Método format()

nombre = "Carlos"
edad = 30
print("Hola, me llamo {} y tengo {} años".format(nombre, edad))

3️⃣ Estilo clásico con %

nombre = "Ana"
edad = 22
print("Hola, me llamo %s y tengo %d años" % (nombre, edad))

✨ Caracteres especiales y secuencias de escape

Para escribir caracteres especiales dentro de cadenas, se usan las llamadas secuencias de escape:

print("Primera línea\nSegunda línea")   # Salto de línea
print("Nombre:\tJavier")                # Tabulación
print("Ella dijo: \"Hola\"")            # Comillas dobles dentro de comillas
print('Ruta: C:\\Usuarios\\Javier')     # Barra invertida

Raw Strings (cadenas sin procesar)

Si no quieres que las secuencias de escape se interpreten, añade una r antes de la cadena:

print(r"C:\nuevos\archivos")
# Muestra literalmente: C:\nuevos\archivos

🔄 Conversión entre tipos

Puedes convertir números y booleanos a texto, y viceversa:

# De número a texto
edad = 25
texto = str(edad)   # "25"

# De texto a número
numero = int("42")  # 42
decimal = float("3.14")  # 3.14

Estas conversiones son muy comunes cuando trabajas con entrada de usuario o datos externos.

🏁 Conclusión

Las cadenas son el corazón de la programación práctica en Python.
Dominar su manipulación te permitirá crear interfaces, procesar datos y comunicar resultados de forma clara.

En la siguiente parte exploraremos los valores booleanos (bool), esenciales para la lógica y el control de flujo en tus programas.

✅ Parte 3 — Booleanos (bool) y valores de verdad

El tipo booleano representa dos estados: True y False. Es la base de la lógica en condiciones, bucles y validaciones.

🧱 Valores booleanos básicos

esta_lloviendo = True
es_fin_de_semana = False
print(type(esta_lloviendo))  # <class 'bool'>

Los booleanos suelen surgir de comparaciones:

edad = 18
print(edad >= 18)  # True
print(5 == 10)     # False
print(3 != 4)      # True

🔗 Operadores lógicos: and, or, not

edad = 25
tiene_licencia = True
print(edad >= 18 and tiene_licencia)  # True
print(edad < 18 or tiene_licencia)    # True
print(not (edad >= 18))               # False

Estas tablas coinciden con el comportamiento estándar de Python y son la base de tus condiciones.

⚡ Evaluación en cortocircuito

Python deja de evaluar cuando ya conoce el resultado: ahorra trabajo y evita errores.

# 'and' se corta si la izquierda es False
x = 0
seguro = (x != 0) and (10 / x > 2)   # No intenta dividir por cero

# 'or' se corta si la izquierda es True
token = "ABC123"
ok = (token is not None) or validar_token_lento(token)  # No llama si ya es True

🧠 Truthiness: qué valores cuentan como True/False

En contextos lógicos, ciertos valores “equivalen” a False: False, None, 0, "", colecciones vacías ([], (), {}, set()). Todo lo demás se evalúa como True.

if "Hola":        # cadena no vacía ⇒ True
    print("Saludo presente")

if []:            # lista vacía ⇒ False
    print("No se imprime")

Esto permite escribir condiciones más limpias:

nombre = ""
if nombre:                    # En lugar de if len(nombre) > 0:
    print("Hola,", nombre)
else:
    print("Nombre no proporcionado")

🧩 Igualdad vs identidad (== vs is)

== compara valores; is compara si son el mismo objeto en memoria.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True  (mismo contenido)
print(a is b)  # False (objetos distintos)
print(a is c)  # True  (misma referencia)

Convención común: para comparar con None, usa is / is not:

resultado = obtener_dato()
if resultado is None:
    print("Sin datos")

🧮 Funciones útiles: all() y any()

all(iterable) es True si todos los elementos son verdaderos; any(iterable) si alguno lo es.

numeros = [2, 4, 6, 8]
print(all(n % 2 == 0 for n in numeros))   # True
print(any(n > 5 for n in numeros))        # True

🔁 Booleanos en control de flujo

edad = 17
if edad >= 18:
    print("Mayor de edad")
else:
    print("Menor de edad")

# Operador ternario
puntuacion = 73
estado = "aprobado" if puntuacion >= 60 else "suspendido"
print(estado)

🔄 Conversión explícita a bool

print(bool(0))          # False
print(bool(42))         # True
print(bool(""))         # False
print(bool("Hola"))     # True
print(bool([]))         # False
print(bool([1, 2, 3]))  # True

🛡️ Mini-patrones seguros (anti-bugs)

• Evita divisiones inseguras: divisor != 0 and (10 / divisor) > 2 (cortocircuito).
• Comprueba existencia de datos: if items: mejor que if len(items) > 0:.
• None seguro: if valor is None: en lugar de == None.

🧪 Ejercicios rápidos

1. Crea una función es_par(n) que devuelva True si n es par y False si no, y úsala para imprimir “OK” si all() confirma que todos los números de una lista son pares.
2. Escribe una condición con and/or que permita entrar a un sitio si el usuario tiene suscripcion_activa o pase_invitado, y no está baneado.
3. Simula un login: si usuario es cadena no vacía y password no es None, imprime “Acceso concedido”; si no, “Acceso denegado”.

🏁 Conclusión

Con los booleanos dominas la toma de decisiones en Python: comparaciones, operadores lógicos, truthiness, cortocircuito y patrones seguros. En la próxima parte verás cómo convertir entre tipos (casting) de manera explícita y segura para enlazar entradas de usuario, números y texto.

🔄 Parte 4 — Conversión entre tipos (casting)

En Python, cada valor tiene un tipo de dato: número, cadena, booleano, lista, etc.
La conversión de tipos (también llamada casting) permite transformar un valor de un tipo a otro de manera explícita o implícita.
Es una habilidad clave para evitar errores y garantizar que las operaciones se realicen correctamente.

🧠 Conceptos básicos

Existen dos tipos de conversión en Python:

🤖 Conversión implícita

Python convierte automáticamente los tipos cuando no hay riesgo de pérdida de información.

entero = 5
decimal = 2.0

resultado = entero + decimal
print(resultado)        # 7.0
print(type(resultado))  # <class 'float'>

Aquí, Python convierte entero a float para que el resultado sea preciso.

⚠️ No todas las conversiones implícitas son posibles:
Si intentas sumar un número y una cadena, obtendrás un error:

# ❌ Error
numero = 10
texto = "20"
print(numero + texto)  # TypeError: unsupported operand types

🧩 Conversión explícita (casting manual)

Cuando Python no puede adivinar lo que quieres, debes convertir el tipo manualmente usando funciones integradas.

🔹 Funciones de conversión más comunes:

📦 Ejemplos prácticos de casting

1️⃣ De número a cadena

edad = 30
mensaje = "Tienes " + str(edad) + " años."
print(mensaje)

➡️ Si no conviertes edad a texto, Python mostrará un error.

2️⃣ De cadena a número

texto = "42"
numero = int(texto)
print(numero * 2)  # 84

Si la cadena no representa un número válido, se lanzará un ValueError:

# ❌ Error:
numero = int("hola")

3️⃣ De booleano a número

print(int(True))   # 1
print(int(False))  # 0

Esta conversión es útil al contar valores verdaderos en listas:

respuestas = [True, False, True, True]
total = sum(respuestas)
print("Respuestas afirmativas:", total)

4️⃣ De número a booleano

print(bool(0))      # False
print(bool(5))      # True
print(bool(-3))     # True

Cualquier número distinto de 0 se considera True.

5️⃣ De lista o colección a cadena

colores = ["rojo", "verde", "azul"]
texto = ", ".join(colores)
print(texto)  # "rojo, verde, azul"

También puedes convertir texto separado por comas en lista:

datos = "uno,dos,tres"
lista = datos.split(",")
print(lista)  # ['uno', 'dos', 'tres']

🧮 Conversión entre tipos numéricos

Python te permite convertir fácilmente entre int, float y complex.

a = 10
b = float(a)
c = complex(a)

print(b)  # 10.0
print(c)  # (10+0j)

⚠️ Pero no puedes convertir directamente un número complejo a real o entero:

# ❌ Error
x = complex(3, 4)
print(int(x))  # TypeError

🧰 Conversión con colecciones

Las colecciones (listas, tuplas, conjuntos) también pueden convertirse entre sí:

tupla = (1, 2, 3)
lista = list(tupla)
conjunto = set(lista)

print(lista)     # [1, 2, 3]
print(conjunto)  # {1, 2, 3}

Esto es muy útil cuando necesitas eliminar duplicados o cambiar estructuras:

# Eliminar duplicados con casting a set
nombres = ["Ana", "Luis", "Ana", "Carlos"]
nombres_unicos = list(set(nombres))
print(nombres_unicos)

⚙️ Conversión segura con comprobaciones

Antes de convertir cadenas a números, conviene comprobar si el texto es numérico para evitar errores:

valor = "123"

if valor.isdigit():
    numero = int(valor)
    print("Número convertido:", numero)
else:
    print("No es un número válido")

También puedes capturar errores con try/except:

texto = "3.14"
try:
    numero = float(texto)
    print("Número:", numero)
except ValueError:
    print("Error: el texto no es numérico.")

🧠 Casting dentro de expresiones

Python permite hacer conversiones dentro de operaciones o condicionales:

edad = "18"
if int(edad) >= 18:
    print("Acceso permitido")

O al trabajar con entrada de usuario:

# Entrada de usuario siempre es str
edad = input("Introduce tu edad: ")
if int(edad) >= 18:
    print("Eres mayor de edad")
else:
    print("Aún no puedes votar")

📊 Resumen general de conversiones

🧩 Ejemplo integrador

Veamos un pequeño programa que combina varios tipos y conversiones:

# Mini calculadora con entrada de texto
print("=== Calculadora Simple ===")
a = input("Número 1: ")
b = input("Número 2: ")

if a.replace('.', '', 1).isdigit() and b.replace('.', '', 1).isdigit():
    a = float(a)
    b = float(b)
    print(f"Suma: {a + b}")
    print(f"Resta: {a - b}")
    print(f"Multiplicación: {a * b}")
    print(f"División: {a / b:.2f}")
else:
    print("Por favor, ingresa solo números válidos.")

✅ Este ejemplo muestra cómo validar, convertir y operar valores ingresados por el usuario sin errores.

🏁 Conclusión

La conversión de tipos es esencial para conectar distintas partes de un programa:
entradas de usuario (texto), cálculos (números) y resultados (cadenas).

Ahora que conoces los fundamentos de int, float, str y bool, puedes manipular información de manera precisa y segura.

En la siguiente parte realizaremos un resumen práctico de todos los tipos de datos fundamentales, con ejercicios guiados e integradores para consolidar lo aprendido.

🧩 Parte 5 — Ejemplos prácticos y ejercicios integradores

Hemos visto los cuatro pilares de los tipos de datos fundamentales en Python:
números, cadenas, booleanos y conversiones.
Ahora vamos a ponerlos en práctica con ejemplos y ejercicios que te ayudarán a pensar como programador.

⚙️ Ejemplo 1 — Calculadora básica interactiva

Un clásico para practicar números, entrada de usuario y casting.

print("=== Calculadora Básica ===")

a = input("Introduce el primer número: ")
b = input("Introduce el segundo número: ")

# Validar que sean numéricos
if a.replace('.', '', 1).isdigit() and b.replace('.', '', 1).isdigit():
    a = float(a)
    b = float(b)
    print(f"Suma: {a + b}")
    print(f"Resta: {a - b}")
    print(f"Multiplicación: {a * b}")
    print(f"División: {a / b:.2f}")
else:
    print("Error: ingresa solo números válidos.")

✅ Conceptos aplicados: casting, validación booleana, uso de if y operaciones numéricas.

🧠 Ejemplo 2 — Evaluador de contraseñas

En este ejercicio trabajamos con str y bool.

print("=== Evaluador de Contraseñas ===")
password = input("Introduce tu contraseña: ")

# Verificación básica
tiene_mayus = any(c.isupper() for c in password)
tiene_minus = any(c.islower() for c in password)
tiene_num = any(c.isdigit() for c in password)
longitud_ok = len(password) >= 8

segura = all([tiene_mayus, tiene_minus, tiene_num, longitud_ok])

if segura:
    print("✅ Contraseña segura.")
else:
    print("⚠️ Tu contraseña debe tener al menos 8 caracteres, una mayúscula, una minúscula y un número.")

✅ Conceptos aplicados: len(), métodos de cadena, operadores lógicos y all().

💡 Ejemplo 3 — Conversión de temperatura

Ejercicio clásico de conversión entre unidades.

print("=== Conversor de Temperaturas ===")

celsius = input("Introduce la temperatura en °C: ")

if celsius.replace('.', '', 1).isdigit():
    celsius = float(celsius)
    fahrenheit = (celsius * 9/5) + 32
    kelvin = celsius + 273.15
    print(f"{celsius}°C = {fahrenheit:.2f}°F = {kelvin:.2f}K")
else:
    print("Valor no válido.")

✅ Conceptos aplicados: casting, aritmética de float, formateo de cadenas y condicionales.

🔢 Ejemplo 4 — Clasificador de números

Analiza si un número es positivo, negativo, par o impar.

print("=== Clasificador de Números ===")

n = input("Introduce un número entero: ")

if n.lstrip('-').isdigit():
    n = int(n)
    if n == 0:
        print("El número es cero.")
    else:
        print("El número es positivo." if n > 0 else "El número es negativo.")
        print("Es par." if n % 2 == 0 else "Es impar.")
else:
    print("Por favor, ingresa un número entero válido.")

✅ Conceptos aplicados: conversión str → int, operadores aritméticos, if anidados y ternarios.

📜 Ejemplo 5 — Procesador de texto simple

Demuestra el poder de los métodos de str.

print("=== Procesador de Texto ===")

texto = input("Escribe una frase: ")

print("Longitud:", len(texto))
print("Mayúsculas:", texto.upper())
print("Minúsculas:", texto.lower())
print("Primera letra:", texto[0])
print("Última letra:", texto[-1])
print("Palabras:", texto.split())
print("¿Contiene 'Python'?", "Python" in texto)

✅ Conceptos aplicados: métodos de cadena, slicing, operadores in, y funciones integradas.

🎲 Ejemplo 6 — Simulador de dado y validación lógica

Ejemplo con bool, int y el módulo random.

import random

print("=== Lanzamiento de Dado ===")

cara = random.randint(1, 6)
print(f"Salió el número {cara}")

# Evaluación booleana
es_ganador = cara == 6
print("🎉 ¡Ganaste!" if es_ganador else "Inténtalo de nuevo.")

✅ Conceptos aplicados: generación aleatoria, comparación, operadores lógicos y formato condicional.

🧮 Ejemplo 7 — Promedio de notas

Ejemplo realista combinando listas, números y casting.

print("=== Promedio de Notas ===")

notas_texto = input("Introduce las notas separadas por comas: ")
notas_lista = [float(n) for n in notas_texto.split(",")]

promedio = sum(notas_lista) / len(notas_lista)
print(f"Promedio final: {promedio:.2f}")

if promedio >= 5:
    print("✅ Aprobado")
else:
    print("❌ Suspendido")

✅ Conceptos aplicados: casting en listas por comprensión, operaciones con sum() y len(), condicionales booleanos.

💬 Ejemplo 8 — Chat automatizado simple

Un ejemplo divertido que combina cadenas y lógica booleana.

print("=== Chat Automatizado ===")

mensaje = input("Tú: ")

if "hola" in mensaje.lower():
    print("Bot: ¡Hola! ¿Cómo estás?")
elif "adiós" in mensaje.lower():
    print("Bot: Hasta pronto 👋")
else:
    print("Bot: No entiendo tu mensaje.")

✅ Conceptos aplicados: uso de in, métodos lower(), elif y control de flujo lógico.

💻 Mini-proyecto final — Analizador de datos personales

Combina todos los tipos fundamentales en un pequeño script interactivo:

print("=== Analizador de Datos Personales ===")

nombre = input("Nombre: ")
edad = input("Edad: ")
altura = input("Altura (en metros): ")

# Validación
if edad.isdigit() and altura.replace('.', '', 1).isdigit():
    edad = int(edad)
    altura = float(altura)

    print(f"\n👤 {nombre}, {edad} años, {altura} m de altura")
    print("Mayor de edad:", edad >= 18)
    print("Altura en centímetros:", int(altura * 100))
else:
    print("Error: datos no válidos.")

✅ Conceptos integrados: input(), casting, operadores lógicos, condiciones booleanas y formateo de texto.

📚 Tabla de repaso rápido

🧩 Ejercicios propuestos

1. 💰 Pide al usuario el precio y el descuento de un producto, calcula el precio final y muéstralo con dos decimales.
2. 🔤 Solicita una palabra e indica si es palíndromo (se lee igual al derecho y al revés).
3. 🎯 Crea un programa que pida tres números y determine el mayor usando operadores lógicos.
4. 📏 Convierte una distancia en kilómetros a millas (1 km = 0.62137 millas).
5. 🔢 Dada una cadena con números separados por espacios, conviértela en lista de enteros y calcula su suma total.

🏁 Conclusión general

En esta sección has aplicado los cuatro tipos de datos fundamentales de Python para resolver problemas reales.
Ahora dominas cómo representar, comparar, transformar y validar información numérica, textual y lógica.