Variables y tipos de datos

Variables y tipos de datos

Las variables son uno de los conceptos fundamentales en programación. En Python, las variables son contenedores para almacenar datos que puedes usar y modificar a lo largo de tu programa.

Variables en Python

Creación y asignación de variables

En Python, no necesitas declarar explícitamente una variable antes de usarla. Simplemente asignas un valor a un nombre de variable usando el operador =:

# Asignación de variables
nombre = "Ana"
edad = 25
altura = 1.65
es_estudiante = True

Reglas para nombrar variables

1. Los nombres de variables pueden contener letras, números y guiones bajos (_).
2. Los nombres de variables deben comenzar con una letra o un guion bajo, nunca con un número.
3. Los nombres de variables distinguen entre mayúsculas y minúsculas (edad y Edad son variables diferentes).
4. Los nombres de variables no pueden ser palabras reservadas de Python (como if, for, while, etc.).

Convenciones de nombres

Como vimos en la lección anterior, Python utiliza la convención snake_case para nombres de variables:

# Convención snake_case (recomendada)
nombre_completo = "Ana García"
fecha_de_nacimiento = "15/05/1998"
numero_de_telefono = "555-123-4567"

# Evitar
NombreCompleto = "Ana García"  # PascalCase (usado para clases)
fechaDeNacimiento = "15/05/1998"  # camelCase

Variables múltiples

Puedes asignar valores a múltiples variables en una sola línea:

# Asignación múltiple
x, y, z = 10, 20, 30

# Mismo valor a múltiples variables
a = b = c = 0

Tipos de datos en Python

Python es un lenguaje de tipado dinámico, lo que significa que no necesitas declarar el tipo de una variable al crearla. El tipo se determina automáticamente en tiempo de ejecución.

Tipos de datos básicos

Números

1. Enteros (int): Números sin parte decimal.

edad = 25
temperatura_minima = -5
población = 7_800_000_000  # Los guiones bajos mejoran la legibilidad

2. Números de punto flotante (float): Números con parte decimal.

altura = 1.75
pi = 3.14159
científico = 6.022e23  # Notación científica (6.022 × 10²³)

3. Números complejos (complex): Números con parte real e imaginaria.

complejo = 3 + 4j  # j representa la unidad imaginaria

Texto

Cadenas de texto (str): Secuencias de caracteres.

nombre = "Ana"
mensaje = 'Hola, mundo'
texto_largo = """Este es un texto
que ocupa múltiples
líneas."""

# Concatenación de cadenas
saludo = "Hola, " + nombre + "!"

# Formateo de cadenas (f-strings, disponible desde Python 3.6)
saludo_formateado = f"Hola, {nombre}! Tienes {edad} años."

# Métodos de cadenas
print(nombre.upper())  # ANA
print(mensaje.replace("Hola", "Adiós"))  # Adiós, mundo
print(len(mensaje))  # 12 (longitud de la cadena)

Booleanos

Valores booleanos (bool): Representan verdadero (True) o falso (False).

es_mayor_de_edad = True
tiene_mascota = False

# Operaciones booleanas
print(es_mayor_de_edad and tiene_mascota)  # False
print(es_mayor_de_edad or tiene_mascota)   # True
print(not es_mayor_de_edad)                # False

Tipos de datos compuestos

Listas

Las listas son colecciones ordenadas y modificables de elementos.

# Creación de listas
colores = ["rojo", "verde", "azul"]
números = [1, 2, 3, 4, 5]
mixta = [1, "dos", True, 3.14]

# Acceso a elementos (indexación desde 0)
print(colores[0])       # rojo
print(colores[-1])      # azul (índice negativo cuenta desde el final)

# Modificación de elementos
colores[1] = "amarillo"
print(colores)          # ["rojo", "amarillo", "azul"]

# Métodos de listas
colores.append("morado")  # Añade al final
colores.insert(1, "naranja")  # Inserta en posición específica
colores.remove("azul")  # Elimina por valor
eliminado = colores.pop()  # Elimina y devuelve el último elemento
longitud = len(colores)  # Obtiene la longitud

# Slicing (rebanado)
primeros_tres = números[0:3]  # [1, 2, 3]
pares = números[1::2]  # [2, 4] (inicio:fin:paso)

Tuplas

Las tuplas son colecciones ordenadas e inmutables (no se pueden modificar después de creadas).

# Creación de tuplas
coordenadas = (10, 20)
persona = ("Ana", 25, "Ingeniera")

# Acceso a elementos
print(coordenadas[0])  # 10
print(persona[1])      # 25

# No se pueden modificar
# coordenadas[0] = 15  # Esto daría un error

# Desempaquetado de tuplas
nombre, edad, profesión = persona
print(nombre)  # Ana

# Tupla de un solo elemento
singleton = (42,)  # La coma es importante

Diccionarios

Los diccionarios son colecciones no ordenadas de pares clave-valor.

# Creación de diccionarios
persona = {
    "nombre": "Carlos",
    "edad": 30,
    "profesión": "Desarrollador",
    "lenguajes": ["Python", "JavaScript", "Go"]
}

# Acceso a valores
print(persona["nombre"])  # Carlos

# Modificación de valores
persona["edad"] = 31

# Añadir nuevos pares clave-valor
persona["ciudad"] = "Barcelona"

# Verificar si una clave existe
if "apellido" in persona:
    print(persona["apellido"])
else:
    print("No se encontró el apellido")

# Métodos de diccionarios
claves = persona.keys()    # Obtiene todas las claves
valores = persona.values()  # Obtiene todos los valores
elementos = persona.items()  # Obtiene pares (clave, valor)

# Obtener con valor predeterminado
apellido = persona.get("apellido", "No especificado")

