Y a-t-il une raison de ne pas toujours utiliser des arguments sous forme de mots-clés ?

Question

Avant de me lancer dans Python, j'avais commencé par lire quelques livres sur Objective-C / Cocoa. Si je me souviens bien, la plupart des fonctions exigeaient que les arguments des mots-clés soient explicitement indiqués. Jusqu'à récemment, j'ai oublié tout cela, et j'ai simplement utilisé des arguments positionnels en Python. Mais dernièrement, j'ai rencontré quelques bugs dus à des positions incorrectes - des petites choses sournoises.

Cela m'a fait réfléchir - de manière générale, à moins qu'il n'y ait une circonstance qui exige spécifiquement des arguments autres que des mots-clés - y a-t-il une bonne raison de ne pas utiliser des arguments de mots-clés ? Est-il considéré comme un mauvais style de toujours les utiliser, même pour des fonctions simples ?

J'ai l'impression que, comme la plupart de mes programmes de 50 lignes passent régulièrement à 500 lignes ou plus, si je m'habitue à toujours utiliser des arguments sous forme de mots-clés, le code sera plus facile à lire et à maintenir au fur et à mesure de sa croissance. Y a-t-il une raison pour que ce ne soit pas le cas ?

UPDATE :

L'impression générale que j'ai est qu'il s'agit d'une préférence de style, avec de nombreux arguments valables pour dire qu'ils ne devraient généralement pas être utilisés pour des arguments très simples, mais qu'ils sont par ailleurs conformes à un bon style. Avant d'accepter, je veux juste clarifier les choses - y a-t-il des problèmes spécifiques non stylistiques qui découlent de cette méthode - par exemple, des pertes de performance significatives ?

Answer 1

Il n'y a aucune raison de ne pas utiliser les arguments des mots-clés, si ce n'est pour la clarté et la lisibilité du code. Le choix d'utiliser ou non des mots-clés devrait être basé sur le fait que le mot-clé ajoute ou non des informations supplémentaires utiles à la lecture du code.

Je suis la règle générale suivante :

1. S'il est difficile de déduire la fonction (nom) de l'argument à partir du nom de la fonction - passez-le par mot clé (par exemple, je ne voudrais pas avoir text.splitlines(True) dans mon code).
2. S'il est difficile de déduire l'ordre des arguments, par exemple si vous avez trop d'arguments, ou si vous avez des arguments optionnels indépendants - passez-le par mot-clé (ex. funkyplot(x, y, None, None, None, None, None, None, 'red') n'a pas l'air particulièrement agréable).
3. Ne jamais passer les premiers arguments par mot-clé si le but de l'argument est évident. Vous voyez, sin(2*pi) est meilleur que sin(value=2*pi) il en va de même pour plot(x, y, z) .

Dans la plupart des cas, les arguments obligatoires stables seront positionnels, et les arguments facultatifs seront des mots-clés.

Il y a également une différence possible en termes de performances, car dans chaque implémentation, les arguments par mot-clé seraient légèrement plus lents, mais étant donné qu'il s'agirait généralement d'une optimisation prématurée et que les résultats ne seraient pas significatifs, je ne pense pas que cela soit crucial pour la décision.

MISE À JOUR : préoccupations non stylistiques

Les arguments de type mot-clé peuvent faire tout ce que les arguments de type positionnel peuvent faire, et si vous définissez une nouvelle API, il n'y a pas d'inconvénients techniques à part d'éventuels problèmes de performance. Cependant, vous risquez d'avoir de petits problèmes si vous combinez votre code avec des éléments existants.

Considérez ce qui suit :

• Si vous faites en sorte que votre fonction prenne des arguments de type mot-clé, cela devient une partie de votre interface. Vous ne pouvez pas remplacer votre fonction par une autre qui a une signature similaire mais un mot-clé différent pour le même argument.
• Vous pourriez vouloir utiliser un décorateur ou un autre utilitaire sur votre fonction qui suppose que votre fonction prend un argument positionnel. Les méthodes non liées sont un exemple d'un tel utilitaire car elles passent toujours le premier argument comme positionnel après l'avoir lu comme positionnel, donc cls.method(self=cls_instance) ne fonctionne pas même s'il y a un argument self dans la définition.

Aucun de ces éléments ne constitue un réel problème si vous concevez bien votre API et si vous documentez l'utilisation des arguments des mots-clés, en particulier si vous ne concevez pas quelque chose qui doit être interchangeable avec quelque chose qui existe déjà.

Answer 2

Si votre objectif est d'améliorer la lisibilité des appels de fonctions, pourquoi ne pas simplement déclarer les fonctions comme d'habitude, par ex.

def test(x, y):
    print "x:", x
    print "y:", y

Et appelez simplement les fonctions en déclarant les noms explicitement, comme ceci :

test(y=4, x=1)

Ce qui vous donne évidemment la sortie :

x: 1
y: 4

ou cet exercice serait inutile.

Cela évite que les arguments soient optionnels et qu'ils aient besoin de valeurs par défaut (à moins que vous ne le souhaitiez, auquel cas il suffit d'utiliser les arguments par mot-clé ! ) et vous donne toute la polyvalence et la lisibilité améliorée des arguments nommés qui ne sont pas limités par l'ordre.

Answer 3

Eh bien, il y a quelques raisons pour lesquelles je ne le ferais pas.

Si tous vos arguments sont des arguments de type mot-clé, cela augmente le bruit dans le code et peut enlever toute clarté sur les arguments requis et ceux qui sont optionnels.

Aussi, si je dois utiliser votre code, je pourrais avoir envie de vous tuer ! !! (Je plaisante), mais devoir taper le nom de tous les paramètres à chaque fois... pas très amusant.

Answer 4

Pour proposer un autre argument, je pense qu'il existe des cas où les paramètres nommés peuvent améliorer la lisibilité. Par exemple, imaginez une fonction qui crée un utilisateur dans votre système :

create_user("George", "Martin", "g.m@example.com", "payments@example.com", "1", "Radius Circle")

À partir de cette définition, on ne sait pas du tout ce que ces valeurs peuvent signifier, même si elles sont toutes requises, alors qu'avec des paramètres nommés, c'est toujours évident :

create_user(
    first_name="George",
    last_name="Martin",
    contact_email="g.m@example.com",
    billing_email="payments@example.com",
    street_number="1",
    street_name="Radius Circle")

Answer 5

Je me souviens avoir lu une très bonne explication des "options" dans les programmes UNIX : "Les options sont censées être facultatives, un programme devrait pouvoir fonctionner sans aucune option".

Le même principe pourrait être appliqué à mot-clé en Python. Ce type d'arguments doit permettre à l'utilisateur de "personnaliser" l'appel de la fonction, mais une fonction doit pouvoir être appelée sans aucune paire d'arguments implicites de type mot-clé-valeur.