parse-extract-input

name	parse-extract-input
description	For text processing: extract numbers, words, structured data from messy text using regex patterns, parsing utilities.

parse-extract-input

When to Use

• Extracting numbers from text
• Finding words or identifiers
• Parsing structured input files
• Data cleaning
• Advent of Code input parsing

When NOT to Use

• Structured format (use JSON/CSV parsers)
• Complex grammar (use proper parser)
• Simple split is enough

The Pattern

Use regex or helper functions to extract structured data from text.

import re

def ints(text):
    """Extract all integers from text."""
    return tuple(map(int, re.findall(r'-?[0-9]+', text)))

def words(text):
    """Extract all words from text."""
    return tuple(re.findall(r'[a-zA-Z]+', text))

def atoms(text):
    """Extract all atoms (numbers or identifiers)."""
    return tuple(atom(s) for s in re.findall(r'[+-]?\d+\.?\d*|\w+', text))

def atom(s):
    """Parse string as number or keep as string."""
    try:
        return int(s)
    except ValueError:
        try:
            return float(s)
        except ValueError:
            return s

Example (from pytudes AdventUtils.ipynb)

import re

def ints(text: str) -> Tuple[int, ...]:
    """A tuple of all the integers in text."""
    return tuple(map(int, re.findall(r'-?[0-9]+', text)))

def positive_ints(text: str) -> Tuple[int, ...]:
    """A tuple of all positive integers in text."""
    return tuple(map(int, re.findall(r'[0-9]+', text)))

def digits(text: str) -> Tuple[int, ...]:
    """A tuple of all single digits in text."""
    return tuple(map(int, re.findall(r'[0-9]', text)))

def words(text: str) -> Tuple[str, ...]:
    """A tuple of all alphabetic words in text."""
    return tuple(re.findall(r'[a-zA-Z]+', text))

def atoms(text: str) -> Tuple:
    
     ((atom, re.findall(, text)))

 ():
    
    :
        x = (text)
         (x)  x.is_integer()  x
     ValueError:
         text.strip()


ints()  
words()  
atoms()  

Key Principles

1. Regex for patterns: r'-?[0-9]+' for signed integers
2. Return tuples: Immutable, hashable results
3. Cascading conversion: Try int, then float, then string
4. Negative-aware: Include -? for negative numbers
5. Reusable utilities: Same functions for any input