Tipos, operaciones, input y conversión

En esta lección vas a aprender a guardar datos en variables, conocer los tipos básicos de Python (int, float, str, bool y None), operar con ellos, mostrar resultados prolijos con f-strings y pedirle datos al usuario con input(). El punto clave: input() siempre devuelve texto, y convertirlo bien es tu responsabilidad.

Variables

Una variable es un nombre que apunta a un valor. Se crea con el signo =:

producto = "Yerba"
precio = 3200
cantidad = 2
print(producto, precio * cantidad)

Yerba 6400

El = no significa "igual" como en matemática: significa asignar. Se lee "a precio le asigno 3200". Podés reasignar una variable cuando quieras:

contador = 1
contador = contador + 1
print(contador)  # 2

Reglas para los nombres:

• Pueden tener letras, números y guiones bajos, pero no pueden empezar con un número.
• Distinguen mayúsculas: precio y Precio son dos variables distintas.
• La convención en Python es snake_case: minúsculas y palabras separadas con _, como precio_unitario o total_con_descuento.
• Elegí nombres que digan qué guardan. total_mensual se entiende; x2 no.

print acepta varios valores separados por comas y los muestra con un espacio entre ellos, como en el ejemplo de arriba.

Los tipos básicos

Cada valor tiene un tipo, que define qué podés hacer con él. La función type() te dice cuál es:

print(type(42))        # <class 'int'>
print(type(3.5))       # <class 'float'>
print(type("hola"))    # <class 'str'>
print(type(True))      # <class 'bool'>
print(type(None))      # <class 'NoneType'>

Python tiene tipado dinámico: no declarás el tipo, se deduce del valor. Una misma variable puede apuntar primero a un número y después a un texto (aunque hacerlo suele confundir).

Algunos detalles:

• En el código, los decimales se escriben con punto: 3.5, nunca 3,5.
• Para números grandes podés usar _ como separador visual: 1_000_000 es lo mismo que 1000000.
• True y False van con mayúscula inicial.
• None se usa para indicar que algo todavía no tiene valor, por ejemplo descuento = None hasta que se calcule.

Operadores aritméticos

Dos cosas para tener en cuenta:

• / siempre devuelve float, aunque la división sea exacta: 10 / 2 da 5.0.
• Si en una operación hay un float, el resultado es float: 3 + 1.0 da 4.0.

// y % sirven mucho juntos. Por ejemplo, para pasar segundos a minutos y segundos:

segundos_totales = 200
minutos = segundos_totales // 60
segundos = segundos_totales % 60
print(minutos, "min", segundos, "s")

3 min 20 s

El orden de las operaciones es el de la matemática: primero **, después *, /, // y %, y al final + y -. Usá paréntesis cuando quieras otro orden o para que se lea mejor:

print(2 + 3 * 4)    # 14
print((2 + 3) * 4)  # 20

Asignación compuesta

Actualizar una variable a partir de su propio valor es tan común que tiene atajo:

saldo = 1000
saldo += 250   # equivale a saldo = saldo + 250
saldo -= 100   # saldo = saldo - 100
saldo *= 2     # saldo = saldo * 2
print(saldo)   # 2300

Funciones numéricas útiles

print(round(3.14159, 2))  # 3.14
print(round(2.7))         # 3
print(abs(-15))           # 15
print(max(4, 9, 2))       # 9
print(min(4, 9, 2))       # 2

Los decimales no son exactos

Los float se guardan en binario y algunos decimales no se pueden representar exactos:

print(0.1 + 0.2)  # 0.30000000000000004

No es un bug de Python: pasa en casi todos los lenguajes. Para mostrar resultados, redondeá o formateá (lo vemos enseguida). Para comparar decimales, no uses == directo con resultados de cuentas.

Operaciones con texto

Con strings, + une (concatena) y * repite. len() cuenta los caracteres:

nombre = "Lu"
apellido = "Pérez"
print(nombre + " " + apellido)  # Lu Pérez
print("-" * 10)                 # ----------
print(len(apellido))            # 5

Los strings pueden ir entre comillas simples o dobles. Si el texto tiene una comilla simple adentro, usá dobles afuera: "Es Python, no 'pitón'".

Comparaciones y booleanos

Los operadores de comparación devuelven True o False:

edad = 20
print(edad >= 18)       # True
print(edad == 21)       # False
print("a" == "A")       # False
print("hola" != "chau") # True

Fijate la diferencia: = asigna, == compara. En la lección 3 vas a usar estas comparaciones para tomar decisiones.

f-strings: mostrar valores con formato

Concatenar con + se vuelve incómodo enseguida, y además solo funciona entre strings. La forma moderna de armar textos es la f-string: un string con una f adelante, donde lo que va entre llaves se reemplaza por su valor.

producto = "Café"
precio = 4500
cantidad = 3
print(f"{cantidad} x {producto} = ${precio * cantidad}")

3 x Café = $13500

Adentro de las llaves podés poner cualquier expresión. Después de : podés agregar un formato:

promedio = 7.666666
total = 1234567.891
porcentaje = 0.256

print(f"Promedio: {promedio:.2f}")      # dos decimales
print(f"Total: {total:,.2f}")           # separador de miles y dos decimales
print(f"Avance: {porcentaje:.1%}")      # como porcentaje
print(f"[{'izq':<6}] [{'der':>6}]")     # alinear a izquierda o derecha en 6 lugares

Promedio: 7.67
Total: 1,234,567.89
Avance: 25.6%
[izq   ] [   der]

