30 tips on Python and 30 tips on Python

30 tips on Python and 30 tips on Python

When I started learning python, I began to summarize a collection of python tips. When will I go to Stack Overflow?
Or when I saw a piece of cool code in an open-source software, I was surprised: I could do this again !, At that time, I tried the code myself and added it to my set after I understood its overall idea. This blog is actually a part of the public appearance after this collection. If you are already a python guru, You should know most of the usage here, but I think you should be able to find some new tips that you don't know. If you were a c, c ++, and java programmer, and you are learning python at the same time, or you are just a beginner in programming, then you will see a lot of useful practical skills that can surprise you, just as I did at the beginning.

Every technique and language usage will be presented to you in an example, without any additional instructions. I have tried my best to make every example easy to understand, but readers may still have some obscure points because of their different familiarity with python. So if these examples cannot be understood by you, at least the title of this example will help you when you go to google search.

The entire set is probably sorted by difficulty level. Simplicity is common at the beginning and rarely at the end.

1.1 binning

>>> a, b, c = 1, 2, 3>>> a, b, c(1, 2, 3)>>> a, b, c = [1, 2, 3]>>> a, b, c(1, 2, 3)>>> a, b, c = (2 * i + 1 for i in range(3))>>> a, b, c(1, 3, 5)>>> a, (b, c), d = [1, (2, 3), 4]>>> a1>>> b2>>> c3>>> d4

　　

1.2 binning variable exchange

 

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

　　

1.3 extension unpacking (only compatible with python3)

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

　　

1.4 negative Index

 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> a[-1]10>>> a[-3]8

1.5 cut list

 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> a[2:8][2, 3, 4, 5, 6, 7]

1.6 negative index cutting list

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> a[-4:-2][7, 8]

1.7 specified step cut list

 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> a[::2][0, 2, 4, 6, 8, 10]>>> a[::3][0, 3, 6, 9]>>> a[2:8:2][2, 4, 6]

1.8 negative step cut list

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> a[::-1][10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]>>> a[::-2][10, 8, 6, 4, 2, 0]

1.9 list cut assignment

>>> a = [1, 2, 3, 4, 5]>>> a[2:3] = [0, 0]>>> a[1, 2, 0, 0, 4, 5]>>> a[1:1] = [8, 9]>>> a[1, 8, 9, 2, 0, 0, 4, 5]>>> a[1:-1] = []>>> a[1, 5]

1.10 Naming list Cutting Method

>>> a = [0, 1, 2, 3, 4, 5]>>> LASTTHREE = slice(-3, None)>>> LASTTHREEslice(-3, None, None)>>> a[LASTTHREE][3, 4, 5]

1.11 list and iterator compression and decompression

>>> a = [1, 2, 3]>>> b = ['a', 'b', 'c']>>> z = zip(a, b)>>> z[(1, 'a'), (2, 'b'), (3, 'c')]>>> zip(*z)[(1, 2, 3), ('a', 'b', 'c')]

1.12 list adjacent element Compressors

 

>>> a = [1, 2, 3, 4, 5, 6]>>> zip(*([iter(a)] * 2))[(1, 2), (3, 4), (5, 6)] >>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))>>> group_adjacent(a, 3)[(1, 2, 3), (4, 5, 6)]>>> group_adjacent(a, 2)[(1, 2), (3, 4), (5, 6)]>>> group_adjacent(a, 1)[(1,), (2,), (3,), (4,), (5,), (6,)] >>> zip(a[::2], a[1::2])[(1, 2), (3, 4), (5, 6)] >>> zip(a[::3], a[1::3], a[2::3])[(1, 2, 3), (4, 5, 6)] >>> group_adjacent = lambda a, k: zip(*(a[i::k] for i in range(k)))>>> group_adjacent(a, 3)[(1, 2, 3), (4, 5, 6)]>>> group_adjacent(a, 2)[(1, 2), (3, 4), (5, 6)]>>> group_adjacent(a, 1)[(1,), (2,), (3,), (4,), (5,), (6,)]

　　

1.13 sliding value windows with compressors and iterators in the list

>>> def n_grams(a, n):...     z = [iter(a[i:]) 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)]

　　

 

1.14 reverse dictionary with a compressed file

>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}>>> m.items()[('a', 1), ('c', 3), ('b', 2), ('d', 4)]>>> zip(m.values(), m.keys())[(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]>>> mi = dict(zip(m.values(), m.keys()))>>> mi{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

1.15 expand the list

>>> a = [[1, 2], [3, 4], [5, 6]]>>> list(itertools.chain.from_iterable(a))[1, 2, 3, 4, 5, 6] >>> sum(a, [])[1, 2, 3, 4, 5, 6] >>> [x for l in a for x in l][1, 2, 3, 4, 5, 6] >>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]>>> [x for l1 in a for l2 in l1 for x in l2][1, 2, 3, 4, 5, 6, 7, 8] >>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]>>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]>>> flatten(a)[1, 2, 3, 4, 5, 6, 7, 8]

　　

 

