ugly huffman code

from random import randint

from copy import copy

class huf_tree_node:
    def __init__(self,data=None,freq=None,left=None,right=None):
        self.data=data
        self.freq=freq
        self.left=left
        self.right=right

    def other_name(self, level=0):

        print('\t' * level + repr(self.data) + "  " + repr(self.freq))
        if self.left is not None:
            self.left.other_name(level + 1)
        if self.right is not None:
            self.right.other_name(level + 1)
    """def __repr__(self, level=0):
        ret = "\t" * level + repr(self.data) + "\n"

        ret += self.left.__repr__(level + 1)
        ret += self.right.__repr__(level + 1)
        return ret
        """
class huf_min_heap:
    def heapify(self,root):
        left = 2 * root + 1
        right = 2 * root + 2
        lowest = root

        if left < len(self.heap) and self.heap[left].freq < self.heap[lowest].freq:
            lowest = left

        if right < len(self.heap) and self.heap[right].freq < self.heap[lowest].freq:
            lowest = right


        if lowest != root:
            self.heap[root],self.heap[lowest]=self.heap[lowest],self.heap[root]
            self.heapify(lowest)
    def build_heap(self):

        for i in range(len(self.heap) // 2 , -1 ,-1):
            self.heapify(i)

    def add_to_heap(self,node):
        self.heap.append(node)
        self.added_last(len(self.heap)-1)

    def added_last(self,child):
        if child==0:
            return
        parent = (child - 1) // 2

        if self.heap[parent].freq > self.heap[child].freq:
            self.heap[child], self.heap[parent] = self.heap[parent], self.heap[child]
            self.added_last(parent)

    def get_min(self):
        res=self.heap[0]
        self.heap[0]=self.heap[len(self.heap)-1]
        del self.heap[len(self.heap)-1]
        self.heapify(0)
        return res


    def __init__(self,arr,key,data):
        self.heap=[]

        for i in range (len(arr)):
            tmp=huf_tree_node(arr[i][data],arr[i][key])
            self.heap.append(tmp)

        self.build_heap()

    def print_heap(self):
        print()
        for i in range (len(self.heap)):
            print(self.heap[i].data,self.heap[i].freq)
        print()

class huffman_tree:
    def __init__(self):
        self.root=None

    def create_tree(self,arr,key=0,data=1):
        self.arr=arr
        tmp=copy(arr)
        self.heap=huf_min_heap(tmp,key,data)

        #self.heap.print_heap()

        while len(self.heap.heap) > 1:
            left=self.heap.get_min()
            right=self.heap.get_min()

            top = huf_tree_node(None,left.freq+right.freq,left,right)

            self.heap.add_to_heap(top)

            #self.heap.print_heap()

        self.root=top


    def print_tree(self):
        def _print_tree(root,):
            if root is None:
                return
            print(root.freq,root.data)

            _print_tree(root.left)

            _print_tree(root.right)

        _print_tree(self.root)



    def get_code(self):
        def printArr(arr,n):
            for i in range(n):
                print(arr[i],end="")
            print()
        def printCode(arr,n):
            res=''
            for i in range(n):
                res+=str(arr[i])
            return res
        def _get_code(root,res,i,code):
            #print(i)
            if root.left is not None:
                res[i]=0
                _get_code(root.left,res,i+1,code)
            if root.right is not None:
                res[i]=1
                _get_code(root.right,res,i+1,code)
            if root.right is None and root.left is None:
                #print(root.data,end=" ")
                #printArr(res, i)
                code[self.k][0]=root.data
                code[self.k][1]=printCode(res,i)
                self.k += 1

        #code_table = [[None,None]]*len(self.arr)
        code_table=[]
        for i in range(len(self.arr)):
            code_table.append([None,None])

        #print(code_table)
        res=[None]*len(self.arr)

        self.k=0
        _get_code(self.root,res,0,code_table)
        del self.k
        #print(code_table)
        return code_table

    def other_name(self, level=0):
        self.root.other_name()

def upperCaseAlphabet(n):
    return chr(65+n)

n=10
arr=[]

for i in range(n):
    arr.append([randint(10,100),upperCaseAlphabet(i)])

#arr=[[50,'A'],[25,'B'],[75,'C'],[100,'D'],[25,'E'],[5,'F'],[50,'G'],[20,'H']]
print(arr)

tree=huffman_tree()
tree.create_tree(arr,0,1)

"""print("\n\n\n\n")
tree.print_tree()
print("\n\n\n\n")"""
code=tree.get_code()
print("\n",code)

#tree.other_name()