Comment définir une fonction dans Python

Utilisez le didacticiel Python officiel sur la définition des fonctions comme votre référence: chaque fonction commence pardef, suivi d'un nom, parenthèses pour les paramètres, un côlon arrière et un bloc en retrait qui fonctionne lorsque la fonction est appelée.

Méthode 1 - Créez et appelez une fonction de base

Étape 1:Déclarer une fonction avecdefet un côlon.

def greet():
    print("Hello from a function!")

Étape 2:Appelez la fonction en utilisant son nom avec des parenthèses.

greet()

Cela établit le modèle minimal: définition d'abord, appelez après. Python s'exécute de haut en bas, donc une fonction doit être définie avant l'appel.

Méthode 2 - Ajouter des paramètres et des défauts

Étape 1:Ajoutez des paramètres à l'intérieur des parenthèses pour accepter les entrées.

def full_name(first, last):
    print(first + " " + last)

Étape 2:Appelez la fonction avec des arguments correspondants.

Lisez également:

full_name("Ada", "Lovelace")

Étape 3:Attribuer une valeur par défaut avec=pour faire un argument facultatif.

def hello(name="World"):
    print(f"Hello, {name}!")

hello()          # uses default
hello("Python")  # overrides default

Les défauts simplifient les appelants et gardez votre API stable lors de l'ajout d'un comportement facultatif. Voir les arguments par défaut dans le tutoriel officiel.

Méthode 3 - Valeurs de retour

Étape 1:UtiliserreturnPour renvoyer une valeur à l'appelant.

def area(w, h):
    return w * h

Étape 2:Capturez la valeur renvoyée dans une variable.

a = area(3, 4)
print(a)

Étape 3:Renvoyez plusieurs valeurs (elles sont emballées dans un tuple).

def point():
    return 10, 20

x, y = point()

Les détails de l'énoncé de retour sont couverts dans la référence du langage.

Méthode 4 - Acceptez un nombre variable d'arguments

Étape 1:Collecter des arguments de position supplémentaires avec*args.

def total(*args):
    return sum(args)

print(total(1, 2, 3))

Étape 2:Collectez les arguments de mots clés avec**kwargs.

def report(**kwargs):
    for k, v in kwargs.items():
        print(k, "=", v)

report(name="Keyboard", price=19.99)

Cette interface permet à votre fonction de flexion à diverses entrées. Voir «Listes d'arguments arbitraires» dans le tutoriel officiel.

Méthode 5 - Contrôlez comment les appelants passent les arguments

Étape 1:Faire des paramètres positionnels uniquement en ajoutant/après eux.

def echo(x, /):
    print(x)

echo(3)      # OK
# echo(x=3)  # TypeError

Étape 2:Faire des paramètres de mot-clé uniquement en ajoutant*devant eux.

def scale(value, *, factor=2):
    return value * factor

scale(10, factor=3)  # OK
# scale(10, 3)       # TypeError

Utilisez-les pour concevoir des API claires et sûres. Voir «Paramètres spéciaux» dans le tutoriel officiel.

Méthode 6 - documenter et organiser votre fonction

Étape 1:Ajoutez un docstring sur la première ligne du corps pour décrire l'objectif, les paramètres et la valeur de retour.

def hypotenuse(a, b):
    """Compute the length of the hypotenuse from legs a and b."""
    return (a**2 + b**2) ** 0.5

Étape 2:Garde les appels de script uniquement avecif __name__ == "__main__"Les importations ne les exécutent donc pas.

def main():
    print(hypotenuse(3, 4))

if __name__ == "__main__":
    main()

Les conventions docstring sont définies dans PEP 257, et le__main__Le motif est couvert dans les documents sur l'exécution des modules en tant que scripts.

Méthode 7 - Utilisez un lambda pour des uniques simples

Étape 1:Créer une petite fonction anonyme aveclambdapour les cas rapides et à expression unique.

double = lambda x: x * 2
print(double(5))

Étape 2:PréférerdefLorsque vous avez besoin de déclarations, un docstring ou une réutilisation.

def double_def(x):
    return x * 2

La syntaxe Lambda est spécifiée dans la référence du langage.

Méthode 8 - Placer les définitions où ils seront exécutés avant utilisation

Étape 1:Définissez les fonctions avant le premier appel dans le fichier pour éviter les erreurs de nom.

# Correct: defined before use
def hello():
    print("Hello")

hello()

Étape 2:Éviter d'appeler une fonction avant que sa définition ne soit exécutée; Python résout les noms à l'exécution, de haut en bas.

# This will raise NameError at runtime:
# hello()
# def hello():
#     print("Hello")

Étape 3:Définissez éventuellement les fonctions d'assistance dans une autre fonction pour garder la portée locale.

def outer():
    def inner():
        return "scoped helper"
    return inner()

Conseils rapides

Les «paramètres» sont les noms de l'en-tête de fonction; Les «arguments» sont les valeurs que vous passez dans l'appel.
Utiliserpasscomme un espace réservé lors de la décroche d'un corps de fonction.
Gardez les fonctions petites et concentrées; Cela simplifie les tests et la réutilisation.

Avecdef, paramètres réfléchis et renvoie clairs, vous écrirez des fonctions faciles à appeler, à tester et à étendre. Démarrer simple, puis ajouter les valeurs par défaut,*args/ /**kwargset les règles d'argument à mesure que votre API doit augmenter.