Regular Expressions NLP

 

Natural Language Processing (NLP)

Natural Language Processing (NLP) is a subfield of artificial intelligence (AI) focused on enabling machines to understand, interpret, and generate human language. It combines computational linguistics with machine learning and deep learning techniques to bridge the gap between human communication and computer understanding.

Core Tasks in NLP

1. Text Classification:

   • Assign predefined categories or labels to text data.
   • Example: Spam detection, sentiment analysis, topic classification.

2. Named Entity Recognition (NER):

   • Identify and classify entities in text such as names, dates, locations, or organizations.
   • Example: Extracting "New York" as a location from "I live in New York."

3. Machine Translation:

   • Translate text from one language to another.
   • Example: Google Translate translating from English to French.

4. Text Summarization:

   • Generate a concise summary of a longer document or article.
   • Example: Summarizing a news article into a few sentences.

5. Sentiment Analysis:

   • Determine the sentiment or emotion expressed in text (e.g., positive, negative, neutral).
   • Example: Analyzing customer reviews to understand opinions about a product.

6. Part-of-Speech (POS) Tagging:

   • Assign grammatical labels (e.g., noun, verb, adjective) to each word in a text.
   • Example: Tagging "run" as a verb in "I run every morning."

7. Question Answering (QA):

   • Build systems that answer questions based on input text or context.
   • Example: Answering "What is the capital of France?" based on a paragraph.

8. Speech Recognition:

   • Convert spoken language into text.
   • Example: Transcribing voice commands in digital assistants like Siri or Alexa.

9. Text Generation:

   • Generate coherent and contextually relevant text from given prompts.
   • Example: ChatGPT generating conversational responses or creative writing.

10. Dependency Parsing:

    • Analyze the grammatical structure of a sentence and establish relationships between words.
    • Example: Identifying that "dog" is the subject and "runs" is the action in "The dog runs."

Techniques in NLP

1. Traditional Techniques:

   • Rule-based approaches, stemming from computational linguistics.
   • Statistical methods, such as Hidden Markov Models (HMMs) and n-grams.

2. Modern Techniques:

   • Word Embeddings: Represent words as dense vectors (e.g., Word2Vec, GloVe).
   • Deep Learning Models: Utilize RNNs, LSTMs, GRUs, and Transformers for contextual understanding.
   • Pre-trained Models: Leverage state-of-the-art models like BERT, GPT, RoBERTa, and T5 for advanced NLP tasks.

Applications of NLP

1. Search Engines:

   • Power search algorithms by understanding user queries and ranking results.

2. Chatbots and Virtual Assistants:

   • Enable systems like Siri, Alexa, and customer support bots to engage in natural conversations.

3. Social Media Monitoring:

   • Analyze trends, sentiments, and opinions from social media platforms.

4. Healthcare:

   • Extract insights from medical records, assist in diagnostics, and perform symptom analysis.

5. Document Processing:

   • Automate the extraction of relevant information from legal or financial documents.

Summary

NLP brings computers closer to human-level understanding of language by tackling diverse tasks, from translation and summarization to sentiment analysis and text generation. With advancements in deep learning and pre-trained models, NLP has become increasingly powerful, finding applications in numerous industries and real-world scenarios.

Lexical, Syntactic, and Semantic Processing in NLP

These are three key levels of language processing in Natural Language Processing (NLP), each addressing a different aspect of understanding human language.

---

1. Lexical Processing

Definition: Lexical processing focuses on the analysis of individual words and their properties in a text.

Key Aspects:

• Tokenization: Splitting text into smaller units such as words, phrases, or subwords.
  Example: Breaking "The quick brown fox" into ["The", "quick", "brown", "fox"].

• Stemming and Lemmatization: Reducing words to their root forms.

  • Stemming: Chopping suffixes off words (e.g., "running" → "run").
  • Lemmatization: Mapping words to their base or dictionary forms (e.g., "running" → "run", considering context).

• Part-of-Speech (POS) Tagging: Assigning grammatical roles (e.g., noun, verb, adjective) to words. Example: "The (DET) quick (ADJ) brown (ADJ) fox (NOUN)."

