Strings and Regular Expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Basic String Methods\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
      "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n",
      "\r",
      "\u000b",
      "\f",
      "\n",
      "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n",
      "0123456789abcdefABCDEF\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "print(string.ascii_uppercase)\n",
    "print(string.printable)\n",
    "print(string.punctuation)\n",
    "print(string.hexdigits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#TESTS!\n",
    "s = \"hello\"\n",
    "print(s.startswith(\"h\"))\n",
    "print(s.endswith(\"o\"))\n",
    "print(\"ll\" in s)\n",
    "print(s.isalpha())\n",
    "print(s.isalnum())\n",
    "print(s.isspace())\n",
    "print(s.isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Count the number of characters in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of characters: 6\n",
      "Number of `l`s: 2\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of characters:\",s.count(\"\"))\n",
    "print(\"Number of `l`s:\",s.count(\"l\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `upper`, `lower` and `swapcase`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n",
      "hello\n",
      "hELLO\n"
     ]
    }
   ],
   "source": [
    "s = \"Hello\"\n",
    "print(s.upper())\n",
    "print(s.lower())\n",
    "print(s.swapcase())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `capitalize`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"uncapitalized\".islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Uncapitalized'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"uncapitalized\".capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Capitalized'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string = \"uncapitalized\"\n",
    "if my_string.lower():\n",
    "    my_string = my_string[2:].capitalize()\n",
    "my_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `capwords`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The Quick Brown Fox Jumped Over The Lazy Dog.'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"the quick brown fox jumped over the lazy dog.\"\n",
    "string.capwords(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `strip`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s= \"  Hello}}}:  \"\n",
    "s = s.strip()\n",
    "s.strip(\"}:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.strip(\"elo}:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `find`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.find(\"o\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## format a list and `.join`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'([Ss]trings)|([Aa]re)|([Ff]un)'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "term_list = [\"[Ss]trings\",\"[Aa]re\",\"[Ff]un\"]\n",
    "\n",
    "\"|\".join([\"({})\".format(term) for term in term_list])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepend a `.join`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Attributes: 1, 2, 3'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Attributes: \"+\", \".join([\"1\",\"2\",\"3\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Using the builtin `iter` funtion with strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['h', 'e', 'l', 'l', 'o', '1']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(\"hello\"+\"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h-e-l-l-o'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"-\".join(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## `format`\n",
    "The following has been condensed from the docs found here; [pyformat](https://pyformat.info/).   \n",
    "\n",
    "Everyone that does python should memorize this module.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{}\".format(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{} world\".format(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'two one'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{1} {0}'.format('one', 'two')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:d}'.format(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Answer = 42'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Answer = {:d}'.format(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0042'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:04d}'.format(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'-42'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:+d}'.format(-42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.14'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:.2f}'.format(np.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'03.14'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:05.2f}'.format(np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `format` on classes and dicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'str repr'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Data(object):\n",
    "\n",
    "    def __str__(self):\n",
    "        return 'str'\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'repr'\n",
    "\n",
    "'{0!s} {0!r}'.format(Data())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jean-Luc Picard'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person = {'first': 'Jean-Luc', 'last': 'Picard'}\n",
    "'{p[first]} {p[last]}'.format(p=person)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tree: oak'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Plant(object):\n",
    "    type = 'tree'\n",
    "    kinds = [{'name': 'oak'}, {'name': 'maple'}]\n",
    "\n",
    "'{p.type}: {p.kinds[0][name]}'.format(p=Plant())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `format` for padding text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'      test'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:>10}'.format('test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xylop'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:.5}'.format('xylophone')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `format` use on `datetime`\n",
    "\n",
    "- [pyformat](https://pyformat.info/#datetime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<HTML>\n",
    "<table class=\"docutils\" border=\"1\">\n",
    "<colgroup>\n",
    "<col width=\"15%\">\n",
    "<col width=\"43%\">\n",
    "<col width=\"32%\">\n",
    "<col width=\"9%\">\n",
    "</colgroup>\n",
    "<thead valign=\"bottom\">\n",
    "<tr class=\"row-odd\"><th class=\"head\">Directive</th>\n",
    "<th class=\"head\">Meaning</th>\n",
    "<th class=\"head\">Example</th>\n",
    "<th class=\"head\">Notes</th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody valign=\"top\">\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%a</span></code></td>\n",
    "<td>Weekday as locale’s\n",
    "abbreviated name.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">Sun, Mon, ..., Sat\n",
    "(en_US);</div>\n",
    "<div class=\"line\">So, Mo, ..., Sa\n",
    "(de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1)</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%A</span></code></td>\n",
    "<td>Weekday as locale’s full name.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">Sunday, Monday, ...,\n",
    "Saturday (en_US);</div>\n",
    "<div class=\"line\">Sonntag, Montag, ...,\n",
    "Samstag (de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1)</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%w</span></code></td>\n",
    "<td>Weekday as a decimal number,\n",
    "where 0 is Sunday and 6 is\n",
    "Saturday.</td>\n",
    "<td>0, 1, ..., 6</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%d</span></code></td>\n",
    "<td>Day of the month as a\n",
    "zero-padded decimal number.</td>\n",
    "<td>01, 02, ..., 31</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%b</span></code></td>\n",
    "<td>Month as locale’s abbreviated\n",
    "name.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">Jan, Feb, ..., Dec\n",
    "(en_US);</div>\n",
    "<div class=\"line\">Jan, Feb, ..., Dez\n",
    "(de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1)</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%B</span></code></td>\n",
    "<td>Month as locale’s full name.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">January, February,\n",
    "..., December (en_US);</div>\n",
    "<div class=\"line\">Januar, Februar, ...,\n",
    "Dezember (de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1)</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%m</span></code></td>\n",
    "<td>Month as a zero-padded\n",
    "decimal number.</td>\n",
    "<td>01, 02, ..., 12</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%y</span></code></td>\n",
    "<td>Year without century as a\n",
    "zero-padded decimal number.</td>\n",
    "<td>00, 01, ..., 99</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%Y</span></code></td>\n",
    "<td>Year with century as a decimal\n",
    "number.</td>\n",
    "<td>0001, 0002, ..., 2013,\n",
    "2014, ..., 9998, 9999</td>\n",
    "<td>(2)</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%H</span></code></td>\n",
    "<td>Hour (24-hour clock) as a\n",
    "zero-padded decimal number.</td>\n",
    "<td>00, 01, ..., 23</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%I</span></code></td>\n",
    "<td>Hour (12-hour clock) as a\n",
    "zero-padded decimal number.</td>\n",
    "<td>01, 02, ..., 12</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%p</span></code></td>\n",
    "<td>Locale’s equivalent of either\n",
    "AM or PM.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">AM, PM (en_US);</div>\n",
    "<div class=\"line\">am, pm (de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1),\n",
    "(3)</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%M</span></code></td>\n",
    "<td>Minute as a zero-padded\n",
    "decimal number.</td>\n",
    "<td>00, 01, ..., 59</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%S</span></code></td>\n",
    "<td>Second as a zero-padded\n",
    "decimal number.</td>\n",
    "<td>00, 01, ..., 59</td>\n",
    "<td>(4)</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%f</span></code></td>\n",
    "<td>Microsecond as a decimal\n",
    "number, zero-padded on the\n",
    "left.</td>\n",
    "<td>000000, 000001, ...,\n",
    "999999</td>\n",
    "<td>(5)</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%z</span></code></td>\n",
    "<td>UTC offset in the form +HHMM\n",
    "or -HHMM (empty string if the\n",
    "object is naive).</td>\n",
    "<td>(empty), +0000, -0400,\n",
    "+1030</td>\n",
    "<td>(6)</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%Z</span></code></td>\n",
    "<td>Time zone name (empty string\n",
    "if the object is naive).</td>\n",
    "<td>(empty), UTC, EST, CST</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%j</span></code></td>\n",
    "<td>Day of the year as a\n",
    "zero-padded decimal number.</td>\n",
    "<td>001, 002, ..., 366</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%U</span></code></td>\n",
    "<td>Week number of the year\n",
    "(Sunday as the first day of\n",
    "the week) as a zero padded\n",
    "decimal number. All days in a\n",
    "new year preceding the first\n",
    "Sunday are considered to be in\n",
    "week 0.</td>\n",
    "<td>00, 01, ..., 53</td>\n",
    "<td>(7)</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%W</span></code></td>\n",
    "<td>Week number of the year\n",
    "(Monday as the first day of\n",
    "the week) as a decimal number.\n",
    "All days in a new year\n",
    "preceding the first Monday\n",
    "are considered to be in\n",
    "week 0.</td>\n",
    "<td>00, 01, ..., 53</td>\n",
    "<td>(7)</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%c</span></code></td>\n",
    "<td>Locale’s appropriate date and\n",
    "time representation.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">Tue Aug 16 21:30:00\n",
    "1988 (en_US);</div>\n",
    "<div class=\"line\">Di 16 Aug 21:30:00\n",
    "1988 (de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1)</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%x</span></code></td>\n",
    "<td>Locale’s appropriate date\n",
    "representation.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">08/16/88 (None);</div>\n",
    "<div class=\"line\">08/16/1988 (en_US);</div>\n",
    "<div class=\"line\">16.08.1988 (de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1)</td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><code class=\"docutils literal\"><span class=\"pre\">%X</span></code></td>\n",
    "<td>Locale’s appropriate time\n",
    "representation.</td>\n",
    "<td><div class=\"first last line-block\">\n",
    "<div class=\"line\">21:30:00 (en_US);</div>\n",
    "<div class=\"line\">21:30:00 (de_DE)</div>\n",
    "</div>\n",
    "</td>\n",
    "<td>(1)</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><code class=\"docutils literal\"><span class=\"pre\">%%</span></code></td>\n",
    "<td>A literal <code class=\"docutils literal\"><span class=\"pre\">'%'</span></code> character.</td>\n",
    "<td>%</td>\n",
    "<td>&nbsp;</td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>\n",
    "</HTML>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2017-01-25 14:10:47'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "'{:%Y-%m-%d %H:%M:%S}'.format(datetime.now())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2017 Jan 13'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{:%Y %b %d}\".format(datetime.now())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'21:28:24 2017-01-08'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{:{tfmt} {dfmt}}'.format(datetime.now(), dfmt='%Y-%m-%d', tfmt='%H:%M:%S')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# The python regular expression library `re`\n",
    "\n",
    "- AMAZING SITE FOR TESTING REs [regex101](https://regex101.com/)\n",
    "- [regular expressions Wikipetia](http://en.wikipedia.org/wiki/Regular_expression#Examples)\n",
    "- [re -- Python doc](https://docs.python.org/2/library/re.html)\n",
    "- [Regular expression by example](http://flockhart.virtualave.net/RBIF0100/regexp.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Character | Meaning \n",
    "--- | ---\n",
    "`\".\"` | Matches any character except a newline.\n",
    "`\"^\"` | Matches the start of the string.\n",
    "`\"$\"` | Matches the end of the string or just before the newline at he end of the string.\n",
    "`\"*\"` | Matches 0 or more (greedy) repetitions of the preceding RE. **Greedy** = match as many repetitions as possible.\n",
    "`\"+\"` | Matches 1 or more (greedy) repetitions of the preceding RE.\n",
    "`\"?\"` | Matches 0 or 1 (greedy) of the preceding RE.\n",
    "`*?,+?,??` | Non-greedy versions of the previous three special characters.\n",
    "`{m,n}` | Matches from m to n repetitions of the preceding RE.\n",
    "`{m,n}?` | Non-greedy version of the above.\n",
    "`\"\\\\\"` | Either escapes special characters or signals a special sequence.\n",
    "`[]` | Indicates a set of characters. A \"^\" as the first character indicates a complementing set.\n",
    "`[`&#124;`]` | A&#124;B , creates an RE that will match either A or B.\n",
    "`(...)` | Matches the RE inside the parentheses. The contents can be retrieved or matched later in the string.\n",
    "`(?aiLmsux)` | Set the A, I, L, M, S, U, or X flag for the RE (see below).\n",
    "`(?:...)` | Non-grouping version of regular parentheses.\n",
    "`(?P<name>...)` | The substring matched by the group is accessible by name.\n",
    "`(?P=name)` | Matches the text matched earlier by the group named name.\n",
    "`(?#...)` | A comment; ignored.\n",
    "`(?=...)` | Matches if ... matches next, but doesn't consume the string.\n",
    "`(?!...)` | Matches if ... doesn't match next.\n",
    "`(?<=...)` | Matches if preceded by ... (must be fixed length).\n",
    "`(?<!...)` | Matches if not preceded by ... (must be fixed length).\n",
    "`(?(id/name)yes`&#124;`no)` | Matches yes pattern if the group with id/name matched, the (optional) no pattern otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Symbol | Meaning\n",
    "--- | ---\n",
    "`\\number` | Matches the contents of the group of the same number.\n",
    "`\\A` | Matches only at the start of the string.\n",
    "`\\Z` | Matches only at the end of the string.\n",
    "`\\b` | Matches the empty string, but only at the start or end of a word.\n",
    "`\\B` | Matches the empty string, but not at the start or end of a word.\n",
    "`\\d` | Matches any decimal digit; equivalent to the set [0-9] in bytes patterns or string patterns with the ASCII flag. In string patterns without the ASCII flag, it will match the whole range of Unicode digits.\n",
    "`\\D` | Matches any non-digit character; equivalent to [^\\d].\n",
    "`\\s` | Matches any whitespace character; equivalent to [ \\t\\n\\r\\f\\v] in bytes patterns or string patterns with the ASCII flag. In string patterns without the ASCII flag, it will match the whole range of Unicode whitespace characters.\n",
    "`\\S` | Matches any non-whitespace character; equivalent to [^\\s].\n",
    "`\\w` | Matches any alphanumeric character; equivalent to [a-zA-Z0-9_] in bytes patterns or string patterns with the ASCII flag. In string patterns without the ASCII flag, it will match the range of Unicode alphanumeric characters (letters plus digits plus underscore). With LOCALE, it will match the set [0-9_] plus characters defined as letters for the current locale.\n",
    "`\\W` | Matches the complement of \\w.\n",
    "`\\\\` | Matches a literal backslash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "# help(re)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `re.search`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Hello there. I am a string!\"\n",
    "pattern = \"string\"\n",
    "m = re.search(pattern,s)\n",
    "m.group(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'words'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Search for things that are words\n",
    "rx = re.compile('(\\w+)')\n",
    "s = '...words, words...'\n",
    "m = rx.search(s)\n",
    "m.group(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'...'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Search for things that are not words\n",
    "rx = re.compile('(\\W+)')\n",
    "s = '...words, words...'\n",
    "m = rx.search(s)\n",
    "m.group(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<html>'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Here is a pretty simple example using html syntax\n",
    "s = \"<html> <p>Hello there<\\p>. I am a string!<\\html>\"\n",
    "pattern = \"(\\<(/?[^\\>]+)\\>)\"\n",
    "m = re.search(pattern,s)\n",
    "m.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `re.split`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['...words ', ' words...']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = '\\d'\n",
    "s = '...words 9 words...'\n",
    "re.split(pattern,s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['...words ', '9', ' words...']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = '(\\d)'\n",
    "s = '...words 9 words...'\n",
    "re.split(pattern,s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0', '3', '9r']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.split('[a-f]+', '0a3B9r', flags=re.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `re.sub`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'File_name_with_spaces.txt'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "remove_pattern = \"\\s\"\n",
    "replace_pattern = \"_\"\n",
    "s = \"File name with spaces.txt\"\n",
    "re.sub(remove_pattern,replace_pattern,s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `re.findall`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find all adverbs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['carefully', 'quickly']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"He was carefully disguised but captured quickly by police.\"\n",
    "re.findall(r\"\\w+ly\", text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find words that begin with `c`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['carefully', 'captured']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"He was carefully disguised but captured quickly by police.\"\n",
    "re.findall(r\"\\s(c\\w+)\", text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change the interior of words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Prossofer Adoembllak, peslae rrpeot yuor anceebss polmptry.'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import random\n",
    "\n",
    "def repl(m):\n",
    "    inner_word = list(m.group(2))\n",
    "    random.shuffle(inner_word)\n",
    "    return m.group(1) + \"\".join(inner_word) + m.group(3)\n",
    "text = \"Professor Abdolmalek, please report your absences promptly.\"\n",
    "re.sub(r\"(\\w)(\\w+)(\\w)\", repl, text)\n",
    "\n",
    "re.sub(r\"(\\w)(\\w+)(\\w)\", repl, text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `re.findall` to find words with formatting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hello (word)',\n",
       " 'hello (Two Words)',\n",
       " 'foobar (Sentence with 1xLetter [B4(100)] the digit)']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "sentence = \"hello (word), hello (Two Words); foobar (Sentence with 1xLetter [B4(100)] the digit)\"\n",
    "rx = re.compile(\";|,\")\n",
    "split_sentence = rx.split(sentence)\n",
    "split_and_stripped = [i.strip() for i in split_sentence]\n",
    "split_and_stripped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hello_word',\n",
       " 'hello_two_words',\n",
       " 'foobar_sentence_with_1xletter_[b4100]_the_digit']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[re.sub(\"[\\(\\)]\",\"\",thing.replace(\" \",\"_\").lower()) for thing in split_and_stripped]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## using `filter` with `re`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hello (word)', 'hello (Two Words)']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rx = re.compile(\"[Ww]ord\")\n",
    "list(filter(rx.findall,split_and_stripped))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foobar (Sentence with 1xLetter [B4(100)] the digit)']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rx = re.compile(\"\\dx\")\n",
    "list(filter(rx.findall,split_and_stripped))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'foobar (Sentence with 1xLetter [B4(100)] the digit)'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\".join(list(filter(rx.findall,split_and_stripped)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Making a `re` AND function\n",
    "\n",
    "* [Inspired by this stack overflow answer](http://stackoverflow.com/a/4389683/3727854)\n",
    "* Check it out on [regex101](https://regex101.com/r/H8XK7q/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'^(?=.*\\\\bthing one\\\\b)(?=.*\\\\bthing two\\\\b).*$'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "ex_list = [\"thing one\",\"thing two\"]\n",
    "\n",
    "def rxAndGen(ex_list):\n",
    "    \"\"\"Returns a regex psuedo \"AND\" formatted string from list of strings.\n",
    "    \"\"\"\n",
    "    rxAnd = lambda x:\"(?=.*\\\\b{}\\\\b)\".format(x)\n",
    "\n",
    "    andList = list(map(rxAnd,ex_list))\n",
    "\n",
    "    formatted_list = \"^\"+\"\".join(andList)+\".*$\"\n",
    "    \n",
    "    return formatted_list\n",
    "\n",
    "rxAndGen(ex_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This is a sentence with thing one and also contains thing two.',\n",
       " 'By terms I mean thing one thing two.']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rx = re.compile(rxAndGen(ex_list))\n",
    "\n",
    "ex_str_list = [\"This is a sentence with thing one and also contains thing two.\",\n",
    "              \"This is a sentence that doesn't contain the terms.\",\n",
    "              \"By terms I mean thing one thing two.\",\n",
    "              \"This one doesn't have the terms either\"]\n",
    "\n",
    "# rx.findall(ex_str_list)\n",
    "list(filter(rx.findall, ex_str_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---\n",
    "\n",
    "# Most effective way to remove punctuation from a string\n",
    "http://stackoverflow.com/questions/265960/best-way-to-strip-punctuation-from-a-string-in-python#266162"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A string with punctuation'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "s = \"A string, with; punctuation!\"\n",
    "table = str.maketrans({key: None for key in string.punctuation})\n",
    "\n",
    "s.translate(table)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "s = \"A string, with; punctuation!\"\n",
    "\n",
    "def remove_punctuation(s):\n",
    "    return s.translate(str.maketrans({key: None for key in string.punctuation}))\n",
    "\n",
    "remove_punctuation(\"hello!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"he llo\".replace(\" \",\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}