📌 En síntesis: Comparativa de algoritmos de ordenamiento cuadráticos y logarítmicos: principio divide y vencerás, estabilidad y rendimiento práctico.

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 la programación, uno de los fundamentos esenciales para organizar y reutilizar código es el uso de métodos. Los métodos permiten encapsular instrucciones dentro de una clase para que puedan ser ejecutadas repetidamente bajo diferentes condiciones, promoviendo así la claridad, modularidad y mantenimiento del código. En Python, un método es una función definida dentro de una clase, que actúa sobre los atributos del objeto. A lo largo de este apunte, profundizaremos en cómo se definen, estructuran e invocan métodos, y cómo se integran en programas más grandes que hacen uso de la programación orientada a objetos (POO). Comenzaremos por revisar la definición formal de un método y su diferencia con una función común. Luego, analizaremos su estructura básica, destacando el uso del parámetro especial self, que permite a un método acceder a los atributos y otros métodos de la clase a la que pertenece. También aprenderemos a realizar la declaración de un método, es decir, cómo escribirlo correctamente dentro de una clase, incluyendo la sintaxis apropiada y buenas prácticas de estilo. Uno de los aspectos más importantes en programación es invocar métodos correctamente. Veremos cómo se llaman desde una instancia de clase, y cómo hacerlo desde una función especial llamada main() que actúa como punto de entrada del programa. Además, exploraremos la utilidad de la sentencia import, que permite separar el código en diferentes archivos, facilitando la organización y reutilización de clases y métodos en distintos proyectos. Por último, se explicarán los conceptos de parámetro y declaración de parámetro, fundamentales para que los métodos sean dinámicos y reciban información desde su invocación. Entenderemos cómo declarar uno o más parámetros dentro de un método, y cómo estos afectan su funcionalidad.

Este apunte te entregará una base sólida para construir tus propias clases con métodos bien definidos, invocados correctamente, y capaces de resolver subproblemas de forma clara, ordenada y profesional.

En Python, un método es una función definida dentro de una clase que realiza una acción específica y opera sobre los datos (atributos) del objeto creado a partir de esa clase. Es una de las principales herramientas que se utilizan en programación orientada a objetos (POO). A diferencia de una función común que se puede usar de forma independiente, un método pertenece a un objeto y se accede a través de dicho objeto. Es decir, el método “vive dentro” de la clase y se invoca mediante una instancia (objeto) de esa clase. Todos los métodos deben recibir por convención un primer parámetro llamado self, que hace referencia al propio objeto. Gracias a self, los métodos pueden acceder o modificar los atributos del objeto o llamar a otros métodos dentro de la misma clase. A continuación, vemos un ejemplo de método siempre dentro de una clase. ¿Qué se hizo aquí?

• Se creó una clase llamada Saludo.
• Dentro de ella, se definió un método llamado decir_hola.
• El método imprime un mensaje por pantalla.
• El parámetro self es obligatorio, aunque no se use directamente.

Figura 1: Ejemplo básico de clase con método en Python

---

📌 Definición de método

class Saludo: def decir_hola(self): print(“Hola, bienvenidos a la clase de programación.”)

¿Qué se hizo aquí?

• Se creó una clase Estudiante con un atributo nombre.

• Se definió un método saludar() que usa self.nombre para acceder al dato del objeto y mostrarlo.

• El método se puede usar en cualquier instancia creada a partir de la clase.

Figura 2: Método que accede a un atributo del objeto

Ahora, abordemos el siguiente ejemplo de método que accede a un atributo del objeto. class Estudiante: def init(self, nombre): self.nombre = nombre # Atributo def saludar(self): print(“Hola, mi nombre es”,

Figura 3. Definición de métodos con parámetros en Python

2.1. Componentes detallados de un método Tabla 1. Componentes detallados de un método Un método en Python tiene una estructura muy similar a una función, pero se define dentro de una clase y su primer parámetro debe ser siempre self. Este parámetro representa al objeto actual que llama al método y permite acceder a sus atributos y otros métodos.

