1.1-Python_Refresher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hi! Welcome Back to Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some examples to make sure we're on the same page! \n",
    "All examples on this page are in Python 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 1: Jumping Back In"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Motivational Quote Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Motivational Quote Generator\n",
    "# July 2, 2019\n",
    "# Author: Steven Bergner\n",
    "\n",
    "print(\"Being an adult means basically Googling stuff\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Greetings Chatbot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we'll look at *conditional statements* and getting *input* from the command line. We'll also look at some string methods like lower()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reply = input(\"How are you? \").lower()  # The value from raw_input is passed to the lower() function\n",
    "if \"fine\" in reply:\n",
    "    reply = input(\"Oh good! What's your name? \")\n",
    "elif \"not good\" in reply:\n",
    "    reply = input(\"Oh bummer! What's your name? \")\n",
    "else:\n",
    "    reply = input(\"Huh! What's your name? \")\n",
    "print(\"Nice to meet you, \" + reply + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Better Quote Generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at how to *import* a module -- a bit of code that someone else wrote so that you can have extra functionality!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "quotes = [\"So it turns out that being an adult is mostly just Googling how to do stuff. (Anonymous)\",\n",
    "          \"The best way to predict the future is to invent it. (Alan Kay)\",\n",
    "         \"Take criticism seriously, but not personally. (Hillary Clinton)\"]\n",
    "print(random.choice(quotes))  # choice is a function contained in the random module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coffee Bot Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a CoffeeBot that asks if you would like cream.\n",
    "\n",
    "- It should accept Yes/yes or No/no as inputs, and reply appropriately depending on the answer.\n",
    "- If the user inputs anything else, it should repeat back their answer and say that it does not understand.\n",
    "\n",
    "Examples:\n",
    "\n",
    "\n",
    "<img align=\"left\" src=\"img/coffeebot1.png\">\n",
    "<img align=\"left\" src=\"img/coffeebot2.png\">\n",
    "<img align=\"left\" src=\"img/coffeebot3.png\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your CoffeeBot code here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fortune Cookie Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a fortune cookie generator that prints out a random fortune when the\n",
    "program is run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your fortune cookie generator here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 2: Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we'll practice *loop*ing over lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nosy Question Bot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# Introduction\n",
    "print(\"Hello, this is Nosy Question Bot. I'd like to ask you a few questions!\")\n",
    "\n",
    "questions = [\"Given the choice of anyone in the world, whom would you want as a dinner guest?\",\n",
    "            \"Would you like to be famous? In what way?\", \"What would be a perfect day for you?\"]\n",
    "\n",
    "responses = [\"Interesting.\", \"I see!\", \"Fascinating.\"]\n",
    "\n",
    "# Make a loop that asks the question from the list\n",
    "for question in questions:\n",
    "    print(question)\n",
    "    \n",
    "    # Get a reply but don't do anything with it\n",
    "    input()\n",
    "    \n",
    "    print(random.choice(responses))\n",
    "    \n",
    "print(\"You are a super interesting person! Thanks for replying to my questions.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## New Years Bot Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a New Years Bot that counts down from 10 to 1. \n",
    "- It should use a loop and each number should be on a new line.\n",
    "- At the end of the countdown, it should output Happy New Year!\n",
    "\n",
    "You may use a list to hold your numbers, or use math if you know it (we'll practice the latter in a bit.)\n",
    "\n",
    "Example:\n",
    "\n",
    "<img align=\"left\" src=\"img/newyear-example.png\" >\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your New Years Bot here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 3: Math and Loops (Cont'd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this unit, we'll practice *addition* and counting using accumulator variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vancouver Popular Cafes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This program will get input from 5 people to find out what their favourite cafe is, between **Starbucks** and **Tim Hortons**. At the end, it prints out the number of people who like each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize counters\n",
    "starbucks_count = 0\n",
    "timmys_count = 0\n",
    "\n",
    "for i in range(5):\n",
    "    \n",
    "    # Ask the user what their favourite cafe is\n",
    "    favourite_cafe = input(\n",
    "        \"What's your favourite cafe out of Starbucks and Tim Hortons? \")\n",
    "    \n",
    "    if favourite_cafe.lower() == \"starbucks\":\n",
    "        starbucks_count = starbucks_count + 1  # Add 1 to the count\n",
    "    \n",
    "    elif favourite_cafe.lower() == \"tim hortons\":\n",
    "        timmys_count += 1  # Equivalent to the above\n",
    "    \n",
    "print(starbucks_count)\n",
    "print(timmys_count)\n",
    "\n",
    "# Can you print a statement here about which cafe is more popular, using the > or < operators?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chip Rater "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, you'll practice converting between data *types* and using *division*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Greetings\n",
    "print(\"Welcome to Chip Rater. I'd like you to answer a few questions.\")\n",
    "\n",
    "# List of questions\n",
    "questions = [\"How crispy is the chip out of 5? \", \n",
    "             \"How would you rate the packaging out of 5? \", \n",
    "             \"How would you rate the taste out of 5? \"]\n",
    "\n",
    "# Initialize score\n",
    "total = 0\n",
    "\n",
    "# Go through each question and get rating\n",
    "for question in questions:\n",
    "    rating = int(input(question))  # Converting to integer type\n",
    "    total += rating\n",
    "\n",
    "# Calculate average rating\n",
    "num_questions = len(questions)\n",
    "print(\"You've rated this chip a \" + str(total/num_questions) + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Olympic Judging Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write an Olympic Judging program that outputs the average scores from 5 different judges. \n",
    "\n",
    "- Each score is out of 10 points maximum. \n",
    "- Half points are allowed (e.g. 7.5 - remember the *float* data type)\n",
    "\n",
    "The program should take 5 inputs and output the final average score. \n",
    "\n",
    "Example:\n",
    "\n",
    "<img align=\"left\" src=\"img/olympic-example.png\" />\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your Olympic Judge program here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 4: Functions, Indexing, and Nesting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we'll look at *functions*. Recall that we used the functions inside the random module earlier. We can write our own functions, in order to not have to copy/paste everywhere."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Power Function Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example of a \"fruitful function\" that returns a value\n",
    "def power(x,y):\n",
    "    return x**y\n",
    "\n",
    "# Add code below that calls the power function and prints out the result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, try using the **power** function above by *calling* it with 2 *parameters*. \n",
    "Add your code in the box above, but below the function definition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Word Finder Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some of the code you will read this week, sometimes functions return more than one value! Try this one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we define a function\n",
    "def find_word_that_starts_with(wordlist, letter):\n",
    "    \n",
    "    # We want to return the word and the location in the wordlist\n",
    "    for i in range(len(wordlist)):\n",
    "        \n",
    "        # Get the word at index i\n",
    "        word = wordlist[i]\n",
    "        \n",
    "        # Check first letter at index 0\n",
    "        if word[0] == letter:\n",
    "            return (wordlist[i], i)\n",
    "        \n",
    "    # If we went through the whole list and couldn't find anything, return None\n",
    "    return (None, None)\n",
    "\n",
    "# -------------------------\n",
    "\n",
    "# Now let's call the function\n",
    "(word, location) = find_word_that_starts_with([\"peacocks\", \"emu\", \"kangaroo\"], \"p\")\n",
    "\n",
    "if word != None:\n",
    "    print(word, location)\n",
    "else:\n",
    "    print(\"Not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try changing the function parameters above and see what happens!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 5: Slicing and Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to get sub-parts of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = [\"a\",\"b\",\"c\",\"d\",\"e\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How would you print \"ab\"? How about \"cde\"? Or \"de\"?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prices = {\"tea\": 3.00, \"coffee\": 4.00, \"donut\": 3.50}\n",
    "\n",
    "print(prices[\"tea\"] + prices[\"coffee\"])\n",
    "\n",
    "# Can you add an expression below that would output Your total is $6.5, using the dictionary?"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}