adding strings revised and output cleared

Author: zackchase

chapter01_introduction/sec04_strings.ipynb

@@ -14,7 +14,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -31,18 +31,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "36\n",
-      "31\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(len(string1))\n",
     "print(len(string2))\n",
@@ -56,24 +47,16 @@
    "source": [
     "## Concatenation \n",
     "\n",
-    "Concatenation is a name for the operation where we one string and append it to the end of another string, yielding a new, longer string."
+    "Concatenation is a name for the operation \n",
+    "where we append one string to the end of another, \n",
+    "yielding a new, longer string."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "string1:  Helm, warp one -- \n",
-      "string2:  Engage!\n",
-      "string3:  Helm, warp one -- Engage!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "string1 = \"Helm, warp one -- \"\n",
     "string2 = \"Engage!\"\n",
@@ -88,25 +71,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Whenever we concatenate two strings, the resulting string will have a length equal to the some of the substrings from which it was formed. "
+    "Whenever we concatenate two strings, \n",
+    "the resulting string will have a length \n",
+    "equal to the sum of the substrings from which it was formed. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "18\n",
-      "7\n",
-      "25\n",
-      "25\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(len(string1))\n",
     "print(len(string2))\n",
@@ -120,56 +94,53 @@
    "source": [
     "## String Methods\n",
     "\n",
-    "We'll get more into how objects work in subsequent chapters but it's time you learned that objects are associated with some functionality by means of *methods*. Methods are basically functions that act upon a given object. We can invoke an object's methods with syntax that looks like this `object.method_name()`. Just as we can provide inputs (also called arguments) to a function, e.g. `print(string1, string2)` some methods require additional inputs. \n",
+    "We'll get more into how objects work in subsequent chapters \n",
+    "but it's time you learned that objects are associated \n",
+    "with some functionality by means of *methods*. \n",
+    "Methods are basically functions that act upon a given object.\n",
+    "We can invoke an object's methods with syntax \n",
+    "that looks like this: `object.method_name()`. \n",
+    "Just as we can provide inputs (also called arguments) \n",
+    "to an ordinary function, e.g. `print(string1, string2)`,\n",
+    "some methods require that we supply arguments. \n",
     "\n",
-    "All strings come bundled with a few helpful methods. The following handy methods don't require any arguments: We can flip all alphabetic characters to either upper or lower case by calling the `.upper()` or `.lower()` methods, respectively (leaving numeric and special characters alone)."
+    "Strings come bundled with a few helpful methods.\n",
+    "The following handy methods don't require any arguments:\n",
+    "We can flip all alphabetic characters \n",
+    "to either *upper* or *lower* or *title* (capitalized initials)\n",
+    "by calling the `.upper()`, `.lower()`, or `.title()` methods, \n",
+    "respectively (all three leave numeric and special characters unaltered)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "regular: \t Helm, warp one -- Engage!\n",
-      "upper: \t \t HELM, WARP ONE -- ENGAGE!\n",
-      "lower: \t \t helm, warp one -- engage!\n",
-      "original: \t Helm, warp one -- Engage!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"regular: \\t\", string3)\n",
     "print(\"upper: \\t \\t\", string3.upper())\n",
     "print(\"lower: \\t \\t\", string3.lower())\n",
+    "print(\"title: \\t \\t\", string3.title())\n",
     "print(\"original: \\t\", string3)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note that calling the method did not change the original string. In other words, `.upper()` is a function, that returns a new string (that is all upper cased), while leaving the underlying object unchanged. We can see this clearly here:"
+    "Note that calling the method did not change the original string.\n",
+    "In other words, `.upper()` is a function\n",
+    "that returns a new string (that is all upper cased),\n",
+    "while leaving the underlying object unchanged. \n",
+    "We can see this clearly here:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Helm, warp one -- Engage!\n",
-      "HELM, WARP ONE -- ENGAGE!\n",
-      "<class 'str'>\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "upper_string = string3.upper()\n",
     "print(string3)\n",
@@ -181,7 +152,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note that `upper_string` has no idea that it was produced by setting `string3` to upper case. All trace of the original capitalziation scheme is lost. As far as it's concerned, `upper_string` is just an ordinary string that happens to contain capital letters."
+    "In fact, note that strings are immutable. \n",
+    "Thus while we can convert a string into various\n",
+    "other related strings, we can never alter the underlying string. \n",
+    "We can even reassign a variable that once pointed at a given string\n",
+    "to subsequently point at a new string, but this isn't the same thing\n",
+    "as mutating a string.\n",
+    "\n",
+    "Note that `upper_string` has no idea \n",
+    "that it was produced by setting `string3` to upper case. \n",
+    "All trace of the original capitalziation scheme is lost.\n",
+    "As far as it's concerned, `upper_string` is \n",
+    "just an ordinary string that happens to contain capital letters."
    ]
   },
   {
@@ -190,24 +172,20 @@
    "source": [
     "## Escape Sequences\n",
     "\n",
-    "For certain special characters we can't just express them in a string literal. We need to use an escape sequence. One example is the newline character. To express a newline in a string literal we can't actually put a newline in the middle of the code. Instead, we use \"\\n\"."
+    "For certain special characters we can't \n",
+    "just express them in a string literal.\n",
+    "We need to use an escape sequence. \n",
+    "One example is the newline character.\n",
+    "To express a newline in a string literal,\n",
+    "we can't actually put a newline in the middle of the code.\n",
+    "Instead, we use \"\\n\"."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "a\n",
-      "b\n",
-      "c\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"a\\nb\\nc\")"
    ]
@@ -216,35 +194,27 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Similarly `\"\\t\"` indicates a horizontal tab, `\"\\\\\"` indicates a backslash, and `\\\"` represents a double quote. Note that we only need to escape double quotes inside a double-quote-enclosed string literal. Likewise, we only need to escape single quotes inside a single-quote-enclosed string literal. However, either kind of quotation mark *can* be indicated via an escape sequence, regardless of whether the string is double- or single-quote-enclosed. "
+    "Similarly `\"\\t\"` indicates a horizontal tab,\n",
+    "`\"\\\\\"` indicates a backslash, and `\\\"` represents a double quote.\n",
+    "Note that we only need to escape double quotes \n",
+    "inside a double-quote-enclosed string literal.\n",
+    "Likewise, we only need to escape single quotes\n",
+    "inside a single-quote-enclosed string literal.\n",
+    "However, either kind of quotation mark\n",
+    "*can* be indicated via an escape sequence,\n",
+    "regardless of whether the string is double- or single-quote-enclosed. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "ename": "SyntaxError",
-     "evalue": "EOF while scanning triple-quoted string literal (<ipython-input-8-603cbfe7ffea>, line 4)",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-8-603cbfe7ffea>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    print(\"\"\")\u001b[0m\n\u001b[0m              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOF while scanning triple-quoted string literal\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print('\\\"')\n",
     "print('\"')\n",
     "print(\"\\\"\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -263,7 +233,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.7.4"
   }
  },
  "nbformat": 4,