### Python
RegEx: An Overview
**RegEx
(Regular Expressions)** is a powerful tool in Python for matching patterns
within strings. Python's **`re`** module provides support for using regular
expressions, allowing you to search, match, and manipulate strings based on
specific patterns.
### Common
Uses of Python's `re` Module
1.
**Searching for patterns in strings**.
2.
**Replacing parts of strings** based on patterns.
3.
**Extracting substrings** that match a pattern.
4.
**Splitting strings** based on patterns.
### Basic
Syntax of Regular Expressions
Here are
some common regex symbols used for pattern matching:
- **`.`**:
Matches any single character except newline.
- **`^`**:
Anchors the pattern to the start of the string.
- **`$`**:
Anchors the pattern to the end of the string.
- **`[]`**:
Matches any one character inside the brackets.
- **`|`**:
Acts like OR between patterns (e.g., `a|b` matches either `a` or `b`).
- **`*`**:
Matches 0 or more repetitions of the preceding element.
- **`+`**:
Matches 1 or more repetitions of the preceding element.
- **`?`**:
Matches 0 or 1 repetition of the preceding element.
-
**`{m,n}`**: Matches between `m` and `n` repetitions of the preceding element.
- **`\d`**:
Matches any digit (equivalent to `[0-9]`).
- **`\w`**:
Matches any alphanumeric character (equivalent to `[a-zA-Z0-9_]`).
- **`\s`**:
Matches any whitespace character (spaces, tabs, etc.).
### How to
Use the `re` Module
Here are
some common functions provided by the `re` module:
1.
**`re.search()`**: Searches for the first occurrence of the pattern in a
string.
2.
**`re.match()`**: Checks if the pattern matches the beginning of the string.
3.
**`re.findall()`**: Returns all matches of the pattern in the string.
4. **`re.sub()`**:
Substitutes matches of the pattern with a replacement string.
5.
**`re.split()`**: Splits a string based on a pattern.
### Examples
of Using Python RegEx
#### Example
1: Simple Pattern Search with `re.search()`
```python
import re
text =
"The rain in Spain"
pattern =
"rain"
# Search for
the pattern "rain"
match =
re.search(pattern, text)
if match:
print("Pattern found!")
else:
print("Pattern not found.")
```
#### Example
2: Finding All Matches with `re.findall()`
```python
import re
text =
"The rain in Spain falls mainly in the plain."
pattern =
r"\bin\b" # Matches the word
"in"
# Find all
occurrences of the word "in"
matches =
re.findall(pattern, text)
print(matches) # Output: ['in', 'in']
```
#### Example
3: Pattern Matching with `re.match()`
```python
import re
text =
"Python is great!"
pattern =
"Python"
# Match
pattern at the beginning of the string
if
re.match(pattern, text):
print("Match found!")
else:
print("No match.")
```
#### Example
4: Substituting Strings with `re.sub()`
```python
import re
text =
"I love Python programming!"
pattern =
"Python"
# Replace
"Python" with "Java"
result =
re.sub(pattern, "Java", text)
print(result) # Output: "I love Java
programming!"
```
#### Example
5: Splitting Strings with `re.split()`
```python
import re
text =
"apple, banana, cherry, date"
pattern =
",\s*" # Matches a comma
followed by optional spaces
# Split the
string by commas
fruits =
re.split(pattern, text)
print(fruits) # Output: ['apple', 'banana', 'cherry',
'date']
```
### Special
Features of the `re` Module
#### 1.
**Using Raw Strings (r'')**
In Python,
you should use raw strings (`r'...'`) when writing regular expressions to avoid
escaping backslashes. For example:
```python
pattern =
r"\d{3}" # Matches any
sequence of exactly 3 digits
```
#### 2.
**Using Groups in Regular Expressions**
You can use
parentheses `()` to capture parts of the pattern in groups. These groups can
then be extracted or referred to later.
```python
import re
text =
"My phone number is 123-456-7890"
pattern =
r"(\d{3})-(\d{3})-(\d{4})"
# Search and
capture groups
match =
re.search(pattern, text)
if match:
print(match.group(1)) # Output: 123
print(match.group(2)) # Output: 456
print(match.group(3)) # Output: 7890
```
#### 3.
**Flags for Pattern Matching**
The `re`
module provides flags for modifying the behavior of regular expressions:
-
**`re.IGNORECASE` or `re.I`**: Makes the pattern matching case-insensitive.
-
**`re.MULTILINE` or `re.M`**: Allows `^` and `$` to match the start and end of
each line in a string.
-
**`re.DOTALL` or `re.S`**: Allows the `.` symbol to match newline characters.
Example
using flags:
```python
import re
text =
"Hello, Python!"
pattern =
r"python"
#
Case-insensitive search
match =
re.search(pattern, text, re.IGNORECASE)
if match:
print("Pattern found!")
else:
print("Pattern not found.")
```
### How to
Install the `re` Module
The `re`
module is built into Python, so no installation is necessary. You can start
using it by importing it at the start of your script:
```python
import re
