Question

假设d是dict

d={' a ':1,'b ':2}

如果我们这样给出

d.has_key(' a ')
True

但这是假的

d.has_key('a')
False

所以我尝试了这个

d.has_key('\sa\s')
False

所以如何找到有空格的dict键而不剥离它们的空格

提前致谢

Answer 1

您必须将其删除：

d = {' a ':1,'b ':2}
key = 'a'
print any(key == k.strip() for k in d.iterkeys())

打印True

要获取该值，您可以使用此方法：

def get_stripped(d, key):
    return next((v for k,v in d.iteritems() if key == k.strip()), None)

print get_stripped(d, 'a') # prints 1
print get_stripped(d, 'c') # prints None

如果d = {' a ': 1, ' a': 2}和key = 'a'，则只会返回一个任意值。

Answer 2

如果你经常需要它，你可以继承dict：

class D(dict):
    def __init__(self, *args, **kwargs):
        super(D, self).__init__(*args, **kwargs)
        self._skeys = dict((k.strip(), v) for k, v in self.iteritems())

    def __setitem__(self, key, val):
        super(D, self).__setitem__(key, val)
        self._skeys[key.strip()] = key

    def __getitem__(self, key):
        try:
            return dict.__getitem__(self, key)
        except KeyError:
            return self[self._skeys[key]]

    def __contains__(self, key):
        return (dict.__contains__(self, key) or key in self._skeys)

用法：

d = D({'a':1, 'b':2})
d['  c  '] = 3
print 'c' in d # True
print d['c'] # 3

如果任何key_n.strip() != key_m.strip()

n != m为True，则此类正常工作

Answer 3

您可以使用此生成器表达式：'a' in (item.strip() for item in d.keys())

>>> d={' a ':1, 'b ':2}
>>> 'a' in (item.strip() for item in d.keys())
True
>>> 'b' in (item.strip() for item in d.keys())
True
>>> 'c' in (item.strip() for item in d.keys())
False
>>> d
>>> {' a ': 1, 'b ': 2}

修改

要访问该值，您可以：

>>> for key, value in d.iteritems(): if key.strip()=='a': print value 1

或者，单行版本：

>>> [value for key, value in d.iteritems() if key.strip() == 'a'][0] 1 >>> [value for key, value in d.iteritems() if key.strip() == 'b'][0] 2

基本上，[value for key, value in d.iteritems() if key.strip() == 'b']会返回值列表，[0]会选择第一个值。如果您有几个类似的键，例如：

>>> d = {'a':1, ' a':2, ' a ':3}

然后你可以这样做：

>>> values = [value for key, value in d.iteritems() if key.strip() == 'a'] >>> len(values) 3 >>> values[0] 1 >>> values[1] 2 >>> values[2] 3

Answer 4

如果你需要测试很多，我建议你创建一个剥离值字典。

>>> d={' a ':1,'b ':2}
>>> t = dict( (pair[0].strip(), pair) for pair in d.iteritems())
>>> print t.has_key('a')
True
>>> print t['a']
(' a ', 1)

Answer 5

d = {' a':'b',' c ':'c','b ':'b'}
key = ' a'
[d[l] for l in  d.iterkeys() if l.strip() == key.strip()]
['b']

Answer 6

>>>d = {' a ':1, 'b ':2}
>>>dd = dict((l.strip(), v) for l, v in d.iteritems())
>>>dd
{'a':1, 'b':2}
>>>'a' in dd
True
>>>d['a']
1

Answer 7

我认为@ astynax的答案中显示的概念 - 派生一个字典子类 - 是在正确的轨道上然而它是不完整的...可能是因为提供一个完整的字典子类可能是很多工作，因为有很多相互关联的方法需要被覆盖。

避免这种情况的快捷方式是从UserDict.DictMixin类而不是dict派生子类。优点是它可以减少必须写入至少四个的方法的数量。通过实施几个额外的优化，可以获得更高的效率。

这是一个完整的工作示例，它执行此操作，导致某些行为几乎完全像字典对象，除了所需的忽略键周围的任何空白区域。除非删除密钥，否则性能应该几乎与标准字典的性能一样好，尽管它确实使用了更多的内存。

import UserDict

class WhiteOut(UserDict.DictMixin):
    """ Mapping object with white space insensitive keys """
    def __init__(self, *args, **kwargs):
        self._dict = dict(*args, **kwargs)
        self._skeys = dict((k.strip(), v) for k, v in self._dict.iteritems())

    def __getitem__(self, key):
        try:
            return self._dict.__getitem__(key)
        except KeyError:
            return self._skeys.__getitem__(key.strip())

    def __setitem__(self, key, val):
        self._dict.__setitem__(key, val)
        self._skeys.__setitem__(key.strip(), val)

    def __delitem__(self, key):
        try:
            self._dict.__delitem__(key)
        except KeyError:
            stripped_key = key.strip()
            try:
                self._skeys.__delitem__(stripped_key)
            except KeyError:
                raise
            else:  # delete item corresponding to stripped_key in _dict
                for akey in self._dict:
                    if akey.strip() == stripped_key:
                        self._dict.__delitem__(akey)
                        return

    def keys(self):
        return self._dict.keys()

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

    def __contains__(self, key):
        return self._skeys.__contains__(key.strip())

if __name__ == '__main__':
    wo = WhiteOut({'a':1, ' b':2})
    wo['  c  '] = 3
    print 'c' in wo # True
    print wo['c'] # 3
    print 'has_key:'
    print wo.has_key('  c  ')
    print wo.has_key('c')
    print wo['c '] # 3
    print 'wo.keys():', wo.keys()
    wokeys = [k for k in wo]
    print 'wo keys via iteration:', wokeys
    wo.pop("b")
    print 'wo.keys() after pop("b"):', wo.keys()
    try:
        wo.pop('not there')
    except KeyError:
        pass
    else:
        print "wo.pop('not there') didn't raise an exception as it should have"

如何使用空格标识dict键而不删除空格

7 个答案: