Python RegEx Cheat Sheet

Regular Expressions (RegEx)

• A comprehensive guide to Regular Expressions (RegEx) in Python, covering various aspects and functions of the re module.

Character Classes and Sets

• A character class matches any one character from a set of characters.
• Common character classes:
  • \d: Matches any digit, equivalent to [0-9].
  • \D: Matches any non-digit, equivalent to [^0-9].
  • \w: Matches any word character (letters, digits, or underscore), equivalent to [a-zA-Z0-9_].
  • \W: Matches any non-word character, equivalent to [^a-zA-Z0-9_].
  • \s: Matches any whitespace character (space, tab, newline, etc.), equivalent to [ \t\n\r\f\v].
  • \S: Matches any non-whitespace character, equivalent to [^\s].
• Custom character sets: Use square brackets [] to create a custom character set.
  • [abc]: Matches any one of a, b, or c.
  • [^abc]: Matches any character that is not a, b, or c.
  • [a-z]: Matches any lowercase letter.
  • [A-Z]: Matches any uppercase letter.
  • [0-9]: Matches any digit.

Greedy vs. Non-Greedy Matching

• Greedy matching: By default, quantifiers in RegEx match as much text as possible.
  • *: Matches as many characters as possible.
• Non-greedy (lazy) matching: Appending a ? to a quantifier makes it non-greedy, matching as little text as possible.
  • *?: Matches as few characters as possible.

Common Issues and Solutions

• Handling None results: Check if a match object is None before calling methods like group() to avoid AttributeError.
• Example: Use an if statement to check if the match object is None before proceeding.

Flags

• Modify the behavior of the RegEx engine:
  • re.I (or re.IGNORECASE): Makes the pattern case-insensitive.
  • re.M (or re.MULTILINE): ^ and $ match the start and end of each line, not just the start and end of the string.
  • re.S (or re.DOTALL): The dot . matches any character, including newline characters.

Quantifiers

• Used to specify how many times a character, character class, or a group of characters can occur in a match.
• Basic quantifiers:
  • * (Asterisk): Matches 0 or more occurrences of the preceding element.
  • + (Plus): Matches 1 or more occurrences of the preceding element.
  • ? (Question Mark): Matches 0 or 1 occurrence of the preceding element (making it optional).
  • {n} (Specific Number): Matches exactly n occurrences of the preceding element.
  • {n,} (Minimum Number): Matches n or more occurrences of the preceding element.
  • {n,m} (Range): Matches between n and m occurrences of the preceding element.

Greedy vs. Lazy Quantifiers

• Greedy quantifiers:
  • *, +, ?, {n,}, {n,m}: Match as much text as possible.
• Lazy (non-greedy) quantifiers:
  • *?, +?, ??, {n,}?, {n,m}?: Match as little text as possible.

Practical Applications

• Data validation: Checking if a string contains a valid date or phone number.
• Data extraction: Extracting all occurrences of a pattern in a text.
• Data cleaning: Removing unwanted characters from a string.### Greedy and Lazy Quantifiers
• Greedy quantifiers are more common and used for parsing logs, extracting data, etc. where maximum matches are desired
• Specific Number and Range quantifiers are useful for data validation (phone numbers, IDs, etc.) where the length of the input is fixed or has specific limits
• Minimum Number quantifier ensures a minimum amount of something, like a password with at least 8 characters

The Question Mark (?) in RegEx

• The ? has two different roles in RegEx:
  • As an Optional Quantifier: makes the preceding element optional, matching 0 or 1 occurrence
  • As a Lazy Modifier: turns a quantifier into a lazy (non-greedy) version, matching as little as possible

Examples of Optional Quantifier and Lazy Modifier

• colou?r matches both "color" and "colour" (optional quantifier)
• a+? matches as few consecutive 'a's as possible (lazy modifier)
• Python code examples demonstrate the difference between optional quantifier and lazy modifier

Realistic Examples of ?

• In a document, the word "organize" can appear in both American English ("organize") and British English ("organise")
• Using organiz(s|e)? pattern matches both "organize" and "organise"
• The ? makes the 's' optional, accommodating both spellings

Lazy Quantifiers in Action

• Extracting the first sentence from a paragraph: .*?\. (lazy pattern) matches the shortest string ending in a period
• Extracting the first word from each line: ^.*? (lazy pattern) matches the start of a line and captures the shortest string up to the first space
• Lazy quantifiers are essential in scenarios where precise, minimal matches are needed within larger strings

Understanding Lazy Quantifiers

• Lazy quantifiers tell the RegEx engine to match the smallest possible string up to the point where the subsequent part of the pattern is satisfied
• In a lazy match, the engine consumes as little of the string as possible while still allowing the remainder of the RegEx to match