Variables y tipos

• Nivel: principiante
• Úsala cuando: una actividad incluya variables, conversiones, operadores o input()
• Conocimientos previos útiles: ejecutar código y usar print()

En esta página crearás un registro de encuesta que recibe texto, convierte la edad y las horas, calcula minutos de estudio y evalúa comparaciones que dan True o False. Estudiarás por qué los datos escritos con input() llegan como texto y cuándo hace falta convertirlos.

Qué puedes consultar aquí

• distinguir un valor de un nombre de variable en una asignación;
• explicar qué hace = y diferenciarlo de ==;
• reconocer int, float, str y bool, y consultar un tipo con type();
• convertir texto numérico y construir expresiones con operadores;
• interpretar errores frecuentes de nombres, tipos, conversiones y división.

1. Valores, nombres y asignación

Una variable es un nombre asociado a un valor durante la ejecución. La instrucción de asignación usa =: primero evalúa la expresión de la derecha y después asocia el resultado al nombre de la izquierda.

materia = "Biología"
puntaje = 8
puntaje = puntaje + 1

print(materia)
print(puntaje)

Salida:

Biología
9

materia y puntaje son nombres. "Biología", 8 y, después de la tercera instrucción, 9 son valores. En puntaje = puntaje + 1, la expresión puntaje + 1 usa el valor actual, produce 9 y vuelve a asociar ese resultado con puntaje.

= asigna; no pregunta si dos valores son iguales. El operador == compara y devuelve True o False:

edad = 16
print(edad == 16)  # True
print(edad == 17)  # False

Un nombre puede contener letras, números y guion bajo, pero no puede comenzar con un número ni coincidir con una palabra reservada. Python distingue mayúsculas de minúsculas: total y Total son nombres diferentes. Conviene usar snake_case, como costo_total, y elegir nombres que indiquen el dato representado.

Python permite volver a asociar un nombre con otro tipo de valor. Aun así, mantener un tipo estable en cada nombre facilita la lectura del programa.

2. Cómo consultar un tipo con type()

type(valor) devuelve el tipo del valor que recibe. Estas cuatro llamadas permiten verificar qué tipo tiene cada valor durante la ejecución:

cantidad = 12
precio = 18.5
nombre = "Lina"
disponible = True

print(type(cantidad))
print(type(precio))
print(type(nombre))
print(type(disponible))

Salida:

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

La palabra class forma parte de la representación que muestra Python para un tipo. Para esta página, basta con reconocer los nombres int, float, str y bool dentro de esa salida.

3. int, float, str y bool

Python tiene más tipos. Estos son cuatro tipos básicos usados en esta página:

Las comparaciones también producen valores bool. Por ejemplo, 18.5 < 20 da como resultado True.

Muchos números decimales no pueden representarse de forma exacta como float. Por eso, este resultado es posible y no es un error de sintaxis:

print(0.1 + 0.2)  # 0.30000000000000004

En los ejercicios no dependerás de que una operación con decimales produzca una representación exacta. Observa además que "123" es texto por las comillas, aunque sus caracteres sean dígitos.

4. Conversión de tipos

Las funciones int(), float() y str() construyen valores del tipo indicado; pueden convertir una entrada cuando su valor y formato son compatibles.

edad_texto = "16"
edad = int(edad_texto)
estatura = float("1.68")
mensaje = str(edad)

print(edad + 1)
print(estatura)
print(type(mensaje))

Salida:

17
1.68
<class 'str'>

No toda conversión es válida. int("dieciséis") lanza ValueError. int("3.5") también lanza ValueError porque esa cadena no representa directamente un entero; float("3.5") sí devuelve un decimal.

bool() no sirve para interpretar respuestas textuales como “sí” o “no”. bool("False") devuelve True: al convertir una cadena a bool, Python considera verdadera cualquier cadena que no esté vacía. Más adelante usarás una comparación explícita para una respuesta.

5. Operadores y expresiones

