huffman编解码英文文本[Python]

对英文文本的字母进行huffman编码，heapq优先队列构建huffman树

python huffman.py source.txt result.txt

 import sys
 import heapq
 import collections

 class Node(object):
     def __init__(self,value = None,count = 1,left = None,right = None, code = ''):
         self.value = value
         self.count = count
         self.left = left
         self.right = right
         self.code = code

     def isleaf(self):
         if self.left != None:
             return False
         elif self.right != None:
             return False
         else:
             return True

     def __repr__(self):
         return "Node(%r,%r)"%(self.value,self.count)
     #for sort or priority queue
     def __lt__(self,other):
         return self.count < other.count
     #for operator +
     def __add__(self,other):
         self.code = 0
         other.code = 1
         # only leaf node value is need
         return Node(self.value+other.value,self.count+other.count,self,other)

 def getTreeRoot(text):
     Counter = collections.Counter(text)
     head = [Node(k,v) for (k,v) in Counter.items()]
     heapq.heapify(head)

     while len(head) >= 2:
         heapq.heappush(head, heapq.heappop(head) + heapq.heappop(head))

     root = head[0]
     return root

 def huffman(root, prefix = []):
     code = {}
     if root is None:
         return code
     prefix = prefix + [root.code]
     if root.isleaf():
         code[root.value] = prefix
     else:
         code.update(huffman(root.left,prefix))
         code.update(huffman(root.right,prefix))
     return code

 def gethuffmantext(text):
     root = getTreeRoot(text)
     codebook = huffman(root)
     for k,v in codebook.items():
         newv = "".join(str(char) for char in v)
         codebook[k] = newv
     print (codebook)
     print("The original text size is {}".format(len(text) * 8))
     huffmantext = []
     lenhuffman = 0
     for char in text:
         lenhuffman += len(codebook[char])
         huffmantext.append(codebook[char])
     print ("The huffman code text size is {}".format(lenhuffman))

     return huffmantext, codebook, lenhuffman

 def gettextfromhuffmancode(huffmantext,codebook):

     reversecodebook = {value:key for (key,value) in codebook.items()}

     text = []
     for huffmancode in huffmantext:
         text.append(reversecodebook[huffmancode])

     return text

 if __name__ == "__main__":
     text = open(sys.argv[1],"rb").read()
     newfile = sys.argv[2]
     #huffmantext, codebook, lenhuffman = gethuffmantext("hello world")
     huffmantext, codebook, lenhuffman = gethuffmantext(text)
     text1 = gettextfromhuffmancode(huffmantext,codebook)
     text1 = "".join(str(v) for v in text1)

     lenoftext = len(text)*8.0
     lenofhuffman = lenhuffman

     print ("The compression ratio is %lf  \n" % (1.0 * lenhuffman / lenoftext ))

     fp = open(newfile,"wb")
     fp.write(text1)
     fp.close()