揭秘Python类初始化机制:__init__和__init_subclass__你真的用对了吗?

【Python】面向对象:类,继承、初始化、调用函数、方法 面向对象编程(Object-Oriented Programming,简称OOP)是一种程序设计模型,它将对象作为程序的基本单元,以提高软件的可重用性、灵活性和扩展性。Python是一种支持面向对象编程的语言。 在Python中,面向对象编程主要涉及以下几个核心概念: 类(Class)、对象(Object)、封装(Encapsulation)、继承(Inheritance)、多态(Polymorphism) 阅读详情

第一章:Python类初始化机制概述

在Python中,类的初始化是对象创建过程中的关键环节,决定了实例的状态和行为。这一过程主要由构造方法 `__init__` 触发,在对象被创建后自动执行,用于设置实例属性和完成必要的初始化逻辑。

类初始化的基本流程

当通过类名调用创建实例时,Python首先调用 `__new__` 方法生成一个空对象,随后自动调用 `__init__` 方法对其进行初始化。开发者通常关注 `__init__`,因为它允许传入参数并赋值给实例变量。
class Person:
    def __init__(self, name, age):
        self.name = name  # 初始化姓名
        self.age = age    # 初始化年龄

# 创建实例,触发 __init__
p = Person("Alice", 30)
上述代码中,`__init__` 接收 `name` 和 `age` 参数,并将其绑定到实例上。每次创建 `Person` 对象时,都必须提供这两个参数,否则将引发异常。

初始化参数的灵活性

Python支持默认参数和可变参数,使得初始化更加灵活。以下表格展示了不同参数形式的应用场景:
参数类型示例用途说明
必传参数def __init__(self, name)每次实例化必须提供
默认参数def __init__(self, name, age=18)未传时使用默认值
可变参数def __init__(self, *args)接收任意数量位置参数
  • 初始化发生在对象创建之后、使用之前
  • __init__ 不应返回非 None 值,否则会引发 TypeError
  • 可通过 super() 调用父类的 __init__ 实现继承初始化

第二章:深入理解__init__方法

2.1 __init__的基本语法与执行时机

在 Python 中,`__init__` 是类实例化时自动调用的初始化方法,用于设置对象的初始状态。它并非构造器本身(真正的构造器是 `__new__`),而是在对象创建后立即执行。
基本语法结构
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
上述代码中,`__init__` 接收 `self`(指向新创建的实例)以及自定义参数。当执行 `p = Person("Alice", 30)` 时,`__init__` 自动运行,将传入值绑定到实例属性。
执行时机详解
  • 在 `__new__` 创建实例后自动调用
  • 每次实例化对象时都会触发
  • 若未显式定义,Python 会查找父类中的 `__init__`
该方法不返回值(应返回 None),否则可能引发 TypeError。正确使用 `__init__` 能确保对象在诞生之初即具备完整可用的状态。

2.2 实例属性的初始化策略与最佳实践

在面向对象编程中,实例属性的初始化直接影响对象状态的稳定性和可维护性。合理的初始化策略能避免未定义行为并提升代码可读性。
构造函数内集中初始化
推荐在构造函数中统一初始化所有实例属性,确保对象创建时即处于有效状态。
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.is_active = True  # 默认值显式声明
上述代码在 __init__ 中初始化核心属性,并为 is_active 提供合理默认值,避免后续访问时出现 AttributeError。
延迟初始化与属性装饰器
对于开销较大的属性,可采用延迟初始化(Lazy Initialization)结合 @property 实现。
  • 减少构造时资源消耗
  • 提升实例创建效率
  • 按需加载复杂数据

2.3 父类与子类中__init__的调用链管理

在面向对象编程中,正确管理父类与子类的构造函数调用链是确保对象初始化完整性的关键。Python 中通过 `super()` 函数实现这一机制,避免父类被重复或遗漏调用。
调用链的基本模式
使用 `super().__init__()` 可显式调用父类的初始化方法,保证多继承下的方法解析顺序(MRO)正确执行。
class Parent:
    def __init__(self, name):
        self.name = name
        print("Parent initialized")

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
        print("Child initialized")
上述代码中,`super().__init__(name)` 确保 `Parent` 类的初始化逻辑被执行,`self.name` 被正确赋值。参数 `name` 由子类传递给父类,实现数据的逐级构建。
多继承中的调用顺序
当存在多个父类时,Python 遵循 MRO 规则线性化调用链。可通过 `ClassName.__mro__` 查看调用顺序,确保每个类的 `__init__` 仅执行一次。

2.4 使用*args和**kwargs实现灵活初始化

在Python类的初始化过程中,*args和**kwargs为构造函数提供了高度的灵活性,允许接收任意数量的位置参数和关键字参数。
基本语法与作用
class FlexibleInit:
    def __init__(self, name, *args, **kwargs):
        self.name = name
        self.args = args
        self.kwargs = kwargs
其中,*args收集额外的位置参数为元组,**kwargs收集额外的关键字参数为字典。这使得同一个构造函数能适应多种输入形式。
实际应用场景
  • 构建可扩展的数据模型基类
  • 实现继承时避免显式传递所有参数
  • 封装第三方库对象时保持接口开放
通过合理使用这两个参数,可以显著提升代码的复用性和可维护性。

2.5 常见__init__使用误区与陷阱分析

默认参数使用可变对象
一个常见陷阱是在 __init__ 中使用可变对象(如列表或字典)作为默认参数值,这会导致所有实例共享同一对象。

class BadExample:
    def __init__(self, items=[]):
        self.items = items

a = BadExample()
b = BadExample()
a.items.append(1)
print(b.items)  # 输出: [1],意外共享了列表
上述代码中,items 默认指向同一个列表对象。正确做法是使用 None 并在方法体内初始化:

class GoodExample:
    def __init__(self, items=None):
        self.items = items if items is not None else []
父类初始化遗漏
在继承场景中,若未显式调用父类的 __init__,可能导致父类属性未初始化。
  • 使用 super().__init__() 确保继承链完整
  • 多重继承时注意 MRO(方法解析顺序)影响

第三章:探秘__init_subclass__钩子机制

3.1 __init_subclass__的引入背景与作用原理

Python 在类系统设计上持续演进,__init_subclass__ 自 Python 3.6 起被引入,旨在解决传统元类过于复杂、侵入性强的问题。该方法允许父类在子类创建时自动执行初始化逻辑,简化了类的定制流程。
核心机制
当定义一个类继承自某父类时,Python 会自动调用父类的 __init_subclass__ 方法,开发者可在此注入钩子逻辑:

class PluginBase:
    registered_plugins = []

    def __init_subclass__(cls, plugin_name=None, **kwargs):
        super().__init_subclass__(**kwargs)
        if plugin_name:
            cls.registered_plugins.append(plugin_name)

class MyPlugin(PluginBase, plugin_name="example"):
    pass
上述代码中,每次定义新插件类时,其名称自动注册到全局列表。参数说明: - cls:正在创建的子类; - plugin_name:通过关键字参数传入的自定义配置; - **kwargs:传递给父类的额外参数,避免干扰其他类构造逻辑。 此机制降低了元类使用的必要性,提升了代码可读性与模块化程度。

3.2 自定义类创建行为:参数传递与预处理

在Python中,类的创建过程可通过`__new__`和元类进行深度定制。参数传递不仅限于`__init__`,更可在实例化前对输入进行验证与转换。
参数预处理示例
class ValidatedClass:
    def __new__(cls, value):
        if not isinstance(value, int):
            raise TypeError("值必须为整数")
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        self.value = abs(value)  # 预处理:取绝对值
上述代码中,__new__控制实例创建,确保类型安全;__init__则对参数做逻辑规范化。
常见预处理策略
  • 类型检查与自动转换(如字符串转数值)
  • 边界校验(如限制数值范围)
  • 默认值填充与字段映射

3.3 元类之外的新选择:__init_subclass__的应用场景

Python 3.6 引入的 `__init_subclass__` 提供了一种更简洁的类创建定制方式,相比复杂的元类机制,更适合大多数场景。
自动注册子类
常用于插件系统或序列化框架中,子类可自动注册到全局 registry:

class PluginBase:
    registry = {}

    def __init_subclass__(cls, name=None, **kwargs):
        super().__init_subclass__(**kwargs)
        plugin_name = name or cls.__name__
        PluginBase.registry[plugin_name] = cls

class MyPlugin(PluginBase, name="custom"):
    pass
代码中,`__init_subclass__` 在子类定义时自动执行,将类注册到 `registry`。参数 `name` 支持自定义注册名,`**kwargs` 确保与未来扩展兼容。
强制属性检查
可用于验证子类是否实现必要属性:
  • 避免运行时因缺失字段导致错误
  • 提升框架的健壮性和开发体验

第四章:综合应用与高级技巧

4.1 利用__init_subclass__实现注册表模式

