Every number from 1,2,5,6,9,10... is divisible by 4 with remainder 1 or 2.

>>> ','.join(str(i) for i in xrange(100) if i % 4 in (1,2))
'1,2,5,6,9,10,13,14,...'

Trying to be consistent with what you first tried, you could do something like this

def generateNumber(num):
    mylist = []
    for i in range(num+1):
         mylist.append(i)
    return mylist


x = generateNumber(10)

but, you could, instead just say,

x = range(10+1)  # gives a generator that will make a list

or

x = list(range(10+1))  # if you want a real list

In general though, you should keep this list based on inputting the number 10 so it is [0...9] and not [0...10].

If the closed form is available you can use a list comprehension. This has the advantage that all the required memory can be allocated right at the beginning:

seq = [(i + 1)**2 for i in range(1, n+1)]

Repeatedly appending to a list causes internal resizing of the underlying memory and thus involves unnecessary memory allocations and copies.

Without a closed form you can still use a generator:

def gen_seq(n):
    a = 0
    for i in range(1, n+1):
        a += 2*i - 1
        yield a

Performance comparison

In [1]: def f1(n): 
   ...:     return [(i + 1)**2 for i in range(1, n+1)] 
   ...:                                                                                       

In [2]: def gen_seq(n): 
   ...:     a = 0 
   ...:     for i in range(1, n+1): 
   ...:         a += 2*i - 1 
   ...:         yield a 
   ...:                                                                                       

In [3]: def f2(n): 
   ...:     return list(gen_seq(n)) 
   ...:                                                                                       

In [4]: %timeit f1(100_000)                                                                   
29.7 ms ± 271 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [5]: %timeit f2(100_000)                                                                   
16.1 ms ± 176 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

The generator version is almost 2x faster than the list comprehension. This is because the recursive version benefits from the relatively simple operations that are involved. Multiplying an integer by 2 is simply a 1-lshift and adding or subtracting a number is an O(N) operation where N is the number of digits. Multiplying two integers however is O(N*log(N)) and hence takes more time to compute. The recursive version benefits from the already-computed part a_{n-1} which it can reuse at each step.

[str(i) for i in range(3000, 3100+1)]

This is faster than using map().