Python Basic (Assessments and Final Project).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "addition_str = \"2+5+6+20\"\n",
    "\n",
    "for i in addition_str:\n",
    "    str1 = addition_str.split(\"+\")\n",
    "print(type(str))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['75.1', '77.7', '83.2', '82.5', '81.0', '79.5', '85.7']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# week_temps_f is a string with a list of fahrenheit temperatures separated by the , sign. Write code that uses the \n",
    "# accumulation pattern to compute the average (sum divided by number of items) and assigns it to avg_temp. Do not hard \n",
    "# code your answer (i.e., make your code compute both the sum or the number of items in week_temps_f) (You should use \n",
    "# the .split(\",\") function to split by \",\" and float() to cast to a float).\n",
    "\n",
    "\n",
    "week_temps_f = \"75.1,77.7,83.2,82.5,81.0,79.5,85.7\"\n",
    "week_temps_f = week_temps_f.split(\",\")\n",
    "x = []\n",
    "    \n",
    "for a in range(len(week_temps_f)):\n",
    "    x.append(float(week_temps_f[a]))\n",
    "sum = 0\n",
    "for i in range(len(x)):\n",
    "    sum += x[i]\n",
    "avg_temp = sum/len(x)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2', '5', '6', '20']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(str1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5, 6, 20]\n"
     ]
    }
   ],
   "source": [
    "x = []\n",
    "for a in range(len(str1)):\n",
    "    x.append(int(str1[a]))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "sum_var = 0\n",
    "for i in range(len(x)):\n",
    "    sum = sum + x[i]\n",
    "sum_var = sum_var + sum\n",
    "print(sum_var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "wn = turtle.Screen()\n",
    "alex = turtle.Turtle()\n",
    "\n",
    "for color in [\"yellow\", \"red\", \"purple\", \"blue\"]:\n",
    "    alex.color(color)\n",
    "    alex.forward(50)\n",
    "    alex.right(90)\n",
    "    \n",
    "wn.exitonclick()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(\"abbcabcacabb\".count('abb',2,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.5\n"
     ]
    }
   ],
   "source": [
    "print(18/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "percent_rain = [94.3, 45, 100, 78, 16, 5.3, 79, 86]\n",
    "resps = []\n",
    "for i in percent_rain:\n",
    "    if i > 90:\n",
    "        resps.append(\"Bring an umbrella.\")\n",
    "    elif i > 80:\n",
    "        resps.append(\"Good for the flowers?\")\n",
    "    elif i > 50:\n",
    "        resps.append(\"Watch out for clouds!\")\n",
    "    else:\n",
    "        resps.append(\"Nice day!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Bring an umbrella.', 'Nice day!', 'Bring an umbrella.', 'Watch out for clouds!', 'Nice day!', 'Nice day!', 'Watch out for clouds!', 'Good for the flowers?']\n"
     ]
    }
   ],
   "source": [
    "print(resps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 66\n",
    "output = []\n",
    "\n",
    "if x > 63:\n",
    "    output.append(True)\n",
    "elif x > 55:\n",
    "    output.append(False)\n",
    "else:\n",
    "    output.append(\"Neither\")\n",
    "\n",
    "if x > 67:\n",
    "    output.append(True)\n",
    "else:\n",
    "    output.append(None)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, None]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n"
     ]
    }
   ],
   "source": [
    "# to calculate number of characters in the phrase..(Using Accumulation Pattern)\n",
    "phrase = \"WHat a wonderful day to program!\"\n",
    "tot = 0\n",
    "for char in phrase:\n",
    "    if char != \" \":\n",
    "        tot = tot + 1\n",
    "print(tot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# to calculate the numer of vowels...\n",
    "s = \"whar if we went to the zoo\"\n",
    "x = 0\n",
    "for i in s:\n",
    "    if i in ['a', 'e', 'i', 'o', 'u']:\n",
    "        x +=1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 3 o's in ananotopoeia\n"
     ]
    }
   ],
   "source": [
    "# to calucalte a particular letter...\n",
    "word = \"ananotopoeia\"\n",
    "\n",
    "o_count = 0\n",
    "for c in word:\n",
    "    if c == 'o':\n",
    "        o_count = o_count + 1\n",
    "        \n",
    "print('There are ' + str(o_count) + \" o's in \"+ word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29\n"
     ]
    }
   ],
   "source": [
    "# max value accumulation\n",
    "nums = [9,3,8,1,5,29,2]\n",
    "best_num = nums[0]\n",
    "for n in nums:\n",
    "    if n > best_num:\n",
    "        best_num = n\n",
    "print(best_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Accumulator patter with Conditionals\n",
    "s = \"We are Learning!\"\n",
    "x = 0\n",
    "for i in s:\n",
    "    if i in ['a', 'b', 'c', 'd', 'e']:\n",
    "        x +=1\n",
    "        \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# minimum vale\n",
    "list = [5,2,1,4,9,10]\n",
    "min_value = list[0]\n",
    "for item in list:\n",
    "    if item < min_value:\n",
    "        min_value = item\n",
    "print(min_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# For each string in the list words, find the number of characters in the string. \n",
    "# If the number of characters in the string is greater than 3, \n",
    "# add 1 to the variable num_words so that num_words should end up with \n",
    "# the total number of words with more than 3 characters.\n",
    "\n",
    "words = [\"water\", \"chair\", \"pen\", \"basket\", \"hi\", \"car\"]\n",
    "num_words = 0\n",
    "for i in words:\n",
    "    str1 = len(i)\n",
    "    if str1 > 3:\n",
    "        num_words += 1\n",
    "print(num_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['adopted', 'baked', 'beamed', 'confided', 'grilled', 'planted', 'timed', 'waved', 'wished']\n"
     ]
    }
   ],
   "source": [
    "# For each word in words, add ‘d’ to the end of the word if the word ends \n",
    "# in “e” to make it past tense. Otherwise, add ‘ed’ to make it past tense.\n",
    "#  Save these past tense words to a list called past_tense.\n",
    "\n",
    "words = [\"adopt\", \"bake\", \"beam\", \"confide\", \"grill\", \"plant\", \"time\", \"wave\", \"wish\"]\n",
    "\n",
    "\n",
    "past_tense=[]\n",
    "for word in words:\n",
    "    if word[-1] !='e':\n",
    "        past_tense+=([word+'ed'])\n",
    "    else:\n",
    "        past_tense+=([word+'d'])\n",
    "print(past_tense)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3 Write code to count the number of strings in list items that have the character w in it. \n",
    "# Assign that number to the variable acc_num.\n",
    "\n",
    "items = [\"whirring\", \"wow!\", \"calendar\", \"wry\", \"glass\", \"\", \"llama\",\"tumultuous\",\"owing\"]\n",
    "\n",
    "x = 0\n",
    "for word in items:\n",
    "    if 'w' in word:\n",
    "        x += 1\n",
    "acc_num = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n"
     ]
    }
   ],
   "source": [
    "#4 Write code that counts the number of words in sentence that contain either an “a” or an “e”.\n",
    "# Store the result in the variable num_a_or_e.\n",
    "# Note 1: be sure to not double-count words that contain both an a and an e.\n",
    "# HINT 1: Use the in operator.\n",
    "# HINT 2: You can either use or or elif.\n",
    "# Hard-coded answers will receive no credit.\n",
    "\n",
    "sentence = \"python is a high level general purpose programming language that can be applied to many different classes of problems.\"\n",
    "\n",
    "num_a_or_e = 0\n",
    "for i in sentence.split():\n",
    "    if ('a' in i) or ('e' in i):\n",
    "        num_a_or_e += 1\n",
    "\n",
    "print(num_a_or_e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1 rainfall_mi is a string that contains the average number of inches of rainfall in\n",
    "# Michigan for every month (in inches) with every month separated by a comma. \n",
    "# Write code to compute the number of months that have more than 3 inches of rainfall. \n",
    "# Store the result in the variable num_rainy_months. In other words, count the number \n",
    "# of items with values > 3.0.\n",
    "\n",
    "rainfall_mi = \"1.65, 1.46, 2.05, 3.03, 3.35, 3.46, 2.83, 3.23, 3.5, 2.52, 2.8, 1.85\"\n",
    "count = 0\n",
    "for i in rainfall_mi:\n",
    "    str1 = rainfall_mi.split(\",\")\n",
    "x = []\n",
    "for a in range(len(str1)):\n",
    "    x.append(float(str1[a]))\n",
    "\n",
    "for j in range(len(x)):\n",
    "    if x[j] > 3.0:\n",
    "        count += 1\n",
    "num_rainy_months = count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2 The variable sentence stores a string. Write code to determine how many words \n",
    "# in sentence start and end with the same letter, including one-letter words. \n",
    "# Store the result in the variable same_letter_count.\n",
    "\n",
    "sentence = \"students flock to the arb for a variety of outdoor activities such as jogging and picnicking\"\n",
    "\n",
    "# Write your code here.\n",
    "same_letter_count = 0\n",
    "sentence_split = sentence.split(' ')\n",
    "for d in sentence_split:\n",
    "    if d[0] == d[-1]:\n",
    "        same_letter_count += 1\n",
    "    elif d[-1] == d[0]:\n",
    "        same_letter_count += 1\n",
    "same_letter_count "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'three']\n",
      "['a', 'f']\n"
     ]
    }
   ],
   "source": [
    "# using del operator to delete an item from the list..\n",
    "a = ['one', 'two', 'three']\n",
    "del a[1]\n",
    "print(a)\n",
    "\n",
    "alist = ['a', 'b', 'c', 'd', 'e', 'f']\n",
    "del alist[1:5]\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "[5, 82, 83]\n"
     ]
    }
   ],
   "source": [
    "                                        # Aliasing\n",
    "\n",
    "a = [81,82,83]\n",
    "b = [81,82,83]\n",
    "print(a is b)\n",
    "\n",
    "b = a\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "\n",
    "b[0] = 5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2168596273288\n",
      "2168596273288\n"
     ]
    }
   ],
   "source": [
    "print(id(a))\n",
    "print(id(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 2, 8, 999, 5]\n"
     ]
    }
   ],
   "source": [
    "alist = [4,2,8,6,5]\n",
    "blist = alist\n",
    "blist[3] = 999\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "[81, 82, 83]\n",
      "[5, 82, 83]\n"
     ]
    }
   ],
   "source": [
    "                                # Cloning Lists\n",
    "\n",
    "a = [81,82,83]\n",
    "b = a[:]      # make a clone using slice\n",
    "\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "\n",
    "b[0] = 5\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['q', 'i']\n"
     ]
    }
   ],
   "source": [
    "# Could aliasing cause potential confusion in this problem?\n",
    "b = ['q', 'u', 'i']\n",
    "z = b\n",
    "b[1] = 'i'\n",
    "z.remove('i')\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "sent = \"Holidays can be a fun time when you have good company!\"\n",
    "phrase = sent\n",
    "phrase = phrase + \" Holidays can also be fun on your own!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Holidays can be a fun time when you have good company! Holidays can also be fun on your own!'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 27, 3, 12]\n",
      "[5, 12, 27, 3, 12]\n",
      "2\n",
      "3\n",
      "1\n",
      "[12, 3, 27, 12, 5]\n",
      "[3, 5, 12, 12, 27]\n",
      "[3, 12, 12, 27]\n",
      "27\n",
      "[3, 12, 12]\n"
     ]
    }
   ],
   "source": [
    "# List Methods\n",
    "\n",
    "mylist = []\n",
    "mylist.append(5)\n",
    "mylist.append(27)\n",
    "mylist.append(3)\n",
    "mylist.append(12)\n",
    "print(mylist)\n",
    "\n",
    "mylist.insert(1, 12)\n",
    "print(mylist)\n",
    "print(mylist.count(12))\n",
    "\n",
    "print(mylist.index(3))\n",
    "print(mylist.count(5))\n",
    "\n",
    "mylist.reverse()\n",
    "print(mylist)\n",
    "\n",
    "mylist.sort()\n",
    "print(mylist)\n",
    "\n",
    "mylist.remove(5)\n",
    "print(mylist)\n",
    "\n",
    "lastitem = mylist.pop()\n",
    "print(lastitem)\n",
    "print(mylist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write code to switch the order of the winners list so that it is now Z to A. \n",
    "# Assign this list to the variable z_winners.\n",
    "\n",
    "winners = ['Alice Munro', 'Alvin E. Roth', 'Kazuo Ishiguro', 'Malala Yousafzai', 'Rainer Weiss', 'Youyou Tu']\n",
    "\n",
    "winners.sort(reverse=True)\n",
    "z_winners = winners"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'London'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write code to take ‘London’ out of the list trav_dest.\n",
    "\n",
    "trav_dest = ['Beirut', 'Milan', 'Pittsburgh', 'Buenos Aires', 'Nairobi', 'Kathmandu', 'Osaka', 'London', 'Melbourne']\n",
    "trav_dest.pop(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write code to add ‘horseback riding’ to the third position \n",
    "# (i.e., right before volleyball) in the list sports.\n",
    "\n",
    "sports = ['cricket', 'football', 'volleyball', 'baseball', 'softball', 'track and field', 'curling', 'ping pong', 'hockey']\n",
    "\n",
    "sports.insert(2,'horseback riding')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['p', 'y', 't', 'h', 'o', 'n', '!']\n",
      "['ended', 'worked', 'played', 'started', 'walked', 'looked', 'opened', 'rained', 'learned', 'cleaned']\n"
     ]
    }
   ],
   "source": [
    "#  5. For each character in the string saved in ael, append that character to a list that \n",
    "#  should be saved in a variable app.\n",
    "\n",
    "ael = \"python!\"\n",
    "app = []\n",
    "for w in ael:\n",
    "    app.append(w)\n",
    "print(app)\n",
    "\n",
    "# 6. For each string in wrds, add ‘ed’ to the end of the word (to make the word past tense).\n",
    "# Save these past tense words to a list called past_wrds.\n",
    "\n",
    "wrds = [\"end\", 'work', \"play\", \"start\", \"walk\", \"look\", \"open\", \"rain\", \"learn\", \"clean\"]\n",
    "\n",
    "past_wrds = [word + \"ed\" for word in wrds]\n",
    "print(past_wrds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Rodney Dangerfield. Your score is -1.\n",
      "Hello Marlon Brando. Your score is 1.\n",
      "Hello You. Your score is 100.\n"
     ]
    }
   ],
   "source": [
    "# Using the .format method\n",
    "\n",
    "scores = [(\"Rodney Dangerfield\", -1), (\"Marlon Brando\", 1), (\"You\", 100)]\n",
    "for person in scores:\n",
    "    name = person[0]\n",
    "    score = person[1]\n",
    "    print(\"Hello {}. Your score is {}.\".format(name, score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your name: Shubham\n",
      "Hello Shubham!\n"
     ]
    }
   ],
   "source": [
    "#  Greeting\n",
    "person = input('Your name: ')\n",
    "print('Hello {}!'.format(person))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the original price: $1000\n",
      "Enter discount percentage: 10\n",
      "$1000.0 discounted by 10.0% is $900.0.\n"
     ]
    }
   ],
   "source": [
    "#  A simple price calculator\n",
    "origPrice = float(input('Enter the original price: $'))\n",
    "discount = float(input('Enter discount percentage: '))\n",
    "newPrice = (1 - discount/100)*origPrice\n",
    "calculation = '${} discounted by {}% is ${}.'.format(origPrice, discount, newPrice)\n",
    "print(calculation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Sally.\n",
      "Hello, Nice to meet you.\n",
      "Hello, Sally.\n"
     ]
    }
   ],
   "source": [
    "# Some more Examples\n",
    "\n",
    "name = \"Sally\"\n",
    "greeting = \"Nice to meet you\"\n",
    "s = \"Hello, {}. {}.\"\n",
    "s = \"Hello, {}.\"\n",
    "\n",
    "print(s.format(name,greeting)) # will print Hello, Sally. Nice to meet you.\n",
    "\n",
    "print(s.format(greeting,name)) # will print Hello, Nice to meet you. Sally.\n",
    "\n",
    "print(s.format(name)) # 2 {}s, only one interpolation item! Not ideal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3 2.35 2.3456700\n"
     ]
    }
   ],
   "source": [
    "v = 2.34567\n",
    "print('{:.1f} {:.2f} {:.7f}'.format(v, v, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 25, 64]\n"
     ]
    }
   ],
   "source": [
    "# The Accumulator pattern with Lists....\n",
    "nums = [3,5,8]\n",
    "accum = []\n",
    "for w in nums:\n",
    "    x = w**2\n",
    "    accum.append(x)\n",
    "#     print(accum)   a good debugging staregy\n",
    "print(accum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 15, 20, 25, 30]\n"
     ]
    }
   ],
   "source": [
    "# Given the list of numbers, numbs, create a new list of those same numbers increased by 5. \n",
    "# Save this new list to the variable newlist.\n",
    "\n",
    "numbs = [5, 10, 15, 20, 25]\n",
    "\n",
    "newlist=[]\n",
    "for i in range(len(numbs)):\n",
    "   newlist.append(numbs[i]+5)\n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter some text Cat\n",
      "C-C-a-a-t-t-\n"
     ]
    }
   ],
   "source": [
    "# Accumulator Pattern With String\n",
    "s = input(\"Enter some text \")\n",
    "ac = \"\"\n",
    "for c in s:\n",
    "    ac = ac + c + \"-\" + c + \"-\"\n",
    "\n",
    "print(ac)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LLAB\n"
     ]
    }
   ],
   "source": [
    "# Reversing the string\n",
    "s = \"ball\"\n",
    "r = \"\"\n",
    "for item in s:\n",
    "   r = item.upper() + r\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign an empty string to the variable output. Using the range function, write \n",
    "# code to make it so that the variable output has 35 a s inside it (like \"aaaaaaaa\n",
    "# aaaaaaaaaaaaaaaaaaaaaaaaaaa\"). Hint: use the accumulation pattern!\n",
    "\n",
    "output = \"\"\n",
    "\n",
    "for w in range(35):\n",
    "    output += 'a'\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['I', ' ', 'l', 'o', 'v', 'e', ' ', 'p', 'y', 't', 'h', 'o', 'n']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For each character in the string already saved in the variable str1,\n",
    "# add each character to a list called chars.\n",
    "\n",
    "str1 = \"I love python\"\n",
    "# HINT: what's the accumulator? That should go here.\n",
    "\n",
    "chars = []\n",
    "for w in str1:\n",
    "    chars.append(w)\n",
    "chars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h!\n",
      "e!\n",
      "l!\n",
      "l!\n",
      "o!\n",
      " !\n",
      "w!\n",
      "o!\n",
      "r!\n",
      "l!\n",
      "d!\n",
      "!!\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "byzo = 'hello world!'\n",
    "c = 0\n",
    "for x in byzo:\n",
    "    z = x + \"!\"\n",
    "    print(z)\n",
    "    c = c + 1\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['R', 'O', 'Y', 'G', 'B', 'I', 'V']\n"
     ]
    }
   ],
   "source": [
    "# Using Accumulator pattern to store the first letter of the word in the list..\n",
    "\n",
    "colors = [\"Red\", \"Orange\", \"Yellow\", \"Green\", \"Blue\", \"Indigo\", \"Violet\"]\n",
    "initials = []\n",
    "\n",
    "for color in colors:\n",
    "    initials.append(color[0])\n",
    "\n",
    "print(initials)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = [\"Red\", \"Orange\", \"Yellow\", \"Green\", \"Blue\", \"Indigo\", \"Violet\", \"Purple\",\n",
    "          \"Pink\", \"Brown\", \"Teal\", \"Turquois\", \"Peach\", \"Beige\"]\n",
    "\n",
    "for position in range(len(colors)):\n",
    "    color = colors[position]\n",
    "    print(color)\n",
    "    if color[0] in [\"P\", \"B\", \"T\"]:\n",
    "        del colors[position]\n",
    "\n",
    "print(colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[67, 80, 90, 78, 93, 20, 79, 89, 96, 97, 92, 88, 79, 68, 58, 90, 98, 100, 79, 74, 83, 88, 80, 86, 85, 70, 90, 100]\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# course_1_assessment_12\n",
    "# Below are a set of scores that students have received in the past semester. \n",
    "# Write code to determine how many are 90 or above and assign that result to the value a_scores.\n",
    "\n",
    "scores = \"67 80 90 78 93 20 79 89 96 97 92 88 79 68 58 90 98 100 79 74 83 88 80 86 85 70 90 100\"\n",
    "\n",
    "\n",
    "for i in scores:\n",
    "    str1 = scores.split(\" \")\n",
    "x  = []    \n",
    "for a in range(len(str1)):\n",
    "    x.append(int(str1[a]))\n",
    "print(x)\n",
    "\n",
    "count = 0\n",
    "for j in range(len(x)):\n",
    "    if x[j] >= 90:\n",
    "        count += 1\n",
    "a_scores = count\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# py3_final_assessment\n",
    "\n",
    "\n",
    "# 1. Below are a set of scores that students have received in the past semester.\n",
    "# Write code to determine how many are 90 or above and assign that result to the value a_scores.\n",
    "\n",
    "scores = \"67 80 90 78 93 20 79 89 96 97 92 88 79 68 58 90 98 100 79 74 83 88 80 86 85 70 90 100\"\n",
    "scores_split = scores.split(\" \")\n",
    "a_scores = 0\n",
    "for x in scores_split:\n",
    "    x = float(x)\n",
    "    if x >= 90:\n",
    "        a_scores += 1\n",
    "\n",
    "print(a_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'OHSE'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2. Write code that uses the string stored in org and creates an acronym which is assigned to the variable acro.\n",
    "# Only the first letter of each word should be used, each letter in the acronym should be a capital letter, and there should be nothing to separate the letters of the acronym.\n",
    "# Words that should not be included in the acronym are stored in the list stopwords. \n",
    "# For example, if org was assigned the string “hello to world” then the resulting acronym should be “HW”.\n",
    "\n",
    "stopwords = ['to', 'a', 'for', 'by', 'an', 'am', 'the', 'so', 'it', 'and', \"The\"]\n",
    "org = \"The organization for health, safety, and education\"\n",
    "\n",
    "stopwords = set(w.upper() for w in stopwords)\n",
    "acro = ''.join(i[0] for i in org.upper().split(' ') if i not in stopwords)\n",
    "acro\n",
    "\n",
    "# this can be also done through this way\n",
    "# a = org.split(\" \")\n",
    "# acro = []\n",
    "\n",
    "# for i in stopwords:\n",
    "#     if i in a:\n",
    "#         a.remove(i)\n",
    "\n",
    "# final_list = []\n",
    "\n",
    "# for i in a:\n",
    "#     if i[-1] !=\",\":\n",
    "#         final_list.append(i)\n",
    "#     else:\n",
    "#         final_list.append(i[0:-1])\n",
    "\n",
    "# new = \"\"\n",
    "# for i in final_list:\n",
    "#     new += i[0]\n",
    "\n",
    "# acro= new.upper()\n",
    "# print(acro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WA. EA. AI. AR. VI\n"
     ]
    }
   ],
   "source": [
    "# 3. Write code that uses the string stored in sent and creates an acronym which is assigned to the variable acro.\n",
    "# The first two letters of each word should be used, each letter in the acronym should be a capital letter, and each element of the acronym should be separated by a “. ” (dot and space).\n",
    "# Words that should not be included in the acronym are stored in the list stopwords.\n",
    "# For example, if sent was assigned the string “height and ewok wonder” then the resulting acronym should be “HE. EW. WO”.\n",
    "\n",
    "stopwords = ['to', 'a', 'for', 'by', 'an', 'am', 'the', 'so', 'it', 'and', 'The']\n",
    "sent = \"The water earth and air are vital\"\n",
    "\n",
    "acro = '. '.join(word[:2].upper() for word in sent.split() if word not in stopwords)\n",
    "print(acro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'was I tac a ro rac a ti saw'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4. A palindrome is a phrase that, if reversed, would read the exact same.\n",
    "# Write code that checks if p_phrase is a palindrome by reversing it and then checking if the reversed version is equal to the original.\n",
    "# Assign the reversed version of p_phrase to the variable r_phrase so that we can check your work.\n",
    "\n",
    "p_phrase = \"was it a car or a cat I saw\"\n",
    "r_phrase = p_phrase[::-1]\n",
    "r_phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The store has 12 shoes, each for 29.99 USD.\n",
      "The store has 20 shirts, each for 9.99 USD.\n",
      "The store has 25 sweatpants, each for 15.00 USD.\n",
      "The store has 13 scarves, each for 7.75 USD.\n"
     ]
    }
   ],
   "source": [
    "# 5. Provided is a list of data about a store’s inventory where each item in the list represents the name of an item, how much is in stock, and how much it costs.\n",
    "# Print out each item in the list with the same formatting, using the .format method (not string concatenation).\n",
    "# For example, the first print statment should read The store has 12 shoes, each for 29.99 USD.\n",
    "\n",
    "inventory = [\"shoes, 12, 29.99\", \"shirts, 20, 9.99\", \"sweatpants, 25, 15.00\", \"scarves, 13, 7.75\"]\n",
    "\n",
    "for item in inventory:\n",
    "    item_desc, number, cost = item.split(\", \")\n",
    "    print(\"The store has {} {}, each for {} USD.\".format(number, item_desc, cost))"
   ]
  }
 ],
 "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
}