Traceback (most recent call last), как исправить?

Question

UuuuuuuuuuuuuuuuNiX @UuuuuuuuuuuuuuuuNiX

Python

Traceback (most recent call last), как исправить?

Поучаю ошибку:

Traceback (most recent call last):
  File "D:\PythonScript\index.py", line 166, in <module>
    interpreter.interpret(source_code)
  File "D:\PythonScript\index.py", line 145, in interpret
    parsed_data = self.parser.parse()
  File "D:\PythonScript\index.py", line 70, in parse
    parsed_data.append(self.parse_statement())
  File "D:\PythonScript\index.py", line 76, in parse_statement
    raise Exception('Ожидается идентификатор')
Exception: Ожидается идентификатор

При запуске кода:

class Lexer:
    def __init__(self, source_code):
        self.source_code = source_code
        self.position = 0
        self.tokens = []

    def tokenize(self):
        while self.position < len(self.source_code):
            current_char = self.source_code[self.position]
    
            if current_char.isdigit():
                self.tokens.append(self.parse_number())
            elif current_char == '"':
                self.tokens.append(self.parse_string())
            elif current_char.isalpha() or current_char == '_':
                self.tokens.append(self.parse_identifier())
            elif current_char.isspace():
                self.position += 1
                continue
            elif current_char == '(' or current_char == ')':
                self.tokens.append({'type': 'paren', 'value': current_char})
            elif current_char == '=':
                self.tokens.append({'type': 'operator', 'value': current_char})
            elif current_char == '+':
                self.tokens.append({'type': 'operator', 'value': current_char})
            else:
                raise Exception(f'Недопустимый символ: {current_char}')
    
            self.position += 1
    
        return self.tokens

        return self.tokens

    def parse_number(self):
        start_position = self.position
        while self.position < len(self.source_code) and self.source_code[self.position].isdigit():
            self.position += 1
        number = int(self.source_code[start_position:self.position])
        return {'type': 'number', 'value': number}

    def parse_string(self):
        start_position = self.position
        self.position += 1
        while self.position < len(self.source_code) and self.source_code[self.position] != '"':
            self.position += 1
        if self.position >= len(self.source_code):
            raise Exception('Неожиданный конец строки')
        self.position += 1
        string = self.source_code[start_position:self.position]
        return {'type': 'string', 'value': string}

    def parse_identifier(self):
        start_position = self.position
        while self.position < len(self.source_code) and (
                self.source_code[self.position].isalpha() or self.source_code[self.position] == '_'):
            self.position += 1
        identifier = self.source_code[start_position:self.position]
        return {'type': 'identifier', 'value': identifier}


class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.position = 0

    def parse(self):
        parsed_data = []
        while self.position < len(self.tokens):
            parsed_data.append(self.parse_statement())
        return parsed_data

    def parse_statement(self):
        variable = self.tokens[self.position]
        if variable['type'] != 'identifier':
            raise Exception('Ожидается идентификатор')
        self.position += 1
    
        if self.position >= len(self.tokens) or self.tokens[self.position]['value'] != '=':
            raise Exception('Ожидается оператор присваивания')
        self.position += 1
    
        value_token = self.tokens[self.position]
        if value_token['type'] == 'string' or value_token['type'] == 'number' or value_token['type'] == 'identifier':
            assignment = {'type': 'assignment', 'variable': variable['value'], 'value': value_token['value']}
            self.position += 1
            return assignment
        else:
            raise Exception('Ожидается строка, число или идентификатор')
    



class SemanticAnalyzer:
    def __init__(self, parsed_data):
        self.parsed_data = parsed_data

    def analyze(self):
        semantic_data = []
        for statement in self.parsed_data:
            if statement['type'] == 'assignment':
                variable = statement['variable']
                value = self.evaluate_expression(statement['value'])
                semantic_data.append({variable: value})
        return semantic_data

    def evaluate_expression(self, expression):
        try:
            return int(expression)
        except ValueError:
            try:
                return float(expression)
            except ValueError:
                return expression.strip('\"')

    def data_acquisition(self, prompt):
        return input(prompt)


class CodeGenerator:
    def __init__(self, semantic_data):
        self.semantic_data = semantic_data

    def generate(self):
        generated_code = ''
        for statement in self.semantic_data:
            variable = list(statement.keys())[0]
            value = statement[variable]
            generated_code += f"{variable} = {repr(value)}\n"
        return generated_code


