# re.search(pattern, string) - Returns a Match object for the first match or None
import re

text = "Python is amazing and python is easy to learn."
pattern = r'python'  # Case-sensitive search for 'python'

# Search for the pattern
match = re.search(pattern, text)

if match:
    print(f"Found '{match.group()}' at position {match.start()}-{match.end()}")
else:
    print("Pattern not found")

# Case-insensitive search with flags
match = re.search(pattern, text, re.IGNORECASE)
if match:
    print(f"Found '{match.group()}' at position {match.start()}-{match.end()}")
            

# re.match(pattern, string) - Matches only at the start of the string
text1 = "Python is a great language"
text2 = "I love Python programming"

# Try to match 'Python' at the beginning
match1 = re.match(r'Python', text1)
match2 = re.match(r'Python', text2)

print(f"Text 1 starts with 'Python': {match1 is not None}")
print(f"Text 2 starts with 'Python': {match2 is not None}")
            

# re.findall(pattern, string) - Returns a list of all matching strings
text = "The rain in Spain falls mainly in the plain."
pattern = r'\b\w*ain\b'  # Words ending with 'ain'

matches = re.findall(pattern, text)
print(f"Words ending with 'ain': {matches}")

# Finding all email addresses in text
text = """
Contact us at support@example.com or sales@example.com.
For billing inquiries, email billing@example.com.
"""

email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
emails = re.findall(email_pattern, text)
print(f"Found email addresses: {emails}")
            

# re.finditer(pattern, string) - Returns an iterator over Match objects
text = "Python was created in 1991 by Guido van Rossum."
pattern = r'\d+'  # Match sequences of digits

# Find all numbers
for match in re.finditer(pattern, text):
    print(f"Found number '{match.group()}' at position {match.start()}-{match.end()}")
            

Real-World Example: Advanced Data Extraction from Structured Text

Here's an example of using advanced regex techniques to extract data from a complex structured text format:

import re

