Maîtriser les fonctions Python | Tutoriels de programmation

Introduction

Dans ce laboratoire, vous allez apprendre à définir et à utiliser des fonctions Python. Nous commencerons par des exemples simples et augmenterons progressivement la complexité.

Commençons!

Objectifs

Fonctions Python

Définir une fonction Python

Pour définir une fonction Python, vous devez utiliser le mot clé def suivi du nom de la fonction et d'un ensemble de parenthèses qui peuvent contenir des arguments. Le corps de la fonction est indenté et suit le caractère :.

Ouvrez un nouvel interpréteur Python.

python3

Voici un exemple d'une fonction simple qui prend un seul argument x et renvoie le carré de x :

def square(x):
  return x ** 2

Dans cet exemple, la fonction square prend un seul argument x et renvoie le carré de x. La valeur est renvoyée à l'appelant à l'aide de l'instruction return.

Pour appeler une fonction, utilisez simplement le nom de la fonction suivi d'un ensemble de parenthèses et de tout argument nécessaire. Par exemple :

result = square(5)  ## result est 25
print(result)

Si une fonction n'a pas d'instruction return, elle renverra None par défaut. Par exemple :

def square(x):
  print(x ** 2)

result = square(5)  ## result est None
print(result)

Vous devez savoir la différence entre les instructions return et print. L'instruction print est utilisée pour afficher la valeur à l'écran, mais l'instruction return est utilisée pour renvoyer la valeur à partir de la fonction.

Il est également possible d'utiliser l'instruction return pour terminer l'exécution d'une fonction tôt. Par exemple :

def find_first_positive(numbers):
  for number in numbers:
    if number > 0:
      return number
  return None

result = find_first_positive([-1, -2, 3, -4, 5])  ## result est 3
print(result)

Dans cet exemple, la fonction find_first_positive renvoie le premier nombre positif de la liste numbers, ou None si aucun nombre positif n'est trouvé. L'instruction return termine l'exécution de la fonction dès qu'un nombre positif est trouvé.

Arguments de fonction

Parfois, il est utile de spécifier des valeurs par défaut pour les arguments de fonction. De cette manière, la fonction peut être appelée sans passer de valeur pour cet argument, et la valeur par défaut sera utilisée à la place.

Voici un exemple d'une fonction qui calcule l'aire d'un rectangle. Elle prend deux arguments : la longueur et la largeur du rectangle. Nous pouvons spécifier des valeurs par défaut pour les deux arguments, de sorte que la fonction peut être appelée avec un seul argument si la longueur et la largeur sont égales :

def rectangle_area(length, width=1):
  return length * width

print(rectangle_area(5))  ## Sortie : 5
print(rectangle_area(5, 2))  ## Sortie : 10

Dans cet exemple, l'argument width a une valeur par défaut de 1. Si la fonction est appelée avec un seul argument, la valeur par défaut de 1 est utilisée pour la width.

Essayez-le vous-même : définissez une fonction appelée power qui prend deux arguments : une base x et un exposant n. Rendez l'argument exposant facultatif, avec une valeur par défaut de 2. Ensuite, appelez la fonction avec différentes valeurs pour la base et l'exposant.

def power(x, n=2):
  return x ** n

print(power(2))  ## Sortie : 4
print(power(2, 3))  ## Sortie : 8

Indication de type d'argument

En Python, les indications de type d'argument de fonction indiquent le type attendu d'un argument passé à une fonction. Elles ont été introduites en Python 3.5 et sont désignées par deux-points suivis du type, placés après le nom de l'argument dans la définition de la fonction.

Les indications de type sont facultatives et n'affectent pas le comportement exécutif du code. Elles sont principalement utilisées par des outils tels que les IDE et les correcteurs de syntaxe pour fournir une meilleure analyse du code et des suggestions d'auto-complétion.

Par exemple, considérez la fonction suivante qui prend deux arguments, un entier et une chaîne de caractères, et renvoie leur concaténation :

def concatenate(a: int, b: str) -> str:
    return str(a) + b

print(concatenate(1, "world")) ## "1world"

Dans cet exemple, les indications de type int et str indiquent que le premier argument a devrait être un entier et le second argument b devrait être une chaîne de caractères.

Les indications de type peuvent également être utilisées avec des classes et leurs instances, par exemple :

class MyClass:
    pass

def my_function(a: MyClass) -> None:
    pass

