Return to Answer

1. Move d = dict() to after the argument checks, so that you only create the dictionary if the inputs are valid

2. The if/else statements inside the for loop can be removed:

        for i in range(1, lim+1):
            n = num - i
            if n:
                dic.setdefault(i, dict())
                worker(n, lim, dic[i])
            else:
                dic.update({i: 0})
                break

becomes:

        for i in range(1, min(num, lim+1)):
            n = num - i
            dic.setdefault(i, dict())
            worker(n, lim, dic[i])
        if num <= lim:
            dic.update({num: 0})

3. Additionally, dic.setdefault(i, dict()) has two modes. One for when the input key doesn't exist and one for when it does exists. I believe that within your code you're only ever hitting the latter mode (key doesn't exist), so dic.setdefault(i, dict()) can be replaced with dic[i] = dict().

4. Lastly, dic.update({num: 0}) can be replaced with dic[num] = 0 which would prevent you from creating the {num: 0} dictionary input to dic.update.

With all changes, the code becomes:

1. Move d = dict() to after the argument checks, so that you only create the dictionary if the inputs are valid.

2. The if/else statements inside the for loop can be removed:

           for i in range(1, lim+1):
               n = num - i
               if n:
                   dic.setdefault(i, dict())
                   worker(n, lim, dic[i])
               else:
                   dic.update({i: 0})
                   break
   

   becomes:

           for i in range(1, min(num, lim+1)):
               n = num - i
               dic.setdefault(i, dict())
               worker(n, lim, dic[i])
           if num <= lim:
               dic.update({num: 0})
   

3. Additionally, dic.setdefault(i, dict()) has two modes. One for when the input key doesn't exist and one for when it does exists. I believe that within your code you're only ever hitting the latter mode (key doesn't exist), so dic.setdefault(i, dict()) can be replaced with dic[i] = dict().

4. Lastly, dic.update({num: 0}) can be replaced with dic[num] = 0 which would prevent you from creating the {num: 0} dictionary input to dic.update.

With all those changes, the code becomes:

I tested this on your same input:

and it produced the same output.

I ran this code on your input:

and it produced the same output as your code.

In terms of code readability, I would suggest renaming d and dic to tree or something that indicates that the dictionaries represent a tree. I would also suggest renaming num to target or target_sum -- if take this suggestion, also consider renaming lim to max_num; i to num; and n to new_target or new_target_sum as appropriate.

In terms of code readability, I would suggest renaming d and dic to tree or something that indicates that the dictionaries represent a tree. I would also suggest renaming num to target or target_sum or just sum_ -- if take this suggestion, also consider renaming lim to max_num or max_; i to num; and n to new_target or new_target_sum or new_sum_ as appropriate. Also consider renaming worker to dfs since that's basically what it is doing and dfs is more descriptive than worker.

With some of the readability changes, the code looks like this:

def partition_tree(target_sum: int, max_num: int) -> dict:
    """take a positive integer `num` and a positive integer `lim`,
    calculate all possible ways integer `num` can be expressed as,
    a summation of integers between 1 and `lim`, returns a tree"""
    if any(not isinstance(i, int) for i in (target_sum, max_num)):
        raise TypeError('The parameters of this function should be `int`s')
    if any(i <= 0 for i in (target_sum, max_num)):
        raise ValueError('The parameters should be both greater than 0')
    tree = dict()
    def worker(target_sum: int, max_num: int, tree: dict) -> None:
        for num in range(1, min(target_sum, max_num+1)):
            new_target_sum = target_sum - num
            tree[num] = dict()
            worker(new_target_sum, max_num, tree[num])
        if target_sum <= max_num:
            tree[target_sum] = 0
    worker(target_sum, max_num, tree)
    return tree

This code still produces the same output as your original code.