霍夫曼编码机

data = np.array([
        ["病人","头疼","肌肉疼","体温","流感"]
        ,["e1",'是', '是', '正常', '否']
        ,["e2",'是', '是', '高', '是']
        ,["e3",'是', '是', '很高', '是']
        ,["e4",'否', '是', '正常', '否']
        ,["e5",'否', '否', '高', '否']
        ,["e6",'否', '是', '很高', '是']])


class huffman:

    def __init__(self,arr=np.zeros((4,4))):
        self.m,self.n = arr.shape
        self.info = arr
        self.mn = len(arr.shape)
        self.dict_binary_encode = binary_dict(arr)
        self.dict_binary_decode = {j:i for i,j in self.dict_binary_encode.items()}
        

    def binarycoder(self,quotient):
        result = []
        while quotient > 0:  
            quotient,remainder=divmod(quotient,2)
            result.append(remainder)
        return result[::-1]
    
    def binary_range(self,n):
        max_index = n - 1
        max_lenght = len(binarycoder(max_index))
        return [[0]*(max_lenght - len(binarycoder(i)))+binarycoder(i) for i in range(n)]
    
    def prob(self,info):
        dim_one = np.ravel(info) 
        distion = np.unique(dim_one)
        m = dim_one.shape[0]
        prob_dict = {d:(dim_one==d).dot(np.ones(m)) for d in  distion}
        return np.array(sorted(prob_dict.items(),key=lambda x:x[1],reverse=True))
    
    def binary_dict(self,info):
        elements = (prob(info)[:,0])
        m = elements.shape[0]
        return {j:"{}{}".format("0b","".join(list(map(lambda x:str(x) ,i)))) for i,j in zip(binary_range(m),elements)}

    def huffman_encoder(self,dim = None):
        zero = np.zeros((self.m,self.n)).astype(str)
        for d,v in self.dict_binary_encode.items():
            bool_ = (self.info == d)
            zero[bool_] = v
        if dim == 1:
            return np.ravel(zero)
        return zero

    def huffman_decoder(self,binary=None,dim=None):
        if binary == None:
            binary = self.huffman_encoder()
            m , n = binary.shape
            res = np.array([self.dict_binary_decode[i] for i in np.ravel(binary)])
            if dim == 1:
                return res
            return res.reshape(m,n)

    def __del__(self):
        print('test')


#
huffman_encoder(data)
h = huffman(data)
h.m
h.info
h.binary_range(64)
h.huffman_encoder(),h.huffman_decoder()