added solutions for last week

Author: Maria Mckinley

solutions/Session08/circle.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+"""
+nifty Circle class
+
+Used to demo propeties and "magic methods"
+"""
+
+from math import pi
+import functools
+
+
+# this is a trick to make all the greater than, less than, etc work.
+# see: https://docs.python.org/3.6/library/functools.html#functools.total_ordering
+@functools.total_ordering
+class Circle(object):
+    """
+    simple class to represent a circle
+
+    one you can do math with -- a bit odd...
+    """
+
+    def __init__(self, radius):
+        self.radius = float(radius)
+
+    @classmethod
+    def from_diameter(cls, diameter):
+        return cls(diameter / 2.0)
+
+    @property
+    def diameter(self):
+        return self.radius * 2.0
+    @diameter.setter
+    def diameter(self, value):
+        self.radius = value / 2.0
+
+    @property
+    def area(self):
+        return self.radius**2 * pi
+
+    def __repr__(self):
+        # usingthe repr attributes is a neat trick
+        return "Circle({:s})".format(repr(self.radius))
+
+    def __str__(self):
+        return "Circle with radius: {:g}".format(self.radius)
+
+    def __add__(self, other):
+        return Circle(self.radius + other.radius)
+
+    def __iadd__(self, other):
+        """
+        for "augmented assignment" -- can be used for in-place addition
+
+        Generally used that way for mutable types. This approach returns
+        self, so that the object is changed in place -- i.e. mutated
+        """
+        self.radius += other.radius
+        return self
+
+    def __mul__(self, factor):
+        return Circle(self.radius * factor)
+
+    def __imul__(self, factor):
+        """see __iadd__"""
+        self.radius *= factor
+        return self
+
+    def __rmul__(self, factor):
+        return Circle(self.radius * factor)
+
+    # You can define them all:
+    #  Might be useful for odd situations (and better performance)
+    # def __eq__(self, other):
+    #     return self.radius == other.radius
+    # def __ne__(self, other):
+    #     return self.radius != other.radius
+    # def __gt__(self, other):
+    #     return self.radius > other.radius
+    # def __ge__(self, other):
+    #     return self.radius >= other.radius
+    # def __lt__(self, other):
+    #     return self.radius < other.radius
+    # def __le__(self, other):
+    #     return self.radius <= other.radius
+
+    # Or you can put the @total_ordering decorator on the class definition
+    # and do only these:
+    def __eq__(self, other):
+        return self.radius == other.radius
+
+    def __lt__(self, other):
+        return self.radius < other.radius
+
+
+# This demostrates how you can
+#  subclass and get everyhting -- even the alternate constructor!
+class Sphere(Circle):
+    """
+    A simple Sphere object, which you can do math with...
+    """
+
+    def volume(self):
+        return 4 / 3 * pi * self.radius ** 3
+
+    def area(self):
+        raise NotImplementedError("Spheres don't have an area")
+
+    def __repr__(self):
+        return "Sphere({:g})".format(self.radius)
+
+    def __str__(self):
+        return "Sphere with radius: {:g}".format(self.radius)
+

solutions/Session08/quad.py

@@ -0,0 +1,11 @@
+
+class Quadratic:
+    def __init__(self, a, b, c):
+        self.a = a
+        self.b = b
+        self.c = c
+    def __call__(self, x):
+        return self.a * x**2 + self.b * x + self.c
+
+
+#my_quad = Quadratic(a=2, b=3, c=1)

solutions/Session08/sparse_array/slice_sparse.py

@@ -0,0 +1,139 @@
+
+"""
+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 __str__(self):
+        msg = ['SparseArray: [']
+        for i in range(self.length):
+            msg.append("{} ".format(self[i]))
+        msg.append(']')
+        return "".join(msg)
+
+    def __getitem__(self, index):
+        # this version supports slicing -- far more complicated
+        mini_array = []
+        if isinstance(index, slice):
+            start, stop, step = index.indices(len(self))
+            if step is None:
+                step = 1
+            key = start
+            mini_array = []
+            while key < stop:
+                mini_array.append(self[key])
+                key += step
+            return mini_array
+        else:
+            # makes it an int, even if it's some other
+            # type that supports being used as an index
+            index = index.__index__()
+            return self._get_single_value(index)
+
+    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, slice):
+            start, stop, step = index.indices(len(self))
+            if step is None:
+                step = 1
+            key = start
+            new_values = []
+            new_keys = []
+            for each in value:
+                if key < stop:
+                    self[key] = each
+                else:
+                    # now instead of replacing values, we need to add (a) value(s) in the center,
+                    # and move stuff over, probably want to collect all of the changes,
+                    # and then make a new dictionary
+                    new_values.append(each)
+                    new_keys.append(key)
+                key += step
+            if new_keys:
+                self._add_in_slice(new_keys, new_values)
+        else:
+            index = index.__index__()
+            self._set_single_value(index, value)
+
+    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 _add_in_slice(self, new_keys, new_values):
+        # sometimes we need to add in extra values
+        # any existing values
+        # greater than the last key of the new data
+        # will be increased by how many
+        new_dict = {}
+        slice_length = len(new_keys)
+        for k, v in self.sparse_array.items():
+            if k >= new_keys[-1]:
+                # print('change keys')
+                # if greater than slice, change key
+                new_dict[k + slice_length] = v
+            elif k in new_keys:
+                # if this is a key we are changing, change it,
+                # unless we are changing to a zero...
+                new_value = values[new_keys.index(k)]
+                if new_value != 0:
+                    new_dict[k] = new_value
+            else:
+                new_dict[k] = v
+        # what if our new key was not previously in the dictionary?
+        # stick it in now
+        for k in new_keys:
+            if k not in new_dict.keys():
+                new_dict[k] = new_values[new_keys.index(k)]
+        # 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
+        # now we need to increase the length by the amount we increased our array by
+        self.length += slice_length
+
+    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.items():
+                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/sparse_array/sparse_array.py

@@ -0,0 +1,75 @@
+
+"""
+An example of emulating a sequence
+
+A SparseArray is like a list, but only stores the non-zero values
+
+It can be indexed, appended-to, and iterated through.
+
+This version does not support slicing.
+"""
+
+
+class SparseArray(object):
+
+    def __init__(self, my_array=()):
+        """
+        initilize a sparse array
+
+        :param my_array: an initial sequence to start with
+                         if there are zeros in it, they wil not be stored
+        """
+        self.length = len(my_array)
+        # self.sparse_array is a dict that stores only the non-zero items
+        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:  # remember that zeros are falsey.
+                sparse_array[index] = number
+        # or the dict comprehension method:
+        # sparse_array = {index:number for index, number in enumerate(my_array) if number}
+        return sparse_array
+
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, key):
+        # fixme: doesn't handle negative indexes properly
+        try:
+            return self.sparse_array[key]
+        except KeyError:
+            if key >= self.length:
+                raise IndexError('array index out of range')
+            return 0
+
+    def __setitem__(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:  # it's the last item -- easy.
+            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.items():
+                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