Python Regular Expressions

The Story That Explains Regular Expressions 🔍Regular Expressions समझाने वाली कहानी 🔍一个讲清正则表达式的故事 🔍

What Is a Regular Expression? 🧩Regular Expression क्या है? 🧩什么是正则表达式？🧩

A regular expression (regex) is a string that describes a search pattern. Most characters, like letters and digits, match themselves. Others — . ^ $ * + ? { } [ ] \ | ( ) — are metacharacters: instructions for the engine.

Regular expression (regex) एक string है जो search pattern बताती है। ज़्यादातर अक्षर, जैसे letters और अंक, ख़ुद से match करते हैं। बाक़ी — . ^ $ * + ? { } [ ] \ | ( ) — metacharacters हैं: engine के लिए निर्देश।

正则表达式（regex）是描述 搜索模式 的字符串。大多数字符（如字母和数字）匹配它们自己。另一些 — . ^ $ * + ? { } [ ] \ | ( ) — 是 元字符：给引擎的指令。

import re

# The simplest regex: literal text
print(re.search("hello", "say hello world"))

# A pattern: one or more digits
print(re.findall(r"\d+", "order 42 shipped 17 items"))

# The shape of a UK postcode
print(re.search(r"[A-Z]{1,2}\d[A-Z\d]? \d[A-Z]{2}", "Send to SW1A 1AA today"))

Raw Strings: Always Write r"..."Raw Strings: हमेशा r"..." लिखें原始字符串：始终写 r"..."

Python reads the backslashes in a normal string before re sees the pattern. "\b" becomes a backspace character, and the search quietly finds nothing. In a raw string, r"\b" stays as the two characters \ and b.

Python सामान्य string के backslashes को re के pattern देखने से पहले ही पढ़ लेता है। "\b" एक backspace अक्षर बन जाता है, और खोज चुपचाप कुछ नहीं पाती। Raw string में r"\b" दो अक्षरों \ और b के रूप में ही रहता है।

Python 会在 re 看到模式 之前 先处理普通字符串中的反斜杠。"\b" 变成退格字符，搜索会悄悄地什么也找不到。在 原始字符串 中，r"\b" 保持为 \ 和 b 两个字符。

import re

# Without r"...", Python turns "\b" into a BACKSPACE character before re sees it
print(repr("\bcat\b"))
print(re.findall("\bcat\b", "a cat sat"))      # [] - looks for backspaces!

# With a raw string, re receives the two characters \ and b
print(repr(r"\bcat\b"))
print(re.findall(r"\bcat\b", "a cat sat"))     # ['cat']

The Search Functions 🔎खोजने वाले Functions 🔎搜索函数 🔎

Five functions find matches. They differ in where they look and what they return.

पाँच functions matches खोजते हैं। वे इसमें अलग हैं कि कहाँ देखते हैं और क्या लौटाते हैं।

有五个函数用于 查找 匹配。它们的区别在于 在哪里 找和 返回什么。

search() — The First Match Anywheresearch() — कहीं भी पहला Matchsearch() — 任意位置的第一个匹配

import re

text = "The rain 42 falls 17 on 8 plains"

result = re.search(r"\d+", text)
print(result)
print(result.group(), result.start(), result.end())   # end is exclusive

# None when nothing matches - always check!
if re.search(r"xyz", text):
    print("found")
else:
    print("not found")

match() and fullmatch() — Start Only, or the Whole Thingmatch() और fullmatch() — सिर्फ़ शुरुआत, या पूराmatch() 与 fullmatch() — 只看开头，或整体

import re

print(re.match(r"\d+", "42 items"))      # starts with digits
print(re.match(r"\d+", "order 42"))      # None - starts with 'o'

print(re.fullmatch(r"\d+", "42"))        # the WHOLE string must match
print(re.fullmatch(r"\d+", "42 items"))  # None - extra text

user_input = "560034"
if re.fullmatch(r"\d{6}", user_input):   # an Indian PIN code
    print("valid 6-digit code")

findall() and finditer() — Every Matchfindall() और finditer() — हर Matchfindall() 与 finditer() — 所有匹配

