Я хочу определить, что функциональный кластер может быть соединен и вызван in-a-go с заданным начальным параметром, а затем получить окончательный результат, я хочу, чтобы он действовал как цепочка командных каналов Linux:
test01() | test02() | test03() | test04()
[init_parameter] ----------------------------------------------------> [final result]
Я в condsidering последовательность функций может быть добавлена / уменьшена / ремикс, например:
test02() | test03() | test01() | test04()
[init_parameter] ----------------------------------------------------> [final result]
test03()| test01() | test04() | test01()
[init_parameter] ----------------------------------------------------> [final result]
Я также хочу, чтобы эти функции могли поставляться со встроенным индикатором способностей, который может использоваться для предварительно определенного интеллектуального параметра, например, если вход не является типом, который может принимать эта функция, или ввод превышает ее максимальную технологическую способность, цепочка может быть проигнорированным в этом потоке вычислений вместо использования "try ... Кроме ...", чтобы поймать эту "логическую" ошибку.
См. Код ниже, непроверенный, просто для описания моей идеи:
def test01(f_inspect=false, a, **b):
my_capability = {
"function_cluster": "A01",
"input_acceptable": type([]),
"input_element_acceptable": type(1),
"input_length_max": 100,
"return_type": type([]),
"return_element": type(1),
"return_length_max": 100,
}
if f_inspect:
return my_capability
return [x+1 for x in a] # just sample and may raise error by python such as div 0
def test02(f_inspect=false, a, **b):
# similiar as test01
def test03(f_inspect=false, a, **b):
# similiar as test01
def test04(f_inspect=false, a, **b):
# similar as test01
#==========================================
#test if function chain is compatible
def f_capability_compatible(current_,next_):
return True if
next_["function_cluster"] == current_["function_cluster"] and
next_["input_acceptable"] is current_["return_type"] and
next_["input_length_max"] >= current_["return_element"] and
next_["input_length_max"] >= current_["return_length_max"]
return False
foos = [test01,test02,test03,test04]
from itertools import permutations
mypermutations = permutations(foos, 3) # get permutations of testXX
init_parameter = [x for x in range(1,100)]
dummy_function_parameter = {
"function_cluster": "A01",
"input_acceptable": type([]),
"input_element_acceptable": type(1),
"input_length_max": 100,
"return_type": type([]),
"return_element": type(1)
"return_length_max": 100,
}
chain_flag = [True for x in range(len(mypermutations))]
#[True, True, True, ..... True, True, True, True, True, True, True]
for x in len(mypermutations):
tmp_para = dummy_function_parameter
for y in mypermutations[x]:
test_result = f_capability_compatible(tmp_para,y(f_inspect=true))
chain_flag[x] = test_result
tmp_para = y(f_inspect=true)
if test_result == False :
print "this can not be chained due to parameter incompatible at position %s" %x
break
#==========================================
result_of_chain = []
# to invoke:
for x in len(mypermutations):
if chain_flag[x] == True:
try :
# invoking my_capability[x] chain in a go
tmp_return = init_parameter
for f in mypermutations[x]:
tmp_return = f(tmp_return) #parameter of testXX(a)
except :
result_of_chain[x] = "Error"
else:
result_of_chain[x] = "Incomp"
Вот мой вопрос,
Можно ли сделать эту цепочку функций и идею комбинации более простой?
=============================================== ========================================
обновить, почему мне нужно предсказать параметр и тип возвращаемого значения:
В командной строке linux мы можем использовать такую команду:
$ cat sometfile | grep something | awk '{print $0}' | grep something > file
это работает, потому что поток данных между этими командами можно рассматривать как "текстовый" тип.
в python, однако, для этих неизвестных функций, в основном, есть возможность выбора типа входного параметра и возвращаемого результата. Если я хочу вызвать эти функции, я должен знать определение этого. Например
>>> def str_in_asciiout_out(str):
return ord(str)
>>>
>>> str_in_asciiout_out("a")
97
>>> str_in_asciiout_out(100)
# oops, I have to, try… expect…
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
str_in_asciiout_out(100)
File "<pyshell#0>", line 2, in str_in_asciiout_out
return ord(str)
TypeError: ord() expected string of length 1, but int found
Попробуйте ... кроме ... правильный и правильный способ кодирования.
Но если я хочу объединить сотни одинаковых функций str_in_asciiout_out () и поместить их в неизвестную последовательность, то я сфокусировался на том, что это лучший конечный результат, который может быть получен за короткое время.
Например, просто пример
Предположим, у меня определено 1000 функций, каждая функция может потребоваться выполнить за один день, чтобы получить вывод по заданному входу, я случайно выбрал 200 функций в цепочку и
str_in_asciiout_out (100)
просто в случае неудачи на последней позиции я могу получить упс, пока не потрачу впустую 199 часов.
Вот почему я хочу знать, может ли функция показать свои возможности, прежде чем тратить время впустую.
Приведенный выше код - это уродливое решение, которое я знаю, поэтому я вставляю идею, чтобы посмотреть, есть ли лучшее решение для моей проблемы.