Zeckendorf Representation of positive integer
First some general review:


You should use a if __name__ == "__main__": guard around the test run to allow importing of your code from another module.
You should add docstrings to your functions to explain what they do. Docstrings are of the format:




def f(x, y):
    """Returns the sum of `x` and `y`"""
    return x + y




As you already mentioned, here is a way to use generators. This has two draw-backs compared to your code:


In find_num_smaller we have to iterate forwards (you cannot iterate backwards through an iterator, at least not without converting it to a list first).
We need to re-generate the generator every loop, because it will be partially exhausted




def fib(max_num):
    """
    Yields the fibonacci sequence until the last element smaller than `max_num`
    """
    n_1, n = 0, 1
    while n &lt; max_num:
        yield n
        n_1, n = n, n + n_1


def find_num_smaller(num, my_list):
    """
    Iterates through an iterator until the value in the iterator is larger than `num`. 
    Returns the value before that.
    """
    last_value = next(my_list)
    for value in my_list:
        if value &gt; num:
            return last_value
        last_value = value
    return last_value


def solve(num):
    """
    Description here
    """
    x = num
    while x &gt; 0:
        temp_value = find_num_smaller(x, fib(num))
        x -= temp_value
        yield temp_value

if __name__ == "__main__":
    print list(solve(10))


Note that your fund_num_smaller will return None if all values in my_list are smaller than num. Here I added returning the last element in that case.

However, this actually performs worse than your code (mostly because iterating reversed saves a lot of time and re-doing the fibonacci sequence wastes a lot of cycles).

As an alternative consider this code:

def find_num_smaller(num, my_list):
    for value in reversed(my_list):
        if value &lt;= num:
            return value


def solve(num):
    l = list(fib(num))
    while num &gt; 0:
        temp_value = find_num_smaller(num, l)
        num -= temp_value
        yield temp_value


Where I used your find_num_smaller and put the fibonacci into a list.

Here is acomparison between the three approaches for the input 123456789123456789123456789123456789123456789123456789 on my machine:

no generator     406 function calls in 0.000 seconds
only generators  10111 function calls in 0.003 seconds
mixed            407 function calls in 0.000 seconds


So using generators here will not give you a speed improvement for most inputs. For the fibonacci numbers it will, however, give you a memory improvement (which will take quite some time to matter).

For really large inputs (like 123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789) there is no improvement visible:

no generator  2947 function calls in 0.017 seconds
mixed         2948 function calls in 0.017 seconds


And for the input 123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789:

no generator  5886 function calls in 0.063 seconds
mixed         5887 function calls in 0.064 seconds


So both approaches seem to scale with the number of digits of the input.