python中的特殊方法使用

new()构造器

范例：使用“__new__()”方法

# coding : utf-8class Message:                                            # 默认object子类def __new__(cls, *args, **kwargs):                      # 特殊方法print("【new】cls = %s、args = %s、kwargs = %s" % (cls,args,kwargs))     # 提示信息return object.__new__(cls)                         # 如果不返回此内容构造方法将不会执行def __init__(self, **kwargs):                          # 构造方法print("【init】kwargs = %s" % kwargs)               # 输出构造方法接收关键字参数def main():                                               # 主函数msg = Message(title="yootk",content="优拓软件学院")     # 实例化Message类对象if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

获取对象信息

范例：观察默认状态下的对象输出

# coding : utf-8class Message:                                            # 默认object子类def __init__(self,content):                            # 构造方法初始化内容self.__content = content                           # 属性赋值def main():                                               # 主函数
msg = Message("www.yootk.com")                         # 实例化类对象print(msg)                                            # 直接输出对象    print(msg.__str__())                                  # 转为字符串输出

if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

范例：覆写“__str__()”方法

# coding : utf-8class Message:                                            # 默认object子类def __init__(self,content):                            # 构造方法初始化内容self.__content = content                           # 属性初始化def __str__(self):                                     # 覆写object类方法return "【__str__()】%s" % self.__content           # 获取对象信息def main():                                               # 主函数
msg = Message("www.yootk.com")                         # 实例化类对象print(msg)                                            # 直接输出对象if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

范例：覆写“__repr__()”方法

# coding : utf-8class Message:                                   # 默认object子类def __init__(self,content):                   # 构造方法初始化内容self.__content = content                 # 覆写特殊方法def __str__(self):                           # 覆写object类方法return "【__str__()】%s" % self.__content # 返回对象信息def __repr__(self):                          # 覆写特殊方法return "【__repr__()】%s" % self.__content # 返回对象信息def main():                                     # 主函数
msg = Message("www.yootk.com")                # 实例化类对象print(str(msg))                              # 不使用str()函数也表示调用“__str__()”print(repr(msg))                             # 必须使用repr()函数才可以调用“__repr__()”if __name__ == "__main__":                       # 判断程序执行名称
main()                                      # 调用主函数

范例：通过方法引用简化重复代码

class Message:                         # 自定义类
def __init__(self,content):         # 构造方法
self.__content = content        # 属性赋值def __str__(self):                  # 特殊方法
return "【__str__()】%s" % self.__content # 返回对象信息__repr__ = __str__                 # 方法引用定义

范例：通过Lambda简化方法定义

class Message:                         # 自定义类
def __init__(self,content):         # 构造方法
self.__content = content        # 属性赋值def __repr__(self) -> str:        # 特殊方法
return "【__str__()】%s" % self.__content # 返回对象信息

对象比较

范例：实现对象的小于判断

# coding : utf-8class Member(object):                                      # 默认object子类def __init__(self,name,age):                           # 构造方法初始化属性内容self.__name = name                                 # 实例属性赋值self.__age = age                                   # 实例属性赋值def __le__(self, other):                               # 覆写特殊方法if not isinstance(other,Member) or other == None:    # 判断对象是否合法return False                                   # 返回False，表示判断失败return self.__age <= other.__age                    # 摘选属性判断def main():                                               # 主函数
mem_a = Member("张三", 18)                             # 实例化Member类对象mem_b = Member("李四", 20)                             # 实例化Member类对象print(mem_a <= mem_b)                                  # 大小比较，调用“__le__()”if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

范例：列表中删除自定义类对象

# coding : utf-8class Member(object):                            # object子类def __init__(self,name,age):                  # 构造方法self.__name = name                       # 实例属性赋值self.__age = age                         # 实例属性赋值def __str__(self):                           # 覆写特殊方法return "姓名：%s、年龄：%d" % (self.__name, self.__age)def __eq__(self, other):                      # 覆写特殊方法if not isinstance(other,Member) or other == None:             # 判断对象是否合法return False                         # 判断失败return self.__age == other.__age and self.__name == other.__namedef main():                                     # 主函数
member_list = [Member("张三", 18), Member("李四", 20)]            # 定义人员信息列表# 删除数据时传入匿名对象，列表会调用类中“__eq__()”方法member_list.remove(Member("张三", 18))        # 删除数据for mem in member_list:                      # 列表迭代print(mem)                               # 输出列表项if __name__ == "__main__":                       # 判断执行名称
main()                                      # 调用主函数

