cool_stuff/regular_expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4cb3dc7b-b908-4ae9-aa77-be943cf116db",
   "metadata": {},
   "source": [
    "## Python was originally created to work with text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dbf21ff-1c91-40c7-8ed9-bae2638508c4",
   "metadata": {},
   "source": [
    "Using Python to parse text is one of the ways the language excels. You should learn a few ways to take advantage of this and use them. Or at least understand what is possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4a4e4e5d-c3dd-42ff-9e5b-6e0ab49e40a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re  # The standard library for regular expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "251b4254-d2a5-47f5-9340-a7587409a76a",
   "metadata": {},
   "source": [
    "Here we are searching a text string for the word \"France\". Since there was no match the search returns None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f5104b8f-50e3-4ebc-840a-b99915440409",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result with \"France\": None\n"
     ]
    }
   ],
   "source": [
    "string = \"The rain in Spain\"\n",
    "result = re.search(\"France\", string)\n",
    "print('result with \"France\":', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58ca7d1d-126c-4fb3-b63b-d5b2ebe5adb0",
   "metadata": {},
   "source": [
    "Here we search for \"rain\" and make a match so a re.match object is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1fe1730f-ab39-466f-b4dd-869606763f11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result with \"rain\": <re.Match object; span=(4, 8), match='rain'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search(\"rain\", string)\n",
    "print('result with \"rain\":', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "937d4ae4-3994-4e97-8749-4ddcdf4e0040",
   "metadata": {},
   "source": [
    "So far when we printed the result variable it was the object not the string found. To get the string found we need to extract it from the returned object by using the .group() method.\n",
    "\n",
    "We can also use some other methods on the returned object to get where the match was found. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5004519b-c643-4060-8f95-45d7f8e1c9d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result <re.Match object; span=(4, 8), match='rain'>\n",
      "result.group(): rain\n",
      "result.start(): 4\n",
      "result.span(): (4, 8)\n"
     ]
    }
   ],
   "source": [
    "print('result', result)\n",
    "print('result.group():', result.group())\n",
    "print('result.start():', result.start())\n",
    "print('result.span():', result.span())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "229e1804-7ff4-4602-b90e-28a5f9ebded9",
   "metadata": {},
   "source": [
    "Typical use requires checking if the returned value is None to check if a match was found. The most common syntax is something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ea20862f-1d50-4dbe-b7ca-e88545159c92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Found \"rain\" in \"The rain in Spain\"\n"
     ]
    }
   ],
   "source": [
    "if result is not None:\n",
    "    print(f'\\nFound \"rain\" in \"{string}\"')\n",
    "else:\n",
    "    print('We did not find a match')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9713273a-44b7-4d78-ad71-e171d800d856",
   "metadata": {},
   "source": [
    "Or you can use a try/except error handling syntax. Trying to extract the value from None will result in raising an _AttributeError_ exception. This will be caught by the try and the except clause is executed. Choose your own adventure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e6c65a24-edc1-4095-9a23-602974af5ba9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Found rain in The rain in Spain\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    result = result.group()\n",
    "    print(f'\\nFound {result} in {string}')\n",
    "except AttributeError:\n",
    "    print('We did not find a match')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a556656d-45e1-4a39-8107-e77deea197fb",
   "metadata": {},
   "source": [
    "Can also find multiple matches. Notice how the search is case sensitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f086f861-edb4-4c82-8c3c-9233b3a46e57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "re.findall(r\"that\", text): ['that']\n",
      "re.findall(r\"that\", text, flags=re.IGNORECASE): ['THAT', 'that', 'That']\n"
     ]
    }
   ],
   "source": [
    "text = 'those THAT tilt that That 8'\n",
    "print('re.findall(r\"that\", text):', re.findall(r\"that\", text))\n",
    "print('re.findall(r\"that\", text, flags=re.IGNORECASE):',\n",
    "      re.findall(r\"that\", text, flags=re.IGNORECASE))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f01c8de-8a5e-4b05-8529-0c0a712a2ee0",
   "metadata": {},
   "source": [
    "This is finding all instances of upper or lower case \"t\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "38568f18-ee1a-4aef-8462-d44eb2807dd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "re.findall(r\"[tT]\",text): ['t', 'T', 'T', 't', 't', 't', 't', 'T', 't']\n",
      "re.findall(pattern, text): ['t', 'T', 'T', 't', 't', 't', 't', 'T', 't']\n"
     ]
    }
   ],
   "source": [
    "print('re.findall(r\"[tT]\",text):', re.findall(r\"[tT]\", text))\n",
    "pattern = re.compile(r\"t\", flags=re.IGNORECASE)\n",
    "print('re.findall(pattern, text):', re.findall(pattern, text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e341a3b-0ddb-42ae-ac3c-78af06a5336b",
   "metadata": {},
   "source": [
    "This finds all characters in a-z or A-Z using escape character notation. \"\\w\" stands for any alpha-numeric character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "66a8e6c9-31c8-4d23-96eb-5829bc07f59e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['t', 'h', 'o', 's', 'e', 'T', 'H', 'A', 'T', 't', 'i', 'l', 't', 't', 'h', 'a', 't', 'T', 'h', 'a', 't', '8']\n"
     ]
    }
   ],
   "source": [
    "print(re.findall(r\"[\\w]\", text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64534b32-2241-4e55-af6d-96c9d26b9b57",
   "metadata": {},
   "source": [
    "Here we can take the single string and split into a list of strings. Works the same as .split() modifier. The \"\\s\" means single space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9bc27adc-c5d1-428a-9d5d-73bd104f9f01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', 'rain', 'in', 'Spain']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string = \"The rain in Spain\"\n",
    "re.split(\"\\s\", string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edf0d4aa-c345-4004-a159-9877e6a1c628",
   "metadata": {},
   "source": [
    "This will stop after the first character that matches and leave the rest as is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "27b22fb0-7ec1-4ca2-8657-90451d32b37e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', 'rain in Spain']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.split(\"\\s\", string, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39b1d3e4-a6f1-45f2-aa38-86da815d79b6",
   "metadata": {},
   "source": [
    "We can also replace a string with another string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e7c9da90-9c98-42dc-8bcf-729e7286fdd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The_rain_in_Spain\n",
      "The_rain in Spain\n",
      "The rain_IN_Spain\n"
     ]
    }
   ],
   "source": [
    "string = \"The rain in Spain\"\n",
    "print(re.sub(\"\\s\", \"_\", string))  # Replace all spaces with underscore\n",
    "print(re.sub(\"\\s\", \"_\", string, 1))  # Replace first instance of spaces with underscore\n",
    "print(re.sub(\" in \", \"_IN_\", string))  # Replace a space followed by space."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf28f032-16d6-4cd5-b87e-a127bcc35c77",
   "metadata": {},
   "source": [
    "We can start to use the power of regular expressions with special characters.\n",
    "The ^ character indicates start of text and $ character indicates end of text. If the match is not found it will return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4ebcced5-9e9f-4850-8d7b-902d24dc6651",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "someText\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "text = 'someText'\n",
    "pattern = r\"^someText$\"\n",
    "search_result = re.match(pattern, text)\n",
    "print(search_result.group())\n",
    "\n",
    "text = '  someText'\n",
    "search_result = re.match(pattern, text)\n",
    "print(search_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77c398a7-96b1-4388-baf5-fb4ca9046b74",
   "metadata": {},
   "source": [
    "The . character means match anything including nothing. The character after . indicates how many to match. In this case * means match 0 or more of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d8f38ec9-d636-496d-8212-22bc543a0fea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'someTextsomeText'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = 'someTextsomeText'\n",
    "pattern = r\".*\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "464864b7-dd0c-4ed2-aa15-2a1365612dfc",
   "metadata": {},
   "source": [
    "In this case + means match 1 or more of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3d38222c-64ce-44a5-adce-824bf353c80d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'someTextsomeText'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\".+\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cefb246-3eb7-45a9-95af-aff126403fd9",
   "metadata": {},
   "source": [
    "Now we can add some complexity. Looks for a string starting with \"some\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "23b5b2e3-af7b-4200-9ed7-c5bfc23c01d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'someTextsomeText'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\"^some.*\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "065477e6-03b3-4720-8d04-b3320bc21e3b",
   "metadata": {},
   "source": [
    "Match anything up to \"xt\" and then end the string. This will search for for first occurrence and if found will return with a match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "089878b9-16f1-45c1-9480-5b1c150994df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'someTextsomeText'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\".*xt+$\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668c5618-76ba-4483-bea2-a1bc73bfe48b",
   "metadata": {},
   "source": [
    "Here we search the string for \"xt\". Since there are two we would normally find the first and return. But here it is saying look for 0 or 1 matches at the end of the string. Since the string ends in \"xt\", this works. The ? is matching nothing which works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5e83bdbd-53ef-44a4-a737-deef320b33fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'someTextsomeText'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\".*xt?\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e125434-6e28-40b4-89b8-6c9c41f03119",
   "metadata": {},
   "source": [
    "We can now say how many times we should find a pattern with {}. Here we look for the instance of \"abc\" one time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2cf0c8ef-677b-402f-ae08-710b750bbcef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcabcABCCCCCCCabc'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = 'abcabcABCCCCCCCabc'\n",
    "\n",
    "pattern1 = r\".*abc{1}\"\n",
    "search_result = re.match(pattern1, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "487ede5d-0308-47fd-9bef-e71745c72aff",
   "metadata": {},
   "source": [
    "Here we say we need to find one to five occurrences of the C in ABC. Notice how there are more than 5 Cs, but only 5 are returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9b440630-0643-40b4-9157-fd4a7c52b3fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcabcABCCCCC'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern2 = r\".*ABC{1,5}\"\n",
    "search_result = re.match(pattern2, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8adf69b-8904-45da-85ed-1583b9a7c91e",
   "metadata": {},
   "source": [
    "Here we group what we search for with the multiple occurrences. Instead of just the one character next to {} find \"BC\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "03dd2f20-755b-4e29-bfa5-7a5683ff83cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcabcABC'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern3 = r\".*A(BC){1}\"\n",
    "search_result = re.match(pattern3, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef82d00a-42a9-47f3-a93a-82920d9da679",
   "metadata": {},
   "source": [
    "Here we search for \"B\" or \"C\", but the search will be a success on first one found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "dd2a5a93-6421-4646-bcb6-dcfa4f0d3dd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcabcABCCCCCCC'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern5 = r\".*(B|C)\"\n",
    "search_result = re.match(pattern5, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44cfaebd-13ca-4754-ba86-2eba3b9e172a",
   "metadata": {},
   "source": [
    "Here we look for the letters between B to J."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e5c8c970-a6c3-4286-81bd-cce3c13640e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcabcAB'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern6 = r\".*A[B-J]\"\n",
    "search_result = re.match(pattern6, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85681970-dd1c-4920-8ba6-c69382f74942",
   "metadata": {},
   "source": [
    "Let's do a more complicated search to highlight some important aspects of regular expressions. In particular the idea that searches are greedy by nature.\n",
    "\n",
    "We start by searching for the first word's character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "73eadc08-07ad-46d9-8c67-adc21fcda485",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'m'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = 'more complicated string with 3456 to search.'\n",
    "pattern = r\"\\w\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c11be07-802c-4ca3-98c1-95957d67854c",
   "metadata": {},
   "source": [
    "Search for 0 or more things ending in a word character. Notice how the one or more search is greedy. It returns as much as possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "16027074-3961-4ca7-acfc-b840e25134b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'more complicated string with 3456 to search'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\".*\\w\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8e3731a-7c0c-43cb-be38-737329688da6",
   "metadata": {},
   "source": [
    "Here we are searching for 0 or more characters ending in a digit not a word character. The one or more search is still greedy and returns the full number in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "58b63c18-78d2-44ef-b17b-621b15dad7ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'more complicated string with 3456'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\".*\\d\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f3ddc73-a4e5-4e37-a6b8-ad36be2cba93",
   "metadata": {},
   "source": [
    "Here things start to run together. There are special characters in the search \".\", \"*\", \"+\", some real text \"with\", \" \" and some escape characters. Escape characters start with \\ to say the next character is not a character to be matched but should be interpreted as what category to search. \\d is a digit, \\w is a word character, \\s is a space character. This says find 0 or more up to a space followed by \"with \", followed by two digits followed by 1 or more characters (which translates into the entire string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cd2dc559-1f11-4f81-99c6-e9912ebcf631",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'more complicated string with 3456 to search.'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pattern = r\".*\\swith \\d\\d.+\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "642ae85b-25e3-45b8-a456-6f69e756a85a",
   "metadata": {},
   "source": [
    "Here we search for two word characters from the beginning. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "66660385-1199-4c88-bab0-b37264d4f2cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = 'abcdeABC123aB'\n",
    "\n",
    "pattern = r\"^\\w{2}\"\n",
    "search_result = re.match(pattern, text)\n",
    "search_result.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ea50dfb-0fa5-4d7a-bc92-a96cf7a13331",
   "metadata": {},
   "source": [
    "This is using ranges of characters - [a-z] means all lower case letters. [A-Z] means all upper case letters. When the brackets are followed by \"+\", it means one or more shoud be found. Same for the \\d digit and \\w word characters. In addition to what is being found, group the results and return individually. To get the groups we call .groups() on the search result. It will return a tuple of matches. If no matches, search_result is set to None. The four patterns all match to the same result just with different syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "62a38a15-7043-4006-9dab-87eac328a64e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('abcde', 'ABC', '123', 'aB')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "pattern = r\"([a-z]+)([A-Z]+)(\\d+)(\\w+)$\"\n",
    "# pattern = r\"^([a-z]{1,5})([A-Z]{1,5})(\\d{1,5})(\\w{1,5})$\"\n",
    "# pattern = r\"([^A-Z]+)([^a-z]+)(\\d+)(\\w+)$\"\n",
    "# pattern = r\"([^A-Z]+)([A-Z]+)(\\d+)(\\w+)$\"\n",
    "search_result = re.match(pattern, text)\n",
    "print(search_result.groups())\n",
    "print(type(search_result.groups()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0157a2a3-1b74-478f-8b87-fc0c039e31c9",
   "metadata": {},
   "source": [
    "We can use standard Python syntax to unpack the tuple into variables directly. We just need to make sure the number of variables match the number of groups we expect to find."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "dd771da1-ac22-4102-ac91-d9d7cd8cd71b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcde ABC 123 aB\n"
     ]
    }
   ],
   "source": [
    "first, second, third, fourth = search_result.groups()\n",
    "print(first, second, third, fourth)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}