Introduction

Les variables héritées mais impossible de les affecter

Vous avez probablement déjà affronté ce problème : vous essayez d’accéder à une variable définie dans un contexte supérieur, mais vous obtenez une erreur UnboundLocalError. Cela peut être particulièrement frustrant lorsqu’il s’agit de fonctions internes ou de closures. Dans cet article, nous allons examiner les raisons derrière ce comportement et explorer comment utiliser des fonctionnalités avancées de Python pour résoudre ce problème.

1. Variables non locales

Lorsque vous définissez une fonction interne dans une autre fonction, les variables définies dans la fonction interne sont considérées comme des variables locales. Cela signifie que vous ne pouvez pas accéder à ces variables depuis l’extérieur de la fonction interne. Par exemple :

def makeInc(x):
    def inc(y):
        # x est une variable locale et ne peut pas être modifiée ici
        x += y
        return x
    return inc

incOne = makeInc(1)
incOne(5)  # UnboundLocalError: local variable 'x' referenced before assignment

Pour résoudre ce problème, vous pouvez utiliser la déclaration nonlocal pour indiquer que la variable doit être considérée comme une variable non locale.

def makeInc(x):
    def inc(y):
        nonlocal x  # maintenant, nous pouvons modifier x
        x += y
        return x
    return inc

incOne = makeInc(1)
incOne(5)  # retourne 6

2. Paramètres nommés

Depuis Python 3.x, vous pouvez utiliser les paramètres nommés pour spécifier que certains arguments doivent être passés en tant que dictionnaires ou de valeurs clé-valeur. Par exemple :

def f(*a, b):
    pass

f(1, 2, 3)  # TypeError: f() missing 1 required keyword-only argument: 'b'

Pour résoudre ce problème, vous pouvez utiliser la syntaxe de paramètres nommés pour spécifier que certains arguments doivent être passés en tant que valeurs clé-valeur.

def f(a, b, *, c):
    pass

f(1, 2, c=3)  # pas d'erreur

3. Fonctions internes

Les fonctions internes sont des fonctionnalités puissantes de Python qui permettent de définir des fonctions à l’intérieur d’autres fonctions. Les variables définies dans une fonction interne sont considérées comme des variables locales, mais vous pouvez utiliser la déclaration nonlocal pour accéder aux variables non locales.

def fibonacci(n):
    def step(a,b):
        return b, a+b
    a, b = 0, 1
    for i in range(n):
        a, b = step(a, b)
    return a

print(fibonacci(10))  # imprime la séquence de Fibonacci jusqu'à 10

4. Limites de récursion

Depuis Python 3.x, il y a une limite à la profondeur de récursion qui peut être atteinte avant d’obtenir un RuntimeError. Vous pouvez utiliser la fonction sys.setrecursionlimit() pour modifier cette limite.

import sys

def cursing(depth):
    try:
        cursing(depth + 1)
    except RuntimeError as RE:
        print('Je me suis récursé {} fois !'.format(depth))

sys.setrecursionlimit(2000)
cursing(0)  # imprime le nombre de fois où la fonction s'est récursée

5. Lambdas

Les lambdas sont des fonctions anonymes qui peuvent être définies en une seule ligne. Vous pouvez utiliser les lambdas pour créer des fonctions récursives.

f = lambda n: 1 if n == 0 else n * f(n-1)
print(f(5))  # imprime la factorielle de 5

6. Définition de fonctions

La définition d’une fonction en Python est simple : vous définissez le nom de la fonction, suivie des paramètres entre parenthèses.

def divide(dividend, divisor):
    print(dividend / divisor)

divide(10, 2)  # imprime 5.0

7. Définition de fonctions avec arguments

Vous pouvez définir des fonctions avec des arguments en spécifiant les paramètres entre parenthèses.

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

print(add(2, 3))  # imprime 5

8. Définition de fonctions avec arguments variables

Vous pouvez définir des fonctions qui acceptent un nombre variable d’arguments en utilisant la syntaxe *args ou **kwargs.

def unpacking(a, b, c=45, d=60, *args, **kwargs):
    print(a, b, c, d, args, kwargs)

unpacking(1, 2)  # imprime 1 2 45 60 () {}

Nous avons vu dans cet article comment utiliser les fonctionnalités avancées de Python pour résoudre des problèmes courants en programmation. Nous avons exploré la déclaration nonlocal pour accéder aux variables non locales, les paramètres nommés pour spécifier que certains arguments doivent être passés en tant que valeurs clé-valeur, les fonctions internes pour définir des fonctions à l’intérieur d’autres fonctions, les limites de récursion pour éviter les erreurs de récursion, les lambdas pour créer des fonctions récursives, la définition de fonctions avec arguments et des arguments variables. Nous espérons que cet article vous aura été utile !