Class_2_Recap -Cont.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recap Cont.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. More on functions: <font color = 'red'> Lambda functions </font> \n",
    " * Ad hoc or anonymous functions that are comprised of a single statement.\n",
    " * Lambda – filter, map, reduce: take a function and a list and applies the function\n",
    "to each elements in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "s = lambda x: x*x\n",
    "print(s(4))\n",
    "print((lambda x: x+2)(2)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 8]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: x +3, [2,4,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 8, 27, 64]\n",
      "[4]\n",
      "-8\n"
     ]
    }
   ],
   "source": [
    "def cube(x):\n",
    "    return x*x*x\n",
    "\n",
    "results = map(cube, (1,2,3,4))\n",
    "print(list(results))\n",
    "\n",
    "results = filter(lambda x: x > 3, (1,2,3,4))\n",
    "print(list(results))\n",
    "results = reduce(lambda x, y: x-y , [1,2,3,4])\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sun'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda a, b: a if len(a) < len(b) else b\n",
    "reduce(f, ['Earth', 'Sun', 'Alpha Centauri', 'Mars', 'Saturn', 'Galaxy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 2, 2]\n"
     ]
    }
   ],
   "source": [
    "def myfilter(x):  #return True if x*x >3  else False\n",
    "    if x*x >3:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "   \n",
    "results = filter(myfilter, [2,4,2, 2, 0.5])\n",
    "print(list(results))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. More on functions: <font color = 'red'> Recursive functions </font> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial_recursive(n):\n",
    "    # Base case: 1! = 1\n",
    "    if n == 1:\n",
    "        return 1\n",
    "\n",
    "    # Recursive case: n! = n * (n-1)!\n",
    "    else:\n",
    "        return n * factorial_recursive(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial_recursive(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3000\n",
      "7000\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.getrecursionlimit())\n",
    "sys.setrecursionlimit(7000)\n",
    "print(sys.getrecursionlimit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  * Fibonacci sequence $ f(n) = f(n-1) + f(n-2),  n>1, f(0) =0, f(1) =1. $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n < 0:\n",
    "        print(\"incorrect input\")\n",
    "    if n==0:\n",
    "        return 0\n",
    "    elif n==1: \n",
    "        return 1\n",
    "    else:\n",
    "        return(fibonacci(n-1) + fibonacci(n-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. __Exceptions__: for handling errors that happen during execution of a program\n",
    "\n",
    "    ![Syntax](try_except.webp)\n",
    "    **courstey** of GeekforGeek webpage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a valuey\n",
      "Make sure that .... \n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    x = int(input(\"Enter a value\"))\n",
    "    y = int(input(\"Enter another value\"))\n",
    "    print(x+y)\n",
    "except: \n",
    "    print(\"Make sure that .... \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 11. Shallow and deep copy: \n",
    "  - Do not stump\n",
    " - No problem with the  simple data types like integers and strings\n",
    " - shallow and deep concern for compound objects, i.e. objects containing other objects, like lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 8\n",
      "94750823613440 94750823613440\n",
      "8 4\n",
      "94750823613440 94750823613312\n"
     ]
    }
   ],
   "source": [
    "x = 8\n",
    "y = x\n",
    "print(x, y)\n",
    "print(id(x), id(y))\n",
    "y = 4\n",
    "print(x, y)\n",
    "print(id(x), id(y))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 0, 10] [8, 0, 10]\n",
      "140238432617488 140238432617488\n"
     ]
    }
   ],
   "source": [
    "x = [8, 9, 10]\n",
    "y = x\n",
    "y[1] = 0\n",
    "print(x, y)\n",
    "print(id(x), id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 9, 10] [8, 0, 10]\n",
      "140181894591824 140181895687056\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "x = [8, 9, 10]\n",
    "y = copy.deepcopy(x) # x[:]\n",
    "y[1] = 0\n",
    "print(x, y)\n",
    "print(id(x), id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 9, 10, ['c', 'b']] [8, 9, 10, ['c', 'b']]\n",
      "140181661428224 140181661428464\n"
     ]
    }
   ],
   "source": [
    "x = [8, 9, 10, ['a', 'b']]\n",
    "y = copy.copy(x) # x[:]\n",
    "y[3][0] = \"c\"\n",
    "print(x, y)\n",
    "print(id(x), id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises: \n",
    "1. Write a Python program that takes two lists and returns a list that contains only the elements that are common between the lists (without duplicates). Make sure your program works on two lists of different sizes.\n",
    "2. Write one line of Python program that takes a list  and returns a new list that has only the even elements of the given list. **Hint: use list comprehension**\n",
    "3. Write a function for checking the speed of drivers. This function should have one parameter:\n",
    " - If speed is less than 70, it should print “Ok”.\n",
    " - Otherwise, for every 5km above the speed limit (70), it should give the driver one demerit point and print the total number of demerit points and calculate fine, which is points $\\times 50$  RWF. For example, if the speed is 80, it should print: “Points: 2, Fine: 100 RWF ”.\n",
    " - If the driver gets more than 12 points, the function should print: “License suspended, Fine: points $\\times 50$  ”.\n",
    "4. Write a function that returns the sum of multiples of 3 and 5 between 0 and limit (parameter). For example, if limit is 20, it should return the sum of 3, 5, 6, 9, 10, 12, 15, 18, 20. \n",
    "5. Find the maximum of a list of numerical values by using lambda and reduce funtions\n",
    "6. Find the minumum of a list of numerical values by using lambda and reduce funtions\n",
    "7. Using recurssion, write a Python program to calculate the sum of a list of numbers. "
   ]
  },
  {
   "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
}