Python 3: Top 50 Tips & Tricks

Python 3: Top 50 Tips & Tricks

Python 3: Top 50 Tips & Tricks. These Python Gems in this post will make Your Code Beautiful and Elegant.

Here is a list of python tips and tricks to help you write an elegant Python 3 code! This article is divided into different kinds of tricks:

  • Python iterable tricks.
  • Python comprehension tricks.
  • Python unpacking tricks.
  • Python itertools tricks.
  • Python collections tricks.
  • Python other tricks.
  • Python easter eggs.
  • Python tricks to understand the context.

1. Python Iterables tricks

Creating a sequence of numbers (zero to ten with skips).

>>> range(0,10,2)
[0, 2, 4, 6, 8]         

Summing a sequence of numbers (calculating the sum of zero to ten with skips).

>>> l = range(0,10,2)
>>> sum(l)
20

Checking whether any element in the sequence is Truthful (checking whether any elements between zero and ten with skips are even).

>>> any(a % 2==0 for a in range(0,10,2))
True

Checking whether all elements in the sequence are Truthful (checking whether all elements between zero and ten with skips are even).


>>> all(a % 2==0 for a in range(0,10,2))
True

Cumulative summing a sequence of numbers (calculating the cumulative sum of zero to ten with skips).

>>> import numpy as np
>>> res = list(np.cumsum(range(0,10,2)))
>>> res
[ 0,  2,  6, 12, 20]

Given each iterable we construct a tuple by adding an index.

>>> a = ['Hello', 'world', '!']
>>> list(enumerate(a))
[(0, 'Hello'), (1, 'world'), (2, '!')]

Concatenating iterable to a single string.

>>> a = ["python","really", "rocks"]
>>> " ".join(a)
'python really rocks'

Combining two iterable of tuples or pivot nested iterables.

# Combining two iterables
>>> a = [1, 2, 3]
>>> b = ['a', 'b', 'c']
>>> z = zip(a, b)
>>> z
[(1, 'a'), (2, 'b'), (3, 'c')]

# Pivoting list of tuples
>>> zip(*z)
[(1, 2, 3), ('a', 'b', 'c')]

Getting min/max from iterable (with/without specific function).

# Getting maximum from iterable
>>> a = [1, 2, -3]
>>> max(a)
2

# Getting maximum from iterable
>>> min(a)
1

# Bot min/max has key value to allow to get maximum by appliing function
>>> max(a,key=abs)
3

Getting sorted iterable (can sort by “compare” function).

>>> a = [1, 2, -3]
>>> sorted(a)
[-3, 1, 2]

>>> sorted(a,key=abs)
[1, 2, -3]

Splitting a single string to list.

>>> s = "a,b,c"
>>> s.split(",")
["a", "b", "c"]

Initializing a list filled with some repetitive number.

>> [1]* 10
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Merging/Upserting two dictionaries.

>>> a = {"a":1, "b":1}
>>> b = {"b":2, "c":1}
>>> a.update(b)
>>> a
{"a":1, "b":2, "c":1}

Naming and saving slices of iterables.


# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]

Finding the index of an item in a list.

>>> a = ["foo", "bar", "baz"]
>>> a.index("bar")
1

Finding the index of the min/max item in an iterable.

>>> a = [2, 3, 1]
>>> min(enumerate(a),key=lambda x: x[1])[0]
2

Rotating iterable by k elements.

>>> a = [1, 2, 3, 4]
>>> k = 2
>>> a[-2:] + a[:-2]
[3, 4, 1, 2]

Removing useless characters on the end/start/both of your string.

>>> name = "//George//"
>>> name.strip("/")
'George'
>>> name.rstrip("/")
'//George'
>>> name.lstrip("/")
'George//'

Reversing an iterable wit order (string, list etc).

# Reversing string
>>> s = "abc"
>>> s[::-1]
"cba"

# Reversing list
>>> l = ["a", "b", "c"]
>>> l[::-1]
["c", "b", "a"]

2. Python branching tricks

Multiple predicates short-cut.

>>> n = 10
>>> 1 < n < 20
True

For-else construct useful when searched for something and find it.

