Python3的特殊成员

梦里梦外; 2022-02-25 00:50 178阅读 0赞

对象后面加括号可执行：正常使用都是 obj = class\_name()  obj.func() 用对象点。

--------------------

class A():
        def __init__(self):
            print('hello __init__')
    
        # 对象后面加括号可执行 该函数
        def __call__(self, *args, **kwargs):
            print('hello __call__')
    
    
    # 方式一：执行
    obj = A()
    obj()
    # 方式二：执行__call__
    A()()

--------------------

小结： 对象后面加括号，会默认执行\_\_call\_\_() ,可以通过类后面加双括号，直接调用\_\_call\_\_(),然后在该函数内定一些操作。

强制类型转换int(): 正常使用，可以直接把字符串str ='123' 转换为 num = int(str)  num =123

--------------------

str = '123'
    num = int(str)
    
    
    class B():
        def __init__(self):
            print('init')
    
        # 内部转换 int() 时 就会将返回值赋值给对象
        def __int__(self):
            return 1
    
    
    obj = B()
    obj1 = int(obj)  # 直接转换对象成int 不行 只有类内有__int__方法，就会把返回值给对象
    print(obj1, type(obj1))

--------------------

小结：如果对于对象强制类型转换int() 就会默认调用类内\_\_int\_\_() ,可以直接将该函数的返回值赋值给被强制转换的对象。

打印对象 str():可以直接打印实例化的对象，并可以在函数中调用输出该类私有成员字段

--------------------

class C():
    
        # 内部转换 str() 时 就会将返回值赋值给对象
        # 该函数作用更大，可以打印对象的时候输出私有成员字段
        def __str__(self):
            print('hello')
            return '调用 内置 str'
    
    
    ubj = C()
    
    print(ubj)  # 注意这里是作为string打印 直接转换对象成str 不行 只有类内有__int__方法，就会把返回值给对象

--------------------

小结：直接打印对象，会得到该对象内存地址，但是如果类内如果有\_\_str\_\_()，就可以将该函数返回值赋值给对象并打印，并且可以在该函数内调用，使用该对象类内的私有成员。

两个对象相加add():可以直接实现对象相加，然后在该函数内可以打印，调用类内成员，可以返回一个对象

析构函数 del() : 可以在对象被销毁时自动执行。

--------------------

class D():
        '''
        该注释是该类的 该注释也会被当做字段
        '''
    
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def __add__(self, other):
            print('D1 add D2')
            # # 可以返回一个计算值
            # return self.age + other.age
            # 可以返回一个对象
            return D('smith', 22)
    
        # 析构方法()    对象被销毁时自动执行
        def __del__(self):
            print('析构函数被执行', self.name)
    
    
    d1 = D('aric', 18)
    d2 = D('alis', 19)
    # 两个对象相加时，自动执行第一个对象的add方法，并且将第二个对象当做参数传递进入
    d3 = d1 + d2
    print(d3)
    # __dict__ 将封装的内容（字段）以字典的形式返回
    d4 = D('smith', 18)
    d5 = d4.__dict__
    print(d5)
    
    d6 = D('smith2', 16).__dict__
    print(d6)

--------------------

小结： 对象相加通过+ 例：obj3= obj1+ obj2。就会调用类内的\_\_add\_\_()函数，注意参数是两个self 和 other,然后就会执行类内语句，可以返回对象成员字段，也可以返回一个对象。打印该返回对象是，当然是打印的该对象内存地址。对于类的\_\_dict\_\_ 参数，功能是将封装的内容（字段）以字典的形式返回。对于析构函数，不需要刻意调用，当对象不再使用时，系统会默认调用销毁该对象。

通过索引取值，赋值，删除，切片等操作：类似用于列表的操作，同样适用于对象

--------------------

