Entorno y Configuración Inicial

Para quienes provienen de lenguajes compilados como C, la transición a Python implica entender su naturaleza interpretada. En entornos Windows, existen dos formas rápidas de cerrar el intérprete interactivo:

• Atajo de teclado: Ctrl + Z seguido de Enter.
• Comando funcional: exit().

Si utilizas Sublime Text y el sistema no apunta a la versión correcta de Python, puedes definir un nuevo sistema de construcción (Build System) con el siguiente JSON:

{
    "cmd": ["python3", "-u", "$file"],
}

Manipulcaión de Cadenas y Datos Simples

A diferencia de los arreglos de caracteres en C, los strings en Python son objetos versátiles que admiten comillas simples, dobles o triples (estas últimas para textos multilínea).

saludo = "Hola Mundo"
# Métodos comunes
print(saludo.upper())    # Convierte a mayúsculas
print(saludo.lower())    # Convierte a minúsculas
print(saludo.strip())    # Elimina espacios laterales

# F-Strings (Interpolación de variables)
version = 3.10
print(f"Estamos usando Python {version}")

En cuanto a los tipos numéricos, Python maneja enteros de precisión arbitraria y flotantes. Una característica útil para la legibilidad es el uso de guiones bajos como separadores de miles:

poblacion = 8_000_000  # Equivalente a 8000000
coord_x, coord_y = 10.5, 20.8  # Asignación múltiple

Estructuras de Datos Dinámicas

Listas

Las listas son equivalentes a arreglos dinámicos. Soportan indexación negativa para acceder a elementos desde el final.

frutas = ["manzana", "pera", "uva"]
frutas.append("naranja")      # Agregar al final
frutas.insert(0, "limón")     # Insertar en índice específico
ultimo = frutas.pop()         # Extraer el último elemento
del frutas[1]                 # Eliminar por índice

El "slicing" o segmentación permite extraer sucbonjuntos de la lista de forma eficiente:

numeros = list(range(10))     # [0, 1, ..., 9]
sub_lista = numeros[2:5]      # Elementos del índice 2 al 4
copia_real = numeros[:]       # Clonar la lista completa

Diccionarios y Conjuntos

Los diccionarios almacenan pares clave-valor, similares a un std::map o una tabla hash.

usuario = {"id": 1, "nombre": "Admin"}
valor = usuario.get("rol", "Invitado")  # Acceso seguro con valor por defecto

# Iteración de diccionarios
for llave, val in usuario.items():
    print(f"{llave}: {val}")

Los conjuntos (sets) se definen con llaves y garantizan la unicidad de los elementos:

id_unicos = {101, 102, 101, 103}  # El resultado será {101, 102, 103}

Lógica de Control y Bucles

Python utiliza la indentación en lugar de las llaves {} de C para definir bloques de código.

valores = [10, 20, 30]
if valores:
    print("La lista tiene datos")
elif len(valores) == 0:
    print("Lista vacía")

# Bucle while con eliminación de elementos
while "naranja" in frutas:
    frutas.remove("naranja")

Desde la versión 3.10, Python incluye la estructura match...case, similar al switch de C pero con capacidades de pattern matching:

estado = 404
match estado:
    case 200:
        print("Éxito")
    case 404:
        print("No encontrado")
    case _:
        print("Error desconocido")

Funciones y Modularidad

Las funciones se definen con la palabra clave def. Soportan parámetros con valores por defecto y argumentos de longitud variable.

def generar_perfil(nombre, edad=18, **detalles):
    perfil = {"nombre": nombre, "edad": edad}
    perfil.update(detalles)
    return perfil

# *args captura tuplas, **kwargs captura diccionarios
def suma_flexible(*nums):
    return sum(nums)

Programación Orientada a Objetos

El método __init__ actúa como constructor. El primer parámetro de cada método de instancia debe ser self.

class Dispositivo:
    def __init__(self, marca):
        self.marca = marca

    def encender(self):
        print(f"{self.marca} encendido")

class Smartphone(Dispositivo):
    def __init__(self, marca, os):
        super().__init__(marca)
        self.os = os
    
    def encender(self): # Sobrescritura de método
        print(f"Iniciando {self.os} en {self.marca}")

Persistencia y Gestión de Excepciones

El uso de la sentencia with asegura que los recursos (como archivos) se cierren automáticamente, similar a un bloque RAII en C++.

import json

# Escritura de JSON
datos = {"temp": 25.5, "status": "ok"}
with open("config.json", "w") as archivo:
    json.dump(datos, archivo)

# Manejo de errores
try:
    with open("datos.txt", "r") as f:
        contenido = f.read()
except FileNotFoundError:
    print("El archivo no existe")
else:
    print("Lectura exitosa")

Pruebas Unitarias

El módulo unittest permite validar la lógica del código mediante aserciones.

import unittest

def calcular_area(radio):
    return 3.1416 * (radio ** 2)

class TestGeometria(unittest.TestCase):
    def test_area(self):
        self.assertAlmostEqual(calcular_area(1), 3.1416)

if __name__ == "__main__":
    unittest.main()

Decoradores y Cierres (Closures)

Un decorador es una función que recibe otra función y extiende su comportamiento sin modificar su código original.

def logger(func):
    def envoltura(*args, **kwargs):
        print(f"Ejecutando: {func.__name__}")
        return func(*args, **kwargs)
    return envoltura

@logger
def operacion_critica(x):
    return x * 2

# También es posible crear decoradores basados en clases usando __call__
class ContadorLlamadas:
    def __init__(self, func):
        self.func = func
        self.conteo = 0

    def __call__(self, *args, **kwargs):
        self.conteo += 1
        print(f"Llamada número {self.conteo}")
        return self.func(*args, **kwargs)