5 techniques to Idiomatic Python (Loops)
Tags: python, idiomatic, loops
Published: 2021-09-14 15:33:55

---
title: 5 techniques to Idiomatic Python (Loops)
published: true
date: 2020-08-21 06:44:53 UTC
tags: python, idiomatic, loops
canonical_url: https://idiomaticprogrammers.com/post/idiomatic-python-programming/
cover_image: https://res.cloudinary.com/idiomprog/image/upload/v1600081748/Idiomatic%20Programmers/idiomatic_python.jpg
---

Python is, in my opinion, one of the easiest and most versatile languages in computer science. If you write python code correctly, it is difficult to differentiate a python code from pseudo-code. But sometimes, in the process of writing the most beautiful python code, most developers forget one thing: the execution speed of the code.

You can write code that is so readable and a layman can confuse it as English written by someone with bad grammar skills, yet it is understandable. But that code takes more than 300ms to run. That might not be that much of a delay but in the programming world, it is a serious problem.

On the other hand, one can write the same code in a different idiom that it takes less than 10ms to run. But, even expert python developers undergo a hard time understanding it.

It is thus very imported, for a developer to strike a balance between these two extremes. These kinds of code are known as Idiomatic Code in the industry.

Idiomatic Code, by definition, is a code that does a common task in a common way for your language. In other words, idiomatic code is any code that is easy to read and at the same time, is extremely efficient.

I follow Raymond Hettinger ([@raymondh](https://twitter.com/raymondh)) a lot on twitter, he is one of the core developers in the Python community and he has contributed a lot of code in the Python repository to make the python language more idiomatic.

In this blog, I will go through some of the techniques that will help you improve your python code. Starting with:

### 1. range()

Let's start from the obvious, say you need to iterate from 2 to 10. So if you're like an absolute beginner you might write something like this:

```python
for i in [2,3,4,5,6,7,8,9,10]:
    print(i)
```

Something like this works and is very understandable, it is not a scalable approach. What if you want to loop through 2 to 2 million.

In situations like this, you can use the `range(stop)` or `range(start, stop, [step,])` built-in function.

the _range_ function automatically generates the list for you. For example, you can rewrite the above code as:

```python
for i in range(2, 11):
    print(i)
```

Notice how I wrote start from 2 and end at 11 and not 10. This is because the range function loops till `stop - 1`. There is one more parameter in range function other than the start and stop, that is the step. Step determines how many numbers the range have to skip.

Let's say you need to print all even numbers from 2 to 10, in that case, the skip parameter will be 2. By default, it is 1.

```python
for i in range(2,11,2):
    print(i)

# OUTPUT: 2 4 6 8 10
```

Now let's say that you need to loop through a list. With the knowledge of range(), you might do this:

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for i in range(len(cloths))
  print(cloths[i])
```

But in python, there is a better way:

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for cloth in cloths
  print(cloth)
```

### 2. zip()

Let's say you have two lists, colour and cloths, of different sizes and you want to pair them until the smaller list is over. In this case, you can write a code like this:

```python
colours = ['pink', 'red', 'green']
cloths = ['shirt', 'hat', 'socks', 'shorts']

n = min(len(colours), len(cloths))
for i in range(n):
    print(colours[i], cloths[i])
    
# OUTPUT
# pink shirt
# red hat
# green socks
```

Which is good, but you can also use the in-built function `zip(*iterables)` the best thing about this function is that you can pass any number of lists, not just two. Let me rewrite the above code and then explain to you how zip works.

```python
colours = ['pink', 'red', 'green']
cloths = ['shirt', 'hat', 'socks', 'shorts']

for colour, cloth in zip(colours, cloths):
    print(colour, cloth)
    
# OUTPUT
# pink shirt
# red hat
# green socks
```

You might have guessed, zip takes any number of lists and returns another list that contains one element from each list. As you can see, both version produces the same output but the second one looks cleaner.

### 3. reversed()

If you want to loop over a list in reverse order, the traditional method was something like this.

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for i in range(len(cloths)-1, -1, -1):
  print(cloths[i])
  
  
# Output
# -------
# shorts
# socks
# hat
# shirt
```

But with Python, you can use the builtin function called reversed(). Take a look at this example:

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for cloth in reversed(cloths):
  print(cloth)
  
  
# Output
# -------
# shorts
# socks
# hat
# shirt
```

The second one is cleaner and faster than the first one.

### 4. enumerate()

You want to loop through a list along with the index. It's pretty straight forward in traditional programming:

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for i in range(len(cloths)):
  print(i, cloths[i])
  
  
# Output
# -------
# 0 shorts
# 1 socks
# 2 hat
# 3 shirt
```

But there is a cleaner and more efficient way in python:

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for i, cloth in enumerate(cloths):
  print(i, cloth)
  
  
# OUTPUT
# -------
# 0 shorts
# 1 socks
# 2 hat
# 3 shirt
```

### 5. sorted()

You need to loop over a list in sorted order, instead of running a sorting algorithm, you can use the sorted() built-in method.

```python
nums = [2,3,1,5,2]

for i in sorted(nums):
  print(i)
 
# OUTPUT
# ------
# 1
# 2
# 2
# 3
# 5
```

The python sorted function uses Tim Sort with an average complexity of n\*log(n)

For reverse sorting, you can use the attribute ```sorted(nums, reverse=True)```

What you want to sort a list of strings.

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for cloth in sorted(cloths):
  print(cloth)
  
# OUTPUT
# ------
# hat
# shirt
# shorts
# socks
```

It will sort based on letters, but what if you want to sort based on length of the string, you can do that with key attribute. For example:

```python
cloths = ['shirt', 'hat', 'socks', 'shorts']

for cloth in sorted(cloths, key=len):
  print(cloth)
  
# OUTPUT
# ------
# hat
# shirt
# socks
# shorts
```

So that was 5 techniques using with you can make your python code more idiomatic.