机械做网站好处wordpress安装配置文件

机械做网站好处,wordpress安装配置文件,电子商务网站建设实战,好看的网站的导航怎么做引言 在现代数控加工领域#xff0c;数控编程语言常常包含变量和表达式#xff0c;这为参数化编程提供了极大的灵活性。然而#xff0c;在实际加工过程中#xff0c;通常需要将参数化程序转换为具体的数值程序。本文将详细介绍如何使用Python处理包含变量的数控代码文件数控编程语言常常包含变量和表达式这为参数化编程提供了极大的灵活性。然而在实际加工过程中通常需要将参数化程序转换为具体的数值程序。本文将详细介绍如何使用Python处理包含变量的数控代码文件实现变量替换和代码简化。问题分析数控代码中的变量通常以符号开头如1107、1017等。这些变量可能用于表示刀具半径补偿、加工深度等参数。变量之间可能存在依赖关系例如1017:0.6427876096865394×11071017: 0.6427876096865394 × 11071017:0.6427876096865394×11071018:−0.766044443118978×11071018: -0.766044443118978 × 11071018:−0.766044443118978×11071144:8.2195110171144: 8.21951 10171144:8.2195110171145:94.7956310181145: 94.79563 10181145:94.795631018程序执行时需要根据给定的1107值计算所有相关变量并将所有变量引用替换为具体数值最终生成可直接执行的G代码。解决方案设计1. 基本思路处理这类问题的核心思想是解析数控代码文件识别变量赋值语句和变量引用建立变量间的依赖关系按顺序计算变量值将代码中的变量引用替换为计算后的数值清理变量赋值语句生成简洁的G代码2. 关键技术点变量识别使用正则表达式匹配变量格式表达式计算安全地计算包含变量的数学表达式依赖关系处理确保变量按正确顺序计算代码简化移除冗余的变量赋值语句完整代码实现版本1基础处理框架 数控代码变量替换处理框架 功能读取包含变量的数控代码替换所有变量为具体数值 作者数控编程助手 版本1.0 importreimportosclassNcVariableProcessor:数控代码变量处理器def__init__(self):初始化处理器self.variables{}# 存储变量值的字典self.assignment_patternre.compile(r(\d):\s*\s*(.);)# 匹配变量赋值self.var_ref_patternre.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_namematch.group(1)ifvar_nameinself.variables:returnstr(self.variables[var_name])else:raiseValueError(f未定义的变量: {var_name})# 替换所有变量引用exprself.var_ref_pattern.sub(replace_var,expression)try:# 安全计算表达式resulteval(expr,{__builtins__:{}},{})returnfloat(result)exceptExceptionase:raiseValueError(f表达式计算错误:{expression}-{e})defprocess_line(self,line):处理单行代码 Args: line: 输入行字符串 Returns: tuple: (处理后的行, 是否输出该行) lineline.rstrip()# 跳过空行和注释ifnotlineorline.startswith(%):returnline,True# 检查是否是变量赋值语句matchself.assignment_pattern.match(line)ifmatch:var_namematch.group(1)expressionmatch.group(2)try:# 计算变量值valueself.compute_expression(expression)self.variables[var_name]valuereturnNone,False# 不输出赋值语句exceptValueErrorase:print(f警告:{e})returnline,True# 处理非赋值语句替换变量引用defreplace_in_code(match):var_namematch.group(1)ifvar_nameinself.variables:returnf{self.variables[var_name]:.5f}else:returnmatch.group(0)# 保持原样processed_lineself.var_ref_pattern.sub(replace_in_code,line)returnprocessed_line,Truedefprocess_file(self,input_file,output_file,initial_varsNone):处理整个文件 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,encodingutf-8)asf:linesf.readlines()exceptUnicodeDecodeError:withopen(input_file,r,encodinggbk)asf:linesf.readlines()# 处理每一行processed_lines[]fori,lineinenumerate(lines,1):try:processed_line,should_outputself.process_line(line)ifshould_outputandprocessed_lineisnotNone:processed_lines.append(processed_line)exceptExceptionase:print(f第{i}行处理错误:{e})processed_lines.append(line)# 保持原行# 写入输出文件withopen(output_file,w,encodingutf-8)asf:f.write(\n.join(processed_lines))print(f处理完成:{input_file}-{output_file})print(f处理的变量数:{len(self.variables)})# 使用示例if__name____main__:# 创建处理器processorNcVariableProcessor()# 设置初始变量例如1107的值processor.set_variable(1107,10.0)# 处理文件input_file01001.txtoutput_fileprocessed_nc.txtifos.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_processed0self.errors[]# 编译正则表达式self.assign_regexre.compile(r(\d):\s*\s*(.?)(?;|$))self.var_regexre.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_namematch.group(1)ifvar_nameinself.variables:returnstr(self.variables[var_name])raiseNameError(f变量 {var_name}未定义)# 替换所有变量引用whileTrue:new_exprself.var_regex.sub(replace_var,expr)ifnew_exprexpr:breakexprnew_exprtry:# 安全计算resulteval(expr,{__builtins__:None},self.safe_dict)returnfloat(result)exceptExceptionase:raiseValueError(f表达式 {expr} 计算失败:{e})defparse_assignments(self,line):解析行中的赋值语句 Args: line: 输入行 Returns: tuple: (非赋值部分, 赋值语句列表) assignments[]remainingline# 查找所有赋值语句pos0whileTrue:matchself.assign_regex.search(remaining[pos:])ifnotmatch:break# 提取赋值语句full_matchmatch.group(0)var_namematch.group(1)expressionmatch.group(2).strip()assignments.append((var_name,expression))# 更新位置posmatch.end()# 如果后面是分号跳过ifposlen(remaining)andremaining[pos];:pos1# 获取非赋值部分non_assignremaining[pos:]ifposlen(remaining)elsereturnnon_assign.strip(),assignmentsdefprocess_single_line(self,line):处理单行代码 Args: line: 输入行 Returns: str: 处理后的行 self.lines_processed1# 移除首尾空白lineline.strip()# 处理特殊行ifnotlineorline.startswith(%)orline.startswith(():returnline# 解析赋值语句non_assign_part,assignmentsself.parse_assignments(line)# 处理赋值语句forvar_name,expressioninassignments:try:valueself.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_namematch.group(1)ifvar_nameinself.variables:# 根据上下文决定精度ifG00intextorG01intext:returnf{self.variables[var_name]:.5f}else:returnf{self.variables[var_name]}returnmatch.group(0)returnself.var_regex.sub(repl,text)# 处理非赋值部分processed_non_assignreplace_vars_in_text(non_assign_part)# 清理多余的分号ifprocessed_non_assign.endswith(;):processed_non_assignprocessed_non_assign.rstrip(;)returnprocessed_non_assigndefbatch_process(self,input_files,output_dir,initial_varsNone):批量处理多个文件 Args: input_files: 输入文件列表 output_dir: 输出目录 initial_vars: 初始变量字典 # 创建输出目录os.makedirs(output_dir,exist_okTrue)# 设置初始变量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_varsself.variables.copy()self.variablesinitial_vars.copy()ifinitial_varselse{}self.errors[]# 处理文件output_fileos.path.join(output_dir,fproc_{os.path.basename(input_file)})withopen(input_file,r,encodingutf-8)asf:input_linesf.readlines()output_lines[]forlineininput_lines:processedself.process_single_line(line)ifprocessed:# 只添加非空行output_lines.append(processed)# 写入输出文件withopen(output_file,w,encodingutf-8)asf:f.write(\n.join(output_lines))# 恢复变量self.variablescurrent_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__:# 创建处理器processorEnhancedNcProcessor()# 设置初始变量initial_variables{1107:5.0,# 示例值1001:10.0,# 可以设置多个初始变量}# 要处理的文件列表input_files[01001.txt,01002.txt]# 假设有多个文件# 批量处理output_dirprocessed_filesresultsprocessor.batch_process(input_files,output_dir,initial_variables)# 显示处理结果print(f\n处理完成共处理{len(results)}个文件)print(f输出目录:{output_dir})# 显示汇总信息total_errorssum(len(r[errors])forrinresults)iftotal_errors0: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,precision5):初始化优化器 Args: precision: 数值精度小数位数 self.precisionprecision self.variables{}self.macro_definitions{}# 编译正则表达式self.macro_patternre.compile(r%\s*MACRO\s*;,re.IGNORECASE)self.assign_patternre.compile(r(\d)\s*:\s*\s*(.?)\s*(;|$))self.var_patternre.compile(r(\d))self.gcode_patternre.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_namematch.group(1)ifvar_nameinself.variables:returnstr(self.variables[var_name])returnmatch.group(0)exprself.var_pattern.sub(replace_match,expression)try:# 安全计算resulteval(expr,{__builtins__:{}},{})returnfloat(result)exceptExceptionase:raiseValueError(f表达式错误:{expression}-{e})defparse_line(self,line):解析行内容 Args: line: 输入行 Returns: dict: 解析结果 lineline.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[]remainingline# 查找所有赋值语句whileTrue:matchself.assign_pattern.search(remaining)ifnotmatch:breakvar_namematch.group(1)expressionmatch.group(2)assignments.append({var_name:var_name,expression:expression,full_match:match.group(0)})# 移除已匹配的部分remainingremaining[:match.start()]remaining[match.end():]ifassignments:result[is_assignment]Trueresult[assignments]assignments# 检查G代码gcode_matcheslist(self.gcode_pattern.finditer(remaining))ifgcode_matches:result[is_gcode]Trueresult[gcode_commands][m.group(1)formingcode_matches]# 处理剩余部分可能包含变量引用ifremaining.strip():# 替换变量引用defreplace_vars(match):var_namematch.group(1)ifvar_nameinself.variables:returnself.format_number(self.variables[var_name])returnmatch.group(0)processedself.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:# 提取命令字母和值lettercmd[0].upper()valuecmd[1:].strip()# 保留原始值格式化在最后进行grouped[letter]value# 构建优化后的字符串# G命令放在最前面ordered_keys[]ifGingrouped: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:valuefloat(grouped[key])formattedself.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_varsNone):处理文件 Args: input_file: 输入文件 output_file: 输出文件 initial_vars: 初始变量 # 设置初始变量ifinitial_vars:forname,valueininitial_vars.items():self.set_variable(name,value)# 读取文件try:withopen(input_file,r,encodingutf-8)asf:linesf.readlines()except:withopen(input_file,r,encodinggbk)asf:linesf.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:# 解析行parsedself.parse_line(line)# 处理赋值语句ifparsed[is_assignment]:line_stats[assignments]1forassigninparsed[assignments]:try:valueself.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]:optimizedself.optimize_gcode_block(parsed[gcode_commands])# 如果有其他内容添加到优化后的G代码后面other_contentparsed[processed]ifother_contentandnotother_content.startswith(tuple(GXYZABC)):ifoptimized:processed_linef{optimized};{other_content}else:processed_lineother_contentelse:processed_lineoptimizedifoptimizedelseother_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,encodingutf-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(fG代码行:{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__:# 创建优化器optimizerGCodeOptimizer(precision5)# 设置初始变量initial_vars{1107:15.5}# 可根据需要修改# 输入输出文件input_file01001.txtoutput_fileoptimized_nc.txtifos.path.exists(input_file):# 处理文件resultoptimizer.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):linef.readline()ifnotline:breakprint(line.rstrip())else:print(f输入文件不存在:{input_file})版本4完整应用示例 数控代码批量处理工具 功能完整的数控代码处理流水线 版本4.0 importosimportsysimportjsonimportloggingfromdatetimeimportdatetime# 配置日志logging.basicConfig(levellogging.INFO,format%(asctime)s - %(levelname)s - %(message)s,handlers[logging.FileHandler(nc_processor.log),logging.StreamHandler(sys.stdout)])classNcProcessingPipeline:数控代码处理流水线def__init__(self,config_fileNone):初始化流水线 Args: config_file: 配置文件路径 self.configself.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.configself.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})# 检查文件大小不超过10MBifos.path.getsize(file_path)10*1024*1024:logging.error(f文件过大:{file_path})returnFalsereturnTruedefparse_variable_assignments(self,content):解析变量赋值语句 Args: content: 文件内容 Returns: dict: 变量依赖关系 importre# 匹配变量赋值patternre.compile(r(\d)\s*:\s*\s*(.?)(?;|\n|$))assignments{}formatchinpattern.finditer(content):var_namematch.group(1)expressionmatch.group(2).strip()# 提取依赖的变量depsre.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_iterationslen(assignments)*2# 防止无限循环iteration0whileiterationmax_iterations:iteration1progressFalseforvar_name,infoinassignments.items():ifinfo[computed]:continue# 检查依赖是否都已计算deps_computedall(depincomputedfordepininfo[dependencies])ifdeps_computed:try:# 替换表达式中的变量引用expressioninfo[expression]fordepininfo[dependencies]:expressionexpression.replace(f{dep},str(computed[dep]))# 计算表达式valueeval(expression,{__builtins__:{}},{})computed[var_name]float(value)info[computed]Trueinfo[value]value progressTruelogging.debug(f计算变量 {var_name}{expression}{value})exceptExceptionase:logging.error(f变量 {var_name}计算失败:{e})# 使用默认值0computed[var_name]0.0info[computed]Trueinfo[value]0.0progressTrueifnotprogress:break# 检查未计算的变量forvar_name,infoinassignments.items():ifnotinfo[computed]:logging.warning(f变量 {var_name}未计算使用默认值0)computed[var_name]0.0returncomputeddefprocess_single_file(self,input_file,output_fileNone,initial_valuesNone):处理单个文件 Args: input_file: 输入文件 output_file: 输出文件 initial_values: 初始变量值 Returns: dict: 处理结果 start_timedatetime.now()# 验证文件ifnotself.validate_input_file(input_file):return{status:error,message:f文件验证失败:{input_file}}# 默认输出文件名ifnotoutput_file:base_nameos.path.splitext(os.path.basename(input_file))[0]output_filef{base_name}_processed.{self.config[output_format]}# 备份原文件ifself.config[backup_original]:backup_filef{input_file}.backuptry:importshutil shutil.copy2(input_file,backup_file)logging.info(f已备份原文件:{backup_file})exceptExceptionase:logging.warning(f文件备份失败:{e})try:# 读取文件withopen(input_file,r,encodingutf-8)asf:contentf.read()# 解析变量赋值assignmentsself.parse_variable_assignments(content)logging.info(f解析到{len(assignments)}个变量赋值)# 计算变量值initial_valuesinitial_valuesor{}computed_valuesself.compute_variable_values(assignments,initial_values)logging.info(f计算了{len(computed_values)}个变量值)# 替换变量引用importre var_patternre.compile(r(\d))defreplace_var(match):var_namematch.group(1)ifvar_nameincomputed_values:valuecomputed_values[var_name]# 根据精度格式化returnf{value:.{self.config[precision]}f}returnmatch.group(0)# 替换所有变量引用processed_contentvar_pattern.sub(replace_var,content)# 移除变量赋值语句可选ifself.config.get(remove_assignments,True):assignment_patternre.compile(r\d\s*:\s*.*?(?;|\n|$);?)processed_contentassignment_pattern.sub(,processed_content)# 移除注释可选ifself.config.get(remove_comments,False):# 移除%注释processed_contentre.sub(r%.*?(?\n|$),,processed_content)# 移除()注释processed_contentre.sub(r\(.*?\),,processed_content)# 优化G代码格式ifself.config.get(optimize_gcode,True):# 合并多空格processed_contentre.sub(r\s, ,processed_content)# 清理多余的分号processed_contentre.sub(r;\s*;,;,processed_content)# 移除空行linesprocessed_content.split(\n)processed_lines[line.strip()forlineinlinesifline.strip()]processed_content\n.join(processed_lines)# 写入输出文件withopen(output_file,w,encodingutf-8)asf:f.write(processed_content)# 计算处理时间end_timedatetime.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_dirNone,initial_valuesNone):批量处理文件 Args: input_files: 输入文件列表 output_dir: 输出目录 initial_values: 初始变量值 Returns: list: 处理结果列表 results[]# 创建输出目录ifoutput_dir:os.makedirs(output_dir,exist_okTrue)total_fileslen(input_files)successful0failed0logging.info(f开始批量处理{total_files}个文件)fori,input_fileinenumerate(input_files,1):logging.info(f处理文件{i}/{total_files}:{input_file})# 确定输出文件路径ifoutput_dir:base_nameos.path.basename(input_file)output_fileos.path.join(output_dir,fproc_{base_name})else:output_fileNone# 处理文件resultself.process_single_file(input_file,output_file,initial_values)# 更新统计ifresult[status]success:successful1else:failed1results.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_files0else0,total_processing_time:sum(r.get(processing_time,0)forrinresultsifr[status]success),average_compression:sum(r.get(compression_ratio,0)forrinresultsifr[status]success)/successfulifsuccessful0else0,timestamp:datetime.now().isoformat()}logging.info(f批量处理完成汇总:{summary})# 保存结果到JSON文件report_filefprocessing_report_{datetime.now().strftime(%Y%m%d_%H%M%S)}.jsonwithopen(report_file,w)asf:json.dump({config:self.config,summary:summary,results:results},f,indent2)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:contentf.read()# 解析变量assignmentsself.parse_variable_assignments(content)# 提取所有变量引用importre all_var_refsre.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,visitedNone):ifvisitedisNone:visitedset()ifvar_nameinvisited:return0# 循环依赖ifvar_namenotinassignments:return0ifvar_nameindepths:returndepths[var_name]visited.add(var_name)max_depth0fordepinassignments[var_name][dependencies]:depthget_depth(dep,visited.copy())max_depthmax(max_depth,depth)depths[var_name]max_depth1returndepths[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]})# 检查复杂依赖depthsself.calculate_dependency_depth(assignments)forvar_name,depthindepths.items():ifdepth3:recommendations.append(f变量 {var_name}依赖链深度为{depth}考虑简化)returnrecommendations# 主程序入口defmain():主函数print(*60)print(数控代码变量处理工具 v4.0)print(*60)# 创建流水线pipelineNcProcessingPipeline()# 示例处理单个文件input_file01001.txtifos.path.exists(input_file):print(f\n1. 分析文件:{input_file})# 生成变量报告reportpipeline.generate_variable_report(input_file)ifreport:print(f 发现{report[total_variables]}个变量)print(f 变量赋值语句:{report[variable_assignments]})print(f 建议:{len(report[recommendations])}条)# 显示前5个最常用的变量sorted_usagesorted(report[variable_usage].items(),keylambdax:x[1],reverseTrue)[:5]print(f 最常用的变量:)forvar,countinsorted_usage:print(f {var}: 使用{count}次)print(f\n2. 处理文件)# 设置初始变量值initial_values{1107:10.0}# 根据实际情况修改# 处理文件resultpipeline.process_single_file(input_fileinput_file,output_fileprocessed_output.txt,initial_valuesinitial_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 Z1145; G00 X1144; G00 Y60.12500; G00 C0.00000; G01 Y50.12500 X1144 Z1145 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()