# How to write a function that takes a positive integer N and returns a list of the first N natural numbers

6

I'm taking this online Python course and trying to solve the following problem called Coding Exercise: It's Natural:

Write a function naturalNumbers which takes a positive integer n as input, and returns a list [1, 2, ...] consisting of the first n natural numbers.

Do I even need a for loop to create a list? Here's my code (which doesn't work obviously). Keep in mind, they have not taught list comprehension. I found this concept on stackoverflow.

``````def naturalNumbers(n):
list = [n+1 for i in n]
return list
``````

Should I take another approach where I create multiple lists of 1,2,3...n and concatenate them all together like [1] + [2] + [3]....

This question is tagged with `python` `list` `for-loop`

4

Do I even need a for loop to create a list?

No, you can (and in general circumstances should) use the built-in function `range()`:

``````>>> range(1,5)
[1, 2, 3, 4]
``````

i.e.

``````def naturalNumbers(n):
return range(1, n + 1)
``````

Python 3's `range()` is slightly different in that it returns a `range` object and not a list, so if you're using 3.x wrap it all in `list()`: `list(range(1, n + 1))`.

5

There are two problems with your attempt.

First, you've used `n+1` instead of `i+1`, so you're going to return something like `[5, 5, 5, 5]` instead of `[1, 2, 3, 4]`.

Second, you can't `for`-loop over a number like `n`, you need to loop over some kind of sequence, like `range(n)`.

So:

``````def naturalNumbers(n):
return [i+1 for i in range(n)]
``````

But if you already have the `range` function, you don't need this at all; you can just `return range(1, n+1)`, as arshaji showed.

So, how would you build this yourself? You don't have a sequence to loop over, so instead of `for`, you have to build it yourself with `while`:

``````def naturalNumbers(n):
results = []
i = 1
while i <= n:
results.append(i)
i += 1
return results
``````

Of course in real-life code, you should always use `for` with a `range`, instead of doing things manually. In fact, even for this exercise, it might be better to write your own `range` function first, just to use it for `naturalNumbers`. (It's already pretty close.)

There is one more option, if you want to get clever.

If you have a list, you can slice it. For example, the first 5 elements of `my_list` are `my_list[:5]`. So, if you had an infinitely-long list starting with `1`, that would be easy. Unfortunately, you can't have an infinitely-long list… but you can have an iterator that simulates one very easily, either by using `count` or by writing your own 2-liner equivalent. And, while you can't slice an iterator, you can do the equivalent with `islice`. So:

``````from itertools import count, islice
def naturalNumbers(n):
return list(islice(count(1), n))
``````