l'héritage de str ou int

Pourquoi j'ai des problèmes pour créer une classe héritant de str (ou int)

class C(str):
   def __init__(self, a, b):
     str.__init__(self,a)
     self.b = b

C("a", "B")

TypeError: str() takes at most 1 argument (2 given)

tha même si j'essaie d'utiliser int au lieu de str, mais il fonctionne avec des classes personnalisées. J'ai besoin d'utiliser __new__ au lieu de __init__? pourquoi?

InformationsquelleAutor Ruggero Turra | 2010-04-20
  1. 67
    >>> class C(str):
...     def __new__(cls, *args, **kw):
...         return str.__new__(cls, *args, **kw)
... 
>>> c = C("hello world")
>>> type(c)
<class '__main__.C'>

>>> c.__class__.__mro__
(<class '__main__.C'>, <type 'str'>, <type 'basestring'>, <type 'object'>)

    Depuis __init__ est appelé après que l'objet est construit, il est trop tard pour modifier la valeur d'immuable types. Notez que __new__ est un classmethod, j'ai donc appelé le premier paramètre cls

    Voir ici pour plus d'informations

    >>> class C(str):
...     def __new__(cls, value, meta):
...         obj = str.__new__(cls, value)
...         obj.meta = meta
...         return obj
... 
>>> c = C("hello world", "meta")
>>> c
'hello world'
>>> c.meta
'meta'
    • J'ai utilisé votre réponse pour vous aider à répondre à ma propre DONC, la question ici. Merci!
    InformationsquelleAutor John La Rooy
  2. 11

    Hériter de types intégrés est très rarement utile. Vous devez faire face à plusieurs problèmes, et vous n'avez pas vraiment beaucoup d'avantages.

    Il est presque toujours préférable d'utiliser la composition. Au lieu d'hériter de str, vous devez garder un str objet comme un attribut.

    class EnhancedString(object):
     def __init__(self, *args, **kwargs):
         self.s = str(*args, **kwargs)

    vous pouvez reporter les méthodes que vous souhaitez travailler sur le sous-jacent str self.s manuellement ou automatiquement à l'aide de __getattr__.

    Cela étant dit, qui ont besoin de votre propre type de chaîne est quelque chose qui devrait vous donner une pause. Il y a beaucoup de classes qui doit stocker une chaîne de données principale, mais en général, vous souhaitez utiliser str ou unicode (le dernier si vous êtes représentant de texte) pour la représentation générale de chaînes de caractères. (Une commune exception est si vous avez besoin d'utiliser une INTERFACE toolkit de type chaîne de caractères.) Si vous voulez ajouter des fonctionnalités à vos chaînes, essayez si vous pouvez utiliser les fonctions qui opèrent sur les chaînes plutôt que de nouveaux objets pour servir en tant que chaînes, ce qui rend votre code plus simple et plus compatible avec tous les autres programmes.

    • oui, c'était ma première solution, mais le problème est que j'ai des fonctions qui veulent un argument de type chaîne (ils sont des fonctions C++ à partir d'une bibliothèque, je ne peux pas modifier), avec ma mise en œuvre de ces fonctions à l'aide de ma classe que arguments. Pouvez-vous mieux expliquer la façon d'obtenir ce résultat à l'aide de __getattr__?
    • l'acceptation d'une chaîne de caractères en argument est un underdefined chose. Je ne sais pas ce que votre bibliothèque C++ est et comment il est enveloppé, mais un emballage doit le rendre compatible avec le droit de types pour le travail. La fabrication d'une nouvelle classe de vous-même que personne n'a jamais vu avant, plutôt qu'à l'aide de son classe string ou Python string (de la classe et de travailler avec qui) semble être une drôle de manière de faire fonctionner les choses.
    • Pour utiliser __getattr__ de reporter sinon pas défini des attributs à un attribut spécifique dans la composition est accompli par un code comme def __getattr__(self, name): return getattr(self.s, name). Notez que ce code n'est pas forcément recommandé, mais peut bien fonctionner dans certains cas, il est souvent préférable de définir manuellement les choses que vous voulez dans la composition.
    • J'ai c_function(char*), je peux l'utiliser en python comme c_function(s) où s est un str instance. s de représenter quelque chose, et je veux qu'il ait une name, un beautiful_name et ainsi de suite. J'ai donc dérivé d'une classe C de str, donc je peux passer un objet c de classe C à python_function que, par exemple, ne print c.name et appel c_function(c)
    • > "Hériter de types intégrés est très rarement la peine." Cela pourrait être vrai, mais pas toujours. Il est parfois utile de créer un "marqué" chaîne de type, par exemple pour produire des types distincts de la chaîne comme des jetons d'un analyseur. Le problème avec cela, cependant, est que (je crois), vous perdez le court-chaîne de l'optimisation de la performance.
    • dans ce cas, la composition est encore beaucoup moins sujettes à l'erreur. Héritant de str est une source potentielle d'erreur, mais n'est pas réellement vous aider.
    • Je ne suis pas convaincu. Pouvez-vous pourquoi vous pensez que l'héritage de str est une source potentielle d'erreur? Parce que ce n'est pas idiomatique?
    • docs.python.org/3/library/... "La classe, UserString agit comme un wrapper autour des objets string. La nécessité de cette classe a été partiellement remplacée par la capacité de la sous-classe directement à partir de str;" Il n'est pas unidiomatic.
    • Supposons que vous ne your_subclass[:5] ou your_subclass.replace(x, y)--que faut-il de retour? Une instance de str ou une instance de votre sous-classe? Ce n'est pas encore défini, mais dans la pratique, il sera de retour str. Il n'y a aucune garantie de quelque manière que ce soit, et ce genre de comportement indéfini est une mauvaise chose.
    • vous devriez toujours écrire du code qui est aussi clair que possible et aussi facile à comprendre qu'il n'est que possible. Sous-classement d'objets internes est tout simplement difficile à penser, à entretenir et à utiliser.

    InformationsquelleAutor Mike Graham
  3. 8

    Lorsque vous instancier une classe, les arguments que vous passer en, sont transmis à la fois la __new__ (constructeur), puis à la __init__ (initialiseur) les méthodes de la classe. Donc, si vous hériter d'une classe qui a des restrictions sur le nombre d'arguments qui peuvent être fournis lors de l'instanciation, vous devez vous assurer que ni ses __new__, ni ses __init__ aurait plus d'arguments qu'ils s'attendent à obtenir. Donc, c'est le problème que vous avez. Vous instanciez votre classe avec C("a", "B"). L'interprète cherche __new__ méthode dans C. C ne l'a pas, donc python jette un coup d'oeil dans sa classe de base str. Et comme il en a une, c'est que l'un est utilisé et fourni avec les deux arguments. Mais str.__new__ s'attend à obtenir un seul argument (en plus de son objet de classe comme premier argument). Donc TypeError est soulevée. C'est pourquoi vous devez élargir votre enfant en classe de même pour ce que vous faites avec __init__. Mais gardez à l'esprit qu'il doit retourner instance de la classe et que c'est un statique méthode (qu'il est défini par @staticmethod décorateur ou pas) qui compte si vous utilisez super fonction.

    • Pour le vérifier, essayez ceci à l'invite de commandes: >>> str.__init__('abc', 'def'). Cela ne fait rien. Cependant, >>> str.__new__(str, 'abc', 'def') lève l'exception: TypeError: str() takes at most 1 argument (2 given). C'est un peu confus, parce que nous avons appelé str.__new__(..) avec 3 arguments, pas les 2. Est-ce à dire que str.__new__(..) accepte un nombre quelconque d'arguments, mais alors les appels str(..)? Probablement pas, parce que str(..) va appeler str.__new__(..) à son tour...
    • objet de classe n'implémente pas __init__ méthode à tous. Ni ne basestring (str's de la classe de base). __init__ est héritée directement de object et que l'on accepte un nombre quelconque d'arguments. Au contraire __new__ méthode est vraiment mis en œuvre dans str et il accepte au plus 1 argument à côté de la première, qui doit être str ou de ses sous-classe. Essayez des expressions comme >>> '__init__' in str.__dict__ et ainsi de suite pour __new__, basestring et object.
    • C'est une bonne façon de vérifier les méthodes de mise en œuvre. Je suis encore un peu confus pourquoi j'écris str.__new__(str, 'abc', 'def') et il dit que j'ai fourni 2 arguments. Je compte trois là. Pour l'exemple class C(object):\n @staticmethod \n def m(a): pass, si je l'appelle comme C.m(1, 2), il va dire TypeError: m() takes exactly 1 argument (2 given) comme prévu. Je suppose que __new__ produit un message de confusion parce que __new__ est spécial (par exemple, vous n'avez pas besoin d'ajouter de la @staticmethod lors de la mise en œuvre).
    InformationsquelleAutor user2683246
  4. 5

    Utilisation __new__ en cas de immuable types:

    class C(str):
    def __new__(cls, content, b):
        return str.__new__(cls, content)

    def __str__(self):
        return str.__str__(self)

