批量处理前缀转后缀时输出异常，文件写入存在覆盖问题

我在实现递归式前缀表达式转后缀表达式时，遇到两个问题：

• 批量处理文件输入时输出异常，输入和输出无法正确对应
• 写入输出文件时存在内容覆盖问题：一次性复制输入内容会覆盖原有内容，希望实现输入块与对应输出块依次打印

原代码 #

import sys

def isoperator(i):  # 检查是否为运算符
    if i in ['$', '^', '*', '/', '+', '-']:
        return True
    else:
        return False

def isoperandoroperator(i):  # 检查是否为操作数或运算符
    if i.isalpha and i.isnumeric or isoperator(i):
        return True
    else:
        return False

my_list = sys.argv[1]
my_output = sys.argv[2]

def recursivepretopost(input):  # 前缀转后缀的递归方法，接收输入文件对象
    char = input.read(1)
    if char == '\n':
        return ''
    if char == ' ':
        return ''
    if isoperator(char):   # 若为运算符，递归调用检查下一个字符
        return recursivepretopost(input) + recursivepretopost(input) + char
    else:  # 若为操作数，返回该操作数
        return char

with open(my_list, 'r') as file, open(my_output, 'w') as i:  # 打开输入输出文件
    for d in file:
        i.write('Input: ' + d)
        i.write('Output: ')
        i.write(recursivepretopost(file) + '\n')

前缀表达式输入示例 #

-+ABC
-A+BC
$+-ABC+D-EF
-*A$B+C-DE*EF
**A+BC+C-BA
/A+BC +C*BA  
*-*-ABC+BA  
/+/A-BC-BA  
*$A+BC+C-BA 
//A+B0-C+BA
*$A^BC+C-BA     

当前输出 #

Input: -+ABC
Output: ABC+- 
Input: 
Output: AB-C+DEF-+$ 
Input: 
Output: ABCDE-+$*EF*- 
Input: 
Output: ABC+*CBA-+* 
Input: 
Output: ABC+/ 
Input:  +C*BA  
Output: AB-C*BA+-* 
Input:  
Output: ABC-/BA-+/ 
Input:  
Output: ABC+$CBA-+* 
Input:  
Output: AB0+/CBA+-/ 
Input: 
Output: ABC^$CBA-+* 

预期输出 #

Input: -+ABC
Output: AB+C- 
Input: -A+BC
Output: ABC+- 
Input: $+-ABC+D-EF
Output: $+-ABC+D-EF 
Input: -*A$B+C-DE*EF
Output: ABCDE-+$*EF*- 
Input: **A+BC+C-BA
Output: ABC+*CBA-+* 
Input: /A+BC +C*BA
Output: ABC+/ 
Input: *-*-ABC+BA
Output: AB-C*BA+-* 
Input: /+/A-BC-BA
Output: ABC-/BA-+/ 
Input: *$A+BC+C-BA
Output: ABC+$CBA-+* 
Input: //A+B0-C+BA
Output: AB0+/CBA+-/ 
Input: *$A^BC+C-BA
Output: ABC^$CBA-+* 

问题根源分析 #

1. 输入输出不匹配：for d in file读取一行到d后，recursivepretopost(file)会直接从当前文件指针位置继续读取（甚至跨到下一行），导致循环下一次迭代读取的是空行或剩余内容，无法和输入行一一对应。
2. 文件覆盖：用open(my_output, 'w')打开文件会清空原有内容重新写入；同时原递归逻辑直接操作文件指针，导致行处理错位，进一步加剧输出混乱。

修复方案 #

修正后代码 #

import sys

def isoperator(i):
    return i in ['$', '^', '*', '/', '+', '-']

# 修正操作数判断逻辑：原代码未调用方法，改为正确判断字母/数字
def isoperand(i):
    return i.isalpha() or i.isnumeric()

my_list = sys.argv[1]
my_output = sys.argv[2]

# 改用字符串+索引指针处理，避免文件指针错位
def recursivepretopost(expr, ptr):
    if ptr[0] >= len(expr):
        return ''
    char = expr[ptr[0]]
    ptr[0] += 1
    if char == ' ':
        return recursivepretopost(expr, ptr)
    if isoperator(char):
        left = recursivepretopost(expr, ptr)
        right = recursivepretopost(expr, ptr)
        return left + right + char
    elif isoperand(char):
        return char
    else:
        return ''

# 如需追加内容，将'w'改为'a'即可避免覆盖原有文件
with open(my_list, 'r') as file, open(my_output, 'w') as out_file:
    for line in file:
        line = line.rstrip('\n')  # 保留行内空格，移除换行符
        out_file.write(f'Input: {line}\n')
        ptr = [0]  # 用列表存储索引（可变类型，可在函数内修改）
        postfix = recursivepretopost(line, ptr)
        out_file.write(f'Output: {postfix}\n')

修复说明 #

• 递归逻辑改造：不再直接操作文件对象，改为处理单一行的字符串，用可变索引指针跟踪读取位置，确保每行处理独立，不会干扰其他行。
• 操作数判断修正：原代码中i.isalpha是方法引用而非调用，改为isoperand函数正确判断字母或数字。
• 文件写入优化：逐行处理输入内容，确保输入和输出一一对应；如需保留原有输出文件内容，将打开模式从'w'改为'a'即可避免覆盖。

内容的提问来源于stack exchange，提问作者abiwink