Categories
Python

All The Cool Tricks In Python To Make Your Life Easy

Learn some Python’s cool tricks and solve difficult programming question easily.

Simplicity is Python’s way to solve a problem

1. Reverse a string, list or tuple

Whenever I’d find myself in a situation where I was required to perform a reverse operation, more often than not, I would use a for loop or resort to find some function like reverse() that had do the job for me. But later on, to my shock I found, python has got another trick up it’s sleeve to solve this in a jiffy — Slicing OperationYou can use slicing [::-1] syntax to reverse a string, tuple or a list as well.

string = 'John Wick'
print(string[::-1]) # logs: 'kciW nhoJ'
tup = (23, 45, 12, 56)
print(tup[::-1]) # logs: (56, 12, 45, 23)
l = ['john', 'baba', 'yaga', 'wick']
print(l[::-1]) # logs: ['wick', 'yaga', 'baba', 'john']

2. Check if given string is a palindrome

Pretty easy, right? A lot of different approach comes to our mind when we think about this ways to solve this problem. But guess, one of the most simple way to solve this problem could again be the slicing operation.

Using the above discussed reversing trick, one line of code would be enough to check whether a given string is a palindrome or not. Firstly, we use string[::-1] to reverse the string and then we simply compare our original string with the reversed string string == string[::-1] to get the result.

string = 'aibohphobia'
print('Palindrome' if string == string[::-1] else 'No Plaindrome')
# print: Palindrome
string = 'johnwick'
print('Palindrome' if string == string[::-1] else 'No Plaindrome')
# print: No Plaindrome

3. Get “n” number of largest or smallest elements from a list

Today, we will be using python’s standard library heapify to convert our list into heap and then use nlargest(n, iterable) and nsmallest(n, iterable) method to find “n” number of largest and smallest elements from our heap.

lis = [23, 9, 34, 22, 43, 21, 5, 40]
import heapq
heapq.heapify(lis) # Convert list into min heap
print(heapq.nlargest(4, lis)) # will print 4 largest elements
# print: [43, 40, 34, 23]
print(heapq.nsmallest(4, lis)) # will print 4 smallest element
# print: [5, 9, 21, 22]

4. Swap 2 element without using a third variable

This question would come up rather frequently to me in job interviews and the interviewer (if not from python background) would get irritated when I’d use this trick. But as a python enthusiast/developer, you’d always find yourself be in better position when you know such tricks.

Simply use a,b = b,a to swap the values of both the variables. Although if you are interested to know how this internally works, refer this explanation.

a = 10
b = 25
print(f'a: {a}, b: {b}') # print: a: 10, b: 25
a,b = b,a # swapping variable 
print(f'a: {a}, b: {b}') # print: a: 25, b: 10

Of course in interviews, you can always resort to the old ways to answer :-

a,b = 10, 25
a = a ^ b
b = a ^ b 
a = a ^ b
print(f'a: {a}, b: {b}') # print: a: 25, b: 10

5. Count occurrence of each element in a string, tuple and list

Python has an amazing collections module which contains many useful utilities. For this purpose, we are going to use Counter from collections module.

Firstly, let’s split our string using split() function which returns us a list of strings split on spaces by default →


quoteFromGeeta = 'senses exists beyond body  mind exists beyond senses  intelligence exists beyond  and knowing yourself exists beyond intelligence'
word_list = quoteFromGeeta.split()
print(word_list)
print: ['senses', 'exists', 'beyond', 'body', 'mind', 'exists', 'beyond', 'senses', 'intelligence', 'exists', 'beyond', 'mind', 'and', 'knowing', 'yourself', 'exists', 'beyond', 'intelligence']

Now using Counter, Let’s find out the count of each word in our word_list.

from collections import Counter
c = Counter(word_list) # pass your list to Counter
[print(f'Word: {word}, Count: {count}') for word,count in c.items()]
# prints
Word: senses, Count: 2
Word: exists, Count: 4
Word: beyond, Count: 4
Word: body, Count: 1
Word: mind, Count: 2
Word: intelligence, Count: 2
Word: and, Count: 1
Word: knowing, Count: 1
Word: yourself, Count: 1

Easy, isn’t it? Furthermore, you can also find most common words using most_common(n) method.

common_words = c.most_common(3)
[print(word, count) for word,count in common_words]
# print
Word: exists, Count: 4
Word: beyond, Count: 4
Word: senses, Count: 2

