Assignment 3 (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Write a Python Program to implement your own myreduce() function which works exactly\n",
    "### like Python's built-in function reduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#Reduce function allows us to perform operations on the elements of a container or iterable object in a sequential order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "#Seeing how the reduce function works.\n",
    "\n",
    "reduce(lambda x,y:x*y, [1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating myreduce() fucntion\n",
    "\n",
    "def myreduce(func, seq):\n",
    "    \n",
    "#Using the new_val to store the result of each subsequent function implementation, and returning the final one.\n",
    "    \n",
    "    new_val = seq[0]\n",
    "    for i in range(1,len(seq)):\n",
    "        new_val = func(new_val,seq[i])\n",
    "        \n",
    "        \n",
    "    return new_val\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Checking myreduce function to see its working\n",
    "\n",
    "myreduce(lambda x,y:x*y, [1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Write a Python program to implement your own myfilter() function which works exactly\n",
    "### like Python's built-in function filter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Filter function accepts a function and a sequence as arguments. the function being accepted must return a boolean value\n",
    "#Filter function maps the input function and applies it ot each element of the sequence and \n",
    "#returns a generator function which when iterated returns only the values which have a True value\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lets see how filter function works\n",
    "\n",
    "def even_check(x):\n",
    "    if x % 2 ==0:\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 678]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#AS is seen, filter is a generator function and needs to be iterated over to give proper result, hence we use yield command\n",
    "\n",
    "\n",
    "list(filter(even_check,[1,2,3,4,5,6,7,8,678]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#Creating myfilter function\n",
    "\n",
    "def myfilter(func, seq):\n",
    "    new_list = []\n",
    "    for i in seq:\n",
    "        if func(i) == True:\n",
    "            new_list.append(i)\n",
    "            continue\n",
    "    yield new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 4, 6]]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Seems to work, lets check with another input function\n",
    "\n",
    "list(myfilter(even_check, [1,2,3,4,5,6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Check with prime check function to test the myfilter function!\n",
    "\n",
    "\n",
    "import math\n",
    "\n",
    "def prime(x):\n",
    "    if x %2 == 0 and x>2:\n",
    "        return False\n",
    "        \n",
    "    for i in range(3, int(math.sqrt(x)) + 1, 2):\n",
    "        if x % i ==0 :\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2, 3, 5, 7]]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Seems to be working great!\n",
    "\n",
    "\n",
    "list(myfilter(prime,range(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Implement List comprehensions to produce the following lists.\n",
    "### Write List comprehensions to produce the following Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. ['x', 'xx', 'xxx', 'xxxx', 'y', 'yy', 'yyy', 'yyyy', 'z', 'zz', 'zzz', 'zzzz']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'xx', 'xxx', 'xxxx', 'y', 'yy', 'yyy', 'yyyy', 'z', 'zz', 'zzz', 'zzzz']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Lets try to do this with list comprehension, and then with for loops. It will clear our understanding of ist comprehensions\n",
    "#With List comprehension\n",
    "var = ['x','y','z']\n",
    "\n",
    "[obj*num for obj in var for num in range(1,5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'xx', 'xxx', 'xxxx', 'y', 'yy', 'yyy', 'yyyy', 'z', 'zz', 'zzz', 'zzzz']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#With nested for loop\n",
    "\n",
    "var = ['x','y','z']\n",
    "new_var = []\n",
    "for i in var:\n",
    "    for j in range(1,5):\n",
    "        new_var.append(i*j)\n",
    "\n",
    "new_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. ['x', 'y', 'z', 'xx', 'yy', 'zz', 'xxx', 'yyy', 'zzz', 'xxxx', 'yyyy', 'zzzz']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'y', 'z', 'xx', 'yy', 'zz', 'xxx', 'yyy', 'zzz', 'xxxx', 'yyyy', 'zzzz']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#With list comprehension\n",
    "\n",
    "var = ['x','y','z']\n",
    "\n",
    "[obj*num for num in range(1,5) for obj in var]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'y', 'z', 'xx', 'yy', 'zz', 'xxx', 'yyy', 'zzz', 'xxxx', 'yyyy', 'zzzz']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#With For Loop\n",
    "\n",
    "var = ['x','y','z']\n",
    "new_var = []\n",
    "\n",
    "for i in range(1,5):\n",
    "    for j in var:\n",
    "        new_var.append(i*j)\n",
    "        \n",
    "new_var\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [[2], [3], [4], [3], [4], [5], [4], [5], [6]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2], [3], [4], [3], [4], [5], [4], [5], [6]]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With List comprehension\n",
    "\n",
    "var = [2,3,4]\n",
    "\n",
    "[[obj+num] for obj in var for num in range(0,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2], [3], [4], [3], [4], [5], [4], [5], [6]]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With nested for loop\n",
    "var = [2,3,4]\n",
    "new_var = []\n",
    "\n",
    "for i in var:\n",
    "    for j in range(0,3):\n",
    "        new_var.append([i+j])\n",
    "new_var    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [[2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With List comprehension\n",
    "\n",
    "var = [2,3,4,5]\n",
    "\n",
    "\n",
    "[[obj+num for obj in var]for num in range(0,4)]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [(1, 1), (2, 1), (3, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1), (2, 1), (3, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#With list comprehension\n",
    "\n",
    "var = [1,2,3]\n",
    "\n",
    "[(a,b) for b in var for a in var]"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}