# For example assume that I need to search through a list and process each item until a flag item is found and 
# then stop processing. If the flag item is missing then an exception needs to be raised.

for i in mylist:
    if i == theflag:
        break
    process(i)
else:
    raise ValueError("List argument missing terminal flag.")

Trenary operator.

>>> "Python ROCK" if True else " I AM GRUMPY"
"Python ROCK"

Try-catch-else construct.

try:
  foo() 
except Exception: 
  print("Exception occured")
else:
  print("Exception didnt occur")
finally:
  print("Always gets here")

While-else construct.

i = 5

while i > 1:
    print("Whil-ing away!")
    i -= 1
    if i == 3:
        break
else:
    print("Finished up!")

3. Python comprehensions tricks

List comprehension.

>>> m = [x ** 2 for x in range(5)]
>>> m
[0, 1, 4, 9, 16]

Set comprehension.

>>> m = {x ** 2 for x in range(5)}
>>> m
{0, 1, 4, 9, 16}

Dict comprehension.

>>> m = {x: x ** 2 for x in range(5)}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Generator comprehension.

# A generator comprehension is the lazy version of a list comprehension.
>>> m = (x ** 2 for x in range(5))
>>> m
<generator object <genexpr> at 0x108efe408>
>>> list(m)
[0, 1, 4, 9, 16]

>>> m = (x ** 2 for x in range(5))
>>> next(m)
0
>>> list(m)
[1, 4, 9, 16]

List comprehension with the current and previous value.

>>> a = [1, 2, 4,2]
>>> [y - x for x,y in zip(a,a[1:])]
[1, 2, -2]

Note: all comprehension can use predicates with if statement.

4. Python unpacking tricks

Unpack variables from iterable.

# One can unpack all iterables (tuples, list etc)
>>> a, b, c = 1, 2, 3
>>> a, b, c
(1, 2, 3)

>>> a, b, c = [1, 2, 3]
>>> a, b, c
(1, 2, 3)

Swap variables values.

>>> a, b = 1, 2
>>> a, b = b, a
>>> a, b
(2, 1)

Unpack variables from iterable without indicating all elements.

>>> a, *b, c = [1, 2, 3, 4, 5]
>>> a
1
>>> b
[2, 3, 4]
>>> c
5

Unpack variables using the splat operator.

>>> def test(x, y, z):
>>>     print(x, y, z)  
>>> res = test(*[10, 20, 30]) 
10 20 30
>>> res = test(**{'x': 1, 'y': 2, 'z': 3} )
10 20 30  

5. Python Itertools tricks

Flatten iterables.

>>> a = [[1, 2], [3, 4], [5, 6]]
>>> list(itertools.chain.from_iterable(a))
[1, 2, 3, 4, 5, 6]

Creating cartesian products from iterables.

>>> for p in itertools.product([1, 2, 3], [4, 5]):
>>>    print(''.join(str(x) for x in p))

(1, 4)
(1, 5)
(2, 4)
(2, 5)
(3, 4)
(3, 5)

Creating permutation from iterable.

>>> for p in itertools.permutations([1, 2, 3, 4]):
>>>      print(''.join(str(x) for x in p))
123
132
213
231
312
321

Creating ngram from iterable.

>>> from itertools import islice
>>> def n_grams(a, n):
...     z = (islice(a, i, None) for i in range(n))
...     return zip(*z)
...
>>> a = [1, 2, 3, 4, 5, 6]
>>> n_grams(a, 3)
[(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]
>>> n_grams(a, 2)
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
>>> n_grams(a, 4)
[(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]

Combining two iterables of tuples with padding or pivot nested iterable with padding.

>>> import itertools as it
>>> x = [1, 2, 3, 4, 5]
>>> y = ['a', 'b', 'c']
>>> list(zip(x, y))
[(1, 'a'), (2, 'b'), (3, 'c')]

>>> list(it.zip_longest(x, y))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, None), (5, None)]

Creating a combination of k things from an iterable of n

>>> import itertools
>>> bills = [20, 20, 20, 10, 10, 10, 10, 10, 5, 5, 1, 1, 1, 1, 1]
>>> list(itertools.combinations(bills, 3))
[(20, 20, 20), (20, 20, 10), (20, 20, 10), ... ]

