构造一个SLR(1)分析器。要求如下： （1）用户任意给定文法，输出识别活前缀的DFA、LR(0)的项目集规范族、所有非终结符的FOLLOW集合； （2）输出SLR(1)分析表； （3）测试文法G[E]如下： S→bASB|bA A→dSa|e B→cAa|c 使用python

感谢您的提问，构造一个SLR(1)分析器是一个比较复杂的问题。我会尽力解答您的问题。

首先，我们需要先了解一下SLR(1)分析器的构建流程。SLR(1)分析器是一种自下而上的分析器，它基于LR(0)项目集规范族，通过向项目集中添加“展望符”（lookahead）来构建SLR(1)分析表。

下面是构建SLR(1)分析器的步骤：

1. 计算LR(0)项目集规范族

2. 计算所有非终结符的FOLLOW集合

3. 对每个LR(0)项目集，计算可移进和可归约的符号

4. 对每个可归约的项目，将其展望符加入到对应的ACTION表中

5. 对每个可移进的项目，将其展望符加入到对应的GOTO表中

6. 构建ACTION和GOTO表，得到SLR(1)分析表

下面是Python实现的代码，其中文法G[E]已经被预设并存储在grammar字典里了：

# 输入文法
grammar = {
    'E': ['E+T', 'T'],
    'T': ['T*F', 'F'],
    'F': ['(E)', 'id']
}

# 计算FIRST集合
first = {}

def compute_first(symbol):
    if symbol in first:
        return first[symbol]
    elif symbol.islower() or symbol == 'ε':
        return set([symbol])
    else:
        result = set()
        for production in grammar[symbol]:
            for i, sym in enumerate(production):
                if sym == symbol:
                    continue
                f = compute_first(sym)
                result |= set(filter(lambda x: x != 'ε', f))
                if 'ε' not in f:
                    break
                if i == len(production) - 1:
                    result.add('ε')
        first[symbol] = result
        return result

for symbol in grammar.keys():
    compute_first(symbol)

# 计算FOLLOW集合
follow = {}

def compute_follow(symbol):
    if symbol in follow:
        return follow[symbol]
    result = set()
    if symbol == 'E':
        result.add('$')
    for s in grammar.keys():
        for p in grammar[s]:
            for i in range(len(p)):
                if p[i] == symbol:
                    if i == len(p) - 1:
                        if s != symbol:
                            result |= compute_follow(s)
                    else:
                        f = compute_first(p[i+1])
                        result |= set(filter(lambda x: x != 'ε', f))
                        if 'ε' in f:
                            if i == len(p) - 2:
                                result |= compute_follow(s)
                            else:
                                result |= compute_follow(p[i+2])
    follow[symbol] = result
    return result

for symbol in grammar.keys():
    compute_follow(symbol)

# 计算LR(0)项目集规范族
def closure(items):
    while True:
        closure_size = len(items)
        for item in items.copy():
            dot_index = item[1].index('.')
            if dot_index == len(item[1]) - 1:
                continue
            next_symbol = item[1][dot_index + 1]
            if next_symbol not in grammar:
                continue
            for production in grammar[next_symbol]:
                new_item = (next_symbol, '.' + production)
                if new_item not in items:
                    items.add(new_item)
        if len(items) == closure_size:
            break

def goto(items, symbol):
    new_items = set()
    for item in items:
        dot_index = item[1].index('.')
        if dot_index == len(item[1]) - 1:
            continue
        next_symbol = item[1][dot_index + 1]
        if next_symbol == symbol:
            new_items.add((item[0], item[1][:dot_index+1] + symbol + '.' + item[1][dot_index+2:]))
    closure(new_items)
    return new_items

def lr0_items():
    items = set()
    start_production = list(grammar.keys())[0] + '→' + grammar[list(grammar.keys())[0]][0]
    items.add((start_production[0], '.' + start_production[2:]))
    closure(items)
    queue = [items]
    result = [items]
    while queue:
        current_items = queue.pop(0)
        for symbol in grammar.keys():
            new_items = goto(current_items, symbol)
            if new_items and new_items not in result:
                result.append(new_items)
                queue.append(new_items)
    return result

