Extendiendo clases incorporadas en python

Question

¿Cómo puedo extender una clase incorporada en python? Me gustaría agregar un método a la clase str.
He hecho algunas búsquedas pero todo lo que estoy buscando son publicaciones antiguas, espero que alguien sepa algo más nuevo.

Answer 1

Sólo subclase del tipo

>>> class X(str): 
...  def myMethod(self): 
...    return int(self) 
... 
>>> s=X("Hi Mom") 
>>> s.lower() 
'hi mom' 
>>> s.myMethod() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "<stdin>", line 3, in myMethod 
ValueError: invalid literal for int() with base 10: 'Hi Mom' 

>>> z=X("271828") 
>>> z.lower() 
'271828' 
>>> z.myMethod() 
271828 

Answer 2

una posible alternativa sería utilizar el concepto "reapertura de clase" (de forma nativa existente en Ruby) que puede ser implementado en Python usando un decorador clase. Un exemple se da en esta página: http://www.ianbicking.org/blog/2007/08/opening-python-classes.html

cito:

Creo que con decoradores de clase que podría hacer esto:

@extend(SomeClassThatAlreadyExists) 
class SomeClassThatAlreadyExists: 
    def some_method(self, blahblahblah): 
     stuff 

implementa de la siguiente:

def extend(class_to_extend): 
    def decorator(extending_class): 
     class_to_extend.__dict__.update(extending_class.__dict__) 
     return class_to_extend 
    return decorator 

Answer 3

Suponiendo que no puede cambiar las clases integradas. para simular una "clase reapertura" como Ruby en python3 donde __dict__ es un objeto mappingproxy y el objeto no dict:

def open(cls): 
    def update(extension): 
    for k,v in extension.__dict__.items(): 
     if k != '__dict__': 
     setattr(cls,k,v) 
    return cls 
    return update 


class A(object): 
    def hello(self): 
    print('Hello!') 

A().hello() #=> Hello! 

#reopen class A 
@open(A) 
class A(object): 
    def hello(self): 
    print('New hello!') 
    def bye(self): 
    print('Bye bye') 


A().hello() #=> New hello! 
A().bye()  #=> Bye bye 

yo también podría escribir una función decoradora 'abierta', así:

def open(cls): 
    def update(extension): 
    namespace = dict(cls.__dict__) 
    namespace.update(dict(extension.__dict__)) 
    return type(cls.__name__,cls.__bases__,namespace) 
    return update