The easiest way to understand how to write recursive functions is to apply recursion to problems that are naturally recursive, such as tree-walking, expression evaluation and parsing. Here, the recursive solutions will typically be much simpler than iterative ones. You could also look at learning a language which makes recursion the main way of writing functions, such as Haskell or Scheme.

I would also point out that solving Project Euler problems are probably not a good way to learn to be a programmer, though they will teach you a lot about mathematics.

You're right, in many cases iteration is simpler to write and easier to understand. There are cases, though, where recursion is the natural choice.

For example, when you write a binary search tree, the search procedure is most naturally written in a recursive form. To search for a specified key K in the tree, you do this:

1. Compare K to the key R stored at the root node of the tree. If K = R, return true.
2. Otherwise, if K < R: if the root node has a left child, search for K in the left subtree; else, return false.
3. Or, if K > R: if the root node has a right child, search for K in the right subtree; else, return false.

In steps 2 and 3, the searches in the left and right subtrees are done recursively.

Another natural application of recursion is in quicksort, for sorting an array:

1. If the array to be sorted has length 0 or 1, return. (There is nothing to be done.)
2. Pick an element from the array, called the pivot.
3. Reorder the array so that all elements less than the pivot come before the pivot, and all elements greater than the pivot come after the pivot.
4. Sort the subarray that comes before the pivot, and sort the subarray that comes after the pivot.

The sorting in step 5 is done recursively.

More generally, divide-and-conquer algorithms tend to be naturally expressed recursively. Quicksort is an example of a divide-and-conquer algorithm.

Whether recursion is easier really depends. It also depends on the language, but I'm going to stick with Python for now.

I'll try not to bore you with silly recursive mathematics like fibonacci and factorial. Those are trivial and infrequent.

I've also assumed a fair bit more knowledge than I should've; if you're stuck on any of what I've said just ask. The point isn't the code per se, though.

Say you were travelling around a filesystem and listing all the files. If you were to define this iteratively you'd find quite a few problems.

WARNING: This is not good code. Use os.walk. This is purely example material. Also there are infinite loops in here.

directory = "/home"
for item in os.listdir(directory):
    qualified_item = os.path.join(directory, item)

    if os.path.isdir(qualified_item):
        # Placeholder: Need to change directory

    else:
        print(qualified_item)

For the placeholder, you might be tempted to do:

        directory = qualified_item
        print("entering", qualified_item)

but you need to remember to start the loop again, so put everything in a "while":

import os

directory = "/home"

while True:
    for item in os.listdir(directory):
        qualified_item = os.path.join(directory, item)

        try:
            if os.path.isdir(qualified_item):
                directory = qualified_item
                print("entering", qualified_item)
                break

            else:
                print(qualified_item)

        except FileNotFoundError:
            pass

Also you need to break out of a directory once you've finished it. Now we have to store a list of what directories we've been in:

import os

directories = ["/home"]

while True:
    for item in os.listdir(directories[-1]):
        qualified_item = os.path.join(directories[-1], item)

        try:
            if os.path.isidir(qualified_item):
                directories.append(qualified_item)
                print("entering", qualified_item)
                break

            else:
                print(qualified_item)

        except FileNotFoundError:
            pass

    else:
        print("leaving", directories.pop())

But.. ah! You need to store what position in the loop you're in because you reset from the top each time when you go back up the loop:

import os

directories = [("/home", iter(os.listdir("/home")))] # Hacky hack hack

while True:
    directory, contents = directories[-1]

    for item in contents: # "contents" remembers its position
        qualified_item = os.path.join(directory, item)

        try:
            if os.path.isdir(qualified_item):
                directories.append((qualified_item, iter(os.listdir(qualified_item))))
                print("entering", qualified_item)
                break

            else:
                print(qualified_item)

        except FileNotFoundError:
            pass

    else:
        print("leaving", directories.pop()[0])
        if not directories: break

See how problematic this is? Now try adding proper fallback to that ;P.

Let's do it recursively:

import os

def list_files(directory):
    for item in os.listdir(directory):
        qualified_item = os.path.join(directory, item)

        try:
            if os.path.isdir(qualified_item):
                list_files(qualified_item)

            else:
                print(qualified_item)

        except FileNotFoundError:
            pass

list_files("/home")

That's it. State is handled for free. That is the true advantage of recursive algorithms.

This happens in many cases -- you want to go down a path and return to the original state.

Finally, it's worth noting that Python programs aren't traditionally recursive. The majority of my code is non-recursive, it's only when it's easier to express recursively that I go back to recursion. That is fine. If you only like imperative stuff it won't hurt too badly while you're learning.

>>> def very_recursive():
...     very_recursive()
... 
>>> very_recursive()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in very_recursive
  File "<stdin>", line 2, in very_recursive
  File "<stdin>", line 2, in very_recursive
  File "<stdin>", line 2, in very_recursive
  ... lots more ...
  File "<stdin>", line 2, in very_recursive
  File "<stdin>", line 2, in very_recursive
  File "<stdin>", line 2, in very_recursive
  File "<stdin>", line 2, in very_recursive
RuntimeError: maximum recursion depth exceeded

def add1(lst, place=0):
    if len(lst) == place: return
    lst[place] += 1
    add(lst, place+1)

I really found Learn You A Haskell's tutorial on recursion helpful in terms of concepts:

http://learnyouahaskell.com/syntax-in-functions - initial introduction
http://learnyouahaskell.com/recursion

Download the mobile app Robozzle. It's an awesome game that will get your brain thinking recursively.