class Interpreter:
    def __init__(self):
        self.lexer = None
        self.parser = None
        self.semantic_analyzer = None
        self.code_generator = None

    def interpret(self, source_code):
        self.lexer = Lexer(source_code)
        tokens = self.lexer.tokenize()

        self.parser = Parser(tokens)
        parsed_data = self.parser.parse()

        self.semantic_analyzer = SemanticAnalyzer(parsed_data)
        semantic_data = self.semantic_analyzer.analyze()

        self.code_generator = CodeGenerator(semantic_data)
        generated_code = self.code_generator.generate()

        self.execute_code(generated_code)

    def execute_code(self, code):
        exec(code, {'data_acquisition': self.semantic_analyzer.data_acquisition})


if __name__ == "__main__":
    interpreter = Interpreter()
    source_code = '''
    name = data_acquisition("Enter your name: ")
    age = data_acquisition("Enter your age: ")
    write(name)
    '''
    interpreter.interpret(source_code)

Можете помочь? Очень сильно прошу!

Вопрос задан более года назад
90 просмотров

Комментировать

Подписаться 1 Простой Комментировать

Решения вопроса 1

4 комментария

UuuuuuuuuuuuuuuuNiX @UuuuuuuuuuuuuuuuNiX Автор вопроса

Спасибо!

Написано более года назад

UuuuuuuuuuuuuuuuNiX @UuuuuuuuuuuuuuuuNiX Автор вопроса

Друг, но у меня остался вопросик, я не очень гуд в создании парсира, вроде бы я, чисто логически исправил его, но ошибка - Ожидается строка, число или вызов функции повторится. Очень сильно прошу помощи!

Код парсира:

class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.position = 0

    def parse(self):
        parsed_data = []
        while self.position < len(self.tokens):
            parsed_data.append(self.parse_statement())
        return parsed_data

    def parse_statement(self):
        variable = self.tokens[self.position]
        if variable['type'] != 'identifier':
            raise Exception('Ожидается идентификатор')
        self.position += 1

        if self.position >= len(self.tokens) or self.tokens[self.position]['value'] != '=':
            raise Exception('Ожидается оператор присваивания')
        self.position += 1

        value_token = self.tokens[self.position]
        if value_token['type'] == 'function_call':
            function_name = value_token['value']
            arguments = []
            self.position += 1
            while (
                self.position < len(self.tokens)
                and self.tokens[self.position]['type'] != 'paren'
                and self.tokens[self.position]['value'] != ')'
            ):
                argument = self.tokens[self.position]
                arguments.append(argument)
                self.position += 1
            if (
                self.position >= len(self.tokens)
                or self.tokens[self.position]['value'] != ')'
            ):
                raise Exception('Ожидается закрывающая скобка для вызова функции')
            self.position += 1
            return {
                'type': 'assignment',
                'variable': variable['value'],
                'value': {
                    'type': 'function_call',
                    'function_name': function_name,
                    'arguments': arguments
                }
            }
        elif value_token['type'] in ['string', 'number']:
            assignment = {
                'type': 'assignment',
                'variable': variable['value'],
                'value': value_token['value']
            }
            self.position += 1
            return assignment
        else:
            raise Exception('Ожидается строка, число или вызов функции')

А вот код всего проекта( ну на всяк :D ):

class Lexer:
    def __init__(self, source_code):
        self.source_code = source_code
        self.position = 0
        self.tokens = []

    def tokenize(self):
        while self.position < len(self.source_code):
            current_char = self.source_code[self.position]

            if current_char.isdigit():
                self.tokens.append(self.parse_number())
            elif current_char == '"':
                self.tokens.append(self.parse_string())
            elif current_char.isalpha() or current_char == '_':
                self.tokens.append(self.parse_identifier())
            elif current_char.isspace():
                self.position += 1
                continue
            elif current_char == '(' or current_char == ')':
                self.tokens.append({'type': 'paren', 'value': current_char})
            elif current_char == '=':
                self.tokens.append({'type': 'operator', 'value': current_char})
            elif current_char == '+':
                self.tokens.append({'type': 'operator', 'value': current_char})
            else:
                raise Exception(f'Недопустимый символ: {current_char}')

            self.position += 1

        return self.tokens

    def parse_number(self):
       start_position = self.position
       while self.position < len(self.source_code) and self.source_code[self.position].isdigit():
           self.position += 1
       number = int(self.source_code[start_position:self.position])
       return {'type': 'number', 'value': number}

    def parse_string(self):
        start_position = self.position
        self.position += 1
        while self.position < len(self.source_code) and self.source_code[self.position] != '"':
            self.position += 1
        if self.position >= len(self.source_code):
            raise Exception('Неожиданный конец строки')
        self.position += 1
        string = self.source_code[start_position:self.position]
        return {'type': 'string', 'value': string}

    def parse_identifier(self):
        start_position = self.position
        while self.position < len(self.source_code) and (
                self.source_code[self.position].isalpha() or self.source_code[self.position] == '_'):
            self.position += 1
        identifier = self.source_code[start_position:self.position]
        return {'type': 'identifier', 'value': identifier}


