Python · Lección 03 de 27

Tipos de datos

Todo valor en Python tiene un tipo. El tipo determina qué podés hacer con ese valor, cuánta memoria ocupa y cómo se comporta al combinarse con otros. Entender tipos es la base de todo análisis de datos serio.

80–100 min Prerrequisitos: 01 Qué es Python, 02 Instalación

Concepto teórico

¿Qué es un tipo de dato y por qué importa?

Cuando guardás un valor en Python, el intérprete necesita saber qué clase de dato es para tres cosas: (1) cuánta memoria reservar, (2) qué operaciones están permitidas, y (3) cómo comportarse al combinar ese dato con otros. Si tenés el número 5 y el texto "5", se ven iguales en pantalla, pero para Python son completamente distintos: con el primero podés sumar (5 + 3 = 8), con el segundo concatenás ("5" + "3" = "53"). Mismo operador, resultado diferente según el tipo.

Python tiene tipado dinámico: no declarás el tipo explícitamente antes de asignar un valor (como sí pasa en Java con int edad = 35; o en C++ con float precio = 99.5f;). Simplemente escribís edad = 35 y Python infiere automáticamente que es un entero. Si después hacés edad = "treinta y cinco", la variable ahora apunta a un string sin quejarse. Esta flexibilidad acelera el desarrollo pero te exige criterio: si mezclás tipos sin querer, tu código va a fallar o, peor, va a dar resultados incorrectos sin que te des cuenta.

Punto clave: una variable en Python no "contiene" un valor — referencia un objeto en memoria que tiene tipo, valor e identidad. Podés verificar el tipo de cualquier valor con type(valor).

int — Enteros

Los int representan números enteros: positivos, negativos o cero. A diferencia de muchos lenguajes (C, Java, JavaScript) donde los enteros tienen un límite de 32 o 64 bits, en Python los enteros no tienen límite de tamaño. Podés tener un número de 1000 dígitos sin problema — Python le asigna memoria dinámicamente. Esto elimina los bugs de "integer overflow" que son comunes en otros lenguajes.

Formas de escribir enteros:

Decimal (base 10): 42, -15, 0 — lo normal
Binario (base 2): 0b1010 = 10 decimal — útil para operaciones bit a bit
Octal (base 8): 0o12 = 10 decimal — raro, pero existe
Hexadecimal (base 16): 0xFF = 255 decimal — usado en colores, memoria
Separadores legibles: 1_000_000 = 1000000 — Python ignora los guiones bajos, pero vos no. Un millón se lee mucho mejor con separadores.

float — Números decimales

Los float representan números con punto decimal. Internamente usan el estándar IEEE 754 de punto flotante de 64 bits. Esto les da una precisión de aproximadamente 15-17 dígitos significativos, pero NO son exactos. Esta es probablemente la trampa más importante de toda la programación:

0.1 + 0.2 en Python da 0.30000000000000004, no 0.3.

¿Por qué? Porque 0.1 en binario es un número periódico (como 1/3 en decimal es 0.333...). La computadora tiene que truncarlo, y ese error microscópico se acumula. Para la mayoría de cálculos científicos esto es irrelevante, pero para cálculos financieros puede ser catastrófico: si procesás 100,000 transacciones, esos errores de redondeo se acumulan y tu balance no cierra.

Error crítico en finanzas: usar float para cálculos de dinero. Para montos financieros usá Decimal del módulo decimal, que trabaja en base 10 y es exacto. O trabajá en centavos con enteros: $150.50 = 15050 centavos (int). Los bancos usan esta segunda técnica internamente.

Valores especiales de float:

float('inf') — infinito positivo. Útil para inicializar "el mínimo" en búsquedas.
float('-inf') — infinito negativo.
float('nan') — Not a Number. Aparece cuando hacés operaciones inválidas. En pandas, los valores faltantes se representan como NaN.
Notación científica: 1.5e10 = 15,000,000,000. Útil para números muy grandes o muy pequeños.

str — Cadenas de texto

