Spécifications : Fonctions I

Objectifs :

À la fin de cette séquence vous serez capable de :

• Écrire vos propres fonctions
• Appréhender les notions de variables globales et variables locales

Un mini-projet : Morpion

Le jeu « Morpion », plus connu sous le nom de Tic Tac Toe en anglais, est un jeu de stratégie simple joué entre deux joueurs. Voici les règles du jeu :

1. Plateau : Le jeu se joue sur une grille de 3×3 cases.
2. Joueurs : Il y a deux joueurs. Un joueur utilise les « X » et l'autre les « O ».
3. Objectif : Le but du jeu est d'aligner trois de ses symboles (X ou O) horizontalement, verticalement ou en diagonale.
4. Déroulement : Les joueurs jouent à tour de rôle en plaçant leur symbole dans une case vide. Le jeu continue jusqu'à ce que l'un des joueurs aligne trois de ses symboles ou que la grille soit complète sans qu'il y ait d'alignement. Dans ce cas, la partie se termine par un match nul.

1. Définition

En programmation, une fonction est un bloc de code nommé, autonome qui exécute une tâche spécifique ou un groupe de tâches associées dans le but de calculer une valeur ou un résultat final, qui est ensuite renvoyé au code de l'appelant.
La valeur qu'une fonction renvoie à l'appelant est appelée valeur de retour de la fonction.

L'importance d'une fonction réside dans le fait qu'elle est réutilisable. Elle évite la duplication (la répétition) de code. Plutôt que de répéter le même code dans un programme, on le centralise sous la forme d'une fonction que l'on appelle depuis tous les endroits où l'on en a besoin.

Pour finir, une fonction permet de décomposer une « grosse » tâche complexe en de sous-tâches plus simples et plus petites (on les appelle modules), chacune des fonctions se concentrant sur une tâche spécifique.
En conséquence, les fonctions améliorent la qualité, la lisibilité et la maintenance d’un programme.

2. Fonctions prédéfinies dans Python

On les appelle aussi fonctions natives ou built-in en anglais.
Exemples :

• range(),
• abs(),
• lower(),
• type(),
• len()

len('Connais-toi toi-même')

abs(-5.3)

type(["one", 2.5, False])

3. Fonctions définies par l'utilisateur en langage python

3.1. Syntaxe

La définition d’une fonction se compose :

• du mot clé def suivi du nom de la fonction, de parenthèses entourant l’(les) éventuel(s) paramètre(s) de la fonction séparé(s) par des virgules, et du caractère « deux points » (:) qui termine toujours une instruction composée ;
• du bloc d’instructions indenté (décalé) par rapport à la ligne de définition, et qui constitue le corps de la fonction ;
• du mot clé return.

# Syntaxe
def nom_de_la_fonction(éventuels paramètres):
    ............................
    Le corps de la fonction
    ............................
    return valeur_de_retour

Exemples :

from random import randint
#fonction sans paramètre
def loto():
    nbre_aleatoire = randint(0, 10)
    return nbre_aleatoire

#fonction avec un paramètre
def carre(x): # x est le paramètre de la fonction carre
    y = x**2
    return y

Le nombre de paramètres d’une fonction est variable (0, 1, 2...).

3.2. Passage d'arguments

Lorsque l'on fait appel à une fonction, les paramètres sont appelés arguments.

3.2.1 Paramètres et arguments positionnels

Chaque paramètre de la définition de la fonction correspond, dans l’ordre, à un argument de l’appel. La correspondance se fait par affectation des arguments aux paramètres.

def volume(longueur, largeur, hauteur):
    vol = longueur * largeur* hauteur
    return vol

volume(4, 3, 2)

Lorsque la fonction volume est appelée, les arguments passés 2, 3 et 4 sont liés aux paramètres dans l'ordre de leur apparition :
longueur = 4
largeur = 3
hauteur = 2

def difference(nbre1, nbre2):
    dif = nbre1 - nbre2
    return dif

difference(5, 3)

