企业官网建设流程全解析

引言

在现代数控加工领域，数控编程语言常常包含变量和表达式，这为参数化编程提供了极大的灵活性。然而，在实际加工过程中，通常需要将参数化程序转换为具体的数值程序。本文将详细介绍如何使用Python处理包含变量的数控代码文件，实现变量替换和代码简化。

问题分析

数控代码中的变量通常以@符号开头，如@1107、@1017等。这些变量可能用于表示刀具半径补偿、加工深度等参数。变量之间可能存在依赖关系，例如：

@1017:=0.6427876096865394×@1107@1017: = 0.6427876096865394 × @1107@1017:=0.6427876096865394×@1107

@1018:=−0.766044443118978×@1107@1018: = -0.766044443118978 × @1107@1018:=−0.766044443118978×@1107

@1144:=8.21951+@1017@1144: = 8.21951 + @1017@1144:=8.21951+@1017

@1145:=94.79563+@1018@1145: = 94.79563 + @1018@1145:=94.79563+@1018

程序执行时，需要根据给定的@1107值计算所有相关变量，并将所有变量引用替换为具体数值，最终生成可直接执行的G代码。

解决方案设计

1. 基本思路

处理这类问题的核心思想是：

1. 解析数控代码文件，识别变量赋值语句和变量引用
2. 建立变量间的依赖关系，按顺序计算变量值
3. 将代码中的变量引用替换为计算后的数值
4. 清理变量赋值语句，生成简洁的G代码

2. 关键技术点

• 变量识别：使用正则表达式匹配变量格式
• 表达式计算：安全地计算包含变量的数学表达式
• 依赖关系处理：确保变量按正确顺序计算
• 代码简化：移除冗余的变量赋值语句

完整代码实现

版本1：基础处理框架

""" 数控代码变量替换处理框架 功能：读取包含变量的数控代码，替换所有变量为具体数值 作者：数控编程助手 版本：1.0 """importreimportosclassNcVariableProcessor:"""数控代码变量处理器"""def__init__(self):"""初始化处理器"""self.variables={}# 存储变量值的字典self.assignment_pattern=re.compile(r'@(\d+):\s*=\s*(.+);')# 匹配变量赋值self.var_ref_pattern=re.compile(r'@(\d+)')# 匹配变量引用defset_variable(self,var_name,value):"""设置变量值 Args: var_name: 变量名（不带@符号） value: 变量值 """self.variables[str(var_name)]=float(value)defcompute_expression(self,expression):"""计算数学表达式 Args: expression: 包含变量引用的表达式字符串 Returns: float: 计算结果 """# 替换表达式中的变量引用defreplace_var(match):var_name=match.group(1)ifvar_nameinself.variables:returnstr(self.variables[var_name])else:raiseValueError(f"未定义的变量: @{var_name}")# 替换所有变量引用expr=self.var_ref_pattern.sub(replace_var,expression)try:# 安全计算表达式result=eval(expr,{"__builtins__":{}},{})returnfloat(result)exceptExceptionase:raiseValueError(f"表达式计算错误:{expression}->{e}")defprocess_line(self,line):"""处理单行代码 Args: line: 输入行字符串 Returns: tuple: (处理后的行, 是否输出该行) """line=line.rstrip()# 跳过空行和注释ifnotlineorline.startswith('%'):returnline,True# 检查是否是变量赋值语句match=self.assignment_pattern.match(line)ifmatch:var_name=match.group(1)expression=match.group(2)try:# 计算变量值value=self.compute_expression(expression)self.variables[var_name]=valuereturnNone,False# 不输出赋值语句exceptValueErrorase:print(f"警告:{e}")returnline,True# 处理非赋值语句，替换变量引用defreplace_in_code(match):var_name=match.group(1)ifvar_nameinself.variables:returnf"{self.variables[var_name]:.5f}"else:returnmatch.group(0)# 保持原样processed_line=self.var_ref_pattern.sub(replace_in_code,line)returnprocessed_line,Truedefprocess_file(self,input_file,output_file,initial_vars=None):"""处理整个文件 Args: input_file: 输入文件名 output_file: 输出文件名 initial_vars: 初始变量字典 {变量名: 值} """# 初始化变量ifinitial_vars:forvar_name,valueininitial_vars.items():self.set_variable(var_name,value)# 读取文件try:withopen(input_file,'r',encoding='utf-8')asf:lines=f.readlines()exceptUnicodeDecodeError:withopen(input_file,'r',encoding='gbk')asf:lines=f.readlines()# 处理每一行processed_lines=[]fori,lineinenumerate(lines,1):try:processed_line,should_output=self.process_line(line)ifshould_outputandprocessed_lineisnotNone:processed_lines.append(processed_line)exceptExceptionase:print(f"第{i}行处理错误:{e}")processed_lines.append(line)# 保持原行# 写入输出文件withopen(output_file,'w',encoding='utf-8')asf:f.write('\n'.join(processed_lines))print(f"处理完成:{input_file}->{output_file}")print(f"处理的变量数:{len(self.variables)}")# 使用示例if__name__=="__main__":# 创建处理器processor=NcVariableProcessor()# 设置初始变量（例如@1107的值）processor.set_variable('1107',10.0)# 处理文件input_file="01001.txt"output_file="processed_nc.txt"ifos.path.exists(input_file):processor.process_file(input_file,output_file)# 显示变量计算结果print("\n变量计算结果:")forvar_name,valueinsorted(processor.variables.items()):print(f" @{var_name}={value:.10f}")else:print(f"文件不存在:{input_file}")

