Variables y Tipos de Datos en Python 💾

Los cimientos de la programación: aprende a almacenar, etiquetar y clasificar información para resolver problemas científicos y cotidianos.

1. ¿Qué son las Variables? Entendiendo los Contenedores de Datos

Imagina que estás en un laboratorio 🧪. Tienes diferentes recipientes para guardar sustancias: uno para el agua, otro para el ácido, uno para una muestra de suelo, etc. Cada recipiente tiene una etiqueta que te dice qué contiene. En programación, una variable es muy similar: es como un contenedor con una etiqueta (su nombre) que guarda un valor o dato específico.

Puedes pensar en una variable como un espacio reservado en la memoria de la computadora donde se almacena información. Lo más importante es que el valor guardado en una variable puede cambiar durante la ejecución de un programa, ¡pero su nombre (la etiqueta) generalmente permanece igual! 📦✨

En Python, las variables son más técnicamente referencias o "punteros" a objetos que residen en la memoria. Esto significa que el nombre de la variable no contiene el dato en sí mismo, sino la dirección de memoria donde se encuentra ese dato. Esta característica es parte de lo que hace a Python tan dinámico y flexible.

2. Definición y Asignación de Variables

Crear (o "declarar") una variable en Python es muy sencillo. Simplemente eliges un nombre para tu variable y usas el signo igual (=), conocido como el operador de asignación, para darle un valor.

Sintaxis Básica:

nombre_de_la_variable = valor_a_guardar

Cuando Python ejecuta esta línea, hace tres cosas:

1. Crea un objeto en memoria para guardar el valor_a_guardar.
2. Crea la etiqueta nombre_de_la_variable.
3. Hace que nombre_de_la_variable apunte o referencie a la ubicación en memoria de ese valor.

🔬 Ejemplos Aplicados a las Ciencias:

# En Física ⚛️
velocidad_luz_vacio = 299792458  # Unidad: metros por segundo (m/s)
constante_planck = 6.62607015e-34 # Unidad: Joules por segundo (J·s)
temperatura_fusion_agua = 0.0    # Unidad: grados Celsius (°C)
aceleracion_g = 9.81             # Unidad: metros por segundo al cuadrado (m/s²)

# En Biología 🧬
numero_cromosomas_humano = 46    # Adimensional
ph_sangre_humana = 7.4           # Escala de pH (adimensional)
es_organismo_eucariota = True    # Valor booleano (Verdadero/Falso)
nombre_cientifico_humano = "Homo sapiens" # Cadena de texto

# En Matemáticas 📐
numero_pi = 3.1415926535
radio_esfera = 5.2               # Podría ser en cm, m, etc.
angulo_en_radianes = 1.57        # Aproximadamente pi/2
ecuacion_lineal = "y = 2*x + 3"  # Representación como texto

# En Química 🧪
masa_molar_agua = 18.01528       # Unidad: gramos por mol (g/mol)
numero_avogadro = 6.022e23       # Unidad: partículas por mol (mol⁻¹)
simbolo_oxigeno = "O"
es_reaccion_exotermica = False

En Google Colab, puedes escribir estas asignaciones en una celda de código y luego usar print(nombre_de_la_variable) en la misma celda o en celdas posteriores para ver sus valores.

3. Estilos de Nomenclatura en Python (PEP 8)

Elegir buenos nombres para tus variables es crucial. No solo se trata de que el código funcione, sino de que sea fácil de leer y entender. En Python, la guía de estilo oficial PEP 8 nos da recomendaciones claras. ¡Vamos a ver las más importantes!

# Variables científicas:
masa_particula_kg = 1.67e-27
velocidad_inicial_mps = 25.0
energia_cinetica_julios = 0.0

// Evitar en Python para variables:
masaParticula = 1.67e-27
velocidadInicial = 25.0

# Solo para Clases:
class CalculadoraFisica:
    pass
# No para variables: MasaObjeto = 5.0

# Constantes:
PI = 3.14159265
GRAVEDAD_TIERRA = 9.80665 # m/s²

4. Tipos de Datos Fundamentales en Python

