Python: создание экземпляра класса без вызова инициализатора

Question

Есть ли способ избежать звонка __init__ в классе при его инициализации, например, из метода класса?

Я пытаюсь создать в Python класс, не чувствительный к регистру и пунктуации, используемый для эффективного сравнения, но у меня возникают проблемы при создании нового экземпляра без вызова __init__,

>>> class String:

    def __init__(self, string):
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())

    def __simple(self):
        letter = lambda s: ''.join(filter(lambda s: 'a' <= s <= 'z', s))
        return filter(bool, map(letter, map(str.lower, self.__string)))

    def __eq__(self, other):
        assert isinstance(other, String)
        return self.__simple == other.__simple

    def __getitem__(self, key):
        assert isinstance(key, slice)
        string = String()
        string.__string = self.__string[key]
        string.__simple = self.__simple[key]
        return string

    def __iter__(self):
        return iter(self.__string)

>>> String('Hello, world!')[1:]
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    String('Hello, world!')[1:]
  File "<pyshell#1>", line 17, in __getitem__
    string = String()
TypeError: __init__() takes exactly 2 positional arguments (1 given)
>>> 

Что я должен заменить string = String(); string.__string = self.__string[key]; string.__simple = self.__simple[key] с, чтобы инициализировать новый объект с кусочками?

РЕДАКТИРОВАТЬ:

Как следует из приведенного ниже ответа, инициализатор был отредактирован для быстрой проверки отсутствия аргументов.

def __init__(self, string=None):
    if string is None:
        self.__string = self.__simple = ()
    else:
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())

Answer 1

Использование метакласса обеспечивает хорошее решение в этом примере. Метакласс имеет ограниченное использование, но работает нормально.

>>> class MetaInit(type):

    def __call__(cls, *args, **kwargs):
        if args or kwargs:
            return super().__call__(*args, **kwargs)
        return cls.__new__(cls)

>>> class String(metaclass=MetaInit):

    def __init__(self, string):
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())

    def __simple(self):
        letter = lambda s: ''.join(filter(lambda s: 'a' <= s <= 'z', s))
        return filter(bool, map(letter, map(str.lower, self.__string)))

    def __eq__(self, other):
        assert isinstance(other, String)
        return self.__simple == other.__simple

    def __getitem__(self, key):
        assert isinstance(key, slice)
        string = String()
        string.__string = self.__string[key]
        string.__simple = self.__simple[key]
        return string

    def __iter__(self):
        return iter(self.__string)

>>> String('Hello, world!')[1:]
<__main__.String object at 0x02E78830>
>>> _._String__string, _._String__simple
(('world!',), ('world',))
>>> 

Answer 2

Когда это возможно, позволяя __init__ Получить вызов (и сделать вызов безвредным с помощью подходящих аргументов) предпочтительнее. Однако, если для этого требуется слишком много искажений, у вас есть альтернатива, если вы избегаете катастрофического выбора использования классов старого стиля (нет веской причины использовать классы старого стиля в новом коде, и несколько хороших причин не делать)...

   class String(object):
      ...

   bare_s = String.__new__(String)

Эта идиома обычно используется в classmethods, которые предназначены для работы в качестве "альтернативных конструкторов", так что вы обычно увидите, что они используются такими способами, как...:

@classmethod 
def makeit(cls):
    self = cls.__new__(cls)
    # etc etc, then
    return self

(таким образом метод класса будет должным образом наследоваться и генерировать экземпляры подкласса при вызове в подклассе, а не в базовом классе).

Answer 3

Хитрость, которую используют стандартные модули pickle и copy, заключается в создании пустого класса, создании экземпляра объекта с его использованием, а затем назначении этого экземпляра. __class__ в "настоящий" класс. например

>>> class MyClass(object):
...     init = False
...     def __init__(self):
...         print 'init called!'
...         self.init = True
...     def hello(self):
...         print 'hello world!'
... 
>>> class Empty(object):
...     pass
... 
>>> a = MyClass()
init called!
>>> a.hello()
hello world!
>>> print a.init
True
>>> b = Empty()
>>> b.__class__ = MyClass
>>> b.hello()
hello world!
>>> print b.init
False

Но обратите внимание, такой подход очень редко необходим. В обход __init__ может иметь некоторые неожиданные побочные эффекты, особенно если вы не знакомы с исходным классом, поэтому убедитесь, что вы знаете, что делаете.

Answer 4

Передайте другой аргумент в конструктор, например, так:

def __init__(self, string, simple = None):
    if simple is None:
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())
    else:
        self.__string = string
        self.__simple = simple

Затем вы можете назвать это так:

def __getitem__(self, key):
    assert isinstance(key, slice)
    return String(self.__string[key], self.__simple[key])

Кроме того, я не уверен, что разрешено называть как поле, так и метод __simple, Если только для удобства чтения, вы должны изменить это.