self.和_xxx的用法的区别

最新推荐文章于 2025-05-27 16:38:38 发布
最新推荐文章于 2025-05-27 16:38:38 发布
阅读量3.1k 收藏 7
点赞数 1
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_27633421/article/details/52184875

  1. 首先通过self.xxx 通过访问的方法的引用：包含了set和get方法。而通过下划线是获取自己的实例变量，不包含set和get的方法。

  2. self.xxx是对属性的访问；而_xxx是对局部变量的访问。所有被声明为属性的成员，再ios5之前需要使用编译指令@synthesize 来告诉编译器帮助生成属性的getter和setter方法，之后这个指令可以不用认为的指定了，默认情况下编译器会帮助我们生成。编译器在生成getter，setter方法时是有优先级的，他首先查找当前的类中用户是否定义属性的getter，setter方法，如果有，则编译器会跳过，不会再生成，使用用户定义的方法。也就是说你在使用self.xxx时是调用一个getter方法。会使引用计数加一，而_xxx不会使用引用技术加一的。

  3. 如果self。xxx=self。aaa，那么左边就是set方法，右边是get方法，=号左边第一个点是set方法，=号右边最后一个点是get方法（自己粗陋的总结......）。

所有使用self.xxx是更好的选择，因为这样可以兼容懒加载，同时也避免了使用下滑线的时候忽略了self这个指针，后者容易在BLock中造成循环引用。同时，使用 _是获取不到父类的属性，因为它只是对局部变量的访问。

 
最后总结：self方法实际上是用了get和set方法间接调用，下划线方法是直接对变量操作。

在最新的xcode中，已经不需要我们自己去写 set,get 方法，，系统已经自动帮我们生成set,get方法。
同时我们发现在我们访问我们声明的变量时，会有self. 和 以"_"开头的访问方式，那么这两种方式到底有什么样的区别呢？

我们来一起看一下:

<span style="color:#505050">
<span style="color:#954121">@property</span> (retain, <span style="color:#954121">nonatomic</span>) <span style="color:#0086b3">NSMutableArray</span> *nameArray;<span style="color:#954121">self</span><span style="color:#008080">.nameArray</span>是访问属性的,而_nameArray是访问实例变量的.
</span>

属性是实例变量加上GET,SET方法的一个整合体,他主要是承担一个外部访问的一个接口!

实例变量只能在本类中才可以访问,外部不可以访问!

总的原则:

在类内部访问变量的时候用“_”;

在类外部也就是其他类里访问这个类的变量时用“.” 语法；
 
共同点self.shuxing  这样访问属性比如self.array.count 会触发其set方法。
而_shuxing 这样的访问方法比如_array.count 则不会。

注意事项:

手动管理内存的情况下：

使用“.”语法来初始化变量的时候，会产生内存泄漏的问题：

<span style="color:#505050">
<span style="color:#954121">self</span>.nameArray = [NSMutaleArray alloc] init];
</span>

上述代码，造成的问题是，在self.nameArray的时候相当于调用了set方法，引用计数＋1，后面alloc的时候，引用计数再次＋1。
在我们最后dealloc中release的时候，引用计数只减了一次，并没有完成全部释放，这样就造成了内存泄漏的问题。

解决方法：就是用“_”来初始化以及访问变量，这样就不会产生内存问题，虽不是什么高明的办法，但的确有效。

<span style="color:#505050">
_nameArray = [NSMutaleArray alloc] init];
</span>

上述便是“.”和“_”在使用的时候的简单区别。

 
如果是在ARC（自动管理内存）的情况下虽然不存在上述问题，但从编码规范来考虑，还是注意点儿的好。
 

总结：1，self.是对属性的访问，使用它的时候编译器会判断_是否为空，为空的话自动实例化。会自动访问get和set方法

         2，_是对实例变量的访问，我们没有实例化它，不能使用

         3，对类里局部变量访问使用_，外部变量则用self.

         4,在getter方法中，不要再使用self。否则会重复调用getter方法，造成死循环
 
