separated sparse array from sparse array using slices, have all tests passing, probably need more tests

Author: codedragon

.gitignore

@@ -3,4 +3,4 @@ slides_sources/build
 #ignore compiled files, sublime workspace and project files
 *.pyc
 *.sublime*
-
+*.*~

Solutions/Session08/slice_sparse.py

@@ -0,0 +1,96 @@
+
+"""
+example of emulating a sequence using slices
+"""
+
+class SparseArray(object):
+
+    def __init__(self, my_array=()):
+        self.length = len(my_array)
+        self.sparse_array = self.convert_to_sparse(my_array)
+
+    def convert_to_sparse(self, my_array):
+        sparse_array = {}
+        for index, number in enumerate(my_array):
+            if number:
+                sparse_array[index] = number
+        return sparse_array
+
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, index):
+        print('index', index)
+        print('length', self.length)
+        # create a list of the slice they want returned
+        mini_array = []
+        if isinstance(index, int):
+            return self.get_single_value(index)
+        elif isinstance(index, slice):
+            start, stop, step = index.indices(len(self))
+            if step is None:
+                step = 1
+            key = start
+            mini_array = []
+            while key < stop + 1:
+                print('key', key)
+                mini_array.append(self.get_single_value(key))
+                key += step
+        else:
+            raise TypeError("index must be int or slice")
+        return mini_array[:]
+
+    def get_single_value(self, key):
+        if key >= self.length:
+            raise IndexError('array index out of range')
+        else:
+            return self.sparse_array.get(key, 0)
+
+    def __setitem__(self, index, value):
+        if isinstance(index, int):
+            self.set_single_value(index, value)
+        elif isinstance(index, slice):
+            start, stop, step = index.indices(len(self))
+            if step is None:
+                step = 1
+            key = start
+            for each in value:
+                print('key', key)
+                self.set_single_value(key, each)
+                key += step
+        else:
+            raise TypeError("index must be int or slice")
+
+    def set_single_value(self, key, value):
+        if key > self.length:
+            raise IndexError('array assignment index out of range')
+        if value != 0:
+            self.sparse_array[key] = value
+        else:
+            # if the value is being set to zero, we probably need to 
+            # remove a key from our dictionary.
+            self.sparse_array.pop(key, None)
+
+    def __delitem__(self, key):
+        # we probably need to move the keys if we are not deleting the last 
+        # number, use pop in case it was a zero
+        if key == self.length - 1:
+            self.sparse_array.pop(key, None)
+        else:
+            # since we need to adjust all of the keys after the one we are 
+            # deleting, probably most efficient to create a new dictionary
+            new_dict = {}
+            for k, v in self.sparse_array.iteritems():
+                if k >= key:
+                    new_dict[k - 1] = v
+                else:
+                    new_dict[k] = v
+            # note we don't want to do update, since we need to make sure we are
+            # getting rid of the old keys, when we moved the value to a new key
+            self.sparse_array = new_dict
+        # length is now one shorter
+        self.length -= 1
+
+
+
+

Solutions/Session08/test_slice_sparse.py

@@ -0,0 +1,93 @@
+import pytest
+from slice_sparse import SparseArray
+
+
+def set_up():
+    my_array = [2, 0, 0, 0, 3, 0, 0, 0, 4, 5, 6, 0, 2, 9]
+    my_sparse = SparseArray(my_array)
+    return (my_array, my_sparse)
+
+def test_object_exists():
+    my_array, my_sparse = set_up()
+    assert isinstance(my_sparse, SparseArray)
+
+def test_get_non_zero_number():
+    my_array, my_sparse = set_up()
+    assert my_sparse[4] == 3
+
+def test_get_zero():
+    my_array, my_sparse = set_up()
+    assert my_sparse[1] == 0
+
+def test_get_element_not_in_array():
+    my_array, my_sparse = set_up()
+    with pytest.raises(IndexError):
+        my_sparse[14]
+
+def test_get_slice():
+    my_array, my_sparse = set_up()
+    assert my_sparse[2:4] == [0, 0, 3]
+
+def test_get_lenght():
+    my_array, my_sparse = set_up()
+    assert len(my_sparse) == 14
+
+def test_change_number_in_array():
+    my_array, my_sparse = set_up()
+    my_sparse[0] = 3
+    assert my_sparse[0] == 3
+    # make sure others aren't changed
+    assert my_sparse[1] == 0
+    # make sure still same length
+    assert len(my_sparse) == 14
+
+def test_change_number_in_array_to_zero():
+    my_array, my_sparse = set_up()
+    my_sparse[4] = 0
+    assert my_sparse[4] == 0
+    # make sure still same length
+    assert len(my_sparse) == 14
+
+def test_change_number_in_array_from_zero():
+    my_array, my_sparse = set_up()
+    my_sparse[1] = 4
+    assert my_sparse[1] == 4
+    # make sure still same length
+    assert len(my_sparse) == 14
+
+def test_change_slice():
+    my_array, my_sparse = set_up()
+    my_sparse[1:3] = [2, 3, 4]
+    assert my_sparse[1:3] == [2, 3, 4]
+
+def test_delete_number():
+    my_array, my_sparse = set_up()
+    del(my_sparse[4])
+    # if we delete the 4 position, should now be zero
+    assert my_sparse[4] == 0
+    # should have smaller length
+    assert len(my_sparse) == 13
+
+def test_delete_zero():
+    my_array, my_sparse = set_up()
+    del(my_sparse[5])
+    # should still be zero, but should have shorter length
+    assert my_sparse[5] == 0
+    assert len(my_sparse) == 13
+
+def test_delete_last_number():
+    my_array, my_sparse = set_up()
+    del(my_sparse[13])
+    # should get an error?
+    print 'print some stuf damnit'
+    with pytest.raises(IndexError):
+        my_sparse[13]
+    assert len(my_sparse) == 13
+
+def test_indices_change():
+    my_array, my_sparse = set_up()
+    del(my_sparse[3])
+    # next index should have changed
+    # my_sparse[4] was 3 now
+    # my_sparse[3] should be 3
+    assert (my_sparse[3] == 3)

Solutions/Session08/test_sparse_array.py

@@ -70,10 +70,16 @@ def test_delete_last_number():
     my_array, my_sparse = set_up()
     del(my_sparse[13])
     # should get an error?
-    print 'print some stuf damnit'
     with pytest.raises(IndexError):
         my_sparse[13]
     assert len(my_sparse) == 13
 
+def test_indices_change():
+    my_array, my_sparse = set_up()
+    del(my_sparse[3])
+    # next index should have changed
+    # my_sparse[4] was 3 now
+    # my_sparse[3] should be 3
+    assert (my_sparse[3] == 3)