C'est un exemple qui montre comment se référer à différentes zones et espaces de noms et comment les mots-clés globaux et non locaux influencent le lien de la variable :
def scope_test() :
def do_local() :
spam = "spam local".
def do_non-local() :
spam non local
spam = "spam non local".
def do_global() :
spam global
spam = "spam global".
spam = "spam test".
do_local()
print("After local assignment :", spam)
non local()
print("Après une affectation non locale :", spam)
make_global()
print("After global assignment :", spam)
purpose_test()
print('Dans le cadre global:', spam)
La sortie du code exemple est :
.... code bloc:::::: : aucun
Après l'affectation locale : essayez le spam
Après une affectation non locale : spam non local
Après l'affectation globale : spam non local
Dans le contexte mondial : le spam mondial
Notez que l'affectation locale (qui est l'affectation par défaut) n'a pas modifié le lien spam dans le scope_test.
Vous pouvez également voir qu'il n'y avait pas de lien de spam avant l'affectation globale.
Une première considération de l
Les classes introduisent une nouvelle syntaxe, trois nouveaux types d'objets et une nouvelle sémantique.
Syntaxe de la définition de classe
La forme la plus simple d'une définition de classe ressemble à ceci :
ClassName classe :
<déclaration - 1>>>
.
.
.
<instructions -N> <instructions -N>instructions -N> Instructions
Les définitions de classes doivent être exécutées en tant que définitions de fonctions (instructions def) avant de prendre effet. (Il serait concevable de placer une définition de classe dans une branche d'une instruction if ou dans une fonction.)
En pratique, les instructions dans une définition de classe sont généralement des définitions de fonctions, mais d'autres instructions sont autorisées et parfois utiles - nous y reviendrons plus tard. Les définitions de fonctions au sein d'une classe ont généralement une liste d'arguments spéciaux prescrits par la méthode qui appelle les conventions - ceci sera expliqué plus loin.
Lorsque vous saisissez une définition de classe, un nouvel espace de nommage est créé et utilisé comme champ d'application local - de sorte que les affectations aux variables locales prennent effet dans ce nouvel espace de nommage. Les définitions de fonction lient également le nom de la nouvelle fonction.
Si vous quittez normalement une définition de classe (en la terminant), un objet de classe est créé. La zone de validité locale d'origine (qui était active avant la saisie de la définition de classe) est restaurée et l'objet de classe est lié au nom spécifié dans l'en-tête de définition de classe (ClassName dans notre exemple).
Objets de classe
Les objets de classe supportent deux types d'opérations : l'instanciation.
Les références d'attributs utilisent la syntaxe normale utilisée pour toutes les références d'attributs en Python : obj.name. Les attributs valides sont tous les noms qui se trouvaient dans l'espace de noms de classe lorsque l'objet de classe a été créé. Si la définition de classe était comme ça :
classe MyClass :
Un exemple simple de classe"""""""""".
i = 12345
def f(auto) :
retour'Hello World' retour'Hello World
alors MyClass.i et MyClass.f sont des références d'attributs valides qui retournent un objet entier ou une fonction. Les affectations aux attributs de classe sont également possibles, de sorte que la valeur de MyClass.i peut être modifiée par affectation. __doc__ est aussi un attribut valide qui contient la chaîne doc appartenant à la classe : "A simple example class".
L'instanciation de classe utilise la notation de fonction. Imaginons que l'objet de classe est une fonction sans paramètres qui retourne une nouvelle instance de classe. Par exemple (dans le cas de la classe ci-dessus) :
x = MyClasse()
Ceci crée une nouvelle instance de la classe et affecte cet objet à la variable locale x.
L'opération d'instanciation ("appel" d'un objet de classe) crée un objet vide. Beaucoup de classes aiment créer des objets d'instance qui ont été adaptés à un état initial spécifique. Par conséquent, une classe peut définir une méthode spéciale appelée __init__((() comme suit :
def __init__(self) :
self.data = []
Si une classe définit une méthode __init__(), l'instance de classe appelle automatiquement __init__(() pour la nouvelle instance de la classe créée. Dans cet exemple, une nouvelle instance initialisée peut être obtenue comme suit :
x = MyClasse()
Bien sûr, la méthode __init__(() peut avoir des arguments pour plus de flexibilité. Dans ce cas, les arguments passés à l'opérateur d'instanciation de classe sont passés à __init__(). Par exemple :
>>> Complexe de classe :
.......def __init__(self, realpart, imagpart) :
... self.r = part réelle
... self.i = imagpart
...
>>> x = Complexe(3.0, -4.5)
>>> x.r, x.r, x.r, x.i
(3.0, -4.5)