Python 的 `__init_subclass__` 是一种在类创建时自动执行的机制,可用于实现注册表模式,避免手动注册子类。
自动注册机制
通过重写 `__init_subclass__`,可在每个子类定义时将其自动加入全局注册表:

class Plugin:
    registry = {}

    def __init_subclass__(cls, name=None, **kwargs):
        super().__init_subclass__(**kwargs)
        if name is not None:
            Plugin.registry[name] = cls

class HTTPPlugin(Plugin, name="http"):
    pass

class FTPPlugin(Plugin, name="ftp"):
    pass
上述代码中,`__init_subclass__` 接收额外参数 `name`,并将子类按名称注册到 `registry` 字典。`super().__init_subclass__(**kwargs)` 确保父类链正确初始化。
注册表优势
  • 消除重复的手动注册代码
  • 提升模块可扩展性,新增插件无需修改注册逻辑
  • 支持编译期(类创建期)注册,提高运行时效率

4.2 构建可扩展框架:自动发现子类并初始化配置

在构建可扩展系统时,自动发现子类并加载对应配置是实现插件化架构的关键。通过反射机制,可在程序启动时扫描特定包路径下的所有类型,筛选继承自基类或实现特定接口的子类。
子类自动注册示例

// RegisterSubclasses 扫描并注册所有实现了 Processor 接口的子类
func RegisterSubclasses() {
    for _, typ := range findTypesImplementing(processorInterface) {
        instance := reflect.New(typ).Elem().Interface()
        if processor, ok := instance.(Processor); ok {
            processors[typ.Name()] = processor
            LoadConfig(typ.Name()) // 自动加载对应配置
        }
    }
}
上述代码利用反射遍历已知类型集合,判断是否实现指定接口,并实例化后注入全局处理器映射。LoadConfig 根据类型名加载 YAML 或环境变量配置,实现解耦。
配置映射表
子类名称配置文件路径启用状态
DataProcessorconfig/data.yamltrue
LogProcessorconfig/log.yamlfalse

4.3 结合描述符与类装饰器的协同初始化方案

在复杂对象初始化过程中,描述符与类装饰器的结合可实现声明式配置与自动注册机制。
协同工作机制
类装饰器负责扫描并修改类定义,而描述符拦截实例属性访问,二者协作完成延迟初始化与元数据管理。

def tracked(cls):
    for key, value in cls.__dict__.items():
        if isinstance(value, TrackedDescriptor):
            value.name = key
    return cls

class TrackedDescriptor:
    def __init__(self):
        self.name = None
    def __get__(self, instance, owner):
        if instance is None: return self
        return instance.__dict__.get(self.name)
    def __set__(self, instance, value):
        instance.__dict__[self.name] = f"Tracked:{value}"
上述代码中,装饰器 tracked 注入描述符所需的名称信息,解决描述符独立无法获知绑定属性名的问题。描述符则统一处理赋值格式化,实现关注点分离。该模式适用于ORM字段定义、配置中心参数注入等场景。

4.4 避免副作用:安全编写类级初始化逻辑

在类的初始化阶段,不恰当的操作可能引发难以追踪的副作用。应避免在类定义时执行网络请求、文件读写或启动线程等外部交互。
初始化中的常见陷阱
  • 在类体中直接调用外部服务
  • 依赖全局状态导致测试困难
  • 静态字段初始化顺序问题
推荐实践:延迟初始化
使用惰性加载确保资源在首次访问时才被创建:

type Database struct {
    conn *sql.DB
}

var instance *Database
var once sync.Once

func GetInstance() *Database {
    once.Do(func() {
        instance = &Database{
            conn: connectToDB(), // 延迟执行
        }
    })
    return instance
}
上述代码通过 sync.Once 保证初始化逻辑仅执行一次,避免并发竞争。函数 connectToDB() 不在包加载时调用,从而隔离了副作用,提升程序可测试性与模块化程度。

第五章:总结与最佳实践建议

持续集成中的配置管理
在现代 DevOps 流程中,统一的配置管理是保障服务稳定性的关键。使用环境变量而非硬编码配置可显著提升部署灵活性。

// config.go
package main

import "os"

type Config struct {
    DBHost string
    Port   int
}

func LoadConfig() *Config {
    return &Config{
        DBHost: os.Getenv("DB_HOST"), // 从环境变量加载
        Port:   5432,
    }
}
微服务通信的安全策略
服务间调用应强制启用 mTLS(双向 TLS),避免内部流量被窃听。Istio 等服务网格可通过以下策略自动注入证书:
  1. 为每个命名空间启用自动 sidecar 注入
  2. 部署 PeerAuthentication 策略强制 mTLS
  3. 通过 AuthorizationPolicy 限制服务访问权限