其他文章请移步个人博客： http://zhangqq166.cn/
Pytorch实用教程：super(MLP,self).__init__()和super().__init__()有什么区别？
若北辰
05-30 705
在 Python 中，super()函数用于调用父类（超类）的方法。它的使用在继承关系中非常常见，特别是在初始化继承自父类的属性时。在 PyTorch 中，这通常见于初始化nn.Module类的子类。super()的两种调用方式有微妙的差别，但在 Python 3 中常常用来达到同样的目的。这种写法在 Python 2 中非常常见。这里，super()被调用时需要指定当前类名（MLP）和当前实例（self。
self 和 _的区别
three two one 的博客
11-29 462
通过self.xx = 00 相当于调用了xx的setter方法，xx 会先进行release 然后再把00赋值给xx （如果在xx的setter方法里通过self.xx = xx进行赋值，则会形成一个死循环，无限调用setter方法）通过 _xx是直接获取xx的实例变量，所以在setter方法里应该直接使用 _xx = xx来进行赋值。
self和下划线的用法区别
weixin_33795743的博客
05-20 253
在最新的xcode中，已经不需要我们自己去写 set,get 方法，在我们使用@property声明属性时，系统已经自动帮我们生成set,get方法。 同时我们发现在我们访问我们声明的变量时，会有self. 和 以"_"开头的访问方式，那么这两种方式到底有什么样的区别呢？ 我们来一起看一下: @property (retain, nonatomic) NSMutableArray *nameArr...
【Python中的self】Python中的`self`：从基础到进阶的实战指南
Creedassin的博客
05-27 871
带你了解python中的self。self看起来只是一个小小的参数，但它其实是连接对象和方法之间的桥梁。它不是关键字，也不是魔法，而是一个约定俗成的习惯。但正是这个习惯，构成了Python面向对象的核心机制之一。
_和self.赋值的区别
ZTLVV的专栏
07-12 255
1.用_属性赋值，是直接赋值地址，把指针指向内存，strong/copy/retain等修饰词并不起作用 2.用self.赋值，是使用setter方法，通过imp重定向到setPropety方法找到对应的内存，根据属性的修饰词进行操作赋值。用_或者self.进行属性赋值，对使用copy修饰的属性有影响之外，别的区别不大，因为strong/retain等只是引用计数的增加，而copy修饰的时候，如果是进行的深拷贝(比如copy对象为multable数据)，_并不会重新开辟内存，而self.会开辟一份新内存(深
关于self.与_的区别
jie863230900的专栏
07-22 2308
很多时候我们可以看到在xcode的.m开发文档中有self.aa与_aa字段，一直不太明白这其中的区别，和相关的用法，知道写一个东西，调bug的时候顿悟，现在记录下来，仅供参考! 很多时候我们这样写我们的Objective-c代码 //.h文件部分 @interface demo_selfAnd_ @end //.m文件部分 @implementation demo_selfA
【self：与self.的区别】
奶白的雪的博客
07-02 453
在上面的例子中，sayHello方法的定义中包含了一个self参数，通过self.name可以访问对象的name成员。当你在对象内部或对象方法中使用点号（.）来访问对象的成员时，不需要显式地传递self参数，而是直接使用点号后面的成员名。self参数表示对象本身，使用冒号（:）来调用对象方法时，实际上会自动传递对象本身作为第一个参数。在上面的例子中，obj.name使用点号直接访问对象的成员变量，obj:sayHello()中的self.name也使用点号来访问对象的成员变量。
def init_ui(self): #设置主界面的标题 self.setWindowTitle("Cantest") #创建主横向布局 main_layout = QHBoxLayout() # 创建一个水平布局 main_layout，用于管理窗口中的小部件 #toolbar self.toolbar = topLayout.init_toolbar(self) self.addToolBar(self.toolbar) self.top_layout_object.connect_top_functions(self) 中 class topLayout(): def init_toolbar(self): toolbar = QToolBar() toolbar.setObjectName("CAN ToolBar") #设置对象名 self.action_open = QAction("打开CAN", self) self.action_close = QAction("关闭CAN", self) self.action_refresh = QAction("刷新设备", self) self.action_save_log = QAction("保存CANlog", self) toolbar.addAction(self.action_open) # 添加工具按钮 toolbar.addAction(self.action_close) toolbar.addSeparator() # 添加分隔线 toolbar.addAction(self.action_refresh) toolbar.addSeparator() toolbar.addAction(self.action_save_log) # action_open.triggered.connect() return toolbar def connect_top_functions(self): self.action_open.triggered.connect(self.openWindow) self.action_close.triggered.connect(self.closeWindow) self.action_refresh.triggered.connect(self.Refresh_function) self.action_save_log.triggered.connect(self.Save_function) 导致TypeError: topLayout.connect_top_functions() takes 1 positional argument but 2 were given 应该如何解决
最新发布
07-31
在`init_toolbar`方法中，将创建的QAction保存为实例属性（使用self.xxx）。 2. 检查调用`connect_top_functions`的地方，确保只传递了一个参数（即mainWindow对象）。 如果问题仍然存在，请提供调用`connect_...
以下代码有定义小车的运动学属性吗# coding=utf-8 from .collision import * from .graphics import load_texture from .utils import get_file_path class WorldObj: def __init__(self, obj, domain_rand, safety_radius_mult): """ Initializes the object and its properties """ # XXX this is relied on by things but it is not always set # (Static analysis complains) self.visible = True # same self.color = (0, 0, 0) # maybe have an abstract method is_visible, get_color() self.process_obj_dict(obj, safety_radius_mult) self.domain_rand = domain_rand self.angle = self.y_rot * (math.pi / 180) self.generate_geometry() def generate_geometry(self): # Find corners and normal vectors assoc w. object self.obj_corners = generate_corners(self.pos, self.min_coords, self.max_coords, self.angle, self.scale) self.obj_norm = generate_norm(self.obj_corners) def process_obj_dict(self, obj, safety_radius_mult): self.kind = obj['kind'] self.mesh = obj['mesh'] self.pos = obj['pos'] self.scale = obj['scale'] self.y_rot = obj['y_rot'] self.optional = obj['optional'] self.min_coords = obj['mesh'].min_coords self.max_coords = obj['mesh'].max_coords self.static = obj['static'] self.safety_radius = safety_radius_mult *\ calculate_safety_radius(self.mesh, self.scale) def render(self, draw_bbox): """ Renders the object to screen """ if not self.visible: return from pyglet import gl # Draw the bounding box if draw_bbox: gl.glColor3f(1, 0, 0) gl.glBegin(gl.GL_LINE_LOOP) gl.glVertex3f(self.obj_corners.T[0, 0], 0.01, self.obj_corners.T[1, 0]) gl.glVertex3f(self.obj_corners.T[0, 1], 0.01, self.obj_corners.T[1, 1]) gl.glVertex3f(self.obj_corners.T[0, 2], 0.01, self.obj_corners.T[1, 2]) gl.glVertex3f(self.obj_corners.T[0, 3], 0.01, self.obj_corners.T[1, 3]) gl.glEnd() gl.glPushMatrix() gl.glTranslatef(*self.pos) gl.glScalef(self.scale, self.scale, self.scale) gl.glRotatef(self.y_rot, 0, 1, 0) gl.glColor3f(*self.color) self.mesh.render() gl.glPopMatrix() # Below are the functions that need to # be reimplemented for any dynamic object def check_collision(self, agent_corners, agent_norm): """ See if the agent collided with this object For static, return false (static collisions checked w numpy in a batch operation) """ if not self.static: raise NotImplementedError return False def proximity(self, agent_pos, agent_safety_rad): """ See if the agent is too close to this object For static, return 0 (static safedriving checked w numpy in a batch operation) """ if not self.static: raise NotImplementedError return 0.0 def step(self, delta_time): """ Use a motion model to move the object in the world """ if not self.static: raise NotImplementedError class DuckiebotObj(WorldObj): def __init__(self, obj, domain_rand, safety_radius_mult, wheel_dist, robot_width, robot_length, gain=2.0, trim=0.0, radius=0.0318, k=27.0, limit=1.0): WorldObj.__init__(self, obj, domain_rand, safety_radius_mult) if self.domain_rand: self.follow_dist = np.random.uniform(0.3, 0.4) self.velocity = np.random.uniform(0.05, 0.15) else: self.follow_dist = 0.3 self.velocity = 0.1 self.max_iterations = 1000 # TODO: Make these DR as well self.gain = gain self.trim = trim self.radius = radius self.k = k self.limit = limit self.wheel_dist = wheel_dist self.robot_width = robot_width self.robot_length = robot_length # FIXME: this does not follow the same signature as WorldOb def step(self, delta_time, closest_curve_point, objects): """ Take a step, implemented as a PID controller """ # Find the curve point closest to the agent, and the tangent at that point closest_point, closest_tangent = closest_curve_point(self.pos, self.angle) iterations = 0 lookup_distance = self.follow_dist curve_point = None while iterations < self.max_iterations: # Project a point ahead along the curve tangent, # then find the closest point to to that follow_point = closest_point + closest_tangent * lookup_distance curve_point, _ = closest_curve_point(follow_point, self.angle) # If we have a valid point on the curve, stop if curve_point is not None: break iterations += 1 lookup_distance *= 0.5 # Compute a normalized vector to the curve point point_vec = curve_point - self.pos point_vec /= np.linalg.norm(point_vec) dot = np.dot(self.get_right_vec(self.angle), point_vec) steering = self.gain * -dot self._update_pos([self.velocity, steering], delta_time) def get_dir_vec(self, angle): x = math.cos(angle) z = -math.sin(angle) return np.array([x, 0, z]) def get_right_vec(self, angle): x = math.sin(angle) z = math.cos(angle) return np.array([x, 0, z]) def check_collision(self, agent_corners, agent_norm): """ See if the agent collided with this object """ return intersects_single_obj( agent_corners, self.obj_corners.T, agent_norm, self.obj_norm ) def proximity(self, agent_pos, agent_safety_rad): """ See if the agent is too close to this object based on a heuristic for the "overlap" between their safety circles """ d = np.linalg.norm(agent_pos - self.pos) score = d - agent_safety_rad - self.safety_radius return min(0, score) def _update_pos(self, action, deltaTime): vel, angle = action # assuming same motor constants k for both motors k_r = self.k k_l = self.k # adjusting k by gain and trim k_r_inv = (self.gain + self.trim) / k_r k_l_inv = (self.gain - self.trim) / k_l omega_r = (vel + 0.5 * angle * self.wheel_dist) / self.radius omega_l = (vel - 0.5 * angle * self.wheel_dist) / self.radius # conversion from motor rotation rate to duty cycle u_r = omega_r * k_r_inv u_l = omega_l * k_l_inv # limiting output to limit, which is 1.0 for the duckiebot u_r_limited = max(min(u_r, self.limit), -self.limit) u_l_limited = max(min(u_l, self.limit), -self.limit) # If the wheel velocities are the same, then there is no rotation if u_l_limited == u_r_limited: self.pos = self.pos + deltaTime * u_l_limited * self.get_dir_vec(self.angle) return # Compute the angular rotation velocity about the ICC (center of curvature) w = (u_r_limited - u_l_limited) / self.wheel_dist # Compute the distance to the center of curvature r = (self.wheel_dist * (u_l_limited + u_r_limited)) / (2 * (u_l_limited - u_r_limited)) # Compute the rotation angle for this time step rotAngle = w * deltaTime # Rotate the robot's position around the center of rotation r_vec = self.get_right_vec(self.angle) px, py, pz = self.pos cx = px + r * r_vec[0] cz = pz + r * r_vec[2] npx, npz = rotate_point(px, pz, cx, cz, rotAngle) # Update position self.pos = np.array([npx, py, npz]) # Update the robot's direction angle self.angle += rotAngle self.y_rot += rotAngle * 180 / np.pi # Recompute the bounding boxes (BB) for the duckiebot self.obj_corners = agent_boundbox( self.pos, self.robot_width, self.robot_length, self.get_dir_vec(self.angle), self.get_right_vec(self.angle) ) class DuckieObj(WorldObj): def __init__(self, obj, domain_rand, safety_radius_mult, walk_distance): WorldObj.__init__(self, obj, domain_rand, safety_radius_mult) self.walk_distance = walk_distance + 0.25 # Dynamic duckie stuff # Randomize velocity and wait time if self.domain_rand: self.pedestrian_wait_time = np.random.randint(3, 20) self.vel = np.abs(np.random.normal(0.02, 0.005)) else: self.pedestrian_wait_time = 8 self.vel = 0.02 # Movement parameters self.heading = heading_vec(self.angle) self.start = np.copy(self.pos) self.center = self.pos self.pedestrian_active = False # Walk wiggle parameter self.wiggle = np.random.choice([14, 15, 16], 1) self.wiggle = np.pi / self.wiggle self.time = 0 def check_collision(self, agent_corners, agent_norm): """ See if the agent collided with this object """ return intersects_single_obj( agent_corners, self.obj_corners.T, agent_norm, self.obj_norm ) def proximity(self, agent_pos, agent_safety_rad): """ See if the agent is too close to this object based on a heuristic for the "overlap" between their safety circles """ d = np.linalg.norm(agent_pos - self.center) score = d - agent_safety_rad - self.safety_radius return min(0, score) def step(self, delta_time): """ Use a motion model to move the object in the world """ self.time += delta_time # If not walking, no need to do anything if not self.pedestrian_active: self.pedestrian_wait_time -= delta_time if self.pedestrian_wait_time <= 0: self.pedestrian_active = True return # Update centers and bounding box vel_adjust = self.heading * self.vel self.center += vel_adjust self.obj_corners += vel_adjust[[0, -1]] distance = np.linalg.norm(self.center - self.start) if distance > self.walk_distance: self.finish_walk() self.pos = self.center angle_delta = self.wiggle * math.sin(48 * self.time) self.y_rot = (self.angle + angle_delta) * (180 / np.pi) self.obj_norm = generate_norm(self.obj_corners) def finish_walk(self): """ After duckie crosses, update relevant attributes (vel, rot, wait time until next walk) """ self.start = np.copy(self.center) self.angle += np.pi self.pedestrian_active = False if self.domain_rand: # Assign a random velocity (in opp. direction) and a wait time # TODO: Fix this: This will go to 0 over time self.vel = -1 * np.sign(self.vel) * np.abs(np.random.normal(0.02, 0.005)) self.pedestrian_wait_time = np.random.randint(3, 20) else: # Just give it the negative of its current velocity self.vel *= -1 self.pedestrian_wait_time = 8 class TrafficLightObj(WorldObj): def __init__(self, obj, domain_rand, safety_radius_mult): WorldObj.__init__(self, obj, domain_rand, safety_radius_mult) self.texs = [ load_texture(get_file_path("textures", "trafficlight_card0", "jpg")), load_texture(get_file_path("textures", "trafficlight_card1", "jpg")) ] self.time = 0 # Frequency and current pattern of the lights if self.domain_rand: self.freq = np.random.randint(4, 7) self.pattern = np.random.randint(0, 2) else: self.freq = 5 self.pattern = 0 # Use the selected pattern self.mesh.textures[0] = self.texs[self.pattern] def step(self, delta_time): """ Changes the light color periodically """ self.time += delta_time if round(self.time, 3) % self.freq == 0: # Swap patterns self.pattern ^= 1 self.mesh.textures[0] = self.texs[self.pattern] def is_green(self, direction='N'): if direction == 'N' or direction == 'S': if self.y_rot == 45 or self.y_rot == 135: return self.pattern == 0 elif self.y_rot == 225 or self.y_rot == 315: return self.pattern == 1 elif direction == 'E' or direction == 'W': if self.y_rot == 45 or self.y_rot == 135: return self.pattern == 1 elif self.y_rot == 225 or self.y_rot == 315: return self.pattern == 0 return False
07-12
该方法接收动作（线速度和转向角）并更新机器人的位置和朝向。 - `_update_pos`方法：根据差速驱动模型的具体公式，将左右轮的电机控制信号转换为机器人的位置和角度变化。 在`_update_pos`方法中，我们看到了...
强调：下面的代码是能够运行，现在修改，只是局部修改问题，不要胡乱修改。。。修改时一定要说明在什么类的什么地方，这样不要用户进行修改。找准位置，认真修改，本着用户至上的原则。生成完整代码。。。问题：修改要求：用户原来设计主界面是三栏布局（包括左侧面板、右侧面板和中间区域），中间区域（中间区域分为两个框），现在要求确保动态区严格作为中间区域的第二个（从上往下数），用户在运行代码时就发现：错误的问题是每个模块的名称，标签及条目占了整个界面的下半部分，这是一个严重的错误，，用户现在要求把子类界面改成与主界面一样（也是三栏布局（包括左侧面板、右侧面板和中间区域）。只是每个模块的名称，标签及条目必须完全嵌套在动态区框里面（中间区域往下的第二个框里面），在动态区里面，举例说明，也就是在有四个按钮的框里。。。。原代码# ==================== 主界面修改 ==================== class MainInterface: def init(self, root: Tk, pool: NumberPool): self.root = root self.pool = pool self.left_panel = None self.center_frame = None self.right_panel = None self.core_vars = {} self.pool_vars = {} self.status_var = StringVar() self.dynamic_text = None self.current_module = None self._setup_ui() self._setup_event_handlers() self.module_instances = {} self._init_modules() # 初始化排除号码相关控件 self.exclude_front_entries = [] self.exclude_back_entries = [] self.front_dan_entries = [] self.back_dan_entries = [] # 初始化结果文本控件 self.result_text = None # 初始化排除号码变量 self.exclude_front_var = StringVar() self.exclude_back_var = StringVar() self.recommend_front_var = StringVar() self.recommend_back_var = StringVar() # 初始化模块内容框架 self.dynamic_content = None self.module_content_frame = None self.labels = { 'InputAnalysis_analysis': [ "输入号码:" , "前区:" , "后区:" , "推荐号码:", "前区:" , "后区:", ], 'combination_analysis': [ "前区热号:", "前数字频:", "前频繁推:", "后区热号:", "后数字频:", "后低频推:" ], 'follow_analysis': [ "前推荐多:", "前推荐少:", "后推荐多:", "后推荐少:" ], 'trend_analysis': [ "和值:", "质合比:", "奇偶比:", "断区推荐:", "连号推荐:", "冷热推荐:", "后区热号:", "后区冷号:", "趋势号:" ], 'NumberGeneration_analysis': [ "胆码:" , "前区:" , "后区:", "推荐5注号码:", "1:" "", "2:" "", "3:" "", "4:" "", "5:" "" ], } # 初始化所有模块的条目引用 self.front_dan_entry = None self.back_dan_entry = None self.result_text = None self.exclude_front_entry = None self.exclude_back_entry = None self.front_entry = None self.back_entry = None def _focus_adjacent_entry(self, event, current_idx, offset, area): """移动焦点到相邻的输入框""" entries = self.front_exclude_entries if area == 'front' else self.back_exclude_entries new_idx = current_idx + offset if 0 <= new_idx < len(entries): entries[new_idx].focus_set() def _init_modules(self): """初始化所有分析模块""" modules = { 'input_analysis': InputAnalysisModule, 'combination_analysis': CombinationAnalysisModule, 'follow_analysis': FollowAnalysisModule, 'trend_analysis': TrendAnalysisModule, 'number_generation': NumberGenerationModule } for name, cls in modules.items(): self.module_instances[name] = cls(name) def _setup_event_handlers(self): """初始化事件处理器""" event_center.subscribe(EventType.MODULE_COMPLETE, self._handle_module_complete) event_center.subscribe(EventType.UI_UPDATE, self._handle_ui_update) event_center.subscribe(EventType.EXCLUDE_NUMBERS, self._handle_exclude_numbers) def _setup_ui(self): self.root.title(f"大乐透智能分析平台 - {GlobalConfig.VERSION}") self.root.geometry("1400x800") # 添加主标题 title_frame = Frame(self.root) title_frame.pack(fill='x', pady=5) Label(title_frame, text="大乐透智能分析平台", font=('微软雅黑', 16, 'bold')).pack(expand=True) # 主容器 - 三栏布局 main_container = PanedWindow(self.root, orient=HORIZONTAL, sashrelief=RAISED, sashwidth=5) main_container.pack(fill='both', expand=True, padx=5, pady=(0, 5)) # 左侧面板 self.left_panel = Frame(main_container, width=200, bg="#eaeaea") main_container.add(self.left_panel, minsize=150, stretch="never") # 中间内容区 self.center_paned = PanedWindow(main_container, orient=VERTICAL, sashrelief=RAISED, sashwidth=5) main_container.add(self.center_paned, minsize=500, stretch="always") # 右侧面板 self.right_panel = Frame(main_container, width=700, bg="#f5f5f5") main_container.add(self.right_panel, minsize=250, stretch="never") # 初始化各区域 self._setup_left_panel() # 修正方法名 self._setup_center_area() # 修正方法名 self._setup_right_panel() def _setup_left_panel(self): # 修正方法名，添加缺失的"t" """初始化左侧模块按钮区""" module_names = { 'input_analysis': '1. 输入分析', 'combination_analysis': '2. 组合分析', 'follow_analysis': '3. 跟随分析', 'trend_analysis': '4. 趋势分析', 'number_generation': '5. 数字生成' } for module in GlobalConfig.MODULES: Button( self.left_panel, text=module_names[module], width=18, command=lambda m=module: self._on_module_button_click(m) ).pack(pady=3, padx=5, ipady=3) def _setup_center_area(self): """设置中间区域布局，分为上下两部分""" # 上半部分 - 核心区 self.core_frame = Frame(self.center_paned, bd=1, relief='solid') self.center_paned.add(self.core_frame, minsize=150, stretch="never") # 核心区固定高度 # 核心区标题 Label(self.core_frame, text="核心区", font=('微软雅黑', 12, 'bold')).pack(anchor='w', padx=5, pady=2) # 核心数据展示 self.core_vars = { 'front_area': StringVar(), 'back_area': StringVar(), 'front_hot': StringVar(), 'front_cold': StringVar(), 'back_hot': StringVar(), 'back_cold': StringVar() } for label, var_name in [ ("前区:", 'front_area'), ("后区:", 'back_area'), ("前区热号:", 'front_hot'), ("前区冷号:", 'front_cold'), ("后区热号:", 'back_hot'), ("后区冷号:", 'back_cold') ]: frame = Frame(self.core_frame) frame.pack(fill='x', padx=5, pady=2) Label(frame, text=label, width=10, anchor='w').pack(side='left') entry_container = Frame(frame) entry_container.pack(side='left', fill='x', expand=True, padx=(0, 2)) entry = Entry(entry_container, textvariable=self.core_vars[var_name], font=('微软雅黑', 10), state='readonly', readonlybackground='#f0f0f0', relief='sunken', bd=1) entry.pack(fill='x', expand=True) # 下半部分 - 动态区 (严格限制在中间区域下半部分) self.dynamic_frame = Frame(self.center_paned, bd=1, relief='solid') self.center_paned.add(self.dynamic_frame, minsize=200, stretch="always") # 动态区可扩展 # 动态区内部容器 - 确保所有模块内容严格嵌套在此框架内 dynamic_container = Frame(self.dynamic_frame) dynamic_container.pack(fill='both', expand=True, padx=5, pady=5) # 动态区标题框架 dynamic_header = Frame(dynamic_container) dynamic_header.pack(fill='x', pady=5) Label(dynamic_header, text="动态区", font=('微软雅黑', 12, 'bold')).pack(side='left') # 按钮框架 btn_frame = Frame(dynamic_header) btn_frame.pack(side='right') Button(btn_frame, text="运行", width=8, command=self._run_current_module).pack(side='left', padx=2) Button(btn_frame, text="清除", width=8, command=self._clear_dynamic_content).pack(side='left', padx=2) Button(btn_frame, text="保存", width=8, command=self._save_dynamic_content).pack(side='left', padx=2) Button(btn_frame, text="刷新", width=8, command=self._refresh_dynamic).pack(side='left', padx=2) # 模块内容容器 - 严格嵌套在动态区内 self.module_content_frame = Frame(dynamic_container) self.module_content_frame.pack(fill='both', expand=True) # 初始化动态区内容为空白 self.dynamic_content = Frame(self.module_content_frame) self.dynamic_content.pack(fill='both', expand=True) def _on_module_button_click(self, module: str): """模块切换 - 严格在动态区内变化""" self.status_var.set(f"打开 {module} 模块...") self.current_module = module # 清除之前的动态内容 - 仅限动态区 if self.dynamic_content: self.dynamic_content.destroy() # 创建新的动态内容容器 - 严格嵌套在module_content_frame内 self.dynamic_content = Frame(self.module_content_frame) self.dynamic_content.pack(fill='both', expand=True, padx=5, pady=5) # 顶部模块标签区 - 在动态区内 top_label_frame = Frame(self.dynamic_content) top_label_frame.pack(fill='x', pady=5) module_labels = { 'input_analysis': '1. 输入分析', 'combination_analysis': '2. 组合分析', 'follow_analysis': '3. 跟随分析', 'trend_analysis': '4. 趋势分析', 'number_generation': '5. 数字生成' } Label(top_label_frame, text=module_labels.get(module, module), font=('微软雅黑', 14, 'bold')).pack() # 内容区容器 - 在动态区内 content_frame = Frame(self.dynamic_content, bd=1, relief='solid') content_frame.pack(fill='both', expand=True, padx=5, pady=5) # 根据模块类型创建特定内容 - 严格在动态区内 if module == "input_analysis": self._create_input_analysis_content(content_frame) elif module == "combination_analysis": self._create_combination_analysis_content(content_frame) elif module == "follow_analysis": self._create_follow_analysis_content(content_frame) elif module == "trend_analysis": self._create_trend_analysis_content(content_frame) elif module == "number_generation": self._create_number_generation_content(content_frame) # 底部按钮区 - 在动态区内 bottom_frame = Frame(self.dynamic_content) bottom_frame.pack(pady=5, fill='x') Button(bottom_frame, text="运行", command=lambda: self._run_module(module)).pack(side='left', padx=5) Button(bottom_frame, text="清除", command=lambda: self._clear_module_data(module)).pack(side='left', padx=5) Button(bottom_frame, text="保存", command=lambda: self._save_module_data(module)).pack(side='left', padx=5) Button(bottom_frame, text="刷新", command=lambda: self._on_module_renovate(module)).pack(side='right', padx=5) # 模块内容容器 - 这是动态区的核心内容区域 self.module_content_frame = Frame(self.dynamic_frame) self.module_content_frame.pack(fill='both', expand=True, padx=5, pady=5) def _run_current_module(self): """运行当前模块""" if self.current_module: self._run_module(self.current_module) def _clear_dynamic_content(self): """清除动态区内容""" if hasattr(self, 'result_text') and self.result_text: self.result_text.delete(1.0, 'end') def _save_dynamic_content(self): """保存动态区内容""" if hasattr(self, 'result_text') and self.result_text: content = self.result_text.get(1.0, 'end') with open('dynamic_content.txt', 'w', encoding='utf-8') as f: f.write(content) messagebox.showinfo("保存成功", "动态区内容已保存") def _refresh_dynamic(self): """刷新动态区""" if self.current_module: self._on_module_button_click(self.current_module) def _setup_right_panel(self): """设置右侧号码池布局""" # 号码池标题 pool_title_frame = Frame(self.right_panel) pool_title_frame.pack(fill='x', pady=5) Label(pool_title_frame, text="号码池", font=('微软雅黑', 12, 'bold')).pack(anchor='w') # 号码池内容区（添加边框和2px内边距）pool_content = Frame(self.right_panel, bd=1, relief='solid', padx=2, pady=2) pool_content.pack(fill='both', expand=True, padx=5, pady=5) # 创建Canvas和Scrollbar canvas = Canvas(pool_content, highlightthickness=0) scrollbar = Scrollbar(pool_content, orient="vertical", command=canvas.yview) scrollable_frame = Frame(canvas) scrollable_frame.bind( "<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")) ) canvas.create_window((0, 0), window=scrollable_frame, anchor="nw") canvas.configure(yscrollcommand=scrollbar.set) # 号码池项目 - 优化布局和样式（带2px右边距）for label, var_name, row_id in GlobalConfig.UI_CONFIG: frame = Frame(scrollable_frame) frame.grid(row=row_id, column=0, sticky='ew', padx=0, pady=1) # 移除水平padding # 左侧标签（固定宽度8字符）lbl = Label(frame, text=label, width=8, anchor='w') lbl.pack(side='left', padx=(0, 5)) # 标签右侧留5px间距 # 右侧输入框容器（带2px右边距）entry_container = Frame(frame) entry_container.pack(side='left', fill='x', expand=True, padx=(0, 2)) var = StringVar() self.pool_vars[var_name] = var entry = Entry(entry_container, textvariable=var, font=('微软雅黑', 9), state='readonly', readonlybackground='#f0f0f0', relief='sunken', bd=1) entry.pack(fill='x', expand=True) canvas.pack(side="left", fill="both", expand=True) scrollbar.pack(side="right", fill="y") # 底部按钮区 btn_frame = Frame(self.right_panel) btn_frame.pack(fill='x', pady=5) Button(btn_frame, text="整理", width=10, command=self._organize_data).pack(side='left', padx=5) Button(btn_frame, text="冻结", width=10, command=self._freeze_data).pack(side='left', padx=5) Button(btn_frame, text="导出", width=10).pack(side='left', padx=5) def _organize_data(self): """整理号码池数据""" organize_event = Event( event_id=int(time.time()), type=EventType.DATA_ORGANIZE, source='main_ui', target='pool' ) event_center.publish(organize_event) def _freeze_data(self): """冻结号码池数据""" freeze_event = Event( event_id=int(time.time()), type=EventType.DATA_FREEZE, source='main_ui', target='pool' ) event_center.publish(freeze_event) def _on_module_button_click(self, module: str): """完全重构的模块显示方法 - 嵌入主界面动态区""" self.status_var.set(f"打开 {module} 模块...") self.current_module = module # 清除之前的动态内容 if self.dynamic_content: self.dynamic_content.destroy() # 创建模块专属容器 self.dynamic_content = Frame(self.module_content_frame) self.dynamic_content.pack(fill='both', expand=True, padx=5, pady=5) # 顶部模块标签区 top_label_frame = Frame(self.dynamic_content) top_label_frame.pack(fill='x', pady=5) module_labels = { 'input_analysis': '1. 输入分析', 'combination_analysis': '2. 组合分析', 'follow_analysis': '3. 跟随分析', 'trend_analysis': '4. 趋势分析', 'number_generation': '5. 数字生成' } Label(top_label_frame, text=module_labels.get(module, module), font=('微软雅黑', 14, 'bold')).pack() # 内容区容器 content_frame = Frame(self.dynamic_content, bd=1, relief='solid') content_frame.pack(fill='both', expand=True, padx=5, pady=5) # 根据模块类型创建特定内容 if module == "input_analysis": self._create_input_analysis_content(content_frame) elif module == "combination_analysis": self._create_combination_analysis_content(content_frame) elif module == "follow_analysis": self._create_follow_analysis_content(content_frame) elif module == "trend_analysis": self._create_trend_analysis_content(content_frame) elif module == "number_generation": self._create_number_generation_content(content_frame) # 底部按钮区 bottom_frame = Frame(self.dynamic_content) bottom_frame.pack(pady=5, fill='x') Button(bottom_frame, text="运行", command=lambda: self._run_module(module)).pack(side='left', padx=5) Button(bottom_frame, text="清除", command=lambda: self._clear_module_data(module)).pack(side='left', padx=5) Button(bottom_frame, text="保存", command=lambda: self._save_module_data(module)).pack(side='left', padx=5) Button(bottom_frame, text="刷新", command=lambda: self._on_module_renovate(module)).pack(side='right', padx=5) def _create_ui_element(self, parent, label_text): """创建统一的UI元素（带右边距2px）""" frame = Frame(parent) frame.pack(fill='x', pady=2) # 标签固定宽度 Label(frame, text=label_text, width=12, anchor='w').pack(side='left') # 添加容器Frame实现右边距2px entry_container = Frame(frame) entry_container.pack(side='left', fill='x', expand=True, padx=(0, 2)) return entry_container def _create_input_analysis_content(self, parent: Frame): """创建输入分析模块的特定内容""" content_frame = Frame(parent) content_frame.pack(fill='both', expand=True, padx=10, pady=10) # 排除号码区 exclude_frame = Frame(content_frame) exclude_frame.pack(fill='x', pady=5) # 排除号码标签 Label(exclude_frame, text="排除号码:", font=('微软雅黑', 10, 'bold')).pack(anchor='w', pady=5) # 前区排除号码 front_exclude_frame = Frame(exclude_frame) front_exclude_frame.pack(fill='x', pady=2) Label(front_exclude_frame, text="前区:", width=5, anchor='w').pack(side='left') self.exclude_front_entry = Entry(front_exclude_frame) self.exclude_front_entry.pack(side='left', fill='x', expand=True) # 后区排除号码 back_exclude_frame = Frame(exclude_frame) back_exclude_frame.pack(fill='x', pady=2) Label(back_exclude_frame, text="后区:", width=5, anchor='w').pack(side='left') self.exclude_back_entry = Entry(back_exclude_frame) self.exclude_back_entry.pack(side='left', fill='x', expand=True) # 号码输入区 input_frame = Frame(content_frame) input_frame.pack(fill='x', pady=5) Label(input_frame, text="输入号码:", font=('微软雅黑', 10, 'bold')).pack(anchor='w', pady=5) # 前区号码 front_frame = Frame(input_frame) front_frame.pack(fill='x', pady=2) Label(front_frame, text="前区:", width=5, anchor='w').pack(side='left') self.front_entry = Entry(front_frame) self.front_entry.pack(side='left', fill='x', expand=True) # 后区号码 back_frame = Frame(input_frame) back_frame.pack(fill='x', pady=2) Label(back_frame, text="后区:", width=5, anchor='w').pack(side='left') self.back_entry = Entry(back_frame) self.back_entry.pack(side='left', fill='x', expand=True) # 结果显示区 result_frame = Frame(content_frame) result_frame.pack(fill='both', expand=True, pady=5) scrollbar = Scrollbar(result_frame) scrollbar.pack(side='right', fill='y') self.result_text = Text(result_frame, yscrollcommand=scrollbar.set, wrap='word') self.result_text.pack(fill='both', expand=True) scrollbar.config(command=self.result_text.yview) def _create_combination_analysis_content(self, parent: Frame): """创建组合分析模块的特定内容""" content_frame = Frame(parent) content_frame.pack(fill='both', expand=True, padx=10, pady=10) # 使用预定义的labels for label in self.labels['combination_analysis']: frame = Frame(content_frame) frame.pack(fill='x', pady=2) Label(frame, text=label, width=12, anchor='w', font=('微软雅黑', 10, 'bold')).pack(side='left') entry = Entry(frame, width=30, state='readonly', readonlybackground='#f0f0f0') entry.pack(side='left', padx=5) # 保存对控件的引用 var_name = label.replace(':', '').replace(' ', '_') setattr(self, f"{var_name}_entry", entry) # 直接保存到实例变量 if var_name == "front_hot": self.front_hot_entry = entry elif var_name == "front_freq": self.front_freq_entry = entry elif var_name == "front_freq_rec": self.front_freq_rec_entry = entry elif var_name == "back_hot": self.back_hot_entry = entry elif var_name == "back_freq": self.back_freq_entry = entry elif var_name == "back_infreq_rec": self.back_infreq_rec_entry = entry # 结果显示区 result_frame = Frame(content_frame) result_frame.pack(fill='both', expand=True) scrollbar = Scrollbar(result_frame) scrollbar.pack(side='right', fill='y') self.result_text = Text(result_frame, yscrollcommand=scrollbar.set, wrap='word') self.result_text.pack(fill='both', expand=True) scrollbar.config(command=self.result_text.yview) def _create_follow_analysis_content(self, parent: Frame): """创建跟随分析模块的特定内容""" content_frame = Frame(parent) content_frame.pack(fill='both', expand=True, padx=10, pady=10) for label in self.labels['follow_analysis']: frame = Frame(content_frame) frame.pack(fill='x', pady=2) Label(frame, text=label, width=12, anchor='w', font=('微软雅黑', 10, 'bold')).pack(side='left') entry = Entry(frame, width=30, state='readonly', readonlybackground='#f0f0f0') entry.pack(side='left', padx=5) var_name = label.replace(':', '').replace(' ', '_') setattr(self, f"{var_name}_entry", entry) # 直接保存到实例变量 if var_name == "front_more": self.front_more_entry = entry elif var_name == "front_less": self.front_less_entry = entry elif var_name == "back_more": self.back_more_entry = entry elif var_name == "back_less": self.back_less_entry = entry # 结果显示区 result_frame = Frame(content_frame) result_frame.pack(fill='both', expand=True) scrollbar = Scrollbar(result_frame) scrollbar.pack(side='right', fill='y') self.result_text = Text(result_frame, yscrollcommand=scrollbar.set, wrap='word') self.result_text.pack(fill='both', expand=True) scrollbar.config(command=self.result_text.yview) def _create_trend_analysis_content(self, parent: Frame): """创建趋势分析模块的特定内容""" content_frame = Frame(parent) content_frame.pack(fill='both', expand=True, padx=10, pady=10) for label in self.labels['trend_analysis']: frame = Frame(content_frame) frame.pack(fill='x', pady=2) Label(frame, text=label, width=12, anchor='w', font=('微软雅黑', 10, 'bold')).pack(side='left') entry = Entry(frame, width=30, state='readonly', readonlybackground='#f0f0f0') entry.pack(side='left', padx=5) var_name = label.replace(':', '').replace(' ', '_') setattr(self, f"{var_name}_entry", entry) # 直接保存到实例变量 if var_name == "sum_value": self.sum_value_entry = entry elif var_name == "prime_ratio": self.prime_ratio_entry = entry elif var_name == "odd_even_ratio": self.odd_even_ratio_entry = entry elif var_name == "zone_rec": self.zone_rec_entry = entry elif var_name == "consec_rec": self.consec_rec_entry = entry elif var_name == "hot_cold_rec": self.hot_cold_rec_entry = entry elif var_name == "hot_rec": self.hot_rec_entry = entry elif var_name == "cold_rec": self.cold_rec_entry = entry elif var_name == "trend_rec": self.trend_rec_entry = entry # 结果显示区 result_frame = Frame(content_frame) result_frame.pack(fill='both', expand=True) scrollbar = Scrollbar(result_frame) scrollbar.pack(side='right', fill='y') self.result_text = Text(result_frame, yscrollcommand=scrollbar.set, wrap='word') self.result_text.pack(fill='both', expand=True) scrollbar.config(command=self.result_text.yview) def _create_number_generation_content(self, parent: Frame): """创建数字生成模块的动态内容""" content_frame = Frame(parent) content_frame.pack(fill='both', expand=True, padx=10, pady=10) # 胆码输入区 dan_frame = Frame(content_frame) dan_frame.pack(fill='x', pady=5) # 前区胆码 front_dan_frame = Frame(dan_frame) front_dan_frame.pack(fill='x') Label(front_dan_frame, text="前区胆码:").pack(side='left') self.front_dan_entries = [] for i in range(5): entry = Entry(front_dan_frame, width=3) entry.pack(side='left', padx=2) self.front_dan_entries.append(entry) self.front_dan_entry = self.front_dan_entries[0] # 保存第一个条目引用 # 后区胆码 back_dan_frame = Frame(dan_frame) back_dan_frame.pack(fill='x') Label(back_dan_frame, text="后区胆码:").pack(side='left') self.back_dan_entries = [] for i in range(5): entry = Entry(back_dan_frame, width=3) entry.pack(side='left', padx=2) self.back_dan_entries.append(entry) self.back_dan_entry = self.back_dan_entries[0] # 保存第一个条目引用 # 生成的号码显示区 generated_frame = Frame(content_frame) generated_frame.pack(fill='x', pady=5) Label(generated_frame, text="生成号码:").pack(anchor='w') self.generated_labels = [] for i in range(1, 6): frame = Frame(generated_frame) frame.pack(fill='x') Label(frame, text=f"{i}.").pack(side='left') label = Label(frame, text="", width=30, anchor='w') label.pack(side='left') self.generated_labels.append(label) # 结果显示区 result_frame = Frame(content_frame) result_frame.pack(fill='both', expand=True) scrollbar = Scrollbar(result_frame) scrollbar.pack(side='right', fill='y') self.result_text = Text(result_frame, yscrollcommand=scrollbar.set, wrap='word') self.result_text.pack(fill='both', expand=True) scrollbar.config(command=self.result_text.yview) def _run_module(self, module: str): """运行模块""" if module == "input_analysis": # 获取排除号码 exclude_front = self.exclude_front_entry.get() exclude_back = self.exclude_back_entry.get() # 发布排除号码事件 exclude_event = Event( event_id=int(time.time()), type=EventType.EXCLUDE_NUMBERS, source='main_ui', target='pool', data={ 'exclude_front': exclude_front, 'exclude_back': exclude_back } ) event_center.publish(exclude_event) # 在结果文本中记录 self.result_text.insert('end', f"已设置排除号码: 前区 {exclude_front}, 后区 {exclude_back}\n") # 发布模块运行事件 run_event = Event( event_id=int(time.time()), type=EventType.MODULE_RUN, source='main_ui', target=module ) event_center.publish(run_event) def _generate_recommend_numbers(self, exclude_front: str, exclude_back: str): """生成推荐号码（示例逻辑）""" # 实际应用中应调用分析模块生成推荐号码 # 这里简化为生成随机推荐号码 import random # 前区号码范围1-35 all_front = [str(idx) for idx in range(1, 36)] exclude_front_list = exclude_front.split() if exclude_front else [] available_front = [num for num in all_front if num not in exclude_front_list] # 后区号码范围1-12 all_back = [str(idx) for idx in range(1, 13)] exclude_back_list = exclude_back.split() if exclude_back else [] available_back = [num for num in all_back if num not in exclude_back_list] # 随机选择5个前区号码 if len(available_front) >= 5: recommend_front = random.sample(available_front, 5) else: recommend_front = random.sample(all_front, 5) # 随机选择2个后区号码 if len(available_back) >= 2: recommend_back = random.sample(available_back, 2) else: recommend_back = random.sample(all_back, 2) # 更新推荐号码显示 self.recommend_front_var.set(' '.join(sorted(recommend_front, key=int))) self.recommend_back_var.set(' '.join(sorted(recommend_back, key=int))) # 在结果文本中记录 self.result_text.insert('end', f"生成推荐号码: 前区 {self.recommend_front_var.get()}, 后区 {self.recommend_back_var.get()}\n") # 更新号码池 self._update_pool_with_recommendations(self.recommend_front_var.get(), self.recommend_back_var.get()) def _update_pool_with_recommendations(self, front: str, back: str): """用推荐号码更新号码池""" # 发布事件更新号码池 update_event = Event( event_id=int(time.time()), type=EventType.POOL_UPDATE, source='input_analysis', target='pool', data={ 'front_numbers': front, 'back_numbers': back } ) event_center.publish(update_event) # 在结果文本中记录 self.result_text.insert('end', "号码池已更新\n") def _clear_module_data(self, module: str): """清除模块数据""" if module == "input_analysis": if hasattr(self, 'front_entry') and self.front_entry: self.front_entry.delete(0, 'end') if hasattr(self, 'back_entry') and self.back_entry: self.back_entry.delete(0, 'end') if hasattr(self, 'exclude_front_entry') and self.exclude_front_entry: self.exclude_front_entry.delete(0, 'end') if hasattr(self, 'exclude_back_entry') and self.exclude_back_entry: self.exclude_back_entry.delete(0, 'end') if hasattr(self, 'recommend_front_var'): self.recommend_front_var.set('') if hasattr(self, 'recommend_back_var'): self.recommend_back_var.set('') if hasattr(self, 'result_text') and self.result_text: self.result_text.delete(1.0, 'end') elif module == "combination_analysis": if hasattr(self, 'front_hot_entry') and self.front_hot_entry: self.front_hot_entry.delete(0, 'end') if hasattr(self, 'front_freq_entry') and self.front_freq_entry: self.front_freq_entry.delete(0, 'end') if hasattr(self, 'front_freq_rec_entry') and self.front_freq_rec_entry: self.front_freq_rec_entry.delete(0, 'end') if hasattr(self, 'back_hot_entry') and self.back_hot_entry: self.back_hot_entry.delete(0, 'end') if hasattr(self, 'back_freq_entry') and self.back_freq_entry: self.back_freq_entry.delete(0, 'end') if hasattr(self, 'back_infreq_rec_entry') and self.back_infreq_rec_entry: self.back_infreq_rec_entry.delete(0, 'end') if hasattr(self, 'result_text') and self.result_text: self.result_text.delete(1.0, 'end') def _save_module_data(self, module: str): """保存模块数据""" try: data = {} if module == "input_analysis": data['front'] = self.front_entry.get() data['back'] = self.back_entry.get() data['exclude_front'] = self.exclude_front_entry.get() data['exclude_back'] = self.exclude_back_entry.get() data['recommend_front'] = self.recommend_front_var.get() data['recommend_back'] = self.recommend_back_var.get() data['result'] = self.result_text.get(1.0, 'end') elif module == "combination_analysis": data['front_hot'] = self.front_hot_entry.get() data['front_freq'] = self.front_freq_entry.get() data['front_freq_rec'] = self.front_freq_rec_entry.get() data['back_hot'] = self.back_hot_entry.get() data['back_freq'] = self.back_freq_entry.get() data['back_infreq_rec'] = self.back_infreq_rec_entry.get() data['result'] = self.result_text.get(1.0, 'end') # 其他模块数据收集... filename = f"{module}_data.json" with open(filename, 'w', encoding='utf-8') as f: json.dump(data, f, indent=2, ensure_ascii=False) messagebox.showinfo("保存成功", f"数据已保存到{filename}") except Exception as e: messagebox.showerror("保存失败", str(e)) logging.error(f"保存数据失败: {str(e)}", exc_info=True) def _handle_exclude_numbers(self, event: Event): """处理排除号码事件""" if event.data: exclude_front = event.data.get('exclude_front', '') exclude_back = event.data.get('exclude_back', '') # 更新排除号码显示 self.exclude_front_entry.delete(0, 'end') self.exclude_front_entry.insert(0, exclude_front) self.exclude_back_entry.delete(0, 'end') self.exclude_back_entry.insert(0, exclude_back) # 在结果文本中记录 self.result_text.insert('end', f"收到排除号码: 前区 {exclude_front}, 后区 {exclude_back}\n") def _handle_module_complete(self, event: Event): self.status_var.set(f"{event.source} 模块运行完成") if hasattr(self, 'result_text') and self.result_text: self.result_text.insert('end', f"\n{event.source} 模块已完成分析\n") def _on_module_renovate(self, module: str): """刷新模块""" if module == self.current_module: self._on_module_button_click(module) def _handle_ui_update(self, event: Event): """处理UI更新事件""" if not event.data or 'update_type' not in event.data: return update_type = event.data['update_type'] data = event.data.get('data', {}) # 处理核心变量更新 if update_type == 'organized_data': # 确保所有核心变量已初始化 if not hasattr(self, 'core_vars'): self.core_vars = { 'front_area': StringVar(), 'back_area': StringVar(), 'front_hot': StringVar(), 'front_cold': StringVar(), 'back_hot': StringVar(), 'back_cold': StringVar() } # 更新界面变量 self.core_vars['front_area'].set(str(data.get('front_numbers', []))) self.core_vars['back_area'].set(str(data.get('back_numbers', []))) self.core_vars['front_hot'].set(str(data.get('front_hot', []))) self.core_vars['front_cold'].set(str(data.get('front_cold', []))) self.core_vars['back_hot'].set(str(data.get('back_hot', []))) self.core_vars['back_cold'].set(str(data.get('back_cold', [])))
07-16
event_center.subscribe(EventType.EXCLUDE_NUMBERS, self._handle_exclude_numbers) def _setup_ui(self): self.root.title(f"大乐透智能分析平台 - {GlobalConfig.VERSION}") self.root.geometry("1400x800")...
``` import asyncio import re from wechaty import MessageType from wechaty.user import Message from bridge.context import ContextType from channel.chat_message import ChatMessage from common.log import logger from common.tmp_dir import TmpDir class aobject(object): """Inheriting this class allows you to define an async __init__. So you can create objects by doing something like `await MyClass(params)` """ async def __new__(cls, *a, **kw): instance = super().__new__(cls) await instance.__init__(*a, **kw) return instance async def __init__(self): pass class WechatyMessage(ChatMessage, aobject): async def __init__(self, wechaty_msg: Message): super().__init__(wechaty_msg) room = wechaty_msg.room() self.msg_id = wechaty_msg.message_id self.create_time = wechaty_msg.payload.timestamp self.is_group = room is not None if wechaty_msg.type() == MessageType.MESSAGE_TYPE_TEXT: self.ctype = ContextType.TEXT self.content = wechaty_msg.text() elif wechaty_msg.type() == MessageType.MESSAGE_TYPE_AUDIO: self.ctype = ContextType.VOICE voice_file = await wechaty_msg.to_file_box() self.content = TmpDir().path() + voice_file.name # content直接存临时目录路径 def func(): loop = asyncio.get_event_loop() asyncio.run_coroutine_threadsafe(voice_file.to_file(self.content), loop).result() self._prepare_fn = func else: raise NotImplementedError("Unsupported message type: {}".format(wechaty_msg.type())) from_contact = wechaty_msg.talker() # 获取消息的发送者 self.from_user_id = from_contact.contact_id self.from_user_nickname = from_contact.name # group中的from和to，wechaty跟itchat含义不一样 # wecahty: from是消息实际发送者, to:所在群 # itchat: 如果是你发送群消息，from和to是你自己和所在群，如果是别人发群消息，from和to是所在群和你自己 # 但这个差别不影响逻辑，group中只使用到：1.用from来判断是否是自己发的，2.actual_user_id来判断实际发送用户 if self.is_group: self.to_user_id = room.room_id self.to_user_nickname = await room.topic() else: to_contact = wechaty_msg.to() self.to_user_id = to_contact.contact_id self.to_user_nickname = to_contact.name if self.is_group or wechaty_msg.is_self(): # 如果是群消息，other_user设置为群，如果是私聊消息，而且自己发的，就设置成对方。 self.other_user_id = self.to_user_id self.other_user_nickname = self.to_user_nickname else: self.other_user_id = self.from_user_id self.other_user_nickname = self.from_user_nickname if self.is_group: # wechaty群聊中，实际发送用户就是from_user self.is_at = await wechaty_msg.mention_self() if not self.is_at: # 有时候复制粘贴的消息，不算做@，但是内容里面会有@xxx，这里做一下兼容 name = wechaty_msg.wechaty.user_self().name pattern = f"@{re.escape(name)}(\u2005|\u0020)" if re.search(pattern, self.content): logger.debug(f"wechaty message {self.msg_id} include at") self.is_at = True self.actual_user_id = self.from_user_id self.actual_user_nickname = self.from_user_nickname```你修改后的代码里class WechatyMessage(ChatMessage, metaclass=AsyncInitMeta): async def __init__(self, wechaty_msg: Message): super().__init__(wechaty_msg) 这里面async 的问题依然存在 还是报错
03-26
3. 修改`WechatyMessage`的`__init__`方法，正确处理父类初始化，可能需要使用`await super().__init__(wechaty_msg)`，但这要求父类的`__init__`也是异步的。 如果`ChatMessage`的`__init__`是同步的，不能在子类...
self.xxx 和 _xx 的区别
建古的编码生活
12-01 1115
在项目开发中实际应用到的 在赋值和取值的时候 不懂self.xx 和 _xx的区别，使用起来貌似差不多！不过有这样的出来还是有差别 self.xx 调用了该类的setter和getter方法； _xx 直接获取自己的实例变量。@property (nonatomic,copy) NSString *userName; self.userName是对属性的访问， _userName是对局部变量的
self.跟self->什么区别？
weixin_30740295的博客
10-22 1277
1> self.是调用get方法 2> self.是当前本身，是一个指向当前对象的指针 3> self->是直接访问成员变量 转载于:https://www.cnblogs.com/yxxxiaoxiao/p/4900924.html...
property之self.xx与_xx的区别
DCSnail-蜗牛
01-29 1437
关于self.xx和_xx, 是同一个指针,只是前者调用该类的setter或getter方法，后者直接获取自己的实例变量。即这个问题也就演变成了属性(property)和实例变量(instance variable)的区别了。 直接区别: 通过setter和getter方法和通过实例变量的区别 OC 2.0之后属性一旦声明，如果没有readonly修饰的话，当前类自动生成了setter
使用self和_(下划线)的区别
eastWind1101的博客
07-25 490
self和_调用属性的区别
property之 self.xx与_xx的区别
plpldog的博客
08-24 613
关于self.xx和_xx, 是同一个指针,只是前者调用该类的setter或getter方法，后者直接获取自己的实例变量。即这个问题也就演变成了属性(property)和实例变量(instance variable)的区别了。 直接区别: 通过setter和getter方法和通过实例变量的区别 OC 2.0之后属性一旦声明，如果没有readonly修饰的话，当前类自动生成了setter和g...
objective c关于下划线和双下划线的用法
LVXIANGAN的专栏
01-27 9781
关于@synthesis、变量、属性、属性名前面下划线的问题 那个下划线只是为了方便区别全局变量和本地变量,或者防止变量重名,只是一种编程风格,实际上对代码没有实质影响,更无法替代@synthesize语句的功能。你只要记住一个真理， 凡是在头文件里面定义了@property的变量，必定要@synthesize。 看到很多源代码里面，使用前面带下划线变量，然后在@synthesize
Python中self用法详解
weixin_34032621的博客
10-13 414
在介绍Python的self用法之前，先来介绍下Python中的类和实例…… 我们知道，面向对象最重要的概念就是类（class）和实例（instance），类是抽象的模板，比如学生这个抽象的事物，可以用一个Student类来表示。而实例是根据类创建出来的一个个具体的“对象”，每一个对象都从类中继承有相同的方法，但各自的数据可能不同。 1、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值