---

📌 Acceso a los elementos de una lista

---

⚙️ Estructura de un método en Python

class NombreClase: def nombre_metodo(self, parametro1, parametro2, …): # Bloque de instrucciones return resultado Parte Descripción class NombreClase: Declaración de la clase donde se define el método. def nombre_metodo: Palabra clave def seguida del nombre del método (en minúsculas y con guion bajo si tiene más de una palabra). self: Siempre debe estar como primer parámetro. Representa la instancia actual del objeto y permite acceder a sus atributos y otros métodos. parametros: Opcionales. Se usan para enviar información al método desde el exterior. # bloque de código: Instrucciones que definen lo que hace el método (puede incluir condiciones, cálculos, impresión, retornos, etc.). return: También opcional. Se usa si se desea que el método devuelva un resultado.

Explicación

• El método multiplicar tiene dos parámetros: a y b.

• Asigna el producto de la mutiplicación a la variable resultado

• Retorna el producto de esos dos valores. Explicación

• Se define un método llamado mostrar sin parámetros (solo el obligatorio self).

• Imprime un mensaje al ser llamado o invocado. Ahora veamos un ejemplo de método con parámetros.

Figura 5: Método con parámetros

Figura 4: Método sin parámetros adicionales

Veamos a continuación un ejemplo de método sin parámetros adicionales. class Mensaje: def mostrar(self): print(“Este es un método sin parámetros.”) class Calculadora: def multiplicar(self, a, b): resultado = a * b return resultado

Explicación

• El método init se ejecuta al crear el objeto (es un constructor).

• El método calcular_promedio accede a los atributos del objeto usando self y calcula el promedio de las dos notas. Considerar que primero relaiza la operación del oarpentesis, es decir a suma y luego la divide en 2, para entregar e promedio.

• Usa nombres descriptivos en minúsculas, separados por guiones bajos si es necesario (mostrar_mensaje, sumar_valores).

• Siempre comienza con la palabra reservada def y usa self como primer parámetro.

• Si el método realiza una acción sin necesidad de devolver algo, puedes omitir return.

• Si se espera un resultado del método (por ejemplo, un cálculo), usa return para devolverlo.

• Documenta el método con comentarios o docstrings si es complejo. 2.2. Recomendaciones para escribir métodos bien estructurados

Figura 6: Método que usa atributos del objeto

Finalmente, desarrollamos un ejemplo de método que usa atributos del objeto. class Estudiante: def init(self, nombre, nota1, nota2): self.nombre = nombre self.nota1 = nota1 self.nota2 = nota2 def calcular_promedio(self): return (self.nota1 + self.nota2) / 2

Figura 7: Reglas básicas para declarar un método en Python

La declaración de un método en Python se refiere al proceso de escribir su definición dentro de una clase, especificando su nombre, parámetros y el bloque de instrucciones que lo componen. Declarar un método correctamente es fundamental para que la clase pueda ejecutar tareas específicas sobre los objetos que se creen a partir de ella. Toda declaración de método sigue una estructura base, pero puede variar según el tipo de operación que se necesite (mostrar información, procesar datos, devolver resultados, modificar atributos, etc.). 3.1. Reglas básicas para declarar un método en Python En la Figura 7 se reseñan las 7 reglas básicas para poder declarar un método en Python.

---

📌 Acceso a los elementos de una lista

---

📌 Declaración de un método

Debe comenzar con la palabra clave def. Debe tener un nombre válido y representativo Puede incluir parámetros adicionales, según lo que el método necesite. Puede o no tener un return, dependiendo si debe devolver un resultado. Debe tener un bloque de código con la acción que realiza.

---

📌

Debe estar dentro de una clase. El primer parámetro siempre debe ser self, que representa la instancia actual del objeto.

---

📌

---

📌

---

📌

---

📌

---

📌

---

📌

Explicación

