Kann ich integrierten Python-Typen benutzerdefinierte Methoden / Attribute hinzufügen?

Angenommen, ich möchte dem Diktattyp helloWorld()von Python eine Methode hinzufügen . Darf ich das machen?

JavaScript verfügt über ein Prototypobjekt, das sich so verhält. Vielleicht ist es schlechtes Design und ich sollte das diktierte Objekt in Unterklassen unterteilen, aber dann funktioniert es nur in den Unterklassen und ich möchte, dass es in allen zukünftigen Wörterbüchern funktioniert.

So würde es in JavaScript ablaufen:

String.prototype.hello = function() {
    alert("Hello, " + this + "!");
}
"Jed".hello() //alerts "Hello, Jed!"

Hier ist ein nützlicher Link mit weiteren Beispielen: http://www.javascriptkit.com/javatutors/proto3.shtml

Sie können die Methode nicht direkt zum Originaltyp hinzufügen. Sie können den Typ jedoch in eine Unterklasse unterteilen und ihn dann im integrierten / globalen Namespace ersetzen, wodurch der größte Teil des gewünschten Effekts erzielt wird. Leider sind Objekte, die mit Literal-Syntax erstellt wurden, weiterhin vom Vanille-Typ und verfügen nicht über Ihre neuen Methoden / Attribute.

So sieht es aus

# Built-in namespace
import __builtin__

# Extended subclass
class mystr(str):
    def first_last(self):
        if self:
            return self[0] + self[-1]
        else:
            return ''

# Substitute the original str with the subclass on the built-in namespace    
__builtin__.str = mystr

print str(1234).first_last()
print str(0).first_last()
print str('').first_last()
print '0'.first_last()

output = """
14
00

Traceback (most recent call last):
  File "strp.py", line 16, in <module>
    print '0'.first_last()
AttributeError: 'str' object has no attribute 'first_last'
"""

Habe gerade die Forbbidenfrucht probiert!

Hier ist der Code, sehr einfach!

from forbiddenfruit import curse


def list_size(self):
    return len(self)

def string_hello(self):
    print("Hello, {}".format(self))

if __name__ == "__main__":
    curse(list, "size", list_size)
    a = [1, 2, 3]
    print(a.size())
    curse(str, "hello", string_hello)
    "Jesse".hello()

class MyString:
    def __init__(self, string):
        self.string = string
    def bigger_string(self):
        print(' '.join(self.string))

mystring = MyString("this is the string")
mystring.bigger_string()

Ausgabe

t h i s   i s   t h e   s t r i n g

Datenklasse in Python 3.7

from dataclasses import dataclass

@dataclass
class St:

    text : str

    def bigger(self) -> None:
        self.text = list(self.text)
        print(" ".join(self.text))

mys = St("Hello")
mys.bigger()

Ausgabe

H e l l o

HINWEIS : Diese Qualitätssicherung ist als Duplikat zu dieser gekennzeichnet , aber IMO fordert sie etwas anderes an. Ich kann dort nicht antworten, also antworte ich hier.

Insbesondere wollte ich von strbenutzerdefinierten Attributen erben und diese hinzufügen. Bestehende Antworten (insbesondere diejenigen, die sagen, dass Sie nicht können ) haben es nicht ganz gelöst, aber das hat bei mir funktioniert:

class TaggedString(str):
    """
    A ``str`` with a ``.tags`` set and ``.kwtags`` dict of tags.
    Usage example::
      ts = TaggedString("hello world!", "greeting", "cliche",
                        what_am_i="h4cker")
      (ts.upper(), ts.tags, ts.kwtags)
    """

    def __new__(cls, *args, **kwargs):
        return super().__new__(cls, args[0])

    def __init__(self, s, *tags, **kwtags):
        super().__init__()
        self.tags = set(tags)
        self.kwtags = kwtags

Hoffentlich hilft das jemandem! Prost,
Andres

Ja, aber Sie müssen eine neue Klasse desselben Typs definieren und sie sollte von diesem Typ erben.

Zum Beispiel:

class list(list):
    def __init__(self,*args):
        super().__init__(args)
    def map(self,function):
        return [function(i) for i in self]

a = list(1,2,3,4,5)
Def double(i): return i*2

print(a.map(double))

Ja, indem Sie diese Typen unterordnen. Siehe Vereinheitlichen von Typen und Klassen in Python .

Nein, das bedeutet nicht, dass tatsächliche Diktate diesen Typ haben, denn das wäre verwirrend. Die Unterklasse eines integrierten Typs ist die bevorzugte Methode zum Hinzufügen von Funktionen.

Unterklassen sind der richtige Weg in Python. Polyglot-Programmierer lernen, das richtige Werkzeug für die richtige Situation zu verwenden - im Rahmen der Vernunft. Etwas so kunstvoll konstruiertes wie Rails (ein DSL mit Ruby) ist in einer Sprache mit starrerer Syntax wie Python schmerzlich schwer zu implementieren. Die Leute vergleichen oft die beiden und sagen, wie ähnlich sie sind. Der Vergleich ist etwas unfair. Python scheint auf seine eigene Weise. totochto.