范例：覆写“__bool__()”方法实现对象直接判断

# coding : utf-8class Member(object):                            # object子类def __init__(self,name,age):                  # 构造方法self.__name = name                       # 实例属性赋值self.__age = age                         # 实例属性赋值def __bool__(self):                          # 覆写特殊方法return self.__age > 18                   # 判断是否成年def main():                                     # 主函数
mem = Member("李四", 20)                      # 实例化Member对象if mem:                                      # 直接调用“__bool__()”方法返回结果print("成年了！")                        # 提示信息if __name__ == "__main__":                       # 判断程序执行名称
main()                                      # 调用主函数

对象格式化

范例：数据格式化

# coding : utf-8class Message:                                            # object子类def __init__(self, title, url):                        # 构造方法接收初始化参数self.__title = title                               # 为属性赋值self.__url = url                                   # 为属性赋值def __format__(self, format_spec):                      # 格式化字符串if format_spec == "":                              # 是否存在有格式化标记return str(self)                               # 不存在标记直接对象的字符串描述# 按照既定的标记“%title”与“%url”进行内容的字符串替换处理format_data = format_spec.replace("%title", self.__title).replace("%url", self.__url)return format_data                                # 返回格式化后的字符串def __str__(self):                                     # 获取对象信息return "名称：%s、网址：%s" % (self.__title, self.__url) # 返回对象内容

def main():                                               # 主函数
msg = Message("优拓软件学院","www.yootk.com")           # 实例化对象print("{}".format(msg))                                # 未指定格式化字符串，返回对象的字符串表示print("{info:%title：%url}".format(info=msg))           # 定义格式化标记print(format(msg, "%title：%url"))                     # 通过format()函数格式化if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

范例：序列格式化

# coding : utf-8
class Message:
    def __init__(self, title, url):                                                # 构造方法接收初始化参数
        self.__title = title                                                             # 为属性赋值
        self.__url = url                                                                     # 为属性赋值
    def __format__(self, format_spec):                                          # 格式化字符串
        if format_spec == "":                                                         # 是否存在有格式化标记
            return str(self)                                                             # 不存在标记直接对象的字符串描述
        # 按照既定的标记“%title”与“%url”进行内容的字符串替换处理
        format_data = format_spec.replace("%title", self.__title).replace("%url", self.__url)
        return format_data                                                                 # 返回格式化后的字符串
    def __str__(self):                                                                        # 覆写特殊方法
        return "名称：%s、网址：%s" % (self.__title, self.__url) # 返回对象信息
class MessageListFormat:                                                                    # 定义格式化类
    def __init__(self,*msgs):                                                           # 构造方法
        self.msg_list = list(msgs)                                                  # 保存集合列表
    def __format__(self, format_spec):                                          # 覆写特殊方法
        if format_spec == "":                                                           # 是否存在有格式化标记
            return str(self)                                                             # 不存在标记直接对象的字符串描述
        format_data = "\n".join("{:{fs}}".format(m, fs=format_spec) for m in self.msg_list)
        return format_data                                                                 # 返回格式化数据
def main():                                                                                             # 主函数
    message_list = MessageListFormat(Message("沐言优拓", "www.yootk.com") # 实例化对象
   Message("优拓讲师", "李兴华"))                                           # 保存多个对象
    print("{info:%title：%url}".format(info=message_list))    # 定义格式化标记
if __name__ == "__main__":                                                                     # 判断程序执行名称
    main()                                                                                                 # 调用主函数

可调用对象

范例：定义可调用对象

# coding : UTF-8
class Message:                                                                                       # object子类
    def __call__(self, *args, **kwargs):                                       # 定义对象调用支持
        return "title = %s、url = %s" % (kwargs.get("title"), kwargs.get("url")) # 返回数据
def main():                                                                                             # 主函数
    msg = Message()                                                                              # 实例化类对象
    print(msg())                                                                                    # 对象直接调用并且不传递参数
    print(msg(title="沐言优拓",url="www.yootk.com"))                # 对象调用并传递参数
    print(callable(msg))                                                                     # 判断当前对象是否可调用
if __name__ == "__main__":                                                                     # 判断程序执行名称
    main()                                                                                                 # 调用主函数

动态导入

范例：定义“util.py”程序模块

# coding : UTF-8
def get_info():                                                                                      # 定义函数
    return "沐言优拓：www.yootk.com"                                              # 返回信息
class Message:                                                                                       # 自定义Message类
    def echo(self, info):                                                                   # 定义方法
        return "【ECHO】" + info                                                      # 返回信息

