Fundamentos de Programación y Python

1

Fundamentos de Programación con Python para Principiantes

2

Instalación y Uso Básico de Python en Windows y Mac

3

Semántica y Sintaxis en Programación Python

4

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

5

Manejo de Cadenas y Operaciones Básicas en Python

6

Tipos de Datos en Python: Enteros, Flotantes y Booleanos

7

Dominio de la función `print` en Python: usos y formatos avanzados

8

Operaciones matemáticas avanzadas en Python: módulo, potencia y más

9

Entrada de información y manejo de tipos de datos en Python

Colección y Procesamiento de Datos en Python

10

Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos

11

Copiar listas en Python sin compartir memoria con slicing

12

Manejo de Matrices y Tuplas en Python

13

Matrices en Juegos y Imágenes con Python

14

Diccionarios en Python: Uso y Manipulación de Datos

Control de Flujo en Python

15

Estructuras Condicionales en Programación: Uso de If, Else y Elif

16

Iteración y control de flujo con bucles en Python

17

Iteradores y Generadores en Python: Uso Eficiente de Memoria

18

Listas por comprensión en Python: creación y optimización de listas

Funciones y Manejo de Excepciones en Python

19

Funciones y Parámetros en Python: Crea una Calculadora Básica

20

Funciones Lambda en Python: Uso y Aplicaciones Prácticas

21

Recursividad en Python: Factoriales y Serie de Fibonacci

22

Manejo de Excepciones y Errores en Python

Programación Orientada a Objetos en Python

23

Programación Orientada a Objetos en Python: Clases y Métodos Básicos

24

Gestión de Biblioteca con Programación Orientada a Objetos

25

Herencia y Polimorfismo en Programación Orientada a Objetos

26

Programación Orientada a Objetos: Implementación de Clases y Herencia

27

Polimorfismo en Programación Orientada a Objetos

28

Herencia y Uso de la Función super() en Python

29

Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python

Lectura y escritura de archivos

30

Manipulación de Archivos TXT y CSV en Python

31

Manipulación de archivos CSV con Python: lectura y escritura

32

Manejo de Archivos JSON en Python para Aplicaciones Web y APIs

Biblioteca estándar de Python

33

Uso Eficiente de la Biblioteca Estándar de Python

34

Uso de las librerías OS, Math y Random en Python

35

Análisis de Datos de Ventas con Python y Statistics

36

Desarrollo del juego Batalla Naval en Python

Conceptos avanzados de Python

37

Programación Avanzada en Python: POO, Excepciones y Proyectos

38

Escritura de Código Pytónico y Buenas Prácticas en Python

39

Comentarios y Docstrings: Buenas Prácticas en Programación

40

Tiempo de vida y alcance de variables en Python

41

Anotaciones de Tipo en Python para Código Más Legible

42

Validación de Tipos y Manejo de Excepciones en Python

43

Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones

Decoradores

44

Decoradores en Python: Extiende Funcionalidades de Funciones

45

Uso de Decoradores Anidados y con Parámetros en Python

46

Decoradores en Programación Orientada a Objetos en Python

Métodos y estructura de clases en Python

47

Uso de Métodos Mágicos en Python

48

Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases

49

Ejecutar scripts Python con `if __name__ == '__main__'`

50

Metaprogramación en Python: Métodos `__new__` y `__init__`

51

Uso de *args y **kwargs en funciones de Python

52

Métodos y Atributos Privados y Protegidos en Python

53

Uso de Property en Python: Getter, Setter y Eliminación de Atributos

54

Métodos estáticos y de clase en Python

Programación concurrente y asíncrona

55

Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas

