" specialdict"模 [英] "specialdict" module
问题描述
你好，
跟进最近的词典累加器线程，我写了一个
小模块，带有几个子类序列。
注释（例如使用super更有意义），更正等等？这是
PEP材料吗？
文档字符串，文档和测试用例将在以后提供。
mfg
Georg
----------------------------- -----------------------------------------
class defaultdict（dict）：
＃_defaulttype：0 =无默认值，1 =默认值，2 = defaultfactory
__slots__ = [''_defaulttype''，' '_default'']
def __init __（self，* args，** kwargs）：
self._defaulttype = 0
super（defaultdict，self）.__ init __（self，* args，** kwargs）
def setdefaultvalue（self，value）：
self._defaulttype = 1
self._default = value
def setdefaultfactory（self，factory，* args，** kwargs）：
如果不可调用（工厂）：
引发TypeError，''默认工厂必须是可调用的''
self._defaulttype = 2
self._default =（工厂，args，kwargs）
def cleardefault（self）：
self._defaulttype = 0
def __getitem __（self，key）：
试试：
返回super（defaultdict，self）.__ getitem __（键）
除了KeyError：
if self._defaulttype == 0：
加价
elif self._defaulttype == 1：
返回self.setdefault（key，self._default）
否则：
返回self.setdefault（键，
self._default [0]（* self._default [1]，** self._default [2]））
class keytransformdict（dict）：
__slots__ = [''_transformer'']
def __init __（ self，* args，** kwargs）：
self._transformer = lambda x：x
super（keytransformdict，self）.__ init __（self，* args，** kwargs）
def settransformer（自我，变压器）：
如果不可赎回（变压器）：
加注TypeError，''变压器必须是可调用的''
self._transformer =变压器
def __setit em __（self，key，value）：
super（keytransformdict，self）.__ setitem __（self，
self._transformer（key），value）
def __getitem __（self，key）：
返回super（keytransformdict，self）.__ getitem __（self，
self._transformer（key））
def __delitem __（自我，关键）：
super（keytransformdict，self）.__ delitem __（self，
self._transformer （键））
class sorteddict（dict）：
def __iter __（self）：
for key in sorted（super） （sorteddict，self）.__ iter __（self））：
产生密钥
def键（个体经营）：
返回列表（self.iterkeys（））
def items（self）：
返回列表（self.iteritems（））
def值（个体积）：
返回列表（self.itervalues（））
def iterkeys（个体经营）：
返回iter（自我）
def iteritems（self）：
返回（（键，自[密钥]）用于键入自己）
def itervalues（自我）：
返回（自我键[self]键）
if __name__ ==''__ main__''：
x = sorteddict（a = 1，b = 3，c = 2）
print x.keys（）
print x.values（）
print x.items（）
Hello,
in follow-up to the recent "dictionary accumulator" thread, I wrote a
little module with several subclassed dicts.
Comments (e.g. makes it sense to use super), corrections, etc.? Is this
PEP material?
Docstrings, Documentation and test cases are to be provided later.
mfg
Georg
----------------------------------------------------------------------
class defaultdict(dict):
# _defaulttype: 0=no default, 1=defaultvalue, 2=defaultfactory
__slots__ = [''_defaulttype'', ''_default'']
def __init__(self, *args, **kwargs):
self._defaulttype = 0
super(defaultdict, self).__init__(self, *args, **kwargs)
def setdefaultvalue(self, value):
self._defaulttype = 1
self._default = value
def setdefaultfactory(self, factory, *args, **kwargs):
if not callable(factory):
raise TypeError, ''default factory must be a callable''
self._defaulttype = 2
self._default = (factory, args, kwargs)
def cleardefault(self):
self._defaulttype = 0
def __getitem__(self, key):
try:
return super(defaultdict, self).__getitem__(key)
except KeyError:
if self._defaulttype == 0:
raise
elif self._defaulttype == 1:
return self.setdefault(key, self._default)
else:
return self.setdefault(key,
self._default[0](*self._default[1], **self._default[2]))
class keytransformdict(dict):
__slots__ = [''_transformer'']
def __init__(self, *args, **kwargs):
self._transformer = lambda x: x
super(keytransformdict, self).__init__(self, *args, **kwargs)
def settransformer(self, transformer):
if not callable(transformer):
raise TypeError, ''transformer must be a callable''
self._transformer = transformer
def __setitem__(self, key, value):
super(keytransformdict, self).__setitem__(self,
self._transformer(key), value)
def __getitem__(self, key):
return super(keytransformdict, self).__getitem__(self,
self._transformer(key))
def __delitem__(self, key):
super(keytransformdict, self).__delitem__(self,
self._transformer(key))
class sorteddict(dict):
def __iter__(self):
for key in sorted(super(sorteddict, self).__iter__(self)):
yield key
def keys(self):
return list(self.iterkeys())
def items(self):
return list(self.iteritems())
def values(self):
return list(self.itervalues())
def iterkeys(self):
return iter(self)
def iteritems(self):
return ((key, self[key]) for key in self)
def itervalues(self):
return (self[key] for key in self)
if __name__ == ''__main__'':
x = sorteddict(a=1, b=3, c=2)
print x.keys()
print x.values()
print x.items()
推荐答案
您用来发布此消息的软件包含了一些
代码。例如：
The software you used to post this message wrapped some of the lines of
code. For example:
def __delitem __（self，key）：
super（keytransformdict，self）.__ delitem __（self，
self._transformer（key））
def __delitem__(self, key):
super(keytransformdict, self).__delitem__(self,
self._transformer(key))
在defaultdict中，我想知道是否所有内容都应被视为
工厂：
def setdefaultvalue（self，value）：< br $> b $ b def工厂（）：返回值
self.setdefaultfactory（工厂）
和no-default模式将不再存在，或者
def cleardefault（self）：
def factory（）：
引发KeyError，key确实不存在且没有默认定义
self.setdefaultfactory（工厂）
（太糟糕了，工厂没有钥匙，这会降低
质量错误消息）
如果是这样，__ getitem__变得更简单：
__slots__ = [''_default'']
def __getitem __（自我，关键）：
尝试：
返回超级（defaultdict，self）.__ getitem __（键）
除了KeyError：
返回self.setdefault（键，应用（* self._default））
我没有因为排序而烦恼字典，据我所知
记住，我不会立即理解使用
keytransformdict。你能给出一个例子吗？
杰夫
-----开始PGP签名-----
版本：GnuPG v1.2.6（GNU / Linux）
iD8DBQFCUCb2Jd01MZaTXX0RAujvAJ4mi7cu3l85k0eeTUsd42 UDtGVAzACgp1um
6Iq2DhOo529q83oRXqquZ5I =
= Ytjv
-----结束PGP SIGNATURE -----
In defaultdict, I wonder whether everything should be viewed as a
factory:
def setdefaultvalue(self, value):
def factory(): return value
self.setdefaultfactory(factory)
and the "no-default" mode would either cease to exist, or
def cleardefault(self):
def factory():
raise KeyError, "key does not exist and no default defined"
self.setdefaultfactory(factory)
(too bad that the key isn''t available in the factory, this degrades the
quality of the error messge)
if so, __getitem__ becomes simpler:
__slots__ = [''_default'']
def __getitem__(self, key):
try:
return super(defaultdict, self).__getitem__(key)
except KeyError:
return self.setdefault(key, apply(*self._default))
I don''t ever have an itch for sorted dictionaries, as far as I can
remember, and I don''t immediately understand the use of
keytransformdict. Can you give an example of it?
Jeff
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.6 (GNU/Linux)
iD8DBQFCUCb2Jd01MZaTXX0RAujvAJ4mi7cu3l85k0eeTUsd42 UDtGVAzACgp1um
6Iq2DhOo529q83oRXqquZ5I=
=Ytjv
-----END PGP SIGNATURE-----
Jeff Epler写道：
Jeff Epler wrote:
您用来发布此消息的软件包含了一些代码行。例如：
The software you used to post this message wrapped some of the lines of
code. For example:
def __delitem __（self，key）：
super（keytransformdict，self）.__ delitem __（self，
self._transformer（key））
def __delitem__(self, key):
super(keytransformdict, self).__delitem__(self,
self._transformer(key))
不知怎的，我担心会发生这种情况。
在defaultdict中，我想知道是否所有东西都应该被视为工厂：
def setdefaultvalue（self，价值）：
def factory（）：返回值
self.setdefaultfactory（工厂）
这是一种合理的方法。 __init__也必须改变，但是这个
不应该太伤害。
和no-default模式将不再存在，或者def defdefault（self）：
def factory（）：
引发KeyError，key不存在且没有默认定义
自我.setdefaultfactory（工厂）
（太糟糕了，工厂里没有钥匙，这会降低错误消息的质量）
那个可以使用__getitem__中的解决方案解决，见下文。
如果是这样，__ getitem__变得更简单：
__slots__ = [''_default'']
def __getitem __（self，键）：
尝试：
返回super（defaultdict，self）.__ getitem __（键）
除了KeyError：
return self.setdefault（key，apply（* self._default） ）
你正在追捕kwargs。此外，apply（）即将被弃用
，所以最好不要使用它。
def __getitem __（自我，密钥）：
尝试：
返回超级（defaultdict，self）.__ getitem __（键）
除了KeyError之外的
，错误：
尝试：
返回self.setdefault（键，
self._default [0]（* self._default [1]，
** self。 _default [2]））
除了KeyError：
引发错误
虽然我不确定KeyError是否会是正确的提高
（可能是自定义错误？）。
我没有对排序的词典感到痒，据我所知记住，我不会立即理解使用
keytransformdict。你能给出一个例子吗？
Somehow I feared that this would happen.
In defaultdict, I wonder whether everything should be viewed as a
factory:
def setdefaultvalue(self, value):
def factory(): return value
self.setdefaultfactory(factory)
That''s a reasonable approach. __init__ must be changed too, but this
shouldn''t hurt too badly.
and the "no-default" mode would either cease to exist, or
def cleardefault(self):
def factory():
raise KeyError, "key does not exist and no default defined"
self.setdefaultfactory(factory)
(too bad that the key isn''t available in the factory, this degrades the
quality of the error messge)
That can be worked around with a solution in __getitem__, see below.
if so, __getitem__ becomes simpler:
__slots__ = [''_default'']
def __getitem__(self, key):
try:
return super(defaultdict, self).__getitem__(key)
except KeyError:
return self.setdefault(key, apply(*self._default))
You are peculating the kwargs. Also, apply() is on the verge of being
deprecated, so better not use it.
def __getitem__(self, key):
try:
return super(defaultdict, self).__getitem__(key)
except KeyError, err:
try:
return self.setdefault(key,
self._default[0](*self._default[1],
**self._default[2]))
except KeyError:
raise err
Although I''m not sure whether KeyError would be the right one to raise
(perhaps a custom error?).
I don''t ever have an itch for sorted dictionaries, as far as I can
remember, and I don''t immediately understand the use of
keytransformdict. Can you give an example of it?
见线程不区分大小写的dict，非破坏性，快速，任何人？，
从04/01/05 12:38开始。
mfg
Georg
See the thread "Case-insensitive dict, non-destructive, fast, anyone?",
starting at 04/01/05 12:38.
mfg
Georg
Georg Brandl写道：
Georg Brandl wrote:
你好，
是对最近的词典累加器的跟进。线程，我写了一个带有几个子类序列的小模块。
注释（例如使用超级有意义），更正等等？这是否是PEP材料？
文档字符串，文档和测试用例将在稍后提供。
制作Georg
Hello,
in follow-up to the recent "dictionary accumulator" thread, I wrote a
little module with several subclassed dicts.
Comments (e.g. makes it sense to use super), corrections, etc.? Is this
PEP material?
Docstrings, Documentation and test cases are to be provided later.
mfg
Georg
Georg：
一些反应：
1.鉴于这些是专业化，为什么不具备：
class defaultvaluedict（dict）：
...
class defaultfactorydict（dict）：
...
而不是必须通过箍来使一个实现满足两个
个案
2.我真的更喜欢在构造函数中指定默认值
我意识到由于dict .__ init__的kw参数这很棘手，但是我
有利于破坏与该接口的兼容性，或采用一些
解决方法来使d = defaultvaluedict（__ default__ = 0）成为可能。
一种解决方法是将默认值存储在dict中，而不是作为属性
的字典。默认情况下，默认值将与键
" __ default __"相关联，但该键名可以更改为（我猜很少）
情况下该键与dict的非默认内容冲突。然后
dict .__ init__只会将__default__ = value作为关键字参数，因为它今天是b $ b，而__getitem__表示丢失的键会返回
dict .__ getitem __（self，" __ default __"）
或者，你可以提供工厂函数来构造defaultdict。
有人（Michele？）最近发布了一个实现这个
3.你可以在开始这整个
线程的计数和listappend方法中工作吗？
4.超级，不，我不认为这是必要的或特别可取的。这些
专业与dict密切相关。 dict.method（self，...）感觉
在这种情况下更合适。
Michael
Georg:
A few reactions:
1. Given that these are specializations, why not have:
class defaultvaluedict(dict):
...
class defaultfactorydict(dict):
...
rather than having to jump through hoops to make one implementation satisfy both
cases
2. I would really prefer to have the default value specified in the constructor
I realize that this is tricky due to the kw arguments of dict.__init__, but I
would favor either breaking compatibility with that interface, or adopting some
workaround to make something like d= defaultvaluedict(__default__ = 0) possible.
One worksaround would be to store the default in the dict, not as an attribute
of the dict. By default the default value would be associated with the key
"__default__", but that keyname could be changed for the (I guess very few)
cases where that key conflicted with non-default content of the dict. Then
dict.__init__ would simply take __default__ = value as a keyword argument, as it
does today, and __getitem__ for a missing key would return
dict.__getitem__(self, "__default__")
Alternatively, you could provide factory functions to construct the defaultdict.
Someone (Michele?) recently posted an implementation of this
3. Can you work in the tally and listappend methods that started this whole
thread off?
4. On super, no I don''t think it''s necessary or particularly desirable. These
specializations have a close association with dict. dict.method(self,...) feels
more appropriate in this case.
Michael
这篇关于" specialdict"模的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