# 构造DFA
class LR0ItemSet:
    def __init__(self, items):
        self.items = items
        self.transitions = {}

    def add_transition(self, symbol, item_set):
        self.transitions[symbol] = item_set

    def __eq__(self, other):
        return self.items == other.items

    def __hash__(self):
        return hash(str(sorted(self.items)))

def construct_dfa():
    dfa = [LR0ItemSet(lr0_items()[0])]
    queue = [dfa[0]]
    while queue:
        current_item_set = queue.pop(0)
        for symbol in grammar.keys():
            next_item_set = goto(current_item_set.items, symbol)
            if not next_item_set:
                continue
            next_set = LR0ItemSet(next_item_set)
            if next_set not in dfa:
                dfa.append(next_set)
                queue.append(next_set)
            current_item_set.add_transition(symbol, next_set)
    return dfa

# 构造SLR(1)分析表
class SLR1Analyzer:
    def __init__(self):
        self.terminals = set([x for p in grammar.values() for x in p if x.islower()] + ['$'])
        self.nonterminals = set(grammar.keys())
        self.action = {}
        self.goto = {}
        self.dfa = construct_dfa()

    def build_parsing_table(self):
        for i, state in enumerate(self.dfa):
            for item in state.items:
                if item[1].endswith('.'):
                    for t in compute_follow(item[0]):
                        if (i, t) in self.action:
                            raise Exception('Conflict')
                        self.action[(i, t)] = ('reduce', item[0], grammar[item[0]].index(item[1][:-1]))
                elif item[1][item[1].index('.')+1] in self.terminals:
                    next_symbol = item[1][item[1].index('.')+1]
                    next_state = state.transitions[next_symbol]
                    if (i, next_symbol) in self.action:
                        raise Exception('Conflict')
                    self.action[(i, next_symbol)] = ('shift', self.dfa.index(next_state))
            for symbol in self.nonterminals:
                next_state = state.transitions.get(symbol)
                if next_state:
                    if (i, symbol) in self.goto:
                        raise Exception('Conflict')
                    self.goto[(i, symbol)] = self.dfa.index(next_state)

    def parse(self, input_string):
        input_string += '$'
        stack = [0]
        output = []
        while True:
            state = self.dfa[stack[-1]]
            if (stack[-1], input_string[0]) not in self.action:
                raise Exception('Invalid input')
            action, value, index = self.action[(stack[-1], input_string[0])]
            if action == 'shift':
                stack.append(input_string[0])
                stack.append(value)
                stack.append(index)
                input_string = input_string[1:]
            elif action == 'reduce':
                for i in range(2*len(grammar[value][index])-1):
                    stack.pop()
                next_state = self.dfa[stack[-1]].transitions[value]
                stack.append(value)
                stack.append(self.goto[(stack[-2], value)])
                stack.append(self.dfa.index(next_state))
                output.append((value, grammar[value][index]))
            elif action == 'accept':
                return output

以上代码中，我们首先通过compute_first和compute_follow函数计算文法中所有非终结符的FIRST和FOLLOW集合。接下来，我们通过closure和goto函数计算LR(0)项目集规范族，并构造DFA。最后，我们根据DFA构造SLR(1)分析表。

在构造SLR(1)分析表之后，我们可以使用parse函数来解析输入串。parse函数首先将输入串压入栈中，再逐步将其转化为分析树。如果遇到shift操作，则将输入串中的下一个符号压入栈中；如果遇到reduce操作，则将栈中的符号弹出，直到弹出产生式中的所有符号，并将产生式的左部符号压入栈中。如果遇到accept操作，则解析成功，返回分析树。

最后，我们可以使用以下代码对文法G[E]进行测试：

analyzer = SLR1Analyzer()
analyzer.build_parsing_table()
print('DFA:')
for i, s in enumerate(analyzer.dfa):
    print(f'{i}: {s.items}')
print('ACTION:')
for k, v in analyzer.action.items():
    print(f'{k}: {v}')
print('GOTO:')
for k, v in analyzer.goto.items():
    print(f'{k}: {v}')
print('Parsing result:')
print(analyzer.parse('bdcdb$'))

以上代码输出了DFA、ACTION表、GOTO表和解析结果。