Video 55 Lambda, Map and Filter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map Function - Built in key word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# shife + tab shows you in built function requirement and details\n",
    "\n",
    "# map(func, *iterables) --> map object\n",
    "\n",
    "# It shows map needs a function and some thing to iterate\n",
    "\n",
    "# Let's define a function that prints even numbers out of a list\n",
    "\n",
    "def even(nums):\n",
    "    for char in nums:\n",
    "        if char % 2 == 0:\n",
    "            print (char)\n",
    "        \n",
    "            \n",
    "even([2,3,4,5,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let us use the inbuilt function Map\n",
    "\n",
    "all_nums = [2,3,4,5,6]\n",
    "\n",
    "def even(nums):\n",
    "    if nums % 2 == 0:\n",
    "        return nums\n",
    "    else:\n",
    "        return \"ODD\"\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 'ODD', 4, 'ODD', 6]"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It maps through ALL the subjects in the list\n",
    "\n",
    "list(map(even, all_nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jacklyne\n",
      "Odd\n",
      "Karisma\n",
      "Odd\n",
      "Katrina\n"
     ]
    }
   ],
   "source": [
    "# Use First Characters of every word which is Odd and Use The Original Name if it's Even\n",
    "\n",
    "def name_list(name_of_models):\n",
    "    \n",
    "    for index ,name in enumerate(name_of_models):\n",
    "\n",
    "# What it does? - Enumerate means it segregate the names and allot INDEX NUMBERS against each name starting from 0. \n",
    "# They names against the even index number alloted gets printed (as required by the function) and odd numbers gets a 'Odd'\n",
    "\n",
    "        if index % 2 == 0:\n",
    "            print (name)\n",
    "        else:\n",
    "            print ('Odd')\n",
    "\n",
    "\n",
    "name_list(['Jacklyne', 'Mallikaa', 'Karisma', 'Karina', 'Katrina'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def name_list(name_of_models):\n",
    "    \n",
    "# The lENGTH of the name_of_models gets calculated and if the length of the name is EVEN the name is printed.\n",
    "# If The Length of name is ODD the INDEX [1] gets printed\n",
    "    \n",
    "    if len(name_of_models) % 2 == 0:\n",
    "        return (name_of_models)\n",
    "    else:\n",
    "        return (name_of_models[0:3])\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Katrinaa'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It returns the name as the length of the name is Even\n",
    "\n",
    "name_list('Katrinaa')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Kar'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It returns the first three words as the Length of the name is Odd\n",
    "\n",
    "name_list('Karinaa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Jacklyne', 'Mallikaa', 'Karisma', 'Karina', 'Katrina']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jacklyne', 'Mallikaa', 'Kar', 'Karina', 'Kat']"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With Mapping, the whole List - 'names', will be mapped and if the length is EVEN, it will print the names.\n",
    "\n",
    "# If it is ODD, it will print First Three Words in the name\n",
    "\n",
    "list(map(name_list, names))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FILTER FUNCTION - Built in Key Word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "Nope\n",
      "4\n",
      "Nope\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "def even(nums):\n",
    "\n",
    "    for char in nums:\n",
    "        if char % 2 == 0:\n",
    "            print (char)\n",
    "        else:\n",
    "            print ('Nope')\n",
    " \n",
    "\n",
    "even([2,3,4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_list = [2,3,4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [],
   "source": [
    "def even(nums):\n",
    "\n",
    "# Filter Function - It filters through the list and returns only what is needed. Unlike MAP.\n",
    "    if nums % 2 == 0:\n",
    "        return nums\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It gives out only the Even numbers from the List\n",
    "\n",
    "list(filter(even, all_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter using for loop\n",
    "\n",
    "for char in filter(even, all_list):\n",
    "        if char % 2 == 0:\n",
    "            print (char)\n",
    "        else:\n",
    "            print ('Nope')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lamda\n",
    "\n",
    "It is a short code generally used for 1 time. It cuts short a big code into small "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(nums)>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda nums: nums % 2 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "even = [2,3,4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda nums: nums % 2 == 0, even))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, False, True, False, True]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda nums: nums % 2 == 0, even))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(name_of_models)>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda name_of_models: len(name_of_models) % 2 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Jacklyne', 'Mallikaa', 'Karisma', 'Karina', 'Katrina']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, False, True, False]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda name_of_models: len(name_of_models) % 2 == 0, names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jacklyne', 'Mallikaa', 'Karina']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda name_of_models: len(name_of_models) % 2 == 0, names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jac', 'Mal', 'Kar', 'Kar', 'Kat']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda words: words[0:3],names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_together(words):\n",
    "    for index, char  in enumerate(words): \n",
    "        print (index, char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 J\n",
      "1 a\n",
      "2 c\n",
      "3 k\n",
      "4 l\n",
      "5 y\n",
      "6 n\n",
      "7 e\n"
     ]
    }
   ],
   "source": [
    "all_together('Jacklyne')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Jacklyne\n",
      "1 Andy\n",
      "2 Joana\n",
      "3 Sweety\n"
     ]
    }
   ],
   "source": [
    "all_together(['Jacklyne', 'Andy', 'Joana','Sweety'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [],
   "source": [
    "models = ['Jacklyne', 'Mallikaa', 'Karisma', 'Karina', 'Katrina']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normal Function\n",
    "\n",
    "def names(models):\n",
    "    for ch in models:\n",
    "        if len(models) %2 ==0:\n",
    "            return models\n",
    "        else:\n",
    "            return \"Nope\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jacklyne'"
      ]
     },
     "execution_count": 378,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names('Jacklyne') # Length is Even "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Nope'"
      ]
     },
     "execution_count": 379,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names('Jacklynne') # Length is Odd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jacklyne', 'Mallikaa', None, 'Karina', None]"
      ]
     },
     "execution_count": 388,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With Map function using Normal Function\n",
    "\n",
    "list(map(names, models))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normal Function\n",
    "\n",
    "def names(models):\n",
    "    for ch in models:\n",
    "        if len(models) %2 ==0:\n",
    "            return models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jacklyne', 'Mallikaa', 'Karina']"
      ]
     },
     "execution_count": 390,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With Filter Function using Normal Function\n",
    "\n",
    "list(filter(names, models))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, False, True, False]"
      ]
     },
     "execution_count": 393,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lambda Function using normal function\n",
    "\n",
    "#def names(models):\n",
    "#    for ch in models:\n",
    "#        if len(models) %2 ==0:\n",
    "#            return models\n",
    "\n",
    "\n",
    "list(map(lambda models:len(models) %2 ==0,models))\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jacklyne', 'Mallikaa', 'Karina']"
      ]
     },
     "execution_count": 394,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda models:len(models) % 2 == 0, models))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "even = lambda nums : nums ** 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1296"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even (6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "even = [2,3,4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[16, 81, 256, 625, 1296]"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda nums: nums ** 4, even))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_together(words): print(words[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enylkcaJ\n"
     ]
    }
   ],
   "source": [
    "all_together('Jacklyne')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab the First letters of a Srting using Lamda\n",
    "\n",
    "models = ['Jacklyne', 'Mallikaa', 'Karisma', 'Karina', 'Katrina']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['J', 'M', 'K', 'K', 'K']"
      ]
     },
     "execution_count": 414,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda letter: letter[0], models))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jacklyne', 'Mallikaa', 'Karina']"
      ]
     },
     "execution_count": 416,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda letter: len(letter) % 2 == 0, models))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}