Tipos de datos

El conjunto al que pertenece un número

Responde dos preguntas: tienes $7$ manzanas y partes una por la mitad. ¿Sostienes ahora $7 + \frac{1}{2}$ manzanas en el mismo sentido que sostenías $7$? Media manzana no es un número entero de manzanas, el $7$ vive en $\mathbb{Z}$, y el $7\frac{1}{2}$ vive en $\mathbb{Q}$.

Un matemático responde preguntándose a qué conjunto pertenece un valor. La misma distinción persigue a todo programa: la máquina almacena $42$ de forma distinta a $42.5$, y $42$ de forma distinta a "42". La palabra que Python usa para “en qué conjunto vive este valor” es tipo.

Entonces: ¿cuántos conjuntos merece la pena distinguir? Cuatro, al principio.

La fila de float tiene una reserva deliberada, aproximado. Un entero se guarda exacto, siempre. Un número real casi nunca: ¿cómo guardarías $1/3 = 0.333\ldots$ con un número finito de dígitos? No puedes, así que Python mantiene una aproximación finita y las cuentas divergen en los últimos dígitos. Ese único hecho explica una sorpresa famosa que verás enseguida.

Preguntar a qué conjunto pertenece

Dada una valor, puedes preguntar su tipo directamente:

type(42)      # <class 'int'>
type(3.14)    # <class 'float'>
type("hi")    # <class 'str'>
type(True)    # <class 'bool'>

Dos notas de notación. Primera, type(...) es una función, le entregas un valor y te devuelve el objeto de tipo al que pertenece ese valor. Segunda, la respuesta imprime <class 'int'>; la palabra class es el término de Python para tipo, y la palabra entre comillas es el nombre del conjunto. Lee <class 'float'> como “pertenece al conjunto float”.

Un nombre no se compromete con un conjunto

Aquí empiezan los beneficios. En un lenguaje de tipado estático declararías por adelantado: x es un entero. Python, en cambio, deja que un nombre apunte donde quiera:

x = 5
print(type(x))    # <class 'int'>
x = "hello"
print(type(x))    # <class 'str'>

Redirigir un nombre a otro conjunto es legal, así que el tipo de x no se lee de ninguna declaración, solo preguntando a qué apunta ahora. Esto es el tipado dinámico. Es cómodo, y es también la razón por la que tu programa puede, en silencio, entregar una cadena a una función que espera números: nada lo impide hasta que la propia operación falla.

¿Qué valores actúan como True?

Todo valor es truthy o falsy, o bien se comporta como True en una condición, o bien como False. La regla es compacta y merece la pena verificarla:

• Falsy: el $0$, el $0.0$, la cadena vacía "" y None
• Truthy: todo lo demás

bool(0)         # False
bool(1)         # True
bool(-1)        # True   — cualquier número no nulo es truthy
bool("")        # False
bool("hello")   # True   — cualquier cadena no vacía es truthy

Fíjate en lo que está en la lista y en lo que queda fuera. -1 es True; 0 no. La cadena "0" es True, es no vacía, y para las cadenas el criterio es la vacuidad, no el valor de su contenido. Esta regla se paga sola en cuanto escribes tu primer if: if score: significa si score no es cero.

Un ejemplo resuelto: auditar una expresión

Los conjuntos pagan en cuanto una expresión los mezcla. Lee el recibo línea a línea y pregunta el conjunto de cada resultado:

unit_price = 4.75
quantity = 4
bill = unit_price * quantity     # float: el float absorbe al int
type(bill)                       # <class 'float'>
bool(bill)                       # True — todo lo distinto de cero es truthy

type(10 / 2)                     # <class 'float'> — la división real nunca da int

Lee bill como el producto de dos conjuntos distintos. Los conjuntos no se “mezclan”, gana el float, porque la proporción no es un número entero de ninguna escala y el conjunto más ancho debe contenerla. La costumbre de auditoría es preguntar al conjunto directamente: type(...) confirma lo que sospechabas en vez de apostar a la suerte.

Errores comunes

• 4 / 2 es 2.0, no 2. La división real (/) siempre devuelve un float en Python 3, incluso cuando la división es exacta. Para un resultado entero pide división entera: 4 // 2 → 2.
• True + True es 2. bool es una subclase de int en Python: True se comporta como $1$ y False como $0$ en aritmética. Los dos conjuntos se solapan, pero type(True) sigue respondiendo bool.
• type() informa el tipo concreto. type(True) es bool, no int, por mucho que True colabore en las sumas.
• type() describe el resultado, no los operandos. type(2 * 3.0) es float, un int multiplicado por un float vive en el conjunto float. No lo predigas de las piezas; pregúntale a la respuesta.