Los str (strings) son secuencias de caracteres. Podés usar comillas simples 'hola', dobles "hola" o triples '''hola''' / """hola""". Las triples permiten texto multilínea.

Características importantes:

Inmutabilidad: una vez creado, un string NO se puede modificar. Cada transformación (.upper(), .replace()) crea un string NUEVO.
Unicode nativo: Python 3 maneja UTF-8 nativamente. Nombres como "González", "Muñoz" o "Ñandú" funcionan sin trucos.
Caracteres de escape: \n (salto de línea), \t (tab), \\ (barra literal), \" (comilla literal).
Raw strings: r"C:\Users\nombre" — no interpreta escapes. Útil para paths de Windows y regex.

bool — Booleanos

bool tiene solo dos valores: True y False. Son el resultado de comparaciones y la base de toda decisión en tu código. Dato curioso: en Python, bool es una subclase de int. Esto significa que True == 1 y False == 0, y podés hacer aritmética con ellos: True + True = 2. Esto es útil para contar cuántos elementos cumplen una condición.

Truthy y falsy: en Python, CUALQUIER valor puede evaluarse como booleano. Los siguientes evalúan como False (son "falsy"):

False, 0, 0.0, 0j
"" (string vacío), [] (lista vacía), () (tupla vacía), {} (dict vacío), set()
None

Todo lo demás es truthy (evalúa como True). Esto incluye: "0" (string con un cero), [0] (lista con un elemento), -1 (negativo), etc.

None — La ausencia de valor

None representa explícitamente "no hay dato". No es lo mismo que 0 (cero es un valor), ni que "" (string vacío es un valor), ni que False. None significa literalmente "ausencia".

Analogía financiera: en scoring crediticio, no es lo mismo "ingreso = 0" (la persona declaró que no tiene ingresos) que "ingreso = None" (la persona no contestó la pregunta). Confundir estos dos casos te rompe métricas y modelos. Un 0 se puede promediar; un None hay que decidir si lo excluís, lo imputás o lo marcás como dato faltante.

Para comparar con None, usá is None en vez de == None. is verifica identidad (es el mismo objeto en memoria), mientras que == verifica igualdad de valor. None es un singleton — solo existe UNA instancia — por eso is es más correcto y más rápido.

Conversión entre tipos (casting)

Muchas veces necesitás convertir un tipo a otro. Los datos que llegan de un CSV, una API o un formulario web vienen casi siempre como strings y necesitás convertirlos al tipo correcto para operar.

Función	Convierte a	Ejemplo	Resultado	¡Cuidado!
`int()`	Entero	`int("42")`	`42`	`int("42.5")` da error — primero float()
`float()`	Decimal	`float("3.14")`	`3.14`	`float("$100")` da error — limpiá el $
`str()`	Texto	`str(42)`	`"42"`	Siempre funciona
`bool()`	Booleano	`bool(0)`	`False`	`bool("False")` es `True` (string no vacío)
`int(float)`	Entero truncado	`int(3.99)`	`3`	Trunca, NO redondea. Usá round() si querés redondear

En data analysis: cuando leés un CSV con pandas, todas las columnas empiezan como string u object. Tu primer paso siempre es tipar correctamente: df["monto"] = pd.to_numeric(df["monto"]), df["fecha"] = pd.to_datetime(df["fecha"]). Si no tipás bien, un .sum() concatena strings en vez de sumar números, y tu reporte tiene basura.

Tip profesional: cuando cargás datos, validá tipos explícitamente y registrá las reglas de conversión. Si un campo "ingreso" viene como "$1,250.50", documentá que hay que sacar el $, reemplazar la coma, y convertir a float. Eso vuelve tu pipeline reproducible y auditable.

Ejemplos explicados paso a paso

Ejemplo 1: Crear variables de cada tipo y verificar con type()

La función type() te dice exactamente qué tipo tiene un valor. Usala constantemente cuando no estés seguro.

ejemplo_01_tipos.pyPython

# Los 5 tipos fundamentales de Python
edad = 28                    # int
precio = 1599.99             # float
nombre = "Rodrigo González"  # str
es_cliente = True            # bool
comentario = None            # NoneType

