Pythonの静的でexcecutableな数式を渡って算術演算子を反復する方法は？

Question

私はitertoolsを使用して数学演算子を反復しようとしています。 通常とarray私は結果を得ることができcombinationsを使用して[1, 2, 3]、の：

1 
1,2 
1,3 
2,3 
1,2,3 

などを

私は、このような方法で[1, 2, 3]のarrayでこれを使用すること：

1+2+3 
1+2-3 
1+2/3 
1+2*3 
1-2+3 
1-2-3 
1-2/3 
1-2*3 
... 

が発生し、式の結果が得られます。

これを行うにはどうすればよいですか？ここで

Answer 1

オペランドの任意の数に一般化溶液、および演算子の通常の優先順位保存：

from itertools import product 

operands = [1, 2, 3, 4] 
operators = [ '+', '*', '-', '//' ] # change '//' to '/' for floating point division 
for opers in product(operators, repeat=len(operands)-1): 
    formula = [ str(operands[0]) ] 
    for op, operand in zip(opers, operands[1:]): 
     formula.extend([op, str(operand)]) 
    formula = ' '.join(formula) 
    print('{} = {}'.format(formula, eval(formula))) 

Answer 2

は、私はそれにアプローチする方法を次のとおりです。

import itertools 
import operator 

まず、すべての可能な組み合わせのリストを作る：

funcs = [operator.add, operator.sub, operator.mul, operator.div] 

combos = list(itertools.product(funcs, repeat=2)) 

>>[(<function operator.add>, <function operator.add>), 
(<function operator.add>, <function operator.sub>), 
(<function operator.add>, <function operator.mul>), 
(<function operator.add>, <function operator.div>), 
(<function operator.sub>, <function operator.add>), 
(<function operator.sub>, <function operator.sub>), 
(<function operator.sub>, <function operator.mul>), 
(<function operator.sub>, <function operator.div>), 
(<function operator.mul>, <function operator.add>), 
(<function operator.mul>, <function operator.sub>), 
(<function operator.mul>, <function operator.mul>), 
(<function operator.mul>, <function operator.div>), 
(<function operator.div>, <function operator.add>), 
(<function operator.div>, <function operator.sub>), 
(<function operator.div>, <function operator.mul>), 
(<function operator.div>, <function operator.div>)] 

その後、我々はすべての可能な結果解決このリストを反復処理します：

を

for fn in combos: 
    print 'This combo {} yielded this result {}'.format(fn, fn[1](fn[0](*seq[:2]), seq[-1])) 

This combo (<built-in function add>, <built-in function add>) yielded this result 6 
This combo (<built-in function add>, <built-in function sub>) yielded this result 0 
This combo (<built-in function add>, <built-in function mul>) yielded this result 9 
This combo (<built-in function add>, <built-in function div>) yielded this result 1 
This combo (<built-in function sub>, <built-in function add>) yielded this result 2 
This combo (<built-in function sub>, <built-in function sub>) yielded this result -4 
This combo (<built-in function sub>, <built-in function mul>) yielded this result -3 
This combo (<built-in function sub>, <built-in function div>) yielded this result -1 
This combo (<built-in function mul>, <built-in function add>) yielded this result 5 
This combo (<built-in function mul>, <built-in function sub>) yielded this result -1 
This combo (<built-in function mul>, <built-in function mul>) yielded this result 6 
This combo (<built-in function mul>, <built-in function div>) yielded this result 0 
This combo (<built-in function div>, <built-in function add>) yielded this result 3 
This combo (<built-in function div>, <built-in function sub>) yielded this result -3 
This combo (<built-in function div>, <built-in function mul>) yielded this result 0 
This combo (<built-in function div>, <built-in function div>) yielded this result 0 

編集：これは操作の規則に従う方法です

ops = ['+','-','*','/'] 

combos = list(itertools.product(ops, repeat=2)) 

for tup in list(itertools.product(combos, [seq])): 
    print 'These operations {} evaluate to this ---> {}'.format(tup[0],eval(''.join(*zip(seq[0],tup[0][0],seq[1],tup[0][1],seq[-1])))) 

These operations ('+', '+') evaluate to this ---> 6 
These operations ('+', '-') evaluate to this ---> 0 
These operations ('+', '*') evaluate to this ---> 7 
These operations ('+', '/') evaluate to this ---> 1 
These operations ('-', '+') evaluate to this ---> 2 
These operations ('-', '-') evaluate to this ---> -4 
These operations ('-', '*') evaluate to this ---> -5 
These operations ('-', '/') evaluate to this ---> 1 
These operations ('*', '+') evaluate to this ---> 5 
These operations ('*', '-') evaluate to this ---> -1 
These operations ('*', '*') evaluate to this ---> 6 
These operations ('*', '/') evaluate to this ---> 0 
These operations ('/', '+') evaluate to this ---> 3 
These operations ('/', '-') evaluate to this ---> -3 
These operations ('/', '*') evaluate to this ---> 0 
These operations ('/', '/') evaluate to this ---> 0 

Answer 3

operatorモジュールの対応する関数を使用して、それらのペアを反復処理します。今

import itertools 
import operator 

ops = [operator.add, operator.sub, operator.mul, operator.div] 

for f1, f2 in itertools.product(*ops, repeat=2): 
    print f1(array[0], f2(array[1], array[2])) 

arrayは、任意の長さを持つことができるならば、それはビットのトリッカーを取得します。

for operations in itertools.product(*ops, repeat=len(array)-1): 
    result = operations[0](array[0], array[1]) 
    for op, operand in zip(operations[1:], array[2:]): 
     result = op(result, operand) 
    print(result) 

上記の構造は、各操作に適切な識別要素を知る必要がなくなります。

優先度に従いたい場合は、式を作成してeval（標準の警告が適用されます）と評価する必要があります。

for ops in itertool.product("+", "-", "*", "/", repeat=len(array)-1): 
    expr = "%s%s%s" % (array[0], ops[0], array[1]) 
    for op, operand in zip(ops[1:], array[2:]): 
    expr = "%s%s%s" % (expr, op, operand) 
    result = eval(expr) 

私は1+2*3に加えて(1+2)*3のような括弧で囲まれた表現を生成するために、これを拡大する練習としてそれを残します。

Answer 4

私の論理を指摘するためにエレガントなもの（膝の上に作られていませんが）は機能しませんが、機能します。 リストを正しい順序で1つずつ減らすことです。例えば。：

データ：1 * 2 + 3 * 4

• ステップ1（第*評価）後：2 + 3 * 4
• ステップ2（第2 *評価）後：2 + 12
ステップ3の後
• （+評価）：14

コード：

import operator 
import itertools 

data = [1.0, 2.0, 3.0, 4.0] 
operators_1 = [operator.mul, operator.div] # this operators have priority over that below 
operators_2 = [operator.add, operator.sub] 

def processOps(formula, data, operators): 
    res_formula = list(formula) 
    result = list(data) 
    for op in formula: 
     if op not in operators: continue 

     i = res_formula.index(op) 
     result = result[:i] + [op(result[i], result[i + 1])] + result[i + 2:] 
     res_formula.remove(op) 

     if len(result) == 1: 
      break 

    return (res_formula, result) 

for f in itertools.product(operators_1 + operators_2, repeat=len(data)-1): 
    result = list(data) 
    formula = list(f) 
    formula, result = processOps(formula, result, operators_1) 
    formula, result = processOps(formula, result, operators_2) 
    print f, result 

UDPこの更新されたロジックは、（1 * 2）+（3/4）のようなケースを正しく処理します。