Add hash table partial implementation template and unit tests

Author: neptunius

source/hashtable.py

@@ -0,0 +1,204 @@
+#!python
+
+from linkedlist import LinkedList
+
+
+class HashTable(object):
+
+    def __init__(self, init_size=8):
+        """Initialize this hash table with the given initial size."""
+        self.buckets = [LinkedList() for i in range(init_size)]
+        self.size = 0  # Number of key-value entries
+
+    def __str__(self):
+        """Return a formatted string representation of this hash table."""
+        items = ['{!r}: {!r}'.format(key, val) for key, val in self.items()]
+        return '{' + ', '.join(items) + '}'
+
+    def __repr__(self):
+        """Return a string representation of this hash table."""
+        return 'HashTable({!r})'.format(self.items())
+
+    def _bucket_index(self, key):
+        """Return the bucket index where the given key would be stored."""
+        return hash(key) % len(self.buckets)
+
+    def load_factor(self):
+        """Return the load factor, the ratio of number of entries to buckets.
+        Best and worst case running time: ??? under what conditions? [TODO]"""
+        # TODO: Calculate load factor
+        # return ...
+
+    def keys(self):
+        """Return a list of all keys in this hash table.
+        Best and worst case running time: ??? under what conditions? [TODO]"""
+        # Collect all keys in each of the buckets
+        all_keys = []
+        for bucket in self.buckets:
+            for key, value in bucket.items():
+                all_keys.append(key)
+        return all_keys
+
+    def values(self):
+        """Return a list of all values in this hash table.
+        Best and worst case running time: ??? under what conditions? [TODO]"""
+        # Collect all values in each of the buckets
+        all_values = []
+        for bucket in self.buckets:
+            for key, value in bucket.items():
+                all_values.append(value)
+        return all_values
+
+    def items(self):
+        """Return a list of all entries (key-value pairs) in this hash table.
+        Best and worst case running time: ??? under what conditions? [TODO]"""
+        # Collect all pairs of key-value entries in each of the buckets
+        all_items = []
+        for bucket in self.buckets:
+            all_items.extend(bucket.items())
+        return all_items
+
+    def length(self):
+        """Return the number of key-value entries by traversing its buckets.
+        Best and worst case running time: ??? under what conditions? [TODO]"""
+        # Count number of key-value entries in each of the buckets
+        item_count = 0
+        for bucket in self.buckets:
+            item_count += bucket.length()
+        return item_count
+        # Equivalent to this list comprehension:
+        return sum(bucket.length() for bucket in self.buckets)
+
+    def contains(self, key):
+        """Return True if this hash table contains the given key, or False.
+        Best case running time: ??? under what conditions? [TODO]
+        Worst case running time: ??? under what conditions? [TODO]"""
+        # Find the bucket the given key belongs in
+        index = self._bucket_index(key)
+        bucket = self.buckets[index]
+        # Check if an entry with the given key exists in that bucket
+        entry = bucket.find(lambda (k, v): k == key)
+        return entry is not None  # True or False
+
+    def get(self, key):
+        """Return the value associated with the given key, or raise KeyError.
+        Best case running time: ??? under what conditions? [TODO]
+        Worst case running time: ??? under what conditions? [TODO]"""
+        # Find the bucket the given key belongs in
+        index = self._bucket_index(key)
+        bucket = self.buckets[index]
+        # Find the entry with the given key in that bucket, if one exists
+        entry = bucket.find(lambda (k, v): k == key)
+        if entry is not None:  # Found
+            # Return the given key's associated value
+            assert isinstance(entry, tuple)
+            assert len(entry) == 2
+            return entry[1]
+        else:  # Not found
+            raise KeyError('Key not found: {}'.format(key))
+
+    def set(self, key, value):
+        """Insert or update the given key with its associated value.
+        Best case running time: ??? under what conditions? [TODO]
+        Worst case running time: ??? under what conditions? [TODO]"""
+        # Find the bucket the given key belongs in
+        index = self._bucket_index(key)
+        bucket = self.buckets[index]
+        # Find the entry with the given key in that bucket, if one exists
+        # Check if an entry with the given key exists in that bucket
+        entry = bucket.find(lambda (k, v): k == key)
+        if entry is not None:  # Found
+            # In this case, the given key's value is being updated
+            # Remove the old key-value entry from the bucket first
+            bucket.delete(entry)
+        # Insert the new key-value entry into the bucket in either case
+        bucket.append((key, value))
+        # TODO: Check if the load factor exceeds a threshold such as 0.75
+        # ...
+        # TODO: If so, automatically resize to reduce the load factor
+        # ...
+
+    def delete(self, key):
+        """Delete the given key and its associated value, or raise KeyError.
+        Best case running time: ??? under what conditions? [TODO]
+        Worst case running time: ??? under what conditions? [TODO]"""
+        # Find the bucket the given key belongs in
+        index = self._bucket_index(key)
+        bucket = self.buckets[index]
+        # Find the entry with the given key in that bucket, if one exists
+        entry = bucket.find(lambda (k, v): k == key)
+        if entry is not None:  # Found
+            # Remove the key-value entry from the bucket
+            bucket.delete(entry)
+        else:  # Not found
+            raise KeyError('Key not found: {}'.format(key))
+
+    def _resize(self, new_size=None):
+        """Resize this hash table's buckets and rehash all key-value entries.
+        Should be called automatically when load factor exceeds a threshold
+        such as 0.75 after an insertion (when set is called with a new key).
+        Best and worst case running time: ??? under what conditions? [TODO]
+        Best and worst case space usage: ??? what uses this memory? [TODO]"""
+        # If unspecified, choose new size dynamically based on current size
+        if new_size is None:
+            new_size = len(self.buckets) * 2  # Double size
+        # Option to reduce size if buckets are sparsely filled (low load factor)
+        elif new_size is 0:
+            new_size = len(self.buckets) / 2  # Half size
+        # TODO: Get a list to temporarily hold all current key-value entries
+        # ...
+        # TODO: Create a new list of new_size total empty linked list buckets
+        # ...
+        # TODO: Insert each key-value entry into the new list of buckets,
+        # which will rehash them into a new bucket index based on the new size
+        # ...
+
+
+def test_hash_table():
+    ht = HashTable(4)
+    print('HashTable: ' + str(ht))
+
+    print('Setting entries:')
+    ht.set('I', 1)
+    print('set(I, 1): ' + str(ht))
+    ht.set('V', 5)
+    print('set(V, 5): ' + str(ht))
+    print('size: ' + str(ht.size))
+    print('length: ' + str(ht.length()))
+    print('buckets: ' + str(len(ht.buckets)))
+    print('load_factor: ' + str(ht.load_factor()))
+    ht.set('X', 10)
+    print('set(X, 10): ' + str(ht))
+    ht.set('L', 50)  # Should trigger resize
+    print('set(L, 50): ' + str(ht))
+    print('size: ' + str(ht.size))
+    print('length: ' + str(ht.length()))
+    print('buckets: ' + str(len(ht.buckets)))
+    print('load_factor: ' + str(ht.load_factor()))
+
+    print('Getting entries:')
+    print('get(I): ' + str(ht.get('I')))
+    print('get(V): ' + str(ht.get('V')))
+    print('get(X): ' + str(ht.get('X')))
+    print('get(L): ' + str(ht.get('L')))
+    print('contains(X): ' + str(ht.contains('X')))
+    print('contains(Z): ' + str(ht.contains('Z')))
+
+    print('Deleting entries:')
+    ht.delete('I')
+    print('delete(I): ' + str(ht))
+    ht.delete('V')
+    print('delete(V): ' + str(ht))
+    ht.delete('X')
+    print('delete(X): ' + str(ht))
+    ht.delete('L')
+    print('delete(L): ' + str(ht))
+    print('contains(X): ' + str(ht.contains('X')))
+    print('size: ' + str(ht.size))
+    print('length: ' + str(ht.length()))
+    print('buckets: ' + str(len(ht.buckets)))
+    print('load_factor: ' + str(ht.load_factor()))
+
+
+if __name__ == '__main__':
+    test_hash_table()

