Tuto Python : notion de scope et nommage des variables

Table des matières

Introduction

Notion de Scope

• Définition
• Noms et Scopes en Python
• Scope globale
• Scope local

Nommage des variables

• Le Mot-Clé Global
• Mot clé nonlocal

Règle LEGB pour les scopes en Python

Accéder à une variable à partir de scope

• Méthode 1 : locals ()
• Méthode 2 : globals()

Exercices

• Exercice 1
• Exercice 2

Conclusion

Introduction :

Bonjour et Bienvenue dans un nouveau tutoriel Python ! Aujourd’hui, nous sommes de retour avec de nouvelles connaissances. La notion qu’on verra aujourd’hui est celle des scopes en Python. C’est une notion très intéressante qui permet de comprendre le fonctionnement des variables au sein d’un programme.

Ce cours sera très riche en exemples et exercices afin de mettre en pratique les notions acquises durant ce tutoriel.

Vous devez avoir des connaissances basiques en Python comme les classes ou les fonctions. Si ce n’est pas fait, je vous invite à jeter un coup d’œil aux tutoriels précédents.

À la fin de ce tutoriel vous apprendrez ce que sont les scopes en Python et leur fonctionnement, l’importance de cette notion en programmation, la règle LEGB et finalement  comment modifier le comportement des scopes.

Voila ! Nous pensons que tout est dit ! Commençons notre voyage.

Notion de Scope:

Définition :

Le terme Scope en Python réfère à la portée d’une variable au sein d’un programme, c’est une autre manière de dire si la variable est accessible ou non dans un bloc de code .

Le plus souvent, vous distinguerez deux types de  Scope générales :

• Scope globale : Les noms que vous définissez dans cette portée sont disponibles pour tout votre code.
• Scope locale : Les noms que vous définissez dans cette portée ne sont disponibles ou visibles que pour le code de la portée.

Les noms dans vos programmes auront la portée du bloc de code dans lequel vous les définissez. Quand vous pouvez accéder au nom d’une variable à partir d’un endroit de votre code, vous direz que le variable  est à la portée.  Si vous ne pouvez pas accéder au nom, alors vous allez dire que le nom est hors de la portée.

Noms et Scopes en Python :

Python est un langage à typage dynamique, les variables sont effectifs dès que vous leur attribuez une valeur pour la première fois. Par ailleurs, la même chose pour les classes et fonctions lorsqu’on les définis en utilisant def ou class . Enfin, les modules existent après leur importation. En résumé, vous pouvez créer des noms Python via l’une des opérations suivantes :

Toutes ces opérations créent ou, dans le cas d’affectations, mettent à jour de nouveaux noms Python parce qu’ils attribuent tous un nom à une variable, constante, fonction, classe, instance, module ou autre objet Python.

Par exemple, si vous assignez une valeur à un nom à l’intérieur d’une fonction, alors ce nom aura une portée Python locale. En revanche, si vous assignez une valeur à un nom en dehors de toutes les fonctions, au niveau supérieur d’un module , alors ce nom aura une portée globale en Python .

Scope globale

Les variables globales sont celles qui sont définies et déclarées en dehors de toute fonction et ne sont spécifiées à aucune fonction. Ils peuvent être utilisés par n’importe quelle partie du programme.

Exemple :

Dans cet exemple, la fonction f utilise la variable globale s

Syntaxe :

# Cette fonction utilise la variable globale s
def f():
print(s)
# scope global
s = "J'aime Python"
f()

Résultat de l’exécution :

Exemple :

Dans cet exemple on définit une variable globale a que nous allons utiliser pour plusieurs fonctions .

Syntaxe :

a=3
def fonction1(x):
return x + a
def fonction2 (x):
return x - a
def fonction3 (x,y):
return x - a*y
print (fonction1(3))
print (fonction2(3))
print (fonction3(3,2))

Résultat de l’exécution :

L’exécution montre bien que la variable a est reconnue et utilisée par les trois fonctions car elle a été définie globalement.

Exemple : calcul des poids

Ici , on veut définir g=9.887 comme variable globale de pesanteur afin de pouvoir calculer le poids des individus en fonction de leurs masses.

Syntaxe :

g=9.887
def calcul_poids(m):
return m*g
print (calcul_poids(75))
print (calcul_poids(87))
print (calcul_poids(52))

Résultat de l’exécution :

Scope local

Par défaut, les paramètres et les noms que vous assignez à l’intérieur d’une fonction n’existent que dans la fonction ou le périmètre local associé à l’appel de fonction. L’exemple suivant vous montre que les variables définies à l’intérieur ne sont pas accessibles.