Creating accumulated results of iterable given a function

>>> import itertools
>>> list(itertools.accumulate([9, 21, 17, 5, 11, 12, 2, 6], min))
[9, 9, 9, 5, 5, 5, 2, 2]

Creating an iterator that returns elements from the iterable as long as the predicate is true

>>> import itertools
>>> itertools.takewhile(lambda x: x < 3, [0, 1, 2, 3, 4])  
[0, 1, 2]

>>> it.dropwhile(lambda x: x < 3, [0, 1, 2, 3, 4])
[3, 4]

Creating an iterator that filters elements from iterable returning only those for which the predicate is _False_

>>> import itertools
# keeping only false values
>>> list(itertools.filterfalse(bool, [None, False, 1, 0, 10]))
[None, False, 0]

Creating an iterator that computes the function using arguments obtained from the iterable of iterables

>>> import itertools 
>>> import operator
>>> a = [(2, 6), (8, 4), (7, 3)]
>>> list(itertools.starmap(operator.mul, a))
[12, 32, 21]

6. Python collections tricks

Set basic operations.

>>> A = {1, 2, 3, 3}
>>> A
set([1, 2, 3])
>>> B = {3, 4, 5, 6, 7}
>>> B
set([3, 4, 5, 6, 7])
>>> A | B
set([1, 2, 3, 4, 5, 6, 7])
>>> A & B
set([3])
>>> A - B
set([1, 2])
>>> B - A
set([4, 5, 6, 7])
>>> A ^ B
set([1, 2, 4, 5, 6, 7])
>>> (A ^ B) == ((A - B) | (B - A))
True

Counter data structure (an unordered collection where elements are stored as dictionary keys and their counts are stored as dictionary values).

import collections

>>> A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7])
>>> A
Counter({3: 4, 1: 2, 2: 2, 4: 1, 5: 1, 6: 1, 7: 1})
>>> A.most_common(1)
[(3, 4)]
>>> A.most_common(3)
[(3, 4), (1, 2), (2, 2)]

Default dictionary structure (a subclass of dictionary that retrieves default value when non-existing key getting accessed).

>>> import collections
>>> m = collections.defaultdict(int)
>>> m['a']
0

>>> m = collections.defaultdict(str)
>>> m['a']
''
>>> m['b'] += 'a'
>>> m['b']
'a'

>>> m = collections.defaultdict(lambda: '[default value]')
>>> m['a']
'[default value]'
>>> m['b']
'[default value]'

>>> m = collections.defaultdict(list)
>>> m['a']
[]

Ordered dict structure (a subclass of dictionary that keeps order).

>>> from collections import OrderedDict

>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'

>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

Deques structure (_Deques are a generalization of stacks and queues)._

>>> import collection
>>> Q = collections.deque()
>>> Q.append(1)
>>> Q.appendleft(2)
>>> Q.extend([3, 4])
>>> Q.extendleft([5, 6])
>>> Q
deque([6, 5, 2, 1, 3, 4])
>>> Q.pop()
4
>>> Q.popleft()
6
>>> Q
deque([5, 2, 1, 3])
>>> Q.rotate(3)
>>> Q
deque([2, 1, 3, 5])
>>> Q.rotate(-3)
>>> Q
deque([5, 2, 1, 3])

>>> last_three = collections.deque(maxlen=3)
>>> for i in range(4):
...     last_three.append(i)
...     print ', '.join(str(x) for x in last_three)
...
0
0, 1
0, 1, 2
1, 2, 3
2, 3, 4

Named tuples structure (create tuple-like objects that have fields accessible by attribute lookup as well as being indexable and iterable).

>>> import collections
>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(x=1.0, y=2.0)
>>> p
Point(x=1.0, y=2.0)
>>> p.x
1.0
>>> p.y
2.0

Use A Dictionary To Store A Switch.


>>> func_dict = {'sum': lambda x, y: x + y, 'subtract': lambda x, y: x - y}
>>> func_dict['sum'](9,3)
12
>>> func_dict['subtract'](9,3)
6

Data classes structure

>>> from dataclasses import dataclass

