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

Escribir código Pythonico y profesional

38/63
Recursos

Aportes 17

Preguntas 1

Ordenar por:

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

q guapa Carli
Escribir código Pythonico y profesional implica seguir ciertas convenciones y mejores prácticas que mejoran la legibilidad, mantenibilidad y eficiencia del código. Aquí hay algunas pautas y ejemplos: \### 1. \*\*Nombres Significativos\*\* Usa nombres claros y descriptivos para variables, funciones y clases. ```python def calculate\_area(radius): """Calcula el área de un círculo dado su radio.""" import math return math.pi \* radius \*\* 2 ``` \### 2. \*\*Funciones y Métodos Breves\*\* Las funciones deben realizar una única tarea y ser lo más cortas posible. ```python def is\_even(number): """Devuelve True si el número es par, de lo contrario False.""" return number % 2 == 0 ``` \### 3. \*\*Uso de Docstrings\*\* Documenta tus funciones y clases usando docstrings para describir su propósito y uso. ```python class Circle: """Clase que representa un círculo.""" def \_\_init\_\_(self, radius): """Inicializa el círculo con un radio.""" self.radius = radius def area(self): """Calcula el área del círculo.""" import math return math.pi \* (self.radius \*\* 2) ``` \### 4. \*\*Listas por Comprensión\*\* Usa listas por comprensión para crear listas de manera más clara y eficiente. ```python squares = \[x\*\*2 for x in range(10)] ``` \### 5. \*\*Manejo de Errores\*\* Usa excepciones para manejar errores de forma limpia. ```python def divide(a, b): """Divide dos números, manejando división por cero.""" try: return a / b except ZeroDivisionError: return "No se puede dividir entre cero." ``` \### 6. \*\*Uso de `with` para Recursos\*\* Utiliza el manejo de contexto `with` para asegurarte de que los recursos se liberan adecuadamente. ```python with open('archivo.txt', 'r') as file: contenido = file.read() ``` \### 7. \*\*Organización del Código\*\* Organiza tu código en módulos y paquetes. Mantén una estructura lógica y usa un archivo `\_\_init\_\_.py` si es necesario. \### 8. \*\*Formato de Código\*\* Usa herramientas como `black` o `flake8` para formatear tu código y mantener la consistencia. \### Ejemplo Completo Aquí tienes un ejemplo completo que sigue las buenas prácticas: ```python import math class Circle: """Clase que representa un círculo.""" def \_\_init\_\_(self, radius): """Inicializa el círculo con un radio.""" self.radius = radius def area(self): """Calcula el área del círculo.""" return math.pi \* (self.radius \*\* 2) def main(): """Función principal del script.""" radius = float(input("Introduce el radio del círculo: ")) circle = Circle(radius) print(f"El área del círculo es: {circle.area():.2f}") if \_\_name\_\_ == "\_\_main\_\_": main() ``` Este ejemplo muestra cómo estructurar el código de manera clara, usar docstrings, y manejar la entrada del usuario de forma segura y eficiente.
Veo muy bien esta clase, son cosas que parecieran obvias, pero luego uno se encuentra con cada cosa tan horrorosa que te preguntas que pensaba la persona que escribio ese codigo jajajaja. Yo aplico muchas de estas buenas practicas de las que mencionas sin importar el lenguaje de programacion
Escribir código Pythonico y profesional Sirve principalmente para hacer código lo más comprensible con el objetivo de que colaboradores puedan modificarlo sin problemas
```js class BankAccount: def __init__(self, account_holder, balance): self.account_holder = account_holder self.balance = balance self.is_active = True ```class BankAccount:    def \_\_init\_\_(self, account\_holder, balance):        *self*.account\_holder = account\_holder        *self*.balance = balance        *self*.is\_active = True
```python import random #Crear rango de datos aleatorios random_h = random.randint(1,10) print(random_h) #Elección aleatorio de colores colors = ['Rojo', 'Azul', 'Verde'] random_color = random.choice(colors) print(random_color) #Barajar una lista de cartas cards = ['As', 'Rey', 'Reina', 'Jota', '10'] random.shuffle(cards) print(cards) ```import random#Crear rango de datos aleatoriosrandom\_h = random.randint(1,10)print(random\_h)#Elección aleatorio de colorescolors = \['Rojo', 'Azul', 'Verde']random\_color = random.choice(colors)print(random\_color) \#Barajar una lista de cartascards = \['As', 'Rey', 'Reina', 'Jota', '10']random.shuffle(cards)print(cards)
```python class Calcular: def suma(self, nums:list[int|float]) -> int | float: return sum(nums) calc = Calcular() print(calc.suma([2, 4])) ```
Además de estas recomendaciones, es importante los principios **solid**: te ayudan con la forma correcta de estructurar las clases. Y ya implementar principios de diseño para mejorar esto.
```js class Calculadora: def sumar_numeros(self, primer_numero, segundo_numero): resultado = primer_numero + segundo_numero return resultado calculadora = Calculadora() print(f"Sumando: 5 + 3: { calculadora.sumar_numeros(5, 3)}") ```class Calculadora:    def sumar\_numeros(self, primer\_numero, segundo\_numero):        resultado = primer\_numero + segundo\_numero        return resultado    calculadora = Calculadora() print(f"Sumando: 5 + 3: { calculadora.sumar\_numeros(5, 3)}")
```python class Calculator: def __init__(self, num1, num2): self.num1 = num1 self.num2 = num2 def sum(self): return self.num1 + self.num2 def rest(self): if self.num1 >= self.num2: return self.num1 - self.num2 else: print("{} is bigger than {} so the operation can't be completed".format(num1, num2)) def multiplication(self): return self.num1 * self.num2 def division(self): return self.num1 / self.num2 value1 = int(input("Please input the first integer to start the operation you want to perform")) message = " Message divider " print("\n" + message.center(79, "#") + "\n") value2 = int(input("Please input the second integer to start the operation you want to perform")) check = Calculator(value1, value2) check.multiplication() ```class Calculator: def \_\_init\_\_(self, num1, num2): self.num1 = num1 self.num2 = num2 def sum(self): return self.num1 + self.num2 def rest(self): if self.num1 >= self.num2: return self.num1 - self.num2 else: print("{} is bigger than {} so the operation can't be completed".format(num1, num2)) def multiplication(self): return self.num1 \* self.num2 def division(self): return self.num1 / self.num2
```python # Crear un iterador para los números impares # Límite LIMIT = 10 # Crear iterador odd_iter = iter(range(1, LIMIT + 1, 2)) # Usar el iterador for num in odd_iter: print(num) ```Se realizaron varios cambios para alinear el código con las recomendaciones de PEP 8. Se usaron constantes en mayúsculas, como `LIMIT`, para seguir las convenciones; se corrigió el nombre de la variable de `odd_itter` a `odd_iter` para evitar errores tipográficos; se ajustó el espaciado en los comentarios para mayor claridad; y se modificó el rango a `range(1, LIMIT + 1, 2)` para generar números impares, asegurando así que el código sea claro, funcional y conforme a las mejores prácticas.
Hola Carli
```js import random class Calculator: def add_numbers(self, first_number, second_number): result = first_number + second_number return result calc = Calculator() first_number = random.randint(1,99) second_number = random.randint(0,9) print(calc.add_numbers(first_number, second_number)) ```
*# Función es\_primo: Verifica si un número es primo usando un método eficiente: # solo verifica hasta la raíz cuadrada del número, lo que mejora la eficiencia.* def es\_primo(n):    """Comprueba si un número es primo."""    if n < 2:        return False    for i in range(2, int(n\*\*0.5) + 1):        if n % i == 0:            return False    return True*# Función primos\_en\_rango: Genera una lista de números primos en el rango especificado.*def primos\_en\_rango(inicio, fin):    """Devuelve una lista de números primos en un rango dado."""    return \[n for n in range(inicio, fin + 1) if es\_primo(n)]    """    n\*\*0.5: Esto calcula la raíz cuadrada de     n. En Python, el operador \*\* se utiliza para la exponenciación. Entonces, n\*\*0.5 es igual a Raiz cuadrada.    """*# Ejemplo de uso*inicio, fin = 10, 50primos = primos\_en\_rango(inicio, fin)print(f"Números primos entre {inicio} y {fin}: {primos}")
!Genial, vamos con todo Carli Code!
Esto tiene muy buena pinta!!! Vamos a darle duro 😁
```python a = 2894 b = 3674 print("Suma:", a + b) # Transformando el código, de acuerdo a PEP8 class Calculator: def __init__(self, a, b): self.a = a self.b = b def sumar(self): return self.a + self.b calculator = Calculator(2894, 3674) print("El valor de la suma es:", calculator.sumar()) ```