Applications:

• Text tokenization for machine learning models.
• Vocabulary building in machine translation systems.

---

2. Syntactic Processing

Definition: Syntactic processing examines the grammatical structure of a sentence and how words are arranged to form meaningful phrases or sentences.

Key Aspects:

• Parsing: Analyzing a sentence's structure to identify relationships between words.
  Example: Building a syntax tree for "The cat sat on the mat."

• Phrase and Dependency Structure:

  • Phrase Structure (Constituency): Groups words into larger units like noun phrases or verb phrases.
  • Dependency Structure: Analyzes the direct relationships between words. Example: In "The cat sat," "cat" depends on "sat" as the subject.

• Grammar Checking: Ensures sentences conform to predefined grammatical rules.

Applications:

• Grammar correction tools like Grammarly.
• Input validation for chatbots and automated systems.

---

3. Semantic Processing

Definition: Semantic processing focuses on understanding the meaning of words, phrases, and sentences in context.

Key Aspects:

• Word Sense Disambiguation (WSD): Resolving ambiguity in word meanings based on context. Example: Determining whether "bank" refers to a riverbank or a financial institution.

• Named Entity Recognition (NER): Identifying entities like names, locations, and dates in text. Example: Extracting "New York" as a location and "Barack Obama" as a person.

• Coreference Resolution: Determining when different expressions refer to the same entity. Example: In "Barack Obama was elected. He served two terms," identifying "He" as referring to "Barack Obama."

• Sentiment Analysis: Identifying the sentiment or emotion expressed in the text. Example: Classifying a review as positive, negative, or neutral.

• Semantic Role Labeling (SRL): Identifying the roles that words play in a sentence. Example: In "John gave Mary a book," labeling "John" as the giver, "Mary" as the receiver, and "book" as the item.

Applications:

• Question-answering systems (e.g., Alexa, Siri).
• Machine translation tools (e.g., Google Translate).

---

Summary of the Levels

Processing Level	Focus	Techniques	Applications
Lexical	Individual words	Tokenization, Stemming, Lemmatization	Vocabulary building, word analysis
Syntactic	Sentence structure	Parsing, POS tagging	Grammar correction, structural analysis
Semantic	Sentence meaning	Word Sense Disambiguation, NER, SRL	Sentiment analysis, question answering

---

Text Encoding in Natural Language Processing (NLP)

Text encoding refers to the process of converting text data (words, sentences, or documents) into numerical representations that can be processed by machine learning models. Since computers work with numbers and not raw text, encoding is essential for NLP tasks.

Types of Text Encoding

1. One-Hot Encoding

• Represents each word as a binary vector.
• Each vector has a single 1 at the index corresponding to the word and 0s elsewhere.
• Example:
  • Vocabulary: ["cat", "dog", "mouse"]
  • Encoding:
    • "cat" → [1, 0, 0]
    • "dog" → [0, 1, 0]
    • "mouse" → [0, 0, 1]
• Pros: Simple to implement.
• Cons: Doesn't capture semantic relationships between words (e.g., "king" and "queen" are treated as entirely unrelated).

2. Bag-of-Words (BoW)

• Represents text as a vector of word counts or frequencies.
• Example:
  • Sentence 1: "The cat sat on the mat."
  • Sentence 2: "The mat is soft."
  • Vocabulary: ["cat", "mat", "soft", "sat", "the"]
  • Encoding for Sentence 1: [1, 1, 0, 1, 2]
  • Encoding for Sentence 2: [0, 1, 1, 0, 1]
• Pros: Simple and useful for document classification.
• Cons: Ignores word order and context.

3. TF-IDF (Term Frequency-Inverse Document Frequency)

• Enhances Bag-of-Words by weighting words based on their importance.
• Formula: [ \text{TF-IDF}(word) = \text{TF}(word) \times \text{IDF}(word) ]
  • TF: Term frequency (how often a word appears in a document).
  • IDF: Inverse document frequency (reduces importance of common words across all documents, like "the").
