Numérique et Sciences Informatiques1ère

Portée et variables
Exercices corrigés

Maîtrisez la portée des variables : locale, globale, portée de bloc et shadowing grâce à ces 5 exercices détaillés.

Concepts & Exercices
Variable → Portée → Accès
Flux d'accès
Locale
def f(): x = 5
Globale
x = 5 en dehors de f()
Non locale
nonlocal x
🔄
Exercice 1
Identifier les variables locales
Exercice 2
Comprendre les variables globales
Exercice 3
Gérer le shadowing de variables
Exercice 4
Utiliser le mot-clé global
Exercice 5
Analyser la portée imbriquée
Corrigé : Exercices 1 à 3
1 Variables locales
Définition :

Variable locale : Variable définie à l'intérieur d'une fonction et accessible uniquement dans cette fonction.

Méthode d'identification :
  1. Rechercher les variables définies à l'intérieur des fonctions
  2. Vérifier si elles sont déclarées avec global ou nonlocal
  3. Confirmer qu'elles ne sont pas accessibles en dehors de la fonction
  4. Comprendre leur durée de vie pendant l'exécution de la fonction
def fonction_locale(): # Variable locale x = 10 y = 20 resultat = x + y print(f"Dans la fonction: x={x}, y={y}, resultat={resultat}") return resultat # Tentative d'accès à une variable locale en dehors de la fonction print("Appel de la fonction:") resultat_fonction = fonction_locale() # Ceci provoquerait une erreur: NameError # print(f"Variable x hors de la fonction: {x}") # x n'est pas accessible ici print(f"Résultat de la fonction: {resultat_fonction}")
Type de variable Portée Accessible dans
Locale Fonction À l'intérieur de la fonction
Paramètre Fonction À l'intérieur de la fonction
Compteur de boucle Boucle À l'intérieur de la boucle
Étape 1 : Définition dans la fonction

Les variables x, y et resultat sont définies dans la fonction

Étape 2 : Accès dans la fonction

Elles sont accessibles à l'intérieur de la fonction où elles sont définies

Étape 3 : Accès en dehors

Elles ne sont pas accessibles en dehors de la fonction

Réponse finale :

Variables x, y et resultat sont locales à la fonction fonction_locale()

Règles appliquées :

Portée limitée : Les variables locales ne sont accessibles que dans leur fonction

Durée de vie : Elles existent seulement pendant l'exécution de la fonction

Isolation : Elles sont isolées du reste du programme

2 Variables globales
Définition :

Variable globale : Variable définie au niveau du module et accessible dans toutes les fonctions.

# Variable globale compteur = 0 def incrementer(): global compteur # Permet de modifier la variable globale compteur += 1 print(f"Dans la fonction: compteur={compteur}") def lire_compteur(): # Lecture de la variable globale print(f"Depuis lire_compteur: compteur={compteur}") def fonction_locale(): # Variable locale qui masque la globale compteur = 5 print(f"Dans fonction_locale: compteur={compteur}") # Utilisation des fonctions print(f"Avant: compteur={compteur}") incrementer() lire_compteur() fonction_locale() print(f"Après: compteur={compteur}")
Étape 1 : Définition globale

La variable compteur est définie au niveau du module

Étape 2 : Accès en lecture

Les fonctions peuvent lire la variable globale sans mot-clé spécial

Étape 3 : Accès en écriture

Pour modifier une variable globale, on doit utiliser le mot-clé global

Étape 4 : Shadowing

Une variable locale peut masquer une variable globale du même nom

Réponse finale :

Variable globale accessible en lecture partout, modifiable avec le mot-clé global

Règles appliquées :

Lecture : Les variables globales sont accessibles en lecture dans toutes les fonctions

Écriture : Pour modifier une variable globale, utiliser le mot-clé global

Shadowing : Une variable locale masque la variable globale du même nom

3 Shadowing de variables
Définition :

Shadowing : Situation où une variable locale a le même nom qu'une variable dans une portée externe, la masquant temporairement.

# Variable globale message = "Global" def fonction_externe(): # Variable de portée englobante message = "Englobante" def fonction_interne(): # Variable locale qui masque la variable englobante message = "Locale" print(f"Dans fonction_interne: {message}") # Accès à la variable englobante def fonction_plus_interne(): nonlocal message # Fait référence à la variable englobante message = "Modifié dans fonction_plus_interne" fonction_plus_interne() print(f"Après fonction_plus_interne: {message}") print(f"Avant fonction_interne: {message}") fonction_interne() print(f"Après fonction_interne: {message}") print(f"Avant fonction_externe: {message}") fonction_externe() print(f"Après fonction_externe: {message}")
Étape 1 : Compréhension des portées

Identifiez la variable globale, englobante et locale avec le même nom

Étape 2 : Analyse du shadowing

Chaque fonction a sa propre version de message

Étape 3 : Utilisation de nonlocal

Le mot-clé nonlocal permet de modifier la variable englobante

Réponse finale :

Shadowing correctement géré avec nonlocal pour accéder à la portée englobante

Règles appliquées :

Shadowing : Une variable locale masque une variable de portée externe

nonlocal : Permet d'accéder à une variable de portée englobante

