IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

les attributs des objets


Sujet :

Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Inscrit en
    Août 2012
    Messages
    15
    Détails du profil
    Informations forums :
    Inscription : Août 2012
    Messages : 15
    Par défaut 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 : 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?

  2. #2
    Expert confirmé
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    4 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 4 062
    Par défaut
    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.

  3. #3
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 741
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 741
    Par défaut
    Salut,

    Citation Envoyé par rogorde Voir le message
    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
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

Discussions similaires

  1. Une question sur les « Names » des objets.
    Par phdnet dans le forum W4 Express
    Réponses: 7
    Dernier message: 04/12/2007, 08h54
  2. Réponses: 6
    Dernier message: 14/11/2007, 15h51
  3. [Castor] Conserver les references des objets
    Par troisj dans le forum Persistance des données
    Réponses: 1
    Dernier message: 01/08/2007, 22h04
  4. MCD a MLD et les attributs des relations
    Par anis_el_madani dans le forum Schéma
    Réponses: 1
    Dernier message: 16/07/2007, 14h45
  5. J'ai pas les infos des objets dans l'éditeur
    Par mister3957 dans le forum MFC
    Réponses: 3
    Dernier message: 20/02/2006, 19h43

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo