merge

Author: rsokl

Python/Module2_EssentialsOfPython/Basic_Objects.ipynb

@@ -364,6 +364,7 @@
     "2\\. What type of number will be returned if you perform a mathematical operation using an integer and a floating-point number? Does this hold for all the arithmetic operations? Determine this by trial and error.\n",
     "\n",
     "3\\. Given the function $f(x) = e^{|x - 2|}$, make use of the `math` module to compute $f(-0.2)$.\n",
+    "\n",
     "***"
    ]
   },
@@ -524,6 +525,7 @@
     ">>> str(True)\n",
     "'True'\n",
     "```\n",
+    "Once a string is formed, it cannot be changed (without creating an entirely new string). Thus a given string object cannot be \"mutated\" - a string is an *immutable* object.\n",
     "\n",
     "As the string stores a *sequence* of characters, Python provides a means for accessing individual characters and subsequences of characters from a string:\n",
     "```python\n",
@@ -538,7 +540,7 @@
     "### String essentials\n",
     "We will only scratch the surface with strings, touching on some essentials. Please refer to the [official Python tutorial](https://docs.python.org/3/tutorial/introduction.html#strings) for a more extensive, but still informal, overview of strings.\n",
     "\n",
-    "In a string, `\\n` is treated as a single character. It denotes a new-line in a string, and will be rendered thusly when the string is printed.\n",
+    "In a string, `\\n` is treated as a single character. It denotes a new-line in a string, and will be rendered thusly when the string is printed. Similarly, `\\t` will render as a tab-character.\n",
     "\n",
     "```python\n",
     "# using `\\n` to create a newline\n",
@@ -580,9 +582,12 @@
     "\n",
     ">>> \"x: {}, y: {}, z: {}\".format(3.2, 8.4, -1.0)\n",
     "'x: 3.2, y: 8.4, z: -1.0'\n",
-    "```\n",
     "\n",
-    "Once a string is formed, it cannot be changed (without creating an entirely new string). Thus a given string object cannot be \"mutated\" - a string is an *immutable* object.\n",
+    "\n",
+    ">>> \"7\".isdigit()\n",
+    "True\n",
+    "\n",
+    "```\n",
     "\n",
     "### Official documentation for strings\n",
     "- [Built-in functions for strings](https://docs.python.org/3/library/stdtypes.html#string-methods)\n",
@@ -596,6 +601,7 @@
     "***\n",
     "\n",
     "**Reading Comprehension: strings**\n",
+    "\n",
     "To answer some of the following questions, you will need to peruse the documentation for the built-in functions of strings. It may take a bit of experimentation to understand the documentation's use of square-brackets to indicate optional inputs for a function.\n",
     "\n",
     "1\\. Use a function that will take the string `\"cat\"`, and returns the string `\"   cat    \"` (which has a length of 11, including the letters c, a, t). Now, change the way you call the function so that it returns `\"----cat----\"` instead. \n",
@@ -605,6 +611,14 @@
     "\n",
     "3\\. Remove the whitespace from both ends of: `\"  basket    \"` \n",
     "\n",
+    "\n",
+    "4\\. Create a string that will print as (the second line begins with a tab-character):\n",
+    "```\n",
+    "Hello\n",
+    "\tover there\n",
+    "```\n",
+    "\n",
+    "5\\. Convert the integer `12` to the string `\"12\"`.\n",
     "***"
    ]
   },
@@ -732,6 +746,59 @@
     "- [Built-in functions for a list](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "***\n",
+    "\n",
+    "**Reading Comprehension: lists**\n",
+    "\n",
+    "To answer some of the following questions, you will need to peruse the documentation for the built-in functions of lists.\n",
+    "\n",
+    "1\\. Create a list whose sole entry is the `None` object.\n",
+    "\n",
+    "2\\. Assign the variable `k` to a list that contains an integer, a boolean, and a string, in that order. Then, add two more entries to the end of the list: a float and a complex number.  \n",
+    "\n",
+    "3\\. Alphabetize the list of names: `[\"Jane\", \"Adam\", \"Ryan\", \"Bob\", \"Zordon\", \"Jack\", \"Jackenzie\"]`. \n",
+    "\n",
+    "***"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lists**\n",
+    "\n",
+    "1\\.\n",
+    "```python\n",
+    ">>> [None]\n",
+    "[None]\n",
+    "```\n",
+    "\n",
+    "2\\.\n",
+    "```python\n",
+    ">>> k = [4, False, \"moo\"]\n",
+    ">>> k.extend([3.14, complex(9, -2)])\n",
+    ">>> k\n",
+    "[4, False, 'moo', 3.14, (9-2j)]\n",
+    "```\n",
+    "\n",
+    "3\\.\n",
+    "```python\n",
+    ">>> names = [\"Jane\", \"Adam\", \"Ryan\", \"Bob\", \"Zordon\", \"Jack\", \"Jackenzie\"]\n",
+    "\n",
+    "# The documentation for `sort` says that the sorting happens \"in-place\". This\n",
+    "# means that the original list is replaced by the sorted list. The alternative\n",
+    "# would be that `sort` returns a new, sorted list, without changing the list\n",
+    "# assigned to `names`.\n",
+    ">>> names.sort()\n",
+    ">>> names\n",
+    "['Adam', 'Bob', 'Jack', 'Jackenzie', 'Jane', 'Ryan', 'Zordon']\n",
+    "```"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -778,7 +845,13 @@
     ">>> y = 0.5\n",
     ">>> y.as_integer_ratio()\n",
     "(1, 2)\n",
+    "\n",
+    ">>> z = [1, 2]\n",
+    ">>> z.append(3)\n",
+    ">>> z\n",
+    "[1, 2, 3]\n",
     "```\n",
+    "\n",
     "You should leverage the official documentation, for which links were provided throughout this section, whenever you are wondering how to best do a specific task with a given type of object.\n",
     "\n",
     "As a final reminder, we saw that that an integer in Python is able to hold a value with arbitrarily-many digits. A floating-point number, on the other hand, is restricted in the number of \"significant\" digits it can hold. Thus, where it is perfectly fine to check if two integers are exactly equal:\n",
@@ -895,6 +968,19 @@
     "```python\n",
     ">>> \"  basket    \".strip()\n",
     "'basket'\n",
+    "```\n",
+    "\n",
+    "4\\.\n",
+    "```python\n",
+    ">>> print(\"Hello\\n\\tover there\")\n",
+    "Hello\n",
+    "\tover there\n",
+    "```\n",
+    "\n",
+    "5\\.\n",
+    "```python\n",
+    ">>> str(11)\n",
+    "\"11\"\n",
     "```"
    ]
   }

Python/Module2_EssentialsOfPython/ConditionalStatements.ipynb