• Pros: Balances word frequency with importance, useful in document retrieval.
• Cons: Computationally expensive for large datasets.

4. Word Embeddings

• Represents words as dense vectors in a continuous space, capturing semantic meaning.
• Popular algorithms:
  • Word2Vec: Trains word embeddings based on co-occurrence in context windows.
  • GloVe: Generates embeddings using word co-occurrence statistics.
• Example:
  • "king" → [0.2, 0.7, -0.5, ...]
  • "queen" → [0.1, 0.6, -0.4, ...]
  • Semantic relationships can be captured (e.g., "king" - "man" + "woman" ≈ "queen").
• Pros: Captures relationships and context between words.
• Cons: Requires significant computational resources for training.

5. Contextual Embeddings

• Dynamic embeddings that depend on the surrounding context of the word.
• Generated by pre-trained models like BERT, GPT, or RoBERTa.
• Example:
  • "bank" in "river bank" might have a different embedding than "bank" in "financial bank."
• Pros: State-of-the-art performance for many NLP tasks.
• Cons: Computationally expensive and large models.

6. Sentence and Document Encoding

• Converts whole sentences or documents into numerical representations.
• Techniques include averaging word embeddings, using convolutional neural networks (CNNs), recurrent neural networks (RNNs), or transformers (e.g., BERT for sentence embedding).
• Example:
  • Sentence: "The cat sat on the mat."
  • Encoding: [0.3, -0.2, 0.7, ...]

---

Summary of Encoding Methods

Encoding Type	Representation	Strengths	Limitations
One-Hot Encoding	Binary vectors	Simple to implement	Ignores semantics
Bag-of-Words	Word counts	Good for document classification	Ignores word order
TF-IDF	Weighted word counts	Balances importance	Computationally expensive
Word Embeddings	Dense word vectors	Captures semantics	Requires training/large models
Contextual Embeddings	Dynamic word vectors	Accounts for context	Computationally expensive
Sentence/Document Encoding	Vectors for whole sentences/documents	Captures higher-level context	May lose fine-grained word details

---

ASCII and Unicode

Both ASCII (American Standard Code for Information Interchange) and Unicode are standards for encoding text into numerical values that computers can process. However, they differ significantly in scope, character support, and use cases.

---

ASCII (American Standard Code for Information Interchange)

1. Definition:

   • A character encoding standard developed in the 1960s to represent text using numerical codes.
   • Originally designed for English language characters.

2. Encoding:

   • Uses 7 bits to represent each character.
   • Can encode 128 characters, including:
     • 33 control characters (e.g., newline, tab).
     • 95 printable characters (e.g., letters, digits, punctuation).

3. Examples:

   • 'A' = 65
   • 'a' = 97
   • '0' = 48

4. Limitations:

   • Limited to English letters, digits, and some symbols.
   • Cannot represent characters from other languages (e.g., Chinese, Arabic).

---

Unicode

1. Definition:

   • A universal character encoding standard developed to support text from all languages and scripts worldwide.
   • Introduced to overcome the limitations of ASCII.

2. Encoding:

   • Can represent over 143,000 characters (as of the latest version) from various writing systems, including emojis, symbols, and characters from non-Latin scripts.
   • Supports multiple encoding forms:
     • UTF-8: Variable-length encoding (1–4 bytes). Backward-compatible with ASCII.
     • UTF-16: Variable-length encoding (2–4 bytes).
     • UTF-32: Fixed-length encoding (4 bytes).

3. Examples:

   • 'A' = U+0041 (Unicode code point for 'A')
   • '😊' = U+1F60A (Unicode code point for the "smiling face with smiling eyes" emoji)
   • 'अ' (Hindi "a") = U+0905

4. Advantages:

   • Supports multiple languages and symbols.
   • Handles modern text needs like emojis and special symbols.

---

Key Differences

Feature	ASCII	Unicode
Character Set	128 characters	Over 143,000 characters
Bit Usage	7 bits	Variable (UTF-8, UTF-16, UTF-32)
Language Support	Limited to English	Global language support
Encoding Form	Fixed-length (7 bits)	Variable-length or fixed-length

