day3_reading_journal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 3 Reading Journal\n",
    "\n",
    "This journal includes several required exercises, but it is meant to encourage active reading more generally.  You should use the journal to take detailed notes, catalog questions, and explore the content from Think Python deeply.\n",
    "\n",
    "Reading: Think Python Chapter 8, 10.1-10.6\n",
    "\n",
    "**Due: Thursday, January 26 at noon**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes\n",
    "Chapter 8:\n",
    "    -String is a squence\n",
    "        -Fruit = 'ban' is an example\n",
    "        -Letter = fruit[1]\n",
    "            -index of string\n",
    "        -zero-based index\n",
    "        -len(string)\n",
    "              -calculates length of string\n",
    "        -[-1] this index takes the last letter and so on [-2], [-3]\n",
    "        -Traversal:traverses string one char at at ime\n",
    "        -For letter in variable\n",
    "            -print(letter)\n",
    "            -#this prints each letter of a word on a new line\n",
    "        -Slice: [0:3] #this takes a substring\n",
    "        -Search: go through loop, break when an answer is found\n",
    "        -Counter: counts iteration of something\n",
    "        -.upper() #converts to upper case\n",
    "        -Invocation: method call\n",
    "        -in: finds substring in whole\n",
    "Chapter 10:\n",
    "    -List: sequence of values\n",
    "        -mutable (changeable)\n",
    "            -numbers[2]=5 #changes second index to 5\n",
    "        -List functions:\n",
    "            +: concatenates\n",
    "            *:multiplies\n",
    "            .sort()\n",
    "            .append()\n",
    "            .extend()\n",
    "            .pop(): removes an index\n",
    "            .remove(): removes an element\n",
    "            del variable[1:5]\n",
    "                deletes substring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 8](http://www.greenteapress.com/thinkpython2/html/thinkpython2009.html)\n",
    "\n",
    "Note: the exercise numbers below match up with the reading for ease of cross referencing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 8.3  \n",
    "\n",
    "Write a function that takes a string as an argument and displays the letters backward, one per line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'olleh'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def backwards(word):\n",
    "    backwards_word = []\n",
    "    count = 1\n",
    "    for letter in word:\n",
    "        backwards_word.append(word[len(word)-count])\n",
    "        count = count+1\n",
    "    return ''.join(backwards_word)\n",
    "    \n",
    "        \n",
    "backwards(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Challenge (optional):** Write a function that translates words into [Pig Latin](https://en.wikipedia.org/wiki/Pig_Latin). \n",
    "\n",
    "**Challenge to the challenge**: Write a function that translates back into English."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oftwares\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'software'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def to_pig_latin(word):\n",
    "    backwards_word = []\n",
    "    count = 1\n",
    "    for letter in word:\n",
    "        backwards_word.append(word[count-len(word)])\n",
    "        count = count+1\n",
    "    backwards = ''.join(backwards_word)\n",
    "    return backwards + \"ay\"\n",
    "\n",
    "def to_english(word):\n",
    "    backwards_word = []\n",
    "    count = -1\n",
    "    word = word[:len(word)-2]\n",
    "    print(word)\n",
    "    for letter in word:\n",
    "        backwards_word.append(word[count])\n",
    "        count = count+1\n",
    "    backwards = ''.join(backwards_word)\n",
    "    return backwards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 8.7\n",
    "Encapsulate the character counting code in a fruitful function named `count` that accepts the string and the letter as arguments and returns the count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count(string, letters):\n",
    "    count = 0\n",
    "    for letter in string:\n",
    "        if letter == letters:\n",
    "            count = count + 1\n",
    "    \n",
    "    return count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 8.1\n",
    "Skim the documentation of the Python [string methods](http://docs.python.org/2/library/stdtypes.html#string-methods). Play with them to make sure you understand how they work-- strip, replace, and upper/lower are particularly useful. Show us some of your experiments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loWer\n",
      "LOWER\n",
      "lower\n",
      "rower\n",
      "this-wont-be-stripped\n"
     ]
    }
   ],
   "source": [
    "lower = \"loWer\"\n",
    "print(lower)\n",
    "lower = lower.upper()\n",
    "print(upper)\n",
    "lower = lower.lower()\n",
    "print(lower)\n",
    "lower = lower.replace(\"l\",\"r\")\n",
    "print(lower)\n",
    "strips = \"www.this-wont-be-stripped.555\".strip('w.5')\n",
    "print(strips)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 8.4  \n",
    "\n",
    "The following functions are all intended to check whether a string contains any lowercase letters, but at least some of them are wrong. For each function, describe what the function actually does (assuming that the parameter is a string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def any_lowercase1(s):\n",
    "    for c in s:\n",
    "        if c.islower():\n",
    "            return True\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This statement returns either True or False. True if the first letter is lowercase and false if the first letter is upper case. This function is probably trying to do this for each letter, but having return in it breaks the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'True'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def any_lowercase2(s):\n",
    "    for c in s:\n",
    "        if 'c'.islower():\n",
    "            return 'True'\n",
    "        else:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again this statement tries to return true or false for each letter. However, it just ends up returning true or false based on the string 'c'. Because 'c' is always lowercase, it will always return true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def any_lowercase3(s):\n",
    "    for c in s:\n",
    "        flag = c.islower()\n",
    "    return flag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This returns the state of the last letter. If it is lowercase it will return True. If it is uppercase it will return False."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def any_lowercase4(s):\n",
    "    flag = False\n",
    "    for c in s:\n",
    "        flag = flag or c.islower()\n",
    "    return flag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This statement returns True if there is at least one lowercase letter in it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def any_lowercase5(s):\n",
    "    for c in s:\n",
    "        if not c.islower():\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This returns False if at least one capital letter occurs. If the capital letter occurs, it goes through the loop and returns false. Elsewise, it returns true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 10.1 - 10.6](http://www.greenteapress.com/thinkpython2/html/thinkpython2011.html)\n",
    "\n",
    "You may want to review [state diagrams in Chapter 2](http://www.greenteapress.com/thinkpython2/html/thinkpython2003.html#toc13).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** What type of items can be placed in a list?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any items can be placed in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** Give at least one similarity and one difference between lists and strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarity: Both can be multiplied with the * operator\n",
    "Difference: Lists are mutable, Strings are not"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write a Python function named `average` that takes a list of numbers and returns their arithmetic mean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def average(list):\n",
    "    total = 0\n",
    "    for i in list:\n",
    "        total = total + i\n",
    "    average = total/len(list)\n",
    "    return average"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "You own a restaurant, and you need to keep up with the latest food fads or risk losing your fickle customers. You decide to write a Python function that adds the hot new ingredient _du jour_ to each of your regular menu items and returns the trendy new menu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['burger with potato', 'salad with potato', 'ice cream with potato']"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_ingredient(menu, ingredient):\n",
    "    \"\"\"\n",
    "    Given a list of string 'menu' items and a trendy 'ingredient' string of the day,\n",
    "    return a new menu list of strings with the ingredient added to each.\n",
    "    \n",
    "    >>> add_ingredient([\"burger\", \"salad\", \"ice cream\"], \"kale\")\n",
    "    ['burger with kale', 'salad with kale', 'ice cream with kale']\n",
    "    \n",
    "    \"\"\"\n",
    "    count = 0\n",
    "    for menu_item in menu:\n",
    "        menu[count] = menu_item + \" with \" + ingredient\n",
    "        count = count + 1\n",
    "    return menu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quick poll\n",
    "About how long did you spend working on this reading journal?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading Journal feedback\n",
    "\n",
    "Have any comments on this Reading Journal? Feel free to leave them below and we'll read them when you submit your journal entry. This could include suggestions to improve the exercises, topics you'd like to see covered in class next time, or other feedback.\n",
    "\n",
    "If you have Python questions or run into problems while completing the reading, you should post them to Piazza instead so you can get a quick response before your journal is submitted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}