Merge pull request #69 from rsokl/oop_edits

Incorporate AJ's edits for Module 4... finally!

Author: rsokl

Python/Module4_OOP/ClassInstances.ipynb

@@ -6,14 +6,14 @@
  "source": [
  "# Instances of a Class\n",
  "\n",
- "Thus far we have learned about the syntax for defining a new class of object, specifying its name, attributes, and methods (which are attributes that are functions). The resulting *class object* is the singular object that encapsulates our class definition. We seldom will want to pass around or manipulate this class object once it is created. Rather, we will want to use it to create individual *instances* of that class. To be more concrete, `list` is a class object (remember that \"class\" and \"type\" are synonymous) - it is the same sort of object that is produced when a `class` definition is executed. As you saw in [Module 2](http://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/Basic_Objects.html#Lists), we can use this class object to create individual *instances* of the list class, each one containing its own sequence of items.\n",
+ "Thus far we have learned about the syntax for defining a new class of object, specifying its name, attributes, and methods (which are attributes that are functions). Once we leave the scope of the class definition, a class object is formed - the resulting *class object* is the singular object that encapsulates our class definition. We seldom will want to pass around or manipulate this class object once it is created. Rather, we will want to use it to create individual *instances* of that class. To be more concrete, `list` is a class object (remember that \"class\" and \"type\" are synonymous) - it is the same sort of object that is produced when a `class` definition is executed. As you saw in [Module 2](http://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/Basic_Objects.html#Lists), we can use this class object to create individual *instances* of the list class, each one containing its own sequence of items.\n",
  "\n",
  "```python\n",
  "# using the class object `list` to create list-instances\n",
- ">>> list()\n",
+ ">>> list() # create a `list`-instance that is empty\n",
  "[]\n",
  "\n",
- ">>> list((1, 2, 3))\n",
+ ">>> list((1, 2, 3)) # create a `list`-instance containing 1, 2, and 3\n",
  "[1, 2, 3]\n",
  "\n",
  "# `a` and `b` are distinct instances of the list class/type\n",
@@ -197,10 +197,12 @@
  ">>> y1 = y\n",
  "```\n",
  "\n",
- "What relationship do `x` and `y` share?\n",
- "\n",
  "What relationship do `x` and `Cat` share?\n",
  "\n",
+ "What relationship do `y` and `Cat` share?\n",
+ "\n",
+ "What relationship do `x` and `y` share?\n",
+ "\n",
  "What relationship do `x2` and `y` share?\n",
  "\n",
  "What relationship do `y` and `y1` share?\n",
@@ -432,11 +434,11 @@
  ">>> y1 = y\n",
  "```\n",
  "\n",
- "What relationship do `Cat` and `y` share?: `y` is in instance of `Cat`.\n",
+ "What relationship do `x` and `Cat` share?: `x` and `Cat` reference the same class object.\n",
  "\n",
- "What relationship do `x` and `y` share?: `x` references `Cat`, and `y` is an instance of `Cat`.\n",
+ "What relationship do `y` and `Cat` share?: `y` is an instance of the `Cat` class.\n",
  "\n",
- "What relationship do `x` and `Cat` share?: `x` and `Cat` reference the same class object.\n",
+ "What relationship do `x` and `y` share?: `x` references `Cat`, and `y` is an instance of `Cat`. Thus `y` is an instance of `x`.\n",
  "\n",
  "What relationship do `x2` and `y` share?: They are independent instances of `Cat`\n",
  "\n",
@@ -445,7 +447,7 @@
  "\n",
  "Identify each of the following objects as a class object or an instance (and if so, an instance of what)\n",
  "\n",
- " - `\"hello world\"`: An instances of the `str` type (a.k.a class)\n",
+ " - `\"hello world\"`: An instance of the `str` type (a.k.a class)\n",
  " - `True`: an instance of the `bool` type\n",
  " - `int`: a class object describing integers\n",
  " - `{\"a\" : 22}`: an instance of the `dict` type \n",
@@ -496,7 +498,7 @@
  "name": "python",
  "nbconvert_exporter": "python",
  "pygments_lexer": "ipython3",
- "version": "3.6.3"
+ "version": "3.6.7"
  }
  },
  "nbformat": 4,

Python/Module4_OOP/Introduction_to_OOP.ipynb

@@ -49,7 +49,7 @@
  "```python\n",
  "class Rectangle:\n",
  " \"\"\" A Python object that describes the properties of a rectangle \"\"\"\n",
- " def __init__(self, width, height, center=(0, 0)):\n",
+ " def __init__(self, width, height, center=(0.0, 0.0)):\n",
  " \"\"\" Sets the attributes of a particular instance of `Rectangle`.\n",
  "\n",
  " Parameters\n",
@@ -89,8 +89,8 @@
  " -------\n",
  " List[Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float]]\"\"\"\n",
  " cx, cy = self.center\n",
