Langage Python

Fonctions et procedures en Python

Lorsqu’une tâche doit être réalisée plusieurs fois par un programme avec seulement des paramètres différents, on peut l’isoler au sein d’une fonction. Cette approche est également intéressante si la personne qui définit la fonction est différente de celle qui l’utilise. Par exemple, nous avons déjà utilisé la fonction print() qui avait été définie par quelqu’un d’autre.
Nous avons déjà rencontré diverses fonctions prédéfinies : print(),input(), range(), len().

Définition d’une fonction

La syntaxe Python pour la définition d’une fonction est la suivante :

    def nom_fonction(liste de paramètres):
        bloc d'instructions

Vous pouvez choisir n’importe quel nom pour la fonction que vous créez, à l’exception des mots-clés réservés du langage, et à la condition de n’utiliser aucun caractère spécial ou accentué (le caractère souligné « _ » est permis). Comme c’est le cas pour les noms de variables, on utilise par convention des minuscules, notamment au début du nom (les noms commençant par une majuscule seront réservés aux classes).

Exemple :

Cette fonction permet d'effacer tous les éléments de la liste. Après cette opération, la liste devient vide.

            def compteur3():
                i = 0
                while i < 3:
                    print(i)
                    i = i + 1
            
            #tester la fonction
            print("bonjour")
            compteur3()
            compteur3()
        

En entrant ces quelques lignes, nous avons défini une fonction très simple qui compte jusqu’à 2.
Notez bien les parenthèses, les deux-points, et l’indentation du bloc d’instructions qui suit la ligne d’en-tête (c’est ce bloc d’instructions qui constitue le corps de la fonction proprement dite).
Après la définition de la fonction, on trouve le programme principal qui débute par l’instruction print("bonjour"). Il y a ensuite au sein du programme principal, l’appel de la fonction grâce à compteur3(). Nous pouvons maintenant réutiliser cette fonction à plusieurs reprises, autant de fois que nous le souhaitons.
Nous pouvons également l’incorporer dans la définition d’une autre fonction.

            def compteur3():
                i = 0
                while i < 3:
                    print(i)
                    i = i + 1

            def double_compteur3():
                compteur3()
                compteur3()
                print("bonjour")
                double_compteur3()
        

Une première fonction peut donc appeler une deuxième fonction, qui elle-même en appelle une troisième, etc. Créer une nouvelle fonction offre l’opportunité de donner un nom à tout un ensemble d’instructions. De cette manière, on peut simplifier le corps principal d’un programme, en dissimulant un algorithme secondaire complexe sous une commande unique, à laquelle on peut donner un nom explicite.
Une fonction est donc en quelque sorte une nouvelle instruction personnalisée, qu’il est possible d’ajouter librement à notre langage de programmation.

Passage des paramètres 

Une chose importante à noter est qu'en Python chaque nom de variable est une référence. Lorsque nous passons une variable à une fonction, une nouvelle référence à l'objet est créée.

Notez bien que :

  • Le nom d’une variable que nous passons comme argument n’a rien à voir avec le nom du paramètre correspondant dans la fonction.
  • Ces noms peuvent être identiques si vous le voulez, mais vous devez bien comprendre qu’ils ne désignent pas la même chose (en dépit du fait qu’ils puissent contenir une valeur identique).
    def TEST(tab):
        tab[0]=12
    
    T=[2, 4, 7, 3]
    TEST(T)
    print(T)
    # -> [12, 4, 7, 3]

Lorsque nous transmettons une référence et que nous modifions la référence reçue en un autre élément, la connexion entre les paramètres transmis et reçus est rompue.

        def TEST(tab):
            tab=[1,3,5]
        
        T=[2, 4, 7, 3]
        TEST(T)
        print(T)
        # -> [2, 4, 7, 3]
        def Changer(a):
            a=4
        
        x=7
        Changer(x)
        print(x)
        # -> 7

Valeurs par défaut pour les paramètres 

Dans la définition d’une fonction, il est possible de définir un argument par défaut pour chacun des paramètres.
On obtient ainsi une fonction qui peut être appelée avec une partie seulement des arguments attendus.

    def somme(a,b=3):
        print(a+b)
    
    somme(5)
    # -> 8

    somme(4,7):
    # -> 11

Arguments avec étiquettes 

Dans la plupart des langages de programmation, les arguments que l’on fournit lors de l’appel d’une fonction doivent être fournis exactement dans le même ordre que celui des paramètres qui leur correspondent dans la définition de la fonction.
Python autorise cependant une souplesse beaucoup plus grande. L'idée est de permettre à l'appelant de spécifier un nom d'argument avec des valeurs afin que l'appelant n'ait pas besoin de se souvenir de l'ordre des paramètres.

        def find(x,tab):
            if x in tab:
                return True
            return False
        T=[2, 5, 7, 10, 40]
        a=7
        print(find(a,T))
        # -> True

        print(find(tab=T,x=a))
        # -> True

Arguments de longueur variable 

Nous pouvons avoir un nombre de paramétres variable sous forme d'une liste

            def find(*args):
                for var in args:
                    print(var)
                
                if args[1] in args[0]:
                    return True

                return False
            T=[2, 5, 7, 10, 40]
            a=7

            print(find(T,a))
            # [2, 5, 7, 10, 40]
            # 7
            # True

sous forme d'un dictionnaire

        def find(**args):
            for var in key, value in kwargs.items():
                print("%s == %s" %(key, value))

            if args['x'] in args['tab']:
                return True

            return False
        T=[2, 5, 7, 10, 40]
        a=7

        find(tab=T,x=a)
        # x=7
        # tab=[2, 5, 7, 10, 40]
        # True

Fonctions anonymes 

En Python, fonction anonyme signifie qu'une fonction est sans nom. Comme nous le savons déjà, le mot clé def est utilisé pour définir les fonctions normales et le mot clé lambda pour créer des fonctions anonymes.

    somme = lambda a,b: a+b  
    print(somme(7,2))
    # 9 

Partager ce cours avec tes amis :
Rédigé par Mostafa Sedoki
Professeur d'Informatique dans les CPGE

Cours Similaires :