Comment avez-vous jeté une instance d'une classe dérivée?

Je suis en train d'utiliser un peu de l'héritage dans un programme en Python, je travaille sur. J'ai une classe de base, Utilisateur, qui implémente toutes les fonctionnalités d'un utilisateur. Je suis l'ajout de la notion de non approuvés de l'utilisateur, ce qui est juste comme un utilisateur, avec l'ajout d'une méthode unique.

L'Utilisateur de la classe a certaines méthodes qui retournent un objet Utilisateur. Cela ne fonctionne pas quand je sous-classe, car je vais finir par avoir un UnapprovedUser retour d'un Utilisateur, m'empêchant de l'appel de cette méthode, parmi d'autres choses.

class User(object):
    base_dn = 'ou=Users,dc=example,dc=org'

    @classmethod
    def get(cls, uid):
        ldap_data = LdapUtil.get(uid + ',' + self.base_dn)
        return User._from_ldap(ldap_data)

class UnapprovedUser(User):
    base_dn = 'ou=UnapprovedUsers,dc=example,dc=org'

    def approve(self):
        new_dn = '' # the new DN
        LdapUtil.move(self.dn, new_dn)

La get() et _from_ldap() méthodes sont les mêmes pour les deux catégories, bien que la get() méthode dans UnapprovedUser doit retourner un UnapprovedUser objet, et non un Utilisateur.

Comment puis-je cast une des instances de l'Utilisateur que je reçois de User.get() dans un UnapprovedUser?

Je veux faire quelque chose comme:

class UnapprovedUser(User):
    # continued from before

    @classmethod
    def get(cls, uid):
        user = super(UnapprovedUser, cls).get(uid)
        return (UnapprovedUser) user # invalid syntax

afin que je puisse envelopper la méthode du parent et tout simplement jeté la valeur renvoyée à la classe correcte. Puis à nouveau, faire de cette façon pourrait conduire à la mère à l'aide de leur valeur pour self.base_dn, qui allait tout casser.

OriginalL'auteur Chris Lieb | 2009-07-13

9

Plutôt que de "casting", je pense que vous voulez vraiment créer un UnapprovedUser plutôt qu'un User lors de l'invocation de UnapprovedUser.get(). Pour ce faire:

Changement User.get d'utiliser effectivement le cls argument qui est passé:
```
@classmethod
def get(cls, uid):
    ldap_data = LdapUtil.get(uid + ',' + self.base_dn)
    return cls._from_ldap(ldap_data)
```
Vous aurez besoin de faire quelque chose de similaire dans _from_ldap. Vous n'avez pas le code pour _from_ldap, mais je suppose qu'à un certain moment, il fait quelque chose comme:
```
result = User(... blah ...)
```
Vous souhaitez le remplacer par:
```
result = cls(... blah ...)
```
Rappelez-vous: en Python un objet de classe est un callable que les constructions les instances de cette classe. Ainsi, vous pouvez utiliser le cls paramètre d'une classmethod pour construire des instances de la classe utilisée pour appeler le classmethod.

Exactement ce que je cherchais. Merci. Je suppose que je n'ai jamais remarqué que vous pouvez le faire avec la cls paramètre à une méthode de classe.

OriginalL'auteur Laurence Gonsalves
1

Python est dynamique, de type de langue, de sorte que le concept de "casting" n'existe pas. Si l'objet est déjà un UnapprovedUser, alors vous pouvez déjà appeler toutes les méthodes qui existent dans la classe, sans avoir à lancer.

Le problème est que je suis un Utilisateur m'est revenue, mais j'en ai besoin pour être un UnapprovedUser alors que je peux appeler cette méthode. Je ne veux pas de code en double si je n'ai pas.
"Casting" est un peu un terme ambigu (d'où le n différents types de moulages en C++), mais il est certainement quelque chose qui s'apparente à au moins une forme de moulage en Python: conversion de type. par exemple: j'ai pu imaginer quelqu'un dire que, str(x) "jette" x en str (mais je pense que la plupart des gens vont pour le plus explicite "convertit" plutôt que "jette").

OriginalL'auteur Chris Jester-Young
1

Dans une méthode de classe, la classe est passé dans le cls paramètre. Ainsi, au lieu de l'Utilisateur.quelque chose ne cls.quelque chose. Fait!

Cela dit, je ne suis pas sûr que je voudrais faire cela avec deux types d'utilisateur. Je ne suis pas 100% sûr de ce que tu veux dire avec "Approuvé" ici, j'ai il me semble être l'une des deux choses.
1. Il se peut que l'utilisateur n'est pas vraiment encore connecté. Dans ce cas, j'aurais un spécial Utilisateur Anonyme instance pour ne pas les utilisateurs connectés. Puisque vous êtes en mouvement le nom de domaine lors de l'approbation, ce qui semble le plus probablement à être ce que vous êtes en train de faire.
2. Cela peut signifier que l'utilisateur n'a pas été approuvé en tant que membre à part entière ou quelque chose. C'est juste un cas particulier de la gestion des permissions, et vous allez probablement envie d'avoir des autorisations plus tard. Je serais plutôt d'ajouter le support pour donner les rôles d'utilisateur, et faire des "Approuvé" un rôle.
Si vous voulez dire quelque chose d'autre avec approuvé, n'hésitez pas à l'ignorer. 🙂

J'ai un simple annuaire LDAP structure que je vais stocker les utilisateurs. ou=Utilisateurs est utilisé par "l'approbation" des utilisateurs. Des Applications qui ressemblent à l'annuaire pour les informations de connexion qu'à se regarder dans ou=Utilisateurs. J'ai également un moyen pour l'utilisateur de demander l'accès à ces applications, où ils ont besoin de l'approbation d'un admin avant de pouvoir vous connecter. Dans ce cas, ils sont créés dans ou=UnapprovedUsers, et a déménagé à ou=Utilisateurs à l'aide de la approve() méthode. Donc, pas de niveaux supplémentaires seront nécessaires.
OK, alors le principe du sens. (Même si bien sûr, avoir les approuver la méthode sur la norme de l'Utilisateur ne fait pas de mal, de sorte que vous ne pourriez pas besoin de deux classes différentes).

OriginalL'auteur Lennart Regebro

super(UnapprovedUser, auto) est mauvais, cela doit être super(UnapprovedUser, cls), car dans la méthode de classe, vous n'avez pas d'auto disponible
Je vais me répéter votre question , dans la classe de base de la création de l'utilisateur et de toute façon vous voulez retourner à la classe dérivée par exemple


   class User(object):

       @classmethod
       def get(cls, uid):
           return User()

   class UnapprovedUser(User):

       @classmethod
       def get(cls, uid):
           user = super(UnapprovedUser, cls).get(uid)
           return user # invalid syntax

   print UnapprovedUser.get("XXX")

de l'impression de l'Utilisateur de l'objet au lieu de UnapprovedUser objet
ici, vous voulez UnapprovedUser.obtenez de retour UnapprovedUser, pour cela, vous pouvez créer une usine de la fonction qui sera de retour de l'utilisateur approprié et de le remplir avec ldap


    class User(object):

        @classmethod
        def get(cls, uid):
            return cls.getMe()

        @classmethod
        def getMe(cls):
            return cls()

    class UnapprovedUser(User):

        @classmethod
        def get(cls, uid):
            user = super(UnapprovedUser, cls).get(uid)
            return user 

    print UnapprovedUser.get("XXX")

il imprime UnapprovedUser objet

OriginalL'auteur Anurag Uniyal

Vous devez vous connecter pour publier un commentaire.