Python-сообщество

def is_prop_formula(string):
    def reducE(string):
        result = re.sub("\(&[A-Z]\)|\([A-Z]>[A-Z]\)|\([A-Z]<[A-Z]\)|\([A-Z]=[A-Z]\)|\([A-Z]_[A-Z]\)|\([A-Z]\)", "X", string)
        if result != string:
            return reducE(result)
        return result
    return reducE(string) == "X"

> print is_prop_formula("(A=B)>(&C<D)=C=T>Z")
False
> print is_prop_formula("(((A=B)>((&C)<D))=(C=(T>Z)))")
True

# 1
class BrokenEgg(Exception):
    pass
# 2
class Brain_breacker:
    def __init__(self):
        # 3
        self.test_exp = ""
        self.expect_operator = 0
        self.braces = 0
        # 4
        self.operators = ("!", "&", "|", "==", "_")
        self.operator_leters = ("!", "&", "|", "=", "_")
        self.prefix_operators = ("!")
        self.var_begining = ("x", "y")
    
    def is_var(self, i):
        # 5
        if self.test_exp[i] in ("x", "y"):
            return True
        return False

    def add_var(self, i):
        # 6
        return i+1

    def check_operator_expection(self, i):
        # 7
        if self.expect_operator:
            raise BrokenEgg("Expect operator after '%s'." % self.test_exp[:i])

    def check_other_expection(self, i):
        # 8
        if not self.expect_operator:
            if self.test_exp[i] in self.prefix_operators:
                return True
            raise BrokenEgg("Don't expect operator after '%s'." % self.test_exp[:i])

    def is_operator(self, i):
        # 9
        if self.test_exp[i] in self.operator_leters:
            return True
        return False

    def add_operator(self, i):
        # 10
        j = i
        buf = ""
        while self.test_exp[j] in self.operator_leters:
            buf += self.test_exp[j]
            j += 1

        if buf in self.operators:
            return j
        else:
            raise BrokenEgg("Operator '%s' doesn't exist." % buf)

    def start(self, expression):
        # 11
        self.test_exp = expression
        i = 0
        while i < len(self.test_exp):
            # 12
            if self.test_exp[i] == "(":
                # 13
                self.check_operator_expection(i)
                # 14
                self.braces += 1
                # 15
                self.expect_operator = False
                # 16
                i += 1
                # 17
                continue
            # 18
            if self.test_exp[i] == ")":
                self.braces -= 1
                # 19
                self.expect_operator = True
                i += 1
                continue
            
            # 20
            if self.is_var(i):
                self.check_operator_expection(i)
                i = self.add_var(i)
                self.expect_operator = True
                continue
            # 21
            if self.is_operator(i):
                self.check_other_expection(i)
                self.expect_operator = False
                i = self.add_operator(i)
                continue
            # 22
            if self.test_exp[i] == " ":
                i += 1
                continue
            # 23
            raise BrokenEgg("Unexpectable simbol '%s'." % self.test_exp[i])
        # 24
        if self.braces:
            raise BrokenEgg("Something wrong with braces.")
        return True

# 25
def test(text, i = [0]):
    # 26
    i[0] += 1
    print ">Test number %s:" % i[0]
    print "Test expression is '%s'." % text
    # 27
    bb = Brain_breacker()
    # 28
    try:
        bb.start(text)
        print "It's allright with '%s'" % text
    except BrokenEgg as e:
        print e
    print ""

# 29
test("(!x == y & x ! x & !(!x & !y))")
test("(!x + y & x ! x & !(!x & !y))")
test("(!x == y & x = x & !(!x & !y))")
test("(!x == (y) & (x ! x & !(!x & !y)))")
test("(!x == (y & (x ! x & !(!x & !y)))")

def reducE(string):

def reducE(string):
        result = re.sub("\(&[A-Z]\)|\([A-Z]>[A-Z]\)|\([A-Z]<[A-Z]\)|\([A-Z]=[A-Z]\)|\([A-Z]_[A-Z]\)|\([A-Z]\)", "X", string)
        if result != string:
            return reducE(result)

>>> def is_prop_formula(string):
    def reducE(string):
        result = re.sub("\(&[A-z]\)|\([A-z]>[A-z]\)|\([A-z]<[A-z]\)|\([A-z]=[A-z]\)|\([A-z]_[A-z]\)|\([A-z]\)", string)
        if result != string:
            return reducE(result)
        return result
    return reducE(string) == string

>>> is_prop_formula("(&d)")
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    is_prop_formula("(&d)")
  File "<pyshell#46>", line 7, in is_prop_formula
    return reducE(string) == string
  File "<pyshell#46>", line 3, in reducE
    result = re.sub("\(&[A-z]\)|\([A-z]>[A-z]\)|\([A-z]<[A-z]\)|\([A-z]=[A-z]\)|\([A-z]_[A-z]\)|\([A-z]\)", string)
TypeError: sub() takes at least 3 arguments (2 given)

def is_prop_formula(string):
    def reducE(string):
        result = re.sub("\(&[A-z]\)|\([A-z]>[A-z]\)|\([A-z]<[A-z]\)|\([A-z]=[A-z]\)|\([A-z]_[A-z]\)|\([A-z]\)",A, string)
        if result != string:
            return reducE(result)
        return result
    return reducE(string) == A

>>> is_prop_formula("(&d)")
Traceback (most recent call last):
  File "<pyshell#50>", line 1, in <module>
    is_prop_formula("(&d)")
  File "<pyshell#49>", line 7, in is_prop_formula
    return reducE(string) == A
  File "<pyshell#49>", line 3, in reducE
    result = re.sub("\(&[A-z]\)|\([A-z]>[A-z]\)|\([A-z]<[A-z]\)|\([A-z]=[A-z]\)|\([A-z]_[A-z]\)|\([A-z]\)",A, string)
NameError: global name 'A' is not defined