Variables y tipos de datos en Python: int, float, str y bool

Una variable es un nombre que apunta a un valor guardado en la memoria. El tipo dice qué clase de valor es y, por consecuencia, qué se puede hacer con él. Cuatro tipos cubren casi todo al comienzo: int para números enteros, float para números con parte decimal, str para texto y bool para verdadero o falso. Python descubre el tipo mirando el valor que escribiste, y el mismo nombre puede apuntar a tipos distintos a lo largo del programa.

En los artículos anteriores ya usaste variables sin mucha ceremonia: preco = 3.5, nome = input(...). Aquí el tema es hacerlo con conciencia. Saber qué tipo hay dentro de cada nombre explica la mayor parte de los resultados extraños que aparecen en las primeras semanas, desde la suma que da 53 hasta la comparación de decimales que sale bien en el computador y mal en la placa, o al revés.

El problema: para la máquina, cinco no es solo cinco

Escribe 5 en un cuaderno y el lector sabe qué hacer con él. Para el computador existen al menos tres cosas distintas que se escriben de manera parecida: el número entero 5, el decimal 5.0 y el texto "5", un carácter que por casualidad es un dígito. Cada uno ocupa la memoria de una forma, responde a operaciones distintas y aparece de forma distinta en la pantalla. El tipo es lo que resuelve esa ambigüedad.

Una imagen útil es la de la etiqueta. En una cocina, el frasco de azúcar tiene una etiqueta que dice "azúcar". La etiqueta no es el azúcar, es solo un nombre pegado a un contenido. Si sacas la etiqueta y la pegas en otro frasco, el nombre pasa a apuntar a otra cosa. En una variable, el nombre es la etiqueta y el valor es el contenido del frasco. El tipo pertenece al contenido: el azúcar es azúcar, sea cual sea la etiqueta.

Variables: crear, nombrar y cambiar

Crear una variable es escribir el nombre, el signo = y el valor. No hay una palabra especial para "declarar", como en otros lenguajes: la variable pasa a existir en la primera línea en la que recibe un valor. Fue lo que mostró la figura de la memoria en el primer artículo de la serie.

Reglas para el nombre

Un nombre de variable puede tener letras, dígitos y el guion bajo _, pero no puede empezar con un dígito, no puede tener espacio ni guion medio y no puede ser una palabra reservada del lenguaje. Las violaciones aparecen como error de sintaxis, y el mensaje no ayuda mucho:

2nota = 5          →  SyntaxError: invalid syntax for integer with base 10
class = 5          →  SyntaxError: invalid syntax
nome-completo = 5  →  SyntaxError: can't assign to expression

En el primer caso, la placa leyó 2nota entero como si fuera un número y se quejó de que no es un entero válido en base 10. En el último, Python leyó nome - completo como una resta, y una resta no puede recibir un valor. Las letras mayúsculas y minúsculas son distintas: total y Total son dos nombres. El simulador también aceptó nombres con tilde, como média, pero la convención entre programadores es evitarlos y escribir en ASCII, para que el código funcione en cualquier editor y en cualquier terminal.

La convención de Python para nombres de variables es la snake_case: letras minúsculas y palabras separadas por guion bajo, como nota_final y preco_item. Las constantes, valores que no cambian durante el programa, suelen escribirse en mayúsculas (PI = 3.14159), aunque Python no impide modificarlas. El mejor nombre es el que no necesita comentario: d no dice nada, dias_de_atraso lo dice todo.

Cambiar el valor y cambiar el tipo

Una variable puede recibir valores nuevos cuantas veces quiera, incluso de tipos distintos. La figura muestra cuatro líneas seguidas para el mismo nombre:

x = 10
print(type(x))
x = "diez"
print(type(x))
x = 10.0
print(type(x))
x = x > 5
print(x, type(x))

Python no se queja de ningún cambio. La flexibilidad es cómoda en programas pequeños y peligrosa en programas grandes, porque el error solo aparece cuando el valor equivocado llega a una cuenta. Después de estas cuatro líneas, por ejemplo, x + 1 da 2 sin ningún aviso: el True vale 1 en las cuentas. Una regla práctica es mantener el mismo tipo en cada variable durante todo el programa, a menos que haya un buen motivo.

