.

Les fonctions

.

DEFINITION :

La programmation est l’art d’apprendre à un ordinateur comment accomplir des tâches qu’il n’était pas capable de réaliser
auparavant. L’une des méthodes les plus intéressantes pour y arriver consiste à ajouter de nouvelles instructions au langage de programmation que vous utilisez, sous la forme de fonctions originales.

Définir une fonction

Les scripts que vous avez écrits jusqu’à présent étaient à chaque fois très courts, car leur objectif était seulement de vous faire assimiler les premiers éléments du langage.

Lorsque vous commencerez à développer de véritables projets, vous serez confrontés à des problèmes souvent forts complexes, et les lignes de programme vont commencer à s’accumuler…

L’approche efficace d’un problème complexe consiste souvent à le décomposer en plusieurs sous-problèmes plus simples qui seront étudiés séparément (ces sous-problèmes peuvent éventuellement être eux-mêmes décomposés à leur tour, et ainsi de suite).

D’autre part, il arrivera souvent qu’une même séquence d’instructions doive être utilisée à plusieurs reprises dans un programme.

Les fonctions

permettent d’éviter de réécrire plusieurs fois les mêmes lignes de code et donc d’avoir un programme plus compact et plus lisible.

Les fonctions et les classes d’objets sont différentes structures de sous-programmes qui ont été imaginées par les concepteurs des langages de haut niveau afin de résoudre les difficultés évoquées ci-dessus.

Nous allons commencer par décrire ici la définition de fonctions sous Python.

Nous avons déjà rencontré diverses fonctions préprogrammées. Voyons à présent comment définir nous-mêmes de nouvelles fonctions originales.

FONCTIONS ET PROCEDURES :

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

 def nom_de_la_fonction(paramètres) :

