{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Strings\" data-toc-modified-id=\"Strings-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Strings</a></span><ul class=\"toc-item\"><li><span><a href=\"#Conceptual-Definition\" data-toc-modified-id=\"Conceptual-Definition-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Conceptual Definition</a></span></li><li><span><a href=\"#Basics-of-strings\" data-toc-modified-id=\"Basics-of-strings-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Basics of strings</a></span></li><li><span><a href=\"#Basics-of-strings-(contd.)\" data-toc-modified-id=\"Basics-of-strings-(contd.)-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Basics of strings (contd.)</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings\n",
    "\n",
    "## Conceptual Definition\n",
    "Though we usually turn to computers to work with numbers, we can also use them\n",
    "to work with alphabets, symbols, and/or numbers- in other words, a sequence of\n",
    "various characters that are are formally called _strings_.\n",
    "\n",
    "## Basics of strings\n",
    "Python, like most programming languages, can manipulate strings. Strings can\n",
    "be enclosed in single quotes (`'...'`) or double quotes (`\"...\"`) with the\n",
    "same result. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'spam eggs'  # Single quotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need to use a quote within the string itself, (e.g., to write words\n",
    "involving apostrophes), then do one of the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'doesn\\'t'  # Use \\' to escape the single quote..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"doesn't\"  # ...or use double quotes instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This use of backslash (`\\`) allows one to *escape quotes* for all special\n",
    "characters.\n",
    "This is sufficient for us to work with [the Vectors Tutorial](NB_Tutorial_Vectors_ReferenceFrames.ipynb).\n",
    "\n",
    "## Basics of strings (contd.)\n",
    "In the Jupyter notebooks, the output string is enclosed in quotes. The string is\n",
    "enclosed in double quotes\n",
    "if the string contains a single quote and no double quotes, otherwise it's\n",
    "enclosed in single quotes. The\n",
    "[`print()`](https://docs.python.org/3.6/library/functions.html#print) function\n",
    "produces a more readable output by omitting the enclosing quotes and by printing\n",
    "escaped and special characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'\"Isn\\'t,\" she said.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('\"Isn\\'t,\" she said.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'First line.\\nSecond line.'  # \\n means newline.\n",
    "s  # Without print(), \\n is included in the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s)  # With print(), \\n produces a new line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don't want escaped characters (prefaced by `\\`) to be interpreted as\n",
    "special characters, use *raw strings* by adding an `r` before the first quote:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('C:\\some\\name')  # Here \\n means newline!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(r'C:\\some\\name')  # Note the r before the quote."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--\n",
    "String literals can span multiple lines and are delineated by triple-quotes:\n",
    "`\"\"\"...\"\"\"` or `'''...'''`. End of lines are automatically included in the\n",
    "string, but it's possible to prevent this by adding a `\\` at the end of the\n",
    "line. For example, without a `\\`, the following example includes an extra line\n",
    "at the beginning of the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\"\n",
    "Usage: thingy [OPTIONS]\n",
    "     -h                        Display this usage message\n",
    "     -H hostname               Hostname to connect to\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding a `\\` removes that extra line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\"\\\n",
    "Usage: thingy [OPTIONS]\n",
    "     -h                        Display this usage message\n",
    "     -H hostname               Hostname to connect to\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because Python doesn't provide a means for creating multi-line comments,\n",
    "developers often just use triple quotes for this purpose. In a Jupyter notebook,\n",
    "however, such quotes define a string literal which appears as the output of a\n",
    "code cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Everything between the first three quotes, including new lines,\n",
    "is part of the multi-line comment. Technically, the Python interpreter\n",
    "simply sees the comment as a string, and because it's not otherwise\n",
    "used in code, the string is ignored. Convenient, eh?\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this reason, it's best in notebooks to use the `#` comment character at the\n",
    "beginning of each line, or better still, just use a Markdown cell!\n",
    "\n",
    "Strings can be *concatenated* (glued together) with the `+` operator, and\n",
    "repeated with `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3 times 'un', followed by 'ium'\n",
    "3 * 'un' + 'ium'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two or more *string literals* (that is, the values enclosed in quotes) placed\n",
    "next to each other are automatically concatenated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Py' 'thon'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Automatic concatenation works only with two literals; it does not work with\n",
    "variables or expressions, so the following cell produces an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prefix = 'Py'\n",
    "prefix 'thon'  # Can't concatenate a variable and a string literal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell likewise produces an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "('un' * 3) 'ium'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To concatenate variables, or a variable and a literal, use `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prefix = 'Py'\n",
    "prefix + 'thon'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Automatic concatenation is particularly useful when you want to break up long\n",
    "strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = ('Put several strings within parentheses '\n",
    "            'to have them joined together.')\n",
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be *indexed* (subscripted), with the first character having index 0.\n",
    "There is no separate character type; a character is simply a string of size one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'Python'\n",
    "word[0]  # Character in position 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[5]  # Character in position 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indices may also be negative numbers, which means to start counting from the end\n",
    "of the string. Note that because -0 is the same as 0, negative indices start\n",
    "from -1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[-1]  # Last character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[-2]  # Second-last character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[-6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to indexing, which extracts individual characters, Python also\n",
    "supports *slicing*, which extracts a substring. To slide, you indicate a *range*\n",
    "in the format `start:end`, where the start position is included but the end\n",
    "position is excluded:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[0:2]  # Characters from position 0 (included) to 2 (excluded)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[2:5]  # Characters from position 2 (included) to 5 (excluded)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you omit either position, the default start position is 0 and the default end\n",
    "is the length of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[:2]   # Character from the beginning to position 2 (excluded)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[4:]  # Characters from position 4 (included) to the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[-2:] # Characters from the second-last (included) to the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This characteristic means that `s[:i] + s[i:]` is always equal to `s`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[:2] + word[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[:4] + word[4:]"
   ]
  },
  {
   "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:\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",
    "The first row of numbers gives the position of the indices 0...6 in the string;\n",
    "the second row gives the corresponding negative indices. The slice from *i* to\n",
    "*j* consists of all characters between the edges labeled *i* and *j*,\n",
    "respectively.\n",
    "\n",
    "For non-negative indices, the length of a slice is the difference of the\n",
    "indices, if both are within bounds. For example, the length of `word[1:3]` is 2.\n",
    "\n",
    "Attempting to use an index that is too large results in an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[42]  # The word only has 6 characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, when used in a range, an index that's too large defaults to the size of\n",
    "the string and does not give an error. This characteristic is useful when you\n",
    "always want to slice at a particular index regardless of the length of a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[4:42]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[42:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python strings are [immutable](https://docs.python.org/3.5/glossary.html#term-\n",
    "immutable), which means they cannot be changed. Therefore, assigning a value to\n",
    "an indexed position in a string results in an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[0] = 'J'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell also produces an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[2:] = 'py'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A slice it itself a value that you can concatenate with other values using `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'J' + word[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[:2] + 'Py'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A slice, however, is not a string literal and cannot be used with automatic\n",
    "concatenation. The following code produces an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word[:2] 'Py'    # Slice is not a literal; produces an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in function\n",
    "[`len()`](https://docs.python.org/3.5/library/functions.html#len) returns the\n",
    "length of a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'supercalifragilisticexpialidocious'\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-->"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}