• El nombre del método es decir_hola.
• Solo tiene el parámetro self porque no necesita información adicional.
• Imprime un saludo al ejecutarse, en la salida estandar, que es la consola o el terminal. Veamos un ejemplo de método sin parámetros adicionales. Continuemos con un método con parámetros y return.

Figura 8: Sintaxis general de declaración

Figura 10: Método sumar dentro de una clase en Python

Figura 9: Método básico dentro de una clase: ejemplo práctico

3.2. Sintaxis general de declaración class NombreClase: def nombre_metodo(self, parametro1, parametro2, …): # Bloque de instrucciones return resultado class Saludo: def decir_hola(self): print(“Hola, ¿cómo estás?”) class Matematica: def sumar(self, a, b): return a + b

Figura 11: Ejemplo de clase con atributo y método en Python Figura 11. Ejemplo de clase con atributo y método e

Figura 11: Ejemplo de clase con atributo y método en Python

Figura 12: Ejemplo de clase con atributo y método en Python

A continuación, un ejemplo de método que modifica un atributo Explicación

• El nombre del método es sumar, que recibe dos parámetros (a y b).

• Usa return para devolver la suma de esos valores.

• Puede ser reutilizado en cualquier parte del programa donde se requiera una suma. Explicación

• El método llamado incrementar modifica el atributo valor del objeto usando self.valor.

• Se declara con un parámetro adicional cantidad, que define cuánto se suma.

• El operador “+=” primero suma valor con cantidad y luego lo asigna a la variable self.valor.suma. Ahora, un ejemplo de método sin retorno (acción directa) class Contador: def init(self): self.valor = 0 def incrementar(self, cantidad): self.valor += cantidad class Mensaje: def mostrar_mensaje(self, texto): print(“Mensaje recibido:”, texto)

Explicación

• Este método no retorna valor alguno.

• Ejecuta directamente una instrucción con print, que cumple una acción. Importante

• Un método se declara con def dentro de una clase.

• El primer parámetro siempre debe ser self.

• Puedes agregar más parámetros si el método necesita recibir datos externos.

• Usa return solo si necesitas devolver un resultado al exterior.

• Usa return cuando necesitas devolver un valor que será utilizado después (por ejemplo, en cálculos).

• No uses return si el método solo imprime o modifica internamente los atributos del objeto. 3.3. ¿Cuándo usar return y cuándo no?

O, si el método requiere parámetros: 4.1. ¿Qué es invocar un método? Invocar un método significa ejecutarlo, es decir, llamarlo desde algún punto del programa para que realice la acción para la cual fue definido. En Python, los métodos se invocan desde un objeto (instancia) de una clase, utilizando la notación de punto (.). Cada vez que se invoca un método, se ejecuta el bloque de código que contiene, utilizando los valores actuales del objeto (sus atributos) y los parámetros proporcionados si los requiere. 4.2. ¿Por qué es importante?

Figura 14: Cómo pasar parámetros a un método de un objeto

Figura 13: Cómo usar un método de un objeto en Python

• Permite activar el comportamiento programado dentro de una clase.

• Permite modificar atributos, procesar datos, retornar resultados o ejecutar acciones.

• Es la base para organizar programas de manera modular y reutilizable 4.3. Sintaxis general de invocación de un método

---

📌 Acceso a los elementos de una lista

---

📌 Invocación de un método

objeto.metodo() objeto.metodo(valor1, valor2, …)

Explicación Crea un objeto s de la clase Saludo y llama al método decir_hola() que imprime un mensaje. A continuación, un ejemplo para invocar un método con parámetros.

Figura 15: Definir una clase, crear un objeto e invocar un método en Python

El objeto debe haber sido creado previamente a partir de la clase que contiene el método. Veamos un ejemplo para invocar un método sin parámetros class Saludo: def decir_hola(self): print(“Hola, ¡bienvenido!”) # Crear objeto s = Saludo() # Invocar el método s.decir_hola()