56

Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`

57

Asincronismo en Python con AsyncIO y Corrutinas

58

Sincronía y Concurrencia en Python: Teoría y Práctica

Creación de módulos y paquetes

59

Módulos y Paquetes en Python: Reutilización y Organización de Código

60

Uso de Paquetes y Subpaquetes en Python con Visual Studio Code

61

Publicación de Paquetes Python en PyPI

Proyecto final

62

Sistema de Gestión de Reservas en Python Avanzado

63

Sistema de Gestión de Reservas en Python Avanzado

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

Comentarios y Docstrings: Buenas Prácticas en Programación

39/63
Recursos

¿Por qué es importante la claridad en los proyectos grandes?

Trabajar en proyectos grandes y complejos requiere no solo habilidades técnicas sino también la capacidad de comunicar eficazmente dentro del equipo. Mantener la claridad a través de documentación precisa, como comentarios y docstrings, es esencial. Estos no solamente facilitan la comprensión del código por parte de otros programadores, sino que también nos ayudan a recordar la lógica detrás de nuestras propias líneas de código en el futuro. Es crucial actualizar tanto el código como los comentarios si hacemos cambios, evitando así la confusión y el desorden.

¿Cómo se utilizan los docstrings y comentarios eficazmente?

Los docstrings y los comentarios son herramientas fundamentales en la programación para documentar y explicar el código, pero deben ser usados con precaución:

  • Docstrings: Se utilizan principalmente dentro de métodos o funciones. Consisten en ofrecer una descripción breve de lo que hace la función, sus parámetros de entrada y el tipo de dato que retorna. Por ejemplo, en una función que calcula el promedio de una lista de números, estructuraríamos un docstring de la siguiente manera:

    def calcular_promedio(numbers):
        """
        Calcula el promedio de una lista de números.
    
        Parameters:
        numbers (list): Lista de enteros o flotantes.
    
        Returns:
        float: El promedio de los números en la lista.
        """
        return sum(numbers) / len(numbers)
    
  • Comentarios: Los comentarios se utilizan para describir lo que hace una línea de código o para agregar notas explicativas. No debemos abusar de ellos ni explicar lo obvio. Son más útiles cuando describen la intención detrás de una línea de código más compleja o cuando se necesita un contexto adicional, pero siempre buscando ser breves y precisos.

    # Imprime el resultado de la función calcular_promedio
    print(calcular_promedio([1, 2, 3, 4, 5]))
    

¿Cuáles son las malas prácticas al escribir docstrings y comentarios?

Escribir documentación puede parecer una tarea sencilla, pero es fácil caer en malas prácticas que disminuyen la efectividad de tus comentarios:

  • Redundancia: No repitas lo que ya es evidente en el nombre de la función o la operación realizada. Si el nombre de la función ya indica que calcula el área de un triángulo, un comentario adicional que repita esta información es innecesario.

  • Sobreinformar: Incluir demasiada información puede llegar a confundir en lugar de aclarar. Recuerda, los comentarios deben añadir valor al código, no abarrotarlo de explicaciones obvias.

Consideremos la siguiente función innecesaria y su tratamiento:

def area_triangulo(base, altura):
    # Calculamos el área del triángulo
    return (base * altura) / 2

# Incorrecto - demasiada información irrelevante o redundante
"""
Función que calcula el área de un triángulo utilizando base y altura,
multiplicando base por altura y dividiendo el resultado entre dos.
Esto retorna un número flotante que es el área.
"""
# Correcto
"""
Calcula el área de un triángulo dado su base y altura.
"""

Consejo final: ¿Cómo puedes mejorar la mantenibilidad del código?

Para escribir un código más mantenible, es crucial usar eficientemente comentarios y docstrings. Evalúa constantemente si la información adicional está aportando valor sin reiterar lo evidente. Así, contribuyes a que el proyecto sea comprensible y fácil de actualizar, no solo para ti, sino para cualquier miembro del equipo, fomentando un desarrollo colaborativo y eficaz. Mantener un balance adecuado entre la cantidad y calidad de la documentación será un pilar fundamental en el éxito del proyecto.

¡Continúa motivado para mejorar tus habilidades documentales!

Aportes 15

Preguntas 1

Ordenar por:

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

Los comentarios y docstrings son super importantes ya sea para tu equipo o tu yo del futuro. Te ayudan a entender que hace la función y si necesita o no parametros. Algo que me gusta mucho del visual y los comentarios es que al invocar la función y pasar el mouse sobre esta, si dicha función tiene comentarios este te los va a mostrar en una pequeña ventana. ![](https://drive.google.com/file/d/1TK3guS7l0jopdd3vvzgEkSBVQuuLkg6L/view?usp=sharing)
esto debería estar en las primeras clases, como después de ver print o variables.
Los **docstrings** en Python son cadenas de texto utilizadas para documentar el propósito, uso y detalles de una función, clase o módulo. Se colocan al inicio de una función, clase o archivo, y permiten describir lo que hace el código, sus parámetros, valores de retorno y cualquier otro detalle relevante. Son esenciales para hacer el código más comprensible y facilitar su uso tanto para el desarrollador como para otros que lo puedan leer. ### **Propósitos de los Docstrings:** 1. **Documentación del código**: Los docstrings sirven para explicar qué hace una función o clase y cómo se debe usar, lo cual es útil tanto para el propio programador como para otros colaboradores en el proyecto. 2. **Generación automática de documentación**: Herramientas como **Sphinx** pueden utilizar los docstrings para generar documentación automática de tu código. 3. **Facilidad de uso**: Al usar la función `help()` en Python, puedes acceder a los docstrings y obtener información rápida sobre la función, clase o módulo. 4. **Estilo de codificación**: Los docstrings forman parte de las buenas prácticas de programación en Python (PEP 257) y ayudan a mantener el código limpio y bien estructurado. ### **Sintaxis de un Docstring:** El docstring se coloca inmediatamente después de la definición de la función, clase o módulo, y debe estar entre comillas triples (`"""` o `'''`). #### Ejemplo 1: **Función**: #### ```python def suma(a, b): """ Suma dos números. Parámetros: a (int o float): El primer número a sumar. b (int o float): El segundo número a sumar. Retorna: int o float: La suma de los dos números. """ return a + b ```Ejemplo 2: **Clase**: #### ```python class Persona: """ Representa una persona con nombre y edad. Parámetros: nombre (str): El nombre de la persona. edad (int): La edad de la persona. """ def __init__(self, nombre, edad): self.nombre = nombre self.edad = edad def saludar(self): """ Imprime un saludo con el nombre de la persona. """ print(f"Hola, mi nombre es {self.nombre}.") ```**Acceder al Docstring:** Puedes acceder a los docstrings en Python utilizando la función `help()` o simplemente imprimiéndolos con el atributo `__doc__`. ```python print(suma.__doc__) help(suma) ```**Beneficios**: * **Mejora la mantenibilidad**: Un código bien documentado es más fácil de entender y mantener. * **Facilita el trabajo en equipo**: Los docstrings permiten que otros desarrolladores comprendan rápidamente el propósito del código sin necesidad de leerlo completamente. * **Ayuda a la depuración**: En proyectos más grandes, el uso de docstrings facilita la identificación de errores y el entendimiento del flujo del código.
Comentarios y Docstrings en Python docstrings se hacen entre comillas triples ''' esto es un docstring, funciona como comentario tambien '''
Que bonito como se ven los *docstirngs* acá, en realidad debo confesar que hasta ahora yo solo utilizaba las triple comillas para comentar el código viejo que tenia y no perderlo mientras refactorizaba alguna parte de mi código 🙈🤦🏽.
```python import statistics numbers = [1,2,3,4,5] def promedio(numbers): """ Uso mean para hallar la media :param Una lista de numeros : :return El promedio en un numero entero: """ promedio = statistics.mean(numbers) print(f"Promedio es : {promedio}") print(promedio(numbers)) ```
Les comparto , la facilidad y lo útil que es y podría ser , utilizar Pycharm , el entorno de desarrollo de python , Te ayuda autocompletando algunas cosas y es mucho mas grafico para ayudarte a entender mejor ![](https://static.platzi.com/media/user_upload/upload-b7409382-9579-4f21-83b2-2e2d014d02cc.png)
Estoy totalmente de acuerdo. La importancia de poder promover comentarios y docstrings de manera eficiente para explicar el código es muy necesaria.
A mi me gusta hacer comentarios cortos, que diga lo que hace al grano sin escribir parrafos. Por ejemplo: ```python def calculate_average(numbers): #calcula el promedio de una lista de números return sum(numbers) / len(numbers) ```
![](https://drive.google.com/file/d/1TK3guS7l0jopdd3vvzgEkSBVQuuLkg6L/view?usp=sharing)Los comentarios y docstrings son super importantes ya sea para tu equipo o tu yo del futuro. Te ayudan a entender que hace la función y si necesita o no parametros. Algo que me gusta mucho del visual y los comentarios es que al invocar la función si dicha función tiene comentarios este te los va a mostrar en una pequeña ventana. ![](https://drive.google.com/file/d/1TK3guS7l0jopdd3vvzgEkSBVQuuLkg6L/view?usp=sharing) ![](file:///C:/Users/joshe/OneDrive/Im%C3%A1genes/Screenshots/Screenshot%202024-10-28%20181501.png)
La guía con recomendaciones para docstrings en Python es el PEP257 <https://peps.python.org/pep-0257/>
```js def calcular_promedio(numeros): """ Calcula el promedio de una lista de números Parámetros: numeros(list): Una lista de números enteros o flotantes Retorna: foat: El promedio de los números de la lista """ return sum(numeros)/len(numeros) numeros = [9, 1, 2, 0, 1.4, 4 ] promedio = calcular_promedio( numeros ) print(f"Array de números: { numeros }") print(f"El promedio es: { promedio }") ```
Los comentarios y docstrings son herramientas importantes en Python para mejorar la legibilidad y el mantenimiento del código. Aquí te explico cómo usarlos de manera efectiva. \### Comentarios Los comentarios se utilizan para explicar el código, hacer aclaraciones sobre ciertas decisiones de diseño o proporcionar contexto sobre la lógica. Deben ser claros y concisos. En Python, los comentarios comienzan con el símbolo `#`. \#### Ejemplo de Comentarios ```python \# Este es un comentario de una sola línea def calcular\_area\_circulo(radio): """Calcula el área de un círculo dado su radio.""" \# Usamos la constante pi de la librería math import math return math.pi \* (radio \*\* 2) # Devuelve el área ``` \### Docstrings Los docstrings son cadenas de documentación que se colocan al principio de funciones, métodos y clases para describir su propósito y cómo se deben usar. Se encierran entre triples comillas `"""` y pueden ocupar varias líneas. Esto permite que sean accesibles a través de la función `help()` en Python. \#### Ejemplo de Docstrings ```python def calcular\_area\_circulo(radio): """ Calcula el área de un círculo dado su radio. Parámetros: radio (float): El radio del círculo. Retorna: float: El área del círculo. """ import math return math.pi \* (radio \*\* 2) ``` \### Mejores Prácticas para Comentarios y Docstrings 1\. \*\*Sé claro y conciso\*\*: Los comentarios y docstrings deben ser fácilmente comprensibles y directos. Evita la jerga innecesaria. 2\. \*\*Usa el estilo de documentación estándar\*\*: Para docstrings, se recomienda seguir convenciones como \[PEP 257]\(https://www.python.org/dev/peps/pep-0257/) o \[Google Style Guide]\(https://google.github.io/styleguide/pyguide.html#383-docstrings). 3\. \*\*Actualiza los comentarios y docstrings\*\*: Si realizas cambios en el código, asegúrate de actualizar los comentarios y docstrings para reflejar esos cambios. 4\. \*\*Evita comentarios redundantes\*\*: No escribas comentarios que repitan lo que el código ya dice. Por ejemplo, no es necesario comentar que una línea de código suma dos números si la línea ya es explícita. \### Ejemplo Completo con Comentarios y Docstrings Aquí tienes un ejemplo más completo que incorpora tanto comentarios como docstrings: ```python import math class Circulo: """ Clase que representa un círculo. Atributos: radio (float): El radio del círculo. """ def \_\_init\_\_(self, radio): """ Inicializa un círculo con el radio dado. Parámetros: radio (float): El radio del círculo. """ self.radio = radio def area(self): """ Calcula el área del círculo. Retorna: float: El área del círculo. """ return math.pi \* (self.radio \*\* 2) # Área = π \* r² def \_\_str\_\_(self): """Devuelve una representación en cadena del círculo.""" return f"Círculo de radio {self.radio}" \# Ejemplo de uso if \_\_name\_\_ == "\_\_main\_\_": circulo = Circulo(5) # Crear un círculo con un radio de 5 print(circulo) # Imprime la representación del círculo print(f"Área: {circulo.area():.2f}") # Imprime el área del círculo ``` En este ejemplo, se utilizan comentarios para aclarar partes del código y se proporcionan docstrings que describen la funcionalidad de la clase y sus métodos. Esto ayuda a otros desarrolladores (y a ti mismo en el futuro) a comprender rápidamente el propósito y el funcionamiento del código.
Muy importante los docstrings! Se ve en todo documento grande, especialmente al inicio de cada función
Básicamente para que el codigó sea accequible a un grupo de programadores, los comentarios son un refresco que desemtrama las cosas que hace determinado código.