global : Permet d'accéder à une variable de portée globale

Corrigé : Exercices 4 à 5
4 Mot-clé global
Définition :

Mot-clé global : Permet à une fonction de modifier une variable définie au niveau du module.

# Variable globale total = 0 liste_globale = [] def ajouter_valeur(valeur): """Ajoute une valeur au total global""" global total, liste_globale total += valeur liste_globale.append(valeur) print(f"Dans la fonction: total={total}, liste={liste_globale}") def fonction_sans_global(): """Essaie de modifier la variable globale sans 'global'""" # Cela crée une variable locale, ne modifie pas la globale total = 100 print(f"Dans fonction_sans_global: total={total}") def fonction_modifie_globale(): """Modifie correctement la variable globale""" global total total *= 2 print(f"Dans fonction_modifie_globale: total={total}") # Exécution print(f"Avant: total={total}, liste={liste_globale}") ajouter_valeur(10) ajouter_valeur(20) fonction_sans_global() print(f"Après fonction_sans_global: total={total}") fonction_modifie_globale() print(f"Après fonction_modifie_globale: total={total}")
Étape 1 : Déclaration avec global

Utilisez global avant le nom de la variable dans la fonction

Étape 2 : Modification de la variable

La variable globale est modifiée, pas une copie locale

Étape 3 : Conséquences

Les modifications persistent après la fin de l'exécution de la fonction

Réponse finale :

Variable globale modifiée correctement avec le mot-clé global

Règles appliquées :

global : Nécessaire pour modifier une variable globale dans une fonction

Lecture : Pas besoin de global pour lire une variable globale

Listes/objets : Les modifications internes aux objets mutables affectent la variable globale

5 Portée imbriquée
Définition :

Portée imbriquée : Situation où une fonction est définie à l'intérieur d'une autre fonction, créant des portées englobantes.

def fonction_externe(x): """Fonction externe avec variable englobante""" variable_englobante = x def fonction_intermediaire(y): """Fonction intermédiaire""" variable_intermediaire = y def fonction_interne(z): """Fonction interne accédant aux portées externes""" variable_locale = z # Accès à toutes les portées possibles resultat = variable_englobante + variable_intermediaire + variable_locale print(f"Englobante: {variable_englobante}") print(f"Intermédiaire: {variable_intermediaire}") print(f"Locale: {variable_locale}") print(f"Résultat: {resultat}") # Modification avec nonlocal nonlocal variable_intermediaire variable_intermediaire *= 10 return resultat resultat_intermediaire = fonction_interne(3) print(f"Après fonction_interne, intermédiaire: {variable_intermediaire}") return resultat_intermediaire resultat_externe = fonction_intermediaire(2) print(f"Après fonction_intermediaire, englobante: {variable_englobante}") return resultat_externe # Exécution resultat_final = fonction_externe(1) print(f"Résultat final: {resultat_final}")
Étape 1 : Compréhension de l'imbrication

Identifiez les différentes couches de portées: externe, intermédiaire, interne

Étape 2 : Accès aux portées externes

La fonction interne peut accéder aux variables des portées externes

Étape 3 : Utilisation de nonlocal

Le mot-clé nonlocal permet de modifier une variable de portée englobante

Réponse finale :

Accès correct aux différentes portées avec gestion appropriée de nonlocal

Règles appliquées :

LEGB : Règle de recherche des variables (Local, Englobante, Globale, Built-in)

nonlocal : Permet de modifier une variable de portée englobante

Accès : Une fonction interne peut lire les variables des portées externes

Cours bien détaillé
LEGB: Local → Englobante → Globale → Built-in
Règle de recherche des variables
🎯
Local (L) : Variables définies dans la fonction actuelle.
📏
Englobante (E) : Variables dans la portée englobante (fonctions imbriquées).
📐
Globale (G) : Variables définies au niveau du module.
📝
Built-in (B) : Noms prédéfinis dans Python (len, print, etc.).
💡
Conseil : Préférez les variables locales pour éviter les effets de bord
🔍
Attention : Les variables globales peuvent causer des bugs difficiles à détecter
Astuce : Utilisez des paramètres pour transmettre des données entre fonctions
📋
Méthode : Limitez l'utilisation de global et nonlocal au strict nécessaire
Vérification : Utilisez des outils d'analyse pour détecter les problèmes de portée
Bonnes pratiques :
  • Préférez les variables locales : Moins de risques de conflits
  • Documentez les variables globales : Expliquez pourquoi elles sont nécessaires
  • Utilisez des constantes globales : Pour les valeurs fixes
  • Limitez l'imbrication : Trop de niveaux rend le code difficile à suivre
  • Testez la portée : Vérifiez que vos variables se comportent comme prévu
Règles de portée :
  • Les variables locales ne sont accessibles que dans leur fonction
  • Les variables globales sont accessibles partout
  • Le mot-clé global est nécessaire pour modifier une variable globale
  • Le mot-clé nonlocal permet d'accéder à une variable de portée englobante
  • Le shadowing masque temporairement une variable de portée externe
global
Accès à la portée globale
nonlocal
Accès à la portée englobante
LEGB
Ordre de recherche
Portée et variables Structure du code