Create a recursion that uses the reverse Polish notation. Here is a pseudo-code:

function rec(digitsLeft, numbers, operators, expression):
    if digitsLeft == 0 and numbers - operators == 1:
        value = evaluate(expression)
        if value in {1..10}: output expression
        return
    if digitsLeft > 0:
        rec(digitsLeft - 1, numbers + 1, operators, [expression, 4])
    if digitsLeft > 1:
        rec(digitsLeft - 2, numbers + 1, operators, [expression, 44])
    if numbers - operators > 1:
        for op in ['+', '-', '*', '/']:
            rec(digitsLeft, numbers, operators + 1, [expression, op])

The reverse Polish notation will take care of operators' precedence, so you don't have to handle brackets.

The initial call is:

rec(4, 0, 0, [])

and the parameters are:

• digitsLeft -- how many digits do we still need to use,
• numbers -- how many numbers our expression already has,
• operators -- how many operators our expression already has,
• expression -- the array holding the elements of the expression.

Of course, you need to write evaluate (the function that evaluates expression) and output (the function that will most likely convert the reverse Polish notation expression to the standard infix notation (using some of the known algorithms, for example this one) and print it to the screen or a file).

A more general version would replace this:

    if digitsLeft > 0:
        rec(digitsLeft - 1, numbers + 1, operators, [expression, 4])
    if digitsLeft > 1:
        rec(digitsLeft - 2, numbers + 1, operators, [expression, 44])

with a loop that would go through $4$, $44$, etc., but for this example, it was easier to do just a copy/paste of two if-s.

If you need any further clarification, please ask.