Fonctions Python : comment appeler et écrire des fonctions

Arguments par défaut

Les arguments par défaut prennent une valeur prédéfinie si aucune valeur n’est fournie lors de l’appel de la fonction. Vous assignez cette valeur par défaut avec l’opérateur =, comme dans l’exemple suivant :

Arguments requis

Comme leur nom l’indique, les arguments requis d’une UDF sont indispensables. Ils doivent être fournis lors de l’appel de la fonction et dans l’ordre exact, comme dans l’exemple suivant :

Vous devez fournir des arguments correspondant aux paramètres a et b pour appeler la fonction sans erreur. Si vous inversez a et b, le résultat ne changera pas, mais ce serait différent si vous modifiez plus() comme suit :

Arguments nommés (keyword)

Si vous souhaitez vous assurer d’appeler les paramètres dans le bon ordre, utilisez des arguments nommés lors de l’appel. Vous identifiez alors les arguments par le nom de leur paramètre. Reprenons l’exemple ci‑dessus pour clarifier :

Notez qu’avec des arguments nommés, vous pouvez aussi inverser l’ordre des paramètres tout en obtenant le même résultat à l’exécution :

Nombre variable d’arguments

Lorsque vous ne connaissez pas à l’avance le nombre exact d’arguments à passer à une fonction, vous pouvez utiliser la syntaxe avec *args :

L’astérisque (*) est placé avant le nom de variable qui contiendra toutes les valeurs des arguments non nommés. Remarquez que vous auriez tout aussi bien pu passer *varint, *var_int_args ou n’importe quel autre nom à la fonction plus().

Astuce : essayez de remplacer *args par un autre nom, en conservant l’astérisque. Vous verrez que le code ci‑dessus fonctionne toujours !

Vous constatez que cette fonction s’appuie sur la fonction native Python sum() pour additionner tous les arguments passés à plus().

Variables globales vs. locales

En général, les variables définies à l’intérieur du corps d’une fonction ont une portée locale, et celles définies à l’extérieur ont une portée globale. Autrement dit, les variables locales sont définies dans un bloc de fonction et ne sont accessibles qu’à l’intérieur de celle‑ci, tandis que les variables globales sont accessibles par toutes les fonctions de votre script :

Vous verrez apparaître un NameError indiquant que name 'total' is not defined lorsque vous essayez d’afficher la variable locale total définie dans le corps de la fonction. La variable init, en revanche, s’affiche sans problème.

Paramètres uniquement positionnels et uniquement nommés

Depuis Python 3.8, vous pouvez mieux contrôler la façon dont les arguments doivent être passés en utilisant deux marqueurs spéciaux dans la signature : / et *. Tout ce qui précède le / ne peut être passé que positionnellement ; tout ce qui suit le * ne peut être passé que par mot‑clé (keyword).

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

 Voici ce que cela implique à l’appel :

greet("Alice")                          # ok
greet("Alice", greeting="Hi")           # ok
greet("Alice", "Hi", punctuation="?")   # ok

greet(name="Alice")                     # TypeError : name est uniquement positionnel
greet("Alice", "Hi", "?")               # TypeError : punctuation est uniquement nommé

Pourquoi vouloir cela ? Deux raisons principales.

D’abord, les paramètres uniquement positionnels vous permettent de les renommer plus tard sans casser le code de quiconque — puisque personne n’est autorisé à utiliser le nom du paramètre comme mot‑clé, vous êtes libre de le changer.

Ensuite, les paramètres uniquement nommés obligent les appelants à être explicites sur ce qu’ils passent, ce qui rend les appels plus lisibles lorsqu’il y a plusieurs options ou indicateurs facultatifs.

En bref, c’est un moyen propre d’imposer l’intention.

Les fonctions anonymes en Python

Les fonctions anonymes sont aussi appelées fonctions lambda en Python, car au lieu d’être déclarées avec le mot‑clé standard def, on utilise le mot‑clé lambda.

Dans le bloc DataCamp Light ci‑dessus, lambda x: x*2 est la fonction anonyme (ou lambda). x est l’argument, et x*2 est l’expression/instruction évaluée et renvoyée. Particularité : cette fonction n’a pas de nom, contrairement aux exemples vus dans la première partie de ce tutoriel. Si vous deviez écrire cette fonction en UDF, vous obtiendriez :

def double(x):
  return x*2

Voyons un autre exemple de fonction lambda avec deux arguments :

On utilise des fonctions anonymes lorsqu’une fonction sans nom est nécessaire pour une courte durée et créée à l’exécution. C’est notamment utile avec filter(), map() et reduce() :

La fonction filter() filtre, comme son nom l’indique, la liste d’entrée my_list selon un critère >10. Avec map(), vous appliquez une fonction à tous les éléments de my_list. Ici, vous multipliez chaque élément par 2.

Notez que la fonction reduce() fait partie de la bibliothèque functools. Vous l’appliquez cumulativement aux éléments de my_list, de gauche à droite, pour réduire la séquence à une valeur unique, 55 dans cet exemple.

Utiliser main() comme fonction en Python

Si vous avez déjà pratiqué d’autres langages comme Java, vous savez que la fonction main est requise pour exécuter le programme. Comme vous l’avez vu ci‑dessus, ce n’est pas nécessaire en Python. En revanche, inclure une fonction main() peut être utile pour structurer votre code de manière logique : les composants les plus importants sont regroupés dans main().

Vous pouvez facilement définir une fonction main() et l’appeler comme toutes les autres fonctions ci‑dessus :

Cependant, en l’état, le code de votre fonction main() sera exécuté si vous importez ce fichier comme module. Pour éviter cela, on appelle main() lorsque __name__ == '__main__'.

Autrement dit, le code ci‑dessus devient :

Remarque : en plus de __main__, il existe une fonction __init__ qui initialise une instance de classe (un objet). En bref, c’est un constructeur/initialiseur, automatiquement appelé lors de la création d’une nouvelle instance. Avec cette fonction, l’objet nouvellement créé est assigné au paramètre self, comme vous l’avez vu plus haut. Voici un exemple :

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())