版本2：增强型变量处理器

""" 增强型数控代码变量处理器 功能：支持更复杂的表达式和批量处理 版本：2.0 """importreimportosimportmathclassEnhancedNcProcessor:"""增强型数控代码处理器"""def__init__(self):"""初始化处理器"""self.variables={}self.lines_processed=0self.errors=[]# 编译正则表达式self.assign_regex=re.compile(r'@(\d+):\s*=\s*(.+?)(?=;|$)')self.var_regex=re.compile(r'@(\d+)')# 支持的数学函数self.safe_dict={'sin':math.sin,'cos':math.cos,'tan':math.tan,'asin':math.asin,'acos':math.acos,'atan':math.atan,'sqrt':math.sqrt,'exp':math.exp,'log':math.log,'log10':math.log10,'pi':math.pi,'e':math.e,'abs':abs,'round':round,'int':int,'float':float}defadd_variable(self,name,value):"""添加或修改变量 Args: name: 变量名 value: 变量值 """self.variables[str(name)]=float(value)defevaluate_expression(self,expr):"""安全地计算表达式 Args: expr: 表达式字符串 Returns: float: 计算结果 """# 替换变量引用defreplace_var(match):var_name=match.group(1)ifvar_nameinself.variables:returnstr(self.variables[var_name])raiseNameError(f"变量 @{var_name}未定义")# 替换所有变量引用whileTrue:new_expr=self.var_regex.sub(replace_var,expr)ifnew_expr==expr:breakexpr=new_exprtry:# 安全计算result=eval(expr,{"__builtins__":None},self.safe_dict)returnfloat(result)exceptExceptionase:raiseValueError(f"表达式 '{expr}' 计算失败:{e}")defparse_assignments(self,line):"""解析行中的赋值语句 Args: line: 输入行 Returns: tuple: (非赋值部分, 赋值语句列表) """assignments=[]remaining=line# 查找所有赋值语句pos=0whileTrue:match=self.assign_regex.search(remaining[pos:])ifnotmatch:break# 提取赋值语句full_match=match.group(0)var_name=match.group(1)expression=match.group(2).strip()assignments.append((var_name,expression))# 更新位置pos+=match.end()# 如果后面是分号，跳过ifpos<len(remaining)andremaining[pos]==';':pos+=1# 获取非赋值部分non_assign=remaining[pos:]ifpos<len(remaining)else''returnnon_assign.strip(),assignmentsdefprocess_single_line(self,line):"""处理单行代码 Args: line: 输入行 Returns: str: 处理后的行 """self.lines_processed+=1# 移除首尾空白line=line.strip()# 处理特殊行ifnotlineorline.startswith('%')orline.startswith('('):returnline# 解析赋值语句non_assign_part,assignments=self.parse_assignments(line)# 处理赋值语句forvar_name,expressioninassignments:try:value=self.evaluate_expression(expression)self.add_variable(var_name,value)exceptExceptionase:self.errors.append(f"第{self.lines_processed}行: @{var_name}赋值失败 -{e}")# 替换非赋值部分中的变量引用defreplace_vars_in_text(text):defrepl(match):var_name=match.group(1)ifvar_nameinself.variables:# 根据上下文决定精度if'G00'intextor'G01'intext:returnf"{self.variables[var_name]:.5f}"else:returnf"{self.variables[var_name]}"returnmatch.group(0)returnself.var_regex.sub(repl,text)# 处理非赋值部分processed_non_assign=replace_vars_in_text(non_assign_part)# 清理多余的分号ifprocessed_non_assign.endswith(';'):processed_non_assign=processed_non_assign.rstrip(';')returnprocessed_non_assigndefbatch_process(self,input_files,output_dir,initial_vars=None):"""批量处理多个文件 Args: input_files: 输入文件列表 output_dir: 输出目录 initial_vars: 初始变量字典 """# 创建输出目录os.makedirs(output_dir,exist_ok=True)# 设置初始变量ifinitial_vars:forname,valueininitial_vars.items():self.add_variable(name,value)results=[]forinput_fileininput_files:ifnotos.path.exists(input_file):print(f"警告: 文件不存在{input_file}")continue# 重置处理器状态（保留初始变量）current_vars=self.variables.copy()self.variables=initial_vars.copy()ifinitial_varselse{}self.errors=[]# 处理文件output_file=os.path.join(output_dir,f"proc_{os.path.basename(input_file)}")withopen(input_file,'r',encoding='utf-8')asf:input_lines=f.readlines()output_lines=[]forlineininput_lines:processed=self.process_single_line(line)ifprocessed:# 只添加非空行output_lines.append(processed)# 写入输出文件withopen(output_file,'w',encoding='utf-8')asf:f.write('\n'.join(output_lines))# 恢复变量self.variables=current_vars# 记录结果results.append({'input':input_file,'output':output_file,'lines':len(output_lines),'variables':len(self.variables),'errors':self.errors.copy()})print(f"✓ 已处理:{input_file}->{output_file}")returnresults# 使用示例if__name__=="__main__":# 创建处理器processor=EnhancedNcProcessor()# 设置初始变量initial_variables={'1107':5.0,# 示例值'1001':10.0,# 可以设置多个初始变量}# 要处理的文件列表input_files=["01001.txt","01002.txt"]# 假设有多个文件# 批量处理output_dir="processed_files"results=processor.batch_process(input_files,output_dir,initial_variables)# 显示处理结果print(f"\n处理完成！共处理{len(results)}个文件")print(f"输出目录:{output_dir}")# 显示汇总信息total_errors=sum(len(r['errors'])forrinresults)iftotal_errors>0:print(f"\n发现{total_errors}个错误:")forresultinresults:forerrorinresult['errors']:print(f"{error}")else:print("\n所有文件处理成功，无错误！")

