python之特殊属性和特殊方法

目录

特殊属性

__dict__查看属性和方法

__class__查看对象所属类

__bases__查看子类的父类

__mro__查看类的层次结构

__subclasses__查看父类被继承的子类

特殊方法

__add__()类的对象相加

__len__()类的对象的长度

__new__()和__init__()

---

前面分享完了面对对象的三大特征：封装、继承和多态之后，我们再来看一下特殊属性和特殊方法

	名称	描述
特殊属性	__dict__	获得类对象或实例对象所绑定的所有属性和方法的字典
特殊方法	__len__()	通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
	__add__()	通过重写__add__()方法，可使用自定义对象具有“+”功能
	__new__()	用于创建对象
	__init__()	对创建对象进行初始化

所谓的特殊属性和特殊方法就是两个下划线开始，两个下划线结束的属性和方法，现在来看看他们有什么作用

特殊属性

__dict__查看属性和方法

class A:
    pass

class B:
    pass

# 多继承
class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 创建C类的对象
x = C('SWS', 20)  # x是C类的实例对象
print(x.__dict__)

我们这里有两个A，B类，然后C类多继承了他们，关于多继承可以看看python之继承及其实现方法，然后就定义了一个__init__()初始化的方法并且定义了两个实例属性name和age，那我们现在就可以用__dict__来查看我们的C类对象x的所有属性和方法

{'name': 'SWS', 'age': 20}

那我们再来看看C类的属性和方法

# 创建C类的对象
x = C('SWS', 20)  # x是C类的实例对象
print(x.__dict__)  # 实例对象的属性字典
print(C.__dict__)  #类对象的属性字典

{'name': 'SWS', 'age': 20}
{'__module__': '__main__', '__init__': <function C.__init__ at 0x000001F3AB41FB80>, '__doc__': None}

那我们现在就可以看到C类的属性'__module__': '__main__'之后就接了'__init__'方法

__class__查看对象所属类

我们用__dict__可以查看属性和方法，当然还可以查看对象所属的类是什么啦

print(x.__class__)

<class '__main__.C'>

我们现在就可以看到x对象所属的类是C类

__bases__查看子类的父类

现在由对象可以看到类，那么由子类可不可以看到父类呢，答案当然是可以的啦，不过这事就要用到__bases__啦

print(C.__bases__)

(<class '__main__.A'>, <class '__main__.B'>)

这样我们就可以看到C类的父类类型的元素A,B啦

__mro__查看类的层次结构

那我们现在可以查看子类的父类了，但是又觉得一层一层看太麻烦了怎么办，那这个时候我们就可以查看层次结构来一目了然

print(C.__mro__)

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

现在是不是觉得看过去一目了然，很方便了呢

__subclasses__查看父类被继承的子类

现在有人不高兴了说，凭什么可以子类查看父类，不可以父类查看子类呢，哈哈哈，不要着急，这不就来了吗

class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age

class D(A):
    pass

print(A.__subclasses__())

为了更直观一点，我有添加了一个子类来继承A类，哈哈哈

[<class '__main__.C'>, <class '__main__.D'>]

看看看，输出了子类的列表了吧，哈哈哈，一点也米有不公平呀

特殊方法

分享完了特殊属性，终于到特殊方法啦

__add__()类的对象相加

我们知道python中整数类型的对象可以相加，虽然是通过+来完成的，但是底层是调用__add__()方法来完成的

a = 60
b = 300
c = a + b
d = a.__add__(b)
print(c, d)

360 360

那我们自定义类型的对象可不可以呢，一起来看看吧

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

sws_1 = SWS('慢蜗牛')
sws_2 = SWS('小蜗牛')
sws_3 = sws_2 + sws_1

print(sws_3)

我们来看看两个对象是不是可以相加，结果大家应该已经猜到了吧

Traceback (most recent call last):
  File "D:\pythonProject\main.py", line 8, in <module>
    sws_3 = sws_2 + sws_1
TypeError: unsupported operand type(s) for +: 'SWS' and 'SWS'

哎呀，电脑报错啦，告诉我们SWS和SWS不能进行相加，那慢蜗牛的牛脾气上来了，我还非要你们想加，哼哼哼

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

    def __add__(self, other):  # 可以看到这里运用了__add__()方法
        return self.name + other.name

sws_1 = SWS('慢蜗牛')
sws_2 = SWS('小蜗牛')
sws_3 = sws_2 + sws_1

print(sws_3)

我们可以看到运用了__add__()方法，并且返回两个名字，来看看行不行

小蜗牛慢蜗牛

哎呀，我真是太牛批啦，这都完成了，那我们来看看直接用__add__()来相加

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

    # def __add__(self, other):  # 这里是注释掉了的
    #     return self.name + other.name

sws_1 = SWS('慢蜗牛')
sws_2 = SWS('小蜗牛')
sws_3 = sws_2.__add__(sws_1)

print(sws_3)

Traceback (most recent call last):
  File "D:\pythonProject\main.py", line 11, in <module>
    sws_3 = sws_2.__add__(sws_1)
AttributeError: 'SWS' object has no attribute '__add__'

好吧好吧，现在看来，要想实现两个自定义类型对象的相加就必须用到被注释掉的部分啦

__len__()类的对象的长度

谈到__len__()，大家肯定就想到了对列表求长度的函数len()，那我们来看看这两者的功能

list_1 = [22, 44, 66, 88]
print(len(list_1))
print(list_1.__len__())

# 下面是输出
4
4

对于列表来说这两者功能都一致啊，那我们想要输出自定义类型对象的长度呢

print(len(sws_1))

# 下面是输出
Traceback (most recent call last):
  File "D:\pythonProject\main.py", line 19, in <module>
    print(len(sws_1))
TypeError: object of type 'SWS' has no len()

哎呀，又报错了，哈哈哈，牛脾气不改，接着和你刚

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

    def __add__(self, other):
        return self.name + other.name

    def __len__(self):
        return len(self.name)

sws_1 = SWS('慢蜗牛')
sws_2 = SWS('SWS')

print(len(sws_1))
print(len(sws_2))

# 下面是输出
3
3

没有错啊，这回你不刚了吧，电脑还是没有人聪明啊

__new__()和__init__()

class SWS(object):
    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id为{}'.format(id(cls)))
        obj = super().__new__(cls)
        print('创建的对象的id为{}'.format(id(obj)))
        return obj

    def __init__(self, name, age):
        print('__init__被调用了，self的id为{}'.format(id(self)))
        self.name = name
        self.age = age

print('object这个类对象的id为{}'.format(id(object)))
print('SWS这个类对象的id为{}'.format(id(SWS)))

sws_1 = SWS('慢蜗牛', 20)
print('sws_1这个SWS类的实例对象的id为{}'.format(id(sws_1)))

object这个类对象的id为140735397846528
SWS这个类对象的id为1979325068288
__new__被调用执行了，cls的id为1979325068288
创建的对象的id为1979331727120
__init__被调用了，self的id为1979331727120
sws_1这个SWS类的实例对象的id为1979331727120

我们之前总是提到创建对象的初始化用__init__()来完成，可是初始化之前，我们肯定要创建一个新对象才行呀，那我们现在就来看看这两者的关系

我们先创建一个实例对象，用＝来赋值肯定是从右边开始

然后看看我们cls的ID和类的ID是一样的，就可以知道第一步是把类赋给cls，然后cls就返回了一个新的对象给obj

第二步就是obj把自己赋给了self来初始化对象

最后返回初始化好的对象给sws_1