Aprender Python se ha vuelto fundamental en el ecosistema DevOps porque actúa como el "pegamento" que une las diferentes etapas del ciclo de vida del software. A diferencia de otros lenguajes, su sintaxis clara y legible permite escribir scripts potentes de manera rápida, facilitando la automatización de tareas repetitivas, la gestión de configuraciones y el aprovisionamiento de infraestructura mediante código (IaC). Además, su vasta colección de bibliotecas y su integración nativa con herramientas líderes como Ansible, Docker y Kubernetes, lo convierten en un recurso indispensable para optimizar flujos de trabajo, mejorar la escalabilidad y reducir el margen de error en entornos de producción complejos.

Vamos a dividir los fundamentos en cuatro pilares esenciales.

Fundamentos

1. Variables y Tipos de Datos

Las variables son "cajas" donde guardas información. En Python no necesitas decir qué tipo de dato es; él lo deduce solo.

• Srt (String): Texto entre comillas.
• Int (Integer): Números enteros.
• Float: Números con decimales.
• Bool (Boolean): Valores de verdad (True o False).

nombre = "Alex"    # Texto
edad = 25          # Entero
estatura = 1.75    # Decimal
es_programador = True 

2. Estructuras de Control (La lógica)

Aquí es donde el programa toma decisiones o repite tareas.

• If / Else: Para tomar decisiones.
• Bucles (For / While): Para repetir acciones.

if edad >= 18:
    print("Eres mayor de edad")
else:
    print("Eres menor de edad")

3. Colecciones: Las Listas

A veces necesitas guardar muchas cosas en una sola variable. Las listas son perfectas para eso.

frutas = ["manzana", "banana", "cereza"]
print(frutas[0])  # Esto imprimirá "manzana" (en programación empezamos a contar desde 0)

4. Funciones

Son bloques de código reutilizables. Imagina que es una "receta" que guardas para usarla cada vez que la necesites sin tener que escribir todo de nuevo.

def saludar(persona):
    return f"Hola, {persona}, ¡bienvenido al código!"

print(saludar("Alex"))

Variables

1. Números (Integers y Floats)

Son la base de cualquier cálculo.

• Integers (int): Números enteros, sin decimales (positivos o negativos).
• Floats (float): Números con punto decimal.

Nota curiosa: En Python, si sumas un entero y un float ($5 + 2.0$), el resultado siempre será un float ($7.0$).

2. Cadenas de Texto (str)

Se conocen como Strings. Se definen usando comillas simples ' ' o dobles " ".

• Puedes "sumarlas" (concatenarlas): "Hola" + " Mundo" resulta en "Hola Mundo".
• Puedes multiplicarlas: "Ja" * 3 resulta en "JaJaJa".

3. Booleanos (bool)

Es el tipo de dato más simple: solo puede ser True (Verdadero) o False (Falso).

Son los interruptores de la lógica. Se usan para responder preguntas como: ¿El usuario está logueado? ¿Es el número mayor a 10?

Tabla Comparativa de Tipos

¿Cómo saber qué tipo de variable tienes?

Python tiene una función mágica llamada type(). Si tienes dudas, puedes preguntarle directamente al código:

distancia = 150.5
print(type(distancia)) 
# La consola te responderá: <class 'float'>

Las Funciones de Conversión

Para arreglar esto, usamos funciones que tienen el mismo nombre que el tipo de dato al que queremos llegar:

• int(): Convierte a entero.
• float(): Convierte a decimal.
• str(): Convierte cualquier cosa a texto.

Ejemplo práctico:

Imagina que pides la edad a un usuario. Por defecto, todo lo que se escribe en el teclado llega a Python como texto.

edad_usuario = "25"         # Es un String
edad_numero = int(edad_usuario)  # ¡Ahora es un Integer!

print(edad_numero + 1)      # Resultado: 26 (Ahora sí podemos sumar)

¿Cuándo podrías tener problemas? (Errores comunes)

No siempre puedes convertir todo. Aquí es donde la lógica debe ser cuidadosa:

1. Texto no numérico: Si intentas hacer int("Hola"), Python se quejará porque no hay un número dentro de esa palabra.
2. Perder decimales: Si conviertes un float a int, Python no redondea, simplemente corta los decimales.
   • int(9.99) se convertirá en 9.

Tabla de Conversiones Rápidas

Estructuras de control

Las estructuras de control permiten que tu código tome decisiones o repita tareas automáticamente.

Imagina que el código es un camino: las estructuras de control son los desvíos y las rotondas.