---

Regular Expressions (Regex) Quantifiers

Quantifiers in regular expressions (regex) define how many times a preceding character, group, or character class must occur to produce a match. They allow you to match patterns with variable lengths, which makes regex highly flexible and powerful.

---

Common Quantifiers

Quantifier	Meaning	Example	Matches
*	Matches 0 or more occurrences	a*	"", "a", "aa", "aaa"
+	Matches 1 or more occurrences	a+	"a", "aa", "aaa"
?	Matches 0 or 1 occurrence	a?	"", "a"
{n}	Matches exactly n occurrences	a{3}	"aaa"
{n,}	Matches n or more occurrences	a{2,}	"aa", "aaa", "aaaa"
{n,m}	Matches between n and m occurrences (inclusive)	a{2,4}	"aa", "aaa", "aaaa"

---

Special Quantifier Usages

1. Greedy vs Lazy Matching

Quantifiers are greedy by default—they match as much text as possible. However, by appending a ? to a quantifier, you can make it lazy, matching as little text as possible.

• Greedy Example:
  Regex: a.*b
  Input: "aaabbb"
  Match: "aaabbb"

• Lazy Example:
  Regex: a.*?b
  Input: "aaabbb"
  Match: "aab"

2. Combining Quantifiers

You can use quantifiers with character classes, groups, or specific characters to build complex patterns.

• Example: (abc)+ matches "abc", "abcabc", "abcabcabc".

---

Examples in Context

1. Phone Number Matching: Regex: \d{3}-\d{2,4}
   Matches: "123-45", "123-4567"
   Explanation: \d{3} matches exactly three digits, followed by a hyphen (-), and \d{2,4} matches 2 to 4 digits.