{indentation} Bloc d’instructions**
  • Vous pouvez choisir n’importe quel nom pour la fonction que vous créez, à l’exception des mots 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, il vous est conseillé d’utiliser surtout des lettres minuscules, notamment au début du nom (les noms commençant par une majuscule seront réservés aux classes.
  • Comme les instructions if et while que vous connaissez déjà, l’instruction def est une instruction composée. La ligne contenant cette instruction se termine obligatoirement par un double point, lequel introduit un bloc d’instructions que vous ne devez pas oublier d’indenter.
  • La liste de paramètres spécifie quelles informations il faudra fournir en guise d’arguments lorsque l’on voudra utiliser cette fonction (les parenthèses peuvent parfaitement rester vides si la fonction ne nécessite pas d’arguments).
  • Une fonction s’utilise pratiquement comme une instruction quelconque. Dans le corps d’un programme, un appel de fonction est constitué du nom de la fonction suivi de parenthèses. Si c’est nécessaire, on place dans ces parenthèses le ou les arguments que l’on souhaite transmettre à la fonction. Il faudra en principe fournir un argument pour chacun des paramètres spécifiés dans la définition de la fonction, encore qu’il soit possible de définir pour ces paramètres des valeurs par défaut.

Exemple 0501 :

.

programme Résultat

# 0501 fonction_multiplication.py

# définir une fonction

def table(base):

      n=1

      while n<10:

            print(n,'x',base,'= ',n*base, ' ;')

            n=n+1

#programme principal

base=int(input("Entrer  un nombre entier :"))

table(base) # appel de la fonction

Entrer  un nombre entier :5

1 x 5 =  5  ;

2 x 5 =  10  ;

3 x 5 =  15  ;

4 x 5 =  20  ;

5 x 5 =  25  ;

6 x 5 =  30  ;

7 x 5 =  35  ;

8 x 5 =  40  ;

9 x 5 =  45  ;

VRAIES FONCTIONS :

Pour les puristes, les fonctions que nous avons décrites jusqu’à présent ne sont pas tout à fait des fonctions au sens strict, mais plus exactement des procédures.

Une « vraie » fonction (au sens strict) doit en effet renvoyer une valeur lorsqu’elle se termine.

Une « vraie » fonction peut s’utiliser à la droite du signe égale dans des expressions telles que :

\(\ y\ = \ \sin(\mathbf{a})\).

On comprend aisément que dans cette expression, la fonction \(\mathbf{\sin}\mathbf{()}\) renvoie une valeur (le sinus de l’argument \(\mathbf{a}\mathbf{\ }\)qui est directement affectée à la variable \(y\).

Commençons par des exemples simples :

.

Exemple 0502 : x est un nombre réel non nul et n un entier naturel. Exemple 0503 : x est un nombre réel non nul et n un entier relatif.

#0502 fonction qui calcule x^n

def exposant(x,n):

      p=1

      if n>0:

            for i in range(n):

                  p=x*p

      return p

resultat=exposant(2,10)

print('2^0= ',resultat)

#503 fonction qui calcule x^n

#n entier relatif

def exposant(x,n):

      p=1

      for i in range(n):

            p=x*p

      return p

def puissance(x,n):

      if n>=0:p=exposant(x,n)

      if n<0:p=1/exposant(x,-n)

      return p

resultat=puissance(2,-3)

print('2^(-3)= ',resultat)

resultat=puissance(-2,3)

print('(-2)^3= ',resultat)

2^0=  1024

2^(-3)=  0.125

(-2)^3=  -8

L’instruction return définit ce que doit être la valeur renvoyée par la fonction. En l’occurrence, il s’agit du cube de l’argument qui a été transmis lors de l’appel de la fonction.

LES TABLEAUX :

Dans le langage python il faut importer des modules qui contiennent le type array (tableau).

Nous allons procéder sans importer de module, on va utiliser les listes pour créer des tableaux, cela permettra de pouvoir stocker toutes sorte de données dans les tableaux.

Les tableaux servent à stocker des données dans un programme, ils ont l’avantage d’être modifiables et de changer de dimensions selon les besoins du programme.

Nous allons définir des fonctions qui vont créer des tableaux, qui vont remplir des tableaux à partir de listes de données. Ainsi que faire du tri croissant et décroissant.

Création d’un tableau :

On va créer des tableaux à l’aide d’une fonction qui va prendre en paramètres le nombre de lignes et le nombre de colonnes.

Module tableau:

Ce fichier peut être importé par un autre programme comme un module.

.

tableau.py

#tableau_liste.py

#module de fonctions ,construction

#remplissage, affichage, tri

#de tableaux et de listes

#

from random import *

from tkinter import *

from math import *

 

def Tableau(ligne,colonne):

            "fabrication d'un tableau lignes colonnes"

            #fabrication du tableau

           

            tableau=ligne*[0]

            for ln in range(ligne):tableau[ln]=colonne*[0]

            return tableau                          

def remplir(liste,ligne,colonne):

      #remplissage du tableau par une liste

      tableau=Tableau(ligne,colonne)

      for ln in range(0,ligne):

            for cn in range(0,colonne):

                  tableau[ln][cn]=liste[colonne*ln+cn]

      return tableau

     

def melange(liste):

      " remplissage aléatoire d'une liste de  nombres entiers"

      numimage=len(liste)

      for i in range(numimage):liste[i]=2

      k=0

      while k<numimage:

            remelange=False

            numero=randrange(100,numimage+100)

            for j in range(0,numimage):

                  if numero==liste[j] :remelange=True

            if remelange==False:

                  liste[k]=numero

                  k=k+1

      return liste

                 

def listetableau(tableau,ligne,colonne):

      "fabrication d'une liste  avec un tableau lignes colonnes"

      #remplissage d'une liste

      liste=[]

      for ln in range(0,ligne):

            for cn in range(0,colonne):

                  liste.append(tableau[ln][cn])

      return liste                            

 

def fabrique_liste(taille,nombre):

      #construit une liste de taille

      #contenant le même nombre

      liste=[]

      for i in range(taille):liste.append(nombre)

      return liste

     

 

def cherche(tableau,ligne,colonne,nombre):

            "recherche l'emplacement du nombre dans le tableau"

            #nombre=8 pacman ; nombre = 12 snake

            for ln in range(0,ligne):

                  for cn in range(0,colonne):

                        if tableau[ln][cn]==nombre:

                              x,y=cn,ln

            # retourne la colonne x et la ligne y

            return x,y

           

def creer_liste20(xc,yc,x,y):

      #liste comportant les coordonnées 20 elements

      #La fonction integre x et y au rang zero

      # et décale tout les termes de la suite au rang supérieur

      x1,y1=x,y

      for i in range(20):

            xt,yt=xc[i],yc[i]

            xc[i],yc[i]=x1,y1

            x1,y1=xt,yt

      return xc,yc

 

def liste_croissante(liste):

      #tri d'une liste

      # en sortie la liste est triée de façon croissante

      liste.sort()

      return liste

def liste_decroissante(liste):    

      #tri d'une liste

      # en sortie la liste est triée de façon décroissante

      liste.reverse()

      return liste

     

def tableau_croissant(tableau,ligne,colonne):

      #tri d'un tableau

      #en sortie les valeurs du tableau

      #sont triées de façon croissante

      liste=listetableau(tableau,ligne,colonne)

      liste.sort()

      tableau=remplir(liste,ligne,colonne)

      return tableau

     

def tableau_decroissant(tableau,ligne,colonne) :

      #tri d'un tableau

      #en sortie les valeurs du tableau

      #sont triées de façon décroissante

      liste=listetableau(tableau,ligne,colonne)

      liste=liste_decroissante(liste)

      tableau=remplir(liste,ligne,colonne)

      return tableau

     

def affiche_tableau(tableau,ligne,colonne):

      #affiche un tableau, ceci est une procédure

      for ln in range(0,ligne):

            for cn in range(0,colonne):

                  print(tableau[ln][cn],end=" ")

            print('')

.

programme Résultat

#0506 utiliser_tableau.py

from tableau import*

ligne,colonne=9,9

taille=ligne*colonne

liste=81*[0]

for i in range(9):

    temp=[]

    temp=liste_neuf(i)

    for j in range(9):

        k=i*2%9

        liste[k*9+j]=temp[j]

tableau1=remplir(liste,ligne,colonne)

print("Tableau avec les données mélangées :")

affiche_tableau(tableau1,ligne,colonne)

tableau=tableau_croissant(tableau1,ligne,colonne)

print("Tableau avec les données croissantes :")

affiche_tableau(tableau,ligne,colonne)

tableau=tableau_decroissant(tableau,ligne,colonne)

print("Tableau avec les données décroissantes :")

affiche_tableau(tableau,ligne,colonne)

Tableau avec les données mélangées :

___________________

| 1 2 3|4 5 6|7 8 9|

| 6 7 8|9 1 2|3 4 5|

| 2 3 4|5 6 7|8 9 1|

___________________

| 7 8 9|1 2 3|4 5 6|

| 3 4 5|6 7 8|9 1 2|

| 8 9 1|2 3 4|5 6 7|

___________________

| 4 5 6|7 8 9|1 2 3|

| 9 1 2|3 4 5|6 7 8|

| 5 6 7|8 9 1|2 3 4|

Tableau avec les données croissantes :

___________________

| 1 1 1|1 1 1|1 1 1|

| 2 2 2|2 2 2|2 2 2|

| 3 3 3|3 3 3|3 3 3|

___________________

| 4 4 4|4 4 4|4 4 4|

| 5 5 5|5 5 5|5 5 5|

| 6 6 6|6 6 6|6 6 6|

___________________

| 7 7 7|7 7 7|7 7 7|

| 8 8 8|8 8 8|8 8 8|

| 9 9 9|9 9 9|9 9 9|

Tableau avec les données décroissantes :

___________________

| 9 9 9|9 9 9|9 9 9|

| 8 8 8|8 8 8|8 8 8|

| 7 7 7|7 7 7|7 7 7|

___________________

| 6 6 6|6 6 6|6 6 6|

| 5 5 5|5 5 5|5 5 5|

| 4 4 4|4 4 4|4 4 4|

___________________

| 3 3 3|3 3 3|3 3 3|

| 2 2 2|2 2 2|2 2 2|

| 1 1 1|1 1 1|1 1 1|

FONCTION lambda :

La fonction lambda est une manière simplifiée d’écrire des fonctions.

>>> lambda x: x\*x*x

>>>  <function <lambda> at 0x02E4A420>

>>> f=lambda x:x**3

>>> f(2)

>>> 8

Mais surtout elle permet le passage d’une fonction comme argument. Des exemples sont donnés dans le chapitre ;

FONCTION lambda :

La fonction lambda est une manière simplifiée d’écrire des fonctions.

>>> lambda x: x\*x*x

>>>  <function <lambda> at 0x02E4A420>

>>> f=lambda x:x**3

>>> f(2)

>>> 8

Mais surtout elle permet le passage d’une fonction comme argument. Des exemples sont donnés dans le chapitre ;

.

Programmes et fonctions

.

PGCD de deux entiers

1) Définitions

\(a\) et \(b\)  étant des entiers relatifs, on note \(D\left( a \right)\) l’ensemble des diviseurs de \(a\) , \(D\left( b \right)\) l’ensemble des diviseurs de \(b\) et l’ensemble des diviseurs communs à \(a\) et à \(b\) .

On a donc :\(D\left( {a,b} \right)\ = \ D\left( a \right) \cap D\left( b \right)\) .

Exemple

\(D\left( 35 \right)\ = \ \left \{ {- 35\ ;\ - 7\ ;\ - 5\ ;\ - 1\ \,\,\,;\,\, 1;\,\, 5;\,\, 7;\,\, 35} \right \}\)

\(D\left( 63 \right)\ = \ \left \{ {- 63\ ;\ - 21\ ;\ - 9\ ;\ - 7\ ;\ - 3\ ;\ - 1;1;\ 3;\ 7;\ 9;\ 21\ ;\ 63} \right \}\) et donc \(D\left( 15,63 \right) = \ \left \{ {- 7\ ;\ - 1\ ;\ 1\ ;\ 7} \right \}.\)

On appelle PGCD de \(a\) et de \(b\) , où \(a\) et \(b\) sont deux entiers relatifs non tous les deux nuls, le plus grand diviseur commun à \(a\) et à \(b\) et on le note \(PGCD\left( {a.b} \right)\) .

Remarque :

Il existe au moins un diviseur commun positif puisque \(1\) est à la fois diviseur de \(a\) et de \(b\) .

Donc dans la pratique, on utilisera uniquement les diviseurs positifs de \(a\) et de \(b\) car \(PGCD(a;b) \in {\mathbb{N}}\,\, et \,\, PGCD(a;b) = PGCD(\left| a \right|;\left| b \right|)\)

On dit que deux entiers relatifs \(a\) et \(b\) non tous les deux nuls sont premiers entre eux, lorsque \(PGCD(a;b) = 1\) .

.

Propriétés de l’ensemble des diviseurs communs

.

Propriété 1 (Lemme d’Euclide) :

étant deux entiers naturels avec \(b \neq 0\)  et \(r\) le reste de la division euclidienne de \(a\) par \(b\) alors \(D\left( {a,b} \right)\ = \ D\left( {b,r} \right)\) et donc   \(PGCD\left( {a,b} \right)\ = \ PGCD\left( {b,r} \right)\)

Propriété 2 :

\(a\) et \(b\) étant deux entiers naturels avec \(b \neq 0\)  , si \(b\) divise \(a\) alors \(D\left( {a,b} \right)\ = \ D\left( b \right)\) et donc \(PGD(a;b) = b\)

Algorithme d’Euclide

Théorème :

\(a\) et \(b\) sont deux entiers naturels tels que \(b \neq 0\) . Pour trouver le \(PGCD\left( {a;b} \right)\) , on applique l’algorithme suivant appelé algorithme d’Euclide ou algorithme des divisions euclidiennes successives et celui-ci est obtenu en un nombre fini d’étapes :

1)   Calculer le reste \(r\) de la division euclidienne de \(a\) par \(b\) ;