Explicación Invoca el método sumar() pasando 10 y 5 como argumentos. El método retorna 15 que se guarda en la variable resultado y se imprime ese valor. Seguimos ahora con un ejemplo para invocar un método desde otro método.

Figura 17: Ejemplo de invocación interna de métodos en Python

Figura 16: Método con parámetros: ejemplo práctico en Python

class Matematica: def sumar(self, a, b): return a + b # Crear objeto m = Matematica() # Invocar el método resultado = m.sumar(10, 5) print(“La suma es:”, resultado) class Usuario: def init(self, nombre): self.nombre = nombre def saludar(self): print(f“Hola, soy {self.nombre}”) def presentarse(self): print(“Me presento:”) self.saludar() # Invocación interna u = Usuario(“Claudia”) u.presentarse()

Importante

• Si un método espera parámetros y no se le entregan al invocarlo, Python lanza un error TypeError.

• Puedes invocar varias veces el mismo método, con distintos valores, sin volver a escribir su definición.

• El orden de los argumentos debe coincidir con los parámetros definidos en la declaración del método. 4.4. Buenas prácticas al invocar métodos

• Asegúrate de que el objeto esté correctamente instanciado antes de invocar el método.

• Si el método retorna un valor, guárdalo en una variable si lo necesitas más adelante.

• Comenta brevemente el propósito de la invocación si ayuda a la claridad del código.

Figura 18: Salida del programa con invocación interna de métodos

Explicación presentarse() llama al método saludar() desde dentro de la clase. La salida será: Me presento: Hola, soy Claudia

Figura 19: Definición de clase con atributos y método para mostrar información

4.5. Ejemplo final: invocación en la práctica class Producto: def init(self, nombre, precio): self.nombre = nombre self.precio = precio def mostrar_info(self): print(f“Producto: {self.nombre}, Precio: ${self.precio}”) p1 = Producto(“Teclado”, 15990) p1.mostrar_info() # Invoca el método desde el objeto p1

5.1. ¿Qué es la sentencia import? En Python, la sentencia import se utiliza para reutilizar código que está en otros archivos o módulos. Esto permite organizar proyectos grandes dividiendo el código en partes más pequeñas, reutilizables y fáciles de mantener. Cuando defines una clase o un conjunto de métodos en un archivo, puedes usarlos desde otro archivo mediante import, sin tener que copiarlos ni reescribirlos. 5.2. ¿Por qué es importante? 5.3. Ejemplo básico. Paso a paso Archivo 1: saludo.py 1. Permite reutilizar código ya escrito. 2. Mejora la organización y modularidad. 3. Facilita el trabajo en equipo (cada persona puede trabajar en archivos distintos). 4. Aumenta la legibilidad del programa.

---

📌 Acceso a los elementos de una lista

---

📌 Sentencia import

saludo.py class Saludo: def decir_hola(self): print(“Hola, desde otro archivo.”)

Figura 20: Definición de clase en un archivo independiente (saludo.py)

Este archivo define una clase Saludo con un método decir_hola().

5.4. ¿Qué hace este código?

• from saludo import Saludo: le indica a Python que busque la clase Saludo dentro del archivo saludo.py.

• Luego, en main(), se crea un objeto de esa clase y se invoca su método.

• El resultado será: Hola, desde otro archivo. 5.5. Otras formas de importar Importar todo el módulo

Figura 21: Importar y utilizar una clase desde otro archivo en Python

Figura 22: Importar un módulo completo y acceder a sus clases en Python

Archivo 2: principal.py # principal.py # Importar la clase desde saludo.py from saludo import Saludo def main(): s = Saludo() s.decir_hola() if name == “main”: main() import saludo s = saludo.Saludo() s.decir_hola()

Figura 24: Uso de alias al importar un módulo en Python

Figura 23: Importar múltiples clases específicas desde un módulo en Python