Una expresión combina valores y operadores para producir otro valor. Los operadores aritméticos de esta página son +, -, *, /, //, % y **.

print(7 / 2)                   # 3.5
print(7 // 2)                  # 3
print(7 % 2)                   # 1
print(2 ** 3)                  # 8
print(8 >= 6)                  # True
print((8 >= 6) and (8 <= 10))  # True

/ realiza una división y devuelve float. Con enteros no negativos, 7 // 2 da 3, el cociente redondeado hacia abajo, y 7 % 2 da 1, el resto: 7 se descompone como 2 * 3 + 1. Los ejemplos de esta página usan operandos no negativos para esas dos operaciones. ** calcula una potencia.

Los operadores de comparación son ==, !=, <, <=, > y >=. Los operadores lógicos and, or y not pueden combinar o negar comparaciones. En los ejemplos de esta página, sus operandos son booleanos y el resultado también es booleano.

+ depende de los tipos de sus operandos. Suma números, pero concatena dos cadenas. Multiplicar una cadena por un entero repite el texto:

print("Py" + "thon")  # Python
print("ha" * 3)        # hahaha
print((4 + 2) * 3)     # 18

Los paréntesis hacen explícito qué operación se evalúa primero y evitan depender de recordar toda la precedencia de operadores.

6. Datos escritos con input()

input() muestra un mensaje, espera una entrada y siempre devuelve str, incluso cuando la persona escribe dígitos. Separar el texto original del valor convertido permite observar el cambio de tipo.

nombre = input("Nombre: ")
horas_texto = input("Horas de estudio esta semana: ")
horas = float(horas_texto)

print(f"{nombre} registró {horas} horas.")

Si se escribe Lina y después 2.5, la última línea muestra Lina registró 2.5 horas.. Para un decimal, la entrada debe usar punto, como 2.5, y no coma. Esta página supone entradas válidas. Si una tarea necesita validar entradas, consulta Condicionales y bucles.

Visual interactivo: sigue el valor y el tipo

El visual compara valores predefinidos de los tipos estudiados. Para cada valor, compara cómo se escribe, el nombre de su tipo y el resultado de una operación válida. Las comillas permiten distinguir una cadena numérica de un número.

Pregunta de observación: ¿qué cambia entre una suma de números y una concatenación de cadenas aunque ambas usen +?

Ejemplo integrado: presupuesto para una actividad escolar

Este programa recibe cuatro cadenas, convierte tres de ellas y usa los valores convertidos en cálculos y comparaciones. No necesita una estructura condicional.

actividad = input("Actividad: ")
participantes = int(input("Número de participantes: "))
costo_por_persona = float(input("Costo por persona: "))
presupuesto = float(input("Presupuesto disponible: "))

costo_total = participantes * costo_por_persona
alcanza = presupuesto >= costo_total
sobrante = presupuesto - costo_total

print(f"Actividad: {actividad}")
print(f"Costo total: ${costo_total:.2f}")
print(f"¿Alcanza el presupuesto? {alcanza}")
print(f"Diferencia: ${sobrante:.2f}")

La diferencia puede ser negativa si el costo supera el presupuesto. :.2f controla cómo print() muestra el decimal con dos cifras; no cambia el tipo de la variable.

Errores comunes

Los nombres de excepción permiten ubicar la clase de problema. Ejecuta este fragmento por separado para observar un TypeError real:

precio_texto = "16"
print(precio_texto + 1)

El mensaje incluye TypeError: can only concatenate str (not "int") to str. La operación mezcla str e int; int(precio_texto) + 1 produce 17.

Comprobación de conocimiento

Práctica

1. Traza una ficha de materia

Sin ejecutar el código, predice sus seis líneas de salida. Después, ejecútalo y compara cada línea con tu predicción:

nombre_materia = "Historia"
calificacion = 8.5
entrega_completa = True

print(nombre_materia)
print(type(nombre_materia))
print(calificacion)
print(type(calificacion))
print(entrega_completa)
print(type(entrega_completa))

La salida comienza con Historia y <class 'str'>; las líneas siguientes deben confirmar los valores y tipos 8.5, float, True y bool. Explica en una oración por qué 8.5 no es int.

2. Modifica un conversor de minutos

Este programa solo calcula las horas completas:

minutos = int(input("Minutos totales: "))
horas_completas = minutos // 60

print(f"Horas completas: {horas_completas}")

Modifícalo para calcular también minutos_restantes con % y mostrarlo. Con una entrada de 135, la salida debe indicar 2 horas completas y 15 minutos restantes. Después prueba 59: debe indicar 0 horas completas y 59 minutos restantes. Explica en una oración el tipo de minutos después de la conversión.

3. Crea una cuenta compartida

Pide el total decimal de una cuenta y el número entero de personas. Calcula y muestra el pago por persona. Con 450.0 y 6, el resultado numérico debe ser 75.0. Para este ejercicio, el número de personas debe ser mayor que cero; no hace falta validarlo con una estructura de control. Explica qué tipo devuelve /.

4. Diagnostica y repara

Este fragmento contiene entradas sin convertir y un nombre no definido:

precio = input("Precio por artículo: ")
cantidad = input("Cantidad: ")
total = precio * cantidad
print(resultado)

Identifica el TypeError que ocurre al multiplicar dos cadenas y el NameError que aparecería al intentar mostrar resultado si se reparara la línea anterior. Convierte precio a float, convierte cantidad a int y muestra total. Usa 12.5 y 4 como prueba: el resultado debe ser 50.0. Añade una oración que indique el tipo de total.

Reto: registro de una encuesta

El método lower() devuelve una nueva cadena en minúsculas y no modifica la cadena original:

respuesta = "SI"
print(respuesta.lower() == "si")  # True
print(respuesta)                   # SI

En este reto, las respuestas válidas son si y no, sin tilde ni espacios adicionales. lower() permite aceptar también variantes como SI o Si.

Completa este programa para registrar una encuesta:

alias = input("Alias: ")
edad_texto = input("Edad: ")
horas_texto = input("Horas semanales de estudio: ")
respuesta = input("¿Participas en un club? Escribe si o no: ")

# Convierte edad_texto y horas_texto a los tipos adecuados.
# Calcula los minutos semanales y las dos comparaciones solicitadas.
# Muestra el alias, los tres resultados y los cuatro tipos finales.

Tu programa debe:

• convertir edad_texto a un int llamado edad y horas_texto a un float llamado horas antes de calcular;
• calcular minutos_semanales a partir de horas;
• calcular es_mayor_de_edad mediante una comparación con 18;
• usar exactamente participa = respuesta.lower() == "si" para la otra comparación;
• mostrar el alias, los tres resultados y type(alias), type(edad), type(horas) y type(participa).

Comprueba el programa con estos dos casos de prueba:

• Con las entradas Luna, 17, 4.5 y si, debe mostrar Minutos semanales: 270.0, Mayor de edad: False y Participa: True.
• Con las entradas Sol, 18, 2 y no, debe mostrar Minutos semanales: 120.0, Mayor de edad: True y Participa: False.

La solución debe incluir al menos un operador aritmético y las dos comparaciones indicadas, sin usar bool(input()). Debes poder explicar por qué las cuatro entradas comienzan como str y qué conversión o comparación da cada tipo final.

Lista de comprobación

Comprueba los resultados con ejemplos observables:

• Puedo explicar con un ejemplo la diferencia entre asignar con = y comparar con ==.
• Puedo predecir el resultado de type() para un int, float, str y bool.
• Puedo convertir texto numérico antes de usarlo en una operación aritmética.
• Puedo elegir entre /, // y % para un cálculo concreto.
• Puedo explicar por qué input() devuelve texto aunque se escriban dígitos.
• Puedo diagnosticar al menos uno de estos errores por su causa: NameError, TypeError, ValueError o ZeroDivisionError.