2. Email Address Matching: Regex: [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
   Matches: "example@email.com"
   Explanation: Quantifiers (+, {2,}) ensure variable-length parts of the email are matched.

3. Optional Patterns: Regex: colou?r
   Matches: "color" and "colour"
   Explanation: The u? makes the "u" optional.

---

Regular Expressions (Regex) for Whitespace Handling

Whitespace characters include spaces, tabs, newlines, and other non-visible characters. Regular expressions provide specific patterns to match and manipulate whitespace in text.

---

Common Whitespace Patterns in Regex

Pattern	Description	Matches
\s	Matches any whitespace character (space, tab, newline, etc.)	" ", "\t", "\n"
\S	Matches any non-whitespace character	"a", "1", "@" (but not " ")
\t	Matches a tab character	"\t"
\n	Matches a newline character	"\n"
\r	Matches a carriage return	"\r"
\f	Matches a form feed	"\f"
\v	Matches a vertical tab	"\v"

---

Examples of Whitespace Handling

1. Match All Whitespace:

   • Regex: \s+
   • Description: Matches one or more consecutive whitespace characters.
   • Example:
     • Input: "The cat\nsat on\t the mat."
     • Match: " ", "\n", "\t"

2. Remove Extra Whitespace:

   • Regex: \s+
   • Replacement: " "
   • Description: Replaces all consecutive whitespace characters with a single space.
   • Example:
     • Input: "The cat\nsat on\t the mat."
     • Output: "The cat sat on the mat."

3. Split Text by Whitespace:

   • Regex: \s+
   • Description: Splits a string into words using whitespace as the delimiter.
   • Example:
     • Input: "The cat sat\non the mat."
     • Output: ["The", "cat", "sat", "on", "the", "mat"]

4. Match Lines with Leading/Trailing Whitespace:

   • Regex: ^\s+ (leading whitespace) or \s+$ (trailing whitespace)
   • Description: Matches lines with whitespace at the beginning or end.
   • Example:
     • Input: " Line 1\nLine 2 \n Line 3 "
     • Matches (for ^\s+): " "

5. Remove All Whitespace:

   • Regex: \s
   • Replacement: ""
   • Description: Removes all whitespace characters from the text.
   • Example:
     • Input: "The cat sat on the mat."
     • Output: "Thecatsatonthemat."

---

Summary of Key Patterns

Pattern	Use Case
\s	Match any whitespace character
\S	Match any non-whitespace character
^\s+	Match leading whitespace
\s+$	Match trailing whitespace
\s+	Match one or more consecutive whitespace

---

Regular Expressions (Regex) Anchors and Wildcards

Anchors and wildcards in regular expressions are fundamental tools to define the position of matches and handle flexible patterns.

---

Anchors

Anchors in regex are used to match positions in a string rather than specific characters. They don't consume any characters but define where a match must occur.

Anchor	Description	Example	Matches
^	Matches the start of a string.	^Hello	"Hello world", but NOT "world Hello".
$	Matches the end of a string.	world$	"Hello world", but NOT "world Hello".
\b	Matches a word boundary.	\bcat\b	"cat" in "The cat sat", but NOT "catch".
\B	Matches a non-word boundary.	\Bcat\B	"catch", but NOT "The cat sat".

Example:

• Regex: ^The.*dog$
  • Matches: A string that starts with "The" and ends with "dog".
  • Input: "The quick brown dog" → Match.
  • Input: "A dog named The" → No match.

---

Wildcards

Wildcards in regex are used to represent one or more unknown or variable characters.

Wildcard	Description	Example	Matches
.	Matches any single character except newline.	a.c	"abc", "a2c", "a_c", but NOT "ac".
.*	Matches zero or more of any character (greedy).	a.*c	"ac", "abc", "axyzc".
.+	Matches one or more of any character (greedy).	a.+c	"abc", "axyzc", but NOT "ac".
[ ]	Matches any single character in the set.	[aeiou]	Matches any vowel (e.g., "a").
[^ ]	Matches any single character NOT in the set.	[^aeiou]	Matches any non-vowel.

Example:

• Regex: H.llo
  • Matches: "Hello", "Hallo", "H3llo".
  • Does NOT match: "Hlo".

---

Combining Anchors and Wildcards

Anchors and wildcards are often combined to create more complex patterns:

• Regex: ^a.*z$
  • Description: Matches strings that start with "a" and end with "z", with any number of characters in between.
  • Input: "amazing" → Match.
  • Input: "abz" → Match.
  • Input: "a_z" → Match.
  • Input: "a world of z" → No match.

---

Summary

Type	Symbol	Function
Anchors	^	Matches the start of a string.
	$	Matches the end of a string.
	\b	Matches word boundaries.
	\B	Matches non-word boundaries.
Wildcards	.	Matches any single character.
	.*	Matches zero or more of any character.
	[ ]	Matches any character in the set.
	[^ ]	Matches any character not in the set.

Regular Expressions (Regex) Character Sets

Character sets in regular expressions allow you to define a range or collection of characters to match. They make regex patterns flexible and concise by enabling you to specify multiple characters in a single pattern.

---

Syntax for Character Sets

• Square Brackets ([ ]): Enclose the character set.
• Range (-): Defines a range of characters (e.g., a-z for all lowercase letters).
• Negation (^): Placed at the beginning of the character set to indicate characters NOT to match.
• Literal Characters: List of specific characters to match.

---

Examples of Character Sets

Character Set	Description	Matches	Does NOT Match
[abc]	Matches a, b, or c	"a", "b", "c"	"d", "x", "1"
[a-z]	Matches any lowercase letter	"a", "m", "z"	"A", "1", "#"
[A-Z]	Matches any uppercase letter	"A", "H", "Z"	"a", "1", "*"
[0-9]	Matches any digit	"0", "5", "9"	"a", "-", "@"
[a-zA-Z]	Matches any letter (case-insensitive)	"a", "A", "z", "Z"	"1", "!", "@"
[0-9a-fA-F]	Matches any hexadecimal digit	"0", "9", "A", "F"	"G", "z", "%"
[^abc]	Matches any character except a, b, or c	"d", "x", "1"	"a", "b", "c"
[^\s]	Matches any non-whitespace character	"a", "1", "@"	" ", "\t", "\n"

---

Special Notes

1. Escape Special Characters:

   • If you want to include special characters (like [ or -) in your character set, escape them with a backslash (\).
   • Example: [\[\]\-] matches [, ], or -.

2. Combining Character Classes:

   • You can combine predefined classes and ranges in the same set.
   • Example: [a-z\d] matches any lowercase letter or digit.

---

Practical Use Cases

1. Validate Alphanumeric Input:

   • Regex: ^[a-zA-Z0-9]+$
   • Matches: Strings containing only letters and digits.

2. Extract Hexadecimal Numbers:

   • Regex: \b[0-9a-fA-F]+\b
   • Matches: "1f4", "FF", "a0b".

3. Match Non-Digit Characters:

   • Regex: [^0-9]+
   • Matches: Strings that do not contain digits (e.g., "abc!", "@#$").

4. Detect Whitespace:

   • Regex: [\s]+
   • Matches: Spaces, tabs, or newlines.

5. Filter Specific Characters:

   • Regex: [aeiouAEIOU]
   • Matches: All vowels (case-insensitive).

---

Summary

Character Set	Use Case
[ ]	Matches specified characters.
[^ ]	Matches characters NOT in the set.
[a-z]	Matches lowercase letters.
[A-Z]	Matches uppercase letters.
[0-9]	Matches digits.
[a-zA-Z0-9]	Matches alphanumeric characters.

Greedy and Non-Greedy (Lazy) Approaches in Regex

In regular expressions (regex), greedy and non-greedy (also called "lazy") quantifiers control how much of the input string a pattern attempts to match. The distinction lies in how much text the quantifier consumes when finding a match.

---

1. Greedy Approach

A greedy quantifier tries to match as much text as possible while still allowing the overall pattern to succeed. It keeps consuming characters until no more matches can be made or until the pattern fails.

Common Greedy Quantifiers:

Quantifier	Meaning
*	Match 0 or more repetitions
+	Match 1 or more repetitions
?	Match 0 or 1 occurrence
{n,}	Match n or more repetitions
{n,m}	Match between n and m repetitions

Example:

• Regex: a.*b
• Input: "axyzb123b456b"
• Match: "axyzb123b456b"
  • Explanation: The .* quantifier consumes everything it can between "a" and the last "b."

---

2. Non-Greedy (Lazy) Approach

A non-greedy quantifier tries to match as little text as possible while still allowing the overall pattern to succeed. You make a quantifier non-greedy by appending a ? to it.

Non-Greedy Quantifiers:

Quantifier	Meaning
*?	Match 0 or more repetitions lazily
+?	Match 1 or more repetitions lazily
??	Match 0 or 1 occurrence lazily
{n,}?	Match n or more repetitions lazily
{n,m}?	Match between n and m repetitions lazily

Example:

• Regex: a.*?b
• Input: "axyzb123b456b"
• Match: "axyzb"
  • Explanation: The .*? quantifier matches as little as possible between "a" and the first "b."

---

Comparison

Feature	Greedy Quantifiers	Non-Greedy Quantifiers
Behavior	Match as much text as possible.	Match as little text as possible.
Efficiency	Can result in overconsumption of text.	Stops matching earlier.
Use Case	Useful when you want to capture everything up to a delimiter or pattern.	Useful when you want the shortest match.

---

Practical Scenarios

1. Extracting the First Match (Non-Greedy):

   • Regex: <.*?>
   • Input: <tag1>content<tag2>
   • Match: <tag1>
   • Explanation: Non-greedy .*? ensures the shortest match between < and >.

2. Extracting the Longest Match (Greedy):

   • Regex: <.*>
   • Input: <tag1>content<tag2>
   • Match: <tag1>content<tag2>
   • Explanation: Greedy .* consumes as much as possible.

---

Summary

• Greedy Quantifiers: Match as much text as possible.
• Non-Greedy Quantifiers: Match as little text as possible.

Common Regular Expression (RE) Functions

When working with regular expressions (regex), programming languages often provide functions that make pattern matching, searching, and manipulation of text easier. Here's a list of common regex functions, using Python's re module as an example:

---

1. re.match()

• Description: Checks if the regex matches at the start of the string.
• Example:

  import re
  result = re.match(r'Hello', 'Hello World')
  print(result.group())  # Output: 'Hello'
  

• Key Note: Returns None if the match is not at the beginning of the string.

---

2. re.search()

• Description: Searches the entire string for the first occurrence of a match.
• Example:

  result = re.search(r'World', 'Hello World')
  print(result.group())  # Output: 'World'
  

• Key Note: Finds a match anywhere in the string.

---

3. re.findall()

• Description: Returns all matches of the regex pattern as a list.
• Example:

  result = re.findall(r'\d+', 'There are 12 cats and 34 dogs')
  print(result)  # Output: ['12', '34']
  

• Key Note: Useful for extracting multiple matches.

---

4. re.finditer()

• Description: Returns an iterator yielding match objects for all matches of the regex pattern.
• Example:

  for match in re.finditer(r'\d+', 'There are 12 cats and 34 dogs'):
      print(match.group())
  # Output:
  # 12
  # 34
  

---

5. re.split()

• Description: Splits a string at each match of the pattern and returns a list.
• Example:

  result = re.split(r'\s+', 'Hello   World!')
  print(result)  # Output: ['Hello', 'World!']
  

• Key Note: Can split on whitespace, digits, or any pattern.

---

6. re.sub()

• Description: Substitutes all occurrences of the regex pattern with a replacement string.
• Example:

  result = re.sub(r'\d+', 'X', 'I have 12 cats and 34 dogs')
  print(result)  # Output: 'I have X cats and X dogs'
  

---

7. re.subn()

• Description: Same as re.sub(), but also returns the number of substitutions made.
• Example:

  result = re.subn(r'\d+', 'X', 'I have 12 cats and 34 dogs')
  print(result)  # Output: ('I have X cats and X dogs', 2)
  

---

8. re.fullmatch()

• Description: Checks if the entire string matches the regex pattern.
• Example:

  result = re.fullmatch(r'Hello World', 'Hello World')
  print(result.group())  # Output: 'Hello World'
  

• Key Note: Returns None if there's any mismatch.

---

9. re.compile()

• Description: Compiles a regex pattern into a reusable regex object for efficiency.
• Example:

  pattern = re.compile(r'\d+')
  result = pattern.findall('There are 12 cats and 34 dogs')
  print(result)  # Output: ['12', '34']
  

---

Summary Table

Function	Description	Example Use Case
re.match()	Matches pattern at the start of a string	Check if a string begins with "Hello".
re.search()	Finds the first match anywhere in the string	Look for a keyword in a sentence.
re.findall()	Returns all matches in a list	Extract all numbers from a text.
re.finditer()	Returns an iterator over match objects	Extract matches with additional details.
re.split()	Splits a string based on the regex pattern	Split a string by whitespace or special symbols.
re.sub()	Replaces matches with a replacement string	Replace all digits in text with "X".
re.subn()	Same as re.sub(), but also returns substitution count	Find and count replacements.
re.fullmatch()	Matches the entire string to a pattern	Validate full strings (e.g., email validation).
re.compile()	Compiles a regex pattern for reuse	Speed up repeated pattern matching.

---

Regular Expressions (Regex) Grouping

Grouping in regular expressions is a powerful technique used to group together parts of a pattern. By enclosing portions of a regex in parentheses (()), you can treat them as a single unit, extract submatches, or apply quantifiers to them.

---

Key Features of Grouping

1. Capturing Groups:

   • Parentheses create a capturing group.
   • The content matched within the group can be extracted or reused.

   Example:

   import re
   match = re.search(r"(dog|cat)", "I have a dog")
   print(match.group(1))  # Output: "dog"
   

2. Non-Capturing Groups:

   • Use (?: ) to create a group without capturing its match.
   • Useful for grouping without saving the match in memory.

   Example:

   re.search(r"(?:dog|cat)", "I have a cat").group()  # Output: "cat"
   

3. Nested Groups:

   • Groups can be nested, and each level is assigned a unique number.

   Example:

   match = re.search(r"((a)b)", "ab")
   print(match.group(1))  # Output: "ab" (outer group)
   print(match.group(2))  # Output: "b" (inner group)
   

4. Backreferences:

   • Reuse the content of a capturing group later in the pattern with \n (where n is the group number).

   Example:

   re.search(r"(dog)\1", "dogdog").group()  # Output: "dogdog"
   

---

Practical Uses of Grouping

1. Extract Submatches:

   • Example: Extracting the domain name from an email address.

   match = re.search(r"(\w+)@(\w+)\.com", "email@domain.com")
   print(match.group(1))  # Output: "email"
   print(match.group(2))  # Output: "domain"
   

2. Apply Quantifiers to Groups:

   • Example: Repeating a group multiple times.

   re.search(r"(ha)+", "hahaha").group()  # Output: "hahaha"
   

3. Conditional Matching:

   • Combine groups with logical OR (|) to match alternative patterns.

   re.search(r"(dog|cat|bird)", "I have a cat").group()  # Output: "cat"
   

---

Summary Table

Feature	Syntax	Use Case
Capturing Group	(pattern)	Extract or reuse matched content.
Non-Capturing Group	(?:pattern)	Group without capturing.
Nested Group	((a)b)	Captures nested parts of the pattern.
Backreference	\1, \2, ...	Reuse previous captured groups in the pattern.
Quantifiers on Groups	(abc)+	Match repetitions of a group.

Date Validation Examples Using Grouping

1. Match Dates in DD-MM-YYYY Format:
   • Regex: (\d{2})-(\d{2})-(\d{4})
   • Explanation:
     • (\d{2}): Matches the day (2 digits).
     • (\d{2}): Matches the month (2 digits).
     • (\d{4}): Matches the year (4 digits).
   • Example Code:

     import re
     date = "24-03-2025"
     match = re.match(r"(\d{2})-(\d{2})-(\d{4})", date)
     if match:
         print("Day:", match.group(1))     # Output: 24
         print("Month:", match.group(2))   # Output: 03
         print("Year:", match.group(3))    # Output: 2025
     

---

2. Extract Dates in MM/DD/YYYY Format:
   • Regex: (\d{2})/(\d{2})/(\d{4})
   • Explanation:
     • (\d{2}): Matches the month.
     • (\d{2}): Matches the day.
     • (\d{4}): Matches the year.
   • Example Code:

     date_string = "03/24/2025"
     match = re.search(r"(\d{2})/(\d{2})/(\d{4})", date_string)
     if match:
         print("Month:", match.group(1))  # Output: 03
         print("Day:", match.group(2))    # Output: 24
         print("Year:", match.group(3))   # Output: 2025
     

---

3. Match Multiple Dates in Text:
   • Regex: (\d{2})-(\d{2})-(\d{4})
   • Example Code:

     text = "Important dates are 24-03-2025 and 15-08-2021."
     matches = re.findall(r"(\d{2})-(\d{2})-(\d{4})", text)
     print(matches)  # Output: [('24', '03', '2025'), ('15', '08', '2021')]
     

---

4. Validate Leap Year Dates:
   • Regex: ^(?:29)-(02)-(\d{4})$
   • Explanation:
     • 29: Matches the 29th day.
     • 02: Matches the month of February.
     • (\d{4}): Captures the year.
     • (?: ): Non-capturing group for precise matching.
   • Example Code:

     leap_date = "29-02-2024"
     match = re.match(r"^(?:29)-(02)-(\d{4})$", leap_date)
     if match:
         print("Valid Leap Year Date!")
     else:
         print("Invalid Leap Year Date!"

Key Summary for Grouping with Dates

Date Format	Regex	Use Case
DD-MM-YYYY	(\d{2})-(\d{2})-(\d{4})	Extract day, month, and year.
MM/DD/YYYY	(\d{2})/(\d{2})/(\d{4})	Extract month, day, and year.
Flexible Separators	(\d{2})[-/](\d{2})[-/](\d{4})	Handle multiple date formats with separators.
Leap Year Dates	^(?:29)-(02)-(\d{4})$	Validate February 29th for leap years.