python_practice.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyN6IZGLCHd02xg2pwjuUNRN",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ChetanKnowIt/Python_Class/blob/main/python_practice.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Python practice\n"
      ],
      "metadata": {
        "id": "5ltHj5TjGh9A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Write a program that contains a function that has one parameter, n, representing an integer\n",
        "greater than 0. The function should return n! (n factorial). Then write a main function that calls this\n",
        "function with the values 1 through 20, one at a time, printing the returned results. This is what your\n",
        "output should look like:\n",
        "\n",
        "1 1\n",
        "\n",
        "2 2\n",
        "\n",
        "3 6\n",
        "\n",
        "4 24\n",
        "\n",
        "5 120\n",
        "\n",
        "6 720\n",
        "\n",
        "7 5040\n",
        "\n",
        "8 40320\n",
        "\n",
        "9 362880"
      ],
      "metadata": {
        "id": "pEyv9xJmJdU2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fact(n):\n",
        "  f = 1\n",
        "  for i in range(1,n+1):\n",
        "    f = f*i\n",
        "  return f\n",
        "\n",
        "if __name__==\"__main__\":\n",
        "  for i in range(1,21):\n",
        "    print(i,fact(i))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QWU14zmJGmZQ",
        "outputId": "31dc0898-6412-4198-afc7-92f6cf5729a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 1\n",
            "2 2\n",
            "3 6\n",
            "4 24\n",
            "5 120\n",
            "6 720\n",
            "7 5040\n",
            "8 40320\n",
            "9 362880\n",
            "10 3628800\n",
            "11 39916800\n",
            "12 479001600\n",
            "13 6227020800\n",
            "14 87178291200\n",
            "15 1307674368000\n",
            "16 20922789888000\n",
            "17 355687428096000\n",
            "18 6402373705728000\n",
            "19 121645100408832000\n",
            "20 2432902008176640000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "3ZtRsQM30_PF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python Program to get Maximum product of elements of list in a 2D list\n",
        "Input :  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
        "Output : 504\n",
        "Explanation:1*2*3 = 6, 4*5*6 = 120, 7*8*9 = 504\n",
        "Since maximum is 504.\n"
      ],
      "metadata": {
        "id": "XTAzgqMQJSeH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getmax(l):\n",
        "  sublst = []\n",
        "  result = []\n",
        "  for i in range(0, len(l)):\n",
        "    sublst = l[i]\n",
        "    #print(sublst)\n",
        "    p=1\n",
        "    for j in sublst:\n",
        "      p = p*j\n",
        "    result.append(p)\n",
        "  #print(result)\n",
        "  return max(result)\n",
        "\n",
        "if __name__==\"__main__\":\n",
        "  lst =  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
        "  print(getmax(lst))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EJr_h9g9JXle",
        "outputId": "99e36567-6772-4039-e03a-e5353e625b96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "504\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sum of number digits in List\n",
        "The original list is : [12, 67, 98, 34]\n",
        "List Integer Summation : [3, 13, 17, 7]\n"
      ],
      "metadata": {
        "id": "LI5BVO7u7Nqp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l=[12,67,98,34]\n",
        "new_lst=[]\n",
        "for i in l:\n",
        "  sum = 0\n",
        "  while i!=0:\n",
        "    sum = sum + i%10\n",
        "    i=i//10  \n",
        "  new_lst.append(sum)\n",
        "print(new_lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OTlUTshx0dOD",
        "outputId": "bdb751ab-832d-4b43-c9a4-f90bd11cb8ae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 13, 17, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GRsJ4J0RH1e3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Program to print duplicates from a list of integers\n",
        "\n",
        "Input :  list = [-1, 1, -1, 8]\n",
        "Output : output_list = [-1]\n",
        "\n",
        "Input : list = [10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20]\n",
        "Output : output_list = [20, 30, -20, 60]\n"
      ],
      "metadata": {
        "id": "mTDHQ9--HYGy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "p =  [10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20] \n",
        "s=[]\n",
        "for i in p:\n",
        "  if p.count(i)>1:\n",
        "    s.append(i)\n",
        "\n",
        "e=list(set(s))\n",
        "print(e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4epIrxLGDeL",
        "outputId": "07fc3b1f-2ee7-4295-8de0-2807baa12edf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[20, -20, 30, 60]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "------------------------------------------------------------------\n",
        "Uncommon elements in Lists of List\n",
        "The original list 1 : [[1, 2], [3, 4], [5, 6]]\n",
        "The original list 2 : [[3, 4], [5, 7], [1, 2]]\n",
        "The uncommon of two lists is : [[5, 6], [5, 7]]\n",
        "\n",
        "------------------------------------------------------------------"
      ],
      "metadata": {
        "id": "7PJ-xdJtKqmB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l1 = [[1,2], [3,4], [5,6]]\n",
        "l2 = [[3,4], [5,7], [1,2]]\n",
        "l3 = []\n",
        "l4 = []\n",
        "\n",
        "for i in l1:\n",
        "  if i in l2:\n",
        "    l3.append(i)\n",
        "  elif i not in l2:\n",
        "    l4.append(i)\n",
        "\n",
        "for i in l2:\n",
        "  if i in l1:\n",
        "    l3.append(i)\n",
        "  elif i not in l1:\n",
        "    l4.append(i)\n",
        "\n",
        "\n",
        "print(l4)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nP8bQbMsF2Ft",
        "outputId": "329c9bc4-b97e-46f0-860f-2d9089e0acd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[5, 6], [5, 7]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8g_mWTywSwYz",
        "outputId": "81464a27-1cdf-47b4-d547-5b4b711df6df"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "findall:  ['o', 'o', 'o', 'o']\n",
            "search:  <re.Match object; span=(12, 13), match='o'>\n",
            "split:  ['The quick br', 'wn f', 'x jumps ', 'ver the lazy d', 'g.']\n",
            "sub:  The quick broown foox jumps oover the lazy doog.\n",
            "<re.Match object; span=(12, 13), match='o'>\n",
            "<re.Match object; span=(17, 18), match='o'>\n",
            "<re.Match object; span=(26, 27), match='o'>\n",
            "<re.Match object; span=(41, 42), match='o'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n=8888218321\n",
        "sum = 0\n",
        "\n",
        "while n!=0:\n",
        "    temp=n%10\n",
        "    sum = sum + temp\n",
        "    n=n//10\n",
        "    \n",
        "print(sum)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X1zySqqM0Xkz",
        "outputId": "d35ad5fc-8496-4d30-a152-d7fe07ac189a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "49\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.random.randint(1,100,20)\n",
        "print(\"input numpy array: \", a)\n",
        "\n",
        "\n",
        "def primeno(n):\n",
        "  flag = False\n",
        "  for i in range(2,n):\n",
        "    if (n % i) == 0:\n",
        "            # if factor is found, set flag to True\n",
        "            flag = True\n",
        "            # break out of loop\n",
        "            break\n",
        "  if not flag:\n",
        "    return n\n",
        "\n",
        "lst = []\n",
        "for i in a:\n",
        "  lst.append(primeno(i))\n",
        "new_list = [i for i in lst if i is not None]\n",
        "#print(new_list)\n",
        "a1 = np.array(new_list)\n",
        "print(\"output prime array: \", a1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jOlKDNH2rfIB",
        "outputId": "4e613ce3-c219-4507-d880-af51a6a8ea18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input numpy array:  [ 7 50 10 56 99 21 90  9 91 60 57 35 51 69 18  9 24  6 35 57]\n",
            "output prime array:  [7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Reverse Row sort in Lists of List The original list is : [[4, 1, 6], [7, 8], [4, 10, 8]] The reverse sorted Matrix is : [[6, 4, 1], [8, 7], [10, 8, 4]]"
      ],
      "metadata": {
        "id": "LEMUZgUCfc4r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l =  [[4, 1, 6], [7, 8], [4, 10, 8]]\n",
        "for i in range(len(l)):\n",
        "  l[i].sort(reverse=True)\n",
        "print(l)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wgrjhy7JfV5g",
        "outputId": "171d055c-366a-4e03-cabd-c3dd683846f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[6, 4, 1], [8, 7], [10, 8, 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Python program to find the sum of a Sublist\n",
        "The original list is : [[4, 1, 6], [7, 8], [4, 10, 8]]\n",
        "result is [11,15,22]\n"
      ],
      "metadata": {
        "id": "4fi3g7_r6KTb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l =  [[4, 1, 6], [7, 8], [4, 10, 8]]\n",
        "newlst = []\n",
        "for i in range(len(l)):\n",
        "  temp = sum(l[i])\n",
        "  newlst.append(temp)\n",
        "\n",
        "  \n",
        "print(newlst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PsyMD5ko6Lbi",
        "outputId": "28ac6375-dcd9-4a4d-cf8f-6349899cda03"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[11, 15, 22]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "------------------------------------------------------------------\n",
        "Python Program to Square Each Odd Number in a List using List Comprehension\n",
        "data=[1,2,3,4,5,6,7]\n",
        "[1, 9, 25, 49]       "
      ],
      "metadata": {
        "id": "IYeLDtig62RJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l= [1,2,3,4,5,6,7]\n",
        "lst = [ x**2 for x in l if x%2==1]\n",
        "print(lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PNzaN2DP64Ug",
        "outputId": "9bf072c7-9d22-4316-cf05-95e2d88555d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 9, 25, 49]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "---------------------------------------------------------------\n",
        "Python program to print even length words in a string\n",
        "Input: s = \"This is a python language\"\n",
        "Output: This is python language"
      ],
      "metadata": {
        "id": "M0mD0xvj71R_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = \"This is a python language\" \n",
        "s1 = s.split(\" \")\n",
        "s2 = [x for x in s1 if len(x)%2==0]\n",
        "f = \" \".join(s2)\n",
        "print(f)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gq-v_Bo-73X9",
        "outputId": "2a0e7bb8-30e7-4c10-9465-9661e61f332a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is python language\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python program to capitalize the first and last character of each word in a string\n",
        "Given the string, the task is to capitalise the first and last character of each word in a string. Examples:\n",
        "\n",
        "Input: hello world \n",
        "Output: HellO WorlD"
      ],
      "metadata": {
        "id": "B3-sqYad9hIQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string = \"hello world\"\n",
        "\n",
        "#method 1\n",
        "s1 = string.split(\" \")\n",
        "lst = []\n",
        "one = []\n",
        "for i in range(0,len(s1)):\n",
        "  lst.append(s1[i][1:-1])\n",
        "  temp = s1[i][0].upper()+lst[i]+s1[i][-1].upper()\n",
        "  one.append(temp)\n",
        "\n",
        "f = \" \".join(one)\n",
        "print(f)\n",
        "\n",
        "#method 2\n",
        "print(string[0:][0].upper()+string[1:4]+string[4].upper()+\" \"+string[6].upper()+string[7:-1]+string[-1].upper())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0FJ7Stcc9jNn",
        "outputId": "97345e11-c325-48ac-b5a4-56f9e78a83ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "HellO WorlD\n",
            "HellO WorlD\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "s = \"The quick brown fox jumps over the lazy dog.\"\n",
        "\n",
        "print(\"findall: \",re.findall('o',s))\n",
        "print(\"search: \",re.search('o',s))\n",
        "print(\"split: \",re.split('o',s))\n",
        "print(\"sub: \",re.sub('o',\"oo\",s))\n",
        "\n",
        "for i in re.finditer('o',s):\n",
        "  print(i)\n",
        "\n",
        "\n",
        "pat = re.compile(r'o')"
      ],
      "metadata": {
        "id": "1fsF6mo-wOIA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4f017b22-b5af-4049-8f84-f38174d3ace7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "findall:  ['o', 'o', 'o', 'o']\n",
            "search:  <re.Match object; span=(12, 13), match='o'>\n",
            "split:  ['The quick br', 'wn f', 'x jumps ', 'ver the lazy d', 'g.']\n",
            "sub:  The quick broown foox jumps oover the lazy doog.\n",
            "<re.Match object; span=(12, 13), match='o'>\n",
            "<re.Match object; span=(17, 18), match='o'>\n",
            "<re.Match object; span=(26, 27), match='o'>\n",
            "<re.Match object; span=(41, 42), match='o'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "CxPKn4W8fSoC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Test question\n",
        "1. ****1234 card number\n",
        "2. factorial of dictionaries\n",
        "3. prime number numpy array and prime tuples of that array\n",
        "4. 4 and 6 digits- valid / Invalid"
      ],
      "metadata": {
        "id": "Oi5VvGmE1A3S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "RMemFt2s1qXL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "path = \"copied path\"\n",
        "df_bonus = pd.read_csv(path)"
      ],
      "metadata": {
        "id": "O41-Ooloxu90"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}