Je travaille principalement avec Python et je révise le code presque quotidiennement. Dans notre base de code, le formatage et le peluchage sont gérés par les tâches CI utilisant black & mypy. Nous nous concentrons donc uniquement sur les changements.

Lorsque vous travaillez en équipe, vous savez déjà quel type de code attendre d'un certain membre de l'équipe. Les revues de code deviennent intéressantes lorsqu'une nouvelle personne rejoint l'équipe. Je dis intéressant, car tout le monde a un style de codage qu'il utilise inconsciemment ; pour le meilleur ou pour le pire ! Comme si j'en avais,

1. Définition de la valeur deOptionaltype. Habituellement, ces variables font partie de la signature

# 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. Gestion des instructions simples if..elif..else (jusqu'à 3-4) avec dict

Il s'agit d'un cas d'utilisation simple dans lequel vous renvoyez une chaîne ou appelez une fonction basée sur une valeur

Remarque : à partir de la version 3.10, vous devez utiliser match à la place de ceci.

Au lieu de faire,

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

Voici quelques exemples, les personnes qui examineront mon code auront plus d'exemples.

Récemment, un nouveau développeur a rejoint mon équipe et j'ai remarqué un modèle que j'ai adoré mais j'ai demandé à le changer en simple if..else case. Je vais d'abord vous montrer le modèle, puis vous donner la raison pour laquelle je demande un changement.

Le code est un décorateur qui fait quelque chose sur les paramètres. Écrivons un décorateur simple (inutile) qui affichera le nombre d'arguments et de kwargs avec lesquels la fonction/méthode a été appelée.

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)

Lors de l'exécution de ce code, vous devriez voir

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

Ça fonctionne bien mais pour les méthodes, ça compte aussi soi-même. alors réparons ça !

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

Il s'agit d'une simple clause if, mais le nouveau développeur a fait autre chose qui était une utilisation intéressante du booléen.

Je n'affiche que le code modifié...

   args_cnt = len(args[is_cls_method:])

La solution est bien meilleure que d'utiliser if, car bool en python est juste un int. Le code original était un peu plus long et remarquer ce petit changement n'est pas évident, également la base de code utilisée par les utilisateurs qui sont des utilisateurs de base de Python. Et, si vous devez deviner ce que fait une ligne, je pense que vous devriez changer pour que cela soit évident.

Qu'en pensez-vous ? Utilisez-vous un booléen comme index ?
Avez-vous d'autres modèles Python comme celui-ci ?