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

This article focuses on "what are the Python language features and programming skills". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "what are the Python language features and programming skills?"

1 unpacking

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

2 unpacking variable exchange

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

3 extended unpacking (only compatible with python3)

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

4 negative index

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

5 cut list

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

6 negative index cut list

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

7 specify step size cut list

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

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]

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

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]

Compression and decompression of 11 lists and iterators

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

12 list adjacent element Compressor

> 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) > > group_adjacent (a, 1) [(1,), (2,), (3,), (4,), (5,), (6,)] > > zip (a [:: 2], a [1zip 2]) [(1, 2), (3, 4), (5, 6)] > > zip (a [: 3], a [1: 3], a [2])) [(1,2,3), (4,5)] > group_adjacent = lambda a, k: zip (* (a [ifor i in range 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,)]

13 Slide the value window 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)] > > n_grams (a, 4) [(1,2,3) 4), (2, 3, 4, 5), (3, 4, 5)]

14 reverse dictionary with compressor

> 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'}

15 list expansion

> 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], [5,6] > [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]

16 generator expression

> g = (x * * 2 for x in xrange (10)) > > next (g) > 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

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: 'A0,1: 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'}

18 derive a reverse dictionary from a dictionary

> 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'}

19 named tuple

> 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

20 inherits named 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).

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

22 manipulate multiple sets

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

23 statistics on the most common elements in iterators

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

24 queues that are operable at 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])

25 double-ended 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).. 0, 10, 1, 21, 2, 32, 3, 43, 4, 54, 5, 65, 6, 76, 7, 87, 8, 9

26 sortable dictionary

> 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

27 default dictionary

> m = dict () > > m ['a'] Traceback (most recent call last): File "", line 1 In KeyError:'a'> m = collections.defaultdict (int) > > m ['a'] > > m ['b'] > > m = collections.defaultdict (str) > m ['b']'> > m ['b'] + ='a' > > m ['b']'a' > > m = collections.defaultdict (lambda:'[default value]') > > m ['a']'[default value]'> m ['b']'[default value]''

28 simple tree representation of the 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 "}

29 object to unique count mapping

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

30 the largest and smallest list elements

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

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) > for p in itertools.product ([0,1], repeat=4): Print''.join (str (x) for x in p)... 0000000100100011010001010110011100010011010111100110111101111

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).. 123124125134134145234235245345 > for c in itertools.combinations_with_replacement ([1,2,3], 2): Print '.join (str (x) for x in c)... 111213222333

33 arrangement and combination of list elements

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

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

35 clustering according to the specified columns in 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 ('{:

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.