Cuando asignas un valor a una variable, ese valor tiene un "tipo". Python maneja varios tipos de datos básicos de forma automática. Conocerlos es esencial para realizar operaciones correctas y entender cómo Python trabaja con la información. En Google Colab, puedes experimentar fácilmente con estos tipos.

numero_estudiantes = 35
anio_actual = 2024
temperatura_minima = -5
puntos_obtenidos = 1500

pi = 3.14159
distancia_km = 12.75
concentracion_molar = 0.05
peso_promedio_kg = 70.5

numero_complejo = 3 + 4j
impedancia_z = 10 - 5j
# print(numero_complejo.real) -> 3.0
# print(numero_complejo.imag) -> 4.0

nombre_planeta = "Tierra"
mensaje = '¡Hola, científico!'
formula_agua = "H₂O"
descripcion = """Experimento sobre
la fotosíntesis."""

es_valido = True
hay_error = False
mayor_que_cero = (5 > 0) # True
es_par = (4 % 2 == 0)  # True

masa = 5.67
print(f"Valor: {masa}, Tipo: {type(masa)}")
# Salida: Valor: 5.67, Tipo: 

nombre = "Einstein"
print(f"'{nombre}' es instancia de str? {isinstance(nombre, str)}")
# Salida: 'Einstein' es instancia de str? True

5. Tipado Dinámico: La Flexibilidad de Python

Una característica distintiva de Python es que es un lenguaje de tipado dinámico. Esto significa que no necesitas declarar explícitamente el tipo de una variable antes de usarla. Python infiere automáticamente el tipo de dato en el momento en que le asignas un valor.

Además, una misma variable puede "apuntar" a datos de diferentes tipos en diferentes momentos durante la ejecución del programa.

mi_variable = 10          # Python sabe que mi_variable es un entero (int)
print(f"Valor: {mi_variable}, Tipo: {type(mi_variable)}")

mi_variable = "Hola, científico!" # Ahora mi_variable apunta a una cadena (str)
print(f"Valor: '{mi_variable}', Tipo: {type(mi_variable)}")

mi_variable = 3.14159   # Y ahora es un flotante (float)
print(f"Valor: {mi_variable}, Tipo: {type(mi_variable)}")

Esta flexibilidad es muy conveniente y hace que Python sea rápido para prototipar y aprender. Sin embargo, también significa que debes tener cuidado y saber qué tipo de dato esperas en tus variables para evitar errores en tiempo de ejecución.

6. Anotaciones de Tipo (Type Hints) - Una Guía Opcional

Aunque Python es de tipado dinámico, a partir de Python 3.5, se introdujeron las anotaciones de tipo. Son una forma opcional de indicar qué tipo de dato se espera para una variable, un parámetro de función o el valor que devuelve una función.

nombre_cientifico: str = "Felis catus"
edad_aproximada: int = 5
peso_kg: float = 4.5
es_mamifero: bool = True

def calcular_energia_cinetica(masa: float, velocidad: float) -> float:
    """Calcula la energía cinética. Espera masa y velocidad como float, devuelve float."""
    return 0.5 * masa * (velocidad ** 2)

energia: float = calcular_energia_cinetica(masa=10.0, velocidad=5.0)
print(f"Energía calculada: {energia} Joules")

Puntos Clave sobre Type Hints:

• Opcionales: Python funciona perfectamente sin ellas.
• No Verificadas por Python en Tiempo de Ejecución: Por defecto, Python no lanza errores si los tipos no coinciden con las anotaciones.
• Para Legibilidad y Herramientas: Ayudan a otros (y a tu yo futuro) a entender el código. Son muy útiles para editores de código (autocompletado) y herramientas de análisis estático (como MyPy) que sí pueden verificar los tipos.

7. Conversión de Tipos Explícita (Type Casting)

A veces, necesitas convertir un valor de un tipo de dato a otro. Por ejemplo, la función input() siempre devuelve el dato ingresado por el usuario como una cadena de texto (str), incluso si el usuario escribe un número. Para realizar operaciones matemáticas con esa entrada, primero debes convertirla a un tipo numérico (int o float). Este proceso de conversión explícita se llama type casting.