class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.position = 0

    def parse(self):
        parsed_data = []
        while self.position < len(self.tokens):
            parsed_data.append(self.parse_statement())
        return parsed_data

    def parse_statement(self):
        variable = self.tokens[self.position]
        if variable['type'] != 'identifier':
            raise Exception('Ожидается идентификатор')
        self.position += 1

        if self.position >= len(self.tokens) or self.tokens[self.position]['value'] != '=':
            raise Exception('Ожидается оператор присваивания')
        self.position += 1

        value_token = self.tokens[self.position]
        if value_token['type'] == 'function_call':
            function_name = value_token['value']
            arguments = []
            self.position += 1
            while (
                self.position < len(self.tokens)
                and self.tokens[self.position]['type'] != 'paren'
                and self.tokens[self.position]['value'] != ')'
            ):
                argument = self.tokens[self.position]
                arguments.append(argument)
                self.position += 1
            if (
                self.position >= len(self.tokens)
                or self.tokens[self.position]['value'] != ')'
            ):
                raise Exception('Ожидается закрывающая скобка для вызова функции')
            self.position += 1
            return {
                'type': 'assignment',
                'variable': variable['value'],
                'value': {
                    'type': 'function_call',
                    'function_name': function_name,
                    'arguments': arguments
                }
            }
        elif value_token['type'] in ['string', 'number']:
            assignment = {
                'type': 'assignment',
                'variable': variable['value'],
                'value': value_token['value']
            }
            self.position += 1
            return assignment
        else:
            raise Exception('Ожидается строка, число или вызов функции')


class SemanticAnalyzer:
    def __init__(self, parsed_data):
        self.parsed_data = parsed_data

    def analyze(self):
        semantic_data = []
        for statement in self.parsed_data:
            if statement['type'] == 'assignment':
                variable = statement['variable']
                value = self.evaluate_expression(statement['value'])
                semantic_data.append({variable: value})
        return semantic_data

    def evaluate_expression(self, expression):
        if expression['type'] == 'function_call':
            function_name = expression['function_name']
            arguments = expression['arguments']
            if function_name == 'data_acquisition':
                prompt = arguments[0]['value']
                return self.data_acquisition(prompt)
            else:
                raise Exception(f'Неизвестная функция: {function_name}')
        elif expression['type'] == 'string':
            return expression['value']
        elif expression['type'] == 'number':
            return expression['value']
        else:
            raise Exception('Недопустимый тип выражения')

    def data_acquisition(self, prompt):
        return input(prompt)


class CodeGenerator:
    def __init__(self, semantic_data):
        self.semantic_data = semantic_data

    def generate(self):
        generated_code = ''
        for statement in self.semantic_data:
            variable = list(statement.keys())[0]
            value = statement[variable]
            generated_code += f"{variable} = {repr(value)}\n"
        return generated_code


class Interpreter:
    def __init__(self):
        self.lexer = None
        self.parser = None
        self.semantic_analyzer = None
        self.code_generator = None

    def interpret(self, source_code):
        self.lexer = Lexer(source_code)
        tokens = self.lexer.tokenize()

        self.parser = Parser(tokens)
        parsed_data = self.parser.parse()

        self.semantic_analyzer = SemanticAnalyzer(parsed_data)
        semantic_data = self.semantic_analyzer.analyze()

        self.code_generator = CodeGenerator(semantic_data)
        generated_code = self.code_generator.generate()

        self.execute_code(generated_code)

    def execute_code(self, code):
        exec(code, {'data_acquisition': self.semantic_analyzer.data_acquisition})


if __name__ == "__main__":
    interpreter = Interpreter()
    source_code = '''
    name = data_acquisition("Enter your name: ")
    print(name)
    '''
    interpreter.interpret(source_code)

Cпасибо!

Написано более года назад

UuuuuuuuuuuuuuuuNiX @UuuuuuuuuuuuuuuuNiX Автор вопроса