- " dx = self.width / 2\n",
- " dy = self.height / 2\n",
+ " dx = self.width / 2.0\n",
+ " dy = self.height / 2.0\n",
  " return [(cx + x, cy + y) for x,y in ((dx, dy), (dx, -dy), (-dx, -dy), (-dx, dy))]\n",
  "```\n",
  "\n",
@@ -127,7 +127,7 @@
  "source": [
  "Just like any other Python object that we have encountered, we can put our `Rectangle`s in lists, store them as values in dictionaries, pass them to functions, reference them with multiple variables, and so on.\n",
  "\n",
- "Popular STEM, data analysis, and machine learning Python libraries rely heavily on the ability to define custom classes of Python objects. For example, [pandas](https://pandas.pydata.org/) defines a spreadsheet-like `DataFrame` class; [PyTorch](https://pytorch.org/), [MXNet](https://mxnet.incubator.apache.org/), and [TensorFlow](https://www.tensorflow.org/) each define tensor classes that are capable of [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation), which is critically important for training neural networks. Understanding Python's class system will greatly improve your ability to leverage libraries like these (Shameless plug: refer to [MyGrad](https://github.com/rsokl/MyGrad) if you are interested in seeing a simple pure-Python/NumPy implementation of an auto-differentiation library). \n",
+ "Popular STEM, data analysis, and machine learning Python libraries rely heavily on the ability to define custom classes of Python objects. For example, [pandas](https://pandas.pydata.org/) defines a spreadsheet-like `DataFrame` class; [PyTorch](https://pytorch.org/), [MXNet](https://mxnet.incubator.apache.org/), and [TensorFlow](https://www.tensorflow.org/) each define tensor classes that are capable of [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation), which is critically important for training neural networks. Understanding Python's class system will greatly improve your ability to leverage libraries like these (Shameless plug: refer to [MyGrad](https://mygrad.readthedocs.io) if you are interested in seeing a simple pure-Python/NumPy implementation of an auto-differentiation library). \n",
  "\n",
  "Moving forward, we will discuss the essential *class definition*, which will permit us to define our own class (a.k.a. type) of object. Next, we will learn about creating distinct *instances* of a given object type and about defining methods. This will lead to our first encounter with *special methods*, which enable us to affect how our object type behaves with Python's various operators. For example, we can define how the `+` operator interacts with our objects. Lastly, we will briefly discuss the concept of class inheritance. \n",
  "\n",
@@ -184,7 +184,7 @@
  "name": "python",
  "nbconvert_exporter": "python",
  "pygments_lexer": "ipython3",
- "version": "3.6.3"
+ "version": "3.6.7"
  }
  },
  "nbformat": 4,

Python/Module4_OOP/Methods.ipynb

@@ -194,6 +194,45 @@
  "```"
  ]
  },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`dict.fromkeys` is an example of a class method that takes in an iterable, and returns a dictionary whose keys are the elements of that iterable, and whose values all default to `None`.\n",
+ "\n",
+ "```python\n",
+ ">>> dict.fromkeys(\"abcd\")\n",
+ "{'a': 2.3, 'b': 2.3, 'c': 2.3, 'd': 2.3}\n",
+ "```\n",
+ "\n",
+ "It is sensible that this is a class method rather than an instance method, as the method creates a brand new dictionary from scratch. It need only have access to the `dict` object (i.e. the `cls` argument) so that it can construct the dictionary. The following is what an implementation of `fromkeys` could look like, were we to define `dict` ourselves: \n",
+ "\n",
+ "```python\n",
+ "class dict:\n",
+ " # assume all other dictionary methods are defined here\n",
+ " @classmethod\n",
+ " def fromkeys(cls, iterable, value=None):\n",
+ " \"\"\" Creates a dictionary whose keys are the elements of `iterable`. All \n",
+ " keys map to `value`.\n",
+ " \n",
+ " Parameters\n",
+ " ----------\n",
+ " iterable: Iterable[Hashable]\n",
+ " An iterable of valid dictionary keys (i.e. any object that is hashable).\n",
+ " \n",
+ " value : Optional[Any]\n",
+ " The value that all of the keys will map to. Defaults to `None`.\n",
+ " \n",
+ " Returns\n",
+ " -------\n",
+ " dict \"\"\"\n",
+ " new_dict = cls() # equivalent to `dict()`: creates a new dictionary instance\n",
+ " for key in iterable:\n",
+ " new_dict[key] = value\n",
+ " return new_dict\n",
+ "```"
+ ]
+ },
  {
  "cell_type": "markdown",
  "metadata": {},
@@ -283,7 +322,7 @@
  "name": "python",
  "nbconvert_exporter": "python",
  "pygments_lexer": "ipython3",
- "version": "3.6.5"
+ "version": "3.6.7"
  }
  },
  "nbformat": 4,