Capture and Replace Text with Python Regex

Select a timestamp to watch that moment on YouTube.

1. 00:00

   Here is a small formatting problem that comes up when a program reads a line of identifiers. We receive four-digit order codes, and we want a friendlier label that drops leading zeros but keeps the numeric value. The code on screen looks plausible: it searches for `ORD-` followed by digits and replaces each occurrence. Let's actually run it. Both code numbers disappear. The regular expression found too much for the chosen fixed replacement. It did not save the part we still need, and the word `order` cannot somehow recover those digits afterward. We also have a second bug that this first example does not reveal.

2. 00:40

   The `+` permits any number of digits, while our contract is exactly four. A five-digit identifier would be transformed even though it is invalid. These are not reasons to avoid regular expressions entirely. They are reasons to define the data rule precisely before writing the pattern. We will inspect the part of a match we care about, use it to compute replacement text, and then test the edges. The lesson on `re.search` and `re.findall` already showed how to locate matching text. Today we go one step further: we preserve a captured field while changing the surrounding representation. Keep watching the actual output at every step, because two regular expressions that

3. 01:23

   look nearly identical can accept very different inputs. The parentheses around the digit pattern make a capture group, and the syntax `?P<number>` gives that group a name. The whole match is `ORD-0042`; the named group is just `0042`. When we print it, the leading zeros remain because a regex group returns text, not an integer. That distinction is useful. The pattern should identify which characters are part of a code. A later Python expression can decide whether to convert the captured text, preserve the original padding, or format it in some new way. If I replace the input with a string that contains no order code, `re.search`

4. 02:04

   returns `None`. I must check that before calling `group`, or I will get an attribute error. In the final solution, `re.sub` invokes our replacement function only for matches, so the callback receives a match object. Notice that I wrote `[0-9]` rather than the shorthand digit token. The shorthand can include many non-ASCII digits in Unicode text. If the incoming order system says four ASCII digits, we should encode that exact rule. Try changing `0042` to `0000` and predict what the group returns. It remains four text characters. Conversion with `int` is a separate, explicit operation.

5. 02:47

   We are also using a raw string for the pattern so the backslashes we add next will reach the regex parser as intended. A replacement function receives one match at a time. For each one, we read the captured number, convert it with `int`, and build the new label. That is why `0007` becomes `7`, while `0042` becomes `42`. The computation is in normal Python code, where it is easier to inspect and test than a complicated replacement string. `re.sub` returns a new string, so printing the original source still shows its unchanged codes. Strings are immutable; the helper's return value is the transformed text.

6. 03:28

   The two `\b` markers are word boundaries. The one before `ORD` prevents our code from starting in the middle of a larger word. The one after the four digits prevents it from accepting just the first four digits of a five-digit code. These boundaries are part of our input contract, not decorative regex syntax. The function should not erase unrelated text, punctuation, spaces, or lowercase identifiers. Ask whether we could instead use a backreference in the replacement string. We could preserve raw digits that way, but we need to strip leading zeros by integer conversion, so the callback is the direct and readable choice.

7. 04:10

   Keep this function small. When input becomes a structured object with several fields, parsing JSON or CSV would be safer to maintain than extending one regex indefinitely. For this constrained text label, the pattern and callback are clear enough to explain line by line. This is the run that tells us whether the repair is actually narrow enough. `XORD-1234` is embedded in a larger word, so the first boundary rejects it. `ORD-12345` has too many digits, so the final boundary rejects the four-digit prefix. The lowercase version is left alone because the pattern is case sensitive,

8. 04:50

   which is intentional for this order-code format. Only `ORD-9876` becomes `order:9876`. If a real system wanted lowercase codes too, we would write that requirement and update the pattern and tests together. We would not quietly turn on case- insensitive matching because a guess about the data format felt convenient. Try inserting a valid code twice. Both occurrences should be transformed in their original positions. Try an empty string: it should return an empty string without error. Try four Arabic-Indic numerals after `ORD-`: `[0-9]` should reject them.

9. 05:33

   That may sound strict, but it is correct when the source format defines ASCII digits. The earlier broken pattern also replaced a five-digit value; the new output demonstrates that we fixed that precise defect rather than merely hiding it in a prettier sample. This way of testing is useful beyond regex. For every parser or validator, include a valid case, a nearby invalid case, and a boundary case that might slip through a partial match. These assertions verify the happy path, two near misses, and empty input. They are development checks, not the function's production input validation. We can now paste or load the same code into the browser console on the lesson

10. 06:14

    page. The practical task starts with the deliberately broken replacement, so you can repair it yourself and select Check task. The lesson also has a short quiz about named groups, computed replacements, and boundaries. Completing both the task and quiz marks that lesson finished locally in your browser. Before moving on, look at the difference between the regex's job and the callback's job. The pattern identifies a complete eligible code. The callback decides how its captured number should be represented. The caller receives a new string and can choose whether to store it, print it, or pass it to another function.

11. 06:55

    That separation is why the final code is easier to change when the output format changes. A final caution: the use of word boundaries assumes surrounding characters are ordinary word or non-word characters as Python defines them. If your identifier grammar permits unusual punctuation or adjoining Unicode letters, write tests for those cases and adjust the pattern to the actual specification. Do not declare a regex universally correct because it passed four classroom examples. Here it meets the stated four-digit order- code rule, and our output makes that claim visible.