Я пытаюсь подклассифицировать объект str и добавлять к нему несколько методов. Моя главная цель - научиться делать это. Где я застрял, я должен подклассифицировать строку в метаклассе и создать мой класс с этой мета или подклассом str напрямую?
А также, я думаю, мне нужно каким-то образом реализовать __new__(), потому что мои пользовательские методы изменят мой строковый объект и вернут новый mystr obj.
Мои методы класса должны быть полностью привязаны с помощью методов str и всегда должны возвращать новый экземпляр класса, когда пользовательские методы его модифицировали. Я хочу иметь возможность сделать что-то вроде этого:
a = mystr("something")
b = a.lower().mycustommethod().myothercustommethod().capitalize()
issubclass(b,mystr) # True
Я хочу иметь все возможности, которые есть у str. Например, a = mystr("something"), тогда я хочу использовать его как, a.capitalize(). mycustommethod(). ниже()
Насколько я понимаю, мне нужно реализовать __new__(). Я так думаю, потому что методы строк, вероятно, попытаются создать новые экземпляры str. Итак, если я перезаписал __new__(), они якобы вернут мой собственный класс str. Тем не менее, я не знаю, как передать аргументы моему методу __init__() класса в этом случае. И я предполагаю, что мне нужно будет использовать type(), чтобы создать новый экземпляр в методе __new__() правильно?
Перезапись __new__() работает, если вы хотите изменить строку при построении:
class caps(str):
def __new__(cls, content):
return str.__new__(cls, content.upper())
Но если вы просто хотите добавить новые методы, вам даже не нужно прикасаться к конструктору:
class text(str):
def duplicate(self):
return text(self + self)
Обратите внимание, что унаследованные методы, такие как, например, upper(), будут возвращать нормальный str, а не text.
Здесь вы можете быстро взломать все, что хотите: вы перехватываете каждый вызов функции и, если видите, что он возвращает строку, вы конвертируете ее обратно в свой собственный тип класса.
Хотя это работает в этом простом примере, у него есть некоторые ограничения. Среди прочего, операторы, такие как оператор индекса, по-видимому, не обрабатываются.
class FunWrapper(object):
def __init__(self, attr):
self.attr = attr
def __call__(self, *params, **args):
ret = self.attr(*params, **args)
if type(ret) is str:
return Foo(ret)
return ret
class Foo(object):
def __init__(self, string):
self.string = string
def __getattr__(self, attr):
return FunWrapper(getattr(self.string, attr))
def newMethod(self):
return "*%s*" % self.string.upper()
f = Foo('hello')
print f.upper().newMethod().lower()
Я пытаюсь подклассифицировать объект str и добавлять к нему несколько методов. Моя главная цель - научиться делать это.
Не перегружайте метод родительским классом (например, верхний ответ). Вместо этого используйте super, как это, для поддержки Python 2:
class Caps(str):
def __new__(cls, content):
return super(Caps, cls).__new__(cls, content.upper())
В Python 3 более эффективно вызывать super как это, но он не совместим с Python 2:
class Caps(str):
def __new__(cls, content):
return super().__new__(cls, content.upper())
Использование:
>>> Caps('foo')
'FOO'
>>> isinstance(Caps('foo'), Caps)
True
>>> isinstance(Caps('foo'), str)
True
Ни один из ответов до сих пор не делает то, что вы запросили здесь:
Мои методы класса должны быть полностью привязаны с помощью методов str, и всегда должен возвращать новый экземпляр класса, когда пользовательские методы изменил его. Я хочу иметь возможность сделать что-то вроде этого:
a = mystr("something") b = a.lower().mycustommethod().myothercustommethod().capitalize() issubclass(b,mystr) # True
(Я полагаю, вы имеете в виду isinstance(), а не issubclass().)
Вам нужен способ перехвата строковых методов. __getattribute__ делает это.
class Caps(str):
def __new__(cls, content):
return super(Caps, cls).__new__(cls, content.upper())
def __repr__(self):
"""A repr is useful for debugging"""
return f'{type(self).__name__}({super().__repr__()})'
def __getattribute__(self, name):
if name in dir(str): # only handle str methods here
def method(self, *args, **kwargs):
value = getattr(super(), name)(*args, **kwargs)
# not every string method returns a str:
if isinstance(value, str):
return type(self)(value)
elif isinstance(value, list):
return [type(self)(i) for i in value]
elif isinstance(value, tuple):
return tuple(type(self)(i) for i in value)
else: # dict, bool, or int
return value
return method.__get__(self) # bound method
else: # delegate to parent
return super().__getattribute__(name)
def mycustommethod(self): # shout
return type(self)(self + '!')
def myothercustommethod(self): # shout harder
return type(self)(self + '!!')
и теперь:
>>> a = Caps("something")
>>> a.lower()
Caps('SOMETHING')
>>> a.casefold()
Caps('SOMETHING')
>>> a.swapcase()
Caps('SOMETHING')
>>> a.index('T')
4
>>> a.strip().split('E')
[Caps('SOM'), Caps('THING')]
И запрошенный запрос работает:
>>> a.lower().mycustommethod().myothercustommethod().capitalize()
Caps('SOMETHING!!!')
Я немного ужасен от сложности других ответов, а также стандартной библиотеки python. Вы можете использовать collection.UserString для подкласса строки и не использовать методы проксирования str.
Просто подклассируйте его и добавьте свои методы. self.data содержит фактическую строку, представленную вашим объектом, поэтому вы можете даже реализовать str- "мутирующие" методы, переназначив self.data внутренне.
Вы можете попробовать что-то вроде:
class mystr(str):
def new_method(self):
pass
но вы не будете уверены, что стандартные методы также вернут экземпляр "mystr"