Aquí se importa todo el archivo saludo.py y se accede a la clase usando la notación saludo.Clase. Importar varias clases Puedes importar múltiples clases o funciones separadas por comas. Importar varias clases Puedes importar múltiples clases o funciones separadas por comas. Importar varias clases Esto es útil si el nombre del archivo es largo o si quieres abreviarlo. Buenas prácticas

• El archivo que contiene la clase debe estar en el mismo directorio (carpeta) que el archivo desde el cual se importa (o debes configurar el PYTHONPATH).

• Los nombres de archivo no deben coincidir con palabras clave de Python (por ejemplo, no llames tu archivo math.py).

• Evita ciclos de importación, es decir, que dos archivos se importen entre sí. from modulo import Clase1, Clase2 import saludo as s persona = s.Saludo() persona.decir_hola()

Tabla 2. Formas de importar módulos y clases en Python Elemento Significado / Uso import archivo Importa todo el archivo, accedes con archivo.Clase() from archivo import Clase Importa directamente la clase o función desde otro archivo import archivo as alias Importa el archivo con un nombre más corto archivo.py Archivo donde defines las clases o métodos a usar if name == “main”: Punto de inicio del programa principal, evita que se ejecute al ser importado No olvidar

6.3. ¿Por qué llamar métodos desde main()?

Figura 25: Estructura de la función principal en Python

🔹 ¿Qué es main() en Python?

En Python, no existe una función main() obligatoria como en otros lenguajes como C o Java, pero se utiliza por convención para organizar el punto de inicio de ejecución de un programa. Usar main() ayuda a que el código sea más claro, escalable y reutilizable. Al colocar la ejecución del programa dentro de una función main() y protegerla con una condición especial llamada if name == “main”:, te aseguras de que el código solo se ejecute cuando el archivo sea ejecutado directamente, y no cuando sea importado desde otro módulo. 6.2. Estructura básica de main()

• Permite organizar el flujo de ejecución del programa.
• Separa la lógica de definición (clases y métodos) de la ejecución principal.
• Facilita las pruebas, la depuración y el mantenimiento del código.
• Hace que tu archivo pueda ser importado por otros sin que se ejecute automáticamente.

---

📌 Acceso a los elementos de una lista

---

📌 Llamada de método desde main()

def main(): # Aquí va el código principal … if name == “main”: main()

Figura 26: Ejemplo de clase y método invocado desde la función main en Python

Figura 27: Implementación de una clase Calculadora y ejecución de

método desde main() Veamos un ejemplo de llamada de método sin parámetros. A continuación un ejemplo de llamada de método con parámetros y retorno. class Saludo: def decir_hola(self): print(“Hola, desde el método llamado en main.”) def main(): s = Saludo() # Crear objeto s.decir_hola() # Llamar método if name == “main”: main() class Calculadora: def sumar(self, a, b): return a + b def main(): calc = Calculadora() resultado = calc.sumar(10, 5) print(“La suma es:”, resultado) if name == “main”: main()

Figura 28: Definición de la clase Usuario con múltiples métodos e invocación

desde main() Ahora un ejemplo para llamar métodos encadenados desde main() 6.4. ¿Qué significa if name == “main”? Cuando Python ejecuta un archivo:

• Si el archivo se ejecuta directamente, name vale “main”, entonces se llama a main().

• Si el archivo se importa desde otro, name no vale “main” y no se ejecuta la función main() automáticamente. Esto permite reutilizar el archivo sin que su lógica principal se dispare sin control. class Usuario: def init(self, nombre): self.nombre = nombre def mostrar_nombre(self): print(f“Usuario: {self.nombre}”) def saludo(self): print(“¡Bienvenido/a!”) def main(): u = Usuario(“Camila”) u.mostrar_nombre() u.saludo()

6.5. Buenas prácticas

• Usa main() siempre que tu programa tenga más de una clase o múltiples llamadas.

• Solo coloca en main() lo que se ejecuta directamente, y mantén la lógica dentro de métodos.

• Usa input() dentro de main() si necesitas interacción con el usuario.

