Make a given number by adding given numbers I have created a code that checks if a number can be made by adding different quantities of given numbers and if so returns the quantities. Is this the best way to do this or is there a more efficient way?

Here is my function:

def sumFinder(quantities, final_num):
    if len(quantities) == 1:
        for i in range(final_num//quantities[0]+1):
            num = quantities[0] * i
            if num == final_num:
                return [i]
        return False
    for i in range(final_num//quantities[0]+1):
        num = quantities[0]*i
        found_nums = sumFinder(quantities[1:], final_num-num)
        if found_nums:
            return [i] + found_nums
    return False


This is an example of it working:

for num in range(100):
    answer = sumFinder([4, 6, 9, 20], num)
    if answer:
        a, b, c, d = answer
        answer = "4({}) + 6({}) + 9({}) + 20({})".format(a, b, c, d)
    print(num, "=", answer)
Avoid repeated values

In your testing code, the values 4, 6, 9, 20 appear in multiple places. You could re-write your code to generate a formatted answer from the list:

num_list = [4, 6, 9, 20]
for num in range(100):
    answer = sumFinder(num_list, num)
    if answer:
        answer = " + ".join("{} * {}".format(a, b) for a, b in zip(num_list, answer))
    print(num, "=", answer)


Document your function and use the correct type

Your function returns both lists and boolean. Maybe it's be clearer to make it return a list (when a list is found) and None otherwise. This can be documented accordingly in a docstring.

def sumFinder(quantities, final_num):
    """Return a list such that dot-product(list, quantities) == final_num. Return None when no list is found."""
    if len(quantities) == 1:
        for i in range(final_num//quantities[0]+1):
            num = quantities[0] * i
            if num == final_num:
                return [i]
        return None
    for i in range(final_num//quantities[0]+1):
        num = quantities[0]*i
        found_nums = sumFinder(quantities[1:], final_num-num)
        if found_nums:
            return [i] + found_nums
    return None


Handle empty input

You access the first element of the input without checking the length first. Maybe it'd be clearer to document this as an invalid input or you could handle it properly by returning [] if final_sum == 0 else None.

Removing duplicated logic

When the empty case is handled, the case with 1 element doesn't need to be handled in a special way.

With a few minor changes, you can write:

def sumFinder(quantities, final_num):
    """Return a list such that dot-product(list, quantities) == final_num. Return None when no list is found."""
    if not quantities:
        return [] if final_num == 0 else None
    first, remain = quantities[0], quantities[1:]
    for i in range(final_num//first+1):
        found_nums = sumFinder(remain, final_num - first * i)
        if found_nums is not None:
            return [i] + found_nums
    return None


Names

Python names are usually snake_cased. Also, find_sum would be a better name that sum_finder which sounds like a class name.

final_num could be renamed target, n, etc.

quantities could be renamed lst