Ciencia de Gatos

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

Un tipo de dato es la naturaleza o forma que tiene la información dentro de un programa. Puede ser un número, una palabra, una lista de cosas, un valor verdadero o falso, entre otros. Cada tipo de dato define qué operaciones puedes hacer con él y cómo se comporta en la memoria.

Python es un lenguaje de tipado dinámico, lo que significa que no necesitas especificar el tipo de dato cuando declaras una variable. En el caso de Python, se infiere automáticamente. Sin embargo, entender qué tipo de dato estás usando es fundamental para:

• Escribir código más claro y legible.
• Evitar errores al combinar tipos incompatibles.
• Optimizar la memoria y el rendimiento.

Imagina que los datos son los juguetes de tu gato. No es lo mismo una pelota (un dato simple como un int), que una caja con juguetes distintos (list), o una etiqueta con su nombre y edad (dict). Cada uno tiene su función.

🔢 int: Números enteros

¿Qué es un int?

Un int (abreviatura de integer) representa un número entero: positivo, negativo o cero, sin parte decimal. Es uno de los tipos más usados porque muchas cosas en el mundo real se cuentan con números exactos: patas, vidas, galletas para gatos…

En Python puedes escribirlos simplemente así:

edad = 5
nivel_maldad = -3
saltos = 0

🐾 ¿Cuándo usar int?

• Cuando quieres contar cosas: número de gatos, juguetes, arañazos.
• Al recorrer bucles (for i in range(10)) donde cada paso es un número entero.
• Para comparar cantidades discretas: ¿hay más ratones que pelotas?

🧪 Ejemplo práctico

gatos = 4
zapatillas_robadas = 2
total_zapatillas = gatos * zapatillas_robadas
print(total_zapatillas)  # Resultado: 8

Explicación: Multiplicamos el número de gatos por cuántas zapatillas roba cada uno. Estamos haciendo aritmética entera: sin decimales, sin complicaciones.

🔍 Operaciones comunes con int

• +, -, *, /: suma, resta, multiplicación y división (¡ojo! / devuelve float)
• //: división entera (descarta los decimales)
• %: módulo (resto de la división)
• **: potencia