Друг, но у меня остался вопросик, я не очень гуд в создании парсира, вроде бы я, чисто логически исправил его, но ошибка - Ожидается строка, число или вызов функции повторится. Очень сильно прошу помощи!

Код парсира:

class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.position = 0

    def parse(self):
        parsed_data = []
        while self.position < len(self.tokens):
            parsed_data.append(self.parse_statement())
        return parsed_data

    def parse_statement(self):
        variable = self.tokens[self.position]
        if variable['type'] != 'identifier':
            raise Exception('Ожидается идентификатор')
        self.position += 1

        if self.position >= len(self.tokens) or self.tokens[self.position]['value'] != '=':
            raise Exception('Ожидается оператор присваивания')
        self.position += 1

        value_token = self.tokens[self.position]
        if value_token['type'] == 'function_call':
            function_name = value_token['value']
            arguments = []
            self.position += 1
            while (
                self.position < len(self.tokens)
                and self.tokens[self.position]['type'] != 'paren'
                and self.tokens[self.position]['value'] != ')'
            ):
                argument = self.tokens[self.position]
                arguments.append(argument)
                self.position += 1
            if (
                self.position >= len(self.tokens)
                or self.tokens[self.position]['value'] != ')'
            ):
                raise Exception('Ожидается закрывающая скобка для вызова функции')
            self.position += 1
            return {
                'type': 'assignment',
                'variable': variable['value'],
                'value': {
                    'type': 'function_call',
                    'function_name': function_name,
                    'arguments': arguments
                }
            }
        elif value_token['type'] in ['string', 'number']:
            assignment = {
                'type': 'assignment',
                'variable': variable['value'],
                'value': value_token['value']
            }
            self.position += 1
            return assignment
        else:
            raise Exception('Ожидается строка, число или вызов функции')

А вот код всего проекта( ну на всяк :D ):

class Lexer:
    def __init__(self, source_code):
        self.source_code = source_code
        self.position = 0
        self.tokens = []

    def tokenize(self):
        while self.position < len(self.source_code):
            current_char = self.source_code[self.position]

            if current_char.isdigit():
                self.tokens.append(self.parse_number())
            elif current_char == '"':
                self.tokens.append(self.parse_string())
            elif current_char.isalpha() or current_char == '_':
                self.tokens.append(self.parse_identifier())
            elif current_char.isspace():
                self.position += 1
                continue
            elif current_char == '(' or current_char == ')':
                self.tokens.append({'type': 'paren', 'value': current_char})
            elif current_char == '=':
                self.tokens.append({'type': 'operator', 'value': current_char})
            elif current_char == '+':
                self.tokens.append({'type': 'operator', 'value': current_char})
            else:
                raise Exception(f'Недопустимый символ: {current_char}')

            self.position += 1

        return self.tokens

    def parse_number(self):
       start_position = self.position
       while self.position < len(self.source_code) and self.source_code[self.position].isdigit():
           self.position += 1
       number = int(self.source_code[start_position:self.position])
       return {'type': 'number', 'value': number}

    def parse_string(self):
        start_position = self.position
        self.position += 1
        while self.position < len(self.source_code) and self.source_code[self.position] != '"':
            self.position += 1
        if self.position >= len(self.source_code):
            raise Exception('Неожиданный конец строки')
        self.position += 1
        string = self.source_code[start_position:self.position]
        return {'type': 'string', 'value': string}

    def parse_identifier(self):
        start_position = self.position
        while self.position < len(self.source_code) and (
                self.source_code[self.position].isalpha() or self.source_code[self.position] == '_'):
            self.position += 1
        identifier = self.source_code[start_position:self.position]
        return {'type': 'identifier', 'value': identifier}


class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.position = 0

    def parse(self):
        parsed_data = []
        while self.position < len(self.tokens):
            parsed_data.append(self.parse_statement())
        return parsed_data

    def parse_statement(self):
        variable = self.tokens[self.position]
        if variable['type'] != 'identifier':
            raise Exception('Ожидается идентификатор')
        self.position += 1

        if self.position >= len(self.tokens) or self.tokens[self.position]['value'] != '=':
            raise Exception('Ожидается оператор присваивания')
        self.position += 1

        value_token = self.tokens[self.position]
        if value_token['type'] == 'function_call':
            function_name = value_token['value']
            arguments = []
            self.position += 1
            while (
                self.position < len(self.tokens)
                and self.tokens[self.position]['type'] != 'paren'
                and self.tokens[self.position]['value'] != ')'
            ):
                argument = self.tokens[self.position]
                arguments.append(argument)
                self.position += 1
            if (
                self.position >= len(self.tokens)
                or self.tokens[self.position]['value'] != ')'
            ):
                raise Exception('Ожидается закрывающая скобка для вызова функции')
            self.position += 1
            return {
                'type': 'assignment',
                'variable': variable['value'],
                'value': {
                    'type': 'function_call',
                    'function_name': function_name,
                    'arguments': arguments
                }
            }
        elif value_token['type'] in ['string', 'number']:
            assignment = {
                'type': 'assignment',
                'variable': variable['value'],
                'value': value_token['value']
            }
            self.position += 1
            return assignment
        else:
            raise Exception('Ожидается строка, число или вызов функции')