Conjuntos

Los conjuntos son colecciones no ordenadas de elementos únicos.

# Creación de conjuntos
colores = {"rojo", "verde", "azul"}
números = {1, 2, 3, 4, 5}

# No permite duplicados
duplicados = {1, 2, 2, 3, 3, 3}
print(duplicados)  # {1, 2, 3}

# Operaciones de conjuntos
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

union = a | b  # {1, 2, 3, 4, 5, 6}
intersección = a & b  # {3, 4}
diferencia = a - b  # {1, 2}
diferencia_simétrica = a ^ b  # {1, 2, 5, 6}

# Métodos de conjuntos
colores.add("amarillo")
colores.remove("verde")  # Lanza error si no existe
colores.discard("negro")  # No lanza error si no existe

Tipo especial: None

None es un tipo especial en Python que representa la ausencia de valor o un valor nulo.

valor = None

def función_sin_retorno():
    print("Esta función no devuelve nada")

resultado = función_sin_retorno()
print(resultado)  # None

Conversión entre tipos de datos

Python permite convertir entre diferentes tipos de datos:

# Conversión a entero
edad_str = "25"
edad_int = int(edad_str)  # 25

# Conversión a float
precio_str = "19.99"
precio_float = float(precio_str)  # 19.99

# Conversión a string
número = 42
número_str = str(número)  # "42"

# Conversión a lista
cadena = "Python"
lista_caracteres = list(cadena)  # ['P', 'y', 't', 'h', 'o', 'n']

# Conversión a tupla
lista = [1, 2, 3]
tupla = tuple(lista)  # (1, 2, 3)

# Conversión a conjunto (elimina duplicados)
lista_con_duplicados = [1, 2, 2, 3, 3, 3]
conjunto = set(lista_con_duplicados)  # {1, 2, 3}

Verificación de tipos

Puedes verificar el tipo de una variable con la función type():

x = 10
y = "Hola"
z = [1, 2, 3]

print(type(x))  # <class 'int'>
print(type(y))  # <class 'str'>
print(type(z))  # <class 'list'>

# Verificar si una variable es de un tipo específico
print(isinstance(x, int))  # True
print(isinstance(y, float))  # False

Mutabilidad vs Inmutabilidad

En Python, algunos tipos de datos son mutables (se pueden modificar después de creados) y otros son inmutables (no se pueden modificar):

• Tipos inmutables: int, float, bool, str, tuple, frozenset
• Tipos mutables: list, dict, set

# Ejemplo con tipos inmutables
a = "hola"
print(id(a))  # Dirección de memoria de 'a'
a = a + " mundo"  # Crea un nuevo objeto en memoria
print(id(a))  # Dirección diferente

# Ejemplo con tipos mutables
lista = [1, 2, 3]
print(id(lista))  # Dirección de memoria de 'lista'
lista.append(4)  # Modifica el objeto existente
print(id(lista))  # Misma dirección

Variables y referencias

En Python, las variables son referencias a objetos en memoria:

# Dos variables referenciando el mismo objeto
a = [1, 2, 3]
b = a  # 'b' referencia al mismo objeto que 'a'

b.append(4)
print(a)  # [1, 2, 3, 4] - 'a' también se ve afectado

# Creación de una copia independiente
c = a.copy()
c.append(5)
print(a)  # [1, 2, 3, 4] - 'a' no se ve afectado
print(c)  # [1, 2, 3, 4, 5]

Consejos prácticos

1. Usa nombres descriptivos: Elige nombres que expliquen claramente el propósito de la variable.
2. Sé consistente: Mantén un estilo de nomenclatura consistente en todo tu código.
3. Evita variables globales: Limita el alcance de tus variables tanto como sea posible.
4. Inicializa tus variables: Siempre asigna un valor inicial a tus variables antes de usarlas.
5. Usa constantes: Para valores que no cambian, usa nombres en MAYÚSCULAS.

# Mal ejemplo
x = 3.14159
r = 5
a = x * r * r

# Buen ejemplo
PI = 3.14159
radio = 5
area_circulo = PI * radio ** 2

Ejercicio práctico

Vamos a crear un programa que utilice diferentes tipos de datos para gestionar información de estudiantes:

# Programa de gestión de estudiantes

# Datos de estudiantes (usando un diccionario)
estudiantes = [
    {
        "nombre": "Ana García",
        "edad": 22,
        "calificaciones": [85, 90, 78, 92, 88],
        "activo": True,
        "cursos": ("Matemáticas", "Física", "Programación")
    },
    {
        "nombre": "Carlos López",
        "edad": 20,
        "calificaciones": [75, 82, 90, 85, 88],
        "activo": False,
        "cursos": ("Historia", "Literatura", "Filosofía")
    }
]

# Función para calcular promedio
def calcular_promedio(calificaciones):
    return sum(calificaciones) / len(calificaciones)

# Procesamiento de datos
for estudiante in estudiantes:
    # Acceso a diferentes tipos de datos
    nombre = estudiante["nombre"]
    promedio = calcular_promedio(estudiante["calificaciones"])
    estado = "Activo" if estudiante["activo"] else "Inactivo"
    
    # Uso de f-strings para formateo
    print(f"Estudiante: {nombre}")
    print(f"Edad: {estudiante['edad']} años")
    print(f"Promedio: {promedio:.2f}")
    print(f"Estado: {estado}")
    
    # Trabajando con tuplas
    print("Cursos:")
    for curso in estudiante["cursos"]:
        print(f"- {curso}")
    
    print("-" * 30)

En la próxima lección, exploraremos los operadores aritméticos en Python y cómo realizar diferentes tipos de cálculos.