Fundamentos de Programación y Python

1

¿Por qué aprender Python?

2

Introducción a Python

3

Conceptos Básicos de Programación

4

Práctica: Te doy la bienvenida a los ejercicios interactivos

5

Manipulación de Cadenas de Texto en Python

6

Enteros, Flotantes y Booleanos

7

Todo lo que Debes Saber sobre print en Python

8

Operaciones Matemáticas en Python

9

Operaciones de Entrada/Salida en Consola

Colección y Procesamiento de Datos en Python

10

Listas

11

Método slice

12

Listas de más dimensiones y Tuplas

13

Aplicación de Matrices

14

Diccionarios

15

Comprehension Lists en Python (CLASE NUEVA)

Control de Flujo en Python

16

Estructuras condicionales

17

Bucles y Control de Iteraciones

18

Generadores e Iteradores

Funciones y Manejo de Excepciones en Python

19

Uso de Funciones en Python

20

Funciones Lambda y Programación Funcional en Python

21

¿Cómo realizar una función recursiva en Python?

22

Manejo de Excepciones y Uso de Pass (CLASE NUEVA)

Programación Orientada a Objetos en Python

23

Fundamentos de Programación Orientada a Objetos en Python

24

Ejercicio Biblioteca con POO

25

Herencia en POO con Python

26

Objetos heredados

27

Los 4 pilares de la programacion orientada a objetos

28

Uso de super() en Python (CLASE NUEVA)

29

Superando los Fundamentos de Programación Orientada a Objetos en Python

Lectura y escritura de archivos

30

Manejo de Archivos .TXT (CLASE NUEVA)

31

Manejo de Archivos CSV (CLASE NUEVA)

32

Manejo de Archivos JSON (CLASE NUEVA)

Biblioteca estándar de Python

33

Biblioteca estándar en Python (CLASE NUEVA)

34

Librería Os, Math y Random (CLASE NUEVA)

35

Librería Statistics y Análisis Estadístico (CLASE NUEVA)

36

Proyecto final: Guerra naval

Conceptos avanzados de Python

37

Recapitulación de lo aprendido hasta ahora

38

Escribir código Pythonico y profesional

39

Comentarios y Docstrings en Python

40

Scope y closures: variables locales y globales

41

Anotaciones de tipo

42

Validación de tipos en métodos

43

Librería Collections y Enumeraciones

Decoradores

44

Decoradores en Python

45

Decoradores anidados y con parámetros

46

Uso de Decoradores en clases y métodos

Métodos y estructura de clases en Python

47

Métodos mágicos

48

Sobrecarga de operadores

49

Implementación de `if __name__ == "__main__":`

50

Metaprogramación en Python

51

Uso de *args y **kwargs

52

Métodos privados y protegidos

53

Gestión avanzada de propiedades

54

Métodos estáticos y de clase avanzados

Programación concurrente y asíncrona

55

Introducción a la concurrencia y paralelismo

56

Threading y multiprocessing en Python

57

Asincronismo con asyncio

58

Asincronismo y concurrencia

Creación de módulos y paquetes

59

Creación de módulos en Python

60

Gestión de paquetes

61

Publicación de paquetes en PyPI

Proyecto final

62

Implementación de un sistema completo

63

Implementación de un Sistema Completo

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Python

Curso de Python

Carli Code

Carli Code

Metaprogramación en Python

50/63
Recursos

