python  session .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a+b= 11\n",
      "a*b= 30\n",
      "a power b = 15625\n",
      "the answer of dividion as double =1.2\n",
      "the answer of dividion as double int= 1\n",
      "the modelus of a and b = 5\n",
      "double\n",
      "single\n"
     ]
    }
   ],
   "source": [
    "#variables \n",
    "a= 5\n",
    "b= 6\n",
    "s=\"study group\"\n",
    "print(\"a+b= {}\".format(a+b))\n",
    "print(\"a*b= {}\".format(a*b))\n",
    "print(\"a power b = {}\".format(a**b))\n",
    "\n",
    "#note the difference between the following statements \n",
    "print(\"the answer of dividion as double ={}\".format(b/a))\n",
    "print(\"the answer of dividion as double int= {}\".format(b//a))\n",
    "# modelus \n",
    "print(\"the modelus of a and b = {}\".format(a%b))\n",
    "\n",
    "#you can use \"\" or '' to assign string\n",
    "s0=\"double\"\n",
    "s1=\"single\"\n",
    "print(s0)\n",
    "print(s1)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "islam \n"
     ]
    }
   ],
   "source": [
    "#re-assinghing to adiiferent data type \n",
    "a =\"islam \"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "#type casting \n",
    "s='10'\n",
    "print(type(s))\n",
    "s=int(s)\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1010101010\n"
     ]
    }
   ],
   "source": [
    "#print\n",
    "a =10\n",
    "a=str(a)\n",
    "print(a*5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 11\n",
      "10,11\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "#using seperator while printing \n",
    "z,b=10,11\n",
    "#with sep \n",
    "print(z,b)\n",
    "#without sep\n",
    "print(z,b,sep=\",\")\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a and b before switch:10, 11 \n",
      "a and b before switch:11, 10 \n"
     ]
    }
   ],
   "source": [
    "#switching trick\n",
    "print(\"a and b before switch:{}, {} \".format(a,b))\n",
    "a,b=b,a\n",
    "print(\"a and b after switch:{}, {} \".format(a,b))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "islam\n",
      "10\n",
      "1 2 4 5 4 \n",
      "type of a is  <class 'str'>\n",
      "type of b is  <class 'int'>\n",
      "type of c is  <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "#IO\n",
    "#take input from user as string \n",
    "a =input() \n",
    "#take input from user as int \n",
    "b =int(input())\n",
    "#take input from user as list \n",
    "c =list(map(int,input().split()))\n",
    "print(\"type of a is \",type (a))\n",
    "print(\"type of b is \",type (b))\n",
    "print(\"type of c is \",type (c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Not in if\n"
     ]
    }
   ],
   "source": [
    "# python program to illustrate If statement \n",
    "\n",
    "#Indentation in Python refers to the (spaces and tabs) that are used at the beginning of a statement. \n",
    "#The statements with the same indentation belong to the same group called a suite\n",
    "  \n",
    "i = 10\n",
    "if i > 15 : \n",
    "    print (\"10 is less than 15\") \n",
    "print (\"I am Not in if\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i is smaller than 15\n",
      "i is smaller than 12 too\n"
     ]
    }
   ],
   "source": [
    "# python program to illustrate nested If statement \n",
    "\n",
    "i = 10\n",
    "if (i == 10): \n",
    "    #  First if statement \n",
    "    if (i < 15): \n",
    "        print (\"i is smaller than 15\") \n",
    "\n",
    "    # Nested - if statement \n",
    "    # Will only be executed if statement above \n",
    "    # it is true \n",
    "    if (i < 12): \n",
    "        print (\"i is smaller than 12 too\") \n",
    "    else: \n",
    "        print (\"i is greater than 15\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a=10 \n",
    "b=11\n",
    "#logic operators in python \n",
    "#and opertor\n",
    "if(a==10 and b==11):\n",
    "    print(\"true\")\n",
    "\n",
    "print(a&b)\n",
    "#&& invalid syntax "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "a=10 \n",
    "b=11\n",
    "#or operator \n",
    "if(a==10 or  b==11):\n",
    "    print(\"true\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 "
     ]
    }
   ],
   "source": [
    "#loops \n",
    "for i in range(5):\n",
    "    print(i,end=' ')   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14 13 12 11 10 9 8 7 6 5 4 3 "
     ]
    }
   ],
   "source": [
    "#print on same line ====> use end \n",
    "#range(start, end ,step)\n",
    "for i in range(14,2,-1):\n",
    "    print(i,end= \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#while loop \n",
    "n=5 \n",
    "while(n):\n",
    "    print(n)\n",
    "    n-=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 is even\n",
      "9 is odd\n",
      "8 is even\n",
      "7 is odd\n",
      "6 is even\n",
      "5 is odd\n",
      "4 is even\n",
      "3 is odd\n",
      "2 is even\n",
      "1 is odd\n"
     ]
    }
   ],
   "source": [
    "#simple program to check if the number is even  or odd \n",
    "n=10\n",
    "while(n):\n",
    "    if(n%2==0):\n",
    "        print(n ,\"is even\")\n",
    "    else:\n",
    "        print(n ,\"is odd\")\n",
    "    n-=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#no switch SAD+LOL\n",
    "#alternative function \n",
    "def f(x):\n",
    "    return {'a': 1,'g':1,'b':1 }.get(x, 9)    # 9 is default if x not found\n",
    "print(f(\"a\"))\n",
    "print(f(\"C\"))#note that 9 is the default value "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the element at index 5 is : 9\n",
      "the element at last index is : 5\n",
      "l list is : [1, 58, 96, 5, 878, 9, 3, 5]\n",
      "the list after deleting the last element  [1, 58, 96, 5, 878, 9, 3]\n",
      "l after append [1, 58, 96, 5, 878, 9, 3, 'islam', [1, 2, 3, 4]]\n",
      "l after reverse is : [[1, 2, 3, 4], 'islam', 3, 9, 878, 5, 96, 58, 1]\n"
     ]
    }
   ],
   "source": [
    "#using list data strcuture in python \n",
    "#note that the list index is zero based \n",
    "l=[1,58,96,5,878,9,3,5]\n",
    "#l_index=[0,1,2,3,4,...] or [...,-3,-2,-1]\n",
    "\n",
    "#acces the element with index 5 in list\n",
    "print(\"the element at index 5 is :\",l[5])\n",
    "\n",
    "#print the last element ohe list \n",
    "print(\"the element at last index is :\",l[-1])\n",
    "\n",
    "#the whole list \n",
    "print(\"l list is :\" , l)\n",
    "\n",
    "#to delete the last element of the list use pop function \n",
    "l.pop()\n",
    "print(\"the list after deleting the last element \", l)\n",
    "#use append function to add a new element to the list \n",
    "#you can add string \n",
    "l.append(\"islam\")\n",
    "#you can list too\n",
    "l.append([1,2,3,4])\n",
    "print(\"l after append\",l)\n",
    " \n",
    "#you can use this trick to reverst the list \n",
    "l=l[::-1]\n",
    "print(\"l after reverse is :\", l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the length of the list is  10\n",
      "the sum of the list is  1067.5\n",
      "the maximun value in the list is  878\n",
      "the minmum value in the list is  0.5\n"
     ]
    }
   ],
   "source": [
    "l=[1,5,58,96,12,.5,878,9,3,5]\n",
    "#use some useful built in functions with lists \n",
    "print(\"the length of the list is \",len(l))\n",
    "print(\"the sum of the list is \",sum(l))\n",
    "print(\"the maximun value in the list is \",max(l))\n",
    "print(\"the minmum value in the list is \",min(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "103"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#ascii\n",
    "ord(\"g\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5, 6, 31, 100]\n"
     ]
    }
   ],
   "source": [
    "#differnce between sort  and sorted functions \n",
    "#both sort and sorted function are used to sort the list \n",
    "#sorted \n",
    "l=[1,2,31,100,4,5,6]\n",
    "l=sorted(l)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5, 6, 31, 100]\n"
     ]
    }
   ],
   "source": [
    "#sort\n",
    "l=[1,2,31,100,4,5,6]\n",
    "l.sort()\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the keys of the dict are  ['java', 'python', 'c']\n",
      "the values of the dict are  [100, 112, 11]\n",
      "java\n",
      "python\n",
      "python\n"
     ]
    }
   ],
   "source": [
    "# creating a new dictionary \n",
    "my_dict ={\"java\":100, \"python\":112, \"c\":11} \n",
    "  \n",
    "# list out keys and values separately \n",
    "key_list = list(my_dict.keys()) \n",
    "val_list = list(my_dict.values()) \n",
    "print(\"the keys of the dict are \",key_list)\n",
    "print(\"the values of the dict are \",val_list)\n",
    "\n",
    "#thats how you get the key of value \n",
    "#method 1 using the previous \n",
    "print(key_list[val_list.index(100)]) \n",
    "print(key_list[val_list.index(112)]) \n",
    "  \n",
    "# one-liner \n",
    "#method 2\n",
    "print(list(my_dict.keys())[list(my_dict.values()).index(112)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#just note that .index returns the indez of the first apperance of value in the list \n",
    "l=[1,2,2,4,5,6]\n",
    "l.index(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the value of key \"assad\" is  hosssam\n",
      "the value of key \"yassmine\" is  elsh7at\n",
      "d after changing  the value of jey islam  {'islam': 'youssef', 'asad': 'hosssam', 'yasmine': 'elsh7at', 'menna': 'magddy'}\n",
      "d after adding a new key and value to it {'islam': 'youssef', 'asad': 'hosssam', 'yasmine': 'elsh7at', 'menna': 'magddy', 11: 'gg'}\n"
     ]
    }
   ],
   "source": [
    "#dictionary\n",
    "\n",
    "d={\"islam\":\"elgendy\",\"asad\":\"hosssam\",\"yasmine\":\"elsh7at\",\"menna\":\"magddy\"}\n",
    "#how to get the the value of the key \n",
    "#method 1 \n",
    "print(\"the value of key \\\"assad\\\" is \" ,d.get(\"asad\"))\n",
    "#method 2 \n",
    "print(\"the value of key \\\"yassmine\\\" is \",d[\"yasmine\"])\n",
    "\n",
    "#re-asssgin a value of key\n",
    "d[\"islam\"]=\"youssef\"\n",
    "print(\"d after changing  the value of jey islam \", d )\n",
    "\n",
    "#adding a new key and value to dict \n",
    "d[11]=\"gg\"\n",
    "print(\"d after adding a new key and value to it\", d )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "islam\tyoussef\n",
      "asad\tmo7afemnzla\n",
      "yasmine\tadele\n",
      "menna\tmw3ine\n",
      "11\tgg\n"
     ]
    }
   ],
   "source": [
    "#use for to print the keys and values \n",
    "for key,value in d.items() :\n",
    "    print(key,value,sep=\"\\t\")\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "islam--asad--yasmine--menna--11--"
     ]
    }
   ],
   "source": [
    "#looping on the keys only\n",
    "#not if you want to loop on values only use \"dict.values()\"\"\n",
    "for key  in d.keys() :\n",
    "    print(key ,end =\"--\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 "
     ]
    }
   ],
   "source": [
    "#print list items using for loops \n",
    "l=[1,2,3,4,5,6,7]\n",
    "for i in l :\n",
    "    print(i,end =' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('islam', 'youssef') ('asad', 'hosssam') ('yasmine', 'elsh7at') ('menna', 'magddy') (11, 'gg')\n"
     ]
    }
   ],
   "source": [
    "#print dict keys and values using unpacking \n",
    "print(*d.items(),sep=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 34 5 64 5 "
     ]
    }
   ],
   "source": [
    "#diferent method to to print list values \n",
    "l=[12,34,5,64,5]\n",
    "for i in range(len(l)):\n",
    "    print(l[i],end =' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 34 5 64 5\n"
     ]
    }
   ],
   "source": [
    "#print list using unpacking \n",
    "#note that the unpacking is faster than  looping \n",
    "print(*l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 'hola']\n",
      "[1, 2, 3, 4, 5, 6, 'hola']\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "l=[1,2,3,4,5,6]\n",
    "#copig the list with same refrence \n",
    "l1=l\n",
    "#coping the list with differernt reference \n",
    "l2=l[:]\n",
    "#note l1 , l2 after changing appending to l\n",
    "l.append(\"hola\")\n",
    "print(l)\n",
    "#l1 changed \n",
    "print(l1)\n",
    "#l2 did not change \n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "#check if the value in the \n",
    "#method 1 \n",
    "for i in l :\n",
    "    if(i==2):\n",
    "        print(\"true\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i am here\n"
     ]
    }
   ],
   "source": [
    "#method 1 \n",
    "#this method is faster than the previous method \n",
    "if 2 in l :\n",
    "    print(\"i am here\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "#check if the value not in the \n",
    "if 8 not in l :\n",
    "    print(\"yes\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok\n"
     ]
    }
   ],
   "source": [
    "#you can apply the previous cincept on string t00\n",
    "s=\"islam\"\n",
    "if \"i\" in s :\n",
    "    print(\"ok\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no\n"
     ]
    }
   ],
   "source": [
    "#how to use is not \n",
    "if type(5) is not  int  :\n",
    "    print(\"ok\")\n",
    "else :\n",
    "    print(\"no\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "study group \n",
      "STUDY GROUP \n"
     ]
    }
   ],
   "source": [
    "s =\"studY GROUP \"\n",
    "#sting functions\n",
    "#convert all sring to lower case \n",
    "print(s.lower())\n",
    "#convert all sring to upper  case \n",
    "print(s.upper())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tu\n"
     ]
    }
   ],
   "source": [
    "#slicing the string \n",
    "print(s[1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================================================================================================\n"
     ]
    }
   ],
   "source": [
    "#print a string more than time on same line \n",
    "print(\"=\"*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "studY\n"
     ]
    }
   ],
   "source": [
    "#check if a substring is in a string \n",
    "if \"tu\" in s :\n",
    "    print(s)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pppudY'"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#replacing a char with another \n",
    "s.replace(\"s\",'p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "##list comprehensin\n",
    "# use list comprehensin to list the even numbers from 0-8 i\n",
    "l=[ i for i in range(0,10,2)]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9, 11, 13]\n"
     ]
    }
   ],
   "source": [
    "##use list comprehensin to add 5 to evey number in another list \n",
    "b=[i+5 for i in l]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "#list comprehensin to square the elements of the list \n",
    "l=[1,2,3,4,5,6]\n",
    "b=[i*i for i in l]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##list comprehensin to square the elements of the list  if the number is even \n",
    "l=[i*i for i in range(9) if(i%2==0)]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "#the syntax of how to definine a simple function in pythi \n",
    "def fun(x):\n",
    "    return x*x\n",
    "print(fun(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "l=[False,True,True]\n",
    "#all function returns True if all the element are true \n",
    "print(all(l))\n",
    "#any returns true if any elenment is true\n",
    "print(any(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is greater than a\n"
     ]
    }
   ],
   "source": [
    "print (\"Both a and b are equal\" if a == b else \"a is greater than b\"\n",
    "        if a > b else \"b is greater than a\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "#[on_true] if [expression] else [on_false] \n",
    "# Program to demonstrate conditional operator \n",
    "a, b = 10, 20\n",
    "  \n",
    "# Copy value of a in min if a < b else copy b \n",
    "min = a if a < b else b \n",
    "  \n",
    "print(min) "
   ]
  }
 ],
 "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
}