Discussion :

[rogorde]

bonjour voila j'ai appris que les variable instancié dans des fonction etais locaux ( supprimé avec la sortie de la fonction ), je suis entré dans la programmation orienté objet et je vois que les variable sont déclaré dans la methode d'initialisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
def __init__(self): 
 
        self.nom = "Dupont"
        self.prenom = "Jean" # Quelle originalité
        self.age = 33 # Cela n'engage à rien
        self.lieu_residence = "Paris"+

elle est une fonction non?

[fred1599]

bonjour voila j'ai appris que les variable instancié dans des fonction etais locaux ( supprimé avec la sortie de la fonction )

Rien compris...

je suis entré dans la programmation orienté objet et je vois que les variable sont déclaré dans la methode d'initialisation :

Tu es entré un peu vite je pense, en POO on parle d'attributs.

Lorsqu'on crée une instance d'une classe, c'est un objet qui est créé.

Le __init__(self, ...) est en fait un constructeur d'objet appelé lors de l'instanciation avec les paramètres se trouvant dans ce constructeur.


Les autres fonctions que tu crées dans ta classe ne sont en réalité pas des fonctions mais des méthodes en POO qui représentent l'action de l'objet.

[wiztricks]

Salut,

bonjour voila j'ai appris que les variable instancié dans des fonction etais locaux ( supprimé avec la sortie de la fonction)

Si vous écrivez:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def init():
       nom = "Dupont"
       prenom = "Jean" # Quelle originalité
       age = 33 # Cela n'engage à rien

nom, prenom et age sont des "variables" "locales" à init.
Leur portée (durée de vie) se réduit à l'activation de la fonction: lorsque la fonction retourne à l'appelant, ces variables n'existent plus.

En gros, les fonctions n'ont pas de mémoire: on les appellera avec des paramètres et retourneront un "objet" (ou rien du tout) fonction de ces paramètres.

je suis entré dans la programmation orienté objet et je vois que les variable sont déclaré dans la methode d'initialisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
def __init__(self): 
 
        self.nom = "Dupont"
        self.prenom = "Jean" # Quelle originalité
        self.age = 33 # Cela n'engage à rien
        self.lieu_residence = "Paris"+

elle est une fonction non?

Ici, la syntaxe introduit un "self" qui va modifier la portée des assignations.
On dira que __init__ est une fonction associée (bound) à l'instance d'un objet, matérialisé par "self". De ce fait, nom, prenom, age,... ne sont plus variables locales de la fonction "__init__" mais attributs de l'objet "self".
Lorsque la méthode __init__ rend le contrôle à l'appelant, les valeurs (objets) associés aux attributs nom, prenom, age,... resteront mémorisés.

C'est cette mémoire qui fait la différence entre "objet" et "fonction".

Simplifions (avant de compliquer)...
Imaginons un objet qui retourne le nombre suivant. Pour faire simple, on va écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> class Counter:
...    def __init__(self, start=0):
...        self.value = start
...    def next(self):
...        self.value += 1
...        return self.value
...

L'objet "Counter" mémorise la valeur d'un entier et les appels à next retournent la valeur suivante.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> c = Counter(0)
>>> c.next()
1
>>> c.next()
2
>>> c.next()
3

Une fonction étant "sans mémoire" impossible de faire cela avec une fonction sans passer par une variable globale:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
value = 0
def counter():
     global value
     value += 1
     return value

Un des intérêts de la classe sera de pouvoir fabriquer plusieurs Counter qui retourneront leur valeur propre (suivant le nombre d'appels) alors qu'avec une fonction, il faudrait multiplier les variables "globales" et donner une indication de celle dont on parle.
exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def next(ctx):
     ctx.value += 1
     return ctx.value

Dans ce cas, next est une fonction (et pas une méthode) qui s'applique à un objet particulier ctx qui doit avoir un attribut "value" qui pourrait être construit via:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class Context:
    def __init__(self, start)
         self.value = start

Il y a donc un intermédiaire entre fonction et méthode qu'on pourrait appeler "action" qui s'applique à un objet particulier (alors que la méthode est "bound" à l'objet). Mais la frontière est light car on pourrait transformer l'action en méthode ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class Context:
    def __init__(self, start)
         self.value = start
    next = next

Compliquons les choses!
Les classes ne sont pas les seuls objets Python "à mémoire". Avec l'exemple de Counter, nous pourrions passer par des Iterables:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
>>> def counter(start=0):
...     value = start
...     while True:
...        value += 1
...        yield value
...

La chose "counter" n'est plus fonction puisqu'elle a une mémoire/état.
Elle pourra retourner la valeur suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> c = counter(10)
>>> next(c)
11
>>> next(c)
12
>>> next(c)
13

Et nous pourrons créer autant d'objet qu'on voudra (fabriquer comme dans le cas de classes).
Cette possibilité d'associer de la mémoire à un objet s'appelle "closure", et c'est beaucoup plus général que les "classes".
- W