Appel de fonctions

La fonction intégrée pow(x, y) permet de calculer la puissance de x élevée à y. Ici, pow est le nom de la fonction, tandis que x et y sont les arguments. Le résultat retourné est x**y. Certaines fonctions n'ont pas de valeur de retour, comme print(), qui affiche simplement un message. Définition de fonctions personnalisées

Voici un exemple de création d'une fonction pour calculer l’aire d’un cercle : ``` import math

def compute_area(radius): """ Calcule l'aire d'un cercle à partir du rayon fourni. Exemple : >>> compute_area(5.5) 95.033177771091246 """ return math.pi * (radius ** 2)

Ce code définit une fonction nommée `compute_area` prenant un paramètre `radius`. La chaîne de documentation (docstring) est encadrée par des triplets de guilemets, ce qui suit la convention Python. Pour afficher cette documentation, on peut utiliser `print(compute_area.__doc__)`. Toute fonction sans instruction `return` renvoie implicitement `None`. Portée des variables
--------------------

Les variables déclarées à l’intérieur d’une fonction sont locales et ne sont accessibles qu’à l’intérieur de celle-ci. Elles sont automatiquement supprimées après exécution. Exemple : ```
import math

def distance(x1, y1, x2, y2):
    squared_sum = (x1 - x2)**2 + (y1 - y2)**2
    return math.sqrt(squared_sum)

def area_rect(x1, y1, x2, y2):
    width = abs(x1 - x2)
    height = abs(y1 - y2)
    return width * height

Dans ces fonctions, chaque variable locale (squared_sum, width, height) n’existe que pendant leur exécution. En revanche, les variables définies en dehors de toute fonction sont globales et peuvent être lues depuis n’importe quelle partie du programme. Cependant, si une variable locale porte le même nom qu’une variable globale, elle masque celle-ci. Pour modifier une variable globale depuis une fonction, il faut utiliser le mot-clé global : ``` username = "Jack"

def greet_user(): print(f"Bonjour {username} !")

def update_name(new_value): global username username = new_value

Utilisation de la fonction principale
-------------------------------------

Il est courant de structurer un script Python autour d’une fonction `main()`, qui sert de point d’entrée : ```
def main():
    password = input("Entrez votre mot de passe : ")
    if password == "apple":
        print("Connexion réussie.")
    else:
        print("Mot de passe incorrect.")
    print("Tâches terminées.")

# L'appel principal doit être fait manuellement dans l'interpréteur

Sans appel explicite à main(), rien ne s'affichera dans l’environnement interactif. Paramètres des fonctions

Passage par référence

Python tarnsmet les arguments par référence. Cela signifie que les paramètres reçoivent une référence vers les objets réels, mais les modifications n’affectent pas l’original si l’objet est immuable. Exemple : ``` def add(a, b): return a + b

x, y = 3, 4 print(add(x, y)) # Affiche 7

Ici, `a` et `b` sont des copies des valeurs de `x` et `y`. Changer `a` ou `b` à l’intérieur de la fonction n’a aucun effet sur `x` ou `y`. ### Valeurs par défaut des paramètres

On peut définir des valeurs par défaut pour certains arguments : ```
def salutation(person, message="Salut"):
    print(f"{message}, {person} !")

salutation("Bob")                    # Salut, Bob !
salutation("Alice", "Bonjour")       # Bonjour, Alice !

Les paramètres avec valeur par défaut doivent apparaître après ceux sans valeur par défaut. ### Arguments nommés

Les arguments peuvent être passés par leur nom, indépendamment de l’ordre : ``` def shopping(location="magasin", item="pâtes", quantity="10 livres"): print(f"Vas au {location}") print(f"Et achète {quantity} de {item}.")

shopping() # Utilise toutes les valeurs par défaut shopping(item="serviettes") # Modifie seulement item shopping(quantity="une tonne", item="serviettes", location="boulangerie")

Cette flexibilité facilite la lecture et l’utilisation des fonctions. Modules
-------

Un module est un fichier `.py` contenant des fonctoins, des classes et des variables utiles à d’autres programmes. Exemple : un module `shapes.py` pour imprimer des formes simples : ```
"""Fonctions pour afficher des formes basiques."""

CHAR = "*"

def draw_rectangle(height, width):
    """Affiche un rectangle."""
    for row in range(height):
        for col in range(width):
            print(CHAR, end="")
        print()

def draw_square(side):
    """Affiche un carré."""
    draw_rectangle(side, side)

def draw_triangle(height):
    """Affiche un triangle rectangle."""
    for row in range(height):
        for col in range(row + 1):
            print(CHAR, end="")
        print()

Ce module peut être importé dans un autre script via import shapes, puis utilisé comme suit : shapes.draw_square(4). Contrairement aux scripts principaux, les modules ne contiennent généralement pas de bloc main() car ils servent de bibliothèque.