import re

text = "The rain 42 falls 17 on 8 plains"
print(re.findall(r"\d+", text))

# With ONE group, findall returns just that group
print(re.findall(r"(\w+): \d+", "John: 25, Alice: 30, Bob: 22"))

# With TWO or more groups, it returns tuples
print(re.findall(r"(\w+): (\d+)", "John: 25, Alice: 30, Bob: 22"))

import re

text = "The rain 42 falls 17 on 8 plains"

# finditer yields Match objects one at a time - memory friendly
for m in re.finditer(r"\d+", text):
    print(f"{m.group()!r:5} at {m.start():2}..{m.end()}")

Picture It — search vs match vs findall 🖼️तस्वीर में — search बनाम match बनाम findall 🖼️图解 — search、match 与 findall 🖼️

Try It — The Regex Lab 🧪करके देखें — Regex Lab 🧪动手试试 — 正则实验室 🧪

Type any pattern and any text. The Lab shows exactly what Python would print, colours each match (and underlines each group), and lists every Match with its span. Start with a preset, then change one symbol at a time. The last preset is a trap — try it.

कोई भी pattern और कोई भी text लिखें। Lab ठीक वही दिखाता है जो Python छापता, हर match को रंगता है (और हर group को रेखांकित करता है), और हर Match को उसके span के साथ सूचीबद्ध करता है। किसी preset से शुरू करें, फिर एक बार में एक चिह्न बदलें। आख़िरी preset एक जाल है — आज़माएँ।

输入任意模式和任意文本。实验室会准确显示 Python 将打印的内容，为每个匹配上色（并给每个分组加下划线），列出每个 Match 及其 span。先从预设开始，然后一次改一个符号。最后一个预设是个陷阱 — 试试看。

The Editing Functions — sub, subn, split, compile ✂️बदलने वाले Functions — sub, subn, split, compile ✂️编辑函数 — sub、subn、split、compile ✂️

sub() and subn() — Search and Replacesub() और subn() — खोजो और बदलोsub() 与 subn() — 查找并替换

In the replacement, \1 or \g<1> inserts group 1, and \g<name> inserts a named group. The replacement can also be a function that receives each Match and returns a string.

Replacement में \1 या \g<1> group 1 डालता है, और \g<name> named group डालता है। Replacement एक function भी हो सकता है जो हर Match पाकर एक string लौटाए।

在替换串中，\1 或 \g<1> 插入第 1 组，\g<name> 插入命名分组。替换也可以是一个 函数，它接收每个 Match 并返回字符串。

import re

print(re.sub(r"\d", "#", "Order 42 for ₹17.50"))
print(re.sub(r"(\w+) (\w+)", r"\2 \1", "Alice Smith"))          # swap with \1 \2
print(re.sub(r"(?P<first>\w+) (?P<last>\w+)", r"\g<last>, \g<first>", "Alice Smith"))
print(re.sub(r"\d", "#", "1-2-3-4-5", count=2))                 # count= as a keyword!

def double(m):
    return str(int(m.group()) * 2)

print(re.sub(r"\d+", double, "a 3 b 5 c 7"))                    # replacement function

new_text, n = re.subn(r"\d", "#", "1-2-3-4-5")
print(new_text, n)

split() — Split by a Patternsplit() — Pattern से तोड़नाsplit() — 按模式分割

import re

print(re.split(r"\s+", "one    two\tthree\nfour"))
print(re.split(r"[,;|]", "apple,banana;cherry|kiwi"))
print(re.split(r"-", "a-b-c-d-e", maxsplit=2))      # maxsplit= as a keyword!

# A capturing group KEEPS the separators in the result
print(re.split(r"([,;])", "a,b;c"))

compile() — Name a Pattern and Reuse Itcompile() — Pattern को नाम दें और दोबारा इस्तेमाल करेंcompile() — 给模式命名并复用

import re

digits = re.compile(r"\d+")            # compile once ...
print(digits.findall("a 12 b 34"))     # ... use many times
print(digits.search("only 99 here"))
print(digits.sub("#", "1 to 100"))
print(digits.pattern, digits.flags)

