Shulou(Shulou.com)06/02 Report--

In this issue, the editor will bring you what are the characteristics and skills of Python language. The article is rich in content and analyzes and narrates it from a professional point of view. I hope you can get something after reading this article.

1 introduction

From the moment I started learning Python, I decided to maintain a list of frequently used "tricks". Whenever I see a paragraph that makes me think, "Cool, that's okay!" (in an example, in StackOverflow, in open source software, etc.), I will try it until I understand it, and then add it to the list. This article is part of the cleaned-up list. If you are an experienced Python programmer, although you may already know something, you can still find something you don't know. If you are a C, C++, or Java programmer learning Python, or are just learning programming, then like me, you will find many of them very useful.

Each trick or language feature can only be verified by examples without too much explanation. Although I have tried my best to make the examples clear, some of them will still look a little complicated, depending on your familiarity. So if it's not clear after looking at the example, the title can provide enough information for you to get the details through Google.

The list is sorted by difficulty, with common language features and techniques at the top.

1.1 split

> > 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) > > a, (b, c), d = [1, (2, 3), 4] > a 1 > > b2 > > c 3 > > d 4

1.2 swap variable split

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

1.3 extended split (applicable under Python 3)

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

1.4 negative index

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

1.5 list slice (a [start:end])

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

1.6 list slices with negative index

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

1.7 list slice with step value (a [start:end:step])

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

1.8 negative stepping worth list slicing

> > 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 slice 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,4,5] > > a [1:-1] = [] > > a [1,5]

1.10 named 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]

1.11 zip package unpacking list and multiples

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

1.12 merge adjacent list items using zip

> 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 zip 2]) [(1, 2), (3, 4), (5, 6)] > zip (a [:: 3], a [1 zip 3], a [2 zip 3]) 3), (4, 5, 6)] > group_adjacent = lambda a, k: zip (* (a [iVera for i in range 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 generate a sliding window (n-grams) using zip and iterators

> 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)] > > n_grams (a) 4) [(1,2,3,4), (2,3,4,5), (3,4,5,6)]

1.14 use zip to reverse the dictionary

> m = {'averse: 1,' baked: 2, 'cantilever: 3,' dashed: 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: 'baked, 3:' cased, 4:'d'}

1.15 flatten 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]

Note: according to Python's documentation, itertools.chain.from_iterable is *.

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 iterative dictionary

> > 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:' A1bath, 2: 'A2levels, 3:' A3bands, 4: 'A4yards, 5:' A5miles, 6: 'A6bands, 7:' A7' 8:'A8', 9:'A9'}

1.18 reverse dictionaries through iterative dictionaries

> m = {'averse: 1,' baked: 2, 'crested: 3,' dashed: 4} > m {'k for k: 4, 'averse: 1,' baked: 2, 'crested: 3} > > {v: k for k, v in m.items ()} {1:' ajar, 2: 'baked, 3:' clocked, 4:'d'}

1.19 named sequence (collections.namedtuple)

> 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

1.20 inheritance of named lists:

> 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 + Q Point (x = 3.0, y = 5.0)

1.21 Collection and collection operation

> > 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]) 2, 4, 5, 6, 7]) > (A ^ B) = ((A-B) | (B-A)) True

1.22Multisets and their operations (collections.Counter)

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

The most common element in the 1.23 iteration (collections.Counter)

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

1.24 double-ended queue (collections.deque)

> > 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])

1.25 double-ended queues with * * length (collections.deque)

> last_three = collections.deque (maxlen=3) > for i in xrange (10):. Last_three.append (I)... Print', '.join (str (x) for x in last_three)... 0, 1, 1, 21, 2, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 7, 7, 8, 9

1.26 Dictionary sort (collections.OrderedDict)

> 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 (collections.defaultdict)

> m = dict () > > m ['a'] Traceback (most recent call last): File "", line 1 In 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 A simple tree is represented by a 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'] [' 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 "}

(go to https://gist.github.com/hrldcpr/2012250 for details)

1.29 Mapping objects to a unique sequence number (collections.defaultdict)

> > import itertools, collections > value_to_numeric_map = collections.defaultdict (itertools.count (). Next) > value_to_numeric_map ['b'] 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 * * minimum elements (heapq.nlargest and heapq.nsmallest)

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

1.31 Cartesian product (itertools.product)

> > for p in itertools.product ([1,2,3], [4,5]): (1,4) (1,5) (2,4) (2,5) (3,4) > for p in itertools.product ([0,1], repeat=4): Print '.join (str (x) for x in p)... 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

1.32 combinations and permutations (itertools.combinations and itertools.combinations_with_replacement)

For c in itertools.combinations ([1, 2, 3, 4, 5], 3): Print'. Join (str (x) for x in c)... 123 124 125 134 135 145 234 235 245 345 > > for c in itertools.combinations_with_replacement ([1, 2, 3], 2): Print '.join (str (x) for x in c)... 11 12 13 22 23 33

1.33 sort (itertools.permutations)

> for p in itertools.permutations ([1,2,3,4]):. Print '.join (str (x) for x in p)... 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4312 4321

1.34 linked iterations (itertools.chain)

> 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) (2, 3) (3, 4) (1, 2, 3, 4) (1, 2, 4) (2, 3, 4)

1.35 Group rows according to a given value (itertools.groupby)

> from operator import itemgetter > 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 ('{:

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.