范例：实现动态导入操作

# coding : UTF-8
def main():                                                                                             # 主函数
    util = __import__('util')                                                           # 导入util.py模块
    get_info_obj = getattr(util, "get_info")                               # 获取模块中的函数引用
    print(get_info_obj())                                                                   # 通过引用对象直接调用函数
    message_class = getattr(util, "Message")                               # 获取模块中的类引用
    print(message_class().echo("www.yootk.com"))                        # 实例化类对象并调用类中方法
if __name__ == "__main__":                                                                     # 判断程序执行名称
    main()                                                                                                 # 调用主函数

属性操作支持

调用拦截

范例：观察调用拦截

# coding : utf-8
class Message:                                                                                       # 默认object子类
    def __getattribute__(self, item):                                            # 覆写object类方法
        print("【getattribute】item = %s" % (item))                 # 监听信息提示
        return object.__getattribute__(self, item)                    # 如果不调用此处则代码无法正确执行
    def send(self, info):                                                                 # 定义类中的方法
        print("消息发送：%s" % info)                                              # 输出提示信息
def main():                                                                                             # 主函数
    msg = Message()                                                                              # 实例化类对象
    msg.content = "沐言优拓：www.yootk.com"                              # 动态配置实例属性
    print(msg.content)                                                                        # 获取属性触发“__getattribute__()”
    msg.send("www.jixianit.com")                                                   # 调用方法触发“__getattribute__()”
if __name__ == "__main__":                                                                     # 判断程序执行名称
    main()                                                                                                 # 调用主函数

范例：进行属性和方法分别拦截处理

# coding : utf-8class Message:                                             # 默认object子类def __getattribute__(self, item):                       # 覆写object类方法if item == "content":                              # 判断内容为content时的操作return "沐言优拓：www.yootk.com"               # 返回提示信息
elif item == "send":                               # 判断名称return self.other                              # 更换为其它方法else:                                             # 其它操作不进行处理return object.__getattribute__(self, item)       # 代码正常执行调用def send(self, info):                                  # 定义类中的方法print("消息发送：%s" % info)                        # 输出提示信息def other(self,note):                                  # 定义一个替代方法print("【替换方法-other】%s" % note)                # 替代操作执行def main():                                               # 输出提示信息
msg = Message()                                       # 实例化类对象# 此时并没有为msg实例化对象动态配置实例属性，按照传统操作此时应该会出现“AttributeError”    print(msg.content)                                     # 获取属性触发“__getattribute__()”msg.send("www.jixianit.com")                           # 调用方法触发“__getattribute__()”if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

10.2.2、实例属性字典

范例：观察“__dict__”字典存储

# coding : utf-8
class Message:                                                                                       # 默认object子类
    def __init__(self,note):                                                             # 构造方法设置属性
        self.__note = note                                                                 # 操作实例属性
def main():                                                                                             # 主函数
    msg = Message("沐言优拓")                                                         # 实例化类对象
    msg.content = "www.yootk.com"                                                   # 配置实例属性
    print(msg.__dict__)                                                                      # 获取属性保存字典信息
if __name__ == "__main__":                                                                     # 判断程序执行名称
    main()                                                                                                 # 调用主函数

范例：进行属性设置和获取监听

# coding : utf-8class Message:                                             # 默认object子类def __init__(self, content):                           # 构造方法定义属性self.__content = content                           # 保存属性内容def remove_content(self):                              # 删除属性del self.__content                                 # 使用“del”关键字删除def get_content(self):                                 # 获取属性内容return self.__content                              # 返回属性内容def __setattr__(self, key, value):                      # 属性设置时拦截print("【setattr】key = %s、value = %s" % (key, value))       # 输出提示信息self.__dict__[key] = value                         # 向“__dict__”中保存属性和数据def __getattr__(self, item):                           # 属性不存在时调用print("【getattr】item = %s" % item)                # 提示信息return "%s属性不存在，返回Nothing" % item          # 属性不存在时的返回值def __delattr__(self, item):                           # 属性删除print("【delattr】item = %s" % item)                # 输出提示信息self.__dict__.pop(item)                            # 从字典中弹出数据def main():                                               # 主函数
msg = Message("www.yootk.com")                         # 实例化类对象print("【获取存在的属性】%s" % msg.get_content())       # 获取存在的属性内容print("【获取不存在的属性】%s" % msg.note)              # 获取不存在的属性内容msg.remove_content()                                  # 删除属性if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

2.3、获取子类实例化信息