Vale conocer dos formas de asignar. Se puede dar el mismo valor a varios nombres a la vez, con a = b = 0, y se pueden asignar varios valores en paralelo, con a, b = 1, 2. La segunda forma permite intercambiar dos valores sin variable auxiliar: a, b = b, a. Funciona porque Python calcula todo lo que está a la derecha antes de guardar cualquier cosa a la izquierda.

Los cuatro tipos básicos

La función type() muestra el tipo de cualquier valor, y es la primera herramienta cuando una cuenta se comporta de manera extraña.

idade = 17
altura = 1.75
nome = "Ana"
aprovado = True
nada = None
print(type(idade), type(altura), type(nome), type(aprovado), type(nada))
print(idade, altura, nome, aprovado, nada)

int: números enteros

El int guarda números sin parte decimal, positivos, negativos o cero. Es el tipo de los conteos, las edades, las cantidades y las posiciones. En Python, un entero no tiene un límite fijo de tamaño como en otros lenguajes: 2 ** 100 calcula 1267650600228229401496703205376 sin desbordarse, y el único límite es la memoria disponible. El simulador ejecuta ese cálculo con normalidad. Cuando la cuenta involucra dos enteros, el resultado es entero, con una excepción que el artículo de operadores va a explicar: la división con / siempre devuelve float, incluso cuando la cuenta sale exacta (10 / 2 es 5.0).

float: números con parte decimal

El float guarda números con decimales, escritos con punto: 1.75, 3.0, 0.001. También acepta notación científica, en la que 2.5e-5 significa 2,5 por diez elevado a menos cinco. Sirve para medidas, promedios, precios y cualquier magnitud continua.

Aquí existe una diferencia entre el Python del computador y el MicroPython de la ESP32 que merece atención. El computador usa float de 64 bits, con cerca de 15 a 17 dígitos significativos. La ESP32 con MicroPython usa 32 bits, con cerca de 7. Eso cambia lo que aparece en la pantalla y, en algunos casos, el resultado de una comparación.

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(1 / 3)
print(16777216.0 + 1)
print(1e39)

En el simulador, esas líneas muestran 0.3, True, 0.33333334, 16777216.0 e inf. En el Python del computador, las mismas líneas muestran 0.30000000000000004, False, 0.3333333333333333, 16777217.0 y 1e+39. Los valores de la columna de la ESP32 vienen del simulador, que reproduce el float de 32 bits de MicroPython. Como todavía no fueron todos comprobados en una placa del laboratorio, conviene repetir la prueba en una ESP32 de verdad y comparar.

Dos puntos son fáciles de recordar. Primero, a partir de 16777216 (que es 2 elevado a 24) el float de 32 bits ya no consigue representar todos los enteros, y 16777216.0 + 1 sigue valiendo 16777216.0. Segundo, el mayor valor del tipo es cerca de 3,4 por diez elevado a 38. Pasarse de eso da inf, el infinito, en lugar de generar un error.

En la práctica, ninguno de estos casos importa para la nota de un alumno. Importa cuando el programa suma muchas veces (un reloj, un acumulador de energía, un sensor leído durante horas) o compara decimales con ==. La solución suele ser una de dos: comparar con una tolerancia, abs(a - b) < 0.0001, o trabajar con enteros. Para dinero, la segunda es la más segura:

