Tutoriel Python: créer et utiliser des fonctions

id 3472

Table des matières

Introduction

Définition

Les fonctions intégrées

Les fonctions sans paramètres

Les fonctions avec paramètres

La différence entre un paramètre et un argument

Fonction à plusieurs paramètres

Définir de la valeur par défaut d’un paramètre

L’instruction return

La portée des variables

Les variables globales

Les variables locales

Les variables non locales

Conclusion

Introduction :

La réutilisation du code est une partie indispensable de la programmation dans n'importe quel langage, mais l’augmentation de la taille de votre code rend sa lisibilité et sa maintenance plus difficile.

Par conséquent, il est nécessaire de respecter le principe DRY (« Don’t Repeat Yourself » ou « ne pas se répéter ») pour que votre projet de programmation réussisse. Ce principe consiste à éviter les redondances de code en utilisant une normalisation de données, par exemple les boucles et les fonctions et l’utilisation de variables globales, locales ou non locales.

Les violations de DRY sont généralement appelées des solutions WET qui est un terme courant signifiant (« Write Everything Twice » qui veut dire « tout écrire deux fois ») ou bien (« Write Every Time » qui veut dire « écrire à chaque fois »).

Ce tutoriel comportera en premier lieu les fonctions et leurs différents types d’utilisation, ainsi que l’importance de l’instruction « return », et par la suite, on parlera de la portée des variables (variables globales, locales et non locales).

1. Définition

Dans un langage de programmation, une fonction est un bloc de code organisé et réutilisable contenant une tâche spécifique ou un groupe de tâches associées qui ne fonctionne que lors de son appel. L’appel d’une fonction est défini par toute instruction composée d'un mot suivi d'informations entre parenthèses.

C’est aussi un outil très important à apprendre en programmation, il doit être compris et pratiqué. À partir de cette leçon, on va se concentrer sur les trois types de fonctions : Les fonction intégrées, les fonctions sans paramètres et les fonctions avec paramètres.

2. Les fonctions intégrées

L’interpréteur du langage de programmation Python 3 contient des fonctions intégrées ou prédéfinies qui sont toujours disponibles lors de leur appel.

On listera ci-dessous certaines fonctions intégrées essentielles pour votre formation sur les fonctions de Python 3 avec leur définition, ainsi que quelques exemples afin de les clarifier :

  • abs() :
    • Cette fonction renvoie la valeur absolue d’un nombre.
  •  Exemple :

 abs ( -56.3 )
#nous renvoie le résultat 56.3.

  • all() :
    • Renvoie True si tous les éléments d'un objet itérable (liste, tuple, dictionnaire…) sont True.
    • Si l’objet itérable est vide, la fonction all() renvoie True.
  • Exemple 1 :

ma_liste = [True, True, True]
 all ( ma_liste ) #nous renvoie le résultat True.

  • Exemple 2 :

ma_liste = [True, False, True]
 all ( ma_liste ) #nous renvoie le résultat False.

  • any() :
    • Renvoie True si au moins un des éléments d'un objet itérable (liste, tuple, dictionnaire…) est True.
    • Si l’objet itérable est vide, la fonction any() renvoie False.
  • Exemple 1 :

 ma_liste = [True, True, True]
 any ( ma_liste ) #nous renvoie le résultat True



  • Exemple 2:

ma_liste = [True, False, True] 
 any ( ma_liste ) #nous renvoie le résultat False

  • bin() :
    • Renvoie la conversion en binaire d'un entier.
    • Le résultat s’affichera toujours précédé par le préfixe 0b.
  • Exemple :

     bin ( 120 ) #nous renvoie le résultat '0b1111000'
     bin ( -20 ) #nous renvoie le résultat '-0b10100'

  • bool() :
    • Renvoie la valeur booléenne d’un objet.
  • Exemple :

     bool ( 2==2 ) #nous renvoie le résultat True.
     bool ( 2>3 )  #nous renvoie le résultat False.

  • callable() :
    • Renvoie True si l’objet entre parenthèses peut être appelable.
  • Exemple :

 callable ( print ) #nous renvoie le résultat True.

  • chr() :
    • Renvoie le caractère correspondant à un code Unicode.
  • Exemple :

