Python 3: Top 50 Tips & 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/")

>>> 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)
# content of the file
>>> file_to_open.exists()
True
``````

Creating decorator to separate concerns

``````>>>from functools import wraps

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

>>>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.
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

8 Likes208.65 GEEK