blocks|key|3064975|text|将另一个参数传递给构造函数，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3064976|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|code-block|syntax|javascript|3064977|然后，您可以这样调用它：|3064978|def+__getitem__(self,+key):
++++assert+isinstance(key,+slice)
++++return+String(self.__string[key],+self.__simple[key])|3064979|此外，我不确定是否允许将字段和方法同时命名为__simple。如果只是为了可读性，你应该改变这一点。|offset|length|style|CODE|3064980|entityMap^0|0|0|0|0|M|8|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Pass another argument to the constructor, like so:

<pre><code>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
</code></pre>

You can then call it like this:

<pre><code>def __getitem__(self, key):
 assert isinstance(key, slice)
 return String(self.__string[key], self.__simple[key])
</code></pre>

Also, I'm not sure it's allowed to name both the field and the method <code>__simple</code>. If only for readability, you should change that.

blocks|key|317961|text|如果可行，让__init__被调用(并通过适当的参数使调用无伤大雅)是更可取的。然而，如果需要太多改动，您确实有另一种选择，只要您避免使用旧式类的灾难性选择(在新代码中使用旧式类没有很好的理由，以及+to的几个很好的理由)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|317962|+++class+String(object):
++++++...

+++bare_s+=+String.__new__(String)|code-block|syntax|javascript|317963|这个习惯用法通常用在classmethod中，它的作用是作为“替代构造函数”，所以你通常会看到它以这样的方式使用：|317964|@classmethod+
def+makeit(cls):
++++self+=+cls.__new__(cls)
++++#+etc+etc,+then
++++return+self|317965|(这样，类方法将被正确地继承，并在子类而不是基类上调用时生成子类实例)。|317966|entityMap^0|6|8|0|0|A|B|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

When feasible, letting <code>__init__</code> get called (and make the call innocuous by suitable arguments) is preferable. However, should that require too much of a contortion, you do have an alternative, as long as you avoid the disastrous choice of using old-style classes (there is no good reason to use old-style classes in new code, and several good reasons not to)...:

<pre><code> class String(object):
 ...

 bare_s = String.__new__(String)
</code></pre>

This idiom is generally used in <code>classmethod</code>s which are meant to work as "alternative constructors", so you'll usually see it used in ways such as...:

<pre><code>@classmethod 
def makeit(cls):
 self = cls.__new__(cls)
 # etc etc, then
 return self
</code></pre>

(this way the classmethod will properly be inherited and generate subclass instances when called on a subclass rather than on the base class).

blocks|key|3278100|text|标准的pickle和copy模块使用的一个技巧是创建一个空类，使用它实例化对象，然后将该实例的__class__分配给“真正的”类。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3278101|>>>+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|code-block|syntax|javascript|3278102|但请注意，这种方法很少是必要的。绕过__init__可能会产生一些意想不到的副作用，特别是在您不熟悉原始类的情况下，因此请确保您知道自己在做什么。|3278103|entityMap^0|1B|9|0|0|I|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

A trick the standard pickle and copy modules use is to create an empty class, instantiate the object using that, and then assign that instance's <code>__class__</code> to the "real" class. e.g.

<pre><code>&gt;&gt;&gt; class MyClass(object):
... init = False
... def __init__(self):
... print 'init called!'
... self.init = True
... def hello(self):
... print 'hello world!'
... 
&gt;&gt;&gt; class Empty(object):
... pass
... 
&gt;&gt;&gt; a = MyClass()
init called!
&gt;&gt;&gt; a.hello()
hello world!
&gt;&gt;&gt; print a.init
True
&gt;&gt;&gt; b = Empty()
&gt;&gt;&gt; b.__class__ = MyClass
&gt;&gt;&gt; b.hello()
hello world!
&gt;&gt;&gt; print b.init
False
</code></pre>

But note, this approach is very rarely necessary. Bypassing the <code>__init__</code> can have some unexpected side effects, especially if you're not familiar with the original class, so make sure you know what you're doing.

blocks|key|3065069|text|在这个例子中，使用元类提供了一个很好的解决方案。元类的用法有限，但运行良好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3065070|>>>+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',))
>>>+|code-block|syntax|javascript|3065071|附录：|offset|length|style|BOLD|3065072|六年后，我的观点更倾向于Alex+Martelli's+answer而不是我自己的方法。考虑到元类仍然在脑海中，下面的答案显示了如何在有元类和没有元类的情况下解决问题：|3065073|#!+/usr/bin/env+python3
METHOD+=+'metaclass'


class+NoInitMeta(type):
++++def+new(cls):
++++++++return+cls.__new__(cls)


class+String(metaclass=NoInitMeta+if+METHOD+==+'metaclass'+else+type):
++++def+__init__(self,+value):
++++++++self.__value+=+tuple(value.split())
++++++++self.__alpha+=+tuple(filter(None,+(
++++++++++++''.join(c+for+c+in+word.casefold()+if+'a'+<=+c+<=+'z')+for+word+in
++++++++++++self.__value)))

++++def+__str__(self):
++++++++return+'+'.join(self.__value)

++++def+__eq__(self,+other):
++++++++if+not+isinstance(other,+type(self)):
++++++++++++return+NotImplemented
++++++++return+self.__alpha+==+other.__alpha