El formato no cambia el valor de la variable: solo cómo se muestra. Las f-strings existen desde Python 3.6; en código viejo vas a ver "{} x {}".format(a, b), que hace lo mismo con otra sintaxis.

input(): pedirle datos al usuario

input() muestra un mensaje, espera a que el usuario escriba algo y aprete Enter, y devuelve lo que escribió como string:

nombre = input("¿Cómo te llamás? ")
print(f"Hola, {nombre}")

¿Cómo te llamás? Ana
Hola, Ana

Ahora mirá qué pasa con números:

a = input("Primer número: ")
b = input("Segundo número: ")
print(a + b)

Primer número: 3
Segundo número: 4
34

El resultado es 34, no 7. input() siempre devuelve str, aunque el usuario escriba dígitos, así que + unió dos textos. Hay que convertir.

Conversión de tipos

Las funciones int(), float(), str() y bool() convierten un valor a ese tipo:

print(int("42") + 1)      # 43
print(float("3.5") * 2)   # 7.0
print(str(100) + " km")   # 100 km
print(int(7.9))           # 7  (corta los decimales, no redondea)
print(float(5))           # 5.0

El programa de la suma, bien hecho:

a = int(input("Primer número: "))
b = int(input("Segundo número: "))
print(f"La suma es {a + b}")

Primer número: 3
Segundo número: 4
La suma es 7

int(input(...)) se lee de adentro hacia afuera: primero input devuelve el texto, después int lo convierte.

Cuando la conversión falla

Si el texto no representa un número válido, la conversión da error:

>>> int("3.5")
ValueError: invalid literal for int() with base 10: '3.5'
>>> int("")
ValueError: invalid literal for int() with base 10: ''
>>> float("12,5")
ValueError: could not convert string to float: '12,5'

• int("3.5") falla porque "3.5" no es un entero. Si puede venir con decimales, usá float().
• int("") falla cuando el usuario aprieta Enter sin escribir nada.
• float("12,5") falla porque Python espera punto decimal.

Por ahora, si el programa recibe algo inválido, se va a cortar con un ValueError. En la lección 3 vas a ver cómo chequear el texto antes de convertir, y en la lección 8, cómo atrapar el error y volver a pedir el dato.

Otro error típico es mezclar texto y números con +:

>>> "Total: " + 500
TypeError: can only concatenate str (not "int") to str

Solución: usá una f-string (f"Total: {500}") o convertí con str(500).

bool() y los valores "vacíos"

bool() convierte cualquier valor a True o False. Son False el 0, el 0.0, el string vacío "" y None; casi todo lo demás es True:

print(bool(0))        # False
print(bool(""))       # False
print(bool("False"))  # True  (es un texto no vacío)
print(bool(-3))       # True

Esto se llama truthiness y lo vas a aprovechar en la lección 3.

Errores comunes

• Olvidarse de convertir lo que devuelve input(). Es el error más frecuente al empezar: "3" + "4" da "34", y "3" * 2 da "33". Si vas a operar, convertí.
• Usar coma decimal. precio = 3,5 no da error, pero crea otra cosa (una tupla, que verás en la lección 5). Siempre punto: 3.5.
• Confundir = con ==. = asigna; == pregunta si son iguales.
• Esperar que int() redondee. int(7.9) da 7. Si querés redondear, usá round().
• Comparar decimales con ==. 0.1 + 0.2 == 0.3 da False. Redondeá antes de comparar: round(0.1 + 0.2, 2) == 0.3.

Practicá

1. Sin ejecutar, anotá qué muestra cada línea. Después comprobalo en el REPL: print(17 // 5), print(17 % 5), print(2 * "ab"), print(10 / 5), print(int("8") + int(2.9)).
2. Escribí un programa que pida el precio de un producto y la cantidad, y muestre el total con dos decimales. El precio puede tener decimales; la cantidad es entera.
3. Escribí un programa que pida una cantidad de minutos y la muestre en horas y minutos. Por ejemplo, 135 tiene que mostrar 2 h 15 min.
4. Escribí un programa que pida una temperatura en grados Celsius y la muestre convertida a Fahrenheit con un decimal. La fórmula es F = C * 9 / 5 + 32.

Soluciones

Ejercicio 1: 3, 2, abab, 2.0 (la división / siempre da float) y 10 (int(2.9) es 2, y 8 + 2 es 10).

Ejercicio 2:

precio = float(input("Precio: "))
cantidad = int(input("Cantidad: "))
total = precio * cantidad
print(f"Total: ${total:.2f}")

Precio: 1250.5
Cantidad: 3
Total: $3751.50

Ejercicio 3:

minutos_totales = int(input("Minutos: "))
horas = minutos_totales // 60
minutos = minutos_totales % 60
print(f"{horas} h {minutos} min")

Minutos: 135
2 h 15 min

Ejercicio 4:

celsius = float(input("Temperatura en °C: "))
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius}°C son {fahrenheit:.1f}°F")

Temperatura en °C: 21.5
21.5°C son 70.7°F

Resumen

• Una variable es un nombre que apunta a un valor; se asigna con = y se nombra en snake_case.
• Los tipos básicos son int, float, str, bool y None; type() te dice cuál tiene un valor.
• / siempre da float; // es la división entera y % el resto.
• Las f-strings (f"Total: {x:.2f}") son la forma recomendada de armar textos con valores y formato.
• input() siempre devuelve str: convertí con int() o float() antes de operar.
• Convertir un texto inválido da ValueError; mezclar str y números con + da TypeError.