07_Comprehensions_map_lambda.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Nothing but the short form of for loop\n",
    "* Can include if-else as well\n",
    "* concise syntax\n",
    "* little difficult to understand at first sight\n",
    "* easy and readable way to generate data structures (list, tuples, dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's look at examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = list(range(0,10))\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** I want to duplicate the my_list by iterating list values one by one ** \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = list(range(0,10))\n",
    "print(\"my_list = \", my_list)\n",
    "my_copy = []\n",
    "for n in my_list:\n",
    "    my_copy.append(n)\n",
    "\n",
    "print(my_list is my_copy)\n",
    "print(\"my_copy = \", my_copy)\n",
    "print(\"is my_copy == my_list ?\", my_copy == my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** By using comprehensions ** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = list(range(0,10))\n",
    "print(\"my_list = \", my_list)\n",
    "\n",
    "my_copy = [n for n in my_list] # Comprehension\n",
    "\n",
    "print(\"my_copy = \", my_copy)\n",
    "print(\"is my_copy == my_list ?\", my_copy == my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** How about squared values? **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = list(range(0,10))\n",
    "print(\"my_list = \", my_list)\n",
    "\n",
    "my_squared = [n*n for n in my_list] # Comprehension\n",
    "\n",
    "print(\"my_squared = \", my_squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using map + lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = list(range(0,10))\n",
    "my_list = map(lambda n: n*n, nums)\n",
    "list(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/2188b5.jpg\" height=\"300px\" width=\"300px\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are map, reduce, filter and lambda in Python?\n",
    "***(hold the thought for Comprehensions for now. We'll get back to it later. )***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A simple one line function\n",
    "- We don't use `def` and `return` as they are implicit\n",
    "- Also called anonymous function\n",
    "- short, sweet and easy to implement\n",
    "- Python supports the creation of anonymous functions (i.e. functions that are not bound to a name) at runtime, using a construct called \"lambda\".\n",
    "- Often used in conjunction with typical functional concepts like filter() and map().\n",
    "\n",
    "Let's consider a function that returns square of a value\n",
    "```python\n",
    "def squared(x):\n",
    "    return x*x\n",
    "```\n",
    "\n",
    "Now, the same function can be made one-liner, usin lambda\n",
    "```python\n",
    "lambda x: x*x\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def squared(x=10):\n",
    "    return x*x\n",
    "\n",
    "print(\"function: \", squared(5))\n",
    "\n",
    "sq = lambda x=10: x*x\n",
    "print(\"Lambda:\", sq(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiple parameters\n",
    "addition = lambda x, y: x+y\n",
    "addition(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can use if else as well inside the lambda function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def maximum(x, y):\n",
    "    if x > y:\n",
    "        return x\n",
    "    else:\n",
    "        return y\n",
    "maximum(7,19)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maximum = lambda x, y: x if x > y else y\n",
    "maximum(3,123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "div = lambda x, y: x/y if y!=0 else \"zero division errer\"\n",
    "div(4,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- using `map` function, we can apply same function to each element of a sequence\n",
    "- returns the modified list\n",
    "- Basic syntax : \n",
    "```python \n",
    "map(func, seq)\n",
    "```\n",
    "- The first argument `func` is the name of a function and the second a sequence (e.g. a list) seq. \n",
    "- `map()` applies the function `func` to all the elements of the sequence `seq`. It returns a new list with the elements changed by `func`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/map.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example\n",
    "def fahrenheit(T):\n",
    "    return ((float(9)/5)*T + 32)\n",
    "def celsius(T):\n",
    "    return (float(5)/9)*(T-32)\n",
    "\n",
    "temp = (36.5, 37, 37.5,39)\n",
    "\n",
    "F = map(fahrenheit, temp)\n",
    "C = map(celsius, temp)\n",
    "print(list(F))\n",
    "print(list(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** can be used with lambda **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = [1, 2, 3, 4]\n",
    "print(list(map(lambda x: x**2, n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- filter item out of sequence\n",
    "- returned filtered list\n",
    "- The function `filter(function, list)` offers an elegant way to filter out all the elements of a list, for which the function function returns `True`.\n",
    "- The function `filter(f,l)` needs a function `f` as its first argument. f returns a Boolean value, i.e. either True or False. \n",
    "- This function will be applied to every element of the list l. Only if f returns True will the element of the list be included in the result list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/filter.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "n = [1, 2, 3, 4]\n",
    "print(tuple(filter(lambda x: x>2, n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fib = [0,1,1,2,3,5,8,13,21,34,55]\n",
    "result = filter(lambda x: x % 2 == 0, fib)\n",
    "print(list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reduce function\n",
    "- returns item, not a list\n",
    "- result of first operation is the input to next operation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/reduce.png\" width=\"300px\" height=\"300px\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example: Addition of each values in the list\n",
    "from functools import reduce\n",
    "nums= [47, 11, 42, 13]\n",
    "final_val = reduce(lambda x,y: x+y, nums)\n",
    "final_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's get back to comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extraction of the even numbers in the list\n",
    "nums = list(range(10))\n",
    "new_list = []\n",
    "for n in nums:\n",
    "    if n%2 == 0:\n",
    "        new_list.append(n)\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# by list comprehensions\n",
    "nums = list(range(10))\n",
    "new_list = [n for n in nums if n%2 == 0]\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ** get (index, letter) pair for each letter in \"abcde\" **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nums = [5, 10, 15, 20, 25]\n",
    "my_list = []\n",
    "for val in enumerate(nums):\n",
    "    my_list.append(val)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [5, 10, 15, 20, 25]\n",
    "my_list = [val for val in enumerate(nums)]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get all pairs\n",
    "my_str = \"abc\"\n",
    "my_list = []\n",
    "for letter in my_str:\n",
    "    for index in range(len(my_str)):\n",
    "        my_list.append((letter, index))\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_str = \"abc\"\n",
    "my_list = [(letter, index) for letter in my_str for index in range(len(my_str))]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  dictionary comprehensions\n",
    "- join two list of key:value pairs\n",
    "- we use zip function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(list(zip([\"a\", \"b\", \"c\"], [1, 2, 3])))\n",
    "# print(list(zip([\"a\", \"b\", \"c\"], [1, 2, 3, 4])))\n",
    "print(list(zip([\"a\", \"b\", \"c\", \"d\"], [1, 2, 3])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lang = [\"Python\", \"Java\", \"C\"]\n",
    "creator = [\"Guido Van Rossum\", \"James Gosling\", \"Denis Ritchi\"]\n",
    "\n",
    "my_dictionary = {}\n",
    "for key, val in zip(lang, creator):\n",
    "    my_dictionary[key]=val\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "lang = [\"Python\", \"Java\", \"C\"]\n",
    "creator = [\"Guido Van Rossum\", \"James Gosling\", \"Denis Ritchi\"]\n",
    "\n",
    "my_dict = {key:val for key, val in zip(lang, creator)} # Comprehensions\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lang = [\"Python\", \"Java\", \"C\", \"linux\"]\n",
    "creator = [\"Guido Van Rossum\", \"James Gosling\", \"Denis Ritchi\", \"Linus Torvalds\"]\n",
    "\n",
    "my_dictionary = {}\n",
    "for key, val in zip(lang, creator):\n",
    "    if key != \"linux\":\n",
    "        my_dictionary[key]=val\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lang = [\"Python\", \"Java\", \"C\", \"linux\"]\n",
    "creator = [\"Guido Van Rossum\", \"James Gosling\", \"Denis Ritchi\", \"Linus Torvalds\"]\n",
    "\n",
    "my_dict = {key:val for key, val in zip(lang, creator)}\n",
    "print(my_dict)\n",
    "\n",
    "\n",
    "my_dictionary = {key:val for key, val in zip(lang, creator) if key != \"linux\"}\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# set comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [1, 2, 3, 4, 5, 5]\n",
    "my_set = {val*val for val in nums}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# how about tuples?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = (1, 2, 3, 4, 5)\n",
    "print(type(nums))\n",
    "my_s_tup = (n*n for n in nums)\n",
    "print(my_s_tup)"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}