版本3：优化版G代码生成器

""" 优化版G代码生成器 功能：生成简洁、格式化的G代码 版本：3.0 """importreimportosfromdatetimeimportdatetimeclassGCodeOptimizer:"""G代码优化器"""def__init__(self,precision=5):"""初始化优化器 Args: precision: 数值精度（小数位数） """self.precision=precision self.variables={}self.macro_definitions={}# 编译正则表达式self.macro_pattern=re.compile(r'%\s*@MACRO\s*;',re.IGNORECASE)self.assign_pattern=re.compile(r'@(\d+)\s*:\s*=\s*(.+?)\s*(;|$)')self.var_pattern=re.compile(r'@(\d+)')self.gcode_pattern=re.compile(r'([GXYZABCUF]\s*[-]?\d*\.?\d+)',re.IGNORECASE)defset_variable(self,name,value):"""设置变量值 Args: name: 变量名 value: 变量值 """self.variables[str(name)]=float(value)defformat_number(self,number):"""格式化数字 Args: number: 输入数字 Returns: str: 格式化后的字符串 """returnf"{float(number):.{self.precision}f}".rstrip('0').rstrip('.')defevaluate_expression(self,expression):"""计算表达式 Args: expression: 表达式字符串 Returns: float: 计算结果 """# 替换变量引用defreplace_match(match):var_name=match.group(1)ifvar_nameinself.variables:returnstr(self.variables[var_name])returnmatch.group(0)expr=self.var_pattern.sub(replace_match,expression)try:# 安全计算result=eval(expr,{"__builtins__":{}},{})returnfloat(result)exceptExceptionase:raiseValueError(f"表达式错误:{expression}->{e}")defparse_line(self,line):"""解析行内容 Args: line: 输入行 Returns: dict: 解析结果 """line=line.strip()result={'original':line,'is_macro':False,'is_comment':False,'is_assignment':False,'is_gcode':False,'assignments':[],'gcode_commands':[],'processed':line}# 检查宏定义ifself.macro_pattern.match(line):result['is_macro']=Trueresult['processed']=f"% MACRO PROCESSED AT{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"returnresult# 检查注释ifline.startswith('%')orline.startswith('(')orline.startswith(';'):result['is_comment']=Truereturnresult# 检查赋值语句assignments=[]remaining=line# 查找所有赋值语句whileTrue:match=self.assign_pattern.search(remaining)ifnotmatch:breakvar_name=match.group(1)expression=match.group(2)assignments.append({'var_name':var_name,'expression':expression,'full_match':match.group(0)})# 移除已匹配的部分remaining=remaining[:match.start()]+remaining[match.end():]ifassignments:result['is_assignment']=Trueresult['assignments']=assignments# 检查G代码gcode_matches=list(self.gcode_pattern.finditer(remaining))ifgcode_matches:result['is_gcode']=Trueresult['gcode_commands']=[m.group(1)formingcode_matches]# 处理剩余部分（可能包含变量引用）ifremaining.strip():# 替换变量引用defreplace_vars(match):var_name=match.group(1)ifvar_nameinself.variables:returnself.format_number(self.variables[var_name])returnmatch.group(0)processed=self.var_pattern.sub(replace_vars,remaining)result['processed']=processed.strip()returnresultdefoptimize_gcode_block(self,commands):"""优化G代码块 Args: commands: G代码命令列表 Returns: str: 优化后的G代码行 """ifnotcommands:return""# 按字母排序并合并grouped={}forcmdincommands:# 提取命令字母和值letter=cmd[0].upper()value=cmd[1:].strip()# 保留原始值，格式化在最后进行grouped[letter]=value# 构建优化后的字符串# G命令放在最前面ordered_keys=[]if'G'ingrouped:ordered_keys.append('G')# 然后是运动坐标foraxisin['X','Y','Z','A','B','C']:ifaxisingrouped:ordered_keys.append(axis)# 最后是其他参数forkeyinsorted(grouped.keys()):ifkeynotinordered_keys:ordered_keys.append(key)# 生成优化后的命令optimized_parts=[]forkeyinordered_keys:try:value=float(grouped[key])formatted=self.format_number(value)optimized_parts.append(f"{key}{formatted}")except:optimized_parts.append(f"{key}{grouped[key]}")return' '.join(optimized_parts)defprocess_file(self,input_file,output_file,initial_vars=None):"""处理文件 Args: input_file: 输入文件 output_file: 输出文件 initial_vars: 初始变量 """# 设置初始变量ifinitial_vars:forname,valueininitial_vars.items():self.set_variable(name,value)# 读取文件try:withopen(input_file,'r',encoding='utf-8')asf:lines=f.readlines()except:withopen(input_file,'r',encoding='gbk')asf:lines=f.readlines()# 处理每一行processed_lines=[]line_stats={'total':0,'comments':0,'assignments':0,'gcode':0,'macros':0,'errors':0}forline_num,lineinenumerate(lines,1):line_stats['total']+=1try:# 解析行parsed=self.parse_line(line)# 处理赋值语句ifparsed['is_assignment']:line_stats['assignments']+=1forassigninparsed['assignments']:try:value=self.evaluate_expression(assign['expression'])self.set_variable(assign['var_name'],value)exceptExceptionase:print(f"第{line_num}行警告:{e}")line_stats['errors']+=1# 处理G代码elifparsed['is_gcode']:line_stats['gcode']+=1# 如果有G代码命令，进行优化ifparsed['gcode_commands']:optimized=self.optimize_gcode_block(parsed['gcode_commands'])# 如果有其他内容，添加到优化后的G代码后面other_content=parsed['processed']ifother_contentandnotother_content.startswith(tuple('GXYZABC')):ifoptimized:processed_line=f"{optimized};{other_content}"else:processed_line=other_contentelse:processed_line=optimizedifoptimizedelseother_contentifprocessed_line:processed_lines.append(processed_line)# 处理宏和注释elifparsed['is_macro']:line_stats['macros']+=1processed_lines.append(parsed['processed'])elifparsed['is_comment']:line_stats['comments']+=1processed_lines.append(parsed['original'])else:# 其他内容ifparsed['processed']:processed_lines.append(parsed['processed'])exceptExceptionase:print(f"第{line_num}行错误:{e}")processed_lines.append(line)# 保持原行line_stats['errors']+=1# 添加文件头注释header=[f"% Generated by GCodeOptimizer v3.0",f"% Source:{os.path.basename(input_file)}",f"% Processed:{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",f"% Variables used:{len(self.variables)}",f"% Precision:{self.precision}decimal places",f"%"]# 写入输出文件withopen(output_file,'w',encoding='utf-8')asf:f.write('\n'.join(header+['']+processed_lines))# 显示统计信息print(f"\n=== 处理统计 ===")print(f"输入文件:{input_file}")print(f"输出文件:{output_file}")print(f"总行数:{line_stats['total']}")print(f"G代码行:{line_stats['gcode']}")print(f"赋值语句:{line_stats['assignments']}")print(f"注释/宏:{line_stats['comments']+line_stats['macros']}")print(f"错误数:{line_stats['errors']}")print(f"压缩率:{(1-len(processed_lines)/line_stats['total'])*100:.1f}%")return{'stats':line_stats,'variables':self.variables,'output_file':output_file}# 使用示例if__name__=="__main__":# 创建优化器optimizer=GCodeOptimizer(precision=5)# 设置初始变量initial_vars={'1107':15.5}# 可根据需要修改# 输入输出文件input_file="01001.txt"output_file="optimized_nc.txt"ifos.path.exists(input_file):# 处理文件result=optimizer.process_file(input_file,output_file,initial_vars)# 显示变量值print(f"\n=== 变量值 ===")forvar_name,valueinsorted(result['variables'].items()):print(f"@{var_name}={value:.{optimizer.precision}f}")# 显示输出文件前10行print(f"\n=== 输出文件预览 ===")withopen(output_file,'r')asf:foriinrange(10):line=f.readline()ifnotline:breakprint(line.rstrip())else:print(f"输入文件不存在:{input_file}")