6. Check if two strings are Anagram

You must be wondering, what is an Anagram, right ?
An anagram of a string is a string that contains the same characters, only the order of characters can be different. For example, “abcd” and “dabc” are an anagram of each other.

Here we are using Counter from collections , so we can easily check if two strings are anagram or not →

from collections import Counter
str1 = 'abcd'
str2 = 'dabc'
c1 = Counter(name1)
c2 = Counter(name2)
print(c1 == c2) # print True

7. Check for more than two conditions using Operator Chaining →

Checking a value for multiple conditions is a task we perform on daily basis.

Let’s consider an example where we need to check for 5 < a < 20. Firstly, let’s see how we would implement it using other programming languages.

if a > 5 and a < 20:
    pass

In python, you can simply use operator chaining →

if 5 < a < 20:
    pass

8. Fetch values from list and assign to variables

To solve this problem, we will use a concept that is still elusive to a lot of developers — Unpacking

Although most of us might have used it at some point but the concept in itself is something that would peek your interest. So if you are new to this concept, then you are definitely going to learn something awesome today.

Unpacking in Python refers to an operation that consists of assigning an iterable of values to a tuple (or list ) of variables in a single assignment statement.

Now let’s refer to an example →

l = ['john', '40', 'assassin']
#with out unpacking feature
name = l[0]
age = age[1]
profession = l[2]
#with unpacking feature
name, age, profession = l

To explore it’s working in-depth, let us refer to this article from Stackabuse for an amazing explanation.

9. Get last element of list, string and tuple →

Let’s see a solution that will make it look like a piece of cake to solve this problem. 

Solution Template –> Using iterable[-1] to find the last element.

l = ['john', '40', 'assassin']
print(l[-1]) # 'assassin'

10. Check if a list or tuple is empty

If you have always found it cumbersome to check if a list is empty or not. And if you have been using such tedious and messy approach like the one shown below. Then we are going to witness something that will make our life so much easier. So first, let us see the more conventionally used way

temp = []
if len(temp) == 0:
   pass
if len(temp):
   pass

In python, an empty list is considered as a false so you can directly check it like the way shown below →

if temp:
   pass

11. Concatenate two list, tuple →

You can use + operator to concatenate tuple and list, after performing concatenation it will return new tuple or list.

# On list
list1 = [1,2,3,4,5]
list2 = [6,7,8,9,10]
list_new = list1 + list2
print(list_new) # print [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# On tuple
tuple1 = (1,2,3,4,5)
tuple2 = (6,7,8,9,10)
tuple3 = (11,12,13,14,15)
tuple_new = tuple1 + tuple2 + tuple3
print(tuple_new)

12. Create a new list from existing list →

Let’s understand our problem statement with an example.

l = ['John Wick', 45, 'assassin']
new_l =  l # this will copy the reference of l in new_l
print(new_l) # print  ['John Wick', 45, 'assassin']
l[0] = 'Baba Yaga' # any change in l will reflect to new_l also
print(new_l) # print ['Baba Yaga', 45, 'assassin']

From above snapshot, it is evident that the new list variable just stored a reference address of the existing list. And now, it points to the reference address but as per our requirement a new list was not created.

Solution — To create a totally new list, you can simply use list[:]on the existing list and you will have a new list through one simple operation.

l = ['John Wick', 45, 'assassin']
new_l =  l[:] # this will create the new list
print(new_l) # print  ['John Wick', 45, 'assassin']
l[0] = 'Baba Yaga' # any change in l will reflect to new_l also
print(new_l) # print ['John Wick', 45, 'assassin']

Note :- list[:] only creates a shallow copy of list. So if we want to create a deep copy you can use deepcopy() method from copy module

To be Continued…

There are more cool libraries in python like functools, itertools, pandas which we will explore in further articles. But for today, we are going to call it a day and let’s try to reflect on what we have learned. Granted it’s not easy to be at pace with everything at once, but now we are aware of tricks that make our life easy. And in time, you will no doubt get comfortable with all these tricks and have them at your fingertips.

Hope you have enjoyed the article. Please do tell me in comment, which trick you like most.

Good Luck, Happy Coding

Let the author know what's in your mind !!

This site uses Akismet to reduce spam. Learn how your comment data is processed.