Remplacement de chaîne par une expression régulière Python

Remplacez en utilisant la sous-fonction du module re.

Comment utiliser le module re Référence https://note.nkmk.me/python-re-match-search-findall-etc/

programme

Le comportement du programme est le suivant.

Les valeurs de response1, response3 et response4 sont converties comme suit. 1)　 Si target_str et tmp_json sont: target_str = "asdasdasd ${key1} asdasdasdasd %key2% asdasdasd |key1| asdasdasd" tmp_json = {"key1" : "value1","key2" : "value2"} La valeur remplacée sera réécrite avec la valeur correspondant à la clé de tmp_json comme indiqué ci-dessous. asdasdasd value1 asdasdasdasd value2 asdasdasd value1 asdasdasd

Si target_str et tmp_json sont: target_str = "asdasdasd ${k1} asdasdasdasd %k2% asdasdasd |key1| asdasdasd" tmp_json = {"key1" : "value1","key2" : "value2"} La valeur remplacée peut être réécrite avec la clé tmp_json elle-même comme indiqué ci-dessous. asdasdasd k1 asdasdasdasd k2 asdasdasd value1 asdasdasd

Si target_str et tmp_json sont: target_str = "asdasdasd $key1} asdasdasdasd key2% asdasdasd key1| asdasdasd" tmp_json = {"key1" : "value1","key2" : "value2"} Il ne correspond pas au modèle d'expression régulière, il est donc identique à la valeur d'origine.

La valeur de response2 est réécrite avec la valeur qui correspond à l'expression régulière, quelle que soit la valeur de tmp_json. Si elle ne correspond pas, elle sera la même que la valeur d'origine comme en 3.

#-*- encoding:utf-8 -*-
from functools import partial
import re

def call_back(match: re.match,tmp_dict=None) -> str:
    """
    call back
    Args:
        match: match object of re module
        tmp_dict: something dict object
    Returns:
        value
    """
    value = match.group("param")
    if tmp_dict != None and value in tmp_dict:
        return tmp_dict[value]
    return value

def search_and_convert(expression: str, tmp_json: dict) -> str:
    """
    Search specified string value, and replace it to the specified one
    Args:
        expression: would be converted string
        tmp_json: something dict value
    Returns:
        expression        
    """
    l = [
        {
            "reg" : re.finditer(r"(?<=\$\{)\w+(?=\})",expression),
            "prefix" : "${",
            "suffix" : "}"
        },
        {
            "reg" : re.finditer(r"(?<=%)\w+(?=%)",expression),
            "prefix" : "%",
            "suffix" : "%"
        },
        {
            "reg" : re.finditer(r"(?<=\|)\w+(?=\|)",expression),
            "prefix" : "|",
            "suffix" : "|"
        }
    ]
    for item in l:
        match_iterator = item["reg"]
        if match_iterator:
            for match in match_iterator:
                value = match.group()
                converted_value = value
                if value in tmp_json:
                    converted_value = tmp_json[value]
                expression = expression.replace(
                    item["prefix"] + value + item["suffix"],
                    converted_value
                )
    return expression


if __name__ == "__main__":
    target_str = "asdasdasd ${key1} asdasdasdasd %key2% asdasdasd |key1| asdasdasd"
    tmp_json = {"key1" : "value1","key2" : "value2"}

    #re.sub with lambda
    print(f"target_str = {target_str}")
    response1 = re.sub(r"\$\{(?P<param>\w+)\}",lambda x: tmp_json[x.group("param")] if x.group("param") in tmp_json else x.group("param"),target_str)
    response1 = re.sub(r"%(?P<param>\w+)%",lambda x: tmp_json[x.group("param")] if x.group("param") in tmp_json else x.group("param"),response1)
    response1 = re.sub(r"\|(?P<param>\w+)\|",lambda x: tmp_json[x.group("param")] if x.group("param") in tmp_json else x.group("param"),response1)
    print(f"response1 = {response1}")
    
    #re.sub with call back. 
    print(f"\033[33mtarget_str = {target_str}")
    response2 = re.sub(r"\$\{(?P<param>\w+)\}",call_back,target_str)
    response2 = re.sub(r"%(?P<param>\w+)%",call_back,response2)
    response2 = re.sub(r"\|(?P<param>\w+)\|",call_back,response2)
    print(f"response2 = {response2}\033[0m")

    #re.sub with call back which has a fixed augument.
    print(f"target_str = {target_str}")
    response3 = re.sub(r"\$\{(?P<param>\w+)\}",partial(call_back,tmp_dict=tmp_json),target_str)
    response3 = re.sub(r"%(?P<param>\w+)%",partial(call_back,tmp_dict=tmp_json),response3)
    response3 = re.sub(r"\|(?P<param>\w+)\|",partial(call_back,tmp_dict=tmp_json),response3)
    print(f"response3 = {response3}")

    #re.search & replace
    print(f"\033[33mtarget_str = {target_str}")
    response4 = search_and_convert(target_str,tmp_json)
    print(f"response4 = {response4}\033[0m")

    if response1 == response3 == response4:
        print("OK")
    else:
        raise Exception("Failed")