Is there a better way to implement this Huffman Algorithm in Python?

From my part I will start to fix some pep8 issues...

from collections import Counter


class Node(object):
    def __init__(self, pairs, frequency):
        self.pairs = pairs
        self.frequency = frequency

    def __repr__(self):
        return repr(self.pairs) + ", " + repr(self.frequency)

    def merge(self, other):
        total_frequency = self.frequency + other.frequency
        for p in self.pairs:
            p[1] = "1" + p[1]
        for p in other.pairs:
            p[1] = "0" + p[1]
        new_pairs = self.pairs + other.pairs
        return Node(new_pairs, total_frequency)


def huffman_codes(s):
    frequency_table = Counter(s)
    initial_table = []
    for k, v in frequency_table.items():
        initial_table.append([k, v])
    initial_table = sorted(initial_table, key=lambda p: p[1])
    # print(initial_table)
    table = []
    for entry in initial_table:
        ch = entry[0]
        freq = entry[1]
        table.append(Node([[ch, ""]], freq))
    # print(table)
    while len(table) > 1:
        first_node = table.pop(0)
        second_node = table.pop(0)
        new_node = first_node.merge(second_node)
        table.append(new_node)
        table = sorted(table, key=lambda n: n.frequency)
        # print(table)
    return dict(map(lambda p: (p[0], p[1]), table[0].pairs))

print(huffman_codes('yashaswita'))

Really does belong on codereview.

1. Use four space indentation. This is the Python standard, and will make any code more "Pythonic". Edit: You're following PEP-8 in all other respects as far as I can tell, so if you like two space indentation, it's not a big deal. Your code is very easy to read.

2. You don't need to sort every time; you don't even need a fully sorted list. Python has a datatype for this -- it's called heapq. Use it's heappush and heappop methods, so you don't have to sort every time. You can actually write a single line loop to do the tree building. Read what that page says about priority queues -- it's what you're using.

3. You don't need anything like

   return dict(map(lambda p: (p[0], p[1]), table[0].pairs))
   

   just

   return dict(table[0].pairs)
   

   does exactly the same thing.

4. If you really want to minimize lines, everything before the while can be written as one line:

   table = sorted((Node([[p[0], ""]], p[1]) for p in Counter(s).iteritems()), key = lambda n : n.frequency)
   

Generally, loops aren't encouraged in python, since it is interpreted rather than compiled, thus the loop body will be "recompiled" at every iteration.

using map/reduce is one good way to avoid loops. another is using the for.. in, e.g.:

initial_table=[[k, v] for k, v in frequency_table.items()]

and similarly for your 2nd for loop.