chr ( 102 ) #nous renvoie le résultat 'f'.
chr ( 37 ) #nous renvoie le résultat '%'.

  • complex() :
    • complex(a,b) renvoie une représentation complexe sous forme (a+b*j).
    •  ‘j’ étant le nombre complexe, ‘a’ la partie réelle et ‘b’ la partie imaginaire.
  • Exemple :

    complex ( 2 , 3 ) #nous renvoie le résultat (2+3j)
     complex ( 2.5 , 3/5 ) #nous renvoie le résultat (2.5+0.6j)

  • dict() :
    • Permet de créer un nouveau dictionnaire.
    • Un dictionnaire est une collection non ordonnée, modifiable et indexée.
  • Exemple :

dict_nourriture = dict ( Orange = 'Fruit' , carotte = 'Légume' )
#nous permet de créer une nouveau dictionnaire.
   dict_nourriture ['Orange'] nous renvoie le résultat 'Fruit'.

  • divmod() :
    • Renvoie le quotient ‘q’ et le reste ‘r’ d’une division de deux nombres sous la forme (q, r).
  • Exemple :

divmod ( 7 , 2 ) #nous renvoie le résultat (3, 1).

  • enumerate() :
    • Renvoie une énumération des éléments d’un objet itérable.
    • Ainsi, on peut ajouter une initiation de cette énumération en l’écrivant sous forme enumerate(objet,start=x)
  • Exemple :

    ma_liste=list('abcde')
       list (enumerate ( ma_liste , 1 ))
    #nous renvoie le résultat [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')].

  • float() :
    • Renvoie la conversion d’un nombre en un nombre réel.
  • Exemple :

float(3) #nous renvoie le résultat 3.0

  • help() :
    • Exécute le système d’aide intégré en Python.
  • hex() :
    • Renvoie la conversion en hexadécimale d'un entier.
    • Le résultat s’affichera toujours précédé par le préfixe 0x.
  • Exemple :

     hex(120) #nous renvoie le résultat '0x78'.
     hex(150*2) #nous renvoie le résultat '0x12c'.

  • input() :
    • Permet à l’utilisateur de saisir des données.
  • int() :
    • Renvoie la conversion d’un nombre en un nombre entier (la valeur inférieure ou égale à la valeur proposée).
  • Exemple :

 int(3.20) #nous renvoie le résultat 3.

  • len() :
    • Renvoie la longueur d’un objet.
  • Exemple :

len('https://www.cours-gratuit.com/') #nous renvoie le résultat 30.

  • list()
    • Permet de créer une nouvelle liste.
  • Exemple :

ma_liste=list('abcde')
#permet de créer une liste de la chaine de caractères ‘abcde’.
   print(ma_liste)
#nous affichera cette liste sous la forme ['a', 'b', 'c', 'd', 'e'].

  • max()
    • Renvoie l’objet dont la valeur est la plus haute.
  • Exemple :

     max(1,2,3,8) #nous renvoie le résultat 8.



  • min()
    • Renvoie l’objet dont la valeur est la plus basse.
  •  Exemple :

     min(1,2,3,8) #nous renvoie le résultat 1.

  • oct()
    • Renvoie la conversion d’un nombre entier en octal.
    •  Le résultat s’affichera toujours précédé par le préfixe 0o.
  • Exemple :

 oct(120) #nous renvoie le résultat '0o170'.
 oct(130*50) #nous renvoie le résultat '0o14544'.

  • pow()
    • pow(a,b) renvoie la valeur de « a » à la puissance de « b ».
  • Exemple :

 pow(5,3) #nous renvoie le résultat 125.

  • print()
    • Permet d’afficher.
  • sum()
    • Renvoie la somme des éléments.
  • type()
    • Renvoie le type d’objet.
  • Exemple :

     type(0.2) #nous renvoie le résultat <class 'float'="">.

