📌 En síntesis: Evaluación formal de algoritmos: notación asintótica Big-O, curvas de complejidad O(1), O(log n), O(n), O(n²) y optimización de memoria.
Guía técnica desarrollada por el equipo de Proyecto Luna para formación profesional y consulta técnica abierta.
📌
📌 Aprendizaje esperado
📌
Construir métodos para implementar algoritmos simples, llamándolas desde una clase.
🚀 Introducción
En esta semana profundizaremos en tres pilares de los métodos en Python: paso de parámetros, valores por defecto y retorno de métodos. Comprender cómo reciben datos los métodos, qué ocurre con esos datos al interior de la clase y cómo devolver resultados es clave para escribir código claro, modular y reutilizable. Veremos la diferencia entre parámetro (lo que se declara) y argumento (lo que se envía), y cómo influye el tipo de dato (inmutable vs mutable) en los cambios dentro del método. Revisaremos la sintaxis y buenas prácticas de valores por defecto para simplificar llamadas y evitar errores comunes, como usar objetos mutables por defecto. Finalmente, estudiaremos el return, cuándo usarlo, qué devuelve un método sin return, y estrategias para retornar múltiples valores o estructuras (tuplas/diccionarios) que facilitan la lectura del programa. Al final tendrás un kit práctico para diseñar métodos robustos que resuelvan subproblemas con parámetros bien definidos, defaults sensatos y retornos precisos.
El paso de parámetros en Python es el mecanismo mediante el cual enviamos información a una función o método en el momento de invocarlo, permitiendo que este trabaje con datos externos sin depender únicamente de valores internos o fijos. En programación orientada a objetos, cuando definimos un método dentro de una clase, el primer parámetro suele ser self (que representa la instancia del objeto), seguido de los parámetros que recibirán la información necesaria para ejecutar su lógica. Los parámetros se declaran entre paréntesis en la definición del método y se corresponden con los argumentos que se pasan al llamarlo. Python transmite estos valores por asignación de referencia, lo que significa que si el parámetro es un objeto mutable (como listas o diccionarios), los cambios realizados dentro del método afectarán al objeto original. Este concepto es clave para crear métodos reutilizables y adaptables a distintos contextos, evitando repetir código y permitiendo que el comportamiento varíe en función de los valores recibidos.
-
Parámetro: es la variable que escribes en la definición del método/función para recibir datos.
-
Argumento: es el valor que entregas cuando invocas el método/función.
Figura 1: Paso de parámetros
📌 Paso de parámetros
📌
Estructura en POO
📌
Tipos de objetos
📌
Características clave
📌
Mecanismo de funcionamiento
-
Primer parámetro: self.
-
Representa la instancia del objeto, seguido de parámetros adicionales.
-
Reciben información necesaria para ejecutar la lógica del método.
-
Declaración entre paréntesis en la definición
-
Correspondencia con argumentos al momento
-
Transmisión por asignación de referencia.
-
Objetos mutables: listas, diccionarios, conjuntos. Los cambios afectan al original
-
Objetos Inmutables: números, strings, tuplas. No se modifica el original.
-
Métodos reutilizables, adaptables a distintos contextos.
-
Evita repetición de código.
-
Comportamiento variable según valores recibidos.
📌 Paso de
📌 parámetros
📌 en Python
del método. de la llamada.
En métodos de clase, el primer parámetro es self (la propia instancia). Al llamar el método no pasas self; Python lo envía automáticamente.
📊 Figura 3: Cómo funciona el paso de parámetros
Figura 2: Ejemplo de paso de parámetros
1.2. Cómo funciona el paso de parámetros 1.1. Ejemplo 1: paso de parámetros class Saludo: def decir_hola(self, nombre): # ← ‘nombre’ es un PARÁMETRO print(f“Hola, {nombre}!”) s = Saludo() s.decir_hola(“Ana”) # ← “Ana” es un ARGUMENTO Al llamar, los argumentos se evalúan y la referencia al objeto resultante se asigna al parámetro. Si el objeto es inmutable (int, float, str, tuple), no podrás cambiar ese mismo objeto desde el método (re-asignas a otro). Si el objeto es mutable (list, dict, set), si lo mutas “en sitio”, el cambio se ve fuera del método.
📌
📌
📌
Python usa un modelo llamado “paso por asignación” (o call by sharing):
Con números/cadenas/tuplas, “modificar” dentro es en realidad re-asignar a otro objeto; el original no cambia. Con listas/diccionarios/conjuntos, las mutaciones (append, remove, actualizar claves, etc.) sí se ven fuera del ámbito de acción del método.
Figura 4: Ejemplo parámetros inmutables
Figura 4: Ejemplo parámetros mutables (Fuente: elaboración propia)
1.4. Ejemplo 3: mutables (sí se pueden modificar en sitio) 1.3. Ejemplo 2: inmutables (no se “cambian” por dentro) def incrementar(x): x += 1 # crea una NUEVA referencia; no toca el ‘x’ externo return x n = 10 m = incrementar(n) print(n) # 10 (no cambió) def agregar_item(lista, valor): lista.append(valor) # mutación en sitio datos = [1, 2] agregar_item(datos, 3) print(datos) # [1, 2, 3] ← cambió fuera del método
Si no quieres cambiar el objeto original, trabaja con una copia adentro del método y retorna el resultado: Con diccionarios:
Figura 6. Copiar y modificar una lista sin alterar la original (Fuente: elaboración propia)
Figura 7: Parámetros con valor por defecto y cálculos sobre datos
1.5. Evitar efectos colaterales def agregar_sin_tocar(lista, valor): nueva = lista.copy() # o lista[:] para listas nueva.append(valor) return nueva original = [1, 2] modificada = agregar_sin_tocar(original, 3) print(original) # [1, 2] print(modificada) # [1, 2, 3] def marcar_entregado(pedido): copia = pedido.copy() copia[“estado”] = “entregado” return copia p = {“id”: 101, “estado”: “pendiente”} p2 = marcar_entregado(p) print(p) # {‘id’: 101, ‘estado’: ‘pendiente’} print(p2) # {‘id’: 101, ‘estado’: ‘entregado’}vv
Regla: los parámetros con default van después de los obligatorios. Cuidado: evita valores por defecto mutables (listas/dicts). Usa None como centinela y crea dentro. self no es un argumento que tú pasas; lo añade Python. Los datos externos van en los parámetros siguientes. 2.1. En métodos de clase: self + otros parámetros
Figura 8: Uso de parámetros con valor por defecto para cálculos
Permiten omitir argumentos en la llamada:
📌 Acceso a los elementos de una lista
📌 Valores por defecto (relación directa con el paso de parámetros)
class Impuesto: def calcular(self, base, tasa=19.0): # tasa default return base * (tasa / 100) i = Impuesto() print(i.calcular(100000)) # usa 19.0
Figura 10: Diccionarios seguros en Python: trabajar sin modificar el original
class CarritoSeguro: def agregar(self, inventario, producto, cantidad): copia = inventario.copy() copia[producto] = copia.get(producto, 0) + cantidad return copia # retornar la versión modificada Si no quieres modificar el inventario original:
Figura 9: Métodos que modifican estructuras mutables.
class Carrito: def agregar(self, inventario, producto, cantidad): # inventario: dict (mutable) inventario[producto] = inventario.get(producto, 0) + cantidad return inventario[producto] stock = {} c = Carrito() c.agregar(stock, “teclado”, 2) print(stock) # {‘teclado’: 2} ← se modificó el dict externo
Figura 11: Uso del return en métodos de clase
class Calculadora: def sumar(self, a, b): return a + b # entrega el resultado al llamador c = Calculadora() res = c.sumar(4, 6) print(res) # 10 El retorno de métodos en Python es el mecanismo por el cual un método entrega un valor de vuelta a quien lo invoca, usando la palabra clave return. En el momento en que Python ejecuta return, el método finaliza y el valor especificado se envía al llamador. Si no se escribe return, el método retorna implícitamente None, lo que suele indicar “no hay resultado” (útil en métodos que solo realizan acciones). 3.1. Retornar un valor simple Aquí el método no imprime el resultado: lo retorna, permitiendo guardarlo, usarlo en otra operación o testearlo.
📌 Acceso a los elementos de una lista
📌 Retorno de métodos
3.3. Retorno múltiple (tupla) y desempaquetado
Figura 13: Retorno de múltiples valores
Diferencia clave: print muestra en pantalla, mientras que return entrega datos para reusar. Para lógica reutilizable y pruebas, prefiere return. Cuando hay varios resultados, puedes retornar una tupla y desempaquetarla al recibir.
Figura 12: El valor None al no usar return en un método
class Mensajes: def mostrar(self, texto): print(texto) # acción, pero no retorna nada m = Mensajes() r = m.mostrar(“Hola”) print(r) # None 3.2. Sin return retorna None class Analitica: def min_max(self, datos): return min(datos), max(datos) # retorna dos valores mn, mx = Analitica().min_max([3, 8, 1, 5]) print(mn mx) # 1 8
Un diccionario da significado a cada dato y facilita su consumo en otras capas del programa o en pruebas. Usar retornos tempranos simplifica la lógica y evita anidaciones de sentencias de control profundas.
Figura 14: Retornar estructuras de datos desde una clase
Figura 15: Control de flujo con retorno anticipado en Python
3.4. Retornar estructuras para claridad (dict)
🔹 Retorno anticipado (guard clauses)
En el ejemplo anterior, se envía la tupla [3,8,1,5] y al invocar la llamada Analitica().min_max[…]: - la variable “mn” recibe el resultado de min(datos) - la variable “mx” recibe el resultado de max(datos) class Facturador: def desglose(self, subtotal, desc=0.0, iva=19.0): base = subtotal * (1 - desc/100) imp = base * (iva/100) total = base + imp return {“subtotal”: subtotal, “base”: base, “impuesto”: imp, “total”: total} class Validador: def raiz_cuadrada(self, x): if x < 0: return None # salida temprana: caso inválido return x ** 0.5
Figura 16: Retornar copias para preservar la integridad de datos
3.7. Importante para las buenas prácticas
- Retorna datos, no hagas solo impresiones: facilita reutilización y testing.
- Documenta qué retorna (tipo y significado).
- Para múltiples resultados, prefiere tupla o dict según claridad.
- Usa retornos tempranos para validar entradas y mantener el método legible. Si retornas una lista/dict construida dentro, quien llama recibe una referencia a ese objeto. Si no quieres que lo modifiquen, puedes retornar una copia: 3.6. Retornar mutables: referencia o copia class Catálogo: def init(self): self._items = {“A”: 10, “B”: 20} def obtener_items(self): return self._items.copy() # protege el estado interno
4.1. Caso de estudio: sistema de cálculo de totales con descuentos e impuestos Una tienda de artículos electrónicos desea implementar un sistema que permita calcular el monto final a pagar por cada compra, aplicando descuentos y el impuesto correspondiente. El sistema debe desarrollarse en Python utilizando programación orientada a objetos, asegurando que el cálculo sea flexible y se pueda adaptar a distintos escenarios de venta. El cálculo parte de un valor subtotal correspondiente a la suma de todos los productos adquiridos. A este subtotal se le puede aplicar un descuento opcional, cuyo valor por defecto será 0 % si no se especifica. Posteriormente, sobre el monto ya descontado, se aplicará el impuesto (IVA) cuyo valor por defecto será 19 %, pero que podrá ser modificado en caso de que la ley cambie o el producto tenga un régimen especial. La solución deberá incluir una clase que contenga al menos tres métodos: uno para aplicar el descuento, otro para calcular el impuesto, y un tercero para generar un desglose con el valor base, el impuesto y el total final. Cada método debe recibir los parámetros necesarios, usar valores por defecto y retornar los resultados calculados, evitando el uso de valores fijos en el código. El sistema también debe validar que los valores ingresados no sean negativos, mostrando un mensaje de error o deteniendo el cálculo si se detecta un dato inválido. Los cálculos deben realizarse con exactitud, considerando decimales para evitar errores de redondeo. Finalmente, se espera que el programa pueda invocarse desde una función main() que simule una compra real, pasando distintos parámetros y mostrando por pantalla el desglose del cálculo. Esta implementación permitirá a la tienda tener una herramienta básica, pero efectiva para automatizar los cálculos y evitar errores humanos, a la vez que servirá como base para integrar más funciones en el futuro, como la gestión de inventario o la emisión de boletas electrónicas.
📌 Acceso a los elementos de una lista
🛠️ Desarrollo
Objetivo Desarrollar una solución en Python, utilizando programación orientada a objetos, que permita a una tienda calcular de forma precisa y automatizada el monto final a pagar por una compra. El sistema debe:
-
Aplicar descuentos opcionales con valor por defecto del 0 %.
-
Calcular impuestos (IVA) con valor por defecto del 19 %, permitiendo modificar este valor cuando sea necesario.
-
Retornar un desglose detallado que incluya el valor base, el impuesto calculado y el total final.
-
Validar que los valores ingresados no sean negativos para garantizar la integridad de los cálculos.
-
Implementar métodos con parámetros y valores por defecto que puedan ser reutilizados en diferentes contextos de venta.
-
Centralizar la lógica en una clase para favorecer el encapsulamiento y la modularidad del código.
-
Ser invocado desde una función main() que simule casos reales de compra, aplicando distintos valores de parámetros para demostrar la flexibilidad de la solución.
Código de implementación: calculadora_comercial.py
Figura 17. Diseño de clases con valores por defecto y control de acceso (Fuente: elaboración propia)
Figura 18. Retorno de datos compuestos con diccionarios (Fuente: elaboración propia)
Resultado Explicación del código Atributos privados
- __tasa almacena el IVA por defecto (19 %).
- __descuento almacena el descuento por defecto (0 %).
- Se declaran como privados para proteger los datos y aplicar encapsulamiento.
Figura 19. Ejecutando cálculos con parámetros por defecto y personalizados (Fuente: elaboración propia)
Figura 20. Resultados del cálculo: comparativa de escenarios
Métodos get/set
-
get_tasa() y set_tasa() permiten leer y modificar la tasa de IVA, validando que no sea negativa.
-
get_descuento() y set_descuento() permiten leer y modificar el descuento, validando que esté entre 0 y 100%. Métodos aplicar_descuento()
-
Recibe subtotal y opcionalmente descuento.
-
Si no se pasa descuento, usa el valor privado por defecto.
-
Calcula la base imponible (subtotal menos el descuento). Método calcular_impuesto()
-
Recibe la base imponible y opcionalmente la tasa de impuesto.
-
Si no se pasa tasa, usa el valor privado por defecto.
-
Calcula el monto del impuesto a partir de la base. Método calcular_total()
-
Combina aplicar_descuento() y calcular_impuesto().
-
Retorna el total final (base + impuesto). Método desglose()
-
Devuelve un diccionario con todos los datos del cálculo: subtotal, descuento, base imponible, impuesto, porcentaje de impuesto y total final.
-
Redondea los valores para presentación clara. Método calcular_impuesto()
-
Crea un objeto de la clase.
-
Configura descuento e IVA por defecto usando los setters.
-
Realiza un cálculo usando valores por defecto y otro sobrescribiendo parámetros.
-
Muestra ambos resultados por pantalla. Buenas prácticas aplicadas
-
Encapsulamiento de datos.
-
Validación de parámetros antes de calcular.
-
Uso de parámetros opcionales y valores por defecto.
-
Métodos que retornan datos en vez de imprimir directamente. Este desarrollo demuestra cómo la implementación de clases y métodos en Python, combinada con el uso de parámetros y valores por defecto, permite construir soluciones flexibles y adaptables a distintos requerimientos, como el cálculo de totales con descuentos e impuestos en un entorno comercial. Mediante la programación orientada a objetos (POO), se logra una estructura clara y organizada que facilita la comprensión, mantenimiento y escalabilidad del código. La incorporación de atributos privados y los métodos get y set refuerza el principio de encapsulamiento, asegurando que los datos internos de la clase se gestionen de forma controlada, evitando modificaciones no deseadas. Este enfoque fomenta la seguridad y la integridad de la información, a la vez que permite una configuración personalizada de los valores por defecto según las necesidades del sistema. El uso de parámetros y valores por defecto en los métodos ofrece flexibilidad, permitiendo que los cálculos se adapten a diferentes escenarios sin necesidad de modificar la lógica interna. Además, el retorno de valores en lugar de imprimir directamente en pantalla promueve la reutilización del código y su integración en otras partes de un sistema mayor. Finalmente, la separación de responsabilidades dentro de la clase y la posibilidad de invocar los métodos desde un main() demuestran buenas prácticas en el diseño de software, sentando las bases para la creación de sistemas más complejos. Este tipo de ejercicios fortalece en los estudiantes la capacidad de analizar un problema, abstraer su solución en forma de métodos bien definidos y aplicar principios de diseño que son esenciales en el desarrollo de aplicaciones profesionales y sostenibles.
📌 Reflexión
Durante esta semana, los y las estudiantes han profundizado en el uso de métodos en Python, poniendo especial énfasis en el paso de parámetros, los valores por defecto y el retorno de datos. A través de actividades prácticas, han comprendido cómo estas características permiten construir métodos más flexibles, claros y adaptables a diferentes necesidades, fortaleciendo la capacidad de diseñar soluciones eficientes. El trabajo en programación orientada a objetos (POO) ha permitido integrar estos métodos dentro de clases con atributos privados, reforzando el principio de encapsulamiento y promoviendo un acceso seguro y controlado a la información interna de los objetos. La implementación de métodos get y set ha mostrado cómo mantener la integridad de los datos, al mismo tiempo que se facilita su configuración y uso. Asimismo, se ha puesto en práctica la modularidad mediante el uso de la sentencia import, separando el programa en varios archivos para una mejor organización, mantenimiento y escalabilidad. Este enfoque, sumado al diseño de métodos con parámetros opcionales y valores por defecto, ha brindado a los estudiantes una visión más profesional sobre la construcción de sistemas. La comprensión y aplicación de estos conceptos ha permitido que los estudiantes elaboren programas donde los métodos encapsulan tareas específicas, retornan resultados reutilizables y se invocan de forma controlada desde funciones principales como main(). Este cierre busca consolidar la conexión entre teoría y práctica, preparando a los y las estudiantes para enfrentar retos de programación más complejos, con una base sólida en el diseño modular y la organización del código.
💡 Conclusión
🚀 Potencia tus proyectos tecnológicos con Proyecto Luna
En Proyecto Luna desarrollamos arquitectura de software de alto rendimiento, optimización de bases de datos críticas y soluciones aplicadas de inteligencia artificial y automatización para empresas y profesionales.
- 💼 Soluciones de ingeniería: Conoce nuestras capacidades y casos de estudio en proyectoluna.com/work/.
- 🛡️ Seguridad y auditoría: Orientación técnica y respuesta ante incidentes en ¿Te han hackeado?.
- 📩 Contacto directo: Escríbenos a través de nuestro formulario de contacto o a
contacto@proyectoluna.com.
📚 Fuentes y lecturas recomendadas
- Chazallet, M. (2020). Programación orientada a objetos en Python. Ediciones Informáticas. http://descubridor.santotomas.cl/primo_library/libweb/action/display.do?tabs=details Tab&ct=display&fn=search&doc=cst_aleph000043172&indx=1&recIds=cst_aleph00004 3172&recIdxs=0&elementId=0&renderMode=poppedOut&displayMode=full&frbrVers ion=&dscnt=1&scp.scps=scope%3A%28cst_aleph%29%2Cscope%3A%28cst_digitool% 29&frbg=&tab=cst_tab&vl(87563938UI0)=any&dstmp=1753287226753&srt=rank&mode =Basic&dum=true&tb=t&vl(1UIStartWith0)=exact&vl(freeText0)=Introducci%C3%B3n +a+la+programaci%C3%B3n+con+Python.&vl(107694436UI1)=all_items&vid=CST Downey, A. (2002). Aprenda a pensar como un programador con Python. Green Tea Press. http://descubridor.santotomas.cl/primo_library/libweb/action/display.do?tabs=details Tab&ct=display&fn=search&doc=cst_aleph000048949&indx=1&recIds=cst_aleph00004 8949&recIdxs=0&elementId=0&renderMode=poppedOut&displayMode=full&frbrVers ion=&dscnt=1&scp.scps=scope%3A%28cst_aleph%29%2Cscope%3A%28cst_digitool% 29&frbg=&tab=cst_tab&vl(87563938UI0)=any&dstmp=1753287839287&srt=rank&mode =Basic&dum=true&tb=t&vl(1UIStartWith0)=exact&vl(freeText0)=Aprenda+a+pensar+c omo+un+programador+con+Python.&vl(107694436UI1)=all_items&vid=CST Marzal, M., y García, R. (2011). . Pearson. http://descubridor.santotomas.cl/primo_library/libweb/action/display.do?tabs=details Tab&ct=display&fn=search&doc=cst_aleph000062601&indx=1&recIds=cst_aleph00006 2601&recIdxs=0&elementId=0&renderMode=poppedOut&displayMode=full&frbrVers ion=&dscnt=1&scp.scps=scope%3A%28cst_aleph%29%2Cscope%3A%28cst_digitool% 29&frbg=&tab=cst_tab&vl(87563938UI0)=any&dstmp=1753287991817&srt=rank&mode =Basic&dum=true&tb=t&vl(1UIStartWith0)=exact&vl(freeText0)=Python+3%3A+los+fu ndamentos+del+lenguaje.&vl(107694436UI1)=all_items&vid=CST
