lecture-02/01-strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "Strings are a very important data type in all languages.  In Python, strings may\n",
    "be quoted several ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "woah!\n",
      "split lines\n"
     ]
    }
   ],
   "source": [
    "inputfile = \"data.txt\"\n",
    "outputfule = 'output.txt'\n",
    "triplequotes = \"\"\"woah!\n",
    "split lines\"\"\"\n",
    "print(triplequotes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a string too.\n",
      "I can span multiple lines!\n"
     ]
    }
   ],
   "source": [
    "triple_single_quotes = '''I am a string too.\n",
    "I can span multiple lines!'''\n",
    "print(triple_single_quotes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quotes in quotes\n",
    "\n",
    "In Python, we can quote strings with either single (`'`) or double quotes (`\"`).\n",
    "Sometimes we want to create a string that contains quotes.  This is easy to do!\n",
    "\n",
    "Strings quoted with `'` can contain `\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bob said, \"it is hot out there today\".'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Bob said, \"it is hot out there today\".'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings quoted with `\"` can contain `'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Python, it's a wonderful language\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Python, it's a wonderful language\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we can escape the quote with `\\`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"it's not Nick's birthday today\""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'it\\'s not Nick\\'s birthday today'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I don\\'t always quote my strings, but when I do, I prefer \"'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I don't always quote my strings, but when I do, I prefer \\\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings versus numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-cf58bd607dc5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'5'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = '5'\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a):  <class 'int'>\n",
      "type(b):  <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(\"type(a): \", type(a))\n",
    "print(\"type(b): \", type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is simple to convert between numbers and strings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# convert int to a string\n",
    "a = str(55)\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99.45\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# convert string to a float\n",
    "a = float(\"99.45\")\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "all\n",
      "That\n",
      "all folks!\n",
      "That's all\n"
     ]
    }
   ],
   "source": [
    "quote = \"\"\"That's all folks!\"\"\"\n",
    "print(quote[2])\n",
    "print(quote[7:10])\n",
    "print(quote[:4])\n",
    "print(quote[7:])\n",
    "print(quote[:-7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to remember how slices work is to think of the indices as pointing\n",
    "between characters, with the left edge of the first character numbered `0`. Then\n",
    "the right edge of the last character of a string of `n` characters has index\n",
    "`n`, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "+---+---+---+---+---+---+\n",
    "| P | y | t | h | o | n |\n",
    "+---+---+---+---+---+---+\n",
    "0   1   2   3   4   5   6\n",
    "-6  -5  -4  -3  -2  -1\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'on'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings are immutable\n",
    "\n",
    "We can access an individual character of a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'hello'\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We cannot change any part of a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-e3da24329531>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'k'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a[0] = 'k'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenation\n",
    "\n",
    "\n",
    "Concatenate (add together) strings with `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jello'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 'j' + a[1:]\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This creates a new string.\n",
    "\n",
    "### String functions / methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Leland'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'leland'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'LELAND'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.find('lan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.find('lan', 1, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many [string methods][py-str-methods].\n",
    "\n",
    "[py-str-methods]: https://docs.python.org/3/library/stdtypes.html#string-methods\n",
    "\n",
    "### String formatting\n",
    "\n",
    "It is often important to create strings formatted from a combination of strings,\n",
    "numbers, and other data.  In Python 3 this is best handled by the `format`\n",
    "string method.  Here is a simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Nick. I am the instructor for CME211.\n"
     ]
    }
   ],
   "source": [
    "name = \"Nick\"\n",
    "course = 'CME211'\n",
    "print(\"My name is {0}. I am the instructor for {1}.\".format(name,course))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Format strings contain \"replacement fields\" surrounded by curly braces `{}`.\n",
    "Anything that is not contained in braces is considered literal text, which is\n",
    "copied unchanged to the output. If you need to include a brace character in the\n",
    "literal text, it can be escaped by doubling: `{{` and `}}`.  The number in the\n",
    "braces refers to the order of arguments passed to `format`.  Numbers don't need\n",
    "to be specified if the sequence of braces has the same order as arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this course is: CME-211\n"
     ]
    }
   ],
   "source": [
    "program = 'CME'\n",
    "number = 211\n",
    "print(\"this course is: {}-{}\".format(program,number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String formatting is a good way to combine text and numeric data.\n",
    "\n",
    "String formatting is also how we control the output of floating point numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    {:f}: 42.420000\n",
      "    {:g}: 42.42\n",
      "    {:e}: 4.242000e+01\n",
      "  {:.2e}: 4.24e+01\n",
      "{: 8.2e}:  4.24e+01\n",
      "{: 8.2e}: -1.00e+00\n"
     ]
    }
   ],
   "source": [
    "print(\"    {{:f}}: {:f}\".format(42.42))\n",
    "print(\"    {{:g}}: {:g}\".format(42.42))\n",
    "print(\"    {{:e}}: {:e}\".format(42.42))\n",
    "print(\"  {{:.2e}}: {:.2e}\".format(42.42))\n",
    "print(\"{{: 8.2e}}: {: 8.2e}\".format(42.42))\n",
    "print(\"{{: 8.2e}}: {: 8.2e}\".format(-1.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the [Python Format Mini-Language docs][py-format-lang] and more [examples][py-format-examples].\n",
    "\n",
    "[py-format-lang]: https://docs.python.org/3/library/string.html#format-specification-mini-language\n",
    "[py-format-examples]: https://docs.python.org/3/library/string.html#format-examples"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}