Python RegEx: String Matching

• Regular Expressions (RegEx) constitute a sequence of characters shaping a complex string-matching pattern
• The re module is used in Python for regular expressions

Key Resources

• https://docs.python.org/3/library/re.html#re.IGNORECASE
• https://realpython.com/regex-python/
• https://www.programiz.com/python-programming/regex
• https://www.w3schools.com/python/python_regex.asp

Matching a Substring

• When you have a string object referred to as s, you can ascertain if s contains a specific substring, such as '123', using Python code
• One method is available to determine if a string object contains a specified substring
• The .find() or .index() methods locate the position of a substring like '123'
• These find() or index() methods are integrated into the string module of Python

Python's Regular Expressions

• Simple character-by-character comparisons are effective in many situations, but, might not always be sufficient for complex string matching
• Regular expressions can identify a sequence of three consecutive decimal digits within strings like 'foo123bar', 'foo456bar', '234baz', and 'qux678'
• Python's regular expressions (regexes) solve complex matching issues

The ‘re’ Module

• A built-in package in Python called re is used when working with Regular Expressions
• One must import the re module to search a string for matches with regular expressions using import re

Key Functions

• findall gets a list containing all matches
• search gets a Match object if there is a match anywhere in the string
• split gets a list where the string has been split at each match
• sub replaces one or many matches with a string

The re.search() Function

• The focus will be on the re.search() function for regex matching
• re.search(<regex>, <string>) scans a string for a regex match
• re.search(<regex>, <string>) scans the string to find the first location where the pattern matches
• re.search() gets a match object if a match is found; otherwise, None is returned

Examining the Returned Match Object

• The search pattern is 123 and is s, and the returned match object will be shown
• A successful call returned a match object rather than None
• span=(3, 6) show the indices where the match was found found in the string
• s[3:6] # '123' means the same as if the substring was obtained through slice notation, i.e. s[3:6]
• match='123' indicates the characters from the string that matched

Truthiness of Match Objects

• A match object is "truthy", enabling its use in a Boolean context such as a conditional statement
• A value such as False is considered Falsy
• A value such as True is considered Truthy

Truthy and Falsy Values according to Python Documentation

• A default object is True
• Non-empty sequences and/or collections (lists, tuples, strings, dictionaries, sets) are True
• Numeric values that are not 0 are True

Falsy

• Empty lists, such as []
• Empty tuples, such as ()
• Empty dictionaries, such as {}
• Empty sets, such as set()
• Empty strings, such as ""
• Empty ranges, such as range(0)
• Zero is False for any non-complex numeric type
• Numerical Types:
  • Integer: 0
  • Float: 0.0
• Constants: None and False

Metacharacters

• The true strength of regex matching in Python uses special characters known as metacharacters in it's pattern
• Interpratation of metacharacters by the RegEx matching engine expands search capabilities
• A character class can determine whether a string contains any sequence of three consecutive decimal digits
• A character class is defined as a set of characters enclosed in square brackets ([])
• The metacharacter sequence matches any single character that belongs to the class

Commonly Used Metacharacters

• [0-9] matches any single decimal digit character, any character between '0' and '9'
• The expression [0-9][0-9][0-9] matches a string containing any sequence of three decimal digit characters
• s matches because it contains three consecutive decimal digit characters, '123'
• Examples of matching other numbers in strings include '465' in "foo465"
• A string that does not contain three consecutive digits will not match

Obtaining String Details with Metacharacters

• When you want details of the output, you can use the following
• .start() shows the index where the match occurred
• .end() shows the index (not included) where the match finished
• .span() returns a tuple including the starting and ending (not included) indexes
• .group() the match case

Metacharacters Listed

Enumerating Characters

• Characters contained in square brackets ([]) represent a character class
• This is an enumerated set of characters to match from
• A character class metacharacter sequence will match any single character that is contained in the class
• Individual matching characters can be enumerated individually

Representing Ranges

