5_RegularExpression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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/kimtaehan01/NLP_2023/blob/main/5_RegularExpression.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WhmHjz8Yy0of"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <font color = 'brown'> **Regular Expression (re)** </font> 정규표현식\n",
        "\n",
        "- 파이썬에서 사용되는 정규표현식 (Regular expressions)은 특정한 규칙을 가진 문자열의 집합을 표현하는 데 사용하는 형식 언어이다.\n",
        "- 정규표현식은 문자열에서 특정한 패턴을 검색하거나 매치하는 데 사용되는 문자열 검색과 치환을 위해 사용되는 기술이다.\n",
        "- 문자열에서 패턴을 정의하고, 그 패턴과 일치하는 부분을 찾거나 변경할 수 있다.\n",
        "- 파이썬 프로그래밍 내장 모듈이다. 복잡한 문자열 처리 작업에 유용하다.\n",
        "- 메타 문자 (Meta characters(특수문자))는 문자가 가진 원래의 의미가 아닌 특별한 용도로 사용되는 문자이다. 정규표현식에서 사용되는 메타 문자는 . ^ $ * + ? \\ | ( ) { } [ ] 이 있다.\n",
        "\n",
        "## <font color = 'brown'> **re**\n",
        "  - Python의 내장 모듈로서, 정규 표현식을 지원하는 라이브러리다. 정규 표현식은 문자열 패턴을 검색, 매치, 치환하거나 조작하는 데 사용됩니다. re 모듈은 문자열을 다룰 때 패턴 매칭과 관련된 작업을 수행하는 데 도움을 준다. 이 모듈을 사용하면 텍스트 데이터에서 원하는 패턴을 검색하거나 추출할 수 있다."
      ],
      "metadata": {
        "id": "xzwuO6jCeINh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🐹 🐾 Common **escape characters** include:\n",
        "\n",
        "- **\\n**: Represents a newline character. It is used to start a new line in a string.\n",
        "- **\\t**: Represents a tab character. It is used to insert a horizontal tab into a string.\n",
        "- **two consecutive backslashes**: Represents a literal backslash character. This is used to include a backslash in a string.\n",
        "- **\\ '**: Represents a single quotation mark (apostrophe). It is used to include a single quotation mark within a string enclosed in single quotes.\n",
        "- **\\ \"**: Represents a double quotation mark. It is used to include a double quotation mark within a string enclosed in double quotes.\n",
        "- **\\r**: Represents a carriage return. It is used to move the cursor to the beginning of the line.\n",
        "- **\\b**: Represents a backspace character. It is used to erase the previous character.\n",
        "\n",
        ">\n",
        "_Just for your reference_: **아래는 집에 가서 그냥 읽어보기**⤵️\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    \\v: Represents a vertical tab character. It is used to insert a vertical tab. It is rarely used.\n",
        "    \\v는 세로 탭(vertical tab) 문자를 나타내는 이스케이프 시퀀스다. 세로 탭은 일반적으로 텍스트 출력 중에 특정 위치로 이동하거나 세로로 텍스트를 정렬하는 데 사용된다. 정규 표현식에서 \\v를 사용하여 세로 탭 문자를 매치할 수 있습니다. 예를 들어, 정규 표현식에서 \\s+는 하나 이상의 연속된 공백 문자를 매치하는 패턴을 나타내며, \\f나 \\v를 사용하여 폼 피드나 세로 탭 문자를 매치할 수 있다. 이러한 이스케이프 시퀀스는 텍스트 데이터에서 특정 종류의 공백 문자를 처리하거나 추출할 때 유용하다.\n",
        "\n",
        "\n",
        "    \\f: Represents a form feed character. It is used to advance the cursor to the next page or form.\n",
        "    \\f는 폼 피드(form feed) 문자를 나타내는 이스케이프 시퀀스다. 폼 피드는 종이 프린터나 출력 장치에서 다음 페이지로 넘어가거나 특정 위치로 이동하는 데 사용되는 제어 문자 중 하나다. 정규 표현식에서 \\f를 사용하여 폼 피드 문자를 매치할 수 있다."
      ],
      "metadata": {
        "id": "kpWi1XZKLCX3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "1️⃣ 정규 표현식 문법 ⤵️\n",
        "\n",
        "정규 표현식을 위해 사용되는 문법 중 meta characters(특수문자)들은 아래와 같다.\n",
        ">\n",
        "\n",
        "|Symbol | Meaning|\n",
        "|--|--|\n",
        "|. | 한 개의 임의의 문자 (줄바꿈 문자인 \\n는 제외)|\n",
        "|? | 앞의 문자가 존재할 수도 있고, 존재하지 않을 수도 있음 (문자가 0개 또는 1개)|\n",
        "|* | 앞의 문자가 무한개로 존재할 수도 있고, 존재하지 않을 수도 있음 (문자가 0개 이상)|\n",
        "|+ | 앞의 문자가 최소 한 개 이상 존재 (문자가 1개 이상)|\n",
        "|^ | 뒤의 문자열로 문자열이 시작|\n",
        "|$ | 앞의 문자열로 문자열이 끝남|\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "l6DD0rHNy1Yn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🐹 🐾 **정규표현식 패턴은 _문자열_ 형태로 표현한다.**\n",
        "\n",
        "🐳💧 <font color = 'red'>**접두어 r 은 Raw 문자열을 나타내며, 이스케이프 문자(e.g., \\n, \\t, \\ 를 해석하지 않고 그대로 문자열로 표현하도록 힌다.**\n",
        "- The 'r' (raw) prefix is commonly used with regular expressions to simplify the handling of backslashes, but there are situations where you might see 'r' used without any escape characters (backslashes) in the regular expression. This can be due to a few reasons:\n",
        "\n",
        "    - <font color = 'blue'>**Consistency**</font>: Some programmers choose to consistently use the 'r' prefix for all regular expressions, even when the pattern doesn't contain any backslashes. This practice can make the code more uniform and easier to read.\n",
        "\n",
        "    - <font color = 'blue'>**Future-Proofing**</font>: Using 'r' for all regular expressions, regardless of whether they contain escape characters, can help prevent issues if the regular expression pattern is later modified to include backslashes. It ensures that backslashes are treated as literal characters from the start.\n",
        "\n",
        "    - <font color = 'blue'>**Code Maintenance**</font>: Code maintenance and readability are important. When you revisit your code in the future, you may not remember the specific details of each regular expression. Using 'r' consistently helps avoid potential pitfalls if you or someone else later modify the pattern.\n",
        "\n",
        "    - <font color = 'blue'>**Compatibility**</font>: It may also be a matter of compatibility across different parts of the code or between different regular expression libraries. Using 'r' consistently ensures that regular expressions are handled consistently throughout the codebase.\n",
        "\n"
      ],
      "metadata": {
        "id": "N-_A8t716QpE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#1. mata character Period . (뜻: 한 개의 임의의 문자) 예시 (cf., #20. r\"\\.\"\")\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"cat, hat, bat, sat, mat, combat, unbated\"\n",
        "pattern = r\".at\"  # .은 어떤 문자든 하나를 나타냄\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jxsLTn4rrNn0",
        "outputId": "ffc25764-7a91-4aa5-97e7-3b5248f038d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: cat\n",
            "Match: hat\n",
            "Match: bat\n",
            "Match: sat\n",
            "Match: mat\n",
            "Match: bat\n",
            "Match: bat\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#1a 💣💊COMPARE\n",
        "text2 = \"at, cat, at, hat, bat, sat, mat, combat, unbated\"\n",
        "\n",
        "matches = re.findall(pattern, text2)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bJAyFarmtPRK",
        "outputId": "9de03068-d8a7-4e76-8315-d3429da7cc85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: cat\n",
            "Match:  at\n",
            "Match: hat\n",
            "Match: bat\n",
            "Match: sat\n",
            "Match: mat\n",
            "Match: bat\n",
            "Match: bat\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2. mata character Question mark ? (뜻: ? 앞의 문자가 0번 혹은 1번 나타날 수 있음) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"color or colour?\"\n",
        "pattern = r\"colou?r\"  # u는 0 또는 1번 나타날 수 있음\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ol84ySQ5uwu6",
        "outputId": "101cc280-8050-4db8-8603-b3fcf613387e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: color\n",
            "Match: colour\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2a 💣💊COMPARE\n",
        "text2 = \"color, colour, or coloer?\"\n",
        "pattern = r\"colou?r\"  # u는 0 또는 1번 나타날 수 있음.\n",
        "\n",
        "matches = re.findall(pattern, text2)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8qhAtXYRvr-O",
        "outputId": "a1da7147-1bcc-4fd0-f12b-e5b2b8c503b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: color\n",
            "Match: colour\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#3. mata character Asterisk * (뜻: *는 앞의 요소가 0회 이상 나타날 수 있음) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"ab, ac, abc, abbc, aabbc, abbbbbbbbbbbbbbc\"\n",
        "pattern = r\"ab*c\"  # b가 0회 이상 반복될 수 있음. r은 Raw 문자열을 나타내며, 이스케이프 문자를 해석하지 않고 그대로 문자열로 표현하도록 힌디.\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SnBzH50SwV9O",
        "outputId": "cf5d4a19-0884-4433-e096-89ce6ff69d10"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: ac\n",
            "Match: abc\n",
            "Match: abbc\n",
            "Match: abbc\n",
            "Match: abbbbbbbbbbbbbbc\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#4. mata character $ (뜻: $는 문자열의 끝을 나타내는 메타 문자, 즉 해당 패턴이 문자열의 끝 부분과 일치해야 함) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Python is a popular programming language. Python is versatile.\"\n",
        "pattern = r'versatile.$'\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pB4b3UZlxgKJ",
        "outputId": "bcd713b7-e143-4ae6-f0b8-144afcd4c978"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: versatile.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#4a. 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Python is a popular programming language. Python is versatile.\"\n",
        "pattern = r'tile.$'\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "id": "8NhSsPtw79gh",
        "outputId": "4a188a9c-ae04-4582-81df-148e260bfcda",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: tile.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#4a 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Python is a popular programming language. Python is versatile:\"\n",
        "pattern = r'language.$'\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)\n",
        "\n",
        "#💊 \"language.\"는 문자열의 <끝>이 아니다. 따라서 출력값이 안나온다. 코드 셀은 NameError 없이 실행된다."
      ],
      "metadata": {
        "id": "qdiO4w2-yl89"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#5. mata character ^ (뜻: ^는 패턴의 시작 부분을 나타냄. 즉, 패턴을 사용하여 문자열을 검색하거나 매치할 때, 해당 패턴이 <문자열의 시작 부분과 일치> 해야함) 예시\n",
        "import re\n",
        "\n",
        "text = \"Python is a programming language. Python is versatile. We all love Python.\"\n",
        "pattern = r'^Python' #^를 사용하여 문자열의 시작 부분에서 특정 단어(e.g., 두개 Python 단어 중 <\"Python\" at the beginning of a string or a line>)를 검색하는 예제\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o1Ystg4EzO84",
        "outputId": "955c648c-90fa-4720-e1f6-a56bbad9909f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: Python\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#5a 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Python is a programming language. Python is versatile. We all love Python.\"\n",
        "pattern = r'^is' #^를 사용하여 문자열의 시작 부분에서 특정 단어(e.g., Python)를 검색하는 예제\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)\n",
        "\n",
        "#\"is\"는 at the beginning of string 이 아니라서 출력값이 안나온다. 코드 셀은 NameError 없이 실행된다."
      ],
      "metadata": {
        "id": "P11daD1282TS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#6. mata character + (뜻: +는 앞의 요소가 1회 이상 나타나야 함을 나타냄) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"cat, caat, caaat\"\n",
        "pattern = r\"ca+t\"  # a가 1회 이상 반복되어야 함\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9jnXicDE2NUd",
        "outputId": "5d6f43ca-d424-49c6-fc59-9d53266c552e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: cat\n",
            "Match: caat\n",
            "Match: caaat\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#6a 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"cat, caat, caaat, sat, set\"\n",
        "pattern = r\"ca+t\"  # a가 1회 이상 반복되어야 함\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jONOvsgz21_N",
        "outputId": "f74861be-c73e-432c-dd89-e17321610e9e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: cat\n",
            "Match: caat\n",
            "Match: caaat\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "|Symbol | Meaning|\n",
        "|--|--|\n",
        "|{숫자}|   숫자만큼 반복\n",
        "|{숫자1, 숫자2}| 숫자1 이상 숫자2 까지 반복. ?, *, +를 이것으로 대체할 수 있음|\n",
        "|{숫자,}| 숫자 이상만큼 반복\n",
        "|[ ] |   대괄호 안의 문자들 중 한 개의 문자와 매치|\n",
        "||.      [amk]라고 한다면 a 또는 m 또는 k 중 하나라도 존재하면 매치를 의미|\n",
        "||       [a-z]와 같이 범위를 지정할 수도 있음|\n",
        "||       [a-zA-Z]는 알파벳 전체를 의미하는 범위이며, 문자열에 알파벳이 존재하면 매치를 의미|\n",
        "|[^문자]|  해당 문자를 제외한 문자를 매치\n",
        "| 1 | A1B와 같이 쓰이며 A 또는 B의 의미| (cf.: a vertical line is replace by 1 to get the system work)"
      ],
      "metadata": {
        "id": "Rp-Ay64d-Es8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#7. {숫자} (뜻: {}를 사용하여 숫자를 지정하는 것은 정규 표현식에서 특정 패턴이 몇 번 나타날지 지정하는 방법 중 하나) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"123 4567 89 12345\"\n",
        "pattern = r\"\\d{3}\"  # \\d Matches any single digit character from 0 to 9. 숫자가 정확히 3번 반복되는 패턴\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vr5AK9reRFxX",
        "outputId": "b813e874-5871-4019-896a-208594b08e5e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 123\n",
            "Match: 456\n",
            "Match: 123\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#8. {숫자, 숫자} (뜻: 첫번째 숫자에서 두번째 숫자 자리수까지 검색) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The numbers are 12345678999, 12345, 987, and 56789.\"\n",
        "pattern = r\"\\d{3,5}\"  # 3자리에서 5자리 숫자를 찾음\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "avYqOIZ7-lsU",
        "outputId": "7003b330-f2b3-413a-b0c4-de39fd879ff6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 12345\n",
            "Match: 67899\n",
            "Match: 12345\n",
            "Match: 987\n",
            "Match: 56789\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#9. {숫자, } (뜻: {숫자,} 구문을 사용하면 최소한 숫자 번 이상 나타나는 패턴을 검색할 수 있음) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The word 'hello' is repeated many times: hellohellohellohellohello\"\n",
        "pattern = r\"(hello){2,}\"  # 'hello'가 두 번 이상 반복되는 패턴을 찾음. 여기서는 hellohellohellohellohello라는 패턴이 1 번 있어서 hello가 출력됨\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X_AiGne7AFaG",
        "outputId": "daf55ff9-aed9-4f8d-f910-c255b34ec7e9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#9a. 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The word 'hello' is repeated many times: hellohellohellohellohello hellohellohellohellohello hellohellohellohellohello\"\n",
        "pattern = r\"(hello){2,}\"  # 'hello'가 두 번 이상 반복되는 패턴을 찾음. 여기서는 hellohellohellohellohello라는 패턴이 3 번 있어서 hello가 3회 출력됨\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c0KkOU2XSSrh",
        "outputId": "d770403f-02a6-4e0c-afaf-ac871a772b40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: hello\n",
            "Match: hello\n",
            "Match: hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 10. [\\d]  (뜻: [ ]는 [ ]대괄호 안의 문자들 중 한 개의 숫자와 일치)예시\n",
        "import re\n",
        "\n",
        "text = \"The price is $100.\"\n",
        "pattern = r\"[\\d]\"\n",
        "# 숫자 하나를 나타내는 문자 클래스: 위 문자열에서 이 패턴을 사용하면 문자열 내에서 \"1\", \"0\", \"0\"이 각각 한 번씩 매치된다.\n",
        "#이 패턴은 숫자를 찾아내는 데 사용될 수 있다.\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3G1nH3o39ZSj",
        "outputId": "54835a46-4769-4369-83d6-45c87ecc92d7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 1\n",
            "Match: 0\n",
            "Match: 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 11. [amk] (뜻: [ ]는 [ ]대괄호 안의 문자들 중 한 개의 문자와 매치) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"I have an apple and a monkey in the kitchen.\"\n",
        "pattern = r\"[amk]\"  # 'a', 'm', 또는 'k' 중 하나의 문자를 찾음\n",
        "\n",
        "matches = re.findall(pattern, text) #re 모듈의 findall 함수를 호출. 이 함수는 문자열(text)에서 정규 표현식 패턴(pattern)과 일치하는 모든 부분을 찾아내어 리스트로 반환.\n",
        "#matches: re.findall() 함수의 결과인 일치하는 부분들이 저장되는 변수. 이 변수에는 text 문자열에서 \"a\", \"m\", 또는 \"k\"와 일치하는 모든 부분이 리스트 형태로 저장.\n",
        "#위의 코드에서 matches 리스트에는 \"a\", \"a\", \"m\", \"a\", \"k\", \"a\", \"m\", \"k\"와 같이 \"a\", \"m\", \"k\"와 일치하는 문자들이 저장\n",
        "\n",
        "for i in matches:     #for match in matches: 루프를 통해 matches 리스트의 각 아이템을 순회하며, 각 일치하는 문자를 출력\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 146
        },
        "id": "AfRu35aJE9Jh",
        "outputId": "4776e7f0-c9ed-4afc-e2e8-dba720b1a089"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-47-2fc4c6cc1727>\"\u001b[0;36m, line \u001b[0;32m13\u001b[0m\n\u001b[0;31m    print(\"Match:\" i)\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax. Perhaps you forgot a comma?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 11a. 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"I have an apple and a monkey in the kitchen.\"\n",
        "pattern = r\"[amk]\"  # 'a', 'm', 또는 'k' 중 하나의 문자를 찾음\n",
        "\n",
        "matches = re.findall(pattern, text) #re 모듈의 findall 함수를 호출. 이 함수는 문자열(text)에서 정규 표현식 패턴(pattern)과 일치하는 모든 부분을 찾아내어 리스트로 반환.\n",
        "#matches: re.findall() 함수의 결과인 일치하는 부분들이 저장되는 변수. 이 변수에는 text 문자열에서 \"a\", \"m\", 또는 \"k\"와 일치하는 모든 부분이 리스트 형태로 저장.\n",
        "#위의 코드에서 matches 리스트에는 \"a\", \"a\", \"m\", \"a\", \"k\", \"a\", \"m\", \"k\"와 같이 \"a\", \"m\", \"k\"와 일치하는 문자들이 저장\n",
        "\n",
        "for i in matches:     #for match in matches: 루프를 통해 matches 리스트의 각 아이템을 순회하며, 각 일치하는 문자를 출력\n",
        "    print(\"Match:\" i)"
      ],
      "metadata": {
        "id": "zj93Z-7QURNr",
        "outputId": "59426af8-06f5-4522-b500-9964538937f5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 146
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-48-2e9b4adf7f21>\"\u001b[0;36m, line \u001b[0;32m13\u001b[0m\n\u001b[0;31m    print(\"Match:\" i)\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax. Perhaps you forgot a comma?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#12. [a-z] (뜻: 'a'부터 'z'까지의 모든 소문자 글자와 일치) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The quick brown fox jumps over the lazy dog.\"\n",
        "pattern = r\"[a-z]\"  # 소문자 알파벳에 일치하는 패턴\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EKoaGHqBUNvz",
        "outputId": "36319ecb-4a83-44b6-a96e-26e4530a680c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: h\n",
            "Match: e\n",
            "Match: q\n",
            "Match: u\n",
            "Match: i\n",
            "Match: c\n",
            "Match: k\n",
            "Match: b\n",
            "Match: r\n",
            "Match: o\n",
            "Match: w\n",
            "Match: n\n",
            "Match: f\n",
            "Match: o\n",
            "Match: x\n",
            "Match: j\n",
            "Match: u\n",
            "Match: m\n",
            "Match: p\n",
            "Match: s\n",
            "Match: o\n",
            "Match: v\n",
            "Match: e\n",
            "Match: r\n",
            "Match: t\n",
            "Match: h\n",
            "Match: e\n",
            "Match: l\n",
            "Match: a\n",
            "Match: z\n",
            "Match: y\n",
            "Match: d\n",
            "Match: o\n",
            "Match: g\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#13. [A-Z] ('a'부터 'z'까지의 모든 대문자 글자와 일치) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"\\\"The book titles are 'The Aesop for Children', 'Harry Potter', and 'Pride and Prejudice',\\\" said Amelia.\"\n",
        "pattern = r\"[A-Z]\"  # 대문자 알파벳에 일치하는 패턴\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yjhd70m5UYA9",
        "outputId": "a7023a27-3ebd-48a0-d606-add2e394555b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: T\n",
            "Match: T\n",
            "Match: A\n",
            "Match: C\n",
            "Match: H\n",
            "Match: P\n",
            "Match: P\n",
            "Match: P\n",
            "Match: A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#14. [a-zA-Z] (뜻:  알파벳(대소문자 구분 없이) 모든 문자와 일치) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"New York is a wonderful city.\"\n",
        "pattern = r\"[a-zA-Z]\"  # 알파벳(대소문자 구분 없이) 모든 문자를 찾을 때 사용\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nGHMPctWUv7W",
        "outputId": "b57a0d15-9a20-4acb-8d58-62188b3fdd62"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: N\n",
            "Match: e\n",
            "Match: w\n",
            "Match: Y\n",
            "Match: o\n",
            "Match: r\n",
            "Match: k\n",
            "Match: i\n",
            "Match: s\n",
            "Match: a\n",
            "Match: w\n",
            "Match: o\n",
            "Match: n\n",
            "Match: d\n",
            "Match: e\n",
            "Match: r\n",
            "Match: f\n",
            "Match: u\n",
            "Match: l\n",
            "Match: c\n",
            "Match: i\n",
            "Match: t\n",
            "Match: y\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#15. [0-9] (뜻: 모든 숫자 (정수 형태)와 일치) 일치\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"A total of 149 episodes of The Aesop for Children.\"\n",
        "pattern = r\"[0-9]\"  #숫자를 찾을 때 사용\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AQL3FTEwVrRK",
        "outputId": "d1179443-59b8-40b0-dd58-be201b39f81f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 1\n",
            "Match: 4\n",
            "Match: 9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#15. 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"In mathematics, 3.14 is a decimal approximation of the mathematical constant π (pi).\"\n",
        "pattern = r\"[0-9]\"  #숫자를 찾을 때 사용\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "id": "A-5Mm7PTYf-D",
        "outputId": "742c9a8d-99b8-4a9e-e6d6-cfacda789964",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 3\n",
            "Match: 1\n",
            "Match: 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#16. [a-zA-Z0-9] (뜻: 대문자 소문자 구분없이 알파벳과 숫자를 포함하는 모든 문자와 일치) 예시\n",
        "import re\n",
        "\n",
        "text = \"24 Hours a Day, 7 Days a Week, & 365 Days a Year!\"\n",
        "pattern = r\"[a-zA-Z0-9]\"  #알파벳(대소문자 구분 없이)과 숫자를 포함하는 모든 문자를 찾을 때 사용. 기호는 포함 안됨.\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8whPpXJTU6aU",
        "outputId": "b7762aae-c099-4987-bcd6-a8c6af63c8f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 2\n",
            "Match: 4\n",
            "Match: H\n",
            "Match: o\n",
            "Match: u\n",
            "Match: r\n",
            "Match: s\n",
            "Match: a\n",
            "Match: D\n",
            "Match: a\n",
            "Match: y\n",
            "Match: 7\n",
            "Match: D\n",
            "Match: a\n",
            "Match: y\n",
            "Match: s\n",
            "Match: a\n",
            "Match: W\n",
            "Match: e\n",
            "Match: e\n",
            "Match: k\n",
            "Match: 3\n",
            "Match: 6\n",
            "Match: 5\n",
            "Match: D\n",
            "Match: a\n",
            "Match: y\n",
            "Match: s\n",
            "Match: a\n",
            "Match: Y\n",
            "Match: e\n",
            "Match: a\n",
            "Match: r\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#15. [^a-zA-Z0-9] (대문자, 소문자, 및 숫자를 제외한 모든 문자와 일치)\n",
        "import re\n",
        "\n",
        "text = \"24 Hours a Day,\\n 7 Days a Week,\\n & 365 Days a Year!\"\n",
        "\n",
        "pattern = r\"[^a-zA-Z0-9]\"  #알파벳(대소문자 구분 없이)과 숫자를 제외한 모든 문자를 찾을 때 사용 (e.g., white space, punctuations, meta characters, etc.)\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p1FWxclyV7Rh",
        "outputId": "7ebbe540-69ec-49c1-9f5a-4c17972480ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match:  \n",
            "Match:  \n",
            "Match:  \n",
            "Match: ,\n",
            "Match: \n",
            "\n",
            "Match:  \n",
            "Match:  \n",
            "Match:  \n",
            "Match:  \n",
            "Match: ,\n",
            "Match: \n",
            "\n",
            "Match:  \n",
            "Match: &\n",
            "Match:  \n",
            "Match:  \n",
            "Match:  \n",
            "Match:  \n",
            "Match: !\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#19. |  (뜻: or 와 일치) 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The color can be either red or blue.\"\n",
        "pattern = r\"either red|blue\"  # \"either red\" 또는 \"blue\"에 일치하는 패턴\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sgtQucMwWL98",
        "outputId": "84861e77-a4ea-40b8-93b0-8f8d1338b8b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: either red\n",
            "Match: blue\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 정규 표현식(re)에서 back slash \\ 는 이스케이프 문자로 사용되며, (특수 문자를 나타내거나) 메타 문자 자체를 일반 문자로 인식하도록 함.\n",
        "- 추후 참고를 위한 노트: 정규 표현식에서 \\s, \\f, \\v는 공백 문자를 나타내는 이스케이프 시퀀스다. 이들은 다음과 같은 의미를 갖는다:\n",
        "  - \\s는 정규 표현식에서 공백 문자(whitespace character)를 나타낸다. 공백 문자에는 스페이스(space), 탭(tab), 개행(newline), 캐리지 리턴(carriage return), 세로 탭(vertical tab), 폼 피드(form feed) 등이 포함된다. 이를 통해 문자열에서 공백 문자를 찾거나 매치할 수 있다.\n",
        "\n"
      ],
      "metadata": {
        "id": "ltll_jRv4ETE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#**<font color = 'red'> _More on RE_**"
      ],
      "metadata": {
        "id": "ESEzerU1NBpM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<font color = 'blue'> **정규 표현식 문법에는 역 슬래쉬(\\)를 이용하여 자주 쓰이는 문자 규칙들이 있다.**</font>\n",
        "\n",
        "|Character Rules|Meaning|\n",
        "|--|--|\n",
        "|\\  |  역 슬래쉬 문자 자체를 의미.이스케이프 문자로 사용|\n",
        "|\\d |  모든 숫자(any numbers)를 의미. [0-9]와 의미가 동일|\n",
        "|\\D |  숫자를 제외한 모든 문자를 의미. [^0-9]와 의미가 동일|\n",
        "|\\s |  공백을 의미합니다. [ \\t\\n\\r\\f\\v]와 의미가 동일.|\n",
        "|\\S |  공백을 제외한 문자를 의미합니다. [^ \\t\\n\\r\\f\\v]와 의미가 동일.|\n",
        "|\\w |  문자 또는 숫자(any charcters or numbers)를 의미합니다. [a-zA-Z0-9]와 의미가 동일.|\n",
        "|\\W |  문자 또는 숫자가 아닌 문자를 의미. [^a-zA-Z0-9]와 의미가 동일.|"
      ],
      "metadata": {
        "id": "cP40ceDaID6I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#20. 정규 표현식에서 백슬래시(\\)는 이스케이프 문자로 사용되며, 특수 문자를 나타내거나 메타 문자 자체를 일반 문자로 인식하도록 함.\n",
        "#백슬래시를 사용하여 특수 문자를 매칭할 수 있다. 예를 들어, \\.은 실제 점 문자(.)를 매치\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Hello, world.\\n This is test #5.\"\n",
        "pattern = r\"\\.\"  # 실제 Period . 문자를 매치\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6nyJV7_03i47",
        "outputId": "33db9c34-651e-47b8-d88e-0a45d0c7f5d7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: .\n",
            "Match: .\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#20.a 💣💊 COMPARE. The following example is more advanced from #1.\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Hello, world.\\n This is test #5.\"\n",
        "pattern = r\".\"  # Period . 문자를 매치\n",
        "#(cf., r'.' for 한개의 임의의 문자(예시: 대문자, 소문자, 숫자, white space, punctuations, symbols).\n",
        "# special charecters including meta charcters는 . 한개의 임의의 문자에 포함되지 않음.)\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "id": "zS5JfoVPihFk",
        "outputId": "c933696b-fc8c-4f54-9d5e-5baaaa49573e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: H\n",
            "Match: e\n",
            "Match: l\n",
            "Match: l\n",
            "Match: o\n",
            "Match: ,\n",
            "Match:  \n",
            "Match: w\n",
            "Match: o\n",
            "Match: r\n",
            "Match: l\n",
            "Match: d\n",
            "Match: .\n",
            "Match:  \n",
            "Match: T\n",
            "Match: h\n",
            "Match: i\n",
            "Match: s\n",
            "Match:  \n",
            "Match: i\n",
            "Match: s\n",
            "Match:  \n",
            "Match: t\n",
            "Match: e\n",
            "Match: s\n",
            "Match: t\n",
            "Match:  \n",
            "Match: #\n",
            "Match: 5\n",
            "Match: .\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#21. 정규 표현식에서 백슬래시(\\)는 이스케이프 문자로 사용되며, 특수 문자를 나타내거나 메타 문자 자체를 일반 문자로 인식하도록 함.\n",
        "#백슬래시를 사용하여 특수 문자를 매칭할 수 있다. 예를 들어, \\$은 실제 dollar sign($)를 매치\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The price is $100.\"\n",
        "pattern = r\"\\$\"  # 달러 기호를 매치\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pUHq2DTm4mgC",
        "outputId": "a1826f29-27f3-407e-a895-b519265c4c0b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: $\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 22. \\d 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The price is $100.\"\n",
        "pattern = r\"\\d\"  # 숫자 하나에 일치. 정규 표현식 패턴 r\"\\d\"은 숫자(digit)에 일치하는 패턴. 따라서 해당 패턴은 문자열에서 각각의 숫자에 일치하게 됨..\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JG-QkioZIr2a",
        "outputId": "eaff0150-2d55-46b7-d958-2c0cc61e7c82"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 1\n",
            "Match: 0\n",
            "Match: 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#22a 💣💊COMPARE\n",
        "\n",
        "#cf., 💊 만약 \"100\"이라는 문자열 전체에 대한 하나의 일치를 원한다면 r\"\\d+\"와 같이 + 메타 문자를 사용하여 숫자가 <하나 이상> 연속해서 일치하도록 패턴을 지정해야 함.\n",
        "\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The price is $100.\"\n",
        "pattern = r\"\\d+\"  # 메타 문자를 사용하여 숫자가 하나 이상 연속해서 일치하도록 패턴을 지정.\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "njhXD--2LhSs",
        "outputId": "451c8dec-8aaa-4541-a981-cc0cc565a08f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 23. \\D 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"The price is $100.\"\n",
        "pattern = r\"\\D\"  # 숫자가 아닌 문자(기호 포함)에 일치\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dJenR0g8JJ4K",
        "outputId": "faeada98-8ee9-4045-d72f-ff7f1f19cb13"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: T\n",
            "Match: h\n",
            "Match: e\n",
            "Match:  \n",
            "Match: p\n",
            "Match: r\n",
            "Match: i\n",
            "Match: c\n",
            "Match: e\n",
            "Match:  \n",
            "Match: i\n",
            "Match: s\n",
            "Match:  \n",
            "Match: $\n",
            "Match: .\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 24. \\s 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Hello   World\"\n",
        "pattern = r\"\\s\"  # 공백 문자에 일치\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-YAo4yI-JRdk",
        "outputId": "bc56ad4a-2540-4743-eb9e-7d9bb41a1e99"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match:  \n",
            "Match:  \n",
            "Match:  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#25.\\S 예시\n",
        "import re\n",
        "\n",
        "text = \"Hello   World\"\n",
        "pattern = r\"\\S\"  # 공백 문자가 아닌 문자에 일치\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MAf8sGWKJXVo",
        "outputId": "7cf3e4a1-b0ba-4169-c235-f778cb9548bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: H\n",
            "Match: e\n",
            "Match: l\n",
            "Match: l\n",
            "Match: o\n",
            "Match: W\n",
            "Match: o\n",
            "Match: r\n",
            "Match: l\n",
            "Match: d\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#26. \\w 예시\n",
        "import re\n",
        "\n",
        "text = \"Python is _awesome_!\"\n",
        "pattern = r\"\\w\"  # an alphanumeric character 일치. cf. an underscores included for 'r\"\\w\". However, punctuations such as period, exclamation mark, etc. are NOT included.\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dmn0l30UJfKf",
        "outputId": "feee31b9-1706-4388-d5d8-bd45ac4b8fe0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: P\n",
            "Match: y\n",
            "Match: t\n",
            "Match: h\n",
            "Match: o\n",
            "Match: n\n",
            "Match: i\n",
            "Match: s\n",
            "Match: _\n",
            "Match: a\n",
            "Match: w\n",
            "Match: e\n",
            "Match: s\n",
            "Match: o\n",
            "Match: m\n",
            "Match: e\n",
            "Match: _\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#27. \\w+ 예시\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"Python is awesome!\"\n",
        "pattern = r\"\\w+\"  #\"단어 문자\"를 나타냅니다. \"단어 문자\"는 알파벳 (대문자 및 소문자), 숫자 및 밑줄 (_)을 포함합니다. +: 이것은 하나 이상의 연속된 문자를 나타냅니다. 따라서 \\w+는 하나 이상의 연속된 \"단어 문자\"를 찾는 패턴\n",
        "\n",
        "matches = re.findall(pattern, text) #\"Python\", \"is\", \"awesome\"는 모두 하나 이상의 연속된 \"단어 문자\"로 이루어져 있으므로 이 정규표현식 패턴에 일치\n",
        "\n",
        "for match in matches:\n",
        "    print(\"Match:\", match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rQJHkVf1LSi8",
        "outputId": "237ba178-d0cc-4c5c-c616-3a0160417c70"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: Python\n",
            "Match: is\n",
            "Match: awesome\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#28. 백슬래시를 사용하여 특수한 문자 클래스를 생성할 수 있음. 예를 들어, \\d는 숫자를 매치하고, \\s는 공백 문자를 매치, \\w+는 하나 이상의 alphnumeric character including underscores\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"123 Main Street and 5 Avenue \"\n",
        "pattern = r\"\\d\\s\\w+\"  # 숫자, 공백, 단어를 매치 (하나의 숫자(\\d), 공백 문자(\\s) 하나 이상의 문자(\\w+)) <\"+\"는 이 sign 앞에 것이 1회 이상 반복되는 것을 뜻함>\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "    print(\"Match:\", i)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WVVXDwOS5B5U",
        "outputId": "4e4f29ea-caee-4fac-a071-54340bac6c60"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 3 Main\n",
            "Match: 5 Avenue\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 28a 💣💊COMPARE\n",
        "\n",
        "import re\n",
        "\n",
        "text = \"123 _Main_ Street_ and 5th Avenue \"\n",
        "pattern = r\"\\d\\s\\w+\"  # 숫자, 공백, 단어를 매치 (하나의 숫자(\\d), 공백 문자(\\s) 하나 이상의 단어 문자(\\w+)) <+ sign 앞에 alphanumeric characters 1회 이상 반복>\n",
        "\n",
        "matches = re.findall(pattern, text)\n",
        "\n",
        "for i in matches:\n",
        "  print(\"Match:\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fCBZj9n06MYZ",
        "outputId": "1cbcc141-5f37-49de-bcfc-39934ff2fa24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Match: 3 _Main_\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        ">\n",
        "2️⃣ 정규표현식 모듈 함수 ⤵️\n",
        "정규표현식 모듈에서 지원하는 함수는 아래와 같다.\n",
        "\n",
        "모듈 함수      설명\n",
        "re.compile()  정규표현식을 컴파일하는 함수다. 다시 말해, 파이썬에게 전해주는 역할을 한다. 찾고자 하는 패턴이 빈번한 경우에는 미리 컴파일 해놓고 사용하면 속도와 편의성면에서 유리하다. (e.g., >> r = re.compile(“ab{2,4}c”)\n",
        "\n",
        "  - In Python, compiling a regular expression means converting a regular expression pattern into a regular expression object. This compiled object can then be used for various operations, such as searching, matching, or replacing text in strings more efficiently. Compiling a regular expression pattern can offer performance benefits when you need to use the same pattern multiple times in your code.\n",
        "    - 파이썬에서 정규 표현식을 컴파일하는 것은 **정규 표현식 패턴을 정규 표현식 객체로 변환**하는 것을 의미한다. 이 컴파일된 객체는 문자열에서 검색, 매칭 또는 텍스트 교체와 같은 다양한 작업에 효율적으로 사용할 수 있다. 정규 표현식 패턴을 컴파일하면 코드에서 동일한 패턴을 여러 번 사용해야 할 때 성능상 이점을 제공할 수 있다.\n",
        "\n",
        "- re.search()   문자열 전체에 대해서 정규표현식과 매치되는지를 검색\n",
        "-re.match()   문자열의 처음이 정규표현식과 매치되는지를 검색\n",
        "-re.split()      정규 표현식을 기준으로 문자열을 분리하여 리스트로 리턴\n",
        "-re.findall()    문자열에서 정규 표현식과 매치되는 모든 경우의 문자열을 찾아서 리스트로 리턴. 만약 매치되는 문자열이 없다면 빈 리스트가 리턴\n",
        "-re.finditer()  문자열에서 정규 표현식과 매치되는 모든 경우의 문자열에 대한 이터레이터 객체를 리턴\n",
        "-re.sub()        문자열에서 정규 표현식과 일치하는 부분에 대해서 다른 문자열로 대체"
      ],
      "metadata": {
        "id": "qc55o_lFrJhw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###<font color = 'green'> **re.compile( ) 예시**"
      ],
      "metadata": {
        "id": "YQdCi_xC3MIu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###**regular expression을 사용한 다음 코드의 설명**\n",
        "\n",
        "shortword = re.compile(r'\\W*\\b\\w{1,3}\\b')\n",
        "\n",
        "  - 이 코드의 목적은 정규 표현식을 사용하여 주어진 텍스트에서 세 글자 이하의 짧은 단어를 찾아내는 것이다.\n",
        "\n",
        "  - 여기에서 정규 표현식 re.compile(r'\\W*\\b\\w{1,3}\\b')은 다음과 같은 요소로 구성된다:\n",
        "\n",
        "    - re.compile(): 이 부분은 정규 표현식을 컴파일하는 함수를 호출한다. 이 함수를 사용하면 정규 표현식을 미리 컴파일하여 재사용할 수 있다.\n",
        "\n",
        "    - r'\\W*\\b\\w{1,3}\\b': 이 부분이 실제 정규 표현식 패턴을 나타낸다. 여기에서 각 부분을 설명하면 다음과 같다.\n",
        "\n",
        "      - \\W*: \\W는 특수 문자가 아닌 문자(영문자, 숫자, 언더스코어)와 일치하는 것을 나타내며, *는 바로 앞의 패턴이 0회 이상 반복됨을 의미한다. 따라서 \\W*는 0회 이상의 특수 문자가 있는 부분을 의미한다. 이것은 짧은 단어 앞뒤에 있는 특수 문자나 공백을 처리하기 위한 부분이다.\n",
        "\n",
        "      - \\b: \\b는 단어 경계를 나타내며, 단어의 시작 또는 끝과 일치한다.\n",
        "\n",
        "      - \\w{1,3}: \\w는 워드 문자(알파벳, 숫자, 언더스코어)와 일치하는 것을 나타낸다. {1,3}는 앞의 패턴인 워드 문자가 1회에서 3회까지 반복됨을 의미한다. 따라서 \\w{1,3}는 1~3글자의 단어를 찾는다.\n",
        "\n",
        "      -\\b: 다시 한 번 \\b를 사용하여 단어 경계를 나타낸다.\n",
        "\n",
        "이렇게 정규 표현식을 조합하면 특수 문자와 공백을 포함하지 않고 1~3글자의 단어를 찾아낼 수 있다. 이 코드를 사용하면 텍스트에서 짧은 단어를 필터링하거나 추출하는 데 유용하게 활용할 수 있다."
      ],
      "metadata": {
        "id": "uaB5KnB33JiY"
      }
    }
  ]
}