Il est important de mentionner que les indications de type sont facultatives et n'affectent pas le comportement exécutif du code. Elles sont principalement utilisées par des outils tels que les IDE et les correcteurs de syntaxe pour fournir une meilleure analyse du code et des suggestions d'auto-complétion.

De plus, Python a un module nommé typing qui contient des types utiles comme List, Tuple, Dict, Set, etc. qui peuvent être utilisés pour donner des indications sur les types d'éléments dans une collection.

from typing import List, Tuple
def my_function(a: List[int], b: Tuple[str, int]) -> None:
    pass

Il est une bonne pratique d'utiliser des indications de type dans votre code pour le rendre plus lisible et maintenable.

Docstring

Une docstring est une chaîne littérale qui apparaît comme première instruction dans la définition d'un module, d'une fonction, d'une classe ou d'une méthode. Une telle docstring devient l'attribut spécial __doc__ de cet objet.

Les docstrings sont utilisées pour documenter le code et sont écrites en texte brut. Elles sont entourées de triples guillemets """ et sont généralement placées au début de la définition de la fonction.

def my_function():
    """Ceci est une docstring."""
    pass

Les docstrings contiennent généralement une courte description de la fonction, de ses arguments et de sa valeur de retour. Elles peuvent également contenir une description plus longue du comportement de la fonction.

def my_function(a: int, b: int) -> int:
    """Retourne la somme de a et b.

    Args:
        a (int) : Le premier nombre.
        b (int) : Le second nombre.

    Returns:
        int : La somme de a et b.
    """
    return a + b

Retourner plusieurs valeurs

En Python, une fonction peut retourner plusieurs valeurs en utilisant un tuple. Voici un exemple d'une fonction qui calcule les valeurs minimale et maximale d'une liste :

def min_max(numbers):
  return min(numbers), max(numbers)

nums = [1, 2, 3, 4, 5]
min_val, max_val = min_max(nums)
print("Valeur minimale :", min_val)  ## Sortie : "Valeur minimale : 1"
print("Valeur maximale :", max_val)  ## Sortie : "Valeur maximale : 5"

Dans cet exemple, la fonction min_max retourne un tuple contenant les valeurs minimale et maximale de la liste numbers. Le tuple est déballé dans les variables min_val et max_val lorsque la fonction est appelée.

Voici un autre exemple de retour de plusieurs valeurs à partir d'une fonction :

def get_student_info(name):
  if name == "John":
    return "John", "Doe", "Informatique"
  elif name == "Jane":
    return "Jane", "Smith", "Physique"
  else:
    return "Inconnu", "Inconnu", "Inconnu"

first_name, last_name, major = get_student_info("John")
print("Prénom :", first_name)  ## Sortie : "Prénom : John"
print("Nom de famille :", last_name)  ## Sortie : "Nom de famille : Doe"
print("Spécialité :", major)  ## Sortie : "Spécialité : Informatique"

first_name, last_name, major = get_student_info("Jane")
print("Prénom :", first_name)  ## Sortie : "Prénom : Jane"
print("Nom de famille :", last_name)  ## Sortie : "Nom de famille : Smith"
print("Spécialité :", major)  ## Sortie : "Spécialité : Physique"

first_name, last_name, major = get_student_info("Bob")
print("Prénom :", first_name)  ## Sortie : "Prénom : Inconnu"
print("Nom de famille :", last_name)  ## Sortie : "Nom de famille : Inconnu"
print("Spécialité :", major)  ## Sortie : "Spécialité : Inconnu"

Dans cet exemple, la fonction get_student_info prend le nom d'un étudiant et retourne un tuple contenant le prénom, le nom de famille et la spécialité de l'étudiant. Le tuple est déballé dans des variables séparées lorsque la fonction est appelée.

Si le nom de l'étudiant n'est pas reconnu, la fonction retourne un tuple avec des valeurs "Inconnu".

Arguments clés

En Python, vous pouvez spécifier les arguments de fonction en utilisant des "arguments de mot clé". Lorsque vous utilisez des arguments de mot clé, vous spécifiez le nom de l'argument suivi de la valeur, et les arguments peuvent être fournis dans n'importe quel ordre.

Voici un exemple d'une fonction qui prend deux arguments : un nom et un message :

def greet(name, message):
  print("Bonjour, " + name + "! " + message)

greet(message="Comment ça va?", name="John")  ## Sortie : "Bonjour, John! Comment ça va?"

Dans cet exemple, la fonction greet est appelée avec les arguments "John" et "Comment ça va?", mais les arguments sont fournis dans un ordre différent de celui dans lequel ils sont définis dans la fonction. En utilisant des arguments de mot clé, vous pouvez spécifier les arguments dans n'importe quel ordre et rendre le code plus lisible.

Vous pouvez également mélanger des arguments de mot clé avec des arguments positionnels, tant que les arguments positionnels sont fournis en premier. Par exemple :

def greet(name, message):
  print("Bonjour, " + name + "! " + message)

greet("John", message="Comment ça va?")  ## Sortie : "Bonjour, John! Comment ça va?"

Dans cet exemple, l'argument name est fourni en tant qu'argument positionnel, tandis que l'argument message est fourni en tant qu'argument de mot clé.

Les arguments de mot clé sont particulièrement utiles lorsqu'une fonction a un grand nombre d'arguments, ou lorsque les arguments ont des valeurs par défaut. Par exemple :

def create_user(name, age=18, gender="inconnu"):
  print("Création d'un utilisateur :", name, age, gender)

create_user("John")  ## Sortie : "Création d'un utilisateur : John 18 inconnu"
create_user("Jane", gender="femme")  ## Sortie : "Création d'un utilisateur : Jane 18 femme"
create_user("Bob", 25, "homme")  ## Sortie : "Création d'un utilisateur : Bob 25 homme"

Dans cet exemple, la fonction create_user prend trois arguments : name, age et gender. Les arguments age et gender ont des valeurs par défaut, donc ils sont facultatifs. En utilisant des arguments de mot clé, vous pouvez spécifier seulement les arguments que vous voulez fournir, et les valeurs par défaut seront utilisées pour le reste.

Args et Kwargs

En Python, vous pouvez utiliser la syntaxe *args et **kwargs pour définir une fonction qui peut prendre un nombre variable d'arguments.

La syntaxe *args est utilisée pour passer un nombre variable d'arguments non nommés à une fonction. Par exemple :

def print_numbers(*args):
  for arg in args:
    print(arg)

print_numbers(1, 2, 3, 4, 5)  ## Sortie : 1, 2, 3, 4, 5
print_numbers(10, 20, 30)  ## Sortie : 10, 20, 30

Dans cet exemple, la fonction print_numbers prend un nombre variable d'arguments et les affiche dans la console. La syntaxe *args est utilisée pour définir la fonction, et les arguments sont passés en tant que tuple à la fonction.

La syntaxe **kwargs est utilisée pour passer un nombre variable d'arguments nommés à une fonction. Par exemple :

def print_keywords(**kwargs):
  for key, value in kwargs.items():
    print(key, ":", value)

print_keywords(name="John", age=30, city="New York")
## Sortie :
## name : John
## age : 30
## city : New York

print_keywords(country="USA", population=327000000)
## Sortie :
## country : USA
## population : 327000000

Dans cet exemple, la fonction print_keywords prend un nombre variable d'arguments nommés et les affiche dans la console. La syntaxe **kwargs est utilisée pour définir la fonction, et les arguments sont passés en tant que dictionnaire à la fonction.

Vous pouvez mélanger la syntaxe *args et **kwargs avec d'autres arguments dans une définition de fonction, tant que les arguments *args et **kwargs sont fournis en dernier. Par exemple :

def print_info(title, *args, **kwargs):
  print(title)
  for arg in args:
    print(arg)
  for key, value in kwargs.items():
    print(key, ":", value)

print_info("Personne", "John", "Jane", "Bob", age=30, city="New York")
## Sortie :
## Personne
## John
## Jane
## Bob
## age : 30
## city : New York

Dans cet exemple, la fonction print_info prend un argument fixe title, suivi d'un nombre variable d'arguments non nommés (*args) et d'un nombre variable d'arguments nommés (**kwargs). Les arguments sont passés à la fonction dans l'ordre dans lequel ils sont définis : d'abord title, puis *args, et enfin **kwargs.

La syntaxe *args et **kwargs peut être utile lorsque vous voulez définir une fonction flexible qui peut accepter un nombre variable d'arguments. Elles peuvent également rendre le code plus lisible en vous permettant d'éviter d'utiliser des noms d'arguments codés en dur dans la définition de la fonction.

Voici un exemple d'une fonction qui utilise *args et **kwargs pour créer un dictionnaire d'arguments :

def create_dict(**kwargs):
  return kwargs

my_dict = create_dict(name="John", age=30, city="New York")
print(my_dict)  ## Sortie : {'name': 'John', 'age': 30, 'city': 'New York'}

my_dict = create_dict(a=1, b=2, c=3)
print(my_dict)  ## Sortie : {'a': 1, 'b': 2, 'c': 3}

Dans cet exemple, la fonction create_dict prend un nombre variable d'arguments nommés et les renvoie sous forme de dictionnaire. La syntaxe **kwargs est utilisée pour définir la fonction, et les arguments sont passés en tant que dictionnaire à la fonction.

Vous pouvez également utiliser l'opérateur * pour "déballer" une liste ou un tuple en arguments séparés lors de l'appel d'une fonction. Par exemple :

def print_numbers(*args):
  for arg in args:
    print(arg)

numbers = [1, 2, 3, 4, 5]
print_numbers(*numbers)  ## Sortie : 1, 2, 3, 4, 5

tuple_of_numbers = (10, 20, 30)
print_numbers(*tuple_of_numbers)  ## Sortie : 10, 20, 30

Dans cet exemple, l'opérateur * est utilisé pour déballer la liste numbers et le tuple tuple_of_numbers en arguments séparés lors de l'appel de la fonction print_numbers.

Vous pouvez également utiliser l'opérateur ** pour "déballer" un dictionnaire en arguments nommés lors de l'appel d'une fonction. Par exemple :

def print_keywords(**kwargs):
  for key, value in kwargs.items():
    print(key, ":", value)

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
print_keywords(**my_dict)
## Sortie :
## name : John
## age : 30
## city : New York

another_dict = {'country': 'USA', 'population': 327000000}
print_keywords(**another_dict)
## Sortie :
## country : USA
## population : 327000000

Dans cet exemple, l'opérateur ** est utilisé pour déballer les dictionnaires my_dict et another_dict en arguments nommés lors de l'appel de la fonction print_keywords.

Fonctions Lambda

En Python, vous pouvez utiliser des "fonctions lambda" pour créer des fonctions anonymes. Les fonctions lambda sont de petites fonctions qui n'ont pas de nom et sont généralement définies et appelées sur une seule ligne de code.

Voici un exemple d'une fonction lambda qui prend deux arguments et renvoie leur somme :

sum = lambda x, y: x + y

result = sum(1, 2)  ## result est égal à 3

Dans cet exemple, le mot clé lambda est utilisé pour définir une fonction lambda qui prend deux arguments x et y et renvoie leur somme. La fonction lambda est assignée à la variable sum et peut être appelée comme n'importe quelle autre fonction.

Est-ce que vous pouvez utiliser une fonction normale au lieu d'une fonction lambda pour définir la même fonction?

def sum(x, y):
  return x + y

result = sum(1, 2)  ## result est égal à 3

Les fonctions lambda sont souvent utilisées comme raccourci pour définir des fonctions simples. Elles sont particulièrement utiles lorsque vous voulez passer une fonction en tant qu'argument à une autre fonction, ou lorsque vous voulez définir une fonction en ligne.

Voici un exemple d'utilisation d'une fonction lambda en tant qu'argument pour la fonction sorted :

words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)  ## Sortie : ['apple', 'date', 'banana', 'cherry']

Dans cet exemple, la fonction sorted prend une liste de mots et une fonction "clé" qui spécifie comment les mots doivent être triés. La fonction lambda passée en tant que fonction clé renvoie la longueur de chaque mot, et les mots sont triés en fonction de leur longueur.

Voici un exemple de définition d'une fonction lambda en ligne :

result = (lambda x: x ** 2)(5)  ## result est égal à 25

Dans cet exemple, la fonction lambda prend un seul argument x et renvoie le carré de x. La fonction lambda est définie et appelée sur une seule ligne de code, et le result est assigné à la variable result.

Les fonctions lambda sont souvent utilisées en Python pour des fonctions courtes et simples qui n'ont pas besoin d'être réutilisées ailleurs dans le code. Elles sont un moyen pratique de définir rapidement de petites fonctions sans avoir besoin de définir une fonction séparée en utilisant le mot clé def.

Portée locale et portée globale

En Python, les variables définies à l'intérieur d'une fonction sont "locales" à la fonction et ne sont disponibles que à l'intérieur de la fonction. Les variables définies en dehors d'une fonction sont "globales" et sont disponibles tout au long du programme.

Voici un exemple d'une variable globale :

message = "Bonjour, le monde!"

def greet():
  print(message)

greet()  ## Sortie : "Bonjour, le monde!"

Dans cet exemple, la variable message est définie en dehors de la fonction greet, donc c'est une variable globale. La fonction greet peut accéder et afficher la variable message car elle est disponible tout au long du programme.

Voici un exemple d'une variable locale :

def greet(name):
  message = "Bonjour, " + name + "!"
  print(message)

greet("John")  ## Sortie : "Bonjour, John!"
print(message)  ## Sortie : NameError: name 'message' is not defined

Dans cet exemple, la variable message est définie à l'intérieur de la fonction greet, donc c'est une variable locale. La fonction greet peut accéder et afficher la variable message, mais elle n'est pas disponible en dehors de la fonction. Si vous essayez d'accéder à la variable message en dehors de la fonction, vous obtiendrez une NameError car la variable n'est pas définie.

Vous pouvez également utiliser le mot clé global pour modifier une variable globale à l'intérieur d'une fonction. Par exemple :

message = "Bonjour, le monde!"

def greet():
  global message
  message = "Bonjour, Python!"
  print(message)

greet()  ## Sortie : "Bonjour, Python!"
print(message)  ## Sortie : "Bonjour, Python!"

Dans cet exemple, la fonction greet utilise le mot clé global pour modifier la variable globale message. La fonction greet affiche la valeur modifiée de message, et la valeur de message est également modifiée en dehors de la fonction.

En général, il est recommandé d'éviter d'utiliser des variables globales car elles peuvent rendre le code plus difficile à comprendre et à maintenir. Il est généralement préférable de passer les variables à des fonctions en tant qu'arguments et de les retourner en tant que résultats plutôt que de modifier des variables globales.

Utiliser une fonction comme argument d'une autre fonction

En Python, vous pouvez passer une fonction en tant qu'argument à une autre fonction. Cela s'appelle une "fonction de premier ordre". Voici un exemple d'une fonction qui prend une autre fonction en tant qu'argument et l'appelle plusieurs fois :

def greet(name):
  print("Bonjour, " + name + "!")

def call(func, args):
  for arg in args:
    func(arg)

names = ["John", "Jane", "Bob"]
call(greet, names)  ## Sortie : "Bonjour, John!", "Bonjour, Jane!", "Bonjour, Bob!"

Dans cet exemple, la fonction call prend deux arguments : une fonction func et une liste d'arguments args. Elle appelle la fonction func avec chaque élément de la liste args en tant qu'argument.

Essayez-le vous-même : définissez une fonction appelée apply qui prend une fonction et une liste de nombres, et renvoie une nouvelle liste contenant le résultat de l'application de la fonction à chaque élément de la liste.

def square(x):
  return x ** 2

def apply(func, numbers):
  result = []
  for number in numbers:
    result.append(func(number))
  return result

numbers = [1, 2, 3, 4, 5]
squared_numbers = apply(square, numbers)
print(squared_numbers)  ## Sortie : [1, 4, 9, 16, 25]

Cette étape peut être un peu difficile, ne vous inquiétez pas si vous ne pouvez pas la résoudre. Vous pouvez la sauter et y revenir plus tard.

Résumé

Vous devriez maintenant avoir une bonne compréhension de la manière de travailler avec les fonctions Python. Voici quelques points clés :

Les fonctions Python sont des blocs de code qui peuvent être définis, appelés et réutilisés.
Vous pouvez définir une fonction en utilisant le mot clé def, suivi du nom de la fonction et des arguments.
Le corps de la fonction devrait être indenté, et vous pouvez utiliser le mot clé return pour renvoyer une valeur à partir de la fonction.
Vous pouvez spécifier les arguments de la fonction en utilisant des "arguments nommés", qui vous permettent de spécifier le nom et la valeur de l'argument lors de l'appel de la fonction.
Vous pouvez utiliser la syntaxe *args pour définir une fonction qui peut prendre un nombre variable d'arguments non nommés, et la syntaxe **kwargs pour définir une fonction qui peut prendre un nombre variable d'arguments nommés.
Vous pouvez utiliser le mot clé lambda pour créer des fonctions anonymes qui sont définies et appelées sur une seule ligne de code.
En Python, les variables définies à l'intérieur d'une fonction sont locales à la fonction et ne sont disponibles que à l'intérieur de la fonction. Les variables définies en dehors d'une fonction sont globales et sont disponibles tout au long du programme.
En général, il est recommandé d'éviter d'utiliser des variables globales et de passer les variables à des fonctions en tant qu'arguments et de les renvoyer en tant que résultats à la place.