Exemple :

Fonction qui calcule le cube d’un nombre.

Syntaxe :

def cube(a):
... resultat1= a ** 3
... print (f'le cube de {a} est: {resultat}')
cube(3)
print (resultat1)

Résultat de l’exécution :

Exemple :

Dans cet exemple, on veut définir une variable local salaire_brut qui ne sera accesible qu’à l’intérieur de la fonction.

Syntaxe :

def salaire_net ():
salaire_brut=10000
salaire_net =salaire_brut - ((salaire_brut*40)/100)
return salaire_net

Résultat de l’exécution :

Et voilà ! Comme prévu le programme ne connait pas la variable salaire_brut.

Exemple : fonction à l’intérieur d’une fonction

Dans cet exemple, on veut définir une fonction mafonc() qui affiche le message  contenu dans la variable x . Cependant , c’est la fonction mafoncinterne() qui doit faire le travail . Donc , on va la définir puis l’appeler à l’intérieur de notre fonction de base .

Syntaxe :

def mafonc():
x = 'Bonjour ! Bienvenue dans ce nouveau tutoriel ! '
def mafoncinterne ():
print(x)
mafoncinterne ()
mafonc()

mafoncinterne()

Résultat de l’exécution :

La fonction mafoncinterne () n’est pas accessible en dehors de la fonction principale où elle a été définie .

Nommage des variables :

Si vous opérez avec le même nom de variable à l’intérieur et à l’extérieur d’une fonction, Python les traitera comme deux variables distinctes, une disponible dans la portée globale (en dehors de la fonction ) et une disponible dans la portée locale (à l’intérieur de la fonction ) .

Exemple :

La fonction va afficher la variable locale et le code la variable globale .

Syntaxe :

x = 30
def mafonc ():
x = 20
print(x)
mafonc()
print(x)

Résultat de l’exécution :

Le Mot-Clé Global :

Imaginons que vous voulez créer ou modifier une variable globale au sein d’une scope locale. Que faire ? Heureusement, le mot-clé global permet de rendre cette variable globale .

Exemple :

Syntaxe :

def mafonct ():
global x
x = 300
mafonct()
print(x)

Résultat de l’exécution :

Et voilà , la variable est accessible même en dehors de la fonction !

Vous pouvez aussi  utiliser le mot-clé global si vous voulez faire un changement à une variable globale dans une fonction .

Exemple :

Dans cet exemple , on veut modifier la valeur d’une variable globale x mais de l’intérieur de la fonction en utilisant le mot global .

Syntaxe :

x = 300
def mafonct ():
global x
x = 200
mafonct ()
print(x)

Résultat de l’exécution :

Effectivement, L’exécution retourne 200 car la valeur de x a été modifiée.

Exemple :

Dans cet exemple, on va modifier la valeur de la variable t .

Syntaxe :

# Cette fonction modifie la variable globale ‘t’
def f():
global t
print(t)
t = "Ce tutoriel est très instruisant ! "
print(t)
# Global Scope
t = "Python es intéressant!"
f()
print(t)

Résultat de l’exécution :

Exemple :

Voici un exemple complet pour bien comprendre la portée d’une variable dans un programme et comment on peut la modifier.

Syntaxe :

# Programme Python pour comprendre la scope d'une variable
var = 2
# Cette fonction utilise la 'var' global car il n'ya pas de 'var' local
def f():
print (" à l'intérieur de f() : ", var)
# la variable 'var' est redéfinie autant que locale Variable 'a'
def g():
var = 3
print ("a l'intérieur de g() : ", var)
# On utilise le mot clé global pour modifier 'var'
def h():
global var
var = 4
print ("à l'intérieur de h() : ", var)
# Global scope
print ('global : ', var)
f ()
print ('global : ', var)
g ()
print ('global : ', var)
h ()
print ('global : ', var)

Résultat de l’exécution :

Mot clé nonlocal :

En Python, le mot-clé nonlocal est utilisé dans le cas de fonctions imbriquées. Ce mot-clé fonctionne comme le global, mais plutôt que global, ce mot-clé déclare une variable pour pointer vers la variable de la fonction d’enclenchement externe, dans le cas de fonctions imbriquées.

Voici un exemple pour bien comprendre cette notion .

Exemple :

Nous voulons tester ce que retourne le programme si on utilise le mot-clé nonlocal sur une variable.

Syntaxe :

