Python [Flow of control(if-else), For loop,Python function,Lambda function,Map function].ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IF-ELSE\n",
    "\n",
    "# We use If... else condition inorder to check if the condition is True or False .\n",
    "\n",
    "logical conditions from mathematics:\n",
    "\n",
    "Equals: a == b\n",
    "Not Equals: a != b\n",
    "Less than: a < b\n",
    "Less than or equal to: a <= b\n",
    "Greater than: a > b\n",
    "Greater than or equal to: a >= b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num is zero\n"
     ]
    }
   ],
   "source": [
    "num=0\n",
    "if num>0:\n",
    "    print('num is positive')\n",
    "elif num<0:\n",
    "    print('num is negative')\n",
    "else:\n",
    "    print('num is zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it is very sunny day\n"
     ]
    }
   ],
   "source": [
    "temp=45\n",
    "if temp>42:\n",
    "    print('it is very sunny day')\n",
    "else:\n",
    "    print('the weather is okay')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "grades=['a','b','c','d','e']\n",
    "for grade in grades:\n",
    "    print(grade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "a\n",
      "1\n",
      "b\n",
      "2\n",
      "c\n",
      "3\n",
      "d\n",
      "4\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for x,y in enumerate(grades):\n",
    "    print(x)\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'rice')\n",
      "(1, 'wheat')\n",
      "(2, 'pulse')\n",
      "(3, 'bajra')\n"
     ]
    }
   ],
   "source": [
    "grocery=['rice','wheat','pulse','bajra']\n",
    "for item in enumerate(grocery):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 rice\n",
      "1 wheat\n",
      "2 pulse\n",
      "3 bajra\n"
     ]
    }
   ],
   "source": [
    "for count,item in enumerate(grocery):\n",
    "    print(count,item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Handling Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a Python program executes, a user introduces conditions that cause run-time errors. As a result the program stops exceuting. As a developer, we need to anticipate these errors by knowing how to handle these exceptions in our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we have 5 kg of apple\n",
      "how many ways are we divide apple0\n",
      "you can't divide by zero again\n"
     ]
    }
   ],
   "source": [
    "print('we have 5 kg of apple')\n",
    "number=input('how many ways are we divide apple')\n",
    "number=int(number)\n",
    "try:\n",
    "    x=5/number\n",
    "    print(\"each person get\",x,\"kg of apple\")\n",
    "except ZeroDivisionError:\n",
    "    print(\"you can't divide by zero again\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_numbers(start,end):\n",
    "    x=0\n",
    "    for i in range(start,end+1):\n",
    "        x+=i\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "sum_of_numbers(2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda function\n",
    "Lambda functions are small functions usually not more than a line. It can have any number of arguments just like a normal function. The body of lambda functions is very small and consists of only one expression. The result of the expression is the value when the lambda is applied to an argument. Also there is no need for any return statement in lambda function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product of number=lambda     x,y    :    x*y\n",
    "function         =Lambda   argument :  argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply(x,y):\n",
    "    z=x*y\n",
    "    return(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(6,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#above muntion can be written in small function using lambda\n",
    "multiply=(lambda x,y:x*y)(8,9)\n",
    "multiply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map function\n",
    "Map functions expects a function object and any number of iterables like list, dictionary, etc. It executes the function_object for each element in the sequence and returns a list of the elements modified by the function object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map_output=list(map(lambda x:x*2, [1,2,3,4]))\n",
    "map_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def square_root (x):\n",
    "    z=math.sqrt(x)\n",
    "    return(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_root(4)"
   ]
  },
  {
   "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
}