重写字典行为Python3

Question

我是一名初学者，使用Python并试图在字典中使用搜索功能来搜索具有点坐标（2）的numpy数组的键。所以，我想要的是：一个字典，其键是numpy数组，其值是整数。然后使用in运算符来比较使用某种容差度量（numpy.allclose函数）的键。据我所知，numpy数组并不是必须的，因此我必须重写getitem和setitem函数（基于我在How to properly subclass dict and override __getitem__ & __setitem__中找到的内容）。但是，如何让这些哈希值可以在字典中添加为键？如何覆盖这种情况下in运算符的行为？

感谢您的帮助！

Answer 1

而不是一个numpy数组，使用浮点数的2元组作为关键。元组是可变的，因为它们是不可变的。

Python字典在后台使用hash-table来快速进行密钥查找。

写一个closeto函数并不难;

def closeto(a, b, limit=0.1): 
    x, y = a 
    p, q = b 
    return (x-p)**2 + (y-q)**2 < limit**2 

这可以用来找到接近的点。但是，你必须迭代所有的密钥，因为密钥查找是确切的。但是如果你在理解中做了这样的迭代，它比它的循环快得多。

测试（在IPython中，使用Python 3）：

In [1]: %cpaste 
Pasting code; enter '--' alone on the line to stop or use Ctrl-D. 
: def closeto(a, b, limit=0.1): 
:  x, y = a 
:  p, q = b 
:  return (x-p)**2 + (y-q)**2 < limit**2 
:-- 

In [2]: d = {(0.0, 0.0): 12, (1.02, 2.17): 32, (2.0, 4.2): 23} 

In [3]: {k: v for k, v in d.items() if closeto(k, (1.0, 2.0), limit=0.5)} 
Out[3]: {(1.02, 2.17): 32} 

Answer 2

转换的数组元组，其中是可哈希：

In [18]: a1 = np.array([0.5, 0.5]) 

In [19]: a2 = np.array([1.0, 1.5]) 

In [20]: d = {} 

In [21]: d[tuple(a1)] = 14 

In [22]: d[tuple(a2)] = 15 

In [23]: d 
Out[23]: {(0.5, 0.5): 14, (1.0, 1.5): 15} 

In [24]: a3 = np.array([0.5, 0.5]) 

In [25]: a3 in d 
--------------------------------------------------------------------------- 
TypeError         Traceback (most recent call last) 
<ipython-input-25-07c81d61b999> in <module>() 
----> 1 a3 in d 

TypeError: unhashable type: 'numpy.ndarray' 

In [26]: tuple(a3) in d 
Out[26]: True 

不幸的是，因为你想申请一个宽容比较，你没有太多的选择，只能迭代所有寻找“关闭”匹配的键，不管你是作为函数还是联机来实现。

Answer 3

Numpy数组不可哈希，但元组是。所以你可以散列数组，如果你把它变成一个元组。从理论上讲，如果您事先将其舍入，则可以利用快速查找，因为您现在有离散点。但是在翻译过程中你会得到解决的问题，因为舍入是用十进制来完成的，但是数字是以二进制存储的。可以通过将其转换为缩放整数来规避这种情况，但会使所有内容都变慢。

最后，你只需要编写一个类，它可以在数组和元组之间来回转换，而且你很好。
实现可能是这样的：

import numpy as np 

class PointDict(dict): 

    def __init__(self, precision=5): 
     super(PointDict, self).__init__() 
     self._prec = 10**precision 

    def decode(self, tup): 
     """ 
     Turns a tuple that was used as index back into a numpy array. 
     """ 
     return np.array(tup, dtype=float)/self._prec 

    def encode(self, ndarray): 
     """ 
     Rounds a numpy array and turns it into a tuple so that it can be used 
     as index for this dict. 
     """ 
     return tuple(int(x) for x in ndarray*self._prec) 

    def __getitem__(self, item): 
     return self.decode(super(PointDict, self).__getitem__(self.encode(item))) 

    def __setitem__(self, item, value): 
     return super(PointDict, self).__setitem__(self.encode(item), value) 

    def __contains__(self, item): 
     return super(PointDict, self).__contains__(self.encode(item)) 

    def update(self, other): 
     for item, value in other.items(): 
      self[item] = value 

    def items(self): 
     for item in self: 
      yield (item, self[item]) 

    def __iter__(self): 
     for item in super(PointDict, self).__iter__(): 
      yield self.decode(item) 

当寻找了很多分，与量化批量写入/查找纯numpy的解决方案可能会更好。然而，这个解决方案很容易理解和实现。