1.16 generator expression

 

>>> g = (x ** 2 for x in xrange(10))>>> next(g)0>>> next(g)1>>> next(g)4>>> next(g)9>>> sum(x ** 3 for x in xrange(10))2025>>> sum(x ** 3 for x in xrange(10) if x % 3 == 1)408

　　

1.17 dictionary Derivation

>>> m = {x: x ** 2 for x in range(5)}>>> m{0: 0, 1: 1, 2: 4, 3: 9, 4: 16} >>> m = {x: 'A' + str(x) for x in range(10)}>>> m{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}

　　

1.18 use a dictionary to derive a reverse dictionary

>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}>>> m{'d': 4, 'a': 1, 'b': 2, 'c': 3}>>> {v: k for k, v in m.items()}{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

　　

1.19 name tuples

>>> Point = collections.namedtuple('Point', ['x', 'y'])>>> p = Point(x=1.0, y=2.0)>>> pPoint(x=1.0, y=2.0)>>> p.x1.0>>> p.y2.0

 

1.20 inherit the name tuples

>>> class Point(collections.namedtuple('PointBase', ['x', 'y'])):...     __slots__ = ()...     def __add__(self, other):...             return Point(x=self.x + other.x, y=self.y + other.y)...>>> p = Point(x=1.0, y=2.0)>>> q = Point(x=2.0, y=3.0)>>> p + qPoint(x=3.0, y=5.0)

 

1.21 operation set

 

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

　　

1.22 multiple sets of operations

>>> A = collections.Counter([1, 2, 2])>>> B = collections.Counter([2, 2, 3])>>> ACounter({2: 2, 1: 1})>>> BCounter({2: 2, 3: 1})>>> A | BCounter({2: 2, 1: 1, 3: 1})>>> A & BCounter({2: 2})>>> A + BCounter({2: 4, 1: 1, 3: 1})>>> A - BCounter({1: 1})>>> B - ACounter({3: 1})

　　

1.23 measure the most common elements in the iteratable.

 

>>> A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7])>>> ACounter({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)]

　　

1.24 queues that can be operated on both ends

 

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

　　

1.25 dual-end queue with maximum length

>>> last_three = collections.deque(maxlen=3)>>> for i in xrange(10):...     last_three.append(i)...     print ', '.join(str(x) for x in last_three)...00, 10, 1, 21, 2, 32, 3, 43, 4, 54, 5, 65, 6, 76, 7, 87, 8, 9

　　

1.26 sorteddictionary

 

>>> m = dict((str(x), x) for x in range(10))>>> print ', '.join(m.keys())1, 0, 3, 2, 5, 4, 7, 6, 9, 8>>> m = collections.OrderedDict((str(x), x) for x in range(10))>>> print ', '.join(m.keys())0, 1, 2, 3, 4, 5, 6, 7, 8, 9>>> m = collections.OrderedDict((str(x), x) for x in range(10, 0, -1))>>> print ', '.join(m.keys())10, 9, 8, 7, 6, 5, 4, 3, 2, 1

　　

 

1.27 default dictionary

>>> m = dict()>>> m['a']Traceback (most recent call last):  File "<stdin>", line 1, in <module>KeyError: 'a'>>>>>> m = collections.defaultdict(int)>>> m['a']0>>> m['b']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]'

　　

1.28 simple tree expression of default dictionary

>>> import json>>> tree = lambda: collections.defaultdict(tree)>>> root = tree()>>> root['menu']['id'] = 'file'>>> root['menu']['value'] = 'File'>>> root['menu']['menuitems']['new']['value'] = 'New'>>> root['menu']['menuitems']['new']['onclick'] = 'new();'>>> root['menu']['menuitems']['open']['value'] = 'Open'>>> root['menu']['menuitems']['open']['onclick'] = 'open();'>>> root['menu']['menuitems']['close']['value'] = 'Close'>>> root['menu']['menuitems']['close']['onclick'] = 'close();'>>> print json.dumps(root, sort_keys=True, indent=4, separators=(',', ': ')){    "menu": {        "id": "file",        "menuitems": {            "close": {                "onclick": "close();",                "value": "Close"            },            "new": {                "onclick": "new();",                "value": "New"            },            "open": {                "onclick": "open();",                "value": "Open"            }        },        "value": "File"    }}

　　

 

1.29 mappings between objects and unique counts

 

>>> import itertools, collections>>> value_to_numeric_map = collections.defaultdict(itertools.count().next)>>> value_to_numeric_map['a']0>>> value_to_numeric_map['b']1>>> value_to_numeric_map['c']2>>> value_to_numeric_map['a']0>>> value_to_numeric_map['b']1

　　