范例：使用“__init_subclass__()”方法

# coding : utf-8class Parent(object):                                               # 定义父类def __init__(self):                                             # 父类无参构造，此方法不会执行print("【Parent】__init__()")                                # 创建目的：方便读者观察def __init_subclass__(cls, **kwargs):                            # 覆写特殊方法print("【Parent-subclass】cls = %s" % (cls))                  # 获取子类信息print("【Parent-subclass】kwars = %s" % (kwargs))             # 获取子类信息

# 定义子类，同时设置子类操作相关的元数据（使用字典的形式进行定义）class Sub(Parent, url="www.yootk.com", teacher="李兴华"):             # 定义子类

    def __init__(self):                                             # 子类构造，不调用父类构造print("【Sub】__init__()")                                  # 输出提示信息def main():                                                        # 主函数sub = Sub()                                                    # 实例化子类对象if __name__ == "__main__":                                          # 判断程序执行名称
main()                                                         # 调用主函数

3、序列操作支持

3.1、自定义迭代

范例：自定义迭代对象

# coding : utf-8class Message:                                                      # 默认继承object类def __init__(self, max):                                         # 构造方法self.__max = max                                            # 设置生成数据的最大值self.__foot = 0                                             # 操作脚标def __iter__(self):                                             # 返回迭代对象return self                                                 # 当前对象为可迭代对象def __next__(self):                                             # 获取内容if (self.__foot >= self.__max):                              # 结束判断return -1                                               # 结束标记else:                                                       # 还有数据
val = self.__max - self.__foot                           # 获取当前迭代数据self.__foot += 1                                         # 修改脚标return val                                              # 返回数据def main():                                                        # 主函数
msg = Message(10)                                               # 实例化类对象for v in msg:                                                   # 对象可以直接进行迭代if (v == -1):                                               # 定义结束标记break                                                  # 退出循环print(v, end="、")                                          # 输出数据if __name__ == "__main__":                                          # 判断程序执行名称
main()                                                         # 调用主函数

范例：修改Message类中的“__next__()”方法定义

class Message:                               # 自定义类# 其他重复代码略…def __next__(self):                      # 获取内容if (self.__foot >= self.__max):       # 结束判断raise StopIteration()            # 结束迭代调用else:                                # 还有数据
val = self.__max - self.__foot     # 获取当前数据self.__foot += 1                  # 修改脚标return val                       # 返回数据

范例：for循环调用可迭代对象

def main():                           # 主函数
msg = Message(10)                  # 实例化类对象for v in msg:                      # 对象直接迭代print(v, end="、")              # 输出数据

3.2、对象反转

范例：自定义反转操作

# coding : utf-8class Message:                                            # 自定义Message类def __init__(self):                                    # 构造方法self.__msg_list = ["沐言优拓","www.yootk.com"]      # 初始化列表def get_msg_list(self):                                # 获取属性return self.__msg_list                             # 返回列表属性def __reversed__(self):                                # 对象反转支持self.__msg_list = reversed(self.__msg_list)         # 反转处理def main():                                               # 主函数
msg = Message()                                       # 实例化类对象reversed(msg)                                         # 序列反转for item in msg.get_msg_list():                        # 迭代输出print(item, end="、")                              # 输出列表项if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数

3.3、字典操作支持

范例：字典操作监听

# coding : utf-8class Message:                                            # 默认object子类def __init__(self):                                    # 构造方法self.__map = {}                                    # 定义一个空的字典def __setitem__(self, key, value):                      # 设置字典数据时触发print("【setitem】设置数据，key = %s、value = %s" % (key,value))self.__map[key] = value                            # 向字典保存数据def __getitem__(self, item):                           # 获取字典数据时触发print("【getitem】获取数据，item = %s" % item)      # 输出提示信息return self.__map.get(item)                        # 从字典获取数据def __delitem__(self, key):                            # “del”删除数据时触发print("【delitem】删除数据，key = %s" % key)        # 输出提示信息self.__map.pop(key)                                # 从字典中弹出数据def __len__(self):                                     # 获取对象长度return len(self.__map)                             # 返回字典长度def main():                                               # 主函数
msg = Message()                                       # 实例化类对象，并可以按照字典模式操作msg["yootk"] = "www.yootk.com"                         # 设置字典数据print("数据保存个数：%s" % len(msg))                    # 获取数据长度print(msg["yootk"])                                   # 获取字典数据del msg["yootk"]                                      # 删除字典数据if __name__ == "__main__":                                # 判断程序执行名称
main()                                                # 调用主函数