按規則決議字串中的嵌套函式并實作函式呼叫
需求
1、按照一定規則決議字串中的函式運算式，并替換這些運算式，這些函式運算式可能包含其它函式運算式，即支持函式嵌套
2、函式運算式格式：${ __函式名稱() }、${__函式名稱( 函式引數 )}
注意：
- 函式名稱以
_打頭 - 函式引數之間使用
||分隔 形如${ __function1( "str_value" || 123456 || 'test' )} ${之間不能有空格- 函式名稱和函式的左括號
(之間不能有空隔 - 函式支持嵌套，形如：
${ __function1( ${__function2()} )} - 函式引數如果是字串，需要使用單引號、雙引號參考 形如
${ __function1( "str_value" || 123)}，${ __function1(key="arg_value")}，${ __function1(key=\'arg_value\')}， - 字串替換規則：待替換的字串，僅包含一個函式運算式，不含其它字符，則該字串被替換為函式回傳值，如果還包含其它字符，或者包含多個函式，則該字串替換函式運算式之前，會先轉換函式回傳值為字串，然后替換這些函式運算式為轉換后的函式回傳值
- 函式引數支持python原生函式 形如
${ __function1( set([1,2,3]) )}
解決思路
1、先決議內部函式，再決議其父函式，即從內到外決議
實作方式：查找不包含嵌套函式運算式的函式運算式，先臨時替換為“臨時插件函式運算式” 形如 '@plugin_func_custom_function_name@'，同時以該值為字典key，存盤對應臨時函式運算式，然后再用替換后的字串去查找不包含嵌套函式運算式的函式運算式，然后再替換字串，直到找不到為止
2、決議替換后的字串，獲取“臨時插件函式運算式”，然后執行呼叫該函式
3、函式引數型別分析
字串引數要求用 單、雙引號 參考，通過eval(引數)轉換，如果轉換成功則用轉換后的，否則用轉換前的
實作代碼
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#
import re
# 插件函式樣例
def base64(*args, **kwargs):
print('base64 called')
print('args：', args)
print('kwargs：', kwargs)
return 1
def read_file(*args, **kwargs):
print('fread_file called')
print('args：', args)
print('kwargs：', kwargs)
return ['a', 1]
def generate_num(*args, **kwargs):
print('generate_num called')
print('args：', args)
print('kwargs：', kwargs)
return 899999
PUGIN_FUNC_MAP = {'read_file':read_file, 'base64':base64, 'generate_num':generate_num} # 存放插件函式名稱和對應函式物體的映射
func_map = {} # 存放程式執行程序中，獲取的臨時函式名稱和函式運算式的映射關系
REG_FOR_TEMP_PLUGIN_FUNC = re.compile('@(plugin_func.+?)@', re.DOTALL) # 用于查找臨時插件函式名稱 形如 [''@plugin_func__base64@','@plugin_func__read_file@']
REG_FOR_FUNC_NAME_OF_EXP = re.compile('\${\s*(_.+?)\(', re.DOTALL) # 用于查找函式運算式中的函式名稱
REG_FOR_FUNC_NAME_AND_ARGS = re.compile('\${\s*(_.+?)\((.*?)\)\s*}', re.DOTALL) # 用于查找函式運算式中的函式定義（函式名稱及其引數）
REG_FOR_STRICT_FUNC_EXP = re.compile('\${\s*_.+\(.*?\)\s*}', re.DOTALL) # 用于獲取嚴格函式定義運算式
REG_FOR_KWARG = re.compile('^[^"\']+[^"\']+\s*=\s*.+', re.DOTALL) # 用于匹配關鍵詞引數
def _replace_function(string):
'''替換字串中的插件引數'''
string = string.strip()
func_name_list = REG_FOR_TEMP_PLUGIN_FUNC.findall(string) # 獲取函式名稱串列 形如 [''@plugin_func__base64@','@plugin_func__read_file@']
if len(func_name_list) == 1 and string == '@%s@' % func_name_list[0]: # 整個字串就是一個函式運算式，字串代表的值的型別和函式回傳值型別相同,如果函式不存在，回傳None
if func_name_list[0] in func_map:
return call_plugin_func(func_map.get(func_name_list[0]))
else:
for func_name in func_name_list:
if func_name in func_map:
string = string.replace('@%s@' % func_name, str(call_plugin_func(func_map.get(func_name))))
return string
def call_plugin_func(function_express):
'''
呼叫插件函式
'''
try:
result = REG_FOR_FUNC_NAME_AND_ARGS.findall(function_express) # 查找函式運算式中的函式定義（函式名稱及其引數）
if result:
plugin_func_name, plugin_func_args = result[0]
plugin_func_name = plugin_func_name.strip('_') # 去掉函式前綴標識 _ 以獲取真正的函式
plugin_func_args = plugin_func_args.strip()
plugin_func_arg_list = []
if plugin_func_args:
plugin_func_arg_list = plugin_func_args.split("||") # 函式引數要求用 || 分隔
position_arg_list = [] # 存放位置引數
keyword_arg_dict = {} # 存放關鍵詞引數
for item in plugin_func_arg_list:
item = item.strip()
if REG_FOR_KWARG.findall(item): # 關鍵詞引數
key, value = https://www.cnblogs.com/shouke/p/re.split('\s*=[=|\s]*', item)
try:
value = https://www.cnblogs.com/shouke/p/_replace_function(value)
keyword_arg_dict[key.strip()] = eval(value)
except Exception as e:
keyword_arg_dict[key.strip()] = value
else:
try:
value = _replace_function(item)
position_arg_list.append(eval(value))
except Exception as e:
position_arg_list.append(value)
if plugin_func_name in PUGIN_FUNC_MAP:
return PUGIN_FUNC_MAP.get(plugin_func_name)(*position_arg_list, **keyword_arg_dict)
else:
return None
else: #未找到函式
print('沒有找到同函式運算式( %s )匹配的函式定義' % function_express)
return None #
except Exception as e:
raise
def replace_function(string):
'''替換函式'''
try:
regular_obj = re.compile('\${\s*(_.+?)\(', re.DOTALL)
# 獲取臨時函式名稱
temp_func_name_list = REG_FOR_FUNC_NAME_OF_EXP.findall(string)
string_copy = string
old_func_name_set = set() # 存放上一次的查找結果
while old_func_name_set != set(temp_func_name_list):
old_func_name_set = set(temp_func_name_list)
for func_name in temp_func_name_list: # 遍歷查找函式對應的函式運算式
pattern = '\${\s*%s\(.*?\)\s*}' % func_name
func_express_list = re.findall(pattern, string_copy) # 獲取函式運算式(因為可能存在函式嵌套，所以獲取的運算式可能是錯誤的)
if not func_express_list: # 找不到函式運算式，說明該函式名稱無效，不合法
continue
for func_express in func_express_list:
temp_func_express = func_express.strip().lstrip('${')
if not REG_FOR_STRICT_FUNC_EXP.findall(temp_func_express): # 運算式不包含嵌套函式，則 獲取正確的函式運算式進行替換
right_func_express_list = REG_FOR_STRICT_FUNC_EXP.findall(func_express)
for right_func_express in right_func_express_list:
string_copy = string_copy.replace(right_func_express, '@plugin_func%s@' % func_name)
func_map['plugin_func%s' % func_name] = right_func_express # 建立臨時函式名稱和函式運算式的映射關系
temp_func_name_list = re.findall(regular_obj, string_copy)
if string_copy == string: # 無變化
return string
return _replace_function(string_copy)
except Exception as e:
print('替換函式出錯%s' % e)
return string
# 運行測驗
src_string = "some string ${ __base64( ${__read_file('filepath')} \
|| 'string_arg' || 'b==整個運算式(包括b==）是字串引數' || '支持單雙引號轉義字符引數\" \
|| 'fake_key_arg1 = 我整個運算式都是字串引數' || key_arg1='關鍵詞字串引數'||key_arg2=1 ||key_arg3=[1, 2, 3] \
|| key_arg4={'a':1, 'b':'字典引數'} \
) } hello"
print(replace_function(src_string))
src_string = '${ __generate_num() }'
print(replace_function(src_string))
運行結果如下
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/283015.html
標籤：Python
下一篇：基于FPGA的數字跑表設計