Python Toolkit.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Writing Efficient Code\n",
    "\n",
    "Efficiency Definition:\n",
    "1. Minimal completion time (fast runtime)\n",
    "2. Minimal resource consumption (small memory footprint)\n",
    "3. Code is Pythonic\n",
    "\n",
    "##### Zen of Python\n",
    "    import this\n",
    "    \n",
    "**Use built in functions over creating your own\n",
    "\n",
    "**Use NumPy arrays over lists for homogeneous numerical values\n",
    "\n",
    "**Use literal syntax over formal for setting lists, tuples, dicts**\n",
    "    ex: use () over tuple(), {} over dict(), [] over list()\n",
    "    \n",
    "**To find memory usage of a saved variable of code:**\n",
    "    - import sys\n",
    "    - sys.getsizeof(variablename)\n",
    "    \n",
    "**Finding items in sets are faster than finding in lists or tuples**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Checking for PEP-8 errors\n",
    "\n",
    "    import pycodestyle\n",
    "\n",
    "    # Create a StyleGuide instance\n",
    "    style_checker = pycodestyle.StyleGuide()\n",
    "\n",
    "    # Run PEP 8 check on multiple files\n",
    "    result = style_checker.check_files(['nay_pep8.py', 'yay_pep8.py'])\n",
    "\n",
    "    # Print result of PEP 8 style check\n",
    "    print(result.messages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Profilers\n",
    "\n",
    "##### line profiler\n",
    "needs installed: pip install line_profiler\n",
    "\n",
    "load: %load_ext line_profiler\n",
    "\n",
    "- %lprun: Run code with the line-by-line profiler: ex: %lprun -f funcname funcname(arguments)\n",
    "\n",
    "##### memory profiler\n",
    "needs installed: pip install memory_profiler\n",
    "\n",
    "load: %load_ext memory_profiler\n",
    "\n",
    "- %mprun: Run code with the line-by-line memory profiler: ex: %mprun -f funcname funcname(args)\n",
    "    - function must be saved as a file in order for memory_profiler to work\n",
    "    - then file imported: from saved_func_file import funcname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pulling up Docstrings¶\n",
    "You can even see how a method works by pulling up its docstring!\n",
    "You can do this by writing ? after the method and running the cell.\n",
    "- pd.read_csv?\n",
    "- pd.read_csv() #Move your cursor inside the parentheses and press shift+tab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Help function\n",
    "\n",
    "Using before just about anything in the parentheses will bring up useful information on that call\n",
    "\n",
    "- help(function)\n",
    "- help(package)\n",
    "- help(datatype)\n",
    "- help(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Main data types\n",
    "- boolean = True / False\n",
    "- integer = 10\n",
    "- float = 10.01\n",
    "- string = “123abc”\n",
    "- list = [ value1, value2, … ]\n",
    "- dictionary = { key1:value1, key2:value2, …} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numeric operators\n",
    "- + addition\n",
    "- - subtraction\n",
    "- * multiplication\n",
    "- / division\n",
    "- ** exponent\n",
    "- % modulus\n",
    "- // floor division\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparison Operators\n",
    "- == equal\n",
    "- != different\n",
    "- .> higher\n",
    "- < lower\n",
    "- .>= higher or equal\n",
    "- <= lower or equal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Operators\n",
    "- and logical AND\n",
    "- or logical OR\n",
    "- not logical NOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Special Characters\n",
    "- _#  - comment_\n",
    "- _\\n  - new line_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Oprerators\n",
    "- string[i] retrieves character at position i\n",
    "- string[-1] retrieves last character\n",
    "- string[i:j] retrieves characters in range i to j\n",
    "- string[i:j:k] retrieves chararcters in range i to j skipping k # of characters\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Operations\n",
    "- list = [] defines an empty list\n",
    "- list[i] = x stores x with index i\n",
    "- list[i] retrieves the item with index I\n",
    "- list[-1] retrieves last item\n",
    "- list[i:j] retrieves items in the range i to j\n",
    "- del list[i] removes the item with index i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Comprehension\n",
    "\n",
    "**preferred over using for loops to iterate through lists**\n",
    "\n",
    "- example: [2*i, 2*j for i in word for j in word if j > 10]\n",
    "    - .......return.........for loop.......for loop........condition\n",
    "\n",
    "\n",
    "for loop\n",
    "\n",
    "    gen1_gen2_name_lengths_loop = []\n",
    "\n",
    "    for name,gen in zip(poke_names, poke_gens):\n",
    "        if gen < 3:\n",
    "            name_length = len(name)\n",
    "            poke_tuple = (name, name_length)\n",
    "            gen1_gen2_name_lengths_loop.append(poke_tuple)\n",
    "            \n",
    "_*below performs same operation, only faster*_\n",
    "\n",
    "list comprehension\n",
    "\n",
    "    gen1_gen2_pokemon = [name for name,gen in zip(poke_names, poke_gens) if gen < 3]\n",
    "    \n",
    "map names\n",
    "\n",
    "    name_lengths_map = map(len, gen1_gen2_pokemon)\n",
    "    \n",
    "combine lists\n",
    "\n",
    "    gen1_gen2_name_lengths = [*zip(gen1_gen2_pokemon, name_lengths_map)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary Operations\n",
    "- dict = {} defines an empty dictionary\n",
    "- dict[k] = x stores x associated to key k\n",
    "- dict[k] retrieves the item with key k\n",
    "- del dict[k] removes the item with key k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Methods\n",
    "- string.upper() converts to uppercase\n",
    "- string.lower() converts to lowercase\n",
    "- string.count(x, start, end) counts how many times x appears (optional start and end points)\n",
    "- string.find(x,start,end) finds character index based on position of the x first occurrence (optional start and end points) - if no substring found, returns -1\n",
    "- string.index() - same as find(), only returns 'substring not found' instead of -1\n",
    "- string.replace(x,y,count) replaces x for y (optional count - # of occurences to replace)\n",
    "- string.strip(x) removes end/beginning characters from a string (default is whitespace delimiter) - can be lstrip(remove left) or rstrip (remove right)\n",
    "- character.join(L) returns a string from L (list) values joined by string\n",
    "- character.format(x) returns a string that includes formatted x\n",
    "- string.split(x) splits strings by specified delimiter x (whitespace is default)\n",
    "- string.splitline() splits strings at line boundary or (\\n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Interpolation (position formatting)\n",
    "\n",
    "**'text{placeholder1} text{placeholder_n}'.format(placeholder1_value, placeholder_n_value)**\n",
    "\n",
    "- can use variables:\n",
    "\n",
    "    my_text = \"Hello, {} World\"\n",
    "    \n",
    "    placeholder = \"Jason's\"\n",
    "    \n",
    "    print(my_text.format(placeholder)\n",
    "    \n",
    "- can use index numbers in a list to reorder values ex: {0} = 1st list item, {-1} = last list item\n",
    "- can use named placeholders ex: title = 'Title' - my_text = 'The Movie {title}.format(title=title)\n",
    "- format specifier - {0:f}% = index 0 is a float\n",
    "- can also round decimal places in float - {0:.2f}%\n",
    "- can also use datetime - \"Now it is: {:%Y-%m-%d %H:%M}\".format(datetime.now())\n",
    "- using dictionary terms:\n",
    "\n",
    "    #Create a dictionary\n",
    "    \n",
    "    plan = {\"field\": courses[0],\"tool\": courses[1]}\n",
    "    \n",
    "    my_message = \"If you are interested in {data[field]}, you can take the course related to {data[tool]}\"\n",
    "    \n",
    "    print(my_message.format(data=plan))\n",
    "    \n",
    "##### literal formatting (also called 'f' string:)\n",
    "\n",
    "    name = 'Jason'\n",
    "    print(f'Hello, my name is {name}')\n",
    "    \n",
    "- conversions: ex: {name!r}\n",
    "\n",
    "    !s - string type\n",
    "    \n",
    "    !r - printable string type\n",
    "    \n",
    "    !a - !r type that is non ASCII\n",
    "    \n",
    "- can call inline operations {num1 * num2} in literal formatting\n",
    "- can also call functions {my_function(x)} in literal formatting\n",
    "\n",
    "##### template formatting\n",
    "\n",
    "    from string import Template\n",
    "    \n",
    "    our_tool = tools[0]\n",
    "    our_fee = tools[1]\n",
    "    our_pay = tools[2]\n",
    "\n",
    "    course = Template(\"We are offering a 3-month beginner course on $tool just for $$ $fee ${pay}ly\")\n",
    "    \n",
    "    print(course.substitute(tool=our_tool, fee=our_fee, pay=our_pay))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List methods\n",
    "- list.append(x) adds x to the end of the list\n",
    "- list.extend(L) appends L to the end of the list\n",
    "- list.insert(i,x) inserts x at i position\n",
    "- list.remove(x) removes the first list item whose value is x\n",
    "- list.pop(i) removes the item at position i and returns its value\n",
    "- list.clear() removes all items from the list\n",
    "- list.index(x) returns a list of values delimited by x\n",
    "- list.count(x) returns a string with list values joined by S\n",
    "- list.sort() sorts list items\n",
    "- list.reverse() reverses list elements\n",
    "- list.copy() returns a copy of the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary Methods\n",
    "- dict.keys() returns a list of keys\n",
    "- dict.values() returns a list of values\n",
    "- dict.items() returns a list of pairs (key,value)\n",
    "- dict.get(k) returns the value associtated to the key k\n",
    "- dict.pop() removes the item associated to the key and returns its value\n",
    "- dict.update(D) adds keys-values (D) to dictionary\n",
    "- dict.clear() removes all keys-values from the dictionary\n",
    "- dict.copy() returns a copy of the dictionary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Built-in functions\n",
    "\n",
    "- print(x, sep='y') prints x objects separated by y\n",
    "- input(s) prints s and waits for an input that will be returned\n",
    "- len(x) returns the length of x (s, L or D)\n",
    "- min(L) returns the minimum value in L\n",
    "- max(L) returns the maximum value in L\n",
    "- sum(L) returns the sum of the values in L\n",
    "- range(n1,n2,n) returns a sequence of numbers from n1 to n2 in steps of n - can enter the stop number only if starting at 0 - must be converted to list to manipulate\n",
    "- abs(n) returns the absolute value of n\n",
    "- round(n1,n) returns the n1 number rounded to n digits\n",
    "- type(x) returns the data type of x (string, float, list, dict …)\n",
    "- str(x) converts x to string\n",
    "- list(x) converts x to a list\n",
    "- int(x) converts x to a integer number\n",
    "- float(x) converts x to a float number\n",
    "- help(s) prints help about x\n",
    "- map(function, L) Applies function to values in L\n",
    "    - using lambda (anonymous function) with map() - map(lambda x: _one-time function_, L)\n",
    "    - saves using a for loop to iterate through data\n",
    "- zip - will combine two variables together into a zip type\n",
    "    - must be unpacked (returns a list of paired tuples)\n",
    "    - can specify # of items to combine from each list through [#start:#finish]\n",
    "- enumerate(values, start=n) creates a numbered indexed pair for each value ex: (0,'a')(1,'b') - can set starting index with the start argument - must be converted to list to manipulate\n",
    "- [\\*function(arguments)] - unpacks a function to work with lists and tuples\n",
    "- [\\**function(arguments)] - unpacks a function to wiork with dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Collections Module\n",
    "\n",
    "import collections\n",
    "\n",
    "**provides alternate data types to lists, tuples, sets and dicts**\n",
    "\n",
    "- Counter - returns a countered dictionary of ordered pairs in order from high->low"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ittertools Module\n",
    "\n",
    "import itertools\n",
    "\n",
    "**provides alternate ways to iterate through data in lieu of loops\n",
    "\n",
    "- combinations(variable, # of combs.) - results in every non-repeatable combination in variable\n",
    "    - must be unpacked to view as list of tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditional Statements\n",
    "- if (condition) :\n",
    " \n",
    "- else if (condition) :\n",
    "\n",
    "- else:\n",
    "\n",
    "- if (value) in (list):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Validation\n",
    "- try:\n",
    "\n",
    "- except (error):\n",
    "\n",
    "- else:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Working with Files and Folders\n",
    "- import os\n",
    "- os.getcwd()\n",
    "- os.makedirs(path)\n",
    "- os.chdir(path)\n",
    "- os.listdir(path)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops\n",
    "- while - runs while condition is met\n",
    "- for - runs through each item specified\n",
    "- nested for loop - loop within a loop\n",
    "\n",
    "- if - conditional loop statement (usually followed by a condition)\n",
    "- elif - adding another conditional statement if needed\n",
    "- else - use at end of loop for when if and/or elif conditions are not met\n",
    "\n",
    "##### best practices\n",
    "1. understand what is being done in each loop iteration\n",
    "2. move one-time calculations outside (above the loop)\n",
    "3. use holistic conversions outside (below) the loop\n",
    "4. anything done once should be outside the loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loop Control Statements\n",
    "- break - finishes loop execution\n",
    "- continue - jumps to next iteration\n",
    "- pass - does nothing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running External Programs\n",
    "- import os\n",
    "- os.system(command)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions\n",
    "- def function(arg1, arg2, *args, kwarg1, kwarg2, **kwargs):\n",
    "- return (data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recursive Functions\n",
    "Recursion is a way of programming or coding a problem, in which a function calls itself one or more times in its body. Usually, it is returning the return value of this function call. If a function definition fulfills the condition of recursion, we call this function a recursive function.\n",
    "\n",
    "Termination condition:\n",
    "A recursive function has to terminate to be used in a program. A recursive function terminates, if with every recursive call the solution of the problem is downsized and moves towards a base case. A base case is a case, where the problem can be solved without further recursion. A recursion can lead to an infinite loop, if the base case is not met in the calls.\n",
    "\n",
    "##### Fibonacci Sequence\n",
    "    def fib(n):\n",
    "        if n < 1:\n",
    "            return \"N must be an integer greater then 1\" #will notify that positive integer is needed\n",
    "        elif n in [1,2]:\n",
    "                return 1 #since addition of first two elements differs from the rest, need the elif statement\n",
    "        else:\n",
    "            return fib(n-1) + fib(n-2) #recursive part that takes the number provided, and returns the proper calculation\n",
    "    \n",
    "    for i in range(1, 10):\n",
    "        print(fib(i))\n",
    "        \n",
    "##### Flatten a  List \n",
    "    def flat_list(L, result=[]):\n",
    "        print('Current L:', L) #Optional, to display process\n",
    "        for i in L:\n",
    "            if type(i) == list:\n",
    "                flat_list(i, result)\n",
    "            else:\n",
    "                result.append(i)\n",
    "        return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generators\n",
    "Creates iterable results from a function design\n",
    "- def function(params):\n",
    "- yield func(params)\n",
    "- can create a comprehension for a generator:\n",
    "    - gen = (((i, j), i + j) for i in func1(8) for j in func2(10))\n",
    "                  yield          for loop         for loop         condition (if, when,etc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modules\n",
    "- import module or module.function()\n",
    "\n",
    "- from module import * function()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading and Writing Files\n",
    "- f = open(path,‘r')\n",
    "- f.read(size)\n",
    "- f.readline(size)\n",
    "- f.close()\n",
    "\n",
    "- f = open(path,’r’)\n",
    "- for line in f:\n",
    "\n",
    "- f.close() \n",
    "\n",
    "- f = open(path,'w')\n",
    "- f.write('str')\n",
    "- f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sets\n",
    "- set(l) - Returns a set object\n",
    "- set1.intersection(set2) - Returns a set of items common to both sets\n",
    "- set1.difference(set2) - Returns a set of items in set1 not in set2\n",
    "- set1.symmetric_difference(set2) - Returns a set of items that are different in both sets\n",
    "- set1.union(set2) - Returns a set of all non-repeating items in both sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Regular Expressions\n",
    "- import re - Import the Regular Expressions module\n",
    "- re.search(r\"abc\",string) - Returns a match object if the regex \"abc\" is found in string, otherwise None\n",
    "- re.match(r\"abc\",string) - same as search, but is specific\n",
    "- re.split(r'dilimiter',string) - splits string by delimiter provided\n",
    "- re.sub(r\"abc\",\"xyz\",string) - Returns a string where all instances matching regex \"abc\" are replaced by \"xyz\"\n",
    "\n",
    "##### metacharacters\n",
    "- \\d = digit (ex: 'User9' returns from re.findall(r'User/d',string)\n",
    "- \\D = non-digit (ex: 'UserN' returns from re.findall(r'User/D',string)\n",
    "- \\w = word - any word containing the provided regex\n",
    "- \\W = non-word - any non-word item\n",
    "- \\s - whitespace\n",
    "- \\S = non-whitespace - any non-whitespace character\n",
    "- . - matches any character\n",
    "- ^ - matches the first instance in the string (^string)\n",
    "- $ - matches the last instance in the string (string$)\n",
    "- \\ - put in front of a charatcer that has another operation to specifically identify\n",
    "- | - basically an 'and' operator cat|dog|bird\n",
    "- [] - can use to denote values [a-zA-z] [0-9] and symbols [%^&!]\n",
    "- [^] - use as negative operandum [^0-9] = find no numbers\n",
    "- () - groups regex terms\n",
    "- (?:regex) - will match but not return what is in the parentheses (non-capturing)\n",
    "##### quantifiers - applies only to the character on its left\n",
    "- + - shows up one time after the first (ex: 04-13 = \\d+-\\d+)\n",
    "- * - shows up zero or more times\n",
    "- ? - shows up zero or one time (this will also convert a greedy search to a lazy search)\n",
    "- {n,m} - shows up minimum n times to maximum m times\n",
    "##### backreference groups\n",
    "    for string in html_tags:\n",
    "        #Complete the regex and find if it matches a closed HTML tags\n",
    "        match_tag =  re.match(r\"<(\\w+)>.*?</\\1>\", string)\n",
    " \n",
    "        if match_tag:\n",
    "            #If it matches print the first group capture\n",
    "            print(\"Your tag {} is closed\".format(match_tag.group(1))) \n",
    "        else:\n",
    "            #If it doesn't match capture only the tag \n",
    "            notmatch_tag = re.match(r\"<(\\w+)>\", string)\n",
    "            #Print the first group capture\n",
    "            print(\"Close your {} tag!\".format(notmatch_tag.group(1)))\n",
    "#####  lookaround\n",
    "- regex(?=reference) = lookup word before the reference\n",
    "- regex(?!reference) = avoid looking up the word before reference\n",
    "- (?<=reference)regex = lookup word after the reference\n",
    "- (?<!reference)regex = avoid looking up the word after reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Datetime\n",
    "- import datetime as dt - Import the datetime module\n",
    "- now = dt.datetime.now() - Assign datetime object representing the current time to now\n",
    "- wks4 = dt.datetime.timedelta(weeks=4) - Assign a timedelta object representing a timespan of 4 weeks to wks4\n",
    "\n",
    "- dt.datetime(year=2020, month=12, day=31) - Assign a datetime object representing December 25, 2020 to newyear_2020\n",
    "\n",
    "- newyear_2020.strftime(\"%A, %b %d, %Y\") - Returns \"Thursday, Dec 31, 2020\"\n",
    "- dt.datetime.strptime('Dec 31, 2020',\"%b, %d, %Y\") - Return a datetime object representing December 31, 2020\n",
    "\n",
    "##### dateutil\n",
    "has a library of tz that holds timezone database information\n",
    " - use tz.gettz('Continent/City') to load that paticular timezone\n",
    " - timezone.utc - sets the timezone to UTC\n",
    "##### timedelta\n",
    "library that allows a change in time to be entered \n",
    " - timedelta(hours=-3)\n",
    " - .total_seconds - total time in seconds that has elapsed\n",
    " ##### daylight savings\n",
    " use the tz library, it accounts for DST, otherwise, use the UTC timezone\n",
    " - tz.datetime_ambiguous(data) - boolean value if one time falls into two timezones\n",
    " - data.astimezone() - changes timezone to another (value should be set to replace)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random\n",
    "- import random - Import the random module\n",
    "- random.random() - Returns a random float between 0.0 and 1.0\n",
    "- random.randint(0,10) - Returns a random integer between 0 and 10\n",
    "- random.choice(l) - Returns a random item from the list l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Counter\n",
    "from collections import Counter - Import the Counter class\n",
    "\n",
    "c = Counter(l) - Assign a Counter (dict-like) object with the counts of each unique item from l, to c\n",
    "\n",
    "c.most_common(3) - Return the 3 most common items from l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Magic Commands\n",
    "- %lsmagic: provides a list of all magic commands\n",
    "- %time: Time the execution of a single statement\n",
    "- %timeit: Time repeated execution of a single statement for more accuracy\n",
    "- %%timeit: Runs timeit on multiple lines of code\n",
    "    - set number of runs for timeit: %timeit -r _number_\n",
    "    - set number of loops for timeit: % timeit -n _number_\n",
    "    - %timeit -o: sets the times in variables for comparing run times\n",
    "        - times.timings - shows all saved times\n",
    "        - times.best - shows best time\n",
    "        - times.worst - shows worst time\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Command Mode (Jupyter)\n",
    "- shift + enter run cell, select below\n",
    "- ctrl + enter run cell\n",
    "- option + enter run cell, insert below\n",
    "- A insert cell above\n",
    "- B insert cell below\n",
    "- C copy cell\n",
    "- V paste cell\n",
    "- D , D delete selected cell\n",
    "- shift + M merge selected cells, or current cell with cell below if only one cell selected\n",
    "- I , I interrupt kernel\n",
    "- 0 , 0 restart kernel (with dialog)\n",
    "- Y change cell to code mode\n",
    "- M change cell to markdown mode (good for documentation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cell Edit Mode\n",
    "- ctrl + click for multi-cursor editing\n",
    "- ctrl + / toggle comment lines\n",
    "- tab code completion or indent\n",
    "- shift + tab tooltip\n",
    "- ctrl + shift + - split cell"
   ]
  }
 ],
 "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.6.10"
  },
  "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": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "307.2px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}