class SemanticAnalyzer:
    def __init__(self, parsed_data):
        self.parsed_data = parsed_data

    def analyze(self):
        semantic_data = []
        for statement in self.parsed_data:
            if statement['type'] == 'assignment':
                variable = statement['variable']
                value = self.evaluate_expression(statement['value'])
                semantic_data.append({variable: value})
        return semantic_data

    def evaluate_expression(self, expression):
        if expression['type'] == 'function_call':
            function_name = expression['function_name']
            arguments = expression['arguments']
            if function_name == 'data_acquisition':
                prompt = arguments[0]['value']
                return self.data_acquisition(prompt)
            else:
                raise Exception(f'Неизвестная функция: {function_name}')
        elif expression['type'] == 'string':
            return expression['value']
        elif expression['type'] == 'number':
            return expression['value']
        else:
            raise Exception('Недопустимый тип выражения')

    def data_acquisition(self, prompt):
        return input(prompt)


class CodeGenerator:
    def __init__(self, semantic_data):
        self.semantic_data = semantic_data

    def generate(self):
        generated_code = ''
        for statement in self.semantic_data:
            variable = list(statement.keys())[0]
            value = statement[variable]
            generated_code += f"{variable} = {repr(value)}\n"
        return generated_code


class Interpreter:
    def __init__(self):
        self.lexer = None
        self.parser = None
        self.semantic_analyzer = None
        self.code_generator = None

    def interpret(self, source_code):
        self.lexer = Lexer(source_code)
        tokens = self.lexer.tokenize()

        self.parser = Parser(tokens)
        parsed_data = self.parser.parse()

        self.semantic_analyzer = SemanticAnalyzer(parsed_data)
        semantic_data = self.semantic_analyzer.analyze()

        self.code_generator = CodeGenerator(semantic_data)
        generated_code = self.code_generator.generate()

        self.execute_code(generated_code)

    def execute_code(self, code):
        exec(code, {'data_acquisition': self.semantic_analyzer.data_acquisition})


if __name__ == "__main__":
    interpreter = Interpreter()
    source_code = '''
    name = data_acquisition("Enter your name: ")
    print(name)
    '''
    interpreter.interpret(source_code)

Cпасибо!

Написано более года назад

Vindicar @Vindicar

UuuuuuuuuuuuuuuuNiX, не, ну за тебя я писать код не буду. Ресурс не для этого. Могу кое что подсказать, впрочем.
Задача парсера - превратить последовательность токенов в дерево операций. Затем программу можно будет выполнить, обойдя это дерево в глубину. Почитай про паттерн Компоновщик (Composite), он тут хорошо применим.

Один из самых простых вариантов - имея последовательность токенов и текущую позицию в ней, перебирать варианты разбора. Если вариант подошел - вставляем полученный узел в текущую последовательность дерева. Если не подошел - пробуем другой. Если ни один не подошел - у нас синтаксическая ошибка.

Проблема в том, что синтаксический узел может иметь дочерние узлы. Например, узел-ветвление содержит три дочерних узла - выражение-условие, код ветки then, код ветки else. Эти узлы могут содержать свои подузлы, и так далее. Наиболее простая (хотя и ограниченная) реализация парсера использует рекурсию для решения этой проблемы - примерно так:

def parse_statement(self, tokens: list[token], startpos: int) -> tuple[SyntaxNode, int]:
    """tokens - список токенов из лексера. startpos - номер текущего токена.
    Возвращаем собранный синтаксический узел и номер токена, до которого мы продвинулись."""
    # перебираем варианты, что может встретиться там, где есть оператор
    for variant in (self.parse_if, self.parse_assignment, ...):
        try:
            node, newpos = variant(tokens, startpos) 
        except MySyntaxError:  # твоё исключение, сигнализирующее об ошибке в синтаксисе
            pass  # вариант не подошел, пробуем еще один
        else:
            return node, newpos
    # если дошли сюда - ни один вариант не подошёл, нам дали какой-то неправильный код
    # К слову, токенизатор должен записать позицию токена в исходном коде в сам токен. 
    raise MySyntaxError(...)  # тут информация об ошибке синтаксиса