# Verificar cada tipo
print(f"edad = {edad}, tipo: {type(edad).__name__}")
print(f"precio = {precio}, tipo: {type(precio).__name__}")
print(f"nombre = {nombre}, tipo: {type(nombre).__name__}")
print(f"es_cliente = {es_cliente}, tipo: {type(es_cliente).__name__}")
print(f"comentario = {comentario}, tipo: {type(comentario).__name__}")

# Enteros en distintas bases
decimal = 255
binario = 0b11111111   # 255 en binario
hexa = 0xFF            # 255 en hexadecimal
print(f"\nDecimal: {decimal}, Binario: {binario}, Hexa: {hexa}")
print(f"¿Son iguales? {decimal == binario == hexa}")

# Separadores legibles
poblacion = 45_808_747
presupuesto = 1_250_000_000
print(f"\nPoblación Argentina: {poblacion:,}")
print(f"Presupuesto: ${presupuesto:,}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: El problema de precisión de float y la solución con Decimal

Este es probablemente el bug más famoso de la programación. Si trabajás con plata, tenés que entender esto.

ejemplo_02_precision.pyPython

from decimal import Decimal

# El problema clásico
print("=== Problema de precisión float ===")
print(f"0.1 + 0.2 = {0.1 + 0.2}")  # 0.30000000000000004!
print(f"¿0.1 + 0.2 == 0.3? {0.1 + 0.2 == 0.3}")  # False!

# Solución 1: round() — simple pero no siempre suficiente
print(f"\nCon round: {round(0.1 + 0.2, 1)}")

# Solución 2: Decimal — exacto para finanzas
print(f"\n=== Decimal (exacto) ===")
a = Decimal('0.1')
b = Decimal('0.2')
print(f"Decimal('0.1') + Decimal('0.2') = {a + b}")
print(f"¿Igual a 0.3? {a + b == Decimal('0.3')}")  # True!

# Simulación bancaria: 10,000 transacciones de $0.10
print(f"\n=== Acumulación de errores ===")
total_float = sum(0.1 for _ in range(10000))
total_decimal = sum(Decimal('0.1') for _ in range(10000))
print(f"Float:   ${total_float}")      # 999.9999999999...
print(f"Decimal: ${total_decimal}")     # 1000.0 exacto
print(f"Diferencia: ${abs(float(total_decimal) - total_float):.15f}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Operaciones entre tipos y qué pasa al mezclar

Python tiene reglas claras sobre qué operaciones están permitidas entre tipos distintos.

ejemplo_03_mezcla.pyPython

# int + float → siempre float (Python "promueve" al tipo más amplio)
print(f"10 + 2.5 = {10 + 2.5} (tipo: {type(10 + 2.5).__name__})")

# str + str → concatenación
print(f"'YPF' + ' SA' = {'YPF' + ' SA'}")

# int * str → repetición del string
print(f"'AR$ ' * 3 = {'AR$ ' * 3}")
print(f"'-' * 40 = {'-' * 40}")

# Operaciones PROHIBIDAS que dan TypeError:
# print("5" + 3)    # TypeError: no podés sumar str + int
# print("5" - "3")  # TypeError: no podés restar strings
# print("a" * "b")  # TypeError: no podés multiplicar str * str

# ¿Cómo resolverlo? Convertí explícitamente:
texto_monto = "1500"
print(f"\n'1500' + 500 = ERROR (str + int)")
print(f"int('1500') + 500 = {int(texto_monto) + 500}")  # 2000
print(f"'1500' + str(500) = {texto_monto + str(500)}")   # "1500500"

# bool como int (True=1, False=0)
print(f"\nTrue + True = {True + True}")    # 2
print(f"True * 100 = {True * 100}")        # 100
print(f"False + 42 = {False + 42}")        # 42

Hacé clic en ▶ Ejecutar

Ejemplo 4: Tabla completa de truthy/falsy

Entender qué valores son "falsy" te evita bugs sutiles. En pandas, esto es crítico para filtrar datos.

ejemplo_04_truthy.pyPython

# TODOS los valores falsy de Python
print("=== Valores FALSY (evalúan como False) ===")
falsys = [False, 0, 0.0, "", [], (), {}, set(), None]
for v in falsys:
    print(f"  {str(v):>10} ({type(v).__name__:>8}) → bool = {bool(v)}")

# Valores que PARECEN falsy pero SON truthy
print("\n=== Sorpresas TRUTHY ===")
truthys = ["0", "False", " ", [0], (0,), {"": 0}, -1, 0.0001]
for v in truthys:
    print(f"  {str(v):>12} ({type(v).__name__:>8}) → bool = {bool(v)}")

# Caso práctico: contar cuántos clientes son activos
estados = [True, True, False, True, False, True, True, False]
activos = sum(estados)  # True=1, False=0, sum cuenta los True
print(f"\nClientes activos: {activos}/{len(estados)}")
print(f"Tasa de actividad: {activos/len(estados):.0%}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Parsear datos reales — de string crudo a tipos correctos

Así se ven los datos en el mundo real: todo viene como texto y vos tenés que convertirlo. Este patrón lo vas a repetir cientos de veces como analista.

ejemplo_05_parseo.pyPython

# Dato crudo de un CSV o API (todo es string)
registro_crudo = "García|35|Buenos Aires|720|$250,000.50|True"

# Paso 1: separar por delimitador
campos = registro_crudo.split("|")
print(f"Campos crudos: {campos}")

# Paso 2: convertir cada campo al tipo correcto
nombre = campos[0]                              # ya es str
edad = int(campos[1])                            # str → int
ciudad = campos[2]                               # ya es str
score = int(campos[3])                           # str → int
ingreso = float(campos[4].replace("$", "").replace(",", ""))  # limpiar y convertir
activo = campos[5] == "True"                     # str → bool

# Paso 3: verificar tipos
print(f"\n=== Registro parseado ===")
print(f"Nombre:  {nombre} ({type(nombre).__name__})")
print(f"Edad:    {edad} ({type(edad).__name__})")
print(f"Ciudad:  {ciudad} ({type(ciudad).__name__})")
print(f"Score:   {score} ({type(score).__name__})")
print(f"Ingreso: ${ingreso:,.2f} ({type(ingreso).__name__})")
print(f"Activo:  {activo} ({type(activo).__name__})")

# Paso 4: ahora podemos operar con los datos tipados
print(f"\n=== Cálculos ===")
print(f"Ingreso mensual: ${ingreso/12:,.2f}")
print(f"Ratio score/edad: {score/edad:.1f}")
print(f"¿Mayor de edad? {edad >= 18}")
print(f"¿Score alto? {score >= 700}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Tipo	Ejemplo	Verificar	Convertir a	Notas
`int`	`42`, `-7`, `0xFF`	`type(x) is int`	`int("42")`	Sin límite de tamaño en Python
`float`	`3.14`, `1.5e10`	`type(x) is float`	`float("3.14")`	Impreciso — usar Decimal para finanzas
`str`	`"hola"`, `'mundo'`	`type(x) is str`	`str(42)`	Inmutable. Unicode nativo.
`bool`	`True`, `False`	`type(x) is bool`	`bool(0)`	Subclase de int (True=1)
`None`	`None`	`x is None`	—	Singleton. Usar `is`, no `==`

Valor	bool()	Categoría
`0`, `0.0`, `""`, `[]`, `{}`, `None`, `False`	`False`	Falsy
Todo lo demás (`1`, `"0"`, `[0]`, `-1`, `"False"`)	`True`	Truthy

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear variables y verificar tipos

Creá 5 variables (una de cada tipo: int, float, str, bool, None) e imprimí cada una con su tipo usando type().__name__. El output debe incluir NoneType.

ejercicio_01.pyDebe incluir "NoneType"

# Creá 5 variables de tipos distintos:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Conversión string a número con IVA

Tenés precio_texto = "1000". Convertilo a float, calculá con IVA 21% e imprimí el resultado. Debe incluir 1210.

ejercicio_02.pyDebe incluir "1210"

precio_texto = "1000"

# Convertí y calculá IVA:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Truthy y falsy

Creá una lista con estos valores: [0, "", "YPF", 42, None, [], False, "0"]. Recorrela e imprimí cada valor con su resultado de bool(). Debe incluir False.

ejercicio_03.pyDebe incluir "False"

valores = [0, "", "YPF", 42, None, [], False, "0"]

# Recorré e imprimí:
for v in valores:
    pass  # reemplazá pass

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Precisión float vs Decimal

Demostrá el problema de 0.1 + 0.2 con float y resolvelo con Decimal. Imprimí ambos resultados. Debe incluir exactamente 0.3.

ejercicio_04.pyDebe incluir "0.3"

from decimal import Decimal

# Mostrá el problema y la solución:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Celsius a Fahrenheit

Convertí celsius = 25 a Fahrenheit con la fórmula (celsius * 9/5) + 32. Verificá que el resultado sea float e imprimilo. Debe incluir 77.

ejercicio_05.pyDebe incluir "77"

celsius = 25

# Convertí y verificá el tipo:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Extraer CUIT

Dado cuit = "20-12345678-9", extraé el cuerpo numérico central (el "12345678") y convertilo a int. Imprimilo. Debe incluir 12345678.

ejercicio_06.pyDebe incluir "12345678"

cuit = "20-12345678-9"

# Extraé el cuerpo central y convertí a int:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Validador de tipo y truthy/falsy

Creá una función analizar(valor) que imprima el valor, su tipo y si es truthy o falsy. Probala con: False, "Galicia", 0, None, [1,2,3]. Debe incluir FALSY.

ejercicio_07.pyDebe incluir "FALSY"

def analizar(valor):
    # Imprimí: valor, tipo, TRUTHY o FALSY
    pass

analizar(False)
analizar("Galicia")
analizar(0)
analizar(None)
analizar([1, 2, 3])

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Limpiar montos con símbolos

Tenés montos_str = ["$1,500.00", "$820.50", "$3,200.00"]. Limpiá los símbolos, convertí a float, sumá e imprimí el total. Debe incluir 5520.5.

ejercicio_08.pyDebe incluir "5520.5"

montos_str = ["$1,500.00", "$820.50", "$3,200.00"]

# Limpiá, convertí y sumá:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Simulación bancaria float vs Decimal

Empezá con $100,000. Aplicá 2% de interés mensual durante 12 meses, una vez con float y otra con Decimal. Imprimí ambos resultados para mostrar la diferencia. Debe incluir Decimal.

ejercicio_09.pyDebe incluir "Decimal"

from decimal import Decimal

# Simulá con float y con Decimal:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Parsear registro completo a diccionario tipado

Dado "López|42|Córdoba|680|$185,000.00|False", parseá cada campo al tipo correcto y creá un diccionario con claves nombre, edad, ciudad, score, ingreso, activo. Imprimí el diccionario. Debe incluir ingreso.

ejercicio_10_desafio.pyDebe incluir "ingreso"

registro = "López|42|Córdoba|680|$185,000.00|False"

# Parseá y armá el diccionario:

Hacé clic en ▶ Ejecutar

Resumen y conexión

Python tiene 5 tipos fundamentales: int (sin límite), float (impreciso), str (inmutable), bool (True/False), None (ausencia).
Python tiene tipado dinámico: infiere el tipo automáticamente del valor asignado.
Los float tienen problemas de precisión (0.1+0.2 ≠ 0.3). Para finanzas, usá Decimal.
Todo valor tiene un comportamiento truthy/falsy. Los "falsy" son: 0, "", [], None, False.
Comparar con None se hace con is None, no con == None.
Los datos reales vienen como strings — siempre necesitás limpiar y convertir antes de operar.

En la siguiente lección (04 · Variables y constantes) vas a aprender cómo nombrar, organizar y reutilizar estos valores que acabás de tipar. Las buenas prácticas de naming son lo que separa código amateur de código profesional.

Recursos: Python docs — Built-in Types · Módulo decimal

Hecho con ❤️ por Rodri Gonzalez