shannon algo

import math
from collections import Counter
import operator

class ShanonFanno(object):

    def __init__(self):
        self.sum_logs_with_pis = 0
        self.size_after_compress = 0
        self.sorted_s = ""
        self.char_dict = dict()

    def devide_chars(self, x, itr, code):
        if len(x) == 2 : return [[x[0], itr + 1, code + "0"], [x[1], itr + 1, code + "1"]]
        if len(x) == 1 : return [[x, itr, code]]
        index = self.break_the_node(x)
        return [self.devide_chars(x[:index+1], itr + 1, code + "0"), self.devide_chars(x[index+1:], itr + 1, code + "1")]

    def make_count(self):
        self.char_dict = dict(Counter(self.sentence))
        char_ls = sorted(self.char_dict.items(), key=operator.itemgetter(1),reverse=True)
        sorted_s = ""
        for i in char_ls :
            sorted_s += i[0]
        return self.char_dict, sorted_s

    def flatten_the_tree(self, tree):
            leaf = False
            flat_list = []
            if len(tree) == 1 : tree = tree[0]
            while(leaf == False):


                if type(tree[-1]) is not list:

                    if len(tree) != 3 : break

                    leaf = True
                    pi = self.sentence.count(tree[0])/self.total
                    log_pi = math.log(1/pi, 2)
                    x = tree.copy()
                    x.append(pi)
                    self.sum_logs_with_pis += pi * log_pi
                    return [x]
                else:

                    flat_right = []
                    flat_left = []
                    flat_right.extend(self.flatten_the_tree(tree[0]))
                    flat_left.extend(self.flatten_the_tree(tree[1]))
                    flat_list.extend(flat_right)
                    flat_list.extend(flat_left)
                    return flat_list




    def break_the_node(self, node):
        total = 0
        for i in node :
            total += self.char_dict[i]
        length = len(node)
        count = 0
        last_char_index = 0
        for i in range(length//2):
            count += self.char_dict[self.sorted_s[i]]
            if (count - (total/2) >= 0):
                last_char_index = i +1
                break
        return last_char_index




    def do_the_work(self,s):
        s = s.replace(' ', '')
        self.sentence = s
        self.total = len(s)
        self.char_dict, self.sorted_s = self.make_count()
        last_char_index = self.break_the_node(self.sorted_s)
        left = self.sorted_s[:last_char_index]
        right = self.sorted_s[last_char_index:]
        left_tree = self.devide_chars(left, 1, "0")
        right_tree = self.devide_chars(right, 1, "1")

        left_flat = self.flatten_the_tree(left_tree)
        right_flat = self.flatten_the_tree(right_tree)
        self.final_flat = []
        self.final_flat.extend(left_flat)
        self.final_flat.extend(right_flat)
        self.write_final_logs(self.final_flat)

    def write_final_logs(self, final_flat):
        for i in final_flat :
            count = self.sentence.count(i[0])
            print("Символ: {0} => [код: {1}], [частота: {2}]".format(i[0],i[2],count))

s2 = input('Введите текст до 255 символов')
sh = ShanonFanno()
sh.do_the_work(s2)