1.30 the largest and smallest list elements

 

>>> a = [random.randint(0, 100) for __ in xrange(100)]>>> heapq.nsmallest(5, a)[3, 3, 5, 6, 8]>>> heapq.nlargest(5, a)[100, 100, 99, 98, 98]

　　

1.31 Cartesian product of two lists

 

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

　　

1.32 list combination and list element substitution combination

 

>>> for c in itertools.combinations([1, 2, 3, 4, 5], 3):...     print ''.join(str(x) for x in c)...123124125134135145234235245345>>> for c in itertools.combinations_with_replacement([1, 2, 3], 2):...     print ''.join(str(x) for x in c)...111213222333

　　

1.33 list element arrangement and combination

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

　　

1.34 connectable iterator

 

>>> a = [1, 2, 3, 4]>>> for p in itertools.chain(itertools.combinations(a, 2), itertools.combinations(a, 3)):...     print p...(1, 2)(1, 3)(1, 4)(2, 3)(2, 4)(3, 4)(1, 2, 3)(1, 2, 4)(1, 3, 4)(2, 3, 4)>>> for subset in itertools.chain.from_iterable(itertools.combinations(a, n) for n in range(len(a) + 1))...     print subset...()(1,)(2,)(3,)(4,)(1, 2)(1, 3)(1, 4)(2, 3)(2, 4)(3, 4)(1, 2, 3)(1, 2, 4)(1, 3, 4)(2, 3, 4)(1, 2, 3, 4)

　　

1.35 specify column Clustering Based on the file

 

>>> import itertools>>> with open('contactlenses.csv', 'r') as infile:...     data = [line.strip().split(',') for line in infile]...>>> data = data[1:]>>> def print_data(rows):...     print '\n'.join('\t'.join('{: <16}'.format(s) for s in row) for row in rows)... >>> print_data(data)young               myope                   no                      reduced                 noneyoung               myope                   no                      normal                  softyoung               myope                   yes                     reduced                 noneyoung               myope                   yes                     normal                  hardyoung               hypermetrope            no                      reduced                 noneyoung               hypermetrope            no                      normal                  softyoung               hypermetrope            yes                     reduced                 noneyoung               hypermetrope            yes                     normal                  hardpre-presbyopic      myope                   no                      reduced                 nonepre-presbyopic      myope                   no                      normal                  softpre-presbyopic      myope                   yes                     reduced                 nonepre-presbyopic      myope                   yes                     normal                  hardpre-presbyopic      hypermetrope            no                      reduced                 nonepre-presbyopic      hypermetrope            no                      normal                  softpre-presbyopic      hypermetrope            yes                     reduced                 nonepre-presbyopic      hypermetrope            yes                     normal                  nonepresbyopic          myope                   no                      reduced                 nonepresbyopic          myope                   no                      normal                  nonepresbyopic          myope                   yes                     reduced                 nonepresbyopic          myope                   yes                     normal                  hardpresbyopic          hypermetrope            no                      reduced                 nonepresbyopic          hypermetrope            no                      normal                  softpresbyopic          hypermetrope            yes                     reduced                 nonepresbyopic          hypermetrope            yes                     normal                  none >>> data.sort(key=lambda r: r[-1])>>> for value, group in itertools.groupby(data, lambda r: r[-1]):...     print '-----------'...     print 'Group: ' + value...     print_data(group)...-----------Group: hardyoung               myope                   yes                     normal                  hardyoung               hypermetrope            yes                     normal                  hardpre-presbyopic      myope                   yes                     normal                  hardpresbyopic          myope                   yes                     normal                  hard-----------Group: noneyoung               myope                   no                      reduced                 noneyoung               myope                   yes                     reduced                 noneyoung               hypermetrope            no                      reduced                 noneyoung               hypermetrope            yes                     reduced                 nonepre-presbyopic      myope                   no                      reduced                 nonepre-presbyopic      myope                   yes                     reduced                 nonepre-presbyopic      hypermetrope            no                      reduced                 nonepre-presbyopic      hypermetrope            yes                     reduced                 nonepre-presbyopic      hypermetrope            yes                     normal                  nonepresbyopic          myope                   no                      reduced                 nonepresbyopic          myope                   no                      normal                  nonepresbyopic          myope                   yes                     reduced                 nonepresbyopic          hypermetrope            no                      reduced                 nonepresbyopic          hypermetrope            yes                     reduced                 nonepresbyopic          hypermetrope            yes                     normal                  none-----------Group: softyoung               myope                   no                      normal                  softyoung               hypermetrope            no                      normal                  softpre-presbyopic      myope                   no                      normal                  softpre-presbyopic      hypermetrope            no                      normal                  softpresbyopic          hypermetrope            no                      normal                  soft