• Siempre acompaña main() con la condición if name == “main” para proteger la ejecución.

Figura 29: Uso de parámetros y argumentos en métodos de clase

Ejemplo Tabla 3. Diferencia entre parámetro y argumento 7.1. ¿Qué es un parámetro? Un parámetro en Python es una variable que se declara dentro de la definición de una función o método, y que sirve para recibir valores desde el exterior cuando esa función o método es invocado. En otras palabras, los parámetros permiten enviar datos al interior de un método para que estos datos sean usados en sus instrucciones. Esto hace que el método sea reutilizable y adaptable a diferentes situaciones. 7.2. Diferencia entre parámetro y argumento

---

📌 Acceso a los elementos de una lista

---

🧠 Concepto de parámetro y declaración de parámetro

Término Definición Parámetro Es la variable que se declara en la definición del método. Argumento Es el valor real que se entrega cuando se llama al método. def saludar(self, nombre): # nombre es un parámetro print(“Hola”, nombre) s.saludar(“Ana”) # “Ana” es el argumento

Ahora, un ejemplo de método con varios parámetros. 7.3. ¿Por qué usar parámetros?

• Para personalizar la ejecución de un método.
• Para enviar datos que necesita el método sin depender de atributos fijos.
• Para evitar repetir código creando métodos reutilizables. A continuación veamos un ejemplo de método con un parámetro. class Saludo: def decir_hola(self, nombre): # parámetro: nombre print(f“Hola, {nombre}”) s = Saludo() s.decir_hola(“Carlos”) # argumento: “Carlos”

Figura 31: Definición de un método con múltiples parámetros en una clase

Figura 30: Uso de parámetros y argumentos en un método de clase

class Calculadora: def multiplicar(self, a, b): # parámetros: a, b return a * b c = Calculadora() print(“Resultado:”, c.multiplicar(4, 5)) #

Tabla 4. Conceptos clave: parámetros y argumentos en métodos Explicación Si no se proporciona argumento, se usa “Invitado” como valor por defecto. 7.4. Consideraciones al declarar parámetros Importante Toma en cuenta las diferencias entre los siguientes conceptos clave. 1. Los parámetros se declaran entre paréntesis después de self en la definición del método. 2. Puedes declarar uno o más parámetros, separados por comas. 3. Puedes usar valores por defecto (parametro=valor) para que no sea obligatorio entregar ese dato. 4. Evita declarar más parámetros de los necesarios para no complicar el método. Finalmente un ejemplo de parámetros con valores por defecto.

Figura 32: Parámetros con valores por defecto en métodos de clase

class Bienvenida: def saludar(self, nombre=“Invitado”): print(f“Bienvenido/a, {nombre}”) b = Bienvenida() b.saludar() # Usa valor por defecto b.saludar(“Lucía”) # Usa argumento Concepto Explicación breve Parámetro Variable usada dentro del método para recibir datos Argumento Valor que se entrega al método cuando se llama Declaración de parámetro Se hace dentro del paréntesis al definir el método (def metodo(self, x, y):) Reutilización Puedes usar el mismo método con distintos valores gracias a los parámetros

• Registrar productos de forma dinámica a través de métodos personalizados.

• Mostrar todos los productos registrados y sus respectivos precios.

• Identificar y mostrar el producto con el precio más alto.

• Aplicar principios de encapsulamiento, permitiendo el acceso controlado al diccionario mediante métodos get y set.

• Organizar el programa en múltiples archivos, utilizando la sentencia import para estructurar el código de forma modular, clara y reutilizable. Caso de estudio: registro de productos y cálculo del precio más alto Una tienda desea implementar un sistema en Python que permita registrar productos y sus precios utilizando un diccionario privado. Además, el sistema debe tener un método para mostrar todos los productos registrados, otro para obtener el producto más caro, y un método get y set para acceder o modificar los datos desde fuera de la clase. Objetivo Desarrollar una solución en Python utilizando programación orientada a objetos, que permita a una tienda gestionar un catálogo de productos y sus precios mediante el uso de un diccionario privado. El sistema debe ser capaz de: Este caso fortalece el dominio de conceptos como clases, métodos, parámetros, diccionarios, encapsulamiento, modularidad y el uso de main() como punto de entrada del programa.

