Module 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Module 2</h1>\n",
    "<p>Main Concepts:</p>\n",
    "<ul>\n",
    "    <li>Write scripts that use variables of different data types</li>\n",
    "    <li>Understand how flow control works in Python</li>\n",
    "    <li>Implement branches with conditional expressions</li>\n",
    "    <li>Encapsulate code into functions</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 1</h1>\n",
    "<p>Complete the function by filling in the missing parts. The color_translator function receives the name of a color, then prints its hexadecimal value. Currently, it only supports the three additive primary colors (red, green, blue), so it returns \"unknown\" for all other colors.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#0000ff\n",
      "unknown\n",
      "#ff0000\n",
      "unknown\n",
      "#00ff00\n",
      "unknown\n"
     ]
    }
   ],
   "source": [
    "def color_translator(color):\n",
    "\tif color == \"red\":\n",
    "\t\thex_color = \"#ff0000\"\n",
    "\telif color == \"green\":\n",
    "\t\thex_color = \"#00ff00\"\n",
    "\telif color == \"blue\":\n",
    "\t\thex_color = \"#0000ff\"\n",
    "\telse:\n",
    "\t\thex_color = \"unknown\"\n",
    "\treturn hex_color\n",
    "\n",
    "print(color_translator(\"blue\")) # Should be #0000ff\n",
    "print(color_translator(\"yellow\")) # Should be unknown\n",
    "print(color_translator(\"red\")) # Should be #ff0000\n",
    "print(color_translator(\"black\")) # Should be unknown\n",
    "print(color_translator(\"green\")) # Should be #00ff00\n",
    "print(color_translator(\"\")) # Should be unknown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 2</h1>\n",
    "<p>What's the value of this Python expression: \"big\" > \"small\"</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"big\" > \"small\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 3</h1>\n",
    "<p>Students in a class receive their grades as Pass/Fail. Scores of 60 or more (out of 100) mean that the grade is \"Pass\". For lower scores, the grade is \"Fail\". In addition, scores above 95 (not included) are graded as \"Top Score\". Fill in this function so that it returns the proper grade.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pass\n",
      "Fail\n",
      "Pass\n",
      "Pass\n",
      "Top Score\n",
      "Fail\n"
     ]
    }
   ],
   "source": [
    "def exam_grade(score):\n",
    "\tif score > 95:\n",
    "\t\tgrade = \"Top Score\"\n",
    "\telif score >= 60:\n",
    "\t\tgrade = \"Pass\"\n",
    "\telse:\n",
    "\t\tgrade = \"Fail\"\n",
    "\treturn grade\n",
    "\n",
    "print(exam_grade(65)) # Should be Pass\n",
    "print(exam_grade(55)) # Should be Fail\n",
    "print(exam_grade(60)) # Should be Pass\n",
    "print(exam_grade(95)) # Should be Pass\n",
    "print(exam_grade(100)) # Should be Top Score\n",
    "print(exam_grade(0)) # Should be Fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 4</h1>\n",
    "<p>What's the value of this Python expression: 11 % 5?</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(11 % 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 5</h1>\n",
    "<p>Complete the body of the format_name function. This function receives first_name and last_name, then prints a formatted string of \"Name: last_name, first_name\" if both names are not blank, or \"Name: \" with just one of the names, if the other one is blank, and nothing if both are blank.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Hemingway, Ernest\n",
      "Name: Madonna\n",
      "Name: Voltaire\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def format_name(first_name, last_name):\n",
    "\t# code goes here\n",
    "\tif(first_name != \"\" and last_name != \"\"):\n",
    "\t  return \"Name: \" + last_name + \", \" + first_name\n",
    "\telif(first_name == \"\" and last_name != \"\"):\n",
    "\t  return \"Name: \" + last_name\n",
    "\telif(first_name != \"\" and last_name == \"\"):\n",
    "\t  return \"Name: \" + first_name\n",
    "\treturn \"\" \n",
    "\n",
    "print(format_name(\"Ernest\", \"Hemingway\"))\n",
    "# Should be \"Name: Hemingway, Ernest\"\n",
    "\n",
    "print(format_name(\"\", \"Madonna\"))\n",
    "# Should be \"Name: Madonna\"\n",
    "\n",
    "print(format_name(\"Voltaire\", \"\"))\n",
    "# Should be \"Name: Voltaire\"\n",
    "\n",
    "print(format_name(\"\", \"\"))\n",
    "# Should be \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 6</h1>\n",
    "<p>The longest_word function is used to compare 3 words. It should return the word with the most number of characters (and the first in the list when they have the same length). Fill in the blank to make this happen.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chair\n",
      "beyond\n",
      "notebook\n"
     ]
    }
   ],
   "source": [
    "def longest_word(word1, word2, word3):\n",
    "\tif len(word1) >= len(word2) and len(word1) >= len(word3):\n",
    "\t\tword = word1\n",
    "\telif len(word2) > len(word1) and len(word2) >= len(word3):\n",
    "\t\tword = word2\n",
    "\telse:\n",
    "\t\tword = word3\n",
    "\treturn(word)\n",
    "\n",
    "print(longest_word(\"chair\", \"couch\", \"table\"))\n",
    "print(longest_word(\"bed\", \"bath\", \"beyond\"))\n",
    "print(longest_word(\"laptop\", \"notebook\", \"desktop\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 7</h1>\n",
    "<p>What's the value of this Python expression?\n",
    "\n",
    "((10 >= 5*2) and (10 <= 5*2))</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print((10 >= 5*2) and (10 <= 5*2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Exercise 8</h1>\n",
    "<p>The fractional_part function divides the numerator by the denominator, and returns just the fractional part (a number between 0 and 1). Complete the body of the function so that it returns the right number. Note: Since division by 0 produces an error, if the denominator is 0, the function should return 0 instead of attempting the division.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0.25\n",
      "0.6666666666666667\n",
      "0.5\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def fractional_part(numerator, denominator):\n",
    "\t# Operate with numerator and denominator to \n",
    "# keep just the fractional part of the quotient\n",
    "  if(denominator != 0):\n",
    "    fractional_part = (numerator / denominator) - (numerator // denominator)\n",
    "    if(fractional_part != 0):\n",
    "      return fractional_part\n",
    "  return 0\n",
    "\n",
    "print(fractional_part(5, 5)) # Should be 0\n",
    "print(fractional_part(5, 4)) # Should be 0.25\n",
    "print(fractional_part(5, 3)) # Should be 0.66...\n",
    "print(fractional_part(5, 2)) # Should be 0.5\n",
    "print(fractional_part(5, 0)) # Should be 0\n",
    "print(fractional_part(0, 5)) # Should be 0"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}