1. El Condicional if (La Toma de Decisiones)

Es la estructura más básica. Evalúa si una condición es verdadera (True) o falsa (False).

• if: "Si pasa esto..."
• elif: "Si no pasó lo anterior, pero pasa esto otro..." (Abreviatura de else if).
• else: "Si no pasó nada de lo de arriba, haz esto."

La importancia de la Indentación (El espacio)

A diferencia de otros lenguajes que usan llaves {}, Python usa espacios (normalmente 4 o una tecla Tab). Si no dejas ese espacio, Python no sabrá qué instrucciones están "dentro" del condicional.

llueve = True

if llueve:
    print("Lleva un paraguas")  # Esto está dentro del if
print("Que tengas un buen día") # Esto se ejecuta siempre

2. Operadores de Comparación

Para que el if funcione, necesitamos comparar valores. Aquí tienes los símbolos clave:

3. Bucles: El Ciclo for

Se usa cuando quieres repetir algo un número específico de veces o recorrer una lista de elementos.

# Imprimir los números del 0 al 4
for i in range(5):
    print(f"Vuelta número: {i}")

4. Bucles: El Ciclo while

Este se repite mientras una condición sea verdadera. ¡Cuidado! Si la condición nunca cambia a falso, el programa se quedará trabado para siempre (bucle infinito).

energia = 3

while energia > 0:
    print("Sigo caminando...")
    energia = energia - 1  # Restamos energía para que el bucle termine algún día
print("Me cansé.")

Operadores Lógicos

(and, or, not)

A veces, una sola condición no es suficiente. Los operadores lógicos te permiten combinar varias preguntas en una sola línea.

• and: Ambas condiciones deben ser verdaderas.
  • Ejemplo: si tengo_dinero and hay_entradas: (Solo entras si pasan las dos cosas).
• or: Al menos una de las condiciones debe ser verdadera.
  • Ejemplo: si es_sabado or es_domingo: (Es fin de semana en cualquiera de los dos casos).
• not: Invierte el valor. Si algo es True, lo vuelve False.
  • Ejemplo: si not esta_lloviendo: (Haz algo solo si NO llueve).

Control de Bucles

(break y continue)

Dentro de los bucles (for o while), puedes "romper las reglas" con estas dos palabras clave:

• break: Detiene el bucle por completo inmediatamente. Es como un botón de emergencia.
• continue: Salta el paso actual y pasa directamente a la siguiente vuelta del bucle. Es como decir "este elemento no me interesa, sigue con el que viene".

Estructuras de Selección

(match-case)

En las versiones más recientes de Python (3.10+), existe algo llamado match. Es una forma más elegante de escribir muchos if/elif cuando estás comparando una variable contra muchos valores posibles.

comando = "salir"

match comando:
    case "iniciar":
        print("Empezando programa...")
    case "salir":
        print("Cerrando todo.")
    case _:
        print("Comando no reconocido") # El guion bajo es el "por defecto"

Resumen de la "Lógica de Control"

Para que lo visualices como un mapa mental:

1. Decisiones: if, elif, else.
2. Repeticiones: for (sabes cuántas veces), while (hasta que algo cambie).
3. Refinamiento: and/or para ser más específico, break/continue para controlar el flujo interno.

Colecciones o contenedores

Existen cuatro tipos principales de colecciones integradas que debes conocer. Cada una tiene una "personalidad" y un propósito distinto:

1. Listas (list)

Son las más usadas. Son ordenadas (mantienen el orden en que guardas las cosas) y mutables (puedes cambiar, quitar o añadir elementos).

• Sintaxis: Se usan corchetes [].
• Lo que debes saber: Se accede a los elementos por su índice (posición), empezando siempre desde el 0.
• Ejemplo: compras = ["pan", "leche", "huevos"]

2. Tuplas (tuple)

Son hermanas de las listas, pero con una diferencia crítica: son inmutables. Una vez que creas una tupla, no puedes cambiar sus elementos ni su tamaño.

• Sintaxis: Se usan paréntesis ().
• Lo que debes saber: Son más rápidas y ligeras que las listas. Se usan para datos que nunca deben cambiar (como las coordenadas GPS o los meses del año).
• Ejemplo: punto_gps = (10.45, -66.89)

3. Conjuntos (set)

Son colecciones de elementos únicos y desordenados. No puedes tener duplicados.

