Use__ slots__ And__ dict__ To save space (it's simply a qualitative leap, and leetcode's personal test is effective)

Definition

        __slots__ and __dict__ Are two special class attributes .

1.__slots__

        __slots__ The function of class attribute is to specify all contained in the instance of the current class all attribute , Note that all , It can only be __slots__ The specified property , Cannot contain other attributes , You cannot create a new attribute . During operation , The meaning of its existence is to tell the interpreter ： All instance properties in this class are here ！

 

2.__dict__

        __dict__ Is used to exist instance properties . That is to say , Any properties of the current instance will be stored in this dictionary .__dict__ There is an improved access speed of attributes , But it also brings additional space consumption , because __dict__ It is essentially a dictionary , And dictionaries are very space consuming .

 

test

         Use __slots__ Specify only a few attributes that need to be used , If there is no need to use ed attribute , Then directly empty , In this way, no additional attributes will be created every time the object is created ( Include __dict__ attribute ), Thus, the space is greatly saved .

          This is the question ：LCS 01. Download plug-ins

        Source code of problem solving ：

from collections import deque
class Node:
    __slots__=('l','r','speed','val')
    def __init__(self, l=None, r=None, speed=None, val=None):
        self.l = l
        self.r = r
        self.speed = speed
        self.val = val
class Solution:
    __slots__=()
    def leastMinutes(self, n: int) -> int:
        if n==1:return 1
        root = Node()
        root.l = Node(None, None, 2, 0)  #  Left child chooses broadband double 
        root.r = Node(None, None, 1, 1)  #  The right child chooses to download directly 
        que = deque()
        que.append(root.l)
        que.append(root.r)
        N = 1
        while True:
            node_tmp = []
            flag = 0
            while len(que) > 0:
                cur_node = que.popleft()
                node_tmp.append(cur_node)
                new_l_val = cur_node.val
                if new_l_val >= n:
                    flag = 1
                    N+=1
                    break
                else:
                    new_l_speed = cur_node.speed * 2
                    cur_node.l = Node(None, None, new_l_speed, new_l_val)

                new_r_val = cur_node.val + cur_node.speed
                if new_r_val >= n:
                    flag = 1
                    N+=1
                    break
                else:
                    new_r_speed = cur_node.speed
                    cur_node.r = Node(None, None, new_r_speed, new_r_val)
            if flag:
                break
            else:
                N += 1
            while node_tmp:
                node = node_tmp.pop()
                if node.l: que.append(node.l)
                if node.r: que.append(node.r)
        return N

Synchronous update in personal blog system ： Use __slots__ and __dict__ To save space （ It's a qualitative leap ,LeetCode Close test effectively ）