性能监控的关键指标
真实案例显示,某电商平台因未监控慢查询导致数据库雪崩。建议核心指标纳入监控系统:
指标类型采集方式告警阈值
API 响应延迟(P99)Prometheus + Exporter>800ms 持续 2 分钟
数据库连接数MySQL Performance Schema>最大连接数 80%
[Client] → (Load Balancer) → [Service A] ↘ → [Service B] → [Database]
元类魔法揭秘:那 99% 的优雅与 1% 的必需 摘要: 元类是Python中创建类的"类",99%的场景可通过装饰器、__init_subclass__或dataclass替代。但在关键1%场景(如框架开发、单例模式)中,元类展现不可替代的价值。本文通过Django ORM字段系统、线程安全单例等案例,揭示元类的本质与适用边界,帮助开发者在复杂场景中优雅解决问题,同时避免过度设计。理解元类不是为了日常使用,而是为了在必要时掌握这把"深度魔法"钥匙。 阅读详情

相关推荐

【护网行动-红蓝攻防】第一章-红蓝对抗基础 认识红蓝紫

军事上的演练,是除了实战以外最能检验军队战斗力的一种考核方式,他可以模拟面对外部势力的攻击时候,如何更好的去维护国家和主权的安全。同样的,在网络上面,真实环境下的网络攻防演练也是检验一个单位,企业网络防御能力,发现潜在危险最好的方法。1.政策要求2安全威胁驱动当前,我国关键信息基础设施面临的网络安全形势严峻复杂,网站平台大规模数据泄露事件频发,生产业务系统安全隐患突出,甚至有的系统长期被控面对高级持续性的网络攻击,防护能力十分欠缺。目前,我国面临的网络安全威胁主要有以下几点。

wxh的博客 1576

python继承相关知识--父类init调用

1、子类调用父类init构造函数的两种方法: 1)无参构造函数调用 class A(): def __init__(self): print("父类的构造函数") class B(A): def __init__(self): #如果父类有构造函数,子类必须写构造函数,否则会报错 A.__init__(self) #方法一,注意这里有se...

测试媛 1705

HAL库硬件SPI驱动ST7735 TFT屏幕:从零实现高效刷屏与图形绘制

本文详细介绍了如何使用STM32的HAL库硬件SPI驱动ST7735 TFT屏幕,从硬件连接到SPI配置优化,再到图形绘制与文本显示的实现。重点分享了DMA传输、局部刷新等高级优化技巧,显著提升刷屏效率,帮助开发者快速掌握屏幕驱动技术并应用于实际项目。

pink的博客 741

python子类、父类的__init__函数

验证了python子类、父类__init__函数的几种组合

听海边涛声 1547

32GB Jetson Orin SOM 不能刷机问题排查

拿到了一个新的Orin SOM,当用orin Devkit CVB或定制的CVB不能用Linux_For_Tegra刷机,flash日志(JetPack5.0DP和5.0.1DP都失败了) 2. 确认mb2配置中将CVB的eeprom读取大小设置是否为0 ? 已经确认是正常的 在定制的orin cvb flash上使用Orin devkit som,启动是成功的。但新得到的Orin som并不工作可以排除理由:使用Orin Devkit CVB和Orin SOM(不是Devkit SOM)仍然不能

jzwjzw19900922的博客 1499

【GD32】DMA及串口应用

GD32 DMA控制器指南摘要 GD32 DMA控制器通过硬件直接管理数据传输,显著减轻CPU负担。主要特性包括: 双DMA控制器共14通道 支持内存/外设间多种传输方向 可配置数据宽度(8/16/32位) 地址自动递增和循环模式 配置流程: 使能DMA时钟 初始化参数(地址/方向/宽度等) 使能通道 配置外设DMA请求 典型应用场景: USART DMA发送:内存数据批量传输到串口 ADC DMA接收:循环模式实现连续采样 DMA通过硬件加速数据传输,提高系统效率,特别适合大数据量传输场景。

m0_58087444的博客 1567

python基本运用:类的介绍和使用

类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例实例化:创建一个类的实例,类的具体对象。对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法1、方法:类中定义的函数2、类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。3、实例变量:在类的声明中,属性是用变量来表示的,这种变量就称为实例变量,实例变量就是一个用 self 修饰的变量。