email_re = re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+")
log_lines = ["mail alice@example.com now", "nothing here", "cc bob.k+news@my-site.co.in"]
for line in log_lines:
    for email in email_re.findall(line):
        print(email)

Speed is a small reason: the re module already keeps the last 512 patterns you used in a cache. The bigger reasons are readability (a well-named constant like EMAIL_RE) and keeping flags in one place.

रफ़्तार छोटी वजह है: re module पहले से ही आपके इस्तेमाल किए आख़िरी 512 patterns cache में रखता है। बड़ी वजहें हैं पढ़ने में आसानी (EMAIL_RE जैसा अच्छे नाम वाला constant) और flags को एक जगह रखना।

速度只是次要原因：re 模块本来就会缓存你最近用过的 512 个模式。更重要的原因是 可读性（像 EMAIL_RE 这样命名良好的常量），以及把标志集中在一处。

The Match Object — What You Get Back 🎁Match Object — आपको क्या मिलता है 🎁Match 对象 — 你得到了什么 🎁

import re

m = re.search(r"(\w+)@(\w+\.\w+)", "Contact: alice@example.com today")

print(m.group())            # the whole match = group(0)
print(m.group(1), m.group(2))
print(m[1], m[2])           # m[n] is a short form of m.group(n)
print(m.groups())
print(m.start(), m.end(), m.span())
print(m.span(2))            # span of group 2 only

m2 = re.search(r"(?P<user>\w+)@(?P<domain>\w+\.\w+)", "alice@example.com")
print(m2.group("user"), m2["domain"])
print(m2.groupdict())

if m3 := re.search(r"\d+", "no digits here"):   # walrus: assign and test
    print(m3.group())
else:
    print("no match - and no AttributeError")

Character Classes — Which Characters? 🔤Character Classes — कौन-से अक्षर? 🔤字符类 — 哪些字符？🔤

import re

print(re.findall(r"c.t", "cat cot cut c@t c t"))
print(re.findall(r"\d\d\d", "call 999 or 112"))
print(re.findall(r"[aeiou]", "hello world"))
print(re.findall(r"[^aeiou\s]", "hello world"))

# Surprise: in Python 3, \d and \w understand ALL languages
print(re.findall(r"\d+", "Price: ४५० or 450"))
print(re.findall(r"\d+", "Price: ४५० or 450", flags=re.ASCII))
print(re.findall(r"\w+", "café 中文 नमस्ते"))

Try It — Character Class Explorerकरके देखें — Character Class Explorer动手试试 — 字符类探索器

Pick a class and watch which of these 20 characters it accepts. Toggle re.ASCII and re.IGNORECASE. Every tile was decided by real Python with re.fullmatch.

एक class चुनें और देखें कि इन 20 अक्षरों में से कौन-से वह स्वीकार करती है। re.ASCII और re.IGNORECASE बदलें। हर tile का फ़ैसला असली Python ने re.fullmatch से किया है।

选一个字符类，看看这 20 个字符中它接受哪些。切换 re.ASCII 和 re.IGNORECASE。每个方块都是由真实 Python 用 re.fullmatch 判定的。

Anchors — Where in the Text? ⚓Anchors — Text में कहाँ? ⚓锚点 — 文本中的位置 ⚓

Anchors match positions, not characters. They take up zero width.

Anchors अक्षरों से नहीं, positions से match करते हैं। उनकी चौड़ाई शून्य होती है।

锚点匹配的是 位置 而不是字符，宽度为零。

import re

print(re.search(r"^Hello", "Hello world"))
print(re.search(r"^Hello", "Say Hello"))
print(re.search(r"world$", "Hello world"))

print(re.findall(r"\bcat\b", "cat cats concatenate"))
print(re.findall(r"cat", "cat cats concatenate"))
print(re.findall(r"\Bcat\B", "cat cats concatenate"))

# $ also matches just BEFORE a final newline; \Z only at the very end
print(re.search(r"\d+$", "42\n"))
print(re.search(r"\d+\Z", "42\n"))