3. Les fonctions sans paramètres :

En addition des fonctions intégrées, on peut créer nos propres fonctions à l’aide de l’instruction def qui signifie « define » ou « définir », servant à déterminer une fonction.

On notera les points suivants qui seront nécessaires pour construire votre fonction :

  • Une fonction est définie par le mot-clé « def ».
  • Le nom d’une fonction est suivi de deux parenthèses, qui peuvent être vides ou peuvent avoir un ou plusieurs paramètres.
  • Après le nom et les parenthèses, il est nécessaire de mettre deux points «:» entre le nom d'une fonction et son corps.
  • Après ces deux points, coupez la ligne et écrivez les tâches que votre fonction doit réaliser.
  • Définissez la sortie de la fonction, par exemple 'print ()' ou conservez la sortie pour une utilisation ultérieure en utilisant 'return'.
  • Exécutez votre fonction en l’appelant, votre fonction doit être appelée après l’avoir définie et non pas avant.

3.1. Exemple d’une fonction sans paramètres :

  • Code :

def ma_fonction():  # Définir la fonction par le mot-clé « def ».
    print ("Bonjour !")  # La tâche ou l’instruction que la fonction doit réaliser.
   ma_fonction()  # L’appel de la fonction

  • Résultat de l’exécution :
Bonjour !

Remarque : Python 3 est un langage qui exécute le programme ligne par ligne. Lorsqu'il atteint une ligne, l'interprète sait ce qu'il a fait avant et non ce qu'il fera après. C'est la raison pour laquelle une variable, une classe ou une fonction doit être définie avant d'être utilisée :

  • Code :

ma_fonction()
def ma_fonction():
   print ("Bonjour !")

  • Résultat de l’exécution:
NameError: name 'ma_fonction' is not defined!

4. Les fonctions avec paramètres :

4.1. La différence entre un paramètre et un argument :

Les paramètres sont les noms de variables temporaires dans une fonction. Par ailleurs, l'argument peut être considéré comme la valeur affectée à cette variable temporaire.

Dans une fonction avec paramètres, ces paramètres agissent comme des espaces réservés pour un argument. Prenant comme exemple la fonction suivante :

Exemple d’une fonction avec paramètre :

  • Code :