@@ -5,6 +5,15 @@
    "metadata": {},
    "source": [
     "# Conditional Statements\n",
+    "\n",
+    "<div class=\"alert alert-warning\">\n",
+    "\n",
+    "**Note**: \n",
+    "\n",
+    "There are reading-comprehension exercises included throughout the text. These are meant to help you put your reading to practice. Solutions for the exercises are included at the bottom of this page.\n",
+    "</div>\n",
+    "\n",
+    "\n",
     "In this section, we will be introduced to the `if`, `else`, and `elif` statements. These allow you to specify that blocks of code are to be executed only if specified conditions are found to be true, or perhaps alternative code if the condition is found to be false. \n",
     "\n",
     "Please refer to the \"Basic Python Object Types\" subsection to recall the basics of the \"boolean\" type, which represents True and False. We will extend that discussion by introducing comparison operations and membership-checking, and then expanding on the utility of the built-in `bool` type. "
@@ -48,28 +57,40 @@
     "```python\n",
     ">>> 2 < 3 < 1  # performs (2 < 3) and (3 < 1)\n",
     "False\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Testing for Membership in Collections: `in` and `not in`\n",
-    "The `in` and `not in` statements are a built-in operator for *testing for membership in a collection of items*. For example:\n",
+    "```\n",
+    "\n",
+    "Whereas `==` checks to see if two objects have the same value, the `is` operator checks to see if two objects are actually the *same* object. For example, creating two lists with the same contents produces two *distinct* lists, that have the same \"value\":\n",
     "\n",
     "```python\n",
-    ">>> 2 in [3, 2, 0]      # test for membership in a list\n",
+    "# demonstrating `==` vs `is`\n",
+    ">>> x = [1, 2, 3]\n",
+    ">>> y = [1, 2, 3]\n",
+    "\n",
+    ">>> x == y\n",
     "True\n",
     "\n",
-    ">>> 3 not in (-2, -1, 0) # test for membership in a tuple\n",
+    "# `x` and `y` reference equivalent, but distinct lists\n",
+    ">>> x is y\n",
+    "False\n",
+    "```\n",
+    "\n",
+    "Thus the `is` operator is most commonly used to check if a variable references the `None` object, or either of the boolean objects:\n",
+    "```python\n",
+    ">>> x = None\n",
+    ">>> x is None\n",
     "True\n",
     "\n",
-    ">>> \"a\" in \"apple\" # test for membership in a string\n",
+    "# (2 < 0) returns the object `False`\n",
+    "# thus this becomes: `False is False`\n",
+    ">>> (2 < 0) is False\n",
     "True\n",
     "```\n",
     "\n",
-    "Whenever possible, Python uses efficient algorithms for testing membership, as invoked by `in` and `not in`."
+    "Use `is not` to check if two objects are distinct:\n",
+    "```python\n",
+    ">>> 1 is not None\n",
+    "True\n",
+    "```"
    ]
   },
   {
@@ -124,7 +145,20 @@
    "metadata": {},
    "source": [
     "## `if`, `else`, and `elif`\n",
-    "We now introduce the simple, but powerful `if`, `else`, and `elif` conditional statements. The following pseudo-code demonstrates their general usage:\n",
+    "We now introduce the simple, but powerful `if`, `else`, and `elif` conditional statements. This will allow us to create simple branches in our code. For instance, suppose you are writing code for a videogame, and you want to update a character's status based on her/his number of health-points (an integer). The following code is representative of this:\n",
+    "\n",
+    "```python\n",
+    "if num_health > 80:\n",
+    "    status = \"good\"\n",
+    "elif num_health > 50:\n",
+    "    status = \"okay\"\n",
+    "elif num_health > 0:\n",
+    "    status = \"danger\"\n",
+    "else:\n",
+    "    status = \"dead\"\n",
+    "```\n",
+    "\n",
+    "The following pseudo-code demonstrates their general template for conditional statements:\n",
     "\n",
     "```\n",
     "if <expression_1>:\n",
@@ -155,13 +189,19 @@
     "```python\n",
     "x = [1, 2]\n",
     "\n",
-    "if 3 < len(x):  # bool(3 < 2) returns False\n",
+    "if 3 < len(x):\n",
+    "    # bool(3 < 2) returns False, this code \n",
+    "    # block is skipped\n",
     "    print(\"`x` has more than three items in it\")\n",
-    "elif len(x) == 2 # bool(len(x) == 2) returns True\n",
+    "elif len(x) == 2\n",
+    "    # bool(len(x) == 2) returns True\n",
+    "    # this code block is executed\n",
     "    print(\"`x` has two items in it\")\n",
-    "elif len(x) == 1 # this statement is never reached\n",
+    "elif len(x) == 1\n",
+    "    # this statement is never reached\n",
     "    print(\"`x` has one items in it\")\n",
-    "else:           # this statement is never reached\n",
+    "else:\n",
+    "    # this statement is never reached\n",
     "    print(\"`x` is an empty list\")\n",
     "\n",
     "\"`x` has two items in it\"\n",
@@ -178,20 +218,66 @@
     "if x < 0:\n",
     "    x = x ** 2\n",
     "# x is now 1\n",
-    "```\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "my_file = \"code.pdf\"\n",
     "\n",
-    "#### Pitfall: Variable Assignment in Conditional Contexts\n",
-    "It is worth pointing out a \"dangerous\" code design pattern, which is to assign a variable conditionally. Take the following code for example:\n",
+    "if \".\" in my_file:\n",
+    "    dot_index = my_file.index(\".\")\n",
+    "    filename = my_file[:dot_index]\n",
+    "else:\n",
+    "    filename = my_file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'code'"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filename"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "***\n",
+    "\n",
+    "**Reading Comprehension: Conditional statements**\n",
     "\n",
+    "1\\. Assume `my_list` is a list. Given the following code:\n",
     "```python\n",
-    "# assume x and y have not yet been defined\n",
-    "if 0 <= z:\n",
-    "    x = 1\n",
-    "else:\n",
-    "    y = 1\n",
+    "first_item = None\n",
+    "\n",
+    "if my_list:\n",
+    "    first_item = my_list[0]\n",
     "```\n",
     "\n",
-    "Any code following this \"if-else\" block is in a perilous state: `y` is never defined if `z` is positive, in which case any subsequent code referencing `y` will raise an error. Similarly, `x` will never be defined if `z` is negative. *Never define a variable conditionally*."
+    "What will happen if `my_list` is `[]`? Will `IndexError` be raised? What will `first_item` be?\n",
+    "\n",
+    "2\\. The variable `my_file` is a string like `\"code.py\"`, `\"my_doc.txt\"`, etc, where a period demarks the end of the file-name and the beginning of the file-type. `my_file` will have at most one period in it. Write code that creates a variable which stores only the filename. Accomodate cases where `my_file` does *not* include a file-type. \n",
+    "\n",
+    "That is, `\"code.py\"` $\\rightarrow$ `\"code\"`, `\"doc2.pdf\"` $\\rightarrow$ `\"doc2\"`, `\"hello_world\"` $\\rightarrow$ `\"hello_world\"` \n",
+    "***"
    ]
   },
   {
@@ -232,13 +318,46 @@
     "# will append 0 to `my_list if `x` is negative\n",
     "my_list.append(1 if x >= 0 else 0)\n",
     "```\n",
+    "```python\n",
+    ">>> x = 2\n",
+    ">>> \"a\" if x == 1 else \"b\"\n",
+    "\"b\n",
+    "```\n",
     "We will see this syntax shine when we learn about comprehension statements. That being said, this syntax should be used judiciously. For example, inline if-else statements ought not be used in arithmetic expressions, for therein lies madness:\n",
     "\n",
     "```python\n",
     "# don't ever do this...ever!\n",
     "2 - 3 if x < 1 else 1 + 6*2 if x >= 0 else 9\n",
     "```"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Reading Comprehension Exercise Solutions:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Conditional statements**\n",
+    "\n",
+    "1\\. If `my_list` is `[]`, then `bool(my_list)` will return `False`, and the code block will be skipped. Thus `first_item` will be `None`.\n",
+    "\n",
+    "2\\. First, check to see if `.` is even contained in `my_file`. If it is, find its index-position, and slice the string up to that index. Otherwise, `my_file` is already the file name.\n",
+    "```python\n",
+    "\n",
+    "my_file = \"code.pdf\"\n",
+    "\n",
+    "if \".\" in my_file:\n",
+    "    dot_index = my_file.index(\".\")\n",
+    "    filename = my_file[:dot_index]\n",
+    "else:\n",
+    "    filename = my_file\n",
+    "```"
+   ]
   }
  ],
  "metadata": {