2)   Si \(r \ = \text{0}\)  alors \(PGCD(a;b) = b\) ;

3)   Si \(r \neq 0\) alors on remplace \(a\) par \(b\) et \(b\)  par \(r\) et on recommence à partir de 1).

.

Code des fonctions PGCD

.

.

.

programme Résultat

def pgcd(a,b):

       return a   if b==0 else pgcd(b,a%b)

print('--------PGCD------------')

a=int(input("Donner un nombre entier : "))

b=int(input("Donner un nombre entier : "))

r=pgcd(a,b)

print('PGCD( ', a,' ; ',b,' ) = ', r)

--------PGCD------------

Donner un nombre entier : 45

Donner un nombre entier : 75

PGCD(  45  ;  75  ) =  15

.

programme Résultat

def permutation(a,b):

      c=a

      a=b

      b=c

      return a,b

def croissant(a,b):

      if a>b: a,b=permutation(a,b)

      return a,b

def reste_division(a,b):

      #b=a*q+r         

      q=b//a

      r=b-q*a

      return r

     

def pgcd(a,b):

      # utilise plusieurs fonctions

      r=2

      while r>1:

            a,b=croissant(a,b)

            r=reste_division(a,b)

            b=r

      a,b=croissant(a,b)

      return b   

print('--------PGCD------------')

a=int(input("Donner un nombre entier : "))

b=int(input("Donner un nombre entier : "))

r=pgcd(a,b)

print('PGCD( ', a,' ; ',b,' ) = ', r)

--------PGCD------------

Donner un nombre entier : 78

Donner un nombre entier : 178

PGCD(  78  ;  178  ) =  2