les attributs des objets

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:

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?

Citation:

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

Rien compris...

Citation:

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.

Salut,

Citation:

Envoyé par rogorde

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:

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.
Citation:
je suis entré dans la programmation orienté objet et je vois que les variable sont déclaré dans la methode d'initialisation :
Code:

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:

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:

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:

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:

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:

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:

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:

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:

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