Une erreur très courante est d'utiliser print là où il faudrait utiliser return. Je vais essayer ici d'éclaircir les choses.

On considère un programme très simple dont le but est de déterminer les coordonnées du milieu d'un segment. L'utilisateur est invité à fournir les coordonnées des 2 extrémités du segment. Le programme affiche les coordonnées du milieu.

Voici comment on ferait ce travail avec un script simple.

print("Extrémité 1")
x1 = int(input("abscisse : "))
y1 = int(input("ordonnée : "))
print("Extrémité 2")
x2 = int(input("abscisse : "))
y2 = int(input("ordonnée : "))
x_milieu = (x1 + x2)/2
y_milieu = (y1 + y2)/2
print("Milieu : (",x_milieu,";",y_milieu,")")

Ce programme est tout à fait valable. C'est le genre de chose que l'on vous invite à faire en cours de maths. En maths on vous propose un problème et vous devez réaliser un script visant à résoudre ce problème. Le script est souvent à usage unique, il ne fait qu'un calcul. On n'a pas besoin de trop détailler.

Dans ce programme il n'y a aucune fonction, donc on a aucune raison d'utiliser le mot-clé return.

En NSI, l'approche est un peu différente : même si on envisage des programmes simples, on veut pouvoir envisager des programmes plus complexes qui nécessitent plus de structuration.

Dans notre exemple, le problème se structure en 3 parties :

1. acquisition des coordonnées des extrémités,
2. calcul des coordonnées du milieu,
3. affichage des coordonnées obtenues.

Dans notre souhait de structurer le programme, on crée une fonction pour le calcul de coordonnées. Appelons cette fonction milieu.

Voici ce que beaucoup d'élèves ont tendance à faire quand on leur demande de créer la fonction milieu.

def milieu():
    print("Extrémité 1")
    x1 = int(input("abscisse : "))
    y1 = int(input("ordonnée : "))
    print("Extrémité 2")
    x2 = int(input("abscisse : "))
    y2 = int(input("ordonnée : "))
    x_milieu = (x1 + x2)/2
    y_milieu = (y1 + y2)/2
    print("Milieu : (",x_milieu,";",y_milieu,")")

On le voit, dans cet exemple, il n'y a aucune structuration. Acquisition, calcul et affichage sont tous dans la même fonction.

On améliore un peu en sortant l'acquisition de la fonction.

def milieu(x1,y1,x2,y2):
    x_milieu = (x1 + x2)/2
    y_milieu = (y1 + y2)/2
    print("Milieu : (",x_milieu,";",y_milieu,")")

print("Extrémité 1")
x1 = int(input("abscisse : "))
y1 = int(input("ordonnée : "))
print("Extrémité 2")
x2 = int(input("abscisse : "))
y2 = int(input("ordonnée : "))
milieu(x1, y1, x2, y2)

Mais cela ne va toujours pas : La fonction milieu se termine par un print. La fonction mélange calcul et affichage.

# définition fonction(s) utile(s)
def milieu(x1,y1,x2,y2):
    x_milieu = (x1 + x2)/2
    y_milieu = (y1 + y2)/2
    return x_milieu, y_milieu

# acquisition
print("Extrémité 1")
x1 = int(input("abscisse : "))
y1 = int(input("ordonnée : "))
print("Extrémité 2")
x2 = int(input("abscisse : "))
y2 = int(input("ordonnée : "))

# calcul
x_m, y_m = milieu(x1, y1, x2, y2)

# affichage
print(f"Milieu : ({x_m} ; {x_m})")

Dans l'idée d'un programme plus gros – évidemment, cet exemple est très simple et ne nécessite pas toute ces améliorations mais il faut comprendre ces principes pour envisager des projets de plus grande taille – on trouverait avantage à

1. documenter la fonction,
2. placer la fonction dans un script annexe

# fichier mesfonctions.py

def milieu(x1,y1,x2,y2):
    """
    x1,y1: coordonnées de l'extrémité 1 d'un segment
    x2,y2: coordonnées de l'extrémité 2 d'un segment
    renvoie x_milieu, y_milieu, coordonnées du milieu du segment
    """
    x_milieu = (x1 + x2)/2
    y_milieu = (y1 + y2)/2
    return x_milieu, y_milieu
    
# ce fichier pourrait contenir bien d'autres fonctions

# fichier main.py, fichier principal du projet en cours
# ce fichier utilise la fonction milieu définie dans l'autre fichier

from mesfonctions import milieu

# acquisition
print("Extrémité 1")
x1 = int(input("abscisse : "))
y1 = int(input("ordonnée : "))
print("Extrémité 2")
x2 = int(input("abscisse : "))
y2 = int(input("ordonnée : "))

# calcul
x_m, y_m = milieu(x1, y1, x2, y2)

# affichage
print("Milieu : (",x_m,";",x_m,")")

Dans ce dernier exemple, le programme principal a été réduit au maximum. Il ne contient plus que les deux interfaces homme / machine : acquisition et affichage. Les détails du calcul sont déplacés dans la fonction qui est définie ailleurs.

Dans le cadre de gros projets, il est indispensable de bien structurer le code et de le découper finement – j'ai déjà dit pourquoi dans Intérêts des fonctions. Calculer et Afficher sont deux choses différentes.

• La fonction qui calcule se contente de renvoyer son résultat : return
• Pour afficher, on peut, dans les cas simples, utiliser print. Si on a décidé de dédier une fonction à l'affichage, le print pourra se trouver dans cette fonction. Mais on aura clairement déterminé au préalable que cette fonction est une fonction d'affichage et qu'elle ne fait rien d'autre.