魔术方法(二)

发表于 分类于 阅读次数： 本文字数： 6.6k 阅读时长 ≈ 6 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Foo:
    def __init__(self, name):
        self.name = name

    def __getitem__(self, item):
        print('getitem执行', self.__dict__[item])

    def __setitem__(self, key, value):
        print('setitem执行')
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('del obj[key]时，delitem执行')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('del obj.key时，delattr执行')
        self.__dict__.pop(item)


f1 = Foo('sb')

setitem

  • 中括号赋值时触发
1
2
3
f1['age'] = 18  # setitem执行

f1['age1'] = 19  # setitem执行

getitem

  • 中括号取值时触发
1
2
3
f1['age']  # getitem执行 18

f1['name'] = 'tank'  # setitem执行

delitem与delattr

  • delitem：中括号删除时触发
  • delattr：.删除时触发
1
2
3
4
5
del f1.age1  # del obj.key时，delattr执行

del f1['age']  # del obj[key]时，delitem执行

print(f1.__dict__)  # {'name': 'tank'}

format

  • 自定制格式化字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
date_dic = {
    'ymd': '{0.year}:{0.month}:{0.day}',
    'dmy': '{0.day}/{0.month}/{0.year}',
    'mdy': '{0.month}-{0.day}-{0.year}',
}


class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __format__(self, format_spec):
        # 默认打印ymd的{0.year}:{0.month}:{0.day}格式
        if not format_spec or format_spec not in date_dic:
            format_spec = 'ymd'
        fmt = date_dic[format_spec]
        return fmt.format(self)


d1 = Date(2016, 12, 29)

print(format(d1))  # 2016:12:29

print('{:mdy}'.format(d1))  # 12-29-2016

del

  • del也称之为析构方法
  • del会在对象被删除之前自动触发
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.f = open('test.txt', 'w', encoding='utf-8')

    def __del__(self):
        print('run======>')
        # 做回收系统资源相关的事情
        self.f.close()


obj = People('egon', 18)
del obj  # del obj会间接删除f的内存占用，但是还需要自定制__del__删除文件的系统占用
print('主')
'''
run=-====>
主
'''

slots

什么是slots

  • slots是一个类变量，变量值可以是列表，元祖，或者可迭代对象，也可以是一个字符串(意味着所有实例只有一个数据属性)
  • 使用点来访问属性本质就是在访问类或者对象的dict属性字典(类的字典是共享的，而每个实例的是独立的)

107-slots-内存.jpg

为什么用slots

  • 字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用slots取代实例的dict

  • 当你定义slots后，slots就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个字典，这跟元组或列表很类似。在slots中列出的属性名在内部被映射到这个数组的指定小标上。使用slots一个不好的地方就是我们不能再给实例添加新的属性了，只能使用在slots中定义的那些属性名。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class Foo:
        __slots__='x'


    f1=Foo()
    f1.x=1
    f1.y=2  # 报错
    print(f1.__slots__)  # f1不再有__dict__

    class Bar:
        __slots__=['x','y']
        
    n=Bar()
    n.x,n.y=1,2
    n.z=3  # 报错

  • 注意：slots的很多特性都依赖于普通的基于字典的实现。另外，定义了slots后的类不再 支持一些普通类特性了，比如多继承。大多数情况下，你应该只在那些经常被使用到 的用作数据结构的类上定义slots比如在程序中需要创建某个类的几百万个实例对象 。

  • 关于slots的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用slots可以达到这样的目的，但是这个并不是它的初衷。它更多的是用来作为一个内存优化工具。

刨根问底

107-slots-刨根问底.jpg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Foo:
    __slots__=['name','age']

    
f1=Foo()
f1.name='alex'
f1.age=18
print(f1.__slots__)  # ['name', 'age']


f2=Foo()
f2.name='egon'
f2.age=19
print(f2.__slots__)  # ['name', 'age']
  • f1与f2都没有属性字典dict了，统一归slots管，节省内存
1
2
3
4
print(Foo.__dict__)
'''
{'__module__': '__main__', '__slots__': ['name', 'age'], 'age': <member 'age' of 'Foo' objects>, 'name': <member 'name' of 'Foo' objects>, '__doc__': None}
'''

doc

  • 返回类的注释信息
1
2
3
4
5
6
7
class Foo:
    '我是描述信息'
    pass


print(Foo.__doc__)
我是描述信息
  • 该属性无法被继承
1
2
3
4
5
6
7
8
class Foo:
    '我是描述信息'
    pass

class Bar(Foo):
    pass
print(Bar.__doc__) #该属性无法继承给子类
None

call

  • 对象后面加括号时，触发执行。
  • 注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
