进阶学Python:Python面向对象系列之魔法方法!

1,858 阅读8分钟

本文已参与掘金创作者训练营第三期,详情查看:掘力计划|创作者训练营第三期正在进行,「写」出个人影响力

📖前言

三毛曾经感慨:

“心之何如,有似万丈迷津,横亘千里,其中并无舟子可以渡人,除了自渡,他人爱莫能助。” ——生命的洪流中,终其一生,我们都在学会怎么做自己的摆渡人。

关于安装和汉化可以观看博主的这篇文章《VsCode下载安装及汉化 》以及Python系列:windows10配置Python3.0开发环境!,安装完毕重启VsCode!

本篇主要介绍类中定义的各种属性,例如类属性、实例属性、类的私有属性,以及各种方法,例如实例方法、类方法、静态方法以及property属性方法等相关知识。


🚀走起

本篇主要介绍面向对象编程中类的魔法属性,这些魔法属性均有其特殊的功能,即执行某些操作时,会自动触发这些魔法方法的执行,了解这些魔法方法可以更好的了解面向对象编程的实现原理;

在学习魔法方法之前,我们先了解其他两个方法:

isinstance()issubclass()

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   demoOne.py
@Time    :   2019/10/30 08:52:50
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib

class A(object):
    pass
class B(A):
    pass

b = B()

# isinstance(o,c) -- 判断前者是否为后者所创建的对象
print(isinstance(b,A))  # True
print(isinstance(b,B))  # True

# issubclass --判断前者是否为后者的子类
print(issubclass(B,A))  # True

反射:hasattr、getattr、setattr、delattr 四个内置函数

  • 反射,又称自省(自我反省),该概念是由Smith于1982首次提出的,是指主要是指程序可以访问、检测和修改它本身状态或行为的一种能力;
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   fansheDemo.py
@Time    :   2019/10/30 08:54:08
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib


class Programmer(object):
    """定义一个程序员类"""
    character = "intelligent"  # 特点:聪明

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def write_code(self):  # 写代码
        pass

    def debug(self):  #调试
        pass


p = Programmer("Mr_Chen", 21, "male")

# hasttr  - 查看该对象是否可以使用该属性或者方法
print(hasattr(p, "name"))
print(hasattr(p, "debug"))

# getattr - 获取对象属性
print(
    getattr(p, "write_code")
)  #<bound method Programmer.write_code of <__main__.Programmer object at 0x0000016F87ABBFD0>>
print(getattr(p, "character"))  # == p.character

# 可以指定第三个参数,当属性不存在时返回该值,而不会报错
# print(getattr(p,"balabala")) # 报错
print(getattr(p, "balabala", "不存在的"))

# setattr -修改对象属性
setattr(Programmer, "character",
        "handsome")  # == Programmer.character = "handsome"
print(p.character)  # handsome

# delattr - 删除该属性
delattr(p, "name")  # == del p.name
print(p.__dict__)  #{'age': 21, 'gender': 'male'},name没啦
delattr(Programmer, "debug")
print(Programmer.__dict__)  #debug属性没啦

反射的优点:可实现一种可插拔机制,例如:在实际项目的开发过程中,通常是多个程序员配合区完成一个大的项目,假如程序员A在开发过程中需要用到程序员B定义的类,但是程序员B请假陪老婆生孩子了,代码没有完成,这时候程序员B可以使用反射的机制继续去完成自己的代码,例如:

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   yuanDemo1.py
@Time    :   2019/10/30 08:56:26
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib


# 程序员A --moduleA
class A(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y


# ---------------------------------------------------------
# 程序员B
from moduleA import A
a = A(10, 20)
if hasattr(a, "cal"):  # 判断是否有该计算方法,不管有没有不影响我其他逻辑的书写和调试
    print(a.cal())
else:
    print("该计算方法没有定义")
    print("继续执行其他的逻辑")

魔法方法

__doc__ 查看类的描述信息
class Foo(object):
    """这是一段关于该类的介绍和描述"""
    pass

print(Foo.__doc__)  #这是一段关于该类的介绍和描述
__module__ 和 __class__
前者查看当前操作的类所在模块,后者查看当前对象的类是什么;
class Bar(object):
    pass

b1 = Bar()
print(Bar.__module__)  # __main__   ----》当前文件所在模块
print(Bar.__class__)  # <class 'type'>
print(b1.__class__)  # <class '__main__.Bar'>

# 注:从上述结果可以看出,类也是对象,该Bar类对象其是由type类实例化得到的,而对象b1是由当前模块的Bar类实例化得到的
__init__  构造方法
当通过类实例化成对象时,自动触发执行__init__方法。
该方法下定义的属性即为实例属性,即会自动开辟一个内存空间,
用来存放该实例对象的属性和类方法的指针。
class Foo(object):
    # 构造方法
    def __init__(self,name):
        self.name =name
        print("in the init")

foo = Foo("sunny chen")   # in the init
__del__ 方法
当由该类创建的实例对象,被删除或者说在内存中被释放时,将会自动触发执行。
class Foo(object):
    # 析构方法
    def __del__(self):
        print("in the __del__")

foo = Foo()
del foo  # in the __del__

此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。当然我上面重新了析构方法时,则无法真正内存回收,底层会有很多实现的功能被封装。   

__call__   对象后面加括号,触发执行。
class Bar(object):
    pass

bar = Bar()
# bar()    # TypeError: 'Bar' object is not callable

# 当一个类中有__call__,其实例化得到的对象便是可调用的即callable
class Foo(object):

    def __call__(self):
        print("in the call")

foo = Foo()
foo()  # in the call

构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 call 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

__dict__   类或者实例的属性字典
类或这实例的属性字典,用来存放类或者实例的属性和方法;
class Bar(object):
    gender = "male"
    def __init__(self,name):
        self.name = name
    def tt(self):
        pass

bar = Bar("sunny chen")
print(Bar.__dict__)
# 输出为:{'__module__': '__main__', 'gender': 'male', '__init__': <function Bar.__init__ at 0x0000020F94F10B70>, 'tt': <function Bar.tt at 0x0000020F94F10BF8>, '__dict__': 
# <attribute '__dict__' of 'Bar' objects>, '__weakref__': <attribute '__weakref__' of 'Bar' objects>, '__doc__': None}

print(bar.__dict__)
#{'name': 'sunny chen'}

该属性字典中以键值对的形式,存放类对象的属性和其对应的值 、方法和其对应的方法指针。

__str__方法
class Bar(object):

    def __str__(self):
        return "<bar object <Bar> at 000000xxxx>"

# 如果一个类中定义了__str__方法,那么在打印对象 时,默认输出该方法的返回值。
bar = Bar()
print(bar)  # <bar object <Bar> at 000000xxxx>


# 其实在其他的对象中也是这样实现,当打印该对象给用户一些提示信息
import threading
def test():
    pass
t = threading.Thread(target=test)
print(t)  #<Thread(Thread-1, initial)>

该方法当用户不清楚该实例对象是什么时,通过打印的方式自动执行该类的内部的__str__方法,用来给用户一定的提示信息。

__getattr__、__setattr__、__delattr__

在学习这三个魔法方法时,我们先了解一下一个概念叫反射,其通过四个内置函数来实现的效果,即 hasattr、getattr、setattr、delattr ;其实当我们调用后面三个方法时,便是执行了类中的魔法方法;例如:

#---------------- copy---------------
class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')


    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key=value #这就无限递归了,你好好想想
        # self.__dict__[key]=value #应该使用它

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item #无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx
__getitem__、__setitem__、delitem__

用法与上面三种十分相似,只是触发的方式不太相同,上面的attr魔法方法是通过点" . "的方式调用触发,而后者item魔法方法是通过字典"[ ]"的方式调用触发;例如:

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        print("in the setitem.")
        self.__dict__[key]=value

    def __delitem__(self, key):
        print('in the delitem..')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('in the delattr..')
        self.__dict__.pop(item)

# obj.["key"]的方式触发__xxxitem__魔法方法
f1=Foo("sunny chen")
ret = f1["name"]  # 触发__getitem__执行
f1["age"]=18   # 触发__setattr__执行


del f1['age']  # 触发__delitem__执行
f1['name']='sunny'
del f1.name  # 触发__delattr__执行
print(f1.__dict__)
  1. 当然还有迭代器和生成器

快去动手试试吧!


🎉最后

  • 更多参考精彩博文请看这里:陈永佳的博客

  • 喜欢博主的小伙伴可以加个关注、点个赞哦,持续更新嘿嘿!