# Programme Python pour démontrer l'intérêt du mot-clé nonlocal
print ("Valeur de a en utilisant non locale est : ", end ="")
def externe():
var = 6
def interne():
nonlocal var
var = 11
interne()
print (var)
externe()
print ("Valeur de a sans utiliser non locale est : ", end="")
def externe():
var = 6
def interne():
var = 11
interne()
print (var)
externe()

Résultat de l’exécution :

Le concept de scope détermine comment les variables et les noms sont recherchés dans votre code. Il détermine la visibilité d’une variable dans le code. La portée d’un nom ou d’une variable dépend de l’endroit dans votre code où vous créez cette variable. Le concept de portée Python est généralement présenté en utilisant une règle connue sous le nom de règle LEGB. Nous allons voir cette règle en détail dans la section  qui suit.

Règle LEGB pour les scopes en Python :

En Python, la règle LEGB est utilisée pour décider de l’ordre dans lequel les espaces de noms doivent être recherchés pour la résolution de Scope.

Les Scopes sont listés en termes d’hiérarchie selon l’ordre suivant :

• Local (L) : Définies à l’intérieur d’une fonction ou classe.
• Enclosed (E) : Fonctions d’enclenchement définies à l’intérieur (concept de fonction imbriquée)
• Global (G) : Défini au niveau le plus élevé .
• Built-in (B) : Noms réservés dans les modules intégrés Python.

La règle LEGB est une sorte de procédure de recherche de noms, qui détermine l’ordre dans lequel Python recherche les noms. Par exemple, si vous référencez un nom donné, alors Python cherchera ce nom séquentiellement dans la portée locale, englobant, globale et intégrée. Si le nom existe, alors vous obtiendrez la première occurrence de celui-ci. Sinon, vous obtiendrez une erreur.

Accéder à une variable à partir de scope :

Dans cette section, nous allons voir comment accéder à une variable dans un code en utilisant deux méthodes différentes :

Méthode 1 : locals ()

C’est une fonction qui stocke les valeurs de toutes les variables dans le périmètre local de la fonction si dans une fonction ou du périmètre global si à l’extérieur.

Exemple :

Syntaxe :

# initialisation de la variable
var = "Python est le meilleur"
# On affiche la variable originale
print ("la variable originale est : " +
var
)
# Accès à la valeur variable du périmètre de code
# utilisation de locals()
resultat= locals()['var']
# Affichage du résultat
print ("Variable résultante après l'utilisation de locals() : " + resultat)

Résultat de l’exécution :

Méthode 2 : globals()

C’est encore une autre fonction qui maintient un dictionnaire de variables de portée globale.

Exemple :

Voici un exemple qui démontre l’utilisation de la méthode globals() .

Syntaxe :

# initialisation de la variable
var = "Python est le meilleur"
# On affiche la variable originale
print ("la variable originale est : " +
var)
# Accessing variable value from code scope
# using globals
resultat = globals()['var']
# printing result
print (" la Variable résultante après l'utilisation de globals(): " +var)

Résultat de l’exécution :

Nous allons passer à quelques exercices d’applications pour être sûr que vous avez bien compris !

Exercices :

Exercice 1 :

Ecrivez une fonction Plus6() qui ajoute 6 à chaque paramètre en entrée de la fonction . La variable 6 doit être globale et x locale.

Solution :

Synyaxe :

def plus6(x):
global num
num=6
res=num+x
return x
plus6(10)

Résultat de l’exécution :

Exercice 2 :

Essayez de deviner la sortie de ce programme !

Syntaxe :

# Programme Python pour comprendre la scope d'une variable
var = 20
# Cette fonction utilise la 'var' global car il n'ya pas de 'var' local
def f ():
print (" à l'intérieur de f () : ", var)
# la variable 'var' est redéfinie autant que locale Variable 'a'
def g ():
var = 30
print ("a l'intérieur de g() : ", var)
# On utilise le mot clé global pour modifier 'var'
def h():
global var
var = 40
print ("à l'intérieur de h() : ", var)
# Global scope
print ('global : ', var)
f ()
print ('global : ', var)
g ()
print ('global : ', var)
h ()
print ('global : ', var)

Résultat de l’exécution :

Conclusion :

Voila ! Nous sommes arrivés à la fin de ce tutoriel. Nous supposons que vous avez parfaitement compris la notion de scope et que vous savez maintenant gérer vos variables au sein d’un programme. En tout cas, plusieurs autres notions aussi intéressantes que celle d’aujourd’hui vous attendent. Ne lâchez rien ! Continuez sur ce chemin. À un très prochain tutoriel !