Fonctions Python

Arguments de Fonction

Une fonction peut prendre des arguments et retourner des valeurs :

Dans l’exemple suivant, la fonction say_hello reçoit l’argument “name” et affiche une salutation :

# Define a function that takes one argument
def say_hello(name):
   print(f'Hello {name}')

# Call the function with a string argument
say_hello('Carlos')

Hello Carlos

say_hello('Wanda')

Hello Wanda

say_hello('Rose')

Hello Rose

Arguments Nommés (Keyword Arguments)

Pour améliorer la lisibilité du code, nous devons être aussi explicites que possible. Nous pouvons y parvenir dans nos fonctions en utilisant des Keyword Arguments :

# Function with multiple parameters
def say_hi(name, greeting):
   print(f"{greeting} {name}")

# Positional arguments: order matters
say_hi('John', 'Hello')

Hello John

# Keyword arguments: order doesn't matter, more readable
say_hi(name='Anna', greeting='Hi')

Hi Anna

Valeurs de Retour (Return Values)

Lors de la création d’une fonction à l’aide de l’instruction def, vous pouvez spécifier quelle doit être la valeur de retour avec une instruction return. Une instruction de retour se compose de ce qui suit :

• Le mot-clé return.

• La valeur ou l’expression que la fonction doit retourner.

# Function that returns a value using return statement
def sum_two_numbers(number_1, number_2):
   return number_1 + number_2

# Call function and store the returned value
result = sum_two_numbers(7, 8)
print(result)

15

Portée Locale et Globale (Local and Global Scope)

• Le code dans la portée globale ne peut utiliser aucune variable locale.

• Cependant, une portée locale peut accéder aux variables globales.

• Le code dans la portée locale d’une fonction ne peut pas utiliser de variables dans toute autre portée locale.

• Vous pouvez utiliser le même nom pour différentes variables si elles se trouvent dans des portées différentes. C’est-à-dire qu’il peut y avoir une variable locale nommée spam et une variable globale également nommée spam.

# Global variable: accessible everywhere
global_variable = 'I am available everywhere'

def some_function():
    print(global_variable)  # Can access global variable
    # Local variable: only exists within this function
    local_variable = "only available within this function"
    print(local_variable)

# This will raise NameError: local_variable doesn't exist in global scope
print(local_variable)

Traceback (most recent call last):
  File "<stdin>", line 10, in <module>
NameError: name 'local_variable' is not defined

L’instruction global

Si vous devez modifier une variable globale depuis l’intérieur d’une fonction, utilisez l’instruction global :

# Use 'global' keyword to modify global variable from inside function
def spam():
    global eggs  # Declare that we're modifying the global variable
    eggs = 'spam'  # This changes the global variable

eggs = 'global'
spam()  # Function modifies global variable
print(eggs)  # Prints 'spam', not 'global'

spam

Il y a quatre règles pour déterminer si une variable est dans une portée locale ou globale :

1. Si une variable est utilisée dans la portée globale (c’est-à-dire en dehors de toutes les fonctions), alors c’est toujours une variable globale.

2. S’il existe une instruction global pour cette variable dans une fonction, c’est une variable globale.

3. Sinon, si la variable est utilisée dans une instruction d’affectation dans la fonction, c’est une variable locale.

4. Mais si la variable n’est pas utilisée dans une instruction d’affectation, c’est une variable globale.

Fonctions Lambda

En Python, une fonction lambda est une fonction anonyme sur une seule ligne, qui peut avoir n’importe quel nombre d’arguments, mais ne peut avoir qu’une seule expression.

Cette fonction :

# Regular function definition
def add(x, y):
    return x + y

add(5, 3)

8

Est équivalente à la fonction lambda :

# Lambda function: anonymous function defined in one line
# Syntax: lambda arguments: expression
add = lambda x, y: x + y
add(5, 3)

8

Comme les fonctions imbriquées régulières, les lambdas fonctionnent également comme des fermetures lexicales (lexical closures) :

# Lambda closure: lambda function that captures variable from outer scope
def make_adder(n):
    return lambda x: x + n  # Lambda captures 'n' from outer function

# Create functions that add different amounts
plus_3 = make_adder(3)  # Returns lambda that adds 3
plus_5 = make_adder(5)  # Returns lambda that adds 5

plus_3(4)  # Returns 4 + 3 = 7

7

plus_5(4)

9

Liens pertinents

• \*args and \*\*kwargs explained
• Args and Kwargs
• Decorators
• Control Flow
• Basics
• Built-in Functions