0

d が dict であるとします

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

このように与えると

d.has_key(' a ')
True

しかし、これは誤りです

d.has_key('a')
False

だから私はこのように試しました

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

空白を取り除かずにスペースを持つ辞書キーを見つける方法

前もって感謝します

4

7 に答える 7

3

それらを削除する必要があります。

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}と の場合、これは任意の値を 1 つだけ返しますkey = 'a'。

于 2012-06-13T13:14:55.463 に答える
1

このジェネレータ式を使用できます：'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
于 2012-06-13T13:25:23.663 に答える
1

頻繁に必要な場合は、次のようにサブクラス化できます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()が True の場合、このクラスは正常に動作します。n != m

于 2012-06-13T13:23:57.630 に答える
0

@astynaxの回答に示されている概念-辞書サブクラスの派生-は正しい軌道に乗っていたと思いますが、不完全です...おそらく、相互に関連するメソッドがかなりあるため、完全な辞書サブクラスを提供するのは大変な作業になる可能性があるためですオーバーライドする必要があります。

UserDict.DictMixinこれを避けるための近道は、 の代わりにクラスからサブクラスを派生させることですdict。利点は、記述する必要があるメソッドの数が最小 4 つに減るということです。最適化としていくつかの追加のものを実装することで、より効率を高めることができます。

これを行う完全な動作例を次に示します。キーの周りの空白を無視することを除いて、辞書オブジェクトとほぼ同じように動作するものになります。おそらくキーを削除する場合を除いて、パフォーマンスは標準のディクショナリとほぼ同じになりますが、より多くのメモリを使用します。

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"
于 2012-06-13T19:19:00.990 に答える
0 
>>>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
于 2012-06-13T13:39:09.593 に答える
0

多くのテストが必要な場合は、削除された値の辞書を作成することをお勧めします。

>>> 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)
于 2012-06-13T13:19:21.670 に答える
0 
d = {' a':'b',' c ':'c','b ':'b'}
key = ' a'
[d[l] for l in  d.iterkeys() if l.strip() == key.strip()]
['b']
于 2012-06-13T13:21:20.187 に答える