Python ofrece funciones incorporadas para estas conversiones:

• int(valor): Intenta convertir valor a un entero.
• float(valor): Intenta convertir valor a un número de punto flotante.
• str(valor): Convierte valor a una cadena de texto.
• bool(valor): Convierte valor a un booleano (la mayoría de los valores son True; 0, 0.0, "", [], None, etc., son False).

Ejemplos de Conversión de Tipos:

# De cadena a número (muy común con input())
edad_texto = input("Ingresa tu edad: ") # ej: el usuario escribe "25"
edad_numero = int(edad_texto)           # Convertimos "25" (str) a 25 (int)
print(f"En 10 años tendrás: {edad_numero + 10} años")

altura_texto = input("Ingresa tu altura en metros (ej: 1.75): ")
altura_flotante = float(altura_texto)   # Convertimos a float
print(f"El doble de tu altura es: {altura_flotante * 2} m")

# De número a cadena
numero_experimento = 42
id_experimento = "EXP-" + str(numero_experimento) # Convertimos 42 a "42" para concatenar
print(id_experimento) # Salida: EXP-42

# De número a booleano
cantidad_muestras = 0
hay_muestras = bool(cantidad_muestras) # False, porque cantidad_muestras es 0
print(f"¿Hay muestras?: {hay_muestras}")

lectura_sensor = 0.001
sensor_activo = bool(lectura_sensor)  # True, porque no es cero
print(f"¿Sensor activo?: {sensor_activo}")

8. Palabras Reservadas (Keywords) de Python

Python tiene un conjunto de palabras especiales, llamadas palabras reservadas o keywords, que tienen un significado predefinido y una función específica dentro del lenguaje. ¡No puedes usar estas palabras como nombres para tus variables, funciones o clases!

Si intentas usar una palabra reservada como nombre de variable, Python te dará un error de sintaxis (SyntaxError).

Aquí tienes algunas de las más comunes. No necesitas memorizarlas todas ahora, pero es bueno reconocerlas:

Puedes ver la lista completa de palabras reservadas en tu versión de Python ejecutando el siguiente código en una celda de Google Colab o en una consola de Python:

import keyword
print(keyword.kwlist)

9. El Valor Especial: None

En Python, None es una palabra reservada y un objeto único que representa la ausencia de valor o un valor nulo. Es de tipo NoneType.

Es importante distinguirlo de 0 (cero), False (falso), o una cadena vacía "". None significa que una variable no tiene asignado ningún valor concreto o que una función no devuelve nada útil.

¿Cuándo se usa None?

• Para inicializar una variable cuando aún no se conoce su valor definitivo:

  datos_del_sensor = None # Aún no hemos leído el sensor
  resultado_calculo = None # El cálculo no se ha realizado

• Las funciones que no especifican un valor de retorno con la palabra clave return, devuelven None implícitamente.
• Como valor predeterminado para parámetros opcionales en funciones.
• Para indicar que una búsqueda no encontró resultados o que una operación no produjo un valor esperado.

# Ejemplo de uso de None
lectura_ph = None # Supongamos que el medidor de pH falló

if lectura_ph is None:
    print("Advertencia: No se pudo obtener la lectura de pH.")
else:
    print(f"El pH medido es: {lectura_ph}")

print(type(None)) # Salida: 

Matemáticas Aplicadas con Variables 📐

# Variables para geometría
base_triangulo: float = 12.5   # metros
altura_triangulo: float = 8.3  # metros

# Cálculo del área
area_triangulo: float = (base_triangulo * altura_triangulo) / 2

print(f"Base: {base_triangulo} m")
print(f"Altura: {altura_triangulo} m")
print(f"Área del triángulo: {area_triangulo:.2f} m²")

# Constantes y variables
PI_CONST: float = 3.14159265
radio: float = 7.5  # cm

perimetro: float = 2 * PI_CONST * radio
area_circular: float = PI_CONST * (radio ** 2)

print(f"Radio: {radio} cm")
print(f"Perímetro: {perimetro:.2f} cm")
print(f"Área: {area_circular:.2f} cm²")