Quantifiers — How Many? 🔁Quantifiers — कितने? 🔁量词 — 几次？🔁

import re

print(re.findall(r"\d+", "a1 b22 c333"))
print(re.findall(r"\d{2,3}", "1 22 333 4444"))
print(re.findall(r"colou?r", "color colour colouur"))

text = "<b>bold</b> and <i>italic</i>"
print(re.findall(r"<.+>", text))       # GREEDY: as much as possible
print(re.findall(r"<.+?>", text))      # LAZY: as little as possible
print(re.findall(r"<[^>]+>", text))    # a negated class: often the best choice

Try It — Engine Step-Throughकरके देखें — Engine Step-Through动手试试 — 引擎单步演示

How does the engine decide? It tries one start position at a time and walks along the pattern. A greedy .+ eats everything, then backtracks one character at a time. A lazy .+? takes one character, then checks whether the rest can already match. Compare the step counts.

Engine कैसे तय करता है? यह एक बार में एक शुरुआती position आज़माता है और pattern के साथ चलता है। Greedy .+ सब कुछ खा जाता है, फिर एक-एक अक्षर backtrack करता है। Lazy .+? एक अक्षर लेता है, फिर जाँचता है कि क्या बाक़ी हिस्सा अभी match हो सकता है। कदमों की गिनती की तुलना करें।

引擎如何做决定？它一次尝试一个起始位置，沿着模式前进。贪婪 的 .+ 先吃掉一切，再逐个字符 回溯。懒惰 的 .+? 先只拿一个字符，然后检查其余部分能否匹配。比较一下步数。

Groups, Alternation and Lookarounds 🧷Groups, Alternation और Lookarounds 🧷分组、选择与环视 🧷

import re

m = re.search(r"(\d{4})-\d{2}-\d{2}", "Born: 1990-03-15")
print(m.group(1))

print(re.findall(r"(?:https?|ftp)://\S+", "visit https://a.com or ftp://b.com"))
print(re.findall(r"(https?|ftp)://\S+", "visit https://a.com or ftp://b.com"))  # capturing!

print(re.findall(r"\b(cat|dog|fish)\b", "I have a cat, a dog, and a fish."))

m = re.search(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})", "Date: 2026-07-12")
print(m["year"], m["month"], m["day"])

print(re.findall(r"\d+(?=px)", "width: 100px, height: 200em"))    # lookahead
print(re.findall(r"\d+(?!\d|px)", "width: 100px, height: 200em"))  # negative lookahead
print(re.findall(r"(?<=₹)\d+", "pay ₹500 not $300"))               # lookbehind
print(re.search(r"(\w)\1", "bookkeeper"))                           # backreference

Look at \d+(?!\d|px): a plain \d+(?!px) would still return '10' from 100px, because the engine backtracks to a shorter number that is not followed by px. Lookarounds check, but the quantifier before them can still move.

\d+(?!\d|px) देखें: सादा \d+(?!px) 100px से भी '10' लौटा देता, क्योंकि engine एक छोटे नंबर तक backtrack करता है जिसके आगे px नहीं है। Lookarounds जाँचते हैं, पर उनसे पहले का quantifier फिर भी खिसक सकता है।

看 \d+(?!\d|px)：单纯的 \d+(?!px) 仍会从 100px 中返回 '10'，因为引擎会回溯到一个后面不是 px 的更短数字。环视只负责检查，但它前面的量词仍然可以移动。

Anatomy of an Email Regex 🧬Email Regex की बनावट 🧬邮箱正则的解剖 🧬

A real-world pattern is a short sentence made of small pieces. Here is a simple email matcher, one piece at a time.

असली pattern छोटे टुकड़ों से बना एक छोटा वाक्य होता है। यहाँ एक सादा email matcher है, एक-एक टुकड़ा करके।

真实世界的模式是由小片段组成的短句。下面是一个简单的邮箱匹配器，逐段拆解。

Flags — Change How Matching Works 🚩Flags — Matching का तरीका बदलें 🚩标志 — 改变匹配方式 🚩

import re

text = "Hello World\nGoodbye World"