Lorsque la fonction difference est appelée, les arguments passés 5 et 3 sont liés aux paramètres dans l'ordre de leur apparition :
nbre1 = 5
nbre2 = 3

difference(3, 5)

Lorsque la fonction difference est appelée, les arguments passés 3 et 5 sont liés aux paramètres dans l'ordre de leur apparition :
nbre1 = 3
nbre2 = 5

Lors de l'appel d'une fonction, il faut toujours faire attention à l'ordre des arguments fournis !

3.2.2. Paramètres et arguments de mots clés

Cette façon d'appeler une fonction permet d'éviter le problème précédent. Elle est, par ailleurs, plus explicite.

difference(nbre1=5, nbre2=3)

difference(nbre2=3, nbre1=5)

3.2.3. Paramètres par défaut

def puissance(nombre, exposant=1):
    resultat = nombre ** exposant
    return resultat

puissance(3)
# L'unique argument fourni est affecté à nombre, par déafut exposant=1

puissance(3, 2)

puissance(4, 3)

3.2.2. Retour multiple

Le résultat est contenu dans un objet de type tuple.

def aire_perimetre_rectangle(longueur, largeur):
    aire = longueur * largeur
    perimetre = 2 * (longueur + largeur)
    return (perimetre, aire)

Remarque 1 :
Il est fortement conseillé d’adjoindre à la définition d’une fonction une docstring.
Une docstring est une chaîne de caractères au début d'une fonction qui spécifie (décrit) la fonction.
doc est l'abréviation de documentation.
Cette documentation peut contenir l'objectif de la fonction, la nature des paramètres, des informations sur les valeurs de retour ou toute autre information jugée utile.
Les docstrings sont également utilisées par les outils de programmation pour fournir une aide au débogage (on dit aussi débbugage) c'est-à-dire une aide à la recherche et la correction des erreurs d’un programme.

def volume(longueur, largeur, hauteur):
    """
        Données : longueur, largeur et hauteur sont des nombres positifs.
        Résultat : La fonction renvoie un nombre, le volume d'un parallélépipède.
    """
    vol = longueur * largeur * hauteur
    return vol

volume(4, 3, 2)

volume(4, 5, 6)

help(volume)

def difference(nbre1, nbre2):
    """
        Input : nbre1 et nbre2 sont des nombres.
        Output : La fonction renvoie un nombre qui est la différence entre nbre1 et nbre2.
    """
    dif = nbre1 - nbre2
    return dif

help(difference)

4. Espace de nommage : variables locales et variables globales

Un espace de noms est une région d'un programme dans laquelle les identifiants ont une signification. C'est une table de correspondance entre des noms et des objets.
Lorsqu'une fonction est appelée, un nouvel espace de noms est créé pour cette fonction, distinct de tous les autres espaces de noms qui existent déjà. On dit que cet espace de noms est local à la fonction et reste en place jusqu'à ce que la fonction se termine. Cela signifie que les variables locales ne sont accessibles qu'à l'intérieur de la fonction dans laquelle elles sont déclarées.
L'espace de nom du programme principal (le programme appelant, on dit aussi client) est dit global et ses variables sont dites globales.

# Variable globale
x = 10

def ma_fonction():
    # Variable locale
    y = 5
    print(f"Dans la fonction {x = }.")  # Accès à la variable globale
    print(f"Dans la fonction {y = }.")  # Accès à la variable locale

# Appel de la fonction
ma_fonction()

# Accès à la variable globale en dehors de la fonction
print(f"En dehors de la fonction {x = }.")

# Tentons d'accéder à la variable locale y en dehors de la fonction
# Cela provoquerait une erreur car y n'existe que dans l'espace de noms de la fonction
print(f"En dehors de la fonction {y = }.")  # Cette ligne provoque une erreur

4. Encapsulation :

