Définir et appeler des fonctions

Donner un nom à un bloc de code

Une fonction est un bloc de code nommé que l'on peut exécuter encore et encore. On la définit une fois avec def, un nom, des parenthèses et deux-points ; le bloc indenté dessous est le corps. return renvoie une valeur à celui qui a appelé la fonction. L'appeler, c'est écrire son nom avec des parenthèses et les valeurs à traiter.

def gross_value(price, quantity):
    return price * quantity

print(gross_value(184.25, 200))  # 36850.0

Paramètres et arguments

Les noms entre parenthèses dans def sont les paramètres : des emplacements pour les entrées. Les valeurs passées à l'appel sont les arguments et remplissent les paramètres dans l'ordre. Si vous les échangez, le résultat change. Passer le mauvais nombre d'arguments est une erreur. Chaque appel reçoit sa propre copie des paramètres.

# Arguments fill the parameters in order
def spread(bid, ask):
    return ask - bid

print(spread(184.25, 184.5))  # 0.25
print(spread(184.5, 184.25))  # -0.25

return n'est pas print

print affiche quelque chose à l'écran pour un humain. return remet une valeur au code appelant pour qu'il puisse continuer à la manipuler. Une fonction sans return renvoie None, c'est-à-dire « rien ». Les fonctions qui calculent doivent renvoyer ; c'est le code appelant qui décide d'afficher ou non.

# A function with no return gives back None
def show(price):
    print("price", price)

result = show(184.25)   # price 184.25
print(result)           # None

De petites fonctions qui s'appuient les unes sur les autres

Une fonction peut en appeler d'autres : on construit ainsi un comportement complexe à partir de petites pièces testables. Donnez à chaque fonction une seule tâche et un nom qui la dit. La docstring, une chaîne juste sous def, l'explique au prochain lecteur. Définissez une fonction avant que s'exécute la ligne qui l'appelle.

# Small functions build bigger ones
def gross_value(price, quantity):
    """Value of a position before costs."""
    return price * quantity


def commission(gross):
    """0.1% of the value, but never less than 1.0."""
    return max(1.0, gross * 0.001)


def net_cost(price, quantity):
    """What the position really costs: value plus commission."""
    gross = gross_value(price, quantity)
    return gross + commission(gross)


print(net_cost(184.25, 200))  # 36886.85

Renvoyer plusieurs valeurs

return a, b renvoie les deux valeurs d'un coup, sous forme de tuple : une paire ordonnée écrite avec des virgules (les tuples auront bientôt leur propre sujet). L'appelant peut nommer les morceaux tout de suite. Découper un ordre de 1 000 actions en 3 tranches avec // et % renvoie la taille de chaque tranche et le reste.

# return several values as a tuple
def split_fill(quantity, slices):
    return quantity // slices, quantity % slices

size, leftover = split_fill(1000, 3)
print(size, leftover)  # 333 1

• Une tâche par fonction, et un nom qui dit ce qu'elle renvoie.
• Calculer et return ; laisser l'appelant afficher.
• Ajouter une docstring qui dit ce qui entre et ce qui sort.

À suivre : les arguments et valeurs par défaut des fonctions, pour appeler des fonctions avec des noms, des valeurs facultatives et un nombre quelconque d'arguments.

Lab : ce qui est noté

• Définir une fonction qui valorise une position avec gross_value25 pts
• Prélever une commission avec un minimum grâce à commission25 pts
• Construire le coût réel à partir de deux fonctions avec net_cost25 pts
• Renvoyer deux valeurs à la fois avec split_fill25 pts