Trabajo principalmente con Python y reviso el código casi a diario. En nuestra base de código, el formato y el linting se manejan mediante trabajos de CI que utilizan black y mypy. Por eso, nos centramos sólo en los cambios.

Cuando trabajas en un equipo, ya sabes qué tipo de código esperar de un determinado miembro del equipo. Las revisiones de código se vuelven interesantes cuando una nueva persona se une al equipo. Digo interesante, ya que todos tienen algún estilo de codificación que lo usan inconscientemente; para bien o para mal! Como si tuviera algunos,

1. Estableciendo el valor de tipo opcional. Usualmente estas variables son parte de la firma

# I used (long back) to do

def func(a: int, b: Optional[list] = None, c: Optional[Dict] = None):

    if b is None:
       b = []
    if c is None:
       c = {}

# Instead I do

def func(a: int, b: Optional[list] = None, c: Optional[Dict] = None):

    b = b or []
    c = c or {}

1. Manejo de declaraciones simples if..elif..else (hasta 3-4) con dict

Este es un caso de uso simple en el que devuelves una cadena o llamas a una función en función de algún valor

Nota: a partir de 3.10 debes usar match en lugar de esto.

En lugar de hacer,

def get_number_of_wheels(vehicle: str):
    if vehicle == "car":
        wheels = 2
    elif vehicle == "bus":
        wheels = 6
    elif vehicle == "bicycle":
        wheels = 2
    else:
        raise ...

# I prefer doing, 

def get_number_of_wheels(vehicle: str):
    return {
       "car": 2,
       "bus": 6,
       "bicycle": 2
    }[vehicle]       # Raise is now KeyError

Arriba hay un par de ejemplos, las personas que revisen mi código tendrán más ejemplos.

Recientemente, un nuevo desarrollador se unió a mi equipo y noté un patrón que me encantó, pero pedí cambiarlo a simple si... en caso contrario. Primero les mostraré el patrón y luego les daré el motivo por el que solicito el cambio.

El código es un decorador que hace algo con los parámetros. Escribamos un decorador simple (inútil) que imprima el número de argumentos y kwargs con los que se llamó a la función/método.

def counter(is_cls_method: bool = False):
    """ print number of args & kwargs for func/method """
    def outer(f):
        def inner(*args, **kwargs):
            args_cnt = len(args)
            kwargs_cnt = len(kwargs)
            print(f"{f.__name__} called with {args_cnt=} & {kwargs_cnt=}")
            return f(*args, **kwargs)
        return inner
    return outer

@counter()
def test1(a, b, c):
    pass

class A:
    @counter(is_cls_method=True)
    def test1(self, a, b, c):
        pass


print("function")
test1(1, 2, c=3)
test1(a=1, b=2, c=3)

print("method")
a = A()
a.test1(1, 2, 3)
a.test1(1, b=2, c=3)

Al ejecutar este código, deberías ver

function
test1 called with args_cnt=2 & kwargs_cnt=1
test1 called with args_cnt=0 & kwargs_cnt=3

method
test1 called with args_cnt=4 & kwargs_cnt=0
test1 called with args_cnt=2 & kwargs_cnt=2

Está funcionando bien, pero en cuanto a los métodos, también se cuenta a sí mismo. ¡Así que solucionemos eso!

def counter(is_cls_method: bool = False):
    def outer(f):
        def inner(*args, **kwargs):
            args_cnt = len(args)

            if is_cls_method:   # Check added
               args_cnt -= 1    # Reduced count by 1

            kwargs_cnt = len(kwargs)
            print(f"{f.__name__} called with {args_cnt=} & {kwargs_cnt=}")
            return f(*args, **kwargs)
        return inner
    return outer

Esta es una cláusula if simple, pero el nuevo desarrollador hizo algo más que fue un uso interesante del booleano.

Estoy mostrando solo el código modificado...

   args_cnt = len(args[is_cls_method:])

La solución es mucho mejor que usar if, ya que bool en Python es simplemente int. El código original era un poco más largo y notar este pequeño cambio no es obvio, además la base del código es utilizada por usuarios que son usuarios básicos de Python. Y, si tienes que adivinar qué hace una línea, creo que deberías cambiarla para que sea obvia.

¿Qué piensas sobre esto? ¿Utilizas booleano como índice?
¿Tienes más patrones de Python como este?