• A regex pattern can include a range of characters separated by a hyphen (-)
• This setup matches any single character that falls within that specified range
• For instance, the character class [a-z] matches any lowercase letter from 'a' to 'z', inclusive
• [0-9] matches any digit character and [0-9a-fA-F] matches any hexadecimal digit character
• The returned match is always the leftmost one found. the function re.search() scans the search string from left to right and stops as soon as it finds a match for the regex pattern, it then halts scanning

Complementation

• You can complement a character class by specifying ^ as the first character to match any character that is not in the set
• [^0-9] matches any character that isn’t a digit
• If a ^ character appears in a character class somewhere other than first, then the ^ has no special meaning and matches a literal '^'

Other Usage Cases for Metacharacters

• Use as first or last character or escape with a backslash (\)

Hyphen Usage

• Hyphens can be used in three ways
  • You can place it as the first or last character
  • Escape it with a backslash \ to use, instead of specifying a range of characters in a character class

Square Brackets

• Square brackets can be used in two ways
  • Place it as the first character
  • Escape it with \ backslash

Other Regex Metacharacters

• They lose special meaning inside a character class

Dot metacharacter

• Matches one single character, excluding newline
• As a RegEx, foo.bar equals the characters "foo," any character except newline, then characters "bar"
  • The first string shown above, fooxbar means .metacharacter matches character x
• Match fails when newline is encountered

Special Sequences in RegEx

• A special sequence is a backslash (\) that follows one of the characters in the list on the next slide
• They each have special meanings

List of Special Character Sequences

Commonly Used Special Sequences

\w and \W

\d and \D

\s and \S

Anchors and Bolds

• Anchors in Regex are unique and specialized, they always match zero-width positions. | ^ and \A | Dollar "$" and \Z*| | :--------------------- | :---------------------------------------- | | The Beginning| end| | Word (\b ) | not a word boundary (\B)|
• Anchors do not consume any part of the search string
• Anchors Specifies a specific location in a search for a Match

Boundaries with Raw Strings

• \b (and`\B`*) demands the use of raw strings in Python
• Strings will begin with a suffix letter as r or R that will be used to ignore the special character

\b Special Sequence

• Anchors a match to a word boundary
• Position current position is used at the beginning or end of a word
• Common Alphanumeric Characters or underscore "_" in Regex as ([A-Za-z,0-9__])

What happens then?

• You use \b on the end in situations you're present
• It is present in the string so it's present for the whole word

Important side note

Raw literal text that exists at the end and start as a \b boundary.

\B - Opposite\b in Regex

• Not the start or finish
• The word "barfoobaz" exists and contains no word in *The Search**

"Escaping Metacharacters"

• Backslash \
• Removes the special meaning of a Metacharacter

"First Example-back slash"

• The dot here represents a wildcard
• The dot . matches every character

"Second Example- Backarrow"

• Represent this to a new line string by defining the Literal Text
• Escape with \ backslash

To Escape a Backslash

• you need to use raw strings

\Quantifiers

• A* quantifier* Metaclass follows a segment and how many characters you need to define for the match to be considered

• To the power * as 0 or greater

• Additions use + to the power of and greater

• If it's something you don't want to add you use ?

• The quantifier meta characters represent both the lazy or greedy versions ### The "Regex"

• Effectively defines what ends the character at the ending

• And what follows the *<> character

Summary of the Lazy or Greedy Versin

Additional Quantifiers

• {\m} - Exact charaters or repetitions/Quantifiers that the preceding Regex refers to
• {\m, \n} Number of any that is preceding

The Regex Version

• Greedy Version = 3, 5 produces, the longest match

• a{3, 5} produces "aaaaaaaa."

• Then in *Regex" The shortest match"

• A(3,5) produces A

Terms

"Grouping Constructs"

• Regex in parts

"Sub expression"

• Group represts the sinlge unit

"Additional Meta Characters"

• Applies each group like Unit

Regex Terms and Applications

"Groups and Syntax

• What follows? "One or more" of string 'bar'