a=C("hello", "world")
print a

    d'impression retourne hello.

    Python chaînes sont immuables types. La fonction __new__ est appelé à créer une nouvelle instance de l'objet C. Le python __new__ fonction est essentiellement existe pour permettre à l'héritage immuable types.

    • type(C("a", "B")) -> NoneType
    • essayez-vous votre réponse? Maintenant, c'retour "
    • -1? Pouvez-vous au moins écrire un commentaire?
    • J'ai écrit 2 commentaires.
    • Et avez-vous vérifié les mises à jour de la poste? Il a été mis à jour en fonction de votre demande. Vous bas-voté après les modifications ont été apportées. Par ailleurs, dans votre commentaire vous fonctionnalité attendue à partir de mon code qui n'a pas été demandée dans votre question (pour obtenir l' __str__() de la fonction de travail de la classe héritée)!
    • Après la première mise en œuvre du code retourné NoneType, après le second, il a donné "". Qui n'a pas demandé de fonctionnalité? Je n'ai pas demander à un __str__ fonction et il n'est pas nécessaire, parce que la classe héritée de str, voir gnibbler réponse. Maintenant, je ne peux pas modifier le downvote, j'ai besoin que vous modifiez votre réponse.

    InformationsquelleAutor zoli2k
  5. 4

    Après avoir lu attentivement cette, voici une autre tentative de sous-classement str. Le changement d'une autre réponse est la création de l'instance de la classe correcte à l'aide de super(TitleText, cls).__new__ . Celui-ci semble se comporter comme un str à chaque fois qu'il est utilisé, mais m'a permis de remplacer une méthode:

    class TitleText(str):
    title_text=""
    def __new__(cls,content,title_text):
        o=super(TitleText, cls).__new__(cls,content)
        o.title_text = title_text
        return o

    def title(self):
        return self.title_text

>>> a=TitleText('name','A nice name')
>>> a
'name'
>>> a[0]
'n'
>>> a[0:2]
'na'
>>> a.title()
'A nice name'

    Ceci vous permet de tranchage et de subscripting correctement. Qu'est-ce pour? Pour renommer l'application Django dans l'admin de la page d'index.

    • Beurk! Le fait que votre repr est trompeur conduit à il n'était pas clair que tout a est un TitleText, a[0] et a[0:2] sont str (aujourd'hui, dans les versions actuelles, comme un détail d'implémentation). Si vous avais écrit une classe sans hériter de str vous pourriez faire beaucoup plus utile et beaucoup moins confuse et trompeuse chose.
    InformationsquelleAutor Missing Semicolon