Python es un lenguaje versátil y potente, y dominar sus funciones avanzadas puede mejorar significativamente la eficiencia y legibilidad de la codificación. A continuación se ofrecen algunos consejos avanzados de Python que le ayudarán a escribir un código mejor, más limpio y más eficiente.

Escribí 2 libros pequeños para leer el fin de semana que cubren Python, aquí están los enlaces: (1) https://leanpub.com/learnpython_inweekend_pt1 & (2) https://leanpub.com/learnpython_inweekend_pt2

1. Utilice listas por comprensión para obtener código conciso

Las listas por comprensión ofrecen una forma concisa de crear listas. A menudo pueden reemplazar los bucles for tradicionales y las declaraciones condicionales, lo que da como resultado un código más limpio y legible.

# Traditional approach
numbers = [1, 2, 3, 4, 5]
squared_numbers = []
for num in numbers:
    squared_numbers.append(num ** 2)

# Using list comprehension
squared_numbers = [num ** 2 for num in numbers]

2. Aproveche las expresiones del generador para mejorar la eficiencia de la memoria

Las expresiones del generador le permiten crear iteradores de manera concisa sin almacenar la secuencia completa en la memoria, lo que los hace más eficientes en cuanto a memoria.

# List comprehension (creates a list)
squared_numbers = [num ** 2 for num in numbers]

# Generator expression (creates an iterator)
squared_numbers = (num ** 2 for num in numbers)

3. Utilice enumerate() para el seguimiento del índice.

Cuando se itera sobre un iterable y se necesita rastrear el índice de cada elemento, la función enumerate() es invaluable.

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")

4. Simplifique la concatenación de cadenas con join()

Usar el método join() para concatenar cadenas es más eficiente que usar el operador, especialmente para cadenas grandes.

fruits = ['apple', 'banana', 'cherry']
fruit_string = ', '.join(fruits)
print(fruit_string)  # Output: apple, banana, cherry

5. Utilice __slots__ para reducir el uso de memoria

De forma predeterminada, Python almacena atributos de instancia en un diccionario, lo que puede consumir una cantidad significativa de memoria. El uso de __slots__ puede reducir el uso de memoria al asignar memoria para un conjunto fijo de variables de instancia.

class Point:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

6. Emplee contextlib.suppress para ignorar excepciones

El administrador de contexto contextlib.suppress le permite ignorar excepciones específicas, simplificando su código al evitar bloques try-except innecesarios.

from contextlib import suppress

with suppress(FileNotFoundError):
    with open('file.txt', 'r') as file:
        contents = file.read()

7. Utilice el módulo itertools

El módulo itertools ofrece una colección de funciones eficientes para trabajar con iteradores. Funciones como producto, permutaciones y combinaciones pueden simplificar operaciones complejas.

import itertools

# Calculate all products of an input
print(list(itertools.product('abc', repeat=2)))

# Calculate all permutations
print(list(itertools.permutations('abc')))

8. Utilice functools.lru_cache para el almacenamiento en caché

El decorador functools.lru_cache puede almacenar en caché los resultados de costosas llamadas a funciones, lo que mejora el rendimiento.

from functools import lru_cache

@lru_cache(maxsize=32)
def fibonacci(n):
    if n 




  
  
  9. Maestros decoradores para un código más limpio


Los decoradores son una herramienta poderosa para modificar el comportamiento de funciones o clases. Se pueden utilizar para iniciar sesión, controlar el acceso y más.



def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()





  
  
  10. Utilice el truco de lo contrario


La construcción for-else en Python le permite ejecutar un bloque else después de que un bucle for se completa normalmente (es decir, sin encontrar una declaración break). Esto puede resultar especialmente útil en operaciones de búsqueda.



for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(f"{n} equals {x} * {n//x}")
            break
    else:
        # Loop fell through without finding a factor
        print(f"{n} is a prime number")








  
  
  Conclusión


Al incorporar estos consejos avanzados de Python en su flujo de trabajo de desarrollo, puede escribir código más eficiente, legible y mantenible.

Ya sea que esté optimizando el uso de la memoria con __slots__, simplificando las operaciones de cadenas con join() o aprovechando el poder del módulo itertools, estas técnicas pueden mejorar significativamente sus habilidades de programación en Python.

Sigue explorando y practicando estos conceptos para mantenerte a la vanguardia en tu viaje a Python.