How do replacement groups preserve parts of matched text?

Use capturing groups: parentheses in the pattern mark the text you want to reuse. For the example Maria Cruz, the pattern r'(\w+) (\w+)' has two groups. Group 1 captures Maria, and group 2 captures Cruz.

In Python’s re.sub, write references to those groups in the replacement string. To put the second captured part first, followed by a comma and the first part, use r'\g<2>, \g<1>'. Python documents this form for inserting captured text into a replacement; using \g<2> also avoids ambiguity if a digit follows a group reference. [S1]

Here is the complete example:

import re

text = "Maria Cruz"
result = re.sub(r'(\w+) (\w+)', r'\g<2>, \g<1>', text)
print(result)

Output:

Cruz, Maria

The r prefixes make these raw Python strings, so the backslashes in the pattern and replacement are easier to read as regex syntax. [S1]

JavaScript uses a different replacement-string convention. With a regular expression passed to String.prototype.replace, numbered groups are inserted with $1, $2, and so on—not Python’s backslash forms. [S2]

The equivalent JavaScript example is:

const text = "Maria Cruz";
const result = text.replace(/(\w+)\s(\w+)/, "$2, $1");
console.log(result);

Output:

Cruz, Maria

The parentheses still capture the first and second pieces; only the replacement references change. Here $2 inserts the second capture and $1 inserts the first. The JavaScript example uses \s between the groups to match whitespace. [S2]

When moving a regex substitution between these languages, check both the pattern and the replacement syntax rather than copying the replacement string unchanged.

Number capturing groups by the order of their opening parentheses: the first capturing pair is group 1, the next is group 2. Write down what each group is meant to hold before arranging the replacement.

For this pattern, the mapping is:

1. \w+ before the space: first part (Maria)
2. \w+ after the space: second part (Cruz)

The replacement lists the desired output order. \g<2>, \g<1> in Python, or $2, $1 in JavaScript, means “second part, comma, first part.” Try it on a representative input and inspect the output before applying it to more text.

This example is limited to two word-like parts separated by whitespace. It does not establish that this pattern fits every naming format, punctuation style, or input. Adjust it for the text you need to process.

Keep the pattern’s captures in the order the fields appear, then refer to them in reverse order in the replacement. For two fields separated by a space, the pattern and replacement pair is:

Python:

r'(\w+) (\w+)'       # pattern
r'\g<2>, \g<1>'     # replacement

JavaScript:

/(\w+)\s(\w+)/       // pattern
"$2, $1"             // replacement

For Maria Cruz, both produce Cruz, Maria. The separator and field patterns here suit this simple example; change them if your input uses a different format. Check the group order against one sample so the replacement puts each field where you intend.