# 5 Python Tricks in one line. Beginner vs Professional

Originally posted on dev.

Python is famous for its simplicity and ease of use. This is achieved, among other things, due to the compactness of the code. At the same time, such conciseness may hide complex program logic. In this article, we will look at 5 examples of “syntactic sugar” for processing sequences, when the built-in constructs of the programming language allow you to write less and easier.

Recall that a sequence is called an iterative data structure or simply an array of elements. In Python, sequences such as list (list), string (str), tuple (tuple), dictionary (dict) or set (set) are most often used.

## CREATING LISTS IN ONE LINE USING LIST COMPREHENSION

Suppose the task is to create a list whose elements are squares of integers. A beginner in programming will do this way:

``````squares = []
for x in range(10):
squares.append(x**2)
``````

As a result:

``````result
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

``````

Note that range is a sequence of numbers from 0 to 10 (not inclusive), and “**” is the exponentiation operator. Now let’s do the same as professional Python developers – the List comprehension construct:

``````squares = [x**2 for x in range(10)]
``````

The result is the same and the code has become more efficient

``````[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
``````

List comprehension can be used for complex (nested) loops. For example, let’s create pairs of elements from two lists the way a beginner will do it:

``````
first = ['a1', 'a2']; second = ['b1', 'b2']
result = []
for i in first:
for j in second :
pair = (i, j)
result.append(pair)

``````

And now a real Python developer with a good level

``````
result = [(i,j) for i in first for j in second]

``````

That’s how with List comprehension you can shorten the process of creating a list from 5 lines to 1. Any programmer will see in your code the hand of a real competent Python developer

## CREATING DICTIONARIES USING DICT COMPREHENSION

You need to create a dictionary whose value corresponds to the square of the key. The beginner’s method requires creating an empty dictionary and a loop with an element-by-element display of the key and value on the next line:

``````
result = {}
for x in range(10):
result[x] = x**2

``````

and result…

``````{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

``````

Yes, we have completed the task. We are programmers. But a real Python professional will only laugh at you.

He will show you the magic

``````result = {x: x**2 for x in range(10)}

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
``````

Note that after x there is a colon separating the key and its value. Similar to a List comprehension, Dict comprehension can be used for nested loops. I hope you noticed that the brackets in the List and Dict comprehensions are different.

## REMOVING DUPLICATES FROM THE LIST

There are duplicate items in the list, and you only need unique values. What will a beginner do? He will definitely create a new list, and in the loop, he will arrange a check for the compliance of the element with the new list. has O(N²) time complexity.:

``````
fruits = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
new = []
for fruit in fruits:
if fruit not in new:
new.append(fruit)

``````

and he will get his result

``````['banana', 'apple', 'pear', 'orange']
``````

As you can see, apple and orange are no longer repeated. In the 5th line, our newcomer checks whether an item is in the new list: if there is, then adds, otherwise ignores. Our professional, who knows about sets, will surprise us again with a 1-line solution has O(N) time complexity

``````# List instead of set
fruits = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

# Actually make `new` a list
new = list(set(fruits))
['banana', 'apple', 'pear', 'orange']
``````

A set is a data structure in which each element is unique. So when you need to exclude duplicate data, use sets

### IMPORTANT NOTICE!

The set does not contain duplicate elements;

The elements of the set are immutable (they cannot be changed), but the set itself is changeable, and it can be changed;

Since the elements are not indexed, the sets do not support any slicing and indexing operations.

## UNPACKING THE ITEMS FROM THE LIST

To pull an element out of the sequence, you want to use the index of the element, right? In some cases, this is correct, but Python allows you to assign each element its own variable.

``````x, y = (15, 5)

x
15

y
5

fruit, num, date = ['apple', 5,(2021, 11, 7)]

date
(2021, 11, 7)
``````

## LISTS SLICING IN PYTHON

In the previous example, we unpacked each item from the list. And what if you need to extract under the list? For example, there is a sequence of 5 elements, you need to take only 3 of them. This is also provided in Python:

``````x = [1, 2, 3, 4, 5]
result = x[:3]

result
[1, 2, 3]
``````

A more detailed syntax looks like this:

``````sequence[start:stop:step]
``````

You can omit START if you want to cut from the zero elements, END if you want to cut to the end, and STEP if your default step is 1

For example:

``````
x = [10, 5, 13, 4, 12, 43, 7, 8]
result = x[1:6:2]
result
[5, 4, 43]
``````

Now, knowing the syntactic sugar in Python and how to use it effectively, you can safely be called a competent Python developer.

Source: dev

Share :