• Sintaxis: Se usan llaves {}.
• Lo que debes saber: Son geniales para eliminar duplicados de una lista o para hacer operaciones matemáticas como "unión" o "intersección". No tienen un orden fijo, así que no puedes pedir el "primer elemento".
• Ejemplo: colores = {"rojo", "verde", "rojo"} (Python eliminará el segundo "rojo" automáticamente).

4. Diccionarios (dict)

Es la colección más potente para organizar datos complejos. Funcionan con un sistema de Clave: Valor.

• Sintaxis: Se usan llaves {} con dos puntos :.
• Lo que debes saber: No buscas por posición (índice), sino por el nombre de la clave. Es como una agenda telefónica real: buscas el nombre para obtener el número.
• Ejemplo: usuario = {"nombre": "Alex", "edad": 25}

Tabla Comparativa de Colecciones

*Nota: Desde Python 3.7, los diccionarios mantienen el orden de inserción por defecto.

¿Qué es lo más importante que debes saber?

Para dominar las colecciones, lo principal es saber cuándo usar cuál:

1. Usa Listas para colecciones de objetos similares que pueden cambiar.
2. Usa Tuplas para proteger datos que no deben alterarse.
3. Usa Sets si quieres asegurarte de que no haya elementos repetidos.
4. Usa Diccionarios cuando necesites etiquetar tus datos para encontrarlos rápido.

Añadir o eliminar elementos de contenedores

Para aprender a manipular contenedores en Python, lo más importante es conocer los métodos (funciones específicas) que cada uno tiene. Como las Tuplas son inmutables, nos enfocaremos en las otras tres, que son las que realmente te permiten hacer cambios.

Aquí tienes la guía práctica de cómo "operar" con ellas:

1. Listas (list)

Las listas son las más flexibles. Tienen métodos muy directos:

• Para agregar:
  • .append(elemento): Agrega al final de la lista.
  • .insert(índice, elemento): Agrega en una posición específica.
• Para eliminar:
  • .remove(elemento): Busca el valor y lo borra (si hay varios, borra el primero que encuentre).
  • .pop(índice): Borra por posición y te devuelve el elemento (si no pones índice, borra el último).
  • del lista[índice]: Una forma directa de borrar por posición.

frutas = ["manzana", "pera"]
frutas.append("naranja")        # ["manzana", "pera", "naranja"]
frutas.insert(0, "fresa")       # ["fresa", "manzana", "pera", "naranja"]
frutas.remove("manzana")        # ["fresa", "pera", "naranja"]

2. Diccionarios (dict)

Aquí no usamos posiciones, usamos las Claves.

• Para agregar o actualizar: No hay un método "add"; simplemente asignas un valor a una clave nueva.
  • diccionario[clave_nueva] = valor
• Para eliminar:
  • .pop(clave): Elimina la clave y te devuelve su valor.
  • del diccionario[clave]: Borra la pareja clave-valor permanentemente.

usuario = {"nombre": "Alex", "edad": 25}
usuario["ciudad"] = "Madrid"    # Agrega: {"nombre": "Alex", "edad": 25, "ciudad": "Madrid"}
usuario.pop("edad")             # Elimina 'edad'

3. Conjuntos (set)

Como no tienen orden ni claves, sus métodos son muy sencillos:

• Para agregar:
  • .add(elemento): Si el elemento ya existe, no hace nada (recuerda que no hay duplicados).
• Para eliminar:
  • .remove(elemento): Borra el elemento. Si no existe, lanza un error.
  • .discard(elemento): Borra el elemento, pero si no existe, no lanza error (es más seguro).

numeros = {1, 2, 3}
numeros.add(4)        # {1, 2, 3, 4}
numeros.add(2)        # {1, 2, 3, 4} (no cambia nada porque el 2 ya estaba)
numeros.discard(1)    # {2, 3, 4}

Resumen Visual de Métodos

Cómo funcionan los Diccionarios por dentro?

Entender cómo funciona un diccionario por dentro es uno de los aspectos más importantes de Python. La magia que hace que un diccionario sea tan rápido (incluso si tiene millones de datos) se llama Tabla de Hash (Hash Table).

Aquí explico la ingeniería que hay detrás de forma sencilla:

1. El concepto de la "Función Hash"

Cuando guardas algo en un diccionario, por ejemplo mi_dict["nombre"] = "Alex", Python no guarda "nombre" tal cual en una lista y luego lo busca letra por letra.

Lo que hace es pasar la clave ("nombre") por una función matemática llamada Hash. Esta función toma cualquier texto o número y lo convierte en un número entero único (o casi único).