print(7 // 2)  # 3
print(7 % 2)   # 1

✅ Ventajas

• Precisión total: 7 siempre es 7.
• Es rápido y ligero para la memoria.
• Se usa en casi todos los bucles, contadores y cálculos básicos.

❌ Inconvenientes

• No sirve para representar medidas fraccionadas (peso, tiempo…).
• Aunque 4 / 2 da 2.0, ya es un float, no un int.

🐱 Comparación felina:

• Un int es como contar los saltos que da tu gato desde la cama al suelo. No hay saltos a medias. Cada salto cuenta completo o no cuenta.
• También es como contar cuántas veces se sube a la encimera antes de que lo regañes. ¡Cifra exacta, sin decimales ni sorpresas!

💧 float: Números decimales

¿Qué es un float?

Un float (abreviatura de floating point number, o número de punto flotante) representa un número que puede tener parte decimal. Son útiles cuando necesitas expresar medidas precisas o fraccionadas, como el peso de tu gato, la cantidad de comida que debe comer, o el tiempo que tarda en subir a la estantería más alta.

peso = 4.5         # 4.5 kg
temperatura = 38.2 # grados Celsius
tiempo = 2.75      # segundos

Python reconoce automáticamente un número como float si lleva punto decimal, incluso si es algo como 5.0.

¿Cuándo usar float?

• Cuando necesitas representar medidas físicas reales como peso, temperatura o velocidad.
• Para operaciones que devuelven resultados fraccionarios.
• En cálculos científicos o estadísticos, donde la precisión decimal es esencial.
• Cuando trabajas con divisiones y necesitas el valor exacto (en vez de redondear).

🧪 Ejemplo práctico

peso_gato = 4.5         # en kilos
comida_por_kg = 0.25    # en kilos de comida por día
comida_total = peso_gato * comida_por_kg
print(comida_total)     # Resultado: 1.125

📌 En este ejemplo, multiplicamos el peso del gato por la cantidad de comida diaria por kilo. Si usáramos int, perderíamos precisión (¡y Mochi pasaría hambre!).

🧠 ¿Y si algo no cuadra?

print(0.1 + 0.2 == 0.3)  # False

😾 ¡Eso parece un error! Pero en realidad, es un fenómeno común en informática: los decimales no se representan de forma exacta en binario, lo que genera pequeñas diferencias al sumar.

✅ Solución:

import math
print(math.isclose(0.1 + 0.2, 0.3))  # True

math.isclose() comprueba si los números son casi iguales, dentro de un margen razonable. Es el equivalente a decir: “No es exacto, pero está lo suficientemente cerca”.

🔧 Operaciones comunes

• +, -, *, /, ** funcionan igual que con enteros.
• round(numero, decimales) → redondea a cierta cantidad de cifras
• math.floor() y math.ceil() → redondeo hacia abajo o arriba.

round(1.23456, 2)  # 1.23

✅ Ventajas

• Perfecto para trabajar con fracciones reales y medidas físicas.
• Permite precisión donde los enteros no bastan.
• Compatible con casi todas las operaciones matemáticas.

❌ Inconvenientes

• Puede ser ligeramente impreciso debido al sistema binario.
• Comparar directamente dos float puede dar resultados inesperados.
• Más costoso a nivel computacional que un int (aunque en la práctica, esto rara vez importa).

🐱 Comparación felina:

• Un float es como pesar a tu gato en una balanza digital: 4.25 kg, no simplemente 4.
• O como calcular el tiempo exacto que tarda en llegar desde el sofá hasta la ventana: 1.67 segundos. Porque cada milésima cuenta cuando estás cazando un mosquito. 🦟

🐾 str: Cadenas de texto

¿Qué es un str?

Un str (abreviatura de string, o cadena) es una secuencia ordenada de caracteres encerrada entre comillas. Puede contener letras, números, espacios, símbolos, e incluso emojis 😻. Es el tipo de dato ideal para representar nombres, frases, etiquetas, comandos, direcciones, textos y todo lo que no sea numérico en esencia.

nombre = "Mochi"
mensaje = '¡Bienvenido a casa!'
emoji = "😺"

En Python puedes usar comillas simples ('texto') o dobles ("texto"), y también triples ('''texto''' o """texto""") para cadenas multilínea.

 ¿Cuándo usar str?

• Cuando trabajas con nombres de usuario, etiquetas o títulos.
• Si vas a mostrar información al usuario (saludos, mensajes de error, instrucciones).
• Al almacenar texto proveniente de formularios, archivos o la web.
• Cuando necesitas generar reportes, imprimir resultados o manipular frases.

🧪 Ejemplo práctico

nombre = "Bigotes"
saludo = f"¡Hola, {nombre}! 🐾"
print(saludo) #¡Hola, Bigotes! 🐾

📌 Este ejemplo usa una f-string, una forma muy cómoda de insertar variables dentro de un texto sin tener que concatenar manualmente.

También podrías hacerlo así:

saludo = "Hola, " + nombre + "! 🐾"

Pero las f-strings son más claras y fáciles de mantener, especialmente si tienes muchos valores que mostrar.

🔍 Cosas útiles que puedes hacer con str

Las cadenas en Python vienen con muchos métodos integrados. Algunos de los más útiles son:

texto = "  Mi gato es gris  "
print(texto.strip())       # Elimina espacios al inicio y final
print(texto.upper())       # Pasa a mayúsculas
print(texto.lower())       # Pasa a minúsculas
print(texto.replace("gris", "negro"))  # Sustituye palabras
print(len(texto))          # Cuenta los caracteres, incluyendo espacios

También puedes recorrerlas como si fueran listas:

for letra in "gato":
    print(letra)


# g
# a
# t
# o

🔧 Concatenación y repetición

miau = "miau " * 3
print(miau)  # miau miau miau 

Puedes unir cadenas usando el operador +, aunque para muchas piezas de texto juntas, se recomienda join():

partes = ["Hola", "gato", "bonito"]
print(" ".join(partes))  # Hola gato bonito

✅ Ventajas

• Extremadamente versátil: puedes usarlo en casi cualquier parte del programa.
• Tiene muchos métodos útiles para transformar y analizar el texto.
• Compatible con otros tipos gracias a la conversión (por ejemplo, str(123)).

❌ Inconvenientes

• No apto para cálculos matemáticos directos.
• Comparar cadenas puede ser sensible a mayúsculas/minúsculas ("Gato" != "gato").
• A veces necesitas transformar el tipo antes de trabajar con números (int("5")).

🐱 Comparación felina:

• Un str es como el collar de identificación de tu gato: tiene su nombre, número de chip, e incluso un "Si me pierdo, llámame" grabado. Todo eso es texto.
• También es lo que usarías para registrar el nombre de un minino en una base de datos: "Luna", "Nube", "Copito". No importa si se llama "Señor Bigotes V", el str lo representa todo.

🔘 bool: Verdadero o falso

¿Qué es un bool?

Un bool (abreviatura de boolean) es un tipo de dato lógico que solo puede tener dos valores:

• True (verdadero)
• False (falso)

No hay más. Dos únicas opciones. Es como cuando le preguntas a tu gato:

• ¿Hay caja vacía? → True
• ¿Hay baño con puerta cerrada? → False

En programación, los booleanos son la base de todas las decisiones. Le dicen a Python si debe hacer una cosa o no. Son fundamentales en estructuras como if, while, y en comparaciones (==, !=, <, etc.).

¿Cuándo usar bool?

• Para expresar condiciones: “¿Está activado?”, “¿Funciona?”, “¿Ha terminado?”.
• Al validar resultados: “¿Este valor es mayor que aquel?”, “¿La lista está vacía?”.
• Para activar o desactivar funcionalidades: interruptores, estados, banderas.
• En filtros o búsquedas: “¿Este elemento cumple la condición?”.

🧪 Ejemplo práctico

hambriento = True

if hambriento:
    print("¡A comer atún!")
else:
    print("Hora de la siesta.")

# ¡A comer atún!

📌 En este ejemplo, la variable hambriento controla lo que hace el programa. Si es True, se imprime un mensaje; si no, se hace otra cosa.

Comparaciones que devuelven bool

print(4 > 2)        # True
print("gato" == "Gato")  # False
print(5 != 10)      # True

Cada comparación evalúa si la afirmación es cierta o no. Es el pensamiento lógico del programa.

Los booleanos son números

En Python, los valores True y False se comportan internamente como 1 y 0, respectivamente. Por eso:

print(True + True + False)  # 2
print(int(True))  # 1
print(int(False)) # 0

Esto permite usar bool en operaciones matemáticas sencillas, especialmente para contar condiciones cumplidas.

¿Cómo saber si algo es “verdadero” o “falso”?

Casi cualquier cosa puede evaluarse como True o False. Algunos ejemplos:

bool(0)            # False
bool(42)           # True
bool("")           # False
bool("gatito")     # True
bool([])           # False (lista vacía)
bool([1, 2, 3])    # True (lista con elementos)

💡 Vacío = False

💡Con contenido = True

✅ Ventajas

• Perfecto para controlar el flujo del programa.
• Muy claro y expresivo: dice lo que ocurre o no.
• Compatible con estructuras condicionales y lógicas.

❌ Inconvenientes

• Solo permite dos estados: puede ser poco flexible para estados más complejos.
• A veces puedes confundirte si una variable parece falsa (0, "", []) pero no lo es en tu lógica.

🐱 Comparación felina:

• Los gatos piensan en booleanos todo el rato. ¿Hay caja disponible? → True ¿La puerta está abierta? → True ¿Te obedecerá? → False
• Es su manera natural de razonar: sin grises, solo sí o no.

🧺 list: Listas

¿Qué es una lista?

Una lista (list) es una colección ordenada y mutable de elementos. Es decir, puedes cambiarla, añadir o quitar cosas, y sus elementos se mantienen en el orden en que los colocaste. Puedes guardar casi cualquier cosa dentro: números, textos, booleanos, incluso otras listas.

Es como una caja de juguetes para tu gato: puedes meter un ratón de peluche, una pelota, una cuerda, y luego agregar un láser o sacar lo que ya no usa. La caja sigue siendo la misma, pero su contenido cambia.

juguetes = ["ratón", "pelota", "plumero"]

¿Cuándo usar listas?

• Cuando necesitas una colección que pueda crecer, reducirse o cambiar.
• Para recorrer elementos uno a uno (por ejemplo, en un bucle for).
• Al guardar varios valores relacionados bajo una misma variable.
• Para ordenar, filtrar o clasificar conjuntos de datos.

🧪 Ejemplo práctico

juguetes = ["ratón", "pelota"]
juguetes.append("caja")
print(juguetes)  # ['ratón', 'pelota', 'caja']

# ['ratón', 'pelota', 'caja']

📌 Aquí usamos .append() para añadir un nuevo elemento a la lista. Python mantiene el orden de los elementos.

Puedes acceder a cada elemento por su posición (índice), empezando desde cero:

print(juguetes[0])  # ratón

Y puedes modificarlo:

juguetes[1] = "cuerda"
print(juguetes)  # ['ratón', 'cuerda', 'caja']

🔍 Métodos útiles de list

gatos = ["Luna", "Simba", "Nube"]

gatos.append("Copito")         # Añade al final
gatos.insert(1, "Bigotes")     # Inserta en posición 1
gatos.remove("Simba")          # Elimina el primer "Simba"
ultimo = gatos.pop()           # Quita y devuelve el último elemento
gatos.sort()                   # Ordena alfabéticamente
gatos.reverse()                # Invierte el orden

También puedes mezclar tipos (aunque se recomienda mantener coherencia):

cosas = ["Mochi", 3, True]

Otra de las cosas útiles que puedes hacer es recorrer una lista

gatos = ["Luna", "Simba", "Nube"]
for gato in gatos:
    print(f"Hola, {gato} 😺")

# Hola, Luna 😺
# Hola, Simba 😺
# Hola, Nube 😺

Esto permite hacer algo con cada elemento, uno a uno.

✅ Ventajas

• Súper flexible: puedes agregar, quitar o modificar lo que quieras.
• Compatible con bucles y condiciones.
• Soporta múltiples tipos de datos.

❌ Inconvenientes

• Puede ocupar más memoria si crece mucho.
• Menos eficiente que estructuras inmutables (como tuple) cuando no necesitas cambiarla.
• No se puede usar como clave en un dict porque es mutable.

🐱 Comparación felina:

• Una lista es como la estantería donde tu gato guarda sus juguetes favoritos (aunque él diga que no los mueve, todos sabemos que sí).
• Es también como la agenda de escondites de siesta: ["sofá", "caja", "radiador"]. Puede cambiar día a día.
• Y si un día encuentra una caja nueva, ¡la añade sin problemas con .append("caja nueva")!

🪨 tuple: Tuplas

¿Qué es una tupla?

Una tupla (o tuple) es una colección ordenada pero inmutable. Es decir, funciona como una lista, pero no se puede modificar después de su creación. No puedes añadirle nuevos elementos, quitarlos, ni cambiar los que ya tiene.

💡 Piensa en una tupla como un conjunto de coordenadas, una etiqueta con información fija o un pack sellado: puedes mirar dentro, puedes usar lo que contiene, pero no puedes cambiarlo sin abrir otro pack nuevo.

coordenadas = (10, 20)

¿Cuándo usar las tuplas?

• Cuando quieres asegurarte de que los datos no cambien accidentalmente.
• Si necesitas asociar múltiples valores fijos, como posición (x, y) o fechas (día, mes, año).
• Para usar como clave en un diccionario, ya que las listas no pueden ser claves.
• Cuando el orden importa, pero la seguridad es más importante que la flexibilidad.

🧪 Ejemplo práctico

gatito = ("Nube", 3, "gris")
nombre, edad, color = gatito
print(f"{nombre} tiene {edad} años y es de color {color}.")

# Nube tiene 3 años y es de color gris.

📌 Aquí usamos una técnica llamada “desempaquetado” para extraer los valores de una tupla y asignarlos a variables individuales. Es limpio, legible y muy útil.

🔍 Cosas que puedes hacer con una tuple

Aunque no puedes modificarla, puedes:

• Acceder a sus elementos con índices
• Recorrerla en un bucle
• Saber su longitud

print(gatito[0])  # Nube

gatito = ("Nube", 3, "gris")
for dato in gatito:
    print(dato)

# Nube
# 3
# gris

print(len(gatito))  # 3

✅ Ventajas

• Seguridad: no se puede modificar por accidente.
• Más rápida que una lista en operaciones repetidas.
• Puede usarse como clave en diccionarios o como elemento en un set.
• Ideal para representar registros simples que no van a cambiar.

❌ Inconvenientes

• No se puede cambiar sin crear una nueva tupla.
• Menos métodos disponibles que una lista.
• Puede ser menos intuitiva al trabajar con colecciones dinámicas.

🐱 Comparación felina:

• Una tupla es como la caja favorita de tu gato cuando viene con las mantas dobladas justo como le gusta: nadie la toca. Si cambias algo, ya no es la misma experiencia.
• También es como las coordenadas de su escondite preferido: (sofá, detrás, manta). No cambia nunca, y si lo hace… deja de ser especial.
• O como su nombre completo con título: ("Señor Bigotes", "III", "de la Casa Ravenclaw"). No lo vas a estar editando cada vez que lo llamas.

🗂️ dict: Diccionarios

¿Qué es un diccionario?

Un dict (abreviatura de dictionary, o diccionario) es una estructura de datos que almacena pares clave-valor. Cada valor está asociado a una clave única, que actúa como una etiqueta o identificador.

Piensa en un diccionario de verdad: buscas una palabra (la clave), y obtienes su definición (el valor). En Python, puedes hacer lo mismo, pero con cualquier tipo de información: el nombre de un gato, su edad, su color, si está vacunado, etc.

gato = {
    "nombre": "Mochi",
    "edad": 2,
    "color": "gris",
    "esterilizado": True
}

¿Cuándo usar los diccionarios?

• Cuando quieras organizar datos de forma estructurada (como si fueran fichas).
• Si necesitas acceder rápidamente a un valor a través de un nombre o etiqueta.
• Para representar objetos del mundo real, con múltiples atributos.
• Al trabajar con formatos tipo JSON, bases de datos o APIs.

🧪 Ejemplo práctico

gato = {"nombre": "Luna", "edad": 4, "color": "negro"}

print(gato["nombre"])
print(f"{gato['nombre']} tiene {gato['edad']} años.")


# Luna
# Luna tiene 4 años.

📌 Aquí usamos las claves "nombre" y "edad" para acceder a los valores almacenados. A diferencia de una lista, no necesitas saber la posición; solo el nombre de la clave.

🔍 Qué puedes hacer con un diccionario

• Añadir o modificar valores
• Eliminar una clave
• Recorrer un diccionario
• Obtener solo las claves o los valores
• Comprobar si una clave existe

# Creamos un diccionario con algunos datos básicos de un gato
gato = {
    "nombre": "Luna",
    "edad": 4,
    "color": "negro"
}

# Añadir o modificar valores en el diccionario
gato["peso"] = 4.5               # Añade una nueva clave 'peso' con valor 4.5
gato["color"] = "gris"           # Modifica el valor de la clave 'color'

# Eliminar una clave
del gato["peso"]                 # Elimina completamente la clave 'peso' del diccionario

# Recorrer el diccionario y mostrar clave y valor
for clave, valor in gato.items():
    print(f"{clave}: {valor}")

# Obtener solo las claves o los valores
print(gato.keys())               # dict_keys(['nombre', 'edad', 'color'])
print(gato.values())             # dict_values(['Luna', 4, 'gris'])

# Comprobar si una clave existe
if "nombre" in gato:
    print("Este gato tiene nombre.")

✅ Ventajas

• Acceso rápido a la información usando claves personalizadas.
• Ideal para representar objetos complejos con muchos atributos.
• Compatible con estructuras de datos más avanzadas (JSON, objetos anidados).
• Muy útil para buscar, actualizar y organizar datos con claridad.

❌ Inconvenientes

• No puedes acceder a los valores por posición numérica como en una lista.
• Las claves deben ser únicas y preferiblemente inmutables (como str, int, tuple).
• Puede ser más difícil de recorrer o manipular si es muy anidado.

🐱 Comparación felina:

• Un diccionario es como la ficha veterinaria de tu gato: tiene su nombre, edad, peso, vacunas, etc. Cada dato tiene su propia etiqueta.
• También es como su perfil secreto de internet: {"usuario": "bigotes_lover", "edad": 5, "ronronea": True}
• O como una base de datos casera para tus mininos:

gatos = {
    "Luna": {"edad": 4, "color": "negro"},
    "Nube": {"edad": 2, "color": "blanco"}
}
print(gatos["Luna"]["color"])  # negro

📋 Resumen de los tipos de datos

Y recuerda, programar con Python tiene algo de cuidar a un gato: a veces no sabes por qué falla algo, a veces todo funciona sin razón aparente… pero con un poco de paciencia, todo empieza a tener sentido. 🐾 Sigue practicando, probando cosas y, sobre todo, jugando.

“Use the right data type for the job. Don’t use a float when an integer will do. Don’t use a string when you have an enumerated type.”Steve McConnell (autor de Code Complete)

❤️Gracias a Álex por contribuir con los ejemplos (aunque no sea un gato)