1
2
3
4
5
6
7
8
9
10
11
12
13
class Foo:
    def __init__(self):
        print('__init__触发了')

    def __call__(self, *args, **kwargs):

        print('__call__触发了')

# 执行 __init__
obj = Foo()  # __init__触发了

# 执行 __call__
obj()  # __call__

init和new

曾经我幼稚的以为认识了python的init()方法就相当于认识了类构造器，结果，new()方法突然出现在我眼前，让我突然认识到原来new才是老大。为什么这么说呢？

我们首先得从new(cls[,…])的参数说说起，new方法的第一个参数是这个类，而其余的参数会在调用成功后全部传递给init方法初始化，这一下子就看出了谁是老子谁是小子的关系。

所以，new方法（第一个执行）先于init方法执行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class A:
    pass


class B(A):
    def __new__(cls):
        print("__new__方法被执行")
        return super().__new__(cls)

    def __init__(self):
        print("__init__方法被执行")


b = B()
'''
__new__方法被执行
__init__方法被执行
'''

我们比较两个方法的参数，可以发现new方法是传入类(cls)，而init方法传入类的实例化对象(self)，而有意思的是，new方法返回的值就是一个实例化对象（ps:如果new方法返回None，则init方法不会被执行，并且返回值只能调用父类中的new方法，而不能调用毫无关系的类的new方法）。我们可以这么理解它们之间的关系，new是开辟疆域的大将军，而init是在这片疆域上辛勤劳作的小老百姓，只有new执行完后，开辟好疆域后，init才能工作。

绝大多数情况下，我们都不需要自己重写new方法，但在当继承一个不可变的类型（例如str类,int类等）时，它的特性就尤显重要了。我们举下面这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class CapStr(str):
    def __init__(self, string):
        string = string.upper()


a = CapStr("I love China!")
print(a)
I love China!
class CapStr(str):
    def __new__(cls, string):
        string = string.upper()
        return super().__new__(cls, string)


a = CapStr("I love China!")
print(a)  # I LOVE CHINA!

我们可以根据上面的理论可以这样分析，我们知道字符串是不可改变的，所以第一个例子中，传入的字符串相当于已经被打下的疆域，而这块疆域除了将军其他谁也无法改变，init只能在这块领地上干瞪眼，此时这块疆域就是”I love China!“。而第二个例子中，new大将军重新去开辟了一块疆域，所以疆域上的内容也发生了变化，此时这块疆域变成了”I LOVE CHINA!“。

小结

小结：****new**和*init*想配合才是python中真正的类构造器

str

  • 打印时触发
1
2
3
4
5
6
7
8
9
10
class Foo:
    pass


obj = Foo()

print(obj)  # <__main__.Foo object at 0x10d2b8f98>

dic = {'a': 1}  # d = dict({'x':1})
print(dic)  # {'a': 1}
  • obj和dic都是实例化的对象，但是obj打印的是内存地址，而dic打印的是有用的信息，很明显dic的打印是非常好的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Foo:
    def __init__(self, name, age):
        """对象实例化的时候自动触发"""
        self.name = name
        self.age = age

    def __str__(self):
        print('打印的时候自动触发，但是其实不需要print即可打印')
        return f'{self.name}:{self.age}'  # 如果不返回字符串类型，则会报错


obj = Foo('nick', 18)
print(obj)  # obj.__str__() # 打印的时候就是在打印返回值
'''
打印的时候自动触发，但是其实不需要print即可打印
nick:18
'''

obj2 = Foo('tank', 30)
print(obj2)
'''
打印的时候自动触发，但是其实不需要print即可打印
tank:30
'''

repr

  • str函数或者print函数—>obj.str()
  • repr或者交互式解释器—>obj.repr()
  • 如果str没有被定义，那么就会使用repr来代替输出
  • 注意：这俩方法的返回值必须是字符串，否则抛出异常
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class School:
    def __init__(self, name, addr, type):
        self.name = name
        self.addr = addr
        self.type = type

    def __repr__(self):
        return 'School(%s,%s)' % (self.name, self.addr)

    def __str__(self):
        return '(%s,%s)' % (self.name, self.addr)


s1 = School('oldboy1', '北京', '私立')
print('from repr: ', repr(s1))  # # from repr:  School(oldboy1,北京)

print('from str: ', str(s1))  # from str:  (oldboy1,北京)

print(s1)  # (oldboy1,北京)

module和class

1
2
3
4
5
6
7
8
9
# lib/aa.py
class C:
    def __init__(self):
        self.name = 'SB'
# index.py

from lib.aa import C

obj = C()

module

  • module 表示当前操作的对象在那个模块
1
print(obj.__module__)  # 输出 lib.aa，即：输出模块

class

  • class表示当前操作的对象的类是什么
1
print(obj.__class__)  # 输出 lib.aa.C，即：输出类