# Lista de datos (ej. mediciones de temperatura)
mediciones: list[float] = [19.5, 20.1, 19.8, 20.5, 20.0]
cantidad_mediciones: int = len(mediciones)
suma_mediciones: float = sum(mediciones)

promedio_temp: float = suma_mediciones / cantidad_mediciones

print(f"Mediciones: {mediciones}")
print(f"Promedio: {promedio_temp:.2f} °C")

# Coeficientes de ax² + bx + c = 0
a: float = 1.0
b: float = -3.0
c: float = 2.0

# Discriminante: b² - 4ac
discriminante: float = (b**2) - (4*a*c)
soluciones_reales: bool = (discriminante >= 0)

print(f"Ecuación: {a}x² + {b}x + {c} = 0")
print(f"Discriminante: {discriminante}")
print(f"¿Tiene soluciones reales?: {soluciones_reales}")

Física Aplicada con Variables ⚛️

# Movimiento Rectilíneo Uniformemente Variado
pos_inicial_m: float = 0.0
vel_inicial_mps: float = 10.0
aceleracion_mps2: float = 2.0
tiempo_s: float = 5.0

# x_f = x_i + v_i*t + 0.5*a*t²
pos_final_m: float = pos_inicial_m + \
                   (vel_inicial_mps * tiempo_s) + \
                   (0.5 * aceleracion_mps2 * tiempo_s**2)

print(f"Posición final: {pos_final_m:.2f} m")

# Constantes y variables
GRAVEDAD_MPS2: float = 9.81
masa_kg: float = 2.5
altura_m: float = 10.0
velocidad_mps: float = 4.0

# E_p = m*g*h; E_c = 0.5*m*v²
energia_potencial_j: float = masa_kg * GRAVEDAD_MPS2 * altura_m
energia_cinetica_j: float = 0.5 * masa_kg * velocidad_mps**2
energia_mecanica_j: float = energia_potencial_j + energia_cinetica_j

print(f"E. Potencial: {energia_potencial_j:.2f} J")
print(f"E. Cinética: {energia_cinetica_j:.2f} J")

# Propiedades de una onda electromagnética
VELOCIDAD_LUZ_MPS: float = 299792458.0
frecuencia_hz: float = 5.09e14 # Luz naranja

# λ = c / f
longitud_onda_m: float = VELOCIDAD_LUZ_MPS / frecuencia_hz
longitud_onda_nm: float = longitud_onda_m * 1e9 # Convertir a nanómetros

print(f"Frecuencia: {frecuencia_hz:.2e} Hz")
print(f"Longitud de onda: {longitud_onda_nm:.1f} nm")

# Ley de los gases ideales: PV = nRT
R_CONST: float = 8.314 # J/(mol·K)
presion_pa: float = 101325.0 # 1 atm
volumen_m3: float = 0.0224  # Para 1 mol a TPE
temp_k: float = 273.15      # 0 °C

# n = PV / RT
num_moles: float = (presion_pa * volumen_m3) / (R_CONST * temp_k)

print(f"Número de moles: {num_moles:.3f} mol")

Biología Aplicada con Variables 🧬

# Información genética
NUM_CROMOSOMAS_HUMANO: int = 46
PORC_ADN_NO_CODIFICANTE: float = 98.5 # Porcentaje

es_diploide: bool = True
especie: str = "Homo sapiens"

print(f"Especie: {especie}")
print(f"Cromosomas: {NUM_CROMOSOMAS_HUMANO}")
print(f"¿Diploide?: {es_diploide}")

# Signos vitales (ejemplos)
frecuencia_cardiaca_reposo_lpm: int = 70
temperatura_corporal_c: float = 36.8
saturacion_oxigeno_porc: float = 98.0

esta_en_rango_normal_temp: bool = 36.5 <= temperatura_corporal_c <= 37.5

print(f"FC Reposo: {frecuencia_cardiaca_reposo_lpm} lpm")
print(f"Temp. Corporal: {temperatura_corporal_c}°C")
print(f"Temp. Normal?: {esta_en_rango_normal_temp}")

