2-4_Python_Exercises-Functions-ANSWERS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b07146f7-51be-4006-847e-b8172a7eb2e0",
   "metadata": {},
   "source": [
    "June 24, 2022\n",
    "\n",
    "**ECON 197 L**\n",
    "\n",
    "## EXERCISES - Functions \n",
    "* With suggested answers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06367075-0801-4eb4-837d-5fb32c4b805e",
   "metadata": {},
   "source": [
    "1. Write a function that accepts three numbers and returns the sum of all three numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8232307d-24bc-42fc-b52f-2a37cfc16f38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum_of_three(x, y, z):\n",
    "    return (x + y + z)\n",
    "\n",
    "sum_of_three(10, 10, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ce378e1-250b-4b48-9bc0-d499c6d34c6f",
   "metadata": {},
   "source": [
    "2. Write a function that accepts three numbers and returns the mean of the three numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "411a4efe-307a-4987-b5f5-887f36ffa55e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.333333333333332"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#def mean_of_three(x, y, z):\n",
    "#    return (x + y + z)/3\n",
    "\n",
    "#mean_of_three(10, 25, 39)\n",
    "\n",
    "def exercise_2(x, y, z):\n",
    "    return sum_of_three(x, y, z)/3\n",
    "\n",
    "exercise_2(10, 23, 31)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec826be6-d6c5-4866-8088-ec3797ffd3fe",
   "metadata": {},
   "source": [
    "3. Write a function that accepts three numbers (or a list of three numbers) and returns the median."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2b8749f6-8770-4c50-b086-ade710bec644",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def median_of_three(a, b, c):\n",
    "    if a > b:\n",
    "        if a < c:\n",
    "            return a\n",
    "        elif b > c:\n",
    "            return b\n",
    "        else: \n",
    "            return c\n",
    "    else:\n",
    "        if a > c:\n",
    "            return a\n",
    "        elif b < c:\n",
    "            return b\n",
    "        else:\n",
    "            return c\n",
    "\n",
    "median_of_three(1, 80, 21)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "189ce936-0de5-495d-af78-4fbeb2346d1b",
   "metadata": {},
   "source": [
    "4. Write a function that accepts a string and returns its length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "21de28e1-7daf-4c25-9bdf-bb0e56c2e1b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count_string(string):\n",
    "    if string != \"\":\n",
    "        return len(string)\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "count_string(\"Economics\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef445e37-e8c2-4ebb-aa85-7286695aa7ed",
   "metadata": {},
   "source": [
    "5. Write a function that takes an integer as an argument and returns its factorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "993782f0-21b1-415a-a766-f14dbdd19ff3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    \n",
    "    factorial = 1\n",
    "    \n",
    "    if n == 0 or n == 1:\n",
    "        return factorial\n",
    "    \n",
    "    elif n >= 2:\n",
    "        for i in range(1, n+1):\n",
    "            factorial = factorial*i\n",
    "        return factorial\n",
    "    \n",
    "    else:\n",
    "        print(\"Factorial is undefined.\")\n",
    "\n",
    "factorial(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd037477-5d96-491d-938a-2af46a81dae1",
   "metadata": {},
   "source": [
    "6. Write a function that lists the prime factors of a number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d63af086-1c02-442c-b360-a6d348838afb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_prime(num):\n",
    "    \n",
    "    if num < 2: \n",
    "        return False\n",
    "    else:\n",
    "        for i in range(2,num):\n",
    "            if (num % i) == 0:\n",
    "                return False\n",
    "                break\n",
    "        else:\n",
    "            return True\n",
    "        \n",
    "def prime_factors(num):\n",
    "    \n",
    "    prime_factors = []\n",
    "    for i in range(1,num+1):\n",
    "        if num % i == 0 and is_prime(i) == True:\n",
    "            prime_factors.append(i)\n",
    "    \n",
    "    return prime_factors\n",
    "\n",
    "#type = int(input(\"Enter a number: \" ))\n",
    "#prime_factors(type)\n",
    "\n",
    "prime_factors(18)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f5c12c-fa77-4c2c-83e2-1d888417c11c",
   "metadata": {},
   "source": [
    "7. Write a function that accepts an integer and returns a list of integers from 1 to that number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "98df65bb-61b3-47ac-9141-993d7112625b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def exercise_7(num):\n",
    "    \n",
    "    list = []\n",
    "    for i in range(1,num):\n",
    "        list.append(i)\n",
    "    return list\n",
    "\n",
    "exercise_7(19)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd0cb281-2c6c-4c19-bb63-1545253247af",
   "metadata": {},
   "source": [
    "8. Write a function that accepts a number, representing temperature reading. The program should ask first the user to identify if the input was Celsius or Fahrenheit. If Celsius, convert to Fahrenheit (and vice versa). If the input is neither Celsius or Fahrenheit, print \"Invalid input\" and a message requesting to strictly choose Celsius or Fahrenheit only. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "bf0c0050-e233-464b-824f-b56887f037bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the temperature reading, excluding unit:  90\n",
      "Enter the input unit, as C or F only:  F\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'90 degrees Fahrenheit is 32.22222222222222 degrees Celsius'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def temp_C_to_F(C):\n",
    "    F = ((9/5)*C) + 32\n",
    "    return float(F)\n",
    "\n",
    "def temp_F_to_C(F):\n",
    "    C = (5/9) *(F - 32)\n",
    "    return float(C)\n",
    "\n",
    "def temp_user_input():\n",
    "    temp_input = input(\"Enter the temperature reading, excluding unit: \")\n",
    "    C_or_F = input(\"Enter the input unit, as C or F only: \")\n",
    "\n",
    "    if (C_or_F.lower() == 'c') or (C_or_F.lower() == 'celsius'):\n",
    "        return \"{} degrees Celsius is {} degrees Fahrenheit\".format(temp_input, temp_C_to_F(float(temp_input)))\n",
    "    \n",
    "    elif (C_or_F.lower() == 'f') or (C_or_F.lower() == 'fahrenheit'):\n",
    "        return \"{} degrees Fahrenheit is {} degrees Celsius\".format(temp_input, temp_F_to_C(float(temp_input)))\n",
    "    \n",
    "    else:\n",
    "        return \"Invalid input\"\n",
    "    \n",
    "temp_user_input()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "0928cdee-d020-432b-b578-f3a319757f4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose a converter:\n",
      "(1) Celsius to Fahrenheit\n",
      "(2) Fahrenheit to Celsius\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the temperature reading:  34\n",
      "Converter number 1 or number 2? 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'34 degrees Celsius is 93.2 degrees Fahrenheit.'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def temp_C_to_F(C):\n",
    "    F = ((9/5)*C) + 32\n",
    "    return float(F)\n",
    "\n",
    "def temp_F_to_C(F):\n",
    "    C = (5/9) *(F - 32)\n",
    "    return float(C)\n",
    "\n",
    "#Note that by default, user-defined inputs are strings.\n",
    "def temp_user_input2():\n",
    "    print(\"Choose a converter:\")\n",
    "    print(\"(1) Celsius to Fahrenheit\")\n",
    "    print(\"(2) Fahrenheit to Celsius\")\n",
    "    \n",
    "    temp_input = input(\"Enter the temperature reading: \")\n",
    "    C_or_F = input(\"Converter number 1 or number 2?\")\n",
    "    \n",
    "    #Note that by default, user-defined inputs are strings.\n",
    "    if C_or_F == '1':\n",
    "        return f\"{temp_input} degrees Celsius is {temp_C_to_F(float(temp_input))} degrees Fahrenheit.\"\n",
    "    \n",
    "    elif C_or_F == '2':\n",
    "        return f\"{temp_input} degrees Fahrenheit is {temp_F_to_C(float(temp_input))} degrees Celsius\"\n",
    "    \n",
    "    else:\n",
    "        return \"Invalid input\"\n",
    "    \n",
    "temp_user_input2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86569565-a2f8-4e1a-a978-839a8c789573",
   "metadata": {},
   "source": [
    "## Midterms ##"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7c9c9e6-2f2d-4c7b-9725-028279559904",
   "metadata": {},
   "source": [
    "Exercise 1: Create a function that accepts two inputs,\n",
    "* nums = a list of integers\n",
    "* x = any real number, float or integer\n",
    "\n",
    "This function should return another list where the elements of nums are added by x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e2167474-85f2-4f68-8e85-121a7b5bdb39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 12, 13, 14, 15]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def exercise_1(nums,x):\n",
    "    list = []\n",
    "    for i in nums:\n",
    "        list.append(i+x)\n",
    "    return list\n",
    "\n",
    "nums = [1, 2, 3, 4, 5]\n",
    "exercise_1(nums, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dea1f9e8-fe53-4861-81a3-034b1c20e697",
   "metadata": {},
   "source": [
    "Exercise 2: Create a function that accepts a list of numbers as input. Do not change the arrangement!\n",
    "\n",
    "Without sorting the list, this function should return the first number that is lower in value than the\n",
    "number preceding it. If there is none, return `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "25168e09-acbd-4396-a19a-3a78c29a823a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.9"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def exercise_2(nums):\n",
    "    #your code here.\n",
    "    i = 1\n",
    "    while nums[i] >= nums[i-1]:\n",
    "        i += 1\n",
    "        if i == len(nums):\n",
    "            return None\n",
    "    else:\n",
    "        return nums[i]\n",
    "    \n",
    "nums = [1,3,5,7,9, 8.9, 12,11]\n",
    "exercise_2(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "198382c4-ceba-43ff-91e9-c3d20fecd54e",
   "metadata": {},
   "source": [
    "Exercise 3: Create a function that has 3 parameters:\n",
    "\n",
    "* list of integers (num)\n",
    "* positive integer number (n1)\n",
    "* another positive integer number (n2).\n",
    "\n",
    "The function will return a list of integers that are multiples of n1 AND n2. If none, return None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "76de53e1-6eb0-4df8-bede-5c88540465ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]\n"
     ]
    }
   ],
   "source": [
    "nums = range(100)\n",
    "\n",
    "def exercise_3(nums, n1, n2):\n",
    "    # your code here.\n",
    "    list2 = []\n",
    "    for i in nums:\n",
    "        if nums[i] % n1 == 0 and nums[i] % n2 == 0:\n",
    "            list2.append(nums[i])\n",
    "    list2.remove(0)\n",
    "    print(list2)\n",
    "\n",
    "exercise_3(nums,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d0b4e868-0dc9-43a0-b8df-59ac215a7f5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 100)\n"
     ]
    }
   ],
   "source": [
    "arange(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a709fed1-87e6-4ffc-ad24-11851945ee30",
   "metadata": {},
   "source": [
    "Exercise 4: Create a function that accepts a list of real numbers of any size and any type (float or\n",
    "integer).\n",
    "The function should return a float representing the product of all the members of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "ba6ebe35-b315-4c4f-beed-b9d6887d95e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "354.89784000000003"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = [1.1,2.2,3.3,4.4,10.1]\n",
    "\n",
    "def exercise_4(nums):\n",
    "    \n",
    "    j = 1\n",
    "    for i in range(len(nums)):\n",
    "        j = j*nums[i]\n",
    "    return j\n",
    "\n",
    "exercise_4(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c8ac1fc-6360-452e-af60-d3706aa67e15",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}