source/hashtable_test.py

@@ -0,0 +1,155 @@
+#!python
+
+from hashtable import HashTable
+import unittest
+
+
+class HashTableTest(unittest.TestCase):
+
+    def test_init(self):
+        ht = HashTable(4)
+        assert len(ht.buckets) == 4
+        assert ht.length() == 0
+        assert ht.size == 0
+
+    def test_keys(self):
+        ht = HashTable()
+        assert ht.keys() == []
+        ht.set('I', 1)
+        assert ht.keys() == ['I']
+        ht.set('V', 5)
+        self.assertItemsEqual(ht.keys(), ['I', 'V'])  # Ignore item order
+        # Python 3 unittest module renamed this assertion method
+        # self.assertCountEqual(ht.keys(), ['I', 'V'])  # Ignore item order
+        ht.set('X', 10)
+        self.assertItemsEqual(ht.keys(), ['I', 'V', 'X'])  # Ignore item order
+        # Python 3 unittest module renamed this assertion method
+        # self.assertCountEqual(ht.keys(), ['I', 'V', 'X'])  # Ignore item order
+
+    def test_values(self):
+        ht = HashTable()
+        assert ht.values() == []
+        ht.set('I', 1)
+        assert ht.values() == [1]
+        ht.set('V', 5)
+        self.assertItemsEqual(ht.values(), [1, 5])  # Ignore item order
+        # Python 3 unittest module renamed this assertion method
+        # self.assertCountEqual(ht.values(), [1, 5])  # Ignore item order
+        ht.set('X', 10)
+        self.assertItemsEqual(ht.values(), [1, 5, 10])  # Ignore item order
+        # Python 3 unittest module renamed this assertion method
+        # self.assertCountEqual(ht.values(), [1, 5, 10])  # Ignore item order
+
+    def test_items(self):
+        ht = HashTable()
+        assert ht.items() == []
+        ht.set('I', 1)
+        assert ht.items() == [('I', 1)]
+        ht.set('V', 5)
+        self.assertItemsEqual(ht.items(), [('I', 1), ('V', 5)])
+        # Python 3 unittest module renamed this assertion method
+        # self.assertCountEqual(ht.items(), [('I', 1), ('V', 5)])
+        ht.set('X', 10)
+        self.assertItemsEqual(ht.items(), [('I', 1), ('V', 5), ('X', 10)])
+        # Python 3 unittest module renamed this assertion method
+        # self.assertCountEqual(ht.items(), [('I', 1), ('V', 5), ('X', 10)])
+
+    def test_length(self):
+        ht = HashTable()
+        assert ht.length() == 0
+        ht.set('I', 1)
+        assert ht.length() == 1
+        ht.set('V', 5)
+        assert ht.length() == 2
+        ht.set('X', 10)
+        assert ht.length() == 3
+
+    def test_size(self):
+        ht = HashTable()
+        assert ht.size == 0
+        ht.set('I', 1)
+        assert ht.size == 1
+        ht.set('V', 5)
+        assert ht.size == 2
+        ht.set('X', 10)
+        assert ht.size == 3
+
+    def test_resize(self):
+        ht = HashTable(2)  # Set init_size to 2
+        assert ht.size == 0
+        assert len(ht.buckets) == 2
+        assert ht.load_factor() == 0
+        ht.set('I', 1)
+        assert ht.size == 1
+        assert len(ht.buckets) == 2
+        assert ht.load_factor() == 0.5
+        ht.set('V', 5)  # Should trigger resize
+        assert ht.size == 2
+        assert len(ht.buckets) == 4
+        assert ht.load_factor() == 0.5
+        ht.set('X', 10)
+        assert ht.size == 3
+        assert len(ht.buckets) == 4
+        assert ht.load_factor() == 0.75
+        ht.set('L', 50)  # Should trigger resize
+        assert ht.size == 4
+        assert len(ht.buckets) == 8
+        assert ht.load_factor() == 0.5
+
+    def test_contains(self):
+        ht = HashTable()
+        ht.set('I', 1)
+        ht.set('V', 5)
+        ht.set('X', 10)
+        assert ht.contains('I') is True
+        assert ht.contains('V') is True
+        assert ht.contains('X') is True
+        assert ht.contains('A') is False
+
+    def test_set_and_get(self):
+        ht = HashTable()
+        ht.set('I', 1)
+        ht.set('V', 5)
+        ht.set('X', 10)
+        assert ht.get('I') == 1
+        assert ht.get('V') == 5
+        assert ht.get('X') == 10
+        assert ht.length() == 3
+        assert ht.size == 3
+        with self.assertRaises(KeyError):
+            ht.get('A')  # Key does not exist
+
+    def test_set_twice_and_get(self):
+        ht = HashTable()
+        ht.set('I', 1)
+        ht.set('V', 4)
+        ht.set('X', 9)
+        assert ht.length() == 3
+        assert ht.size == 3
+        ht.set('V', 5)  # Update value
+        ht.set('X', 10)  # Update value
+        assert ht.get('I') == 1
+        assert ht.get('V') == 5
+        assert ht.get('X') == 10
+        assert ht.length() == 3  # Check length is not overcounting
+        assert ht.size == 3  # Check size is not overcounting
+
+    def test_delete(self):
+        ht = HashTable()
+        ht.set('I', 1)
+        ht.set('V', 5)
+        ht.set('X', 10)
+        assert ht.length() == 3
+        assert ht.size == 3
+        ht.delete('I')
+        ht.delete('X')
+        assert ht.length() == 1
+        assert ht.size == 1
+        with self.assertRaises(KeyError):
+            ht.delete('X')  # Key no longer exists
+        with self.assertRaises(KeyError):
+            ht.delete('A')  # Key does not exist
+
+
+if __name__ == '__main__':
+    unittest.main()