++++if+METHOD+==+'metaclass':
++++++++def+__getitem__(self,+key):
++++++++++++if+not+isinstance(key,+slice):
++++++++++++++++raise+NotImplementedError
++++++++++++instance+=+type(self).new()
++++++++++++instance.__value+=+self.__value[key]
++++++++++++instance.__alpha+=+self.__alpha[key]
++++++++++++return+instance
++++elif+METHOD+==+'classmethod':
++++++++def+__getitem__(self,+key):
++++++++++++if+not+isinstance(key,+slice):
++++++++++++++++raise+NotImplementedError
++++++++++++instance+=+self.new()
++++++++++++instance.__value+=+self.__value[key]
++++++++++++instance.__alpha+=+self.__alpha[key]
++++++++++++return+instance

++++++++@classmethod
++++++++def+new(cls):
++++++++++++return+cls.__new__(cls)
++++elif+METHOD+==+'inline':
++++++++def+__getitem__(self,+key):
++++++++++++if+not+isinstance(key,+slice):
++++++++++++++++raise+NotImplementedError
++++++++++++cls+=+type(self)
++++++++++++instance+=+cls.__new__(cls)
++++++++++++instance.__value+=+self.__value[key]
++++++++++++instance.__alpha+=+self.__alpha[key]
++++++++++++return+instance
++++else:
++++++++raise+ValueError('METHOD+did+not+have+an+appropriate+value')

++++def+__iter__(self):
++++++++return+iter(self.__value)


def+main():
++++x+=+String('Hello,+world!')
++++y+=+x[1:]
++++print(y)


if+__name__+==+'__main__':
++++main()|3065074|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2169191/216356^0|0|0|0|3|0|C|M|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$I|14|J|15|1|16]]|A|$]]|$1|O|3|P|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Using a metaclass provides a nice solution in this example. The metaclass has limited use but works fine.

<pre><code>&gt;&gt;&gt; class MetaInit(type):

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

&gt;&gt;&gt; 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' &lt;= s &lt;= '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)

&gt;&gt;&gt; String('Hello, world!')[1:]
&lt;__main__.String object at 0x02E78830&gt;
&gt;&gt;&gt; _._String__string, _._String__simple
(('world!',), ('world',))
&gt;&gt;&gt; 
</code></pre>

Addendum:

After six years, my opinion favors <a href="https://stackoverflow.com/a/2169191/216356">Alex Martelli's answer</a> more than my own approach. With meta-classes still on the mind, the following answer shows how the problem can be solved both with and without them:

<pre><code>#! /usr/bin/env python3
METHOD = 'metaclass'


class NoInitMeta(type):
 def new(cls):
 return cls.__new__(cls)


class String(metaclass=NoInitMeta if METHOD == 'metaclass' else type):
 def __init__(self, value):
 self.__value = tuple(value.split())
 self.__alpha = tuple(filter(None, (
 ''.join(c for c in word.casefold() if 'a' &lt;= c &lt;= 'z') for word in
 self.__value)))

 def __str__(self):
 return ' '.join(self.__value)

 def __eq__(self, other):
 if not isinstance(other, type(self)):
 return NotImplemented
 return self.__alpha == other.__alpha

 if METHOD == 'metaclass':
 def __getitem__(self, key):
 if not isinstance(key, slice):
 raise NotImplementedError
 instance = type(self).new()
 instance.__value = self.__value[key]
 instance.__alpha = self.__alpha[key]
 return instance
 elif METHOD == 'classmethod':
 def __getitem__(self, key):
 if not isinstance(key, slice):
 raise NotImplementedError
 instance = self.new()
 instance.__value = self.__value[key]
 instance.__alpha = self.__alpha[key]
 return instance

 @classmethod
 def new(cls):
 return cls.__new__(cls)
 elif METHOD == 'inline':
 def __getitem__(self, key):
 if not isinstance(key, slice):
 raise NotImplementedError
 cls = type(self)
 instance = cls.__new__(cls)
 instance.__value = self.__value[key]
 instance.__alpha = self.__alpha[key]
 return instance
 else:
 raise ValueError('METHOD did not have an appropriate value')

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


def main():
 x = String('Hello, world!')
 y = x[1:]
 print(y)


if __name__ == '__main__':
 main()
</code></pre>

Is there any way to avoid calling <code>__init__</code> on a class while initializing it, such as from a class method?

I am trying to create a case and punctuation insensitive string class in Python used for efficient comparison purposes but am having trouble creating a new instance without calling <code>__init__</code>.

<pre><code>&gt;&gt;&gt; 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' &lt;= s &lt;= '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)

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

What should I replace <code>string = String(); string.__string = self.__string[key]; string.__simple = self.__simple[key]</code> with to initialize the new object with the slices?

EDIT:

As inspired by the answer written below, the initializer has been edited to quickly check for no arguments.

<pre><code>def __init__(self, string=None):
 if string is None:
 self.__string = self.__simple = ()
 else:
 self.__string = tuple(string.split())
 self.__simple = tuple(self.__simple())
</code></pre>

How to create a class instance without calling initializer?

Python

有没有办法避免在初始化类时调用__init__，比如从类方法中调用？我试图用Python语言创建一个不区分大小写和标点符号的字符串类，用于有效的比较，但在不调用__init__的情况下创建一个新实例时遇到了问题。>>> class String:    def __init__(self, string):      ...

问如何在不调用初始化器的情况下创建一个类实例？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在不调用初始化器的情况下创建一个类实例？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在不调用初始化器的情况下创建一个类实例？
EN