class DataExtractor:
    """
    A class for extracting structured data from complex text formats
    using advanced regular expression techniques.
    """
    
    def __init__(self):
        """Initialize with compiled regex patterns."""
        # Pattern for extracting key-value pairs with nested structures
        # This handles nested parentheses in values
        self.kvp_pattern = re.compile(
            r'(\w+)=\s*' +           # Key followed by equals sign
            r'(?:' +                  # Start of value alternatives
            r'"((?:[^"\\]|\\.)*)"' +  # Quoted value with escape handling
            r'|' +                    # OR
            r'\'((?:[^\'\\]|\\.)*)\'' + # Single-quoted value
            r'|' +                    # OR
            r'\(((?:[^()]|\([^()]*\))*)\)' + # Parenthesized value (with one level of nesting)
            r'|' +                    # OR
            r'([^,;()]+)' +           # Unquoted, non-special value
            r')'                      # End of value alternatives
        )
        
        # Pattern for nested lists [item1, item2, [subitem1, subitem2], item3]
        self.list_pattern = re.compile(
            r'\[' +                  # Opening bracket
            r'((?:' +                # Start of list content
            r'[^\[\]]*' +            # Non-bracket content
            r'|' +                   # OR
            r'\[(?:[^\[\]]*)\]' +    # Nested list with non-bracket content
            r')*)' +                 # End of list content
            r'\]'                    # Closing bracket
        )
        
        # Pattern for list items (accounting for nesting)
        self.list_item_pattern = re.compile(
            r'(?:' +                 # Start of item alternatives
            r'"((?:[^"\\]|\\.)*)"' + # Quoted item
            r'|' +                   # OR
            r'\'((?:[^\'\\]|\\.)*)\'' + # Single-quoted item
            r'|' +                   # OR
            r'\[((?:[^\[\]]|\[(?:[^\[\]]*)\])*)\]' + # Nested list
            r'|' +                   # OR
            r'([^,\[\]]+)' +         # Unquoted, non-special item
            r')'                     # End of item alternatives
        )
    
    def extract_key_value_pairs(self, text):
        """
        Extract key-value pairs from structured text.
        
        Args:
            text: Text containing key-value pairs
            
        Returns:
            Dictionary of key-value pairs
        """
        result = {}
        
        # Find all key-value pairs
        for match in self.kvp_pattern.finditer(text):
            key = match.group(1)
            
            # Determine which value alternative matched
            if match.group(2) is not None:
                # Double-quoted value
                value = match.group(2)
            elif match.group(3) is not None:
                # Single-quoted value
                value = match.group(3)
            elif match.group(4) is not None:
                # Parenthesized value
                value = match.group(4)
            else:
                # Unquoted value
                value = match.group(5).strip()
            
            # Handle nested lists in values
            if value.startswith('[') and value.endswith(']'):
                value = self.parse_list(value)
            
            result[key] = value
        
        return result
    
    def parse_list(self, list_text):
        """
        Parse a text representation of a list.
        
        Args:
            list_text: Text of list with square brackets
            
        Returns:
            List of parsed items
        """
        # Remove outer brackets
        if list_text.startswith('[') and list_text.endswith(']'):
            list_text = list_text[1:-1].strip()
        
        items = []
        
        # Split on commas that aren't inside quotes, brackets, or parentheses
        depth = 0
        quote_char = None
        current_item = ""
        
        for char in list_text:
            if quote_char:
                # Inside quotes
                if char == quote_char and not (current_item and current_item[-1] == '\\'):
                    quote_char = None
                current_item += char
            elif char == '"' or char == "'":
                # Start of quote
                quote_char = char
                current_item += char
            elif char == '[' or char == '(':
                # Opening bracket or parenthesis
                depth += 1
                current_item += char
            elif char == ']' or char == ')':
                # Closing bracket or parenthesis
                depth -= 1
                current_item += char
            elif char == ',' and depth == 0:
                # Comma at top level
                items.append(current_item.strip())
                current_item = ""
            else:
                current_item += char
        
        # Add the last item
        if current_item.strip():
            items.append(current_item.strip())
        
        # Process each item
        processed_items = []
        for item in items:
            # Check for nested lists
            if item.startswith('[') and item.endswith(']'):
                processed_items.append(self.parse_list(item))
            # Check for quoted items
            elif (item.startswith('"') and item.endswith('"')) or (item.startswith("'") and item.endswith("'")):
                processed_items.append(item[1:-1])
            else:
                processed_items.append(item)
        
        return processed_items
    
    def extract_structured_data(self, text):
        """
        Extract structured data from text containing multiple formats.
        
        Args:
            text: Text to parse
            
        Returns:
            Dictionary of extracted data
        """
        data = {}
        
        # Extract key-value pairs
        kvp_data = self.extract_key_value_pairs(text)
        data.update(kvp_data)
        
        # Extract lists
        list_matches = self.list_pattern.findall(text)
        if list_matches:
            data['lists'] = [self.parse_list(f"[{match}]") for match in list_matches]
        
        return data

# Example usage
extractor = DataExtractor()

# Example of complex structured text
data_text = """
user_info=(name="John Smith", age=30, interests=["programming", "music", "hiking"])
settings=(theme="dark", font_size=12, notification=true)
permissions=["read", "write", ["create", "delete"], "execute"]
raw_data="This is some \"raw\" data with escaped quotes"
complex_value=(nested=(level=2, type="advanced"), format="special")
"""

# Extract data
extracted_data = extractor.extract_structured_data(data_text)

# Print the results
print("Extracted data:")
import json
print(json.dumps(extracted_data, indent=2))

# Access specific values
if 'user_info' in extracted_data:
    user_info = extracted_data['user_info']
    print(f"\nUser info: {user_info}")
    
    # Parsing nested structures manually if needed
    if 'interests=' in user_info:
        # Further extraction might be needed
        interests_match = re.search(r'interests=\[(.*?)\]', user_info)
        if interests_match:
            interests_text = interests_match.group(1)
            interests = [i.strip('"') for i in interests_text.split(',')]
            print(f"User interests: {interests}")
                

This example demonstrates advanced regular expression techniques for parsing complex structured text with nested elements, quoted strings, lists, and more. It uses techniques like capturing groups, non-capturing groups, lookaheads, and complex alternation patterns to extract structured information from text that might be difficult to parse with simple regex patterns.