G3 Basic _Python .ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1,FINDING SUM OF TWO NUMBER AND IDENTYFING WETHER IT IS EVEN OR ODD BY USING THERR FUNCTION.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "Entered value is odd\n"
     ]
    }
   ],
   "source": [
    "#FINDING SUM OF TWO NUMBER AND IDENTYFING WETHER IT IS EVEN OR ODD BY USING THERR FUNCTION\n",
    "\n",
    "def readdata():\n",
    "    a = int(input(\"Enter the data\"))\n",
    "    b = int(input(\"Enter the data\"))\n",
    "    addition(a,b)\n",
    "\n",
    "def addition(a,b):\n",
    "    sum = a+b\n",
    "    print(sum)\n",
    "    oddeven(sum)\n",
    "    \n",
    "\n",
    "def oddeven(sum):\n",
    "    if(sum % 2 == 0):\n",
    "        print(\"Entered value is even\")\n",
    "    else:\n",
    "        print(\"Entered value is odd\")\n",
    "\n",
    "readdata()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2,PYTHON PROGRAM TO FIND SQUAREROOT OF NUMBERS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.23606797749979\n",
      "2.23606797749979\n"
     ]
    }
   ],
   "source": [
    "#  PROGRAM TO FIND SQUAREROOT OF NUMBER\n",
    "import math\n",
    "x=int(input(\"ENTER THE NUMBER\"))\n",
    "def squareroot(x):\n",
    "    result=math.sqrt(x)\n",
    "    return result\n",
    "\n",
    "ans = squareroot(x)\n",
    "print(ans)\n",
    "\n",
    "# simple method to find squareroot of single number\n",
    "import math\n",
    "print(math.sqrt(5))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3, PYTHON PROGRAN TO FIND AREA OF TRIANGLE BY USING FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.5\n"
     ]
    }
   ],
   "source": [
    "#  PROGRAN TO FIND AREA OF TRIANGLE BY USING FUNCTION\n",
    "\n",
    "B=float(input(\"enter the base value\"))\n",
    "H=float(input(\"enter the hight value\"))\n",
    "\n",
    "#  FORMULA OF AREA OF TRIANGLE =(HALF*BASE*HIGHT)\n",
    "def Areatri(B,H):\n",
    "    tri1=1/2*B*H\n",
    "    return tri1\n",
    "\n",
    "ans=Areatri(B,H)\n",
    "print(ans)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4, PYTHON PROGRAM TO FIND SIMPLE INTREST BY USING BY FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.25\n"
     ]
    }
   ],
   "source": [
    "# PROGRAM TO FIND SIMPLE INTREST BY USING BY FUNCTION\n",
    " \n",
    "p=int(input('ENTER THE PRINCIPLE AMOUNT'))\n",
    "t=int(input('ENTER THE TIME'))\n",
    "r=int(input('ENTER THE RATE OF AMOUNT'))\n",
    "\n",
    "#  FORMULA OF SIMPLE INTREST=PRINCIPLE AMOUNT*(TIME*RATE OF INTREST)/100 \n",
    "def simp(p,t,r):\n",
    "    result=p*(t*r)/100 #FORMULA\n",
    "    return result\n",
    "\n",
    "ans=simp(p,t,r)\n",
    "print(ans)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5, PYTHON PROGRAM TO PRINT COMPOUND INTREST BY USING FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3814078125000018\n"
     ]
    }
   ],
   "source": [
    "#  PROGRAM TO PRINT COMPOUND INTREST BY USING FUNCTION\n",
    "\n",
    "p=int(input('ENTER THE PRINCIPLE AMOUNT'))\n",
    "t=int(input('ENTER THE TIME'))\n",
    "r=int(input('ENTER THE RATE OF AMOUNT'))\n",
    "\n",
    "#  FORMULA OF COMPOUND INTREST = PRINCIPLE AMOUNT(1+(RATE OF AMOUNT/100))**TIME  \n",
    "def compint(p,t,r):\n",
    "    a=p*(1+(r/100))**t #FORMULA\n",
    "    ci=a-p\n",
    "    return ci\n",
    "\n",
    "ans=compint(p,t,r)\n",
    "print(ans)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6, PYTHON PROGRAM TO FIND AREA OF CIRCLE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.5\n"
     ]
    }
   ],
   "source": [
    "# PROGRAM TO FIND AREA OF CIRCLE\n",
    "\n",
    "r=int(input('ENTER THE AREA OF CIRCLE'))\n",
    "def circle(r):\n",
    "    result=3.14*r*r   # FORMULA=PI=3.14*R*R\n",
    "    return result\n",
    "\n",
    "ans=circle(r)\n",
    "print(ans)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7,PROGRAM TO PRINT SWAPING OF NUMBERS:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 5)\n"
     ]
    }
   ],
   "source": [
    "# PROGRAM TO PRINT SWAPING OF NUMBERS\n",
    "\n",
    "a=int(input('Enter the value of A'))\n",
    "b=int(input('Enter the value of B'))\n",
    "\n",
    "def swap(a,b):\n",
    "    result=a,b=b,a\n",
    "    return result\n",
    "\n",
    "ans=swap(a,b)\n",
    "print(ans)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8,PYTHON PROGRAM TO GENRATE RANDOM NUMBRE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# Program to generate a random number between 0 and 9\n",
    "\n",
    "# importing the random module\n",
    "import random\n",
    "\n",
    "print(random.randint(0,9))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9,PROGRAM TO CONVERT KILOMETER TO MILES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.106855\n"
     ]
    }
   ],
   "source": [
    "#  PROGRAM TO CONVERT KILOMETER TO MILES\n",
    "\n",
    "k=float(input('ENTER THE VALUE IN KILOMETER'))\n",
    "\n",
    "def kilometer(k):\n",
    "    result=k*0.621371   # 1 KILOMETER =0.621371 MILES\n",
    "    return result\n",
    "\n",
    "ans=kilometer(k)\n",
    "print(ans)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10,PROGRAM TO FIND POSITIVE AND NEGATIVE NUMBER BY USING FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5  IS POSITIVE\n"
     ]
    }
   ],
   "source": [
    "#  PROGRAM TO FIND POSITIVE AND NEGATIVE NUMBER BY USING FUNCTION\n",
    "\n",
    "x=int(input(\"enter the value\"))\n",
    "def posneg(x):\n",
    "    if(x>0):   # (X>0)=ALL THE GRETEST VALUE THAN THE,ZERO ARE POSITIVE\n",
    "        print(x,\" IS POSITIVE\")\n",
    "    else:\n",
    "        print(x,\" IS NEGATIVE\")\n",
    "posneg(x)        "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11,PROGRAM TO FIND EVEN AND ODD BU USING FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd\n"
     ]
    }
   ],
   "source": [
    "#  PROGRM TO FIND EVEN AND ODD BU USING FUNCTION\n",
    "\n",
    "x=int(input(\"enter the value\"))\n",
    "def evod(x):\n",
    "    if x%2==0:\n",
    "     print(\"Even\")\n",
    "    else:\n",
    "       print(\"Odd\")\n",
    "evod(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12,FIND LARGEST AMOUNG THREE NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is largest 5\n"
     ]
    }
   ],
   "source": [
    "#  find largest amoung three numbers\n",
    "\n",
    "a=int(input(\"ENTER THE a VALUE\"))\n",
    "b=int(input('ENTER THE b VALUE'))\n",
    "c=int(input('ENTER THE c VALUE'))\n",
    "  \n",
    "if(a>b & a>c):  # LOGIC TO COMPARE THE VALUES\n",
    "  print(\"a is largest\",a)\n",
    "elif(b>a & b>c):\n",
    "  print(\"b is largest\",b)\n",
    "else:\n",
    "  print(\"c is largest\",c)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "13,PYTHON PROGRAM TO CHECK PRIME NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5  is a prime number\n",
      "5  is a prime number\n",
      "5  is a prime number\n"
     ]
    }
   ],
   "source": [
    "n=int(input('EMTER THE VALUE '))\n",
    "flag=False\n",
    "if n == 1:\n",
    "    print(n, \"is not a prime number\")\n",
    "elif n > 1:\n",
    "       for i in range(2,n):\n",
    "         if (n % i) == 0:\n",
    "            break\n",
    "         if False:\n",
    "            print(n, \"is not a prime number\")\n",
    "         else:\n",
    "            print(n, \" is a prime number\")\n",
    "                "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "14,PYTHON PROGRAM TO PRINT ALL PRIME NUMBER BETWEEN 1 TO 100"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "15,PROGRAM  TO FIND FACTORIAL OF NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "factorial = 1\n",
    "\n",
    "# check if the number is negative, positive or zero\n",
    "if num < 0:\n",
    "   print(\"Sorry, factorial does not exist for negative numbers\")\n",
    "elif num == 0:\n",
    "   print(\"The factorial of 0 is 1\")\n",
    "else:\n",
    "   for i in range(1,num + 1):\n",
    "       factorial = factorial*i\n",
    "   print(\"The factorial of\",num,\"is\",factorial)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "16,PYTHON PROGRAM TO PRINT FIBONACCI OF NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n"
     ]
    }
   ],
   "source": [
    "#  PROGRAM TO FIBONACCI SEQUENCE\n",
    "\n",
    "def Fibonacci(n):\n",
    "   \n",
    "    # Check if input is 0 then it will\n",
    "    # print incorrect input\n",
    "    if n < 0:\n",
    "        print(\"Incorrect input\")\n",
    " \n",
    "    # Check if n is 0\n",
    "    # then it will return 0\n",
    "    elif n == 0:\n",
    "        return 0\n",
    " \n",
    "    # Check if n is 1,2 # 1st=1,2nd=0+1=1,3rd=1+1=2,......\n",
    "    # it will return 1\n",
    "    elif n == 1 or n == 2:\n",
    "        return 1\n",
    " \n",
    "    else:\n",
    "        return Fibonacci(n-1) + Fibonacci(n-2)\n",
    " \n",
    "# result of program \n",
    "print(Fibonacci(9))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PYTHON PROGRAM TO PRINT FIBONACCI BY JUST FORMULA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# SIMPLE PROGRAM TO PRINT FIBONACCIA OF NUMBER\n",
    "\n",
    "n =int (input(\"ENTER THE VALUE\"))\n",
    "\n",
    "FIBO= (n-1)+(n-2)\n",
    "print(FIBO)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "17, PYTHON PROGRAM TO FIND NUMBER DIVISABLE BY ANOTHER NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " THE NUMBER IS DIVISIBLE\n"
     ]
    }
   ],
   "source": [
    "num1=int(input(\"ENTER THE VALUE\"))\n",
    "num2=int(input(\"ENTER THE VALUE\"))\n",
    "if num1%num2==0: \n",
    "    print(\" THE NUMBER IS DIVISIBLE\")\n",
    "else:\n",
    "    print(\"THE NUMBER IS NOT DIVISIBLE\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "18,PYTHON PROGRAM TO CONVERT DECIMAL TO BINARY,OCTAL  AND HEXADECIMAL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b101\n",
      "0x5\n",
      "0o5\n"
     ]
    }
   ],
   "source": [
    "# PROGRAM TO CONVERT DECIMAL TO BINARY ,OCTA AND HEXADECIMAL\n",
    " \n",
    "N=int(input('Enter the value'))\n",
    "print(bin(N))\n",
    "print(hex(N))\n",
    "print(oct(N))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "19,PYTHON PROGRAM TO PRINT ASCII VALUE OF CHARACTER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The ASCII value of '5' is 53\n"
     ]
    }
   ],
   "source": [
    "# PROGRAM TO FIND ASCII VALUE\n",
    "\n",
    "c = input(\"Enter The character\")\n",
    "print(\"The ASCII value of '\" + c + \"' is\", ord(c))\n",
    "#Python ord() function returns the Unicode code from a given character"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "20,PYTHON PROGRAM TO FIND FACTOR OF NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120\n"
     ]
    }
   ],
   "source": [
    "# To take input from the user\n",
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "factorial = 1\n",
    "\n",
    "# check if the number is negative, positive or zero\n",
    "if num < 0:\n",
    "   print(\"Sorry, factorial does not exist for negative numbers\")\n",
    "elif num == 0:\n",
    "   print(\"The factorial of 0 is 1\")\n",
    "else:\n",
    "   for i in range(1,num + 1):\n",
    "       factorial = factorial*i\n",
    "   print(\"The factorial of\",num,\"is\",factorial)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "21,PYTHON PROGRAM TO PRINT A SIMPLE CALCULATOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 0 25 1.0 0\n"
     ]
    }
   ],
   "source": [
    "#  PROGRAM OT PRINT SIMPLE CALCULATOR\n",
    "\n",
    "a=int(input(\"ENTER THE VALUE OF A\"))\n",
    "b=int(input(\"ENTER THE VALUE OF B\"))\n",
    "sum=a+b\n",
    "diff=a-b\n",
    "multi=a*b\n",
    "div=a/b\n",
    "mod=a%b\n",
    "print(sum,diff,multi,div,mod)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "22,PYHTON PROGRAM TO ADD TWO MATRICES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9, 7, 12], [7, 11, 9], [15, 11, 8]]\n",
      "[[9, 7, 12], [7, 11, 9], [15, 11, 8]]\n",
      "[[9, 7, 12], [7, 11, 9], [15, 11, 8]]\n"
     ]
    }
   ],
   "source": [
    "M1=[[1,2,3],[2,5,5],[8,9,7]]\n",
    "M2=[[8,5,9],[5,6,4],[7,2,1]]\n",
    "result=[[M1[i][j]+M2[i][j]   for j in range(len(M1[0]))]\n",
    "     for i in range(len(M1))]\n",
    "\n",
    "for i in result:\n",
    "    print(result)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "23,PYTHON PROGRAM TO TRANSPOSE A MATRICES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 4, 3]\n",
      "[7, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "# Program to transpose a matrix using a nested loop\n",
    "\n",
    "X = [[12,7],\n",
    "    [4 ,5],\n",
    "    [3 ,8]]\n",
    "\n",
    "result = [[0,0,0],\n",
    "         [0,0,0]]\n",
    "\n",
    "# iterate through rows\n",
    "for i in range(len(X)):\n",
    "   # iterate through columns\n",
    "   for j in range(len(X[0])):\n",
    "       result[j][i] = X[i][j]\n",
    "\n",
    "for r in result:\n",
    "   print(r)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "24,PYTHON PROGRAM TO MULTIPLY TWO MATRICES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "25,PYTHON PROGRAM TO CHECK WHETHER  A STRING IS PALAINDROME OR NOT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes it is a palindrome\n"
     ]
    }
   ],
   "source": [
    "#  PYTHON PROGRAM TO CHECK WHETHER THE STRING IS PALINDROME OR NOT\n",
    "\n",
    "def isPalindrome(s):\n",
    "    return s == s[::-1] #I want to reverse it and found a solution like\n",
    "  \n",
    "# Driver code\n",
    "s = \"malayalam\"\n",
    "ans = isPalindrome(s)\n",
    "  \n",
    "if ans:\n",
    "    print(\"Yes it is a palindrome\")\n",
    "else:\n",
    "    print(\"No it is not a palindrome\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "26, PYTHON PROGRAM TO CREAT PYRAMID PATTERNS BY OF NUMBER TILL 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "27,PYTHON PROGRAM TO MERGE TWO LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['gourav', 's', 'popale', 'is', 'student', 'of keonics center']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1=['gourav','s','popale']\n",
    "list2=['is','student','of keonics center']\n",
    "list3=list1+list2\n",
    "\n",
    "list3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "28,PYTHON PROGRAM TO ACCESS INDEX OF LIST USING FOR LOOP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 9\n",
      "1 8\n",
      "2 7\n",
      "3 4\n",
      "4 5\n",
      "5 6\n",
      "6 3\n",
      "7 2\n",
      "8 1\n"
     ]
    }
   ],
   "source": [
    "list=[9,8,7,4,5,6,3,2,1]\n",
    "for index in range(len(list)):\n",
    "    result=list[index]\n",
    "    print(index,result)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "29,PYTHON PROGRAM TO CONCATENATE TWO LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONCANTINATION OF TWO LIST:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "list1=[0,1,2,3,4]\n",
    "list2=[5,6,7,8,9]\n",
    "result=list1+list2\n",
    "print(\"CONCANTINATION OF TWO LIST:\"+str(result))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "30,PYTHON PROGRAM TO PRINT LAST ELEMENT FROM A LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "india\n",
      "india\n"
     ]
    }
   ],
   "source": [
    "# PROGRAM TO GET LAST ELEMENT FROM LIST\n",
    "#  BY USING INDEX NUMBER\n",
    " \n",
    "listx=[\"hubli\",'karnataka','india']\n",
    "print(listx[2])\n",
    "\n",
    "#  BY USING POP()METHOD\n",
    "listx=[\"hubli\",'karnataka','india']\n",
    "print(listx.pop())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "31,PYTHON PROGRAM TO PRINT RANDOMALY SELECT AN ELEMENT FROM THE LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KEONICS\n"
     ]
    }
   ],
   "source": [
    "LIST1=['GOURAV','S','POPLAE','STUDENT','OF','KEONICS']\n",
    "print(LIST1[5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "32,PYTHON PROGRAM TO PRINT ODD NUMBER IN LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9, 11, 13, 15]\n"
     ]
    }
   ],
   "source": [
    "LIST1=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]\n",
    "print(LIST1[0:15:2])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "33,PYTHON PROGRAM TO PRINT ALL EVEN NUMBER IN RANGE IN LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "LIST1=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]\n",
    "for i in LIST1[1:14:2]:\n",
    "    print(i)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "34,PYTHON PROGRAM TO FIND SUM OF ARRAY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum of the array 150\n"
     ]
    }
   ],
   "source": [
    "def sum(arr):\n",
    "    sum=0\n",
    "    for i in arr:\n",
    "      sum=sum+i\n",
    "    return(sum)\n",
    "    \n",
    "arr=[10,20,30,40,50]\n",
    "n=len(arr)\n",
    "ans=(sum(arr))\n",
    "print(\"sum of the array\",ans)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "35,PYTHON PROGRAM TO CHECK IF A STRING IS A NUMBER(FLOAT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "36,PYTHON PROGRAM TO CONVERT TWO LIST INTO A DICTIONARY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ORIGINAL LIST IS : ['GOURAV', 'DARSHAN', 'SMARTH', 'SHANKER']\n",
      "ORIGINAL LIST IS : [1, 2, 3, 4]\n",
      "LIST INTO A DICTIONARY IS {'GOURAV': 1, 'DARSHAN': 2, 'SMARTH': 3, 'SHANKER': 4}\n"
     ]
    }
   ],
   "source": [
    "LIST1=['GOURAV','DARSHAN','SMARTH','SHANKER',]\n",
    "LIST2=[1,2,3,4]\n",
    "print(\"ORIGINAL LIST IS :\",(LIST1))\n",
    "print(\"ORIGINAL LIST IS :\",(LIST2))\n",
    "result={LIST1[i]:LIST2[i] for i in range(len(LIST1))}\n",
    "print(\"LIST INTO A DICTIONARY IS\",result)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "37,PYTHON PROGRAM TO REVERSE A NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 8, 7, 6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num=[1,2,3,4,5,6,7,8,9]\n",
    "num.reverse()\n",
    "num"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "38, PYTHON PROGRAM TO COMPUTE THE POWER OF A NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3125.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "N=int(input(\"ENTER THE VALUE \"))\n",
    "Power=int(input(\"ENTER THE VALUE\"))\n",
    "result=math.pow(N,Power)\n",
    "print(result)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "39,PYTHON PROGRAM TO COUNT THE NUMBER OF DIGITS PRESENT IN A NUMBER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of digits in 122 is: 3\n"
     ]
    }
   ],
   "source": [
    "# Function to count the number of digits in a number\n",
    "def count_digits(number):\n",
    "    # Convert the number to a string and calculate its length\n",
    "    num_str = str(number)\n",
    "    num_digits = len(num_str)\n",
    "    \n",
    "    return num_digits\n",
    "\n",
    "# Input from the user\n",
    "number = str(input(\"Enter a number: \"))\n",
    "\n",
    "# Call the function to count digits\n",
    "result = count_digits(number)\n",
    "\n",
    "# Display the result\n",
    "print(f\"The number of digits in {number} is: {result}\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "40,PYTHON PROGRAM TO DISPLAY CALENDER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       May 5\n",
      "Mo Tu We Th Fr Sa Su\n",
      "                   1\n",
      " 2  3  4  5  6  7  8\n",
      " 9 10 11 12 13 14 15\n",
      "16 17 18 19 20 21 22\n",
      "23 24 25 26 27 28 29\n",
      "30 31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# PROGRAM TO DISPLAY CALENDER\n",
    "import calendar\n",
    "year=int(input(\"ENTER THE VALUE\"))\n",
    "month=(int(input(\"ENTER THE MONTH\")))\n",
    "print(calendar.month(year,month))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9, 7, 12], [7, 11, 9], [15, 11, 8]]\n",
      "[[9, 7, 12], [7, 11, 9], [15, 11, 8]]\n",
      "[[9, 7, 12], [7, 11, 9], [15, 11, 8]]\n"
     ]
    }
   ],
   "source": [
    "M1=[[1,2,3],[2,5,5],[8,9,7]]\n",
    "M2=[[8,5,9],[5,6,4],[7,2,1]]\n",
    "result=[[M1[i][j]+M2[i][j]   for j in range(len(M1[0]))]\n",
    "    for i in range(len(M1))]\n",
    "# result=[]\n",
    "# for i in len(M1):\n",
    "#     for j in M2:\n",
    "#         result=M1[i][j]+M2[i][j]\n",
    "\n",
    "for i in result:\n",
    "    print(result)"
   ]
  }
 ],
 "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}