def présentation(Prénom):  # Définir la fonction avec le paramètre « Prénom ».
 print ("Bonjour !" \nJe m'appelle "+Prénom)
présentation("Ismail")  # L’appel de la fonction avec l’argument « Ismail ».

  • Résultat de l’exécution :
Bonjour !
Je m'appelle Ismail

« Prénom » est le paramètre de la fonction « présentation (Prénom) ». Ce qui signifie que partout où nous saisissons « Prénom » dans la fonction, il agira comme un espace réservé jusqu'à ce qu’on lui passe un argument, qui est dans notre cas « Ismail ».



4.2. Fonction à plusieurs paramètres

Vous pouvez également définir une fonction avec plus d'un paramètre entre ses parenthèses ; tout en les séparant par des virgules.

Exemple d’une fonction avec plusieurs paramètres :

  • Code :

def addition(a,b,c,d):  # Définir la fonction avec les paramètres a, b, c et d.
 print (a+b+c+d)
addition(1,3,8,6)  # L’appel de la fonction avec les arguments 1, 3, 8 et 6.

  • Résultat de l’exécution :
18

4.3. Définir la valeur par défaut d’un paramètre :

Pour définir la valeur par défaut d’un paramètre spécifié dans une définition de fonction Python, l’en-tête de la fonction devient sous la forme def <fonction> (<paramètre>= <valeur>) : , alors <valeur> devient une valeur par défaut pour ce paramètre, Et lors de l’appel de cette fonction <fonction>(), le résultat dépendra de la valeur par défaut définie au paramètre.

En prenant l’exemple précèdent :

  • Code :

def addition(a=0,b=0,c=0,d=0):
 print (a+b+c+d)
addition()

  • Résultat de l’exécution :
0

5. L’instruction return

Bien plus avantageux que l’instruction print(), qui sert à afficher le résultat, l’instruction return nous permet de gérer et utiliser ce résultat pour des prochains calculs.

Remarque : La fonction cesse immédiatement d'être exécutée dès qu’elle renvoie une valeur avec l’instruction return.

Exemple d’une fonction avec l’instruction return

  • Code :

def minimum(a,b):
  if a<=b :
  return a
  else :
  return b
  print("cette instruction ne s'affichera pas")
print(minimum(1,3))
print(minimum(2,3)*5)

  • Résultat de l’exécution :
1  # résultat de l’instruction print(minimum(1,3))
10  # résultat de l’instruction print(minimum(2,3)*5)

6. La portée des variables

6.1. Les variables globales :

Une variable définie en dehors d’une fonction ou dans la portée globale est appelée une variable globale. Elle peut être accessible à l'intérieur ou à l'extérieur de la fonction.

Exemple d’une variable globale :

  • Code :

x=1
def addition_par_deux():
  print(x+2)
addition_par_deux()
print(x)

  • Résultat de l’exécution :
3  # résultat de l’instruction addition_par_deux()
1  # résultat de l’instruction print(x)

Remarque : Pour changer la valeur d’une variable globale à l’intérieur d’une fonction, on doit ajouter le mot-clé « global ».

Exemple d’une variable globale avec changement de valeur sans le mot-clé « global »

  • Code :

y=1
def addition_par_deux():
  y = y+2
  print("la valeur de y à l'intérieur de la fonction est : ", y)
addition_par_deux()
print("la valeur de y à l'extérieur de la fonction est : ", y)

  • Résultat de l’exécution :
UnboundLocalError: local variable 'y' referenced before assignment

Exemple d’une variable globale avec changement de valeur avec le mot-clé « global »

  • Code :

y=1
def addition_par_deux():
  global y
  y = y+2
  print("la valeur de y à l'intérieur de la fonction est : ", y)
addition_par_deux()
print("la valeur de y à l'extérieur de la fonction est : ", y)

  • Résultat de l’exécution :
la valeur de y à l'intérieur de la fonction est :  3
la valeur de y à l'extérieur de la fonction est :  3

6.2. Les variables locales :

Une variable définie à l’intérieur d’une fonction ou dans la portée locale est appelée une variable locale. Elle peut être accessible seulement à l'intérieur de la fonction.

Exemple d’une variable locale

  • Code :

def addition_par_trois():
  x=1
  print(x+3)
addition_par_trois()

  • Résultat de l’exécution :
4  # résultat de l’instruction addition_par_trois()

Contrairement à la variable globale, on peut changer la valeur d’une variable locale à l’intérieur d’une fonction.



Exemple d’une variable locale avec changement de valeur

  • Code :

def addition_par_trois():
  x=1
  x=x+3    # Changement de la valeur de la variable locale x
  print(x)
addition_par_trois()

  • Résultat de l’exécution :
4  # résultat de l’instruction addition_par_trois()

6.3. Les variables non locales :

Une variable définie à l’intérieur d’une fonction qui contient elle-même une autre fonction est appelée une variable non locale. Cette variable ne peut être considérée ni locale ni globale.

On utilise le mot-clé « nonlocal » pour définir une variable non locale.

Exemple d’une variable non locale

  • Code :

def carré_et_cube_de_deux ():
  x=2
  def carré():
  nonlocal x
  print("le carré de deux est : ", x**2))
  carré()
  print("le cube de deux est : ", x**3)
carré_et_cube_de_deux ()

  • Résultat de l’exécution :
le carré de deux est :  4
le cube de deux est :  8

Conclusion

Finalement ! vous venez d’apprendre comment créer et utiliser les fonctions sur Python, ainsi, avec une application progressive de ce tutoriel, vous serait plus apte à élaborer un code DRY qui est gérable avec un minimum de redondances. J'espère que vous avez maintenant tous les outils à adopter pour votre projet Python. Bonne chance à vous !