user_name_admin2的博客 1178

HQChart实战教程64-自定义分时图标题栏

分时图标题栏显示的是当前十字光标所在位置的分钟信息,显示在分时图窗口顶部。一般会显示品种的名称,日期,时间,价格,均价 涨幅,成交量,金额等等,hqchart内置会显示这些信息。如果要额外显示其他的字段,就需要通过替换格式化标题输出函数来是现实。我们在hqchart实例创建完成以后,通过OnCreatedCallback回调函数替换自己的格式化输出函数。返回 { AryText:[ { Text:文字, Color:颜色},…入参 data={ Data: 当前十字光标所在位置的分钟线 }

小银 1057

python--初始化

print(rect.width) # 输出: 5print(rect.height) # 输出: 10print(rect.area) # 输出: 50。

zhao的博客 2168

AI上推荐 之 多任务loss优化(自适应权重篇)

1. 写在前面 在多任务学习中,往往会将多个相关的任务放在一起来学习。例如在推荐系统中,排序模型同时预估候选的点击率和浏览时间。相对于单任务学习,多任务学习有以下优势: 多个任务共享一个模型,占用内存量减少; 多个任务一次前向计算得出结果,推理速度增加; 关联任务通过共享信息,相互补充,可以提升彼此的表现。 前面的一篇文章,主要是从模型结构的角度聊了下多任务学习,介绍了工业界非常经典也常用的MMOE模型,然而,对于多任务学习, Loss的优化也非常重要, 因为我们知道通过多个目标去指导网络进行统一的训练

Miracle8070 1万+

【ComfyUI】【Nunchaku】【diffusers报错解决】秋叶整合包安装 Nunchaku 报错的解决方法

最近在折腾 AI 绘图时,我尝试在秋叶的 ComfyUI 整合包中安装 `ComfyUI-nunchaku` 插件(版本 0.3.3),结果启动后直接报错,提示无法从 `accelerate.utils.memory` 中导入 `clear_device_cache`,让我一度怀疑插件是否兼容。查阅了一堆 issue 和源码之后,总算找到了原因和解决方法。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 1864

揭秘 Python 的造物术:深入理解元类(Metaclass)

摘要:本文深入探讨Python中的元类(Metaclass)概念及其应用。首先从"类也是对象"的基本原理出发,揭示元类作为"类的类"的本质。通过代码示例展示了普通类与元类创建方式的区别,并详细解析了元类工作流中的__new__和__init__方法。文章重点演示了元类在ORM框架设计中的实战应用,包括自动添加类属性和实现简易ORM模型,通过ModelMeta元类自动映射数据库字段。这些内容为理解Python高级特性及框架设计原理提供了实践指导。

weixin_42636075的博客 2152

黑猫带你学UFS协议第12篇:UFS标志(Flags)和属性(Atrributes)详解

UFS中的标志其实就是一些开关,布尔型,非0即1,打开或者关闭。这些标志可以用来使能或者禁止UFS设备的一些功能、模式或者状态。 简单来说,flag和attribute、discriptor一样,都是ufs的寄存器罢了。只不过spec将这些寄存器分类了,分成这三种大的类型了而已。 标志可以被清除、复位、设置、触发、读。 主机也是通过设备管理器的Query Request UPIU来读取或者写标志。

黑猫奥利奥的博客 2086

【Python类继承深度解析】:揭秘__init_subclass__的调用时机与底层机制

掌握Python类继承关键机制,深入解析__init_subclass__的调用时机。适用于自定义类行为、框架开发等场景,揭示其在子类创建时自动触发的底层原理与应用优势,提升代码可维护性,值得收藏。

ProceSeed的博客 324

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

深入理解Python类创建过程(__init_subclass__调用时机大揭秘)

掌握Python类创建核心机制,深入解析__init_subclass__的调用时机。揭示其在子类定义时自动触发的特点,适用于框架设计与元类替代场景,提升代码可维护性与灵活性。原理清晰、示例易懂,值得收藏。

IterLoom的博客 383

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

【Python高级魔法方法揭秘】:__init_subclass__的调用时机你真的懂吗?

掌握__init_subclass__的调用时机,深入理解Python类创建机制。本文解析其在子类定义时的自动触发原理,适用于元类编程与框架设计,提升代码灵活性与可维护性,是Python高级开发的必备知识,值得收藏。

LiteCode的博客 274

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

揭秘__init_subclass__的调用时机:99%的Python开发者都忽略的关键细节

掌握__init_subclass__的调用时机,深入理解Python类创建机制。适用于框架设计与元类替代场景,提升代码可维护性与灵活性。详解执行流程与实际应用优势,值得收藏。

QuickCode的博客 313

Python元类实现LazyLLM自动注册机制解析

元类作为Python的高级特性,是理解类创建过程的关键。通过重写__init__等方法,元类可以在类定义阶段实现自动注册等控制逻辑,这种机制在框架开发中尤为重要。LazyLLM框架创新性地利用元类实现了'继承即注册'的特性,相比传统显式注册或装饰器方案,大幅减少了样板代码。该技术在插件系统、策略模式等场景有广泛应用价值,特别是在需要动态加载组件的分布式系统中,结合WeakValueDictionary可避免内存泄漏问题。理解元类与注册表协同工作的原理,有助于开发者构建更灵活的Python架构。

weixin_32612263的博客 322

深入Python元编程:Metaclass实战与高级应用揭秘

元类是Python元编程的巅峰,通过重写或__call__,我们可以在类创建和实例化阶段注入自定义行为。本文展示的自动属性修改、单例、接口校验、自动注册和日志记录等实战案例,覆盖了框架开发中最常用的场景。然而,能力越大责任越大,在使用元类前,务必权衡是否可以用更简单的方案达到目的。当你确实需要对类的创建过程进行深度控制时,让元类成为你的撒手锏吧!

huozhe01的博客 222

yasb 的 Komorebi Workspaces 工作区状态栏组件:配置、交互与源码级实现解析

`komorebi.workspaces.WorkspaceWidget` 是 yasb(Yet Another Status Bar)内置的 Windows 平铺窗口管理器 Komorebi 工作区组件,它能在状态栏上以按钮形式展示当前显示器上的全部工作区,并通过清晰的 EMPTY / POPULATED / ACTIVE 三种状态标识活跃度。本文将完整讲解该组件的全部配置项(含默认值、格式串占

gitblog_00006的博客 374

关于python中子类继承父类init的三种方法

python

weixw99的博客 7925

【知识点】python的__init__详解

__init__ 方法是 Python 中面向对象编程中类的特殊方法,也称为构造方法,当创建一个类的实例时,__init__ 方法会自动调用。

weixin_39888010的博客 3万+

简化Python数据结构初始化:从繁琐到优雅的进阶指南

简化Python数据结构初始化:从繁琐到优雅的进阶指南

KE17RS的博客 1437

类变量的初始化规则在Python中有哪些特殊类型处理?

表格变量类型初始化语法核心特性避坑方案不可变类型类内直接赋值修改需重新赋值,实例误赋值仅创建实例变量无需特殊处理,使用最安全可变类型类内直接赋值实例修改内部元素会影响所有实例如需隔离,在__init__中重新初始化依赖外部变量类内直接引用需保证引用的变量先定义避免引用未初始化的全局 / 类变量Python 类变量初始化语法上无类型豁免规则,所有类型均在类内直接赋值;核心特殊处理点是可变类型类变量:类内初始化的可变类型会被所有实例共享,需在__init__

yonghengprince的专栏 181

python子类继承父类构造函数__init__的几种情况

python子类继承父类构造函数__init__的几种情况1. 子类不重写父类的__init__方法,那么子类继承父类的__init__2. 子类重写父类的__init__方法,就不会调用父类的__init__3. 如果子类重写了__init__,要继承父类的构造方法,有两种方法 1. 子类不重写父类的__init__方法,那么子类继承父类的__init__ 实例: class Father(object): def __init__(self, name): self.name =

weixin_40734030的博客 1万+

Python_初始化方法

1. 在类的外部给对象增加属性的隐患 我们可以在一个类的外部通过对象名点(.) 的方式非常方便的给对象增加一个属性, 但这种方式存在隐患, 因为程序在运行的时候, 找到属性就可以正常执行(从上到下顺序地找), 找不到属性就会直接报错. 如果把设置name 属性这行代码放在调用方法地末尾(也就是将第15行代码挪动到第19行), 程序就不能正常执行了, 会报错. 执行到第5行的时候, 会告诉我们 Cat() 对象没有name 这个属性. 原因是Python 程序是从上到下顺序执行的, 当在第一行发现.

weixin_52073430的博客 4271
上一篇: 【专家级Pandas指南】:利用axis参数精准控制concat数据流向
下一篇: 【高效Pytest编程实战】:skipif条件判断的7种高阶应用场景
SimCompile
博客等级 码龄1年 140粉丝 2012原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值