Expressions
Régulières

import re

# Chercher un mot exact
re.search(r"bonjour", "Dis bonjour stp")    # Match !
re.search(r"bonjour", "Bonjour le monde !")  # None (casse différente)

# Le r"..." = raw string : le \ n'est pas interprété par Python
# Toujours utiliser r"..." pour écrire des patterns
re.search(r"\d+", "age: 42")  # Match : "42"

# Gourmand vs Non-gourmand : différence cruciale
texte = "<b>gras</b> et <i>italique</i>"

re.findall(r"<.+>",  texte)   # ["<b>gras</b> et <i>italique</i>"]  ← trop gourmand
re.findall(r"<.+?>", texte)   # ["<b>", "</b>", "<i>", "</i>"]   ← correct

# Alternatives avec le pipe |  — testées de gauche à droite
re.search(r"erreur|err|er", "erreur")  # "erreur" ← plus long en premier
re.search(r"er|err|erreur", "erreur")  # "er"     ← piège !

m = re.search(r"(\d{2})/(\d{2})/(\d{4})", "Né le 15/03/1990")
if m:
    m.group()    # "15/03/1990"  ← match complet
    m.group(1)   # "15"
    m.group(2)   # "03"
    m.group(3)   # "1990"
    m.groups()   # ("15", "03", "1990")
    m.start()    # 7   ← position début
    m.end()      # 17  ← position fin
    m.span()     # (7, 17)

# Compiler une fois, utiliser plusieurs fois → performance
EMAIL_RE = re.compile(r"[\w.\-]+@[\w.\-]+\.\w{2,6}")

emails = EMAIL_RE.findall(texte_long)
valide = EMAIL_RE.match(user_input)

# re.compile() accepte aussi des flags
PATTERN = re.compile(r"\bbonjour\b", re.IGNORECASE | re.MULTILINE)

# ✗ Sans VERBOSE : illisible
EMAIL_RE = re.compile(r"^[\w.\-]+@[a-zA-Z0-9\-]+(?:\.[a-zA-Z]{2,6})+$")

# ✓ Avec VERBOSE : chaque partie est expliquée
EMAIL_RE = re.compile(r"""
    ^                       # début de la chaîne
    [\w.\-]+                # partie locale : lettres, chiffres, points, tirets
    @                       # arobase obligatoire
    [a-zA-Z0-9\-]+         # domaine principal
    (?:\.[a-zA-Z]{2,6})+   # extension(s) : .com, .co.uk, etc.
    $                       # fin de la chaîne
""", re.VERBOSE)

# ⚠️  En mode VERBOSE, pour matcher un espace utiliser \s ou [ ] ou \x20

# Combiner plusieurs flags
PATTERN = re.compile(r"motif", re.VERBOSE | re.IGNORECASE | re.MULTILINE)

# Lookahead positif : chiffres suivis de € (sans capturer €)
re.findall(r"\d+(?=€)", "Coûte 42€ ou 15€")   # ["42", "15"]

# Lookahead négatif : lignes de diff ajoutées (pas les en-têtes +++)
re.findall(r"^\+(?!\+\+).+", diff, re.MULTILINE)

# Lookbehind positif : valeur après "total: " (sans capturer le préfixe)
re.findall(r"(?<=total:\s)\d+", "total: 987 articles")  # ["987"]

# Lookbehind négatif : chiffres non précédés de #
re.findall(r"(?<!#)\b\d+\b", "id: 42, couleur: #ff0000")  # ["42"]

# Normaliser des dates vers ISO 8601
def to_iso(m):
    j, mo, a = m.group(1), m.group(2), m.group(3)
    return f"{a}-{mo}-{j}"

re.sub(r"(\d{2})/(\d{2})/(\d{4})", to_iso, "Né le 15/03/1990")
# "Né le 1990-03-15"

# Compteur stateful via une closure (dict mutable)
compteurs = {"h1": 0, "h2": 0}

def numeroter(m):
    niveau = len(m.group(1))  # nombre de #
    if niveau == 1:
        compteurs["h1"] += 1; compteurs["h2"] = 0
        return f"# {compteurs['h1']}. {m.group(2)}"
    else:
        compteurs["h2"] += 1
        return f"## {compteurs['h1']}.{compteurs['h2']}. {m.group(2)}"

re.sub(r"^(#{1,2})\s+(.+)", numeroter, texte, flags=re.MULTILINE)

markdown = """```python
def hello():
    print("Hello")
```"""

# Sans DOTALL : . ne capture pas \n → rate les blocs multi-lignes
re.findall(r"```(\w*)\n(.+)```", markdown)          # []

# Avec DOTALL + non-gourmand : capture tout le bloc
re.findall(r"```(\w*)\n(.*?)```", markdown, re.DOTALL)
# [("python", 'def hello():\n    print("Hello")\n')]