Tipos de Datos: int, float, str, bool

Cada valor en Python tiene un tipo. El tipo determina que operaciones puedes realizar con ese valor y como se comporta en diferentes situaciones. Python es un lenguaje de tipado dinamico, lo que significa que no tienes que declarar explicitamente el tipo de una variable; Python lo infiere automaticamente. Sin embargo, es fundamental entender los diferentes tipos de datos porque afectan la forma en que tu codigo funciona.

Cuando hacems "5 + 5", Python suma los numeros y obtiene 10. Pero cuando hacems "5" + "5", Python concatena los strings y obtiene "55". La misma operacion (+) se comporta diferente dependiendo del tipo de dato. Por eso es crucial entender los tipos y como trabajar con ellos.

Los enteros, o ints, son numeros sin parte decimal. Pueden ser positivos, negativos o cero. En Python, no hay limite para el tamano de un entero (mas alla de la memoria de tu computadora), asi que puedes trabajar con numeros muy grandes sin problemas.

edad = 25
temperatura = -10
cuento = 0
poblacion = 7800000000

Los enteros son utiles para contar cosas, representar indices, almacenar edades, y cualquier situacion donde no necesites numeros decimales. Python maneja los enteros sin necesidad de especificar su tamano.

Puedes convertir otros tipos a entero usando la funcion int():

numero = int("42") # String a entero
decimal = int(3.99) # Float a entero (trunca, no redondea)
booleano = int(True) # Bool a entero (True=1, False=0)

Cuando conviertes un float a int, Python trunca la parte decimal sin redondear. int(3.99) da 3, no 4.

Los numeros flotantes, o floats, son numeros que tienen parte decimal. Se usan para calculos que requieren precision decimal, como mediciones, calculos financieros, y cualquier situacion donde las fracciones importen.

altura = 1.75
precio = 19.99
temperatura = -5.5
pi = 3.14159265

Es importante saber que los floats tienen precision limitada. Esto puede causar resultados inesperados en calculos:

resultado = 0.1 + 0.2
print(resultado) # 0.30000000000000004

Esto ocurre porque las computadoras representan numeros decimales en binario, y algunas fracciones no pueden representarse exactamente. Es un problema comun en todos los lenguajes de programacion. Para aplicaciones que requieren precision exacta (como dinero), Python tiene modulos especiales como decimal.

Convierte otros tipos a float con float():

entero = float(10) # 10.0
string = float("3.14") # 3.14
booleano = float(False) # 0.0

Los strings son secuencias de caracteres. Pueden contener letras, numeros, simbolos, y espacios. Son uno de los tipos mas utilizados en Python, especialmente cuando trabajas con texto, archivos, y entrada/salida de datos.

nombre = "Juan Perez"
ciudad = 'Madrid'
frase = "El disse"hola"ayer"
multilinea = """Este es un
string de multiples
lineas"""

Python ofrece muchas operaciones y metodos utiles para strings:

Longitud de un string:

mensaje = "Hola Mundo"
print(len(mensaje)) # 10

Indexing (acceder a caracteres):

mensaje = "Python"
print(mensaje[0]) # P (primer caracter)
print(mensaje[-1]) # n (ultimo caracter)

Slicing (obtener sub-strings):

mensaje = "Python"
print(mensaje[0:3]) # Pyt (del indice 0 al 2)
print(mensaje[:3]) # Pyt (inicio al 2)
print(mensaje[3:]) # hon (del 3 al final)

Metodos utiles:

texto = " Hola Mundo! "
print(texto.upper()) # " HOLA MUNDO! "
print(texto.lower()) # " hola mundo! "
print(texto.strip()) # "Hola Mundo!"
print(texto.replace("Mundo", "Python")) # " Hola Python! "

Buscar en strings:

frase = "El clima esta agradable hoy"
print("clima" in frase) # True
print("lluvia" in frase) # False

Los booleanos son el tipo mas simple: solo pueden tener dos valores: True (verdadero) o False (falso). Son fundamentales para la toma de decisiones en programacion, especialmente en estructuras condicionales y loops.

esMayorDeEdad = True
tienePermiso = False
estaActivo = True

En Python, otros tipos de datos pueden evaluarse como booleanos. Valores que se consideran falsos (falsy):

• None
• False
• 0 (entero o flotante)
• "" (string vacio)
• [] (lista vacia)
• {} (diccionario vacio)
• () (tupla vacia)
• set() (conjunto vacio)

Todos los demas valores se consideran verdaderos (truthy).

print(bool(1)) # True
print(bool(0)) # False
print(bool("hola")) # True
print(bool("")) # False

Esto es muy util para verificar si un valor existe o no:

nombre = ""
if nombre:
print("Hola,", nombre)
else:
print("Por favor ingresa tu nombre")

Python permite convertir explicitamente entre tipos usando funciones de conversion:

String a numero

edad = "25"
edad_int = int(edad) # 25
edad_float = float(edad) # 25.0

Numero a string

precio = 19.99
precio_str = str(precio) # "19.99"

String a lista

palabra = "python"
lista = list(palabra) # ['p', 'y', 't', 'h', 'o', 'n']

Bool a string

activo = True
activo_str = str(activo) # "True"

Es importante manejar errores al convertir tipos. Si intentas convertir un string invalido a numero, Python generara un error:

numero = int("hola") # ValueError: invalid literal for int()

Para evitar esto, puedes usar try/except (lo aprenderas mas adelante) o verificar que el string sea valido antes de convertir.

Los operadores de comparacion siempre devuelven un valor booleano:

a = 10
b = 5

print(a == b) # False (igual a)
print(a != b) # True (diferente de)
print(a > b) # True (mayor que)
print(a < b) # False (menor que)
print(a >= b) # True (mayor o igual)
print(a <= b) # False (menor o igual)

Puedes encadenar comparaciones en Python:

x = 5
print(1 < x < 10) # True (x esta entre 1 y 10)

Python tiene dos operadores de identidad: is e is not. Estos comparan si dos variables apuntan al mismo objeto en memoria, no si tienen el mismo valor. Esto es diferente de == que compara valores.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b) # True (tienen el mismo contenido)
print(a is b) # False (son objetos diferentes)
print(a is c) # True (c es el mismo objeto que a)

Para tipos simples (numeros, strings), Python reutiliza objetos para valores pequenos (esta optimizacion se llama interning), pero no debes confiar en esto. Usa == para comparar valores y is para comparar identidad.

A veces necesitas combinar diferentes tipos en una operacion. Python no puede sumar un string y un numero directamente:

nombre = "Juan"
edad = 30
print(nombre + edad) # TypeError

Debes convertir primero:

nombre = "Juan"
edad = 30
print(nombre + str(edad)) # "Juan30"
print(f"{nombre} tiene {edad} años") # "Juan tiene 30 años"

Las f-strings (formatted string literals) son una forma moderna y legible de incluir variables dentro de strings:

producto = "Laptop"
precio = 899.99
print(f"El {producto} cuesta ${precio}")
print(f"Precio con IVA: ${precio * 1.16:.2f}")

Resumen

• Enteros (int): numeros sin decimal
• Flotantes (float): numeros con decimal
• Strings (str): texto o secuencias de caracteres
• Booleanos (bool): True o False
• type() muestra el tipo de una variable
• Las funciones int(), float(), str(), bool() convierten tipos
• Los operadores de comparacion devuelven booleanos
• is e is not comparan identidad, == compara valores
• f-strings facilitan incluir variables en strings

En la proxima leccion, aprenderemos sobre operadores aritmeticos y logicos, que te permitiran realizar calculos y tomar decisiones complejas.