class E():
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        # 获取索引下标值
        def __getitem__(self, item):
            # return item+10
            # 如果item是基本类型，int，str索引获取
            # slice对象的话，切片
            if type(item) == slice:
                print('切片')
            else:
                print('非切片')
            print(item)
    
        # 设置带索引下标的值
        def __setitem__(self, key, value):
            print(key, value)
    
        # 删除带索引下标的值
        def __delitem__(self, key):
            print(key)
    
    
    e1 = E('smith', 18)
    # 索引获取
    e2 = e1[2]
    print(e2)  # 2+10
    # 索引赋值
    e1[4] = 28
    print(e1[4])
    # 删除
    del e1[3]
    # 切片
    
    e1[1:4:2]

--------------------

小结： 对于对象主要有\_\_getitem\_\_() 获取索引下标值，\_\_setitem\_\_() 设置带索引下标的值，\_\_delitem\_\_() 删除带索引下标的值。这些操作都是自己进行定义，但是在外部调用使用时与列表的索引使用没有很大不同。

对象可迭代：通过\_\_iter\_\_() 可以将对象变成可迭代对象。

--------------------

class F():
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def __iter__(self):
            return iter([1, 2, 3, 4, 5])
    
    
    f1 = F('smith', 23)
    # 如果类中有__iter__ 方法，对象-》可迭代对象
    # 对象.__iter__() 的返回值：迭代器
    # for 循环，迭代器，next
    # for 循环，可迭代对象，对象.__iter__()，迭代器，next
    # 1.执行li对象的类F 类中的__iter__ 方法，并获取其返回值
    # 2.循环上一步中返回的对象
    for i in f1:
        print(i)

--------------------

小结： 关于迭代，如果for i in 迭代器：可以使用next获取下一个值，如果for i in 可迭代对象：可以使用对象.\_\_iter\_\_() 获取下一个值，也可以使用next 获取下一个值。关于对象可迭代，主要是类内有\_\_iter\_\_() 函数，至于该函数怎么定义完全自行书写。该例子中返回的是一个可迭代对象。

类的父类（重要）：

--------------------

class MyType(type):
        # 初始第二步
        def __init__(self, what, bases=None, dict=None):
            super(MyType, self).__init__(what, bases, dict)
    
        # 第二步
        def __call__(self, *args, **kwargs):
            obj = self.__new__(self, *args, **kwargs)  # 执行Foo的new
            self.__init__(obj)  # 执行Foo的init
    
    
    class Foo(object):
        # 初始第一步
        __metaclass__ = MyType
    
        # 第四步
        def __init__(self, name):
            self.name = name
    
        # 第三步
        def __new__(cls, *args, **kwargs):
            return object.__new__(cls, *args, **kwargs)
    
    
    # 第一步
    obj = Foo()

--------------------

小结：主要给出了调用顺序， 首先是第一步，然后会执行Foo()类内的初始第一步，然后会执行MyType() 类内的\_\_init\_\_()初始第二步，然后第二步会走MyType() 类内的\_\_call\_\_() ，然后调用Foo() 类的\_\_new\_\_() 第三步，然后会调用Foo() 类的\_\_init\_\_()第四步，最后完成对象的实例化。

--------------------

总结：

*  \_\_call\_\_(self,\*args,\*\*kwargs) 实现对象后面可直接加括号：obj = A() obj() 等价A()()
 *  \_\_init\_\_(self) 实现对象的int()强制类型转换:obj = B()  int(obj)
 *  \_\_str\_\_(self) 实现对象的直接打印，注意不是str(obj)，而是print(obj)
 *  \_\_add\_\_(self,other)实现对象的直接相加操作，注意是obj1+obj2, 不是obj1.add(obj2)
 *  \_\_del\_\_(self) 实现对象在被销毁时自动执行，可以自定义，销毁对象时执行什么操作
 *  \_\_dict\_\_ 这是一个参数，会将封装的内容（字段），以字典的形式返回。
 *  \_\_getitem\_\_(self,item) 获取下标值
 *  \_\_setitem\_\_(self,key,value) 设置索引的值
 *  \_\_delitem\_\_(self,key) 删除索引的值
 *  \_\_iter\_\_(self) 将对象进行可迭代化，主要看实现。
 *  初始化一个实例的流程，具体看代码流程。

--------------------