PythonNotes_AWclass.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sep 26 lesson  \n",
    "Modified from: https://www.cdslab.org/python/  \n",
    "               https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/  \n",
    "               https://github.com/uta-carpentries/SWC_spring2019_lessons/blob/master/Lesson2_Python_Basics.ipynb  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lesson outline\n",
    "\n",
    "1. breif review of data types and data structures\n",
    "2. control structures: conditional and loops\n",
    "3. list/dictionary comprehensions\n",
    "3. functions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\t a_dict\t b\t b_dict\t c\t d\t el\t fence\t find3letters\t \n",
      "i\t k\t key\t letters\t letters_dict\t letters_list\t math\t multiply\t myData\t \n",
      "myData_df\t myData_dic\t myData_dict\t myList\t myList2\t myProduct\t myStr\t my_file\t new_dict\t \n",
      "no\t pd\t res\t score\t seq\t seq2\t store_dict\t v\t value\t \n",
      "x\t y\t yes\t z\t \n"
     ]
    }
   ],
   "source": [
    "#List all variable defined in your environment\n",
    "who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:Invalid alias: The name clear can't be aliased because it is another magic command.\n",
      "ERROR:root:Invalid alias: The name more can't be aliased because it is another magic command.\n",
      "ERROR:root:Invalid alias: The name less can't be aliased because it is another magic command.\n",
      "ERROR:root:Invalid alias: The name man can't be aliased because it is another magic command.\n"
     ]
    }
   ],
   "source": [
    "#delete all\n",
    "reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interactive namespace is empty.\n"
     ]
    }
   ],
   "source": [
    "#now\n",
    "who"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic data types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is <class 'float'> \n",
      "b is <class 'int'>\n",
      "a is <class 'int'> now\n"
     ]
    }
   ],
   "source": [
    "#1. numeric(float, int)\n",
    "a=23.5\n",
    "print(\"a is {} \".format(type(a)))\n",
    "\n",
    "b=12\n",
    "print(\"b is {}\".format(type(12)))\n",
    "\n",
    "#can convert between types\n",
    "a=int(a)\n",
    "print(\"a is {} now\".format(type(a)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n",
      "<class 'int'>\n",
      "c is <class 'str'> now\n"
     ]
    },
    {
     "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-251-fcf1ea5d331f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;31m#immutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mmyStr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'o'\u001b[0m\u001b[0;34m\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": [
    "#2. strings\n",
    "myStr=\"Hi\"\n",
    "print(myStr)\n",
    "\n",
    "#can convert\n",
    "c=12\n",
    "print(type(c))\n",
    "c=str(c)\n",
    "print(\"c is {} now\".format(type(c)))\n",
    "\n",
    "#immutable\n",
    "myStr[1]='o'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "#3. boolean\n",
    "yes=True\n",
    "no=False\n",
    "\n",
    "print(type(yes))\n",
    "print(type(no))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#can convert \n",
    "print(bool(2))\n",
    "print(bool(-2))\n",
    "print(bool(\"hi\"))\n",
    "print(bool(0))\n",
    "print(bool(\"None\"))\n",
    "print(bool(None))\n",
    "print(bool(True))\n",
    "print(bool({}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge** What is the value of `res`?  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TrueTrue\n"
     ]
    }
   ],
   "source": [
    "score=21  \n",
    "res = 2*str(bool(type(str(type(3==float(score))))))\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data structures (composite data types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**lists:** ordered collection of elements that can be of different data types. List elements can be changed = mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 'hi', 23]\n"
     ]
    }
   ],
   "source": [
    "#how to create: [] \n",
    "myList=[1,4,\"hi\",23]\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi'"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#how to access list elements [index]\n",
    "myList[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 45, 23]\n"
     ]
    }
   ],
   "source": [
    "#can change list elements =mutable\n",
    "myList[2]=45\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 45, 23, 'dog']\n"
     ]
    }
   ],
   "source": [
    "#list operations\n",
    "#myList.<tab> to see operations that can be performed on lists\n",
    "\n",
    "myList.append(\"dog\")\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12]\n",
      ".pop(3) returns 12 and removes this element from the list [3, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "myList2=[3,6,9,12]\n",
    "print(myList2)\n",
    "el=myList2.pop(3)\n",
    "print(\".pop(3) returns {} and removes this element from the list {}\".format(el, myList2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 9, 12, 3, 6, 9, 12]"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myList3=[3,6,9,12]\n",
    "myList3*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**tuples**: like lists, but immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**dictionaries:** key-value pairs (associative arrays), not ordered, mutable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'rooms': 3, 'trees': 'many', 'garage': 0}\n"
     ]
    }
   ],
   "source": [
    "#how to create:\n",
    "#1. record key-value pairs; key must be unique!\n",
    "myDict={'rooms':3, 'trees':'many', 'garage':0}\n",
    "print(myDict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'rooms': 3, 'trees': 'many', 'garage': 0}\n"
     ]
    }
   ],
   "source": [
    "#2. Create from 2 lists, one containing keys, another -values\n",
    "keys_list=['rooms','trees','garage']\n",
    "values_list=[3,\"many\",0]\n",
    "house_dict=dict(zip(keys_list, values_list))\n",
    "print(house_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('rooms', 3), ('trees', 'many'), ('garage', 0)]"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(keys_list, values_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'sugar': 2, 'bread': 1, 'beer': 7, 'chips': 2}\n"
     ]
    }
   ],
   "source": [
    "#3 From above, can use dict() on list of tuples to make dictionary\n",
    "store_dict=dict([('sugar',2), ('bread',1),('beer',7),('chips',2)])\n",
    "print(store_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#access elements\n",
    "store_dict['sugar']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**sets**: unordered collection of items with unique elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#How to create: {}\n",
    "a={1,3,\"hello\"}\n",
    "b={1,3,\"hello\",3}\n",
    "a==b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-268-8bc71255a22e>\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;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object does not support indexing"
     ]
    }
   ],
   "source": [
    "a[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "#can use sets to remove duplicate values from list:\n",
    "myList=[2,3,6,7,8,7,3]\n",
    "myList_noDup=set(myList)\n",
    "print(list(myList_noDup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{23}"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.add(23)\n",
    "b.difference(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge**   \n",
    "Create a dictionary called `applicant` with three items:  \n",
    "key1: name; value1: list with 2 elements - name and age  \n",
    "key2: address; value2: dictionary with 2 key-value pairs - state and city  \n",
    "key3: occupation; value3: tuple with 2 elements - title and year  \n",
    "\n",
    "After creating the dictionary, access the age of the applicant, the city and occupation title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "Arlington\n",
      "student\n"
     ]
    }
   ],
   "source": [
    "#Solution\n",
    "applicant={'name':['Lydia',20], 'address': {'state':'TX', 'city':'Arlington'}, 'occupation':('student',2019)}\n",
    "#print(applicant)\n",
    "\n",
    "print(applicant['name'][1])\n",
    "print(applicant['address']['city'])\n",
    "print(applicant['occupation'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control structures: conditional and loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conditional statements**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "#Conditional statements: if, elif, else\n",
    "x=5\n",
    "if x>5:  #x>5 is a condition; print statement is executed only if condition evaluates to TRUE\n",
    "    print(\"Number is larger than 5\")\n",
    "else:\n",
    "    print(\"NO\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a number11\n",
      "Number is larger than 5\n"
     ]
    }
   ],
   "source": [
    "#Conditional statements: if, elif, else\n",
    "#Will elif block get executed?\n",
    "\n",
    "x=int(input(\"enter an integer\"))   #try 2,5,7,11\n",
    "\n",
    "if x>5:\n",
    "    print(\"Number is larger than 5\")\n",
    "elif x>10:\n",
    "    print(\"Number is larger than 10\")\n",
    "else:\n",
    "    print(\"NO\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter an integer11\n",
      "Number is larger than 10\n"
     ]
    }
   ],
   "source": [
    "#Conditional statements: if, elif, else\n",
    "x=int(input(\"enter an integer\"))   #try 2,5,7,11\n",
    "\n",
    "if x>10:\n",
    "    print(\"Number is larger than 10\")\n",
    "elif x>5:\n",
    "    print(\"Number is larger than 5\")\n",
    "else:\n",
    "    print(\"NO\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "condition Hi evaluates to True\n"
     ]
    }
   ],
   "source": [
    "#check that if block execution occurs only when condition is True\n",
    "condition='Hi' #try  True, \"Hi\", 0, 4, (3==4), 34<35 as a value for condition\n",
    "if condition:\n",
    "    print(\"condition {} evaluates to True\".format(condition))\n",
    "else:\n",
    "    print(\"condition {} evaluates to False\".format(condition))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Loops**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#for loop\n",
    "for i in range(1,5):\n",
    "    print(i)\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "12\n",
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "#for loop\n",
    "myList=[1,12,3,6]\n",
    "for e in myList:\n",
    "    print(e)\n",
    "    #print(list.index(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 1:**\n",
    "Write a `for loop` to multiply each element of `myList=[1,4,3,7,9]` by `2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "8\n",
      "6\n",
      "14\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "#Solution:\n",
    "myList=[1,4,3,7,9]\n",
    "for e in myList:\n",
    "    new_e=2*e\n",
    "    print(new_e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 1a:**\n",
    "Modify solution to Challenge 1 so the output is a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 8, 6, 14, 18]\n"
     ]
    }
   ],
   "source": [
    "#Solution to Challenge 1a:\n",
    "myList=[1,4,3,7,9]\n",
    "newList=[]\n",
    "for e in myList:\n",
    "    new_e=2*e\n",
    "    newList.append(new_e)\n",
    "print(newList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we are doing here is transforming one list into another. A more **pythonic** way of doing it is to use **list comprehensions**  \n",
    "`list_variable = [x for x in iterable]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 8, 6, 14, 18]\n"
     ]
    }
   ],
   "source": [
    "myList=[1,4,3,7,9]\n",
    "myList=[2*e for e in myList]\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 1b:**\n",
    "Write a `for loop` to multiply each element of `myList=[1,4,3,8,9]` by `2` if a list element is an even number. Output a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 16]\n"
     ]
    }
   ],
   "source": [
    "#Solution to Challenge 1b:\n",
    "myList=[1,4,3,8,9]\n",
    "newList=[]\n",
    "for e in myList:\n",
    "    if e%2==0:\n",
    "        new_e=2*e\n",
    "        newList.append(new_e)\n",
    "print(newList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 1c:** rewrite loop in `Challenge 1b` as list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 16]\n"
     ]
    }
   ],
   "source": [
    "#Solution to challenge 1c:\n",
    "myList=[1,4,3,7,9]\n",
    "newlist=[2*e for e in myList if e%2==0]\n",
    "print(newList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Super Challenge**  \n",
    "Suppose you have this list:  `listOfLists=[[2,3,4],[23,12],[2]]`  \n",
    "\n",
    "1. Write for loop that records elements of every list within this list into a single list called `flatList` \n",
    "2. Rewrite the loop from 1 using list comprehensions  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 23, 12, 2]\n",
      "[2, 3, 4, 23, 12, 2]\n"
     ]
    }
   ],
   "source": [
    "#Solution to Super Challenge:\n",
    "listOfLists=[[2,3,4],[23,12],[2]]\n",
    "\n",
    "#1\n",
    "flatList=[]\n",
    "for sublist in listOfLists:\n",
    "    for e in sublist:\n",
    "        flatList.append(e)\n",
    "print(flatList) \n",
    "\n",
    "#2\n",
    "flatList=[e for sublist in listOfLists for e in sublist]\n",
    "print(flatList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Iterating over python dictionaries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dog boss\n",
      "rooms {'play': 'one', 'bedroom': 1}\n",
      "price high\n",
      "trees ['oaks', 'bamboo']\n"
     ]
    }
   ],
   "source": [
    "a_dict={'dog':'boss','rooms':{'play':'one','bedroom':1}, 'price':'high','trees':['oaks','bamboo']}\n",
    "for key,value in a_dict.items():\n",
    "    print(key,value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('dog', 'boss'), ('rooms', {'play': 'one', 'bedroom': 1}), ('price', 'high'), ('trees', ['oaks', 'bamboo'])])"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#a_dict.items() is a list of tuples\n",
    "a_dict.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dog\n",
      "rooms\n",
      "price\n",
      "trees\n"
     ]
    }
   ],
   "source": [
    "#get keys\n",
    "for key in a_dict.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['dog', 'rooms', 'price', 'trees'])"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "boss\n",
      "{'play': 'one', 'bedroom': 1}\n",
      "high\n",
      "['oaks', 'bamboo']\n"
     ]
    }
   ],
   "source": [
    "#get values\n",
    "for value in a_dict.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rooms\n"
     ]
    }
   ],
   "source": [
    "for key, value in a_dict.items():    \n",
    "    if value == {'play': 'one', 'bedroom': 1}:\n",
    "        print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary comprehensions**: transform one dictionary into another   \n",
    "`dict_variable = {key:value for (key,value) in dictonary.items()}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'book': 5, 'notebook': 3, 'pen': 1}\n"
     ]
    }
   ],
   "source": [
    "#using loop\n",
    "b_dict={'book':5,'notebook': 3,'pen':1}\n",
    "new_dict={}\n",
    "for key,value in b_dict.items():\n",
    "    new_dict[key]=value\n",
    "print(new_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'book': 5, 'notebook': 3, 'pen': 1}\n"
     ]
    }
   ],
   "source": [
    "#with dictionary comprehensions\n",
    "new_dict={k:v for (k,v) in b_dict.items()}\n",
    "print(new_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'book': 15, 'notebook': 9, 'pen': 3}\n"
     ]
    }
   ],
   "source": [
    "#triple every value\n",
    "new_dict={k:v*3 for (k,v) in b_dict.items()}\n",
    "print(new_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge:** modify above so that the new_dict has tripled values only if the original value is less than 4:  \n",
    "`b_dict={'book':5,'notebook': 3,'pen':1}`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'notebook': 9, 'pen': 3}\n"
     ]
    }
   ],
   "source": [
    "#Solution\n",
    "new_dict={k:v*3 for (k,v) in b_dict.items() if v<4}\n",
    "print(new_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function: set of rules that transforms input to output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 304,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Built-in functiona\n",
    "sum([3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, start=0, /)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 306,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#methods: function defined in classes\n",
    "import math\n",
    "math.sqrt(64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "105 ns ± 1.33 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "#user-defines functions\n",
    "\n",
    "def multiply(x,y):\n",
    "    return x*y\n",
    "\n",
    "%timeit multiply(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.7 ns ± 0.0925 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit (3*5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge 2**\n",
    "\n",
    "Write a function called `fence` that takes two parameters called `original` and `wrapper` and returns a new string that has the wrapper character at the beginning and end of the original.  \n",
    "Hint: to concatinate strings, use + operator.  \n",
    "Example of function call:  \n",
    "`fence('name', '---')`  \n",
    "Expected output:    \n",
    "`---name---`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----Sasha----\n"
     ]
    }
   ],
   "source": [
    "#Solution to Challenge 2\n",
    "def fence(original, wrapper):  \n",
    "    new_string=wrapper + original + wrapper\n",
    "    return new_string\n",
    "\n",
    "print(fence(\"Sasha\",\"----\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "#recursive functions\n",
    "#sequence: an=n+4; n=0, a0=4; n=1, a1=5; n=2, a2=6\n",
    "#recursive form:an=a(n-1)+1 with a0=4\n",
    "def seq(n):\n",
    "    if n==0:\n",
    "        return 4\n",
    "    else:\n",
    "        return seq(n-1)+1\n",
    "\n",
    "for i in range(0,5):\n",
    "    print(seq(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "#iterative\n",
    "def seq2(n):\n",
    "    # an=n+4\n",
    "    for i in range(0,n):\n",
    "        print(i+4)\n",
    "seq2(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}