preco_centavos = 1999
quantidade = 3
total_centavos = preco_centavos * quantidade
print(total_centavos)
print(total_centavos // 100, total_centavos % 100)
print(f"R$ {total_centavos // 100},{total_centavos % 100:02d}")

El programa guarda R$ 19,99 como 1999 centavos y solo a la hora de mostrar separa reales y centavos. La división // devuelve la parte entera del cociente y el % devuelve el resto, que son los temas del próximo artículo de la serie. El :02d dentro de la f-string completa con cero a la izquierda para que siempre haya dos dígitos de centavos.

str: texto

El str guarda texto entre comillas simples o dobles, desde una palabra hasta un párrafo, incluido el texto vacío "". Por ahora bastan dos operaciones: el + une dos textos y el * repite un texto, y len("Ana") devuelve el tamaño, 3. Los textos y los números no se mezclan en las cuentas: "5" + 5 es un error, y "5" + "5" vale "55". El artículo sobre strings, en el módulo de estructuras de datos, va a mostrar cómo cortar y transformar texto.

bool: verdadero o falso

El bool tiene solo dos valores, True y False, escritos con la primera letra mayúscula. Escribir true en minúsculas termina en NameError: name 'true' isn't defined, porque Python busca una variable con ese nombre. Los valores bool aparecen sobre todo como resultado de comparaciones (nota >= 6) y son el combustible de las decisiones, tema del módulo 2.

Lo más sorprendente es que cualquier valor puede tratarse como bool. La función bool() convierte, y la regla es la misma en todo Python: los valores "vacíos" o nulos pasan a False, y todo lo demás pasa a True.

print(bool(0), bool(1), bool(-3))
print(bool(0.0), bool(0.5))
print(bool(""), bool("a"), bool(" "), bool("False"), bool("0"))
print(bool(None))

La salida muestra False True True, False True, False True True True True y False. El cero, el texto vacío y el None dan False. El texto "0", el texto "False" e incluso un texto con un único espacio dan True, porque son textos que no están vacíos. También funciona al revés: True vale 1 y False vale 0 en cualquier cuenta numérica, y por eso True + True es 2.

None: la ausencia de valor

El None es el valor que Python usa para decir "aquí no hay nada". Tiene tipo propio, NoneType, y es lo que una función devuelve cuando no devuelve nada a propósito. Es común que aparezca por accidente, como vas a ver en los errores más adelante.

Errores que comete hasta quien programa hace años

Los escenarios de abajo no son de principiante. Suelen aparecer incluso en el código de gente con experiencia, casi siempre bajo presión o cansancio, y en varios de ellos el error más caro es el que no da ningún mensaje.

El nombre casi igual

Una persona con años de práctica escribe la línea de acumular el total y teclea un nombre distinto por error:

total = 10
totl = total + 1
print(total)

El programa corre sin error y muestra 10. La línea 2 creó una variable nueva llamada totl y el total nunca fue modificado. Es el error de tipeo más difícil de encontrar, porque Python no distingue un nombre nuevo de un descuido. Los editores que resaltan nombres ayudan, y la tabla de seguimiento también: la columna totl, que no debería existir, aparece en la tabla.

El == suelto y el = dentro del if

La comparación con == y la asignación con = se parecen tanto que quien programa en varios lenguajes las confunde. Escribir idade == 18 en una línea sola no da error: Python calcula la comparación, obtiene False y descarta el resultado. La variable sigue valiendo 17.

idade = 17
idade == 18
print(idade)

El Serial muestra 17. El error inverso es más ruidoso: if idade = 18: termina en SyntaxError: invalid syntax, porque dentro de un if Python espera una comparación y no una asignación.

Sobrescribir una función de Python

Nombres como str, input y varios otros ya existen en el lenguaje como funciones. Nada impide usarlos como nombre de variable, y la persona solo lo descubre cuando la función desaparece:

str = "hola"
print(str)
print(str(5))

El primer print muestra hola, y el segundo termina en TypeError: 'str' object isn't callable. Lo mismo ocurre con input = "teclado" seguido de input("Nombre: "). La variable tapó la función. El síntoma es un mensaje que dice que "un objeto no puede ser llamado", y la corrección es cambiar el nombre de la variable por algo más específico, como texto o entrada.

El texto "False" que vale True

Un valor leído como texto, de un teclado o de un archivo de configuración, llega como str. Si la persona luego escribe if valor: creyendo que "False" es falso, el programa entra en el if:

valor = "False"
if valor:
    print("entró en el if")

El Serial muestra entró en el if, porque un texto no vacío es verdadero, sea cual sea su contenido. Cuando el dato viene de afuera, la conversión al tipo correcto es un paso explícito, y la comparación con el texto (valor == "True") es más honesta que contar con bool().

La comparación de decimales que cambia de placa

Alguien escribe una prueba con == entre dos decimales, la ejecuta en el computador y ve False, que es la respuesta clásica. En la ESP32, la misma línea muestra True. Lo opuesto también ocurre: un programa que funcionaba en el notebook gracias a los 64 bits deja de funcionar en la placa por culpa de los 32. El hábito que protege es comparar con tolerancia, nunca con ==.

El None que entró en una cuenta

La función print() muestra un valor, pero no devuelve nada. Guardar su resultado en una variable es un error común, y la variable queda con None:

soma = print("Calculando...")
print(soma)
soma + 1

El programa muestra Calculando..., después None, y termina en TypeError: unsupported types for __add__: 'NoneType', 'int'. El mensaje habla del tipo y no del nombre, y por eso conviene recordar que NoneType casi siempre indica una variable que recibió el resultado de algo que no devolvía valor.

Ejercicio: la ficha del alumno

Escribe un programa que guarde el nombre (texto), la edad (entero) y la nota (decimal) de un alumno, calcule si fue aprobado con nota de al menos 6 y muestre cada valor junto a su tipo. Piensa en las cuatro variables antes de escribir, y prevé qué tipo tendrá cada una.

nome = "Ana"
idade = 17
nota = 7.5
aprovado = nota >= 6
print(nome, type(nome))
print(idade, type(idade))
print(nota, type(nota))
print(aprovado, type(aprovado))

La salida trae Ana <class 'str'>, 17 <class 'int'>, 7.5 <class 'float'> y True <class 'bool'>. La variable aprovado no recibió True escrito a mano, recibió el resultado de una comparación, que siempre es un bool.

Para practicar la predicción, intenta adivinar el tipo de estas expresiones y comprueba con type(): 7 / 2, 7 // 2, "7", 7 > 2 y None. Las respuestas, en este orden, son float, int, str, bool y NoneType. Si fallas alguna, vuelve a la regla: la división con / siempre da float, la de // entre enteros da int, y una comparación siempre da bool.

Preguntas frecuentes

¿Necesito declarar el tipo de una variable?

No. Python deduce el tipo por el valor. Existe una forma de anotar el tipo en el código (idade: int = 17), pero sirve como documentación y el intérprete no la usa para verificar nada.

¿Cuál es la diferencia entre 5, 5.0 y "5"?

El primero es un int, el segundo es un float y el tercero es un str. En la comparación, 5 == 5.0 es True porque el valor numérico es el mismo, y 5 == "5" es False, porque un número nunca es igual a un texto.

¿El float de la ESP32 es siempre menos preciso?

Tiene menos dígitos significativos, cerca de 7, contra 15 a 17 en el computador. Para medir temperatura, distancia o tensión en un proyecto de aula, 7 dígitos sobran. La diferencia pesa en cuentas acumuladas y en comparaciones exactas.

¿Por qué Python acepta cambiar el tipo de la variable?

Es lo que se llama tipado dinámico: el tipo se verifica en el momento en que la operación ocurre, y no en el momento de escribir. La ventaja es la rapidez para probar ideas. El precio es que los errores de tipo solo aparecen en la ejecución, como el TypeError de sumar texto con número.

Para continuar

La ruta Lógica con Python tiene desafíos que ejercitan cada tipo. El Suma de dos y el Promedio de notas trabajan con números y conversiones. El Tamaño del nombre usa el len() sobre texto, y el Comparar textos devuelve un bool. En cada uno, escribe primero el tipo que esperas para cada variable.

El próximo tema de la serie son los operadores aritméticos, con la división entera, el resto y la precedencia de las cuentas. Para ver los tipos trabajando en un proyecto de hardware, el artículo sobre el ADC de la ESP32 muestra cómo una tensión se convierte en un número que el programa necesita tratar con cuidado, y el artículo anterior de la serie muestra el input() entregando siempre texto.