map,reduce,filter.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Here we are talking about Map,Reduce and filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "m = lambda x:x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function <lambda> at 0x7f61acf9a9b0>\n"
     ]
    }
   ],
   "source": [
    "print m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print m(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n",
      "100\n",
      "121\n",
      "144\n",
      "169\n",
      "196\n",
      "225\n",
      "256\n",
      "289\n",
      "324\n",
      "361\n",
      "400\n"
     ]
    }
   ],
   "source": [
    "# now as we understand lamda returns the values of expressions for various functions as well, one just have to look \n",
    "# for various other stuff when you really takes care of other things\n",
    "\n",
    "# Now what of I have to provide various values to my Mapfunction so I can use for loop as follows:\n",
    "\n",
    "# follow Excelleance- Kaamyaabi Jhakk maar ke tumare peeche aayegi!!!!\n",
    "my_sequence = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]\n",
    "for value in my_sequence:\n",
    "    print m(value)    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 4,\n",
       " 9,\n",
       " 16,\n",
       " 25,\n",
       " 36,\n",
       " 49,\n",
       " 64,\n",
       " 81,\n",
       " 100,\n",
       " 121,\n",
       " 144,\n",
       " 169,\n",
       " 196,\n",
       " 225,\n",
       " 256,\n",
       " 289,\n",
       " 324,\n",
       " 361,\n",
       " 400]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now as we understand Python and many other languages support dynamic typic that means for each loop \n",
    "# there is refrence counting which is really based on the stuff that how much interation we are going to be done\n",
    "# so here comes map:\n",
    "\n",
    "# map(function,sequence) ---> Now what I am doing is feeding lots of values or sequence to my lambda function \n",
    "# which is automatically understind the main values of my code:\n",
    "\n",
    "map(m,my_sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# isn't it magic? :D Now question is How map,reduce and filter can be used in Datascience\n",
    "# as lamda is like writing expressions to various functions so when we have to work with various \n",
    "# expressions we can use lamda as well\n",
    "double_lambda = lambda x,y:x*x+y*y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "print double_lambda(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# so 9+4 = 13 which is perfectly understandabel to all of us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now we can also pass those values to multiple lists as well so we can create maximium things, it will work something\n",
    "# like this as well.\n",
    "Xs = [2,2,2,2,2,2,2,2,2,2,2,2] \n",
    "Ys = [3,3,3,3,3,3,3,3,3,3,3,3]\n",
    "map(double_lambda,Xs,Ys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# now let's see what is filter?\n",
    "# it is all map but only returns true values which satisfies the condition of the function.\n",
    "m = lambda x:x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter(m,Xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But as you can see in the above matrix it is just returning the same list because there is no True:False statement in \n",
    "# the m func. so for filter make sure your input function should be Boolean\n",
    "# let's rewrite m\n",
    "\n",
    "m = lambda x:x%2==0\n",
    "new_list = [1,2,3,4,5,6,7]\n",
    "filter(m,new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reduce as from the name it means we have to reduce the things as per the requirement. \n",
    "# Reduce works like in the two-arguments. whatever is provided to it it makes pairs of Each Sequence until gets one\n",
    "# result to work with.\n",
    "\n",
    "#Something like this:\n",
    "m = lambda x,y:x+y\n",
    "reduce(m,new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_m = lambda x,y:x if x>y else y\n",
    "reduce(new_m,new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:ipykernel_py2]",
   "language": "python",
   "name": "conda-env-ipykernel_py2-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}