• Entrada: "nombre"
• Función Hash: genera, por ejemplo, 45091823
• Resultado: Ese número se usa como el "índice" o la dirección exacta en la memoria del ordenador.

2. Acceso Instantáneo ($O(1)$)

En una Lista, si quieres encontrar un elemento, Python tiene que revisar uno por uno desde el principio (como buscar una página en un libro pasando hoja por hoja).

En un Diccionario, Python aplica la función Hash a la clave que buscas, obtiene la dirección de memoria y va directamente a ese lugar. No importa si el diccionario tiene 10 elementos o 10 millones; el tiempo que tarda en encontrarlo es prácticamente el mismo. A esto en computación se le llama Complejidad Constante o $O(1)$.

3. Las Reglas de Oro de los Diccionarios

Para que esta "magia" funcione, los diccionarios tienen dos reglas internas estrictas:

• Las Claves deben ser "Hashables" (Inmutables): Solo puedes usar como claves cosas que no cambien (Strings, Números, Tuplas). No puedes usar una Lista como clave, porque si la lista cambia, su código Hash cambiaría y Python "perdería" la dirección de donde guardó el dato.
• Claves Únicas: No puede haber dos claves iguales. Si intentas agregar una clave que ya existe, Python simplemente sobreescribe el valor anterior en esa misma dirección de memoria.

4. ¿Qué pasa si dos claves dan el mismo Hash? (Colisiones)

A veces, dos palabras distintas podrían generar el mismo número de dirección por puro azar. Esto se llama Colisión.

Python es muy inteligente y tiene mecanismos internos (como el Open Addressing) para buscar el siguiente hueco libre cercano si el primero ya está ocupado. Pero esto sucede "bajo el capó" y tú nunca lo notas.

Resumen visual:

1. Tú das una Clave: "color"
2. Python calcula el Hash: hash("color") $\rightarrow$ 12
3. Python va al cajón 12: Ahí guarda el valor "rojo".
4. Para recuperar: Repite el proceso y va directo al cajón 12.

Funciones

¡Perfecto! Has llegado al cuarto y último pilar de los fundamentos: Las Funciones.

Si las variables son los ingredientes y las estructuras de control son los pasos, las funciones son la "receta completa" que guardas en un libro para no tener que recordarla de memoria cada vez.

1. ¿Qué es una Función?

Es un bloque de código con un nombre específico que solo se ejecuta cuando tú lo "llamas". Sirve para dos cosas principales:

1. No repetir código: Si vas a calcular un impuesto 20 veces, creas una función y la usas 20 veces.
2. Organizar: Divide un programa gigante en piezas pequeñas y fáciles de entender.

2. Anatomía de una Función

Para crear una función en Python usamos la palabra clave def (de define).

def saludar_usuario(nombre):   # 'nombre' es un parámetro (la entrada)
    mensaje = f"Hola {nombre}, ¡qué bueno verte!"
    return mensaje             # 'return' es lo que la función te devuelve

• Parámetros: Son las variables que la función necesita para trabajar (como los ingredientes que le pasas a una licuadora).
• Cuerpo: Es el código indentado que hace el trabajo.
• Return: Es el resultado final. Si no pones return, la función hace su trabajo pero no te "entrega" nada de vuelta.

3. Llamar a la Función

Una función definida no hace nada por sí sola. Tienes que "invocarla" por su nombre:

# Guardamos el resultado en una variable
resultado = saludar_usuario("Alex")
print(resultado) # Imprime: Hola Alex, ¡qué bueno verte!

4. Combinando todo: Funciones con Colecciones y Lógica

Aquí es donde verás el poder de lo que has aprendido. Imagina una función que procesa una lista de precios y aplica un descuento si el precio es mayor a 100 (lógica).

def aplicar_descuento(lista_precios):
    precios_finales = [] # Creamos una lista vacía
    
    for precio in lista_precios:
        if precio > 100:
            nuevo_precio = precio * 0.90 # 10% de descuento
            precios_finales.append(nuevo_precio)
        else:
            precios_finales.append(precio)
            
    return precios_finales

# Uso de la función
mis_compras = [50, 120, 80, 200]
print(aplicar_descuento(mis_compras)) 
# Resultado: [50, 108.0, 80, 180.0]

Conceptos Clave para recordar:

• Scope (Alcance): Las variables creadas dentro de una función mueren cuando la función termina. No puedes usarlas afuera a menos que las "devuelvas" con return.
• Argumentos por defecto: Puedes hacer que un parámetro sea opcional.
  • def saludar(nombre="Invitado"): (Si no le pasas nombre, usará "Invitado").