>>> @dataclass
>>> class DataClassCard:
>>>    rank: str
>>>    suit: str

>>> queen_of_hearts = DataClassCard('Q', 'Hearts')
>>> queen_of_hearts.rank
'Q'
>>> queen_of_hearts
DataClassCard(rank='Q', suit='Hearts')
>>> queen_of_hearts == DataClassCard('Q', 'Hearts')
True

7. Other Python tricks

Generating uuid.

# This creates a randomized 128-bit number that will almost certainly be unique.
# In fact, there are over 2¹²² possible UUIDs that can be generated. That’s over five undecillion (or 5,000,000,000,000,000,000,000,000,000,000,000,000).

>>> import uuid
>>> user_id = uuid.uuid4()
>>> user_id 
UUID('7c2faedd-805a-478e-bd6a-7b26210425c7')

Memoization using LRU cache.

import functools

@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

Suppression of expressions

>>> from contextlib import suppress
>>> with contextlib.suppress(ZeroDivisionError):
>>>     10/0
# No exception raised

An elegant way to deal with a file path (3.4≥)

>>> from pathlib import Path
>>> data_folder = Path("source_data/text_files/")

# Path calculation and metadata
>>> file_to_open = data_folder / "raw_data.txt"
>>> file_to_open.name
"raw_data.txt"
>>> file_to_open.suffix
"txt"
>>>file_to_open.stem
"raw_data"

# Files functions                       
>>> f = open(file_to_open)
>>> f.read()
# content of the file                      
>>> file_to_open.exists()
True

Creating decorator to separate concerns

>>>from functools import wraps

>>>def add_sandwich(wrapped):
>>>    @wraps(wrapped)
>>>    def wrapper(*args, **kwargs):
>>>        return wrapped(*args, **kwargs) + ' sandwich'
>>>    return wrapper

>>>@add_sandwich
>>>def ham():
>>>    return 'ham'

>>>ham()
'ham sandwich'

Using yield to create a simple iterator

>>> def foo(lst):
>>>   for x in lst:
>>>       yield x
>>>       yield x*2

>>> a = [1, 3]
>>> list(foo(a))
[1, 2, 3, 6]

8. Python easter eggs

Anti-gravity

import antigravity

antigravity.fly()

The Zen of Python

>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one and preferably only one obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea let's do more of those!

List object attributes

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir("Hello World")
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Summary

_If you think I should add any more or have suggestions please do let me know in the comments. Thank for reading !

Python Python3 Python Tricks Coding Programming

Bootstrap 5 Complete Course with Examples

Bootstrap 5 Tutorial - Bootstrap 5 Crash Course for Beginners

Nest.JS Tutorial for Beginners

Hello Vue 3: A First Look at Vue 3 and the Composition API

Building a simple Applications with Vue 3

Deno Crash Course: Explore Deno and Create a full REST API with Deno

How to Build a Real-time Chat App with Deno and WebSockets

Convert HTML to Markdown Online

HTML entity encoder decoder Online

Generate QR Code using Python — Python Programming — PyShark

This article will explore how to generate QR code in Python and some useful creation features from pyqrcode library. QR codes recently became more popular than ever before, yet few people know that the first iterations of QR codes were created back in 1990s in Japan for the automotive industry.

Python Programming: A Beginner’s Guide

Python is an interpreted, high-level, powerful general-purpose programming language. You may ask, Python’s a snake right? and Why is this programming language named after it?

Guide to Python Programming Language

Guide to Python Programming Language

Does Python Skills Equal Getting a Coding Job?

Does Python Skills Equal Getting a Coding Job? Python is one of the most popular programming languages. It is easy to pick up and begin with the basics.

How To Compare Tesla and Ford Company By Using Magic Methods in Python

Magic Methods are the special methods which gives us the ability to access built in syntactical features such as ‘<’, ‘>’, ‘==’, ‘+’ etc.. You must have worked with such methods without knowing them to be as magic methods. Magic methods can be identified with their names which start with __ and ends with __ like __init__, __call__, __str__ etc. These methods are also called Dunder Methods, because of their name starting and ending with Double Underscore (Dunder).