print(re.findall(r"hello", text, flags=re.IGNORECASE))
print(re.findall(r"^\w+", text))
print(re.findall(r"^\w+", text, flags=re.MULTILINE))
print(re.findall(r"Hello.+World", text))
print(re.findall(r"Hello.+World", text, flags=re.DOTALL))

email = re.compile(r"""
    [A-Za-z0-9._%+-]+     # user name
    @                     # the at sign
    [A-Za-z0-9.-]+        # domain
    \.[A-Za-z]{2,}        # dot + top-level domain
""", re.VERBOSE)
print(email.findall("write to priya.s@iit.ac.in or info@example.com"))

log = "ERROR disk full\nok\nerror retry"
print(re.findall(r"^error.*", log, flags=re.IGNORECASE | re.MULTILINE))
print(re.findall(r"(?i)^error.*", log))          # inline flag at the start

Combine flags with |. An inline flag like (?i) must be at the very start of the pattern (an error since Python 3.11 otherwise). To change a flag for one part only, use (?i:...).

Flags को | से जोड़ें। (?i) जैसा inline flag pattern की बिल्कुल शुरुआत में होना चाहिए (वरना Python 3.11 से error)। सिर्फ़ एक हिस्से के लिए flag बदलना हो तो (?i:...) इस्तेमाल करें।

用 | 组合多个标志。像 (?i) 这样的内联标志必须放在模式的最 开头（否则从 Python 3.11 起会报错）。只想对一部分生效，请用 (?i:...)。

Catastrophic Backtracking 💣Catastrophic Backtracking 💣灾难性回溯 💣

A pattern like (a+)+b has a quantifier inside a quantifier. When the text almost matches — many as but no b — the engine tries every possible way to divide the as between the inner and outer + before giving up. The number of ways doubles with each extra a.

(a+)+b जैसे pattern में quantifier के अंदर quantifier है। जब text लगभग match करता है — बहुत से a पर कोई b नहीं — तो engine हार मानने से पहले a को अंदर और बाहर के + में बाँटने का हर तरीका आज़माता है। हर अतिरिक्त a के साथ तरीकों की संख्या दोगुनी होती है।

像 (a+)+b 这样的模式，量词里面套着量词。当文本 几乎 匹配时 — 很多 a 但没有 b — 引擎会在放弃前尝试把这些 a 分配给内外两个 + 的每一种方式。每多一个 a，方式数就翻倍。

import re, time

for n in (16, 18, 20, 22):
    text = "a" * n + "c"                     # almost matches - but no 'b'
    t = time.perf_counter()
    re.match(r"(a+)+b", text)                # nested quantifiers
    slow = time.perf_counter() - t
    t = time.perf_counter()
    re.match(r"(?>a+)+b", text)              # atomic group (Python 3.11+)
    fast = time.perf_counter() - t
    print(f"n={n}: nested {slow * 1000:8.2f} ms   atomic {fast * 1000:.3f} ms")

Try It — Backtracking Raceकरके देखें — Backtracking Race动手试试 — 回溯赛跑

Slide the number of as and compare four patterns that all mean "some a's then b". The times were measured with real Python on our build machine (on a log scale — each grid step is ×10). Yours will differ, but the doubling will not.

a की संख्या slide करें और चार patterns की तुलना करें जिनका मतलब एक ही है: "कुछ a फिर b"। समय हमारी build machine पर असली Python से नापे गए (log scale पर — हर कदम ×10)। आपके समय अलग होंगे, पर दोगुना होना नहीं बदलेगा।

拖动 a 的数量，比较四个都表示"若干 a 再接 b"的模式。这些耗时是在我们的构建机器上用真实 Python 测得的（对数刻度 — 每格 ×10）。你的数值会不同，但翻倍规律不会变。

A Tested Pattern Library 📚जाँची हुई Pattern Library 📚经过测试的模式库 📚

Each pattern below was run by Python on the sample text; the last column is the real findall result. Notice the limits — they are part of the lesson.

नीचे का हर pattern Python ने नमूना text पर चलाया; आख़िरी column असली findall नतीजा है। सीमाओं पर ध्यान दें — वे भी सबक़ का हिस्सा हैं।

