Les fonctions

Une fonction encapsule un bloc d'instructions qui peut être appelé plusieurs fois. Elle peut avoir des paramètres et retourner un résultat. En Python, nous déclarons une fonction avec le mot-clé def, suivi de son nom et de ses paramètres entre parenthèses. Son corps est délimité par l'indentation.

Déclarer et appeler une fonction

Voici une méthode implémentée en C# :

static int Add(int number1, int number2)
{
    return number1 + number2;
}

int result = Add(3, 5);

En Python, la fonction équivalente s'implémente de la manière suivante :

def add(number1, number2):
    return number1 + number2

result = add(3, 5)
print(result)  # Affiche 8

L'utiliation du mot-clé return termine l'exécution de la fonction et retourne le résultat. Une fonction sans instruction return, ou utilisant return sans préciser de valeur, retourne None.

Par convention, les noms des fonctions et des paramètres utilisent le style snake_case, par exemple calculate_total.

Annoter les types

Python permet d'indiquer les types attendus pour les paramètres et le résultat :

def add(number1: int, number2: int) -> int:
    return number1 + number2

Contrairement aux types déclarés en C#, ces annotations ne sont pas vérifiées. Elles facilitent la lecture du code et permettent à des outils d'analyse de code (tels que Mypy) de détecter des incohérences.

Définir des paramètres facultatifs

Comme en C#, un paramètre peut posséder une valeur par défaut :

def greet(name: str, message: str = "Bonjour") -> str:
    return f"{message} {name}"

print(greet("James"))             # Bonjour James
print(greet("James", "Bonsoir"))  # Bonsoir James

Les paramètres obligatoires précèdent toujours les paramètres possédant une valeur par défaut dans cette forme de déclaration.

Attention : évitez les objets mutables, comme les listes, en valeur par défaut. Cette valeur est créée une seule fois lors de la définition de la fonction et partagée entre les appels. Utilisez plutôt None, puis créez l'objet dans le corps de la fonction.

Utiliser des paramètres nommés

Les valeurs des paramètres peuvent être transmises via leur nom, facilitant la lecture des appels de fonctions :

print(greet(message="Bonsoir", name="James"))

En C#, la syntaxe équivalente utilise le caractère : pour les arguments nommés ; Python utilise le caractère =.

Retourner plusieurs valeurs

Une fonction peut retourner plusieurs valeurs regroupées dans un tuple. Voici une fonction qui retourne l'addition et la soustraction de deux nombres :

def calculate(number1: int, number2: int) -> tuple[int, int]:
    return number1 + number2, number1 - number2

total, difference = calculate(8, 3)

print(total)       # 11
print(difference)  # 5

Dans cet exemple, nous récupérons les éléments du tuple dans deux variables, de manière analogue à la déconstruction d'un tuple en C#.

Passage des paramètres par référence

En C#, le mot-clé ref permet à une méthode de modifier directement la variable fournie par l'appelant (pour les types valeurs et le type string) :

static void Increment(ref int value)
{
    value++;
}

int number = 5;
Increment(ref number);

Console.WriteLine(number); // Affiche 6

Python ne possède pas d'équivalent direct de ref. Un paramètre désigne initialement le même objet que l'argument fourni. Toutefois, affecter une nouvelle valeur au paramètre ne modifie pas la variable de l'appelant :

def increment(value: int) -> None:
    value += 1

number = 5
increment(number)

print(number)  # Affiche 5

Les entiers sont immuables. L'instruction value += 1 associe ici le paramètre local à un autre entier, sans modifier number.

En revanche, une fonction peut modifier le contenu d'un objet mutable telle qu'une liste. Cette modification est valide en dehors de l'appel à la fonction :

def add_number(values: list[int]) -> None:
    values.append(3)

numbers = [1, 2]
add_number(numbers)

print(numbers)  # Affiche [1, 2, 3]