版本4：完整应用示例

""" 数控代码批量处理工具 功能：完整的数控代码处理流水线 版本：4.0 """importosimportsysimportjsonimportloggingfromdatetimeimportdatetime# 配置日志logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(message)s',handlers=[logging.FileHandler('nc_processor.log'),logging.StreamHandler(sys.stdout)])classNcProcessingPipeline:"""数控代码处理流水线"""def__init__(self,config_file=None):"""初始化流水线 Args: config_file: 配置文件路径 """self.config=self.load_config(config_file)self.processors=[]self.results=[]# 设置默认配置self.default_config={'precision':5,'remove_comments':False,'optimize_gcode':True,'output_format':'txt','backup_original':True,'log_level':'INFO'}ifself.config:self.default_config.update(self.config)self.config=self.default_config logging.info(f"数控代码处理流水线已初始化，配置:{self.config}")defload_config(self,config_file):"""加载配置文件 Args: config_file: 配置文件路径 Returns: dict: 配置字典 """ifconfig_fileandos.path.exists(config_file):try:withopen(config_file,'r')asf:returnjson.load(f)exceptExceptionase:logging.error(f"配置文件加载失败:{e}")return{}return{}defvalidate_input_file(self,file_path):"""验证输入文件 Args: file_path: 文件路径 Returns: bool: 是否有效 """ifnotos.path.exists(file_path):logging.error(f"文件不存在:{file_path}")returnFalseifnotfile_path.lower().endswith(('.txt','.nc','.cnc')):logging.warning(f"文件扩展名可能不受支持:{file_path}")# 检查文件大小（不超过10MB）ifos.path.getsize(file_path)>10*1024*1024:logging.error(f"文件过大:{file_path}")returnFalsereturnTruedefparse_variable_assignments(self,content):"""解析变量赋值语句 Args: content: 文件内容 Returns: dict: 变量依赖关系 """importre# 匹配变量赋值pattern=re.compile(r'@(\d+)\s*:\s*=\s*(.+?)(?=;|\n|$)')assignments={}formatchinpattern.finditer(content):var_name=match.group(1)expression=match.group(2).strip()# 提取依赖的变量deps=re.findall(r'@(\d+)',expression)assignments[var_name]={'expression':expression,'dependencies':list(set(deps)),'computed':False,'value':None}returnassignmentsdefcompute_variable_values(self,assignments,initial_values):"""计算变量值 Args: assignments: 变量赋值字典 initial_values: 初始变量值 Returns: dict: 计算后的变量值 """importre# 初始化变量值computed={}computed.update(initial_values)# 标记已计算的变量forvar_nameininitial_values:ifvar_nameinassignments:assignments[var_name]['computed']=Trueassignments[var_name]['value']=initial_values[var_name]# 计算顺序max_iterations=len(assignments)*2# 防止无限循环iteration=0whileiteration<max_iterations:iteration+=1progress=Falseforvar_name,infoinassignments.items():ifinfo['computed']:continue# 检查依赖是否都已计算deps_computed=all(depincomputedfordepininfo['dependencies'])ifdeps_computed:try:# 替换表达式中的变量引用expression=info['expression']fordepininfo['dependencies']:expression=expression.replace(f'@{dep}',str(computed[dep]))# 计算表达式value=eval(expression,{"__builtins__":{}},{})computed[var_name]=float(value)info['computed']=Trueinfo['value']=value progress=Truelogging.debug(f"计算变量 @{var_name}={expression}={value}")exceptExceptionase:logging.error(f"变量 @{var_name}计算失败:{e}")# 使用默认值0computed[var_name]=0.0info['computed']=Trueinfo['value']=0.0progress=Trueifnotprogress:break# 检查未计算的变量forvar_name,infoinassignments.items():ifnotinfo['computed']:logging.warning(f"变量 @{var_name}未计算，使用默认值0")computed[var_name]=0.0returncomputeddefprocess_single_file(self,input_file,output_file=None,initial_values=None):"""处理单个文件 Args: input_file: 输入文件 output_file: 输出文件 initial_values: 初始变量值 Returns: dict: 处理结果 """start_time=datetime.now()# 验证文件ifnotself.validate_input_file(input_file):return{'status':'error','message':f'文件验证失败:{input_file}'}# 默认输出文件名ifnotoutput_file:base_name=os.path.splitext(os.path.basename(input_file))[0]output_file=f"{base_name}_processed.{self.config['output_format']}"# 备份原文件ifself.config['backup_original']:backup_file=f"{input_file}.backup"try:importshutil shutil.copy2(input_file,backup_file)logging.info(f"已备份原文件:{backup_file}")exceptExceptionase:logging.warning(f"文件备份失败:{e}")try:# 读取文件withopen(input_file,'r',encoding='utf-8')asf:content=f.read()# 解析变量赋值assignments=self.parse_variable_assignments(content)logging.info(f"解析到{len(assignments)}个变量赋值")# 计算变量值initial_values=initial_valuesor{}computed_values=self.compute_variable_values(assignments,initial_values)logging.info(f"计算了{len(computed_values)}个变量值")# 替换变量引用importre var_pattern=re.compile(r'@(\d+)')defreplace_var(match):var_name=match.group(1)ifvar_nameincomputed_values:value=computed_values[var_name]# 根据精度格式化returnf"{value:.{self.config['precision']}f}"returnmatch.group(0)# 替换所有变量引用processed_content=var_pattern.sub(replace_var,content)# 移除变量赋值语句（可选）ifself.config.get('remove_assignments',True):assignment_pattern=re.compile(r'@\d+\s*:\s*=.*?(?=;|\n|$);?')processed_content=assignment_pattern.sub('',processed_content)# 移除注释（可选）ifself.config.get('remove_comments',False):# 移除%注释processed_content=re.sub(r'%.*?(?=\n|$)','',processed_content)# 移除()注释processed_content=re.sub(r'\(.*?\)','',processed_content)# 优化G代码格式ifself.config.get('optimize_gcode',True):# 合并多空格processed_content=re.sub(r'\s+',' ',processed_content)# 清理多余的分号processed_content=re.sub(r';\s*;',';',processed_content)# 移除空行lines=processed_content.split('\n')processed_lines=[line.strip()forlineinlinesifline.strip()]processed_content='\n'.join(processed_lines)# 写入输出文件withopen(output_file,'w',encoding='utf-8')asf:f.write(processed_content)# 计算处理时间end_time=datetime.now()duration=(end_time-start_time).total_seconds()# 收集结果result={'status':'success','input_file':input_file,'output_file':output_file,'original_size':len(content),'processed_size':len(processed_content),'variables_found':len(assignments),'variables_computed':len(computed_values),'processing_time':duration,'compression_ratio':(1-len(processed_content)/len(content))*100,'timestamp':end_time.isoformat()}logging.info(f"文件处理完成:{input_file}->{output_file}")logging.info(f"处理统计:{result}")returnresultexceptExceptionase:logging.error(f"文件处理失败{input_file}:{e}")return{'status':'error','message':str(e),'input_file':input_file}defprocess_batch(self,input_files,output_dir=None,initial_values=None):"""批量处理文件 Args: input_files: 输入文件列表 output_dir: 输出目录 initial_values: 初始变量值 Returns: list: 处理结果列表 """results=[]# 创建输出目录ifoutput_dir:os.makedirs(output_dir,exist_ok=True)total_files=len(input_files)successful=0failed=0logging.info(f"开始批量处理{total_files}个文件")fori,input_fileinenumerate(input_files,1):logging.info(f"处理文件{i}/{total_files}:{input_file}")# 确定输出文件路径ifoutput_dir:base_name=os.path.basename(input_file)output_file=os.path.join(output_dir,f"proc_{base_name}")else:output_file=None# 处理文件result=self.process_single_file(input_file,output_file,initial_values)# 更新统计ifresult['status']=='success':successful+=1else:failed+=1results.append(result)# 显示进度progress=(i/total_files)*100logging.info(f"进度:{progress:.1f}% | 成功:{successful}| 失败:{failed}")# 生成汇总报告summary={'total_files':total_files,'successful':successful,'failed':failed,'success_rate':(successful/total_files*100)iftotal_files>0else0,'total_processing_time':sum(r.get('processing_time',0)forrinresultsifr['status']=='success'),'average_compression':sum(r.get('compression_ratio',0)forrinresultsifr['status']=='success')/successfulifsuccessful>0else0,'timestamp':datetime.now().isoformat()}logging.info(f"批量处理完成，汇总:{summary}")# 保存结果到JSON文件report_file=f"processing_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"withopen(report_file,'w')asf:json.dump({'config':self.config,'summary':summary,'results':results},f,indent=2)logging.info(f"详细报告已保存到:{report_file}")returnresults,summarydefgenerate_variable_report(self,input_file):"""生成变量分析报告 Args: input_file: 输入文件 Returns: dict: 变量报告 """ifnotself.validate_input_file(input_file):returnNonetry:withopen(input_file,'r')asf:content=f.read()# 解析变量assignments=self.parse_variable_assignments(content)# 提取所有变量引用importre all_var_refs=re.findall(r'@(\d+)',content)var_usage={}forvarinset(all_var_refs):var_usage[var]=all_var_refs.count(var)# 分析变量类型numeric_vars=[]expression_vars=[]forvar_name,infoinassignments.items():ifre.match(r'^[-+]?\d*\.?\d+$',info['expression'].strip()):numeric_vars.append(var_name)else:expression_vars.append(var_name)# 构建报告report={'file':input_file,'total_variables':len(set(all_var_refs)),'variable_assignments':len(assignments),'variable_usage':var_usage,'numeric_variables':numeric_vars,'expression_variables':expression_vars,'dependency_depth':self.calculate_dependency_depth(assignments),'recommendations':self.generate_recommendations(assignments,var_usage)}returnreportexceptExceptionase:logging.error(f"变量分析失败:{e}")returnNonedefcalculate_dependency_depth(self,assignments):"""计算变量依赖深度 Args: assignments: 变量赋值字典 Returns: dict: 每个变量的依赖深度 """depths={}defget_depth(var_name,visited=None):ifvisitedisNone:visited=set()ifvar_nameinvisited:return0# 循环依赖ifvar_namenotinassignments:return0ifvar_nameindepths:returndepths[var_name]visited.add(var_name)max_depth=0fordepinassignments[var_name]['dependencies']:depth=get_depth(dep,visited.copy())max_depth=max(max_depth,depth)depths[var_name]=max_depth+1returndepths[var_name]forvar_nameinassignments:get_depth(var_name)returndepthsdefgenerate_recommendations(self,assignments,var_usage):"""生成优化建议 Args: assignments: 变量赋值 var_usage: 变量使用统计 Returns: list: 建议列表 """recommendations=[]# 检查未使用的变量forvar_nameinassignments:ifvar_namenotinvar_usageorvar_usage[var_name]<=1:recommendations.append(f"变量 @{var_name}使用次数少，考虑内联或删除")# 检查简单表达式importreforvar_name,infoinassignments.items():iflen(info['dependencies'])==0andre.match(r'^[-+]?\d*\.?\d+$',info['expression']):recommendations.append(f"变量 @{var_name}为常量，可直接替换为{info['expression']}")# 检查复杂依赖depths=self.calculate_dependency_depth(assignments)forvar_name,depthindepths.items():ifdepth>3:recommendations.append(f"变量 @{var_name}依赖链深度为{depth}，考虑简化")returnrecommendations# 主程序入口defmain():"""主函数"""print("="*60)print("数控代码变量处理工具 v4.0")print("="*60)# 创建流水线pipeline=NcProcessingPipeline()# 示例：处理单个文件input_file="01001.txt"ifos.path.exists(input_file):print(f"\n1. 分析文件:{input_file}")# 生成变量报告report=pipeline.generate_variable_report(input_file)ifreport:print(f" 发现{report['total_variables']}个变量")print(f" 变量赋值语句:{report['variable_assignments']}")print(f" 建议:{len(report['recommendations'])}条")# 显示前5个最常用的变量sorted_usage=sorted(report['variable_usage'].items(),key=lambdax:x[1],reverse=True)[:5]print(f" 最常用的变量:")forvar,countinsorted_usage:print(f" @{var}: 使用{count}次")print(f"\n2. 处理文件")# 设置初始变量值initial_values={'1107':10.0}# 根据实际情况修改# 处理文件result=pipeline.process_single_file(input_file=input_file,output_file="processed_output.txt",initial_values=initial_values)ifresult['status']=='success':print(f" 处理成功!")print(f" 输出文件:{result['output_file']}")print(f" 处理时间:{result['processing_time']:.2f}秒")print(f" 压缩率:{result['compression_ratio']:.1f}%")else:print(f" 处理失败:{result['message']}")else:print(f"\n文件{input_file}不存在")print("\n创建示例文件...")# 创建示例文件example_content="""% 示例数控代码 G58; G90 G00 B-50.00000; @1017: = 0.6427876096865394*@1107; @1018: = -0.766044443118978*@1107; @1144: = 8.21951 + @1017; @1145: = 94.79563 + @1018; G00 Z@1145; G00 X@1144; G00 Y60.12500; G00 C0.00000; G01 Y50.12500 X@1144 Z@1145 C0.00000 F1000.0;"""withopen("example_nc.txt","w")asf:f.write(example_content)print("已创建 example_nc.txt 文件")print("\n"+"="*60)print("处理完成！")print("="*60)if__name__=="__main__":main()