Les variables locales à une fonction « ne sont pas accessibles en dehors de la fonction ». En d'autres termes, une fonction permet de cacher un morceau de code. On dit que l'on l'encapsule.
Le programme appelant (le client de la fonction) communique avec la fonction seulement au travers de ses paramètres et les valeurs de retour. Une fonction est aussi appelée une API (Application Programming Interface pour Interface de Programmation d'Applications) permettant à des blocs de codes de cummuniquer entre eux.

Remarque :
une fonction sans le mot clé Return est appelée une procédure. Contrairement aux fonctions, les procédures ne traitent pas des données.

Faites-vous plaisir 1 :
On définit ci-dessous une fonction.

def prix_total(prix_unitaire, quantite, taxe):
    """
        Paramètres : prix_unitaire et quantite sont des nombres,
                     taxe est un nombre décimal.
        Sortie : Elle renvoie un nombre, le prix TTC d'un produit.
    """
    total = prix_unitaire * quantite * (1 + taxe)
    return total

1. Quel est le nom de cette fonction ?
2. Quels sont ses paramètres ?
3. À quoi sert cette fonction ?
4. Appeler cette fonction si l'on veut le prix de l'achat de 15 écharpes dont le prix unitaire est de 25 € et la TVA est de 20 %.

Faites-vous plaisir 2 :

1. Écrire une fonction celsius_vers_fahrenheit qui prend en paramètre une température en degrés celsius, celsius, et qui renvoie l'équivalent en Fahrenheit.
   La formule de conversion est : F = C * 9/5 + 32.
   On accompagnera la fonction d'une documentation qui précise la nature de l'entrée et la nature de la sortie.
2. Tester ce programme avec -15 °C et 100°C.

Faites-vous plaisir 3 :

1. Écrire une fonction, maximum_de_3_nbres, qui prend en paramètres trois nombres et qui renvoie le plus grand de ces trois nombres.
   On accompagnera la fonction d'une documentation qui précise la nature des paramètres et la nature du résultat attendu.
2. Tester ce programme avec les nombres suivants : 5, -7 et 8.

Faites-vous plaisir 4 :

1. Écrire une fonction qui prend en entrée un entier positif et qui renvoie True si l'entier est pair, False sinon.
   Adjoindre à la fonction une docstring qui précise la nature du paramètre et la nature du résultat attendu.
2. Tester cette fonction avec les nombres 12 et 13.

Faites-vous plaisir 5 :

1. À l'aide de l'algorithme du parcours séquentiel, écrire une fonction, recherche, qui prend en paramètres un mot, mot, et une lettre, val, et qui renvoie True si val est présent dans mot, False sinon.
   Adjoindre à la fonction une docstring qui précise la nature des paramètres et la nature du résultat attendu.
2. Tester cette fonction avec le mot mississipi et s puis avec mississipi et a.

Faites-vous plaisir 6 :

1. À l'aide de l'algorithme du parcours séquentiel, écrire une fonction qui prend en entrée un entier positif et qui renvoie, dans une liste, tous les diviseurs de cet entier.
   Adjoindre à la fonction une docstring qui précise la nature du paramètre et la nature du résultat attendu.
2. Tester cette fonction avec l'entier 5 puis l'entier 6.

Faites-vous plaisir 7 :

1. À l'aide de l'algorithme du parcours séquentiel, écrire une fonction qui prend en input une liste de nombres et qui renvoie la somme des nombres de cette liste.
   Adjoindre à la fonction une docstring qui précise la nature du paramètre et la nature du résultat attendu.
2. L'appel de cette fonction avec la liste [1, 2, 3] renvoie 6 ; avec [-5, 4, -6], elle renvoie -7.

Faites-vous plaisir 8 :

1. À l'aide de l'algorithme du parcours séquentiel, écrire une fonction, cpteur_carac qui prend en entrées une phrase, phrase, et un caractère, carac et qui renvoie le nombre d'occurrences (apparitions) de carac dans phrase.
   Adjoindre à la fonction une docstring qui précise la nature du paramètre et la nature du résultat attendu.
2. L'appel de cette fonction avec comme arguments La Beauté de la Nature réside dans sa Simplicité et sa Diversité et s renvoie 5.