# Modelo simple de crecimiento
poblacion_inicial_conejos: int = 100
tasa_natalidad_anual: float = 1.2 # 120%
tasa_mortalidad_anual: float = 0.3 # 30%
anios_estudio: int = 5

# Suponiendo un modelo muy simple sin otros factores
factor_crecimiento_neto = tasa_natalidad_anual - tasa_mortalidad_anual
# No es un cálculo realista, solo para mostrar variables

print(f"Población inicial: {poblacion_inicial_conejos}")
print(f"Factor neto (simplificado): {factor_crecimiento_neto}") 

# Reactivos y productos (simplificado)
reactivo1: str = "Dióxido de Carbono (CO₂)"
reactivo2: str = "Agua (H₂O)"
condicion: str = "Luz Solar"
producto1: str = "Glucosa (C₆H₁₂O₆)"
producto2: str = "Oxígeno (O₂)"

print(f"Fotosíntesis: {reactivo1} + {reactivo2} --({condicion})--> {producto1} + {producto2}")

Química Aplicada con Variables 🧪

# Masas molares y cálculos
MASA_MOLAR_H2O_G_MOL: float = 18.015
MASA_MOLAR_O2_G_MOL: float = 31.998
moles_de_o2: float = 2.5 # moles

masa_de_o2_g: float = moles_de_o2 * MASA_MOLAR_O2_G_MOL

print(f"{moles_de_o2} moles de O₂ equivalen a {masa_de_o2_g:.2f} g.")

# Preparación de una solución
masa_soluto_g: float = 5.844 # NaCl
volumen_solucion_L: float = 0.1 # 100 mL
MASA_MOLAR_NaCl_G_MOL: float = 58.44

moles_nacl: float = masa_soluto_g / MASA_MOLAR_NaCl_G_MOL
concentracion_molar_M: float = moles_nacl / volumen_solucion_L

print(f"Concentración de NaCl: {concentracion_molar_M:.2f} M")

# Datos de un elemento
simbolo_elemento: str = "Na" # Sodio
numero_atomico_Z: int = 11
numero_masico_A: int = 23

numero_protones: int = numero_atomico_Z
numero_electrones: int = numero_atomico_Z # Átomo neutro
numero_neutrones: int = numero_masico_A - numero_atomico_Z

print(f"Elemento: {simbolo_elemento}")
print(f"Protones: {numero_protones}, Neutrones: {numero_neutrones}")

# Cálculo de pH (simplificado)
concentracion_H_ion: float = 1.0e-7 # Molar (agua neutra)
# pH = -log10([H+]) - Necesitaríamos math.log10

# Ejemplo conceptual con booleanos
es_acido: bool = (concentracion_H_ion > 1.0e-7)
es_neutro: bool = (concentracion_H_ion == 1.0e-7)
es_basico: bool = (concentracion_H_ion < 1.0e-7)

print(f"[H+]: {concentracion_H_ion:.1e} M")
print(f"¿Es ácido?: {es_acido}")
print(f"¿Es neutro?: {es_neutro}")

10. Resumen y ¡A Practicar!

¡Felicidades! Ahora comprendes los conceptos fundamentales de las variables y los tipos de datos básicos en Python. Has aprendido:

• Qué son las variables y cómo actúan como etiquetas para almacenar datos.
• Cómo definir variables y las reglas para nombrarlas correctamente.
• La importancia del estilo de nomenclatura (snake_case es tu amigo).
• Los tipos de datos primordiales: enteros (int), flotantes (float), cadenas de texto (str) y booleanos (bool), e incluso una introducción a los complejos (complex).
• Que Python tiene tipado dinámico, lo que ofrece flexibilidad.
• Una introducción a las anotaciones de tipo (type hints) para el futuro.
• Cómo convertir datos entre diferentes tipos (type casting).
• Qué son las palabras reservadas y por qué no puedes usarlas como nombres.
• El significado y uso de la variable especial None.

Estos conceptos son los ladrillos con los que construirás todos tus programas. Entenderlos bien te permitirá manipular datos, realizar cálculos complejos y crear soluciones ingeniosas para problemas en matemáticas, física, biología, química y cualquier otra área que te apasione.