---

🛠️ Desarrollo

Figura 33. Clase RegistroProductos: encapsulación y gestión de

datos con métodos get y set Código de implementación Archivo 1: registro_productos.py

Explicación del código

• Se crea la clase RegistroProductos.

• Se usa un diccionario privado __productos para guardar los productos.

• El método agregar_producto() permite registrar un producto con su precio.

• El método mostrar_productos() recorre el diccionario y muestra los datos.

• producto_mas_caro() devuelve el nombre y precio del producto más costoso.

• get_productos() y set_productos() permiten acceder y modificar el diccionario externamente, respetando el encapsulamiento.

• En la función main(), se crean productos, se invocan los métodos y se muestra el resultado. Resultado

Figura 34. Ejecución del programa principal: uso de

la clase RegistroProductos desde otro archivo

Figura 35. Salida del programa: listado y producto más caro

Código de implementación Archivo main.py

Este desarrollo evidencia cómo la correcta implementación de clases y métodos en Python permite construir soluciones modulares y funcionales para problemas cotidianos, como la gestión de productos en una tienda. Utilizando un diccionario como estructura clave–valor, se logra representar eficientemente el catálogo, asignando a cada producto un precio y permitiendo su administración de manera controlada. El uso de la programación orientada a objetos (POO) aporta claridad y organización al sistema, facilitando la reutilización del código en diferentes contextos. En particular, la incorporación de atributos privados y los métodos get y set refuerzan el principio de encapsulamiento, permitiendo un acceso seguro a la información interna del objeto sin exponer directamente los datos. Por otra parte, los métodos definidos dentro de la clase permiten agregar, mostrar y analizar la información almacenada, destacando el producto con mayor valor como ejemplo de análisis de datos simple, pero significativo. Además, la separación del código en dos archivos utilizando la sentencia import demuestra una práctica profesional para mantener proyectos limpios, escalables y fáciles de mantener. Este tipo de desarrollo no solo fortalece las competencias en Python, sino que también prepara al estudiante para enfrentar desafíos reales de programación, donde la modularidad, la claridad en el diseño y el uso de estructuras adecuadas son fundamentales para crear sistemas robustos y sostenibles en el tiempo.

---

📌 Reflexión

Durante esta semana, los y las estudiantes han profundizado en el uso de métodos en Python, abordando su declaración, estructura, parámetros e invocación desde clases y desde funciones principales como main(). A través de actividades prácticas, han comprendido cómo los métodos permiten encapsular acciones específicas y reutilizables, mejorando la organización y claridad del código. El trabajo con programación orientada a objetos (POO) ha permitido integrar estos métodos en clases que modelan comportamientos concretos, fortaleciendo la lógica del diseño modular. Los estudiantes han desarrollado soluciones en las que los métodos interactúan con atributos privados, empleando estructuras como diccionarios para almacenar y manipular datos de forma eficiente y controlada. Asimismo, se ha aplicado la sentencia import para dividir el programa en múltiples archivos, promoviendo buenas prácticas de desarrollo profesional y reforzando el concepto de modularidad en proyectos escalables. La comprensión del uso de parámetros y argumentos ha sido clave para que los estudiantes puedan diseñar métodos flexibles, capaces de adaptarse a distintos contextos de uso. Este cierre reflexivo busca consolidar los aprendizajes logrados, vinculando el diseño teórico de métodos con su aplicación práctica en programas reales. Comprender la correcta implementación y uso de métodos es esencial para el desarrollo de software robusto, organizado y mantenible, preparando a los y las estudiantes para enfrentar nuevos desafíos de programación con mayor autonomía y confianza.

---

💡 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