def parse_if(self, tokens: list[token], startpos: int) -> tuple[SyntaxNode, int]:
    """Этот метод пытается разобрать ветвление. У всех таких методов одинаковая сигнатура."""
    if startpos >= len(tokens) or tokens[startpos]['type'] != 'if':  # проверяем что начинается с if
        raise MySyntaxError(...)  # не начинается - отказ
    startpos += 1
    condition_node, startpos = self.parse_expression(tokens, startpos)  # парсим выражение-условие
    # может иметь смысл сделать подпрограмму или что-то подобное для такой проверки
    if startpos >= len(tokens) or tokens[startpos]['type'] != ':':  # проверяем что дальше двоеточие
        raise MySyntaxError(...)  # нет - отказ
    startpos += 1
    then_node, startpos = self.parse_statement(tokens, startpos)  # парсим ветку then
    # ну и так далее
    ...
    # в конце собираем узел SyntaxNodeIf и возвращаем
    return SyntaxNodeIf(condition_node, then_node, else_node), startpos

# далее по аналогии пишем методы parse_expression(), parse_assignment() и другие какие надо

Написано более года назад

Пригласить эксперта

Ваш ответ на вопрос

Войдите, чтобы написать ответ

Похожие вопросы

Python

+1 ещё

Простой
Как мне спарсить страницу c множеством запросов на капчу и логин?
- 1 подписчик
- 4 часа назад
- 19 просмотров
0

ответов
Python

+1 ещё

Простой
TELEGRAM API STARS как отправить?
- 1 подписчик
- 4 часа назад
- 21 просмотр
0

ответов
Python

+1 ещё

Простой
Можно ли на Python написать простой сайт без фреймворков?
- 1 подписчик
- 5 часов назад
- 80 просмотров
2

ответа
Python

Простой
Почему антивирус ругается на exe Python?
- 1 подписчик
- 11 часов назад
- 98 просмотров
3

ответа
Python

Простой
Как получить в python-redmine id issue по имени issue?
- 1 подписчик
- 14 часов назад
- 28 просмотров
1

ответ
Python

+1 ещё

Простой
Как отправить фото в группу и чат vk?
- 2 подписчика
- 14 часов назад
- 93 просмотра
0

ответов
Python

Простой
Как нарисовать ёлку вложенным циклом?
- 1 подписчик
- 23 часа назад
- 121 просмотр
2

ответа
PHP

+1 ещё

Простой
Почему при вызове Tensorflow скрипта из PHP возвращает null?
- 1 подписчик
- 26 дек.
- 107 просмотров
0

ответов
Python

Простой
Pynput как обрабатывать сочетания клавиш?
- 1 подписчик
- 26 дек.
- 40 просмотров
1

ответ
Python

+2 ещё

Простой
Ошибка при использовании метода wall.post VK api. Как исправить?
- 1 подписчик
- 25 дек.
- 49 просмотров
1

ответ
Показать ещё Загружается…

Python-разработчик

Uptrade

от 70 000 до 150 000 ₽

Python developer

Greenway Global • Новосибирск

от 150 000 ₽

Python Backend-разработчик (Middle/Senior)

РигИнтел • Пермь

от 200 000 ₽

Разработать лендинг с нуля

28 дек. 2024, в 05:33

100000 руб./за проект

Сделать рабочую копию сайта

28 дек. 2024, в 01:30

7000 руб./за проект

Написать хук для потоков которые используют GetRawInputData

28 дек. 2024, в 01:07

1500 руб./за проект

Answer 1 · 2023-06-10 19:41:50

У тебя парсер строку
name = data_acquisition("Enter your name: ")
разбирает как

name = data_acquisition  <-- присваивание
("Enter your name: ") <-- какой-то левый код

или поработай над приоритетом правил, или тщательнее определяй конец оператора.
Сейчас ты игнорируешь концы строк, а зря. Если у тебя синтаксис питоно-подобный, то они значимы.

Traceback (most recent call last), как исправить?

Войдите, чтобы написать ответ

Минуточку внимания

Войдите на сайт