Aportes 9

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Este curso como muchos otros habría que reformularlo. Aprecio la vocación de la profesora pero creo faltó planificación. No se puede empezar una clase, por ejemplo de metaprogramación en python, sin explicar qué es la metaprogramación, qué problema resuelve o cuál es su utilidad, y pediría si no fuera mucho que no sólo se de un ejemplo sencillo sacado de la nada, sería mucho mejor que proveyeran ejemplos reales de utilidad práctica. En lo posible dentro de un mismo curso se podría ir trabajando el mismo ejemplo desde el comienzo de un problema real y distintas formas de solucionarlo, ir haciendo refactoring, o mostrando distintas aristas a un caso concreto y real.
La metaprogramación en Python es una técnica que permite a los programas manipular o generar código durante su ejecución. Esto se puede lograr a través de varias funcionalidades del lenguaje, como las clases, los decoradores, las funciones de alto orden y los metaclases. Aquí tienes un resumen de las principales técnicas de metaprogramación en Python: \### 1. \*\*Decoradores\*\* Los decoradores son una forma de modificar el comportamiento de una función o método. Puedes crear decoradores para agregar funcionalidades adicionales sin modificar el código original. ```python def mi\_decorador(func): def envoltura(): print("Algo se está haciendo antes de llamar a la función.") func() print("Algo se está haciendo después de llamar a la función.") return envoltura @mi\_decorador def saludar(): print("¡Hola!") saludar() ``` \### 2. \*\*Funciones de alto orden\*\* Las funciones de alto orden son aquellas que pueden recibir otras funciones como argumentos o devolverlas como resultados. Esto permite crear comportamientos dinámicos. ```python def aplicar\_funcion(func, valor): return func(valor) def elevar\_al\_cuadrado(x): return x \*\* 2 resultado = aplicar\_funcion(elevar\_al\_cuadrado, 5) print(resultado) # Salida: 25 ``` \### 3. \*\*Clases y la creación dinámica de clases\*\* Puedes crear clases dinámicamente utilizando el método `type()`, lo que permite definir clases en tiempo de ejecución. ```python def crear\_clase(nombre): return type(nombre, (object,), {}) MiClase = crear\_clase("ClaseDinamica") objeto = MiClase() print(type(objeto)) # Salida: \<class '\_\_main\_\_.ClaseDinamica'> ``` \### 4. \*\*Metaclases\*\* Las metaclases son clases de clases, lo que significa que definen cómo se crean las clases. Puedes crear una metaclase para modificar la creación de clases. ```python class MiMeta(type): def \_\_new\_\_(cls, nombre, bases, dct): dct\['nuevo\_atributo'] = 'Soy un nuevo atributo' return super().\_\_new\_\_(cls, nombre, bases, dct) class MiClase(metaclass=MiMeta): pass objeto = MiClase() print(objeto.nuevo\_atributo) # Salida: Soy un nuevo atributo ``` \### 5. \*\*Reflexión y introspección\*\* Python permite inspeccionar objetos en tiempo de ejecución, lo que puede ser útil para metaprogramación. Puedes utilizar funciones como `getattr()`, `setattr()`, `hasattr()` y `dir()`. ```python class Persona: def \_\_init\_\_(self, nombre): self.nombre = nombre persona = Persona("Juan") print(getattr(persona, 'nombre')) # Salida: Juan setattr(persona, 'edad', 30) print(persona.edad) # Salida: 30 ``` \### Ventajas y desventajas \*\*Ventajas:\*\* \- Permite crear código más flexible y reutilizable. \- Facilita la creación de bibliotecas y frameworks. \- Puede simplificar el código al evitar duplicaciones. \*\*Desventajas:\*\* \- Puede hacer que el código sea más difícil de entender. \- El uso excesivo puede llevar a un rendimiento reducido. \- Puede complicar la depuración debido a su naturaleza dinámica. La metaprogramación es una poderosa herramienta en Python, pero debe usarse con cuidado para mantener la claridad y la mantenibilidad del código.
No entendi la verdad como utilizarlos practicamente. No me gusto esta clase la verdad, deberia haber un botoncito de me gusta y NO me gusta.
EL método **\_\_ call \_\_ , tiene como única relevancia hacer la multificación??? se llama " call " como se puede llammar " Multiply " ???**
```js print("") print("* Ejercicio 1:") print("- Uso de __new__, __init__ y __call__ para crear una fábrica de multiplicadores.") print("") class MultiplerFactory: """ Fábrica de multiplicadores. Esta clase demuestra el uso de los métodos especiales __new__, __init__ y __call__ para crear una fábrica de objetos multiplicadores. Cada multiplicador se crea con un factor específico y se puede usar como una función para multiplicar un número por ese factor. """ def __new__(cls, factor: int): """ Método __new__ para personalizar la creación de instancias. __new__ se llama antes que __init__ y es responsable de crear la instancia de la clase. En este caso, se usa para imprimir un mensaje antes de crear la instancia. Args: cls: La clase MultiplerFactory. factor: El factor del multiplicador. Returns: Una nueva instancia de la clase MultiplerFactory. """ print(f"Creando instancia con factor {factor}") return super(MultiplerFactory, cls).__new__(cls) def __init__(self, factor: int): """ Método __init__ para inicializar la instancia. __init__ se llama después de __new__ y se usa para inicializar los atributos de la instancia. En este caso, se guarda el factor del multiplicador. Args: self: La instancia de la clase MultiplerFactory. factor: El factor del multiplicador. """ print(f"Inicializando con factor {factor}") self.factor = factor def __call__(self, number: int) -> int: """ Método __call__ para hacer que la instancia sea "callable". __call__ permite que una instancia de la clase se use como una función. En este caso, se usa para multiplicar un número por el factor del multiplicador. Args: self: La instancia de la clase MultiplerFactory. number: El número que se va a multiplicar. Returns: El resultado de multiplicar number por el factor del multiplicador. """ return number * self.factor # Crear una instancia de MultiplerFactory con factor 5 multipler = MultiplerFactory(5) # Usar la instancia como una función para multiplicar 10 por 5 result = multipler(10) # Imprimir el resultado print(result) # Salida: 50 ```print("")print("\* Ejercicio 1:")print("- Uso de \_\_new\_\_, \_\_init\_\_ y \_\_call\_\_ para crear una fábrica de multiplicadores.")print("") class MultiplerFactory:    """    Fábrica de multiplicadores.     Esta clase demuestra el uso de los métodos especiales \_\_new\_\_, \_\_init\_\_ y \_\_call\_\_    para crear una fábrica de objetos multiplicadores.  Cada multiplicador se crea con un    factor específico y se puede usar como una función para multiplicar un número por ese factor.    """     def \_\_new\_\_(cls, factor: int):        """        Método \_\_new\_\_ para personalizar la creación de instancias.         \_\_new\_\_ se llama antes que \_\_init\_\_ y es responsable de crear la instancia de la clase.        En este caso, se usa para imprimir un mensaje antes de crear la instancia.         Args:            cls: La clase MultiplerFactory.            factor: El factor del multiplicador.         Returns:            Una nueva instancia de la clase MultiplerFactory.        """        print(f"Creando instancia con factor {factor}")        return super(MultiplerFactory, cls).\_\_new\_\_(cls)     def \_\_init\_\_(self, factor: int):        """        Método \_\_init\_\_ para inicializar la instancia.         \_\_init\_\_ se llama después de \_\_new\_\_ y se usa para inicializar los atributos de la instancia.        En este caso, se guarda el factor del multiplicador.         Args:            self: La instancia de la clase MultiplerFactory.            factor: El factor del multiplicador.        """        print(f"Inicializando con factor {factor}")        self.factor = factor     def \_\_call\_\_(self, number: int) -> int:        """        Método \_\_call\_\_ para hacer que la instancia sea "callable".         \_\_call\_\_ permite que una instancia de la clase se use como una función.        En este caso, se usa para multiplicar un número por el factor del multiplicador.         Args:            self: La instancia de la clase MultiplerFactory.            number: El número que se va a multiplicar.         Returns:            El resultado de multiplicar number por el factor del multiplicador.        """        return number \* self.factor *# Crear una instancia de MultiplerFactory con factor 5*multipler = MultiplerFactory(5) *# Usar la instancia como una función para multiplicar 10 por 5*result = multipler(10) *# Imprimir el resultado*print(result)  *# Salida: 50*
# ¿Qué es una Metaclase? Una metaclase es una clase que actúa como **constructor de otras clases**, permitiendo **personalizar el proceso de creación de clases** mediante la modificación de los métodos \_\_new\_\_ e \_\_init\_\_, y la modificación de los atributos de la clase durante su creación. La metaclase predeterminada en Python es type, y se pueden crear metaclases personalizadas heredando de ella. En general, **es recomendable usar metaclases cuando se necesita modificar el proceso de creación de clases o aplicar cambios a toda una jerarquía de clases**. Es importante destacar que, aunque las metaclases son una herramienta poderosa, su uso se reserva para casos de metaprogramación avanzados, en los que se requiere un control detallado del proceso de creación de clases, la mayoría de las veces, no son necesarias y se pueden obtener los mismos resultados con una semántica más simple, como la herencia tradicional o los decoradores de clase. Si no estás seguro de si necesitas una metaclase, probablemente no la necesites. \*\*(esto lo saque de una interacción que tuve con los notebookLM de Google 🤓)
🫤La verdad no entendí esta clase, ahora me toca ir a otra parte a investigar sobre la meta programación en Python, creo que esta clase se debería volver a hacer o hacer una clase nueva que amplíe la información sobre este tema.
Si se me hizo muy entendible pero es poniendo atención en que el objeto creado se puede llamar como si fuera una función, ésto al haberlo definido con \_\_call**\_\_** que entiendo que al hacerlo, al usar ese objeto como función ejecutará la acción definida al crear la clase en el apartado def \_\_call\_\_
La explicación estuvo bastante "light" pero aquí les dejo un aporte. ### `__new__` Este método es un constructor a nivel de metaclase. Es llamado antes de que se cree una instancia de la clase. Se utiliza principalmente para controlar o personalizar cómo se crea el objeto en memoria. En el ejemplo:def \_\_new\_\_(cls, factor: int): print(f"Creando instancia con factor {factor}") return super(MultiplierFactory, cls).\_\_new\_\_(cls) ```js def __new__(cls, factor: int): print(f"Creando instancia con factor {factor}") return super(MultiplierFactory, cls).__new__(cls) ``` 1. **Función:** * Aquí, `__new__` imprime un mensaje cuando se está creando la instancia. * Luego llama a `super().__new__(cls)` para delegar la creación del objeto a la clase base. 2. **Propósito:** * Permite modificar el comportamiento antes de que el objeto exista (por ejemplo, crear un singleton o implementar un patrón de diseño especial). ### `__call__` Este método hace que una instancia de la clase sea "invocable", es decir, que pueda ser tratada como una función. En el ejemplo: pythonCopyEdit`def __call__(self, number: int) -> int`: ` return` number \* self.factor 1. **Función:** * Cuando `multiplier(10)` se llama, se invoca este método. * Toma `number` como argumento y retorna el producto de `number` y `self.factor`. 2. **Propósito:** * Hace que las instancias de la clase actúen como funciones, permitiendo una sintaxis más sencilla para ciertos usos.