String-Ersetzung durch regulären Python-Ausdruck

Ersetzen Sie mit der Unterfunktion des Re-Moduls.

Verwendung des Re-Moduls Referenz https://note.nkmk.me/python-re-match-search-findall-etc/

Programm

Das Verhalten des Programms ist wie folgt.

Die Werte von Antwort1, Antwort3 und Antwort4 werden wie folgt konvertiert. 1)　 Wenn target_str und tmp_json sind: target_str = "asdasdasd ${key1} asdasdasdasd %key2% asdasdasd |key1| asdasdasd" tmp_json = {"key1" : "value1","key2" : "value2"} Der ersetzte Wert wird mit dem Wert neu geschrieben, der dem Schlüssel von tmp_json entspricht (siehe unten). asdasdasd value1 asdasdasdasd value2 asdasdasd value1 asdasdasd

Wenn target_str und tmp_json sind: target_str = "asdasdasd ${k1} asdasdasdasd %k2% asdasdasd |key1| asdasdasd" tmp_json = {"key1" : "value1","key2" : "value2"} Der ersetzte Wert wird mit dem Schlüssel tmp_json selbst wie unten gezeigt neu geschrieben. asdasdasd k1 asdasdasdasd k2 asdasdasd value1 asdasdasd

Wenn target_str und tmp_json sind: target_str = "asdasdasd $key1} asdasdasdasd key2% asdasdasd key1| asdasdasd" tmp_json = {"key1" : "value1","key2" : "value2"} Es stimmt nicht mit dem Muster des regulären Ausdrucks überein, daher entspricht es dem ursprünglichen Wert.

Der Wert von response2 wird unabhängig vom Wert von tmp_json mit dem Wert umgeschrieben, der dem regulären Ausdruck entspricht. Wenn es nicht übereinstimmt, entspricht es dem ursprünglichen Wert wie in 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")