下面每个模式都由 Python 在示例文本上运行过；最后一列是真实的 findall 结果。注意它们的局限 — 那也是课程的一部分。

Exercises 🏋️अभ्यास 🏋️练习 🏋️

Six problems, from easy to advanced. Try each one in the Regex Lab before reading the solution.

छह सवाल, आसान से कठिन तक। हल पढ़ने से पहले हर एक को Regex Lab में आज़माएँ।

六道题，由易到难。看答案之前，先在正则实验室里试一试。

1 · Extract All Numbers1 · सारे नंबर निकालें1 · 提取所有数字

import re

text = "Order 42 for ₹17.50 delivered on day 3"
print(re.findall(r"\d+(?:\.\d+)?", text))
print(re.findall(r"\d+(\.\d+)?", text))      # capturing group: a different result!

2 · Validate a UK Postcode2 · UK Postcode जाँचें2 · 校验英国邮编

import re

def is_uk_postcode(text):
    return re.fullmatch(r"[A-Z]{1,2}\d[A-Z\d]? \d[A-Z]{2}", text) is not None

for code in ["SW1A 1AA", "M1 1AE", "invalid", "SW1A 1AAA", "sw1a 1aa"]:
    print(f"{code!r:12} {is_uk_postcode(code)}")

3 · Mentions and Hashtags3 · Mentions और Hashtags3 · 提及与话题标签

import re

post = "Loving @python on #Sunday with @friends #100DaysOfCode. Mail me@x.com"

mentions = re.findall(r"(?<!\w)@(\w+)", post)   # not after a letter: skips me@x.com
hashtags = re.findall(r"#(\w+)", post)
print("Mentions:", mentions)
print("Hashtags:", hashtags)

4 · Parse Log Lines4 · Log Lines parse करें4 · 解析日志行

import re

pattern = re.compile(r"""
    \[(?P<time>\d{4}-\d{2}-\d{2}\ \d{2}:\d{2}:\d{2})\]   # [timestamp]
    \s+(?P<level>[A-Z]+)                                  # level
    \s+(?P<msg>.+)                                        # the rest
""", re.VERBOSE)

for line in ["[2026-07-12 14:30:15] INFO User logged in",
             "[2026-07-12 14:31:02] ERROR Disk full",
             "garbage line"]:
    if m := pattern.match(line):
        print(m.groupdict())
    else:
        print("no match:", repr(line))

5 · Redact Sensitive Data5 · संवेदनशील Data छिपाएँ5 · 脱敏敏感数据

import re

text = "Contact alice@x.com or call 07123456789. My email is bob@y.com"

redacted = re.sub(r"[\w.+-]+@[\w-]+\.[\w.-]+", "[EMAIL]", text)
redacted = re.sub(r"\b07\d{9}\b", "[PHONE]", redacted)
print(redacted)

# Indian mobile numbers: optional +91, then 10 digits starting 6-9
print(re.sub(r"(?:\+91[\s-]?)?\b[6-9]\d{9}\b", "[MOBILE]", "Call +91 9876543210 or 8123456789"))

6 · Strong Password Check6 · मज़बूत Password जाँच6 · 强密码校验

import re

STRONG = re.compile(r"""
    (?=.*[a-z])          # at least one lowercase letter
    (?=.*[A-Z])          # at least one uppercase letter
    (?=.*\d)             # at least one digit
    (?=.*[!@#$%^&*])     # at least one special character
    .{8,}                # 8 or more characters in total
""", re.VERBOSE)

def is_strong(pw):
    return STRONG.fullmatch(pw) is not None

for pw in ["Passw0rd!", "weakpass", "Ab1!", "ALLCAPS123!", "Passw0rd!\n"]:
    print(f"{pw!r:14} {is_strong(pw)}")

# The original version used match + ^...$ - it lets a trailing newline slip in:
old = re.compile(r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$")
print(bool(old.match("Passw0rd!\n")))

Common Pitfalls 🕳️आम ग़लतियाँ 🕳️常见陷阱 🕳️

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题