Comprehensive Python Cheat Sheet | 2019 | Coders Blog

1
2
if __name__ == '__main__':     # Runs main() if file wasn't imported.
    main()

1
<list> = <list>[from_inclusive : to_exclusive : ±step_size]

1
2
<list>.append(<el>)            # Or: <list> += [<el>]
<list>.extend(<collection>)    # Or: <list> += <collection>

1
2
3
4
<list>.sort()
<list>.reverse()
<list> = sorted(<collection>)
<iter> = reversed(<list>)

1
2
3
4
5
6
7
sum_of_elements  = sum(<collection>)
elementwise_sum  = [sum(pair) for pair in zip(list_a, list_b)]
sorted_by_second = sorted(<collection>, key=lambda el: el[1])
sorted_by_both   = sorted(<collection>, key=lambda el: (el[1], el[0]))
flatter_list     = list(itertools.chain.from_iterable(<list>))
product_of_elems = functools.reduce(lambda out, x: out * x, <collection>)
list_of_chars    = list(<str>)

1
2
3
4
5
index = <list>.index(<el>)     # Returns index of first occurrence or raises ValueError.
<list>.insert(index, <el>)     # Inserts item at index and moves the rest to the right.
<el> = <list>.pop([index])     # Removes and returns item at index or from the end.
<list>.remove(<el>)            # Removes first occurrence of item or raises ValueError.
<list>.clear()                 # Removes all items. Also works on dict and set.

1
2
3
<view> = <dict>.keys()    # Coll. of keys that reflects changes.
<view> = <dict>.values()  # Coll. of values that reflects changes.
<view> = <dict>.items()   # Coll. of key-value tuples.

1
2
3
4
value  = <dict>.get(key, default=None)       # Returns default if key does not exist.
value  = <dict>.setdefault(key, default=None)# Same, but also adds default to dict.
<dict> = collections.defaultdict(<type>)     # Creates a dict with default value of type.
<dict> = collections.defaultdict(lambda: 1)  # Creates a dict with default value 1.

1
2
3
4
<dict>.update(<dict>)
<dict> = dict(<collection>)            # Creates a dict from coll. of key-value pairs.
<dict> = dict(zip(keys, values))       # Creates a dict from two collections.
<dict> = dict.fromkeys(keys [, value]) # Creates a dict from collection of keys.

1
2
3
4
5
6
>>> from collections import Counter
>>> colors = ['red', 'blue', 'yellow', 'blue', 'red', 'blue']
>>> counter = Counter(colors)
Counter({'blue': 3, 'red': 2, 'yellow': 1})
>>> counter.most_common()[0]
('blue', 3)

1
<set> = set()

1
2
<set>.add(<el>)                               # Or: <set> |= {<el>}
<set>.update(<collection>)                    # Or: <set> |= <set>

1
2
3
4
5
6
<set>  = <set>.union(<coll.>)                 # Or: <set> | <set>
<set>  = <set>.intersection(<coll.>)          # Or: <set> & <set>
<set>  = <set>.difference(<coll.>)            # Or: <set> - <set>
<set>  = <set>.symmetric_difference(<coll.>)  # Or: <set> ^ <set>
<bool> = <set>.issubset(<coll.>)              # Or: <set> <= <set>
<bool> = <set>.issuperset(<coll.>)            # Or: <set> >= <set>

1
2
<set>.remove(<el>)                            # Raises KeyError.
<set>.discard(<el>)                           # Doesn't raise an error.

1
2
<frozenset> = frozenset(<collection>)

1
2
3
<tuple> = ()
<tuple> = (<el>, )
<tuple> = (<el_1>, <el_2>, ...)

1
2
3
4
5
6
7
8
9
10
11
12
>>> from collections import namedtuple
>>> Point = namedtuple('Point', 'x y')
>>> p = Point(1, y=2)
Point(x=1, y=2)
>>> p[0]
1
>>> p.x
1
>>> getattr(p, 'y')
2
>>> p._fields  # Or: Point._fields
('x', 'y')

1
2
3
<range> = range(to_exclusive)
<range> = range(from_inclusive, to_exclusive)
<range> = range(from_inclusive, to_exclusive, ±step_size)

1
2
from_inclusive = <range>.start
to_exclusive   = <range>.stop

1
2
for i, el in enumerate(<collection> [, i_start]):
    ...

1
2
3
<iter> = iter(<collection>)                 # Calling `iter(<iter>)` returns unmodified iterator.
<iter> = iter(<function>, to_exclusive)     # Sequence of return values until 'to_exclusive'.
<el>   = next(<iter> [, default])           # Raises StopIteration or returns 'default' on end.

1
from itertools import count, repeat, cycle, chain, islice

1
2
3
<iter> = count(start=0, step=1)             # Returns incremented value endlessly.
<iter> = repeat(<el> [, times])             # Returns element endlessly or 'times' times.
<iter> = cycle(<collection>)                # Repeats the sequence indefinitely.

1
2
<iter> = chain(<coll.>, <coll.> [, ...])    # Empties collections in order.
<iter> = chain.from_iterable(<collection>)  # Empties collections inside a collection in order.

1
2
3
<iter> = islice(<collection>, to_exclusive)
<iter> = islice(<collection>, from_inclusive, to_exclusive)
<iter> = islice(<collection>, from_inclusive, to_exclusive, +step_size)