For u unknown variables (e.g. a,b,c,d) and the symbols +-*/, find all possible equations of length n

An example being (for u=2, n=5):

(a+b)/a

我当前的代码可以创建所有可能方程式的列表,但不带方括号

v = ["a", "b"]            #Variables
s = ["+", "-", "*", "-"]  #Symbols
n = 7                     #Amount of variables and symbols
a = []                    #Lists combined (find possible equations from)
for i in range(n):
    if i % 2 == 0:
        a.append(v)
    else:
        a.append(s)
equations = list(itertools.product(*a))
for each in equations:
    print("".join(each))

总之,我编写的代码并不包含方程式的所有可能.

例如,对于n = 5和2个变量,我的代码找不到(a b)* b的可能性

在n = 7和4个变量的情况下,它找不到`(a b)*(c d)

我的主要问题：如何创建一些代码,将每个可能的方程式包含在其中,并找到所有可能的方括号,而不重复

复制示例：(a b)* c和a *(b c)

注意：这是重复的,因为由于正在测试所有可能的方程,所以在某些时候a b变为b c,因此* c变为* a

解决方法:

这个函数可以工作,但是它确实有很多表达式可以实现相同的功能,例如x-x或x / x,但有很多不同的东西代替x.但是,它避免了由于关联性或可交换性造成的琐碎重复.

同样,所有可能表达式的列表很快就会变得很长.例如,如果有4个变量,而所有带有5个项的表达式,则可以获得7845320.生成器的使用将使您不会耗尽内存,但不会因此而耗费非常长的时间.

def all_expressions(size, variables):
    def _all_expressions(_size):
        if _size == 1:
            for variable in variables:
                yield (variable, '')
        else:
            for subsize in range(1, _size//2 + 1):
                for expr1, type1 in _all_expressions(subsize):
                    for expr2, type2 in _all_expressions(_size - subsize):
                        if subsize < _size - subsize or expr1 <= expr2:
                            if type1 == '+':
                                if type2 != '+':
                                    yield ("({} + {})".format(expr2, expr1), '+')
                            else:
                                yield ("({} + {})".format(expr1, expr2), '+')
                            if type1 == '*':
                                if type2 != '*':
                                    yield ("({} * {})".format(expr2, expr1), '*')
                            else:
                                yield ("({} * {})".format(expr1, expr2), '*')
                        if type1 != '*':
                            yield ("({} / {})".format(expr1, expr2), '/')
                        if type1 != '+':
                            yield ("({} - {})".format(expr1, expr2), '-')
                        if subsize < _size - subsize:
                            if type2 != '*':
                                yield ("({} / {})".format(expr2, expr1), '/')
                            if type2 != '+':
                                yield ("({} - {})".format(expr2, expr1), '-')
    for expr, t in _all_expressions(size):
        yield expr

for expr in all_expressions(3, ['a', 'b', 'c']):
    print(expr)