Python has a really sophisticated way of handling iterations. The only thing it does not have “GOTO Labels” which I think is good.

Let us compare the three common ways of iterations in Python: While, For and Map by the way of an example. Imagine that you have a list of numbers and you would like to find the square of each number.

```
nums = [1,2,3,5,10]
result = []
for num in nums:
result.append(num*num)
print(result)
```

It would print `[1, 4, 9, 25, 100]`

Alternative form of iteration using for is

```
nums = [1,2,3,5,10]
result = [num*num for num in nums]
print(result)
```

Now, let us try to use `while`

.

```
nums = [1,2,3,5,10]
result = []
i = 0
while i < len(nums):
num = nums[i]
result.append(num*num)
i += 1
print(result)
```

Look at both pieces of code. The `for`

loop iterates over a list and `while`

loop runs as long as the condition is true. So, if you forgot to increase `i`

, the condition will remain false forever and `while`

the loop will not end ever. That’s why `while`

is called an indefinite loop.

Not everything that can be achieved using `while`

can be achieved using `for`

. Everything that can be achieved using `for`

can be achieved using `while`

. `while`

is way more powerful but with more power comes more risk.

So, if your task can be performed using `for`

don’t use `while`

.

Now, let’s take a look at `map`

. The map is a very interesting way of running the independent operations on a list of things. I encountered the map paradigm around 18 years ago while doing grid computing using PERL programming language.

Let’s take a look at the code to solve the same problem as above – squaring each number in a list.

```
nums = [1,2,3,5,10]
def sq(x):
return x*x
result = map(sq, nums)
print(result)
```

Here notice that to the function we are passing our function `sq`

and our array`nums`

. The `map`

function will run the `sq`

function on each element of nums. Here it does not matter to us in what order will it run. Also, whether it uses different processors to run `sq`

function on different parts of the list it would not impact our logic.

The `map`

function is way better to use over `for`

loop but it has constraint. If the next value depends upon the previous computation, we would not be able to use map. So, `map`

can only solve some problems that `for`

can solve. And `for`

can solve some problems that `while`

can.

Advantage of `map`

is that your code will easily be parallelizable i.e. run on multiple computers or multiple processors if you are using `map`

. The code with `for`

loop and `while`

loops we will have to rewrite the logic to make it parallelizable.

Let us take the case of the Fibonacci series. Can we achieve the following using map()? I don’t think so. If you can, please put it in the comments.

```
def fib(n):
result = []
first, second = 0, 1
result.extend([first, second])
for _ in range(n-1):
newnum = first + second
first, second = second, newnum
result.append(newnum)
print(result)
```

>>> fib(20) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

This prints first twenty numbers of `Fibonacci`

series.

There are many examples which are very difficult to achieve using map.

As a conclusion, your order of preference of usage should be:

**map > for > while**

Prefer `map`

over “for” loop. Prefer `for`

over “while” loop.

I hope this discussion was useful to you. You can try it on CloudxLab right away.

Happy Learning!