Créer ses propres fonctions en Python

Article publié le mardi 30 janvier 2024 et mis à jour le mardi 27 février 2024.

Créer ses propres fonctions en Python

Comment déclarer une fonction ? Comment s’en servir et les réutiliser ?

Découvrez tout sur les fonctions dans cet article !

Les fonctions sont un élément essentiel de la programmation en Python. Elles permettent de structurer et d’optimiser notre code. Dans cet article, on va voir les différentes facettes des fonctions, depuis leur définition de base jusqu’à des utilisations plus avancées.

def ma_fonction(a, b, c=42, *args, **kwargs):
  print('corp_de_la_fonction')
  print('une_autre_instruction')
  return a, b, c, *args, *kwargs  # une_ou_plusieurs_valeurs


ma_variable = ma_fonction(0, 1, 2, 3, 4, cinq=5)

print(ma_variable)

Explications en vidéo :

Quand on code des programmes plus complexes, on se retrouve vite avec des centaines ou des milliers de lignes de code.

On va avoir besoin de segmenter ce code en sous-programmes pour pouvoir s’y retrouver.

On va donc utiliser les fonctions pour séparer la logique de notre code, mieux les maintenir et pouvoir les réutiliser à plusieurs endroits.

Explorons tout ce qu’il y a à savoir sur les fonctions en Python sans perdre de temps !

Comment définir une fonction ?

Pour créer une fonction, on utilise le mot-clé def, suivi du nom de la fonction et des parenthèses contenant les paramètres. Par exemple, définissons une fonction appelée ma_fonction.

def ma_fonction(ma_variable):
    print("Ma variable est", ma_variable)

On a le mot def qui nous permet de définir une fonction.

On a ensuite le nom de la fonction qui respecte les mêmes règles que pour les variables, à savoir le snake case, des mots en minuscules séparés par des underscores.

Puis on a des parenthèses dans lesquelles on peut passer des paramètres.

Le symbole deux points, un retour à la ligne avec une indentation d’espaces ou de tabulation.

Et puis le corps de notre fonction qui possède son propre scope.

Cette fonction affiche la valeur de la variable passée en paramètre.

Comment envoyer et récupérer des valeurs d’une fonction ?

Les fonctions peuvent prendre des paramètres. On peut également définir des valeurs par défaut pour rendre certains paramètres optionnels. Le mot-clé return permet de renvoyer une valeur.

def somme(a, b=5):
    return a + b

On peut appeler cette fonction avec somme(3) ou somme(3, 4).

Combien de variables peut on passer en paramètres ?

Les fonctions peuvent accepter un nombre variable de paramètres en utilisant *args pour les arguments positionnels et **kwargs pour les arguments nommés.

Vous voulez en apprendre plus sur les kwargs ? Alors mon article sur ces paramètres nommés en Python est fait pour vous !

def fonction_variable(*args, **kwargs):
    print("Arguments positionnels :", args)
    print("Arguments nommés :", kwargs)

On peut appeler cette fonction avec fonction_variable(1, 2, 3, a=4, b=5).

Exemples de fonctions

def ma_fonction(a, b, c=42, *args, **kwargs):
  return a, b, c, *args, *kwargs


def additionner(a, b):
  return a + b


def soustraire(a, b):
  return a - b


def multiplier(a, b):
  return a * b


def diviser(a, b):
  return a / b


def mettre_au_carre(a, b):
  return a ** b

C’est quoi la portée des variables (Scope) ?

La portée des variables dans les fonctions est cruciale. Les variables déclarées à l’intérieur d’une fonction sont locales à cette fonction, sauf si elles sont déclarées comme globales.

a = 0

def fonction_1():
    a = 1
    print("Fonction_1, a =", a)

def fonction_2():
    a = 2
    print("Fonction_2, a =", a)

print(a)
fonction_1()
fonction_2()

Dans cet exemple, a a trois valeurs différentes dans le programme principal et chaque fonction a son propre a limité par son scope.

Une autre notion importante quand on parle de fonction est la notion de scope.

Déclarons deux fonctions : fonction_1 et fonction_2

Dans le corps de ces fonctions, on va avoir une assignation de variable a.

Dans fonction_1 on fait a = 1 et puis on print(“fonction_1, a =”, a).

Dans fonction_2 on fait a = 2 et puis on print(“fonction_2, a =”, a).

Si on essaie d’afficher a dans notre programme principal, on voit que Python nous dit que la variable a n’est pas définie.

C’est parce que quand on la déclare dans nos fonctions, seules nos fonctions ont accès à cette variable.

Tout en haut de notre programme, on va assigner la valeur 0 à a.

Et maintenant dans notre programme principal, on print(a), et on appelle fonction_1 et fonction_2.

On voit que a a 3 valeurs différentes, car notre programme principal ne connaît que a = 0.

Et chaque fonction a son propre variable a limitée par son scope.

Si on ajoute une variable b = 3 tout en haut du programme, et puis qu’on essaie d’afficher b dans notre première fonction.

On voit que fonction_1 a accès à la variable b. b est ce qu’on appelle une variable globale qui sera accessible dans les autres scopes.

Alors que les variables déclarées dans les fonctions sont des variables locales uniquement accessibles dans le bloc dans lequel elles ont été définies.

Comment coder la fonction range ?

Inspirons-nous de la fonction native range pour créer notre version simplifiée, simple_range. Cette fonction renvoie une liste d’éléments de 0 à n-1.

Si vous ne connaissez pas cette fonction native, j’ai un article complet sur la fonction range.

def simple_range(n):
  l = []
  i = 0

  while i < n:
    l.append(i)
    i += i

  return i

Donc pour faire une fonction simple_range, on utilise le mot def, puis le nom simple_range, des parenthèses dans lesquelles on a le paramètre n.

Dans le corps de la fonction on va déclarer une liste avec l égale et des crochets et puis une variable i.

On va avoir une boucle while qui va boucler tant que i est plus petit que n.

Et dans le corps de notre while on va ajouter l’élément i à notre liste à chaque passage dans la boucle.

On doit ensuite incrémenter i de 1 pour ne pas partir en boucle infinie.

Et à la fin de notre fonction on renvoie notre liste l qui devrait contenir n éléments de 0 à n - 1.

Testons notre fonction en l’appelant avec print(simple_range(5)).

Lançons le programme et on voit bien qu’on a une liste qui contient 5 nombres de 0 à 4.

Vous pouvez améliorer votre fonction simple_range en implémentant plus de fonctionnalités de la fonction range native.

On peut aussi plus simplement avoir la fonction :

def simple_range(n):
    return list(range(n))

On peut utiliser simple_range(5) pour obtenir une liste de 0 à 4.

Aller plus loin avec les fonctions

Bravo 🎉 Vous savez maintenant comment utiliser les fonctions en Python !

Les fonctions en Python offrent une flexibilité et une puissance considérables pour structurer notre code de manière modulaire et réutilisable.

En maîtrisant les concepts de base et en explorant des fonctionnalités avancées telles que les paramètres variables et la portée des variables, on peut écrire un code plus propre et plus optimisé.

On a aussi vu comment recoder une version simplifiée de la fonction range avec notre fonction simple_range, pour renforcer nos compréhension de ces concepts fondamentaux.


Comment Coder

Je m'appelle Thomas. J'ai commencé à coder dans mon enfance. Depuis ma sortie de la première promo de l'École 42, j'ai développé des centaines d'applications et sites web. Sur ce blog, je vous donne les meilleurs conseils et astuces pour apprendre comment apprendre à coder efficacement.