30 Python-Tipps

Als ich anfing, Python zu lernen, begann ich, eine Sammlung von Python-Tipps zusammenzufassen. Als ich später einen coolen Code auf Stack Overflow
oder in einer Open-Source-Software sah, war ich überrascht: Es stellte sich heraus, dass dies immer noch möglich ist! Zu diesem Zeitpunkt würde ich mein Bestes geben, um diesen Code selbst auszuprobieren. Nachdem ich seine Gesamtidee verstanden hatte, würde ich diesen Code zu meiner Sammlung hinzufügen. Dieser Blog ist eigentlich das öffentliche Debüt des letzten Teils dieser Sammlung. Wenn Sie bereits ein Python-Experte sind, sollten Sie grundsätzlich die meisten Verwendungen hier kennen, aber ich denke, Sie sollten auch in der Lage sein, einige neue Tricks zu entdecken, die Sie nicht kennen. Und wenn Sie ein C-, C++- oder Java-Programmierer waren und gleichzeitig Python lernen, oder einfach ein Anfänger, der gerade erst das Programmieren gelernt hat, dann sollten Sie viele praktische Tipps sehen, die besonders nützlich und überraschend sind, wie ich es war, genauso wie zuvor .

Jede Technik und jeder Sprachgebrauch wird jedem an einem Beispiel gezeigt, eine weitere Erklärung ist nicht erforderlich. Ich habe mein Bestes gegeben, um jedes Beispiel leicht verständlich zu machen, aber da die Leser unterschiedlich gut mit Python vertraut sind, kann es dennoch einige unklare Teile geben. Wenn Ihnen also die Beispiele selbst keinen Sinn ergeben, hilft Ihnen zumindest der Titel des Beispiels, wenn Sie später googeln.

Die gesamte Sammlung ist grob nach Schwierigkeitsgrad sortiert, wobei einfache und häufige am Anfang und seltenere am Ende stehen.

1.1 Auspacken

>>> a, b, c = 1, 2, 3
>>> , 2, 3)
>>> a, b, c = [1, 2, 3]
>>> a, b, c
(1, 2, 3 )
>>> a, b, c = (2 * i + 1 für i im Bereich(3))
>>> 3, 5)
>>> a, (b, c), d = [1, (2, 3), 4]
>>> a
1
>>> b
2
>>> c
3
>>> d

1.2 Unboxing-Variablenaustausch

>>> a, b = 1, 2

>>>

>>> a, b

(2, 1)

　

1.3 Erweiterungs-Unboxing (nur kompatibel mit Python3)

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

>>> a

1

>>> >[2, 3, 4]

>>> c

5


　

1,4 Negativindex

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

>>> a[-1]

10

>>> a[-3]

8

1,5 Schnittliste



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

>>> a[2:8]

[2, 3, 4 , 5 , 6, 7]

1.6 Negativindex-Schnittliste

>>> 8, 9, 10]
>>> a[-4:-2]
[7, 8]

1.7 Schrittgrößen-Schnittliste angeben

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

>>> ::2]

[0, 2, 4, 6, 8, 10]

>>> a[::3]

[0, 3, 6, 9]

>>> a[2:8:2]

[2, 4, 6]


1,8 Negative Schrittgrößen-Schnittliste

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

[10, 8, 6, 4, 2, 0]

1.9 Listenschnittzuweisung

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

>>> = [8, 9]

>>> a

[1, 8, 9, 2, 0, 0, 4, 5]

>>> 1] = []
>>> a
[1, 5]


1.10 Benannte Listenschneidemethode

>>> ; = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = Slice(-3, None)
>>> Keine, Keine)
>>> a[LASTTHREE]

[3, 4, 5]

1.11 Komprimierung und Dekomprimierung von Listen und Iteratoren

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

>> ;> zip(*z)

[(1, 2, 3), ('a', 'b', 'c')]

1.12 Listen sind angrenzender Elementkompressor

>>> 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 在列表中用压缩器和迭代器滑动取值窗口

>>> 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 用压缩器反转字典

>>> 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 列表展开

>> ;> 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 für l in a für x in l]
[1, 2, 3, 4, 5, 6]

>>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
>>> [x für l1 in a für l2 in l1 für x in l2]
[1, 2, 3, 4, 5, 6, 7, 8]

>>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]
>>> flatten = lambda x: [y für l in x für y in flatten(l)] if type(x) is list else [x]
>>> flatten(a)
[1, 2, 3, 4, 5, 6, 7, 8]

　　

 

1.16 生成器表达式

 

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

　　

1.17 字典推导

> ;>> m = {x: x ** 2 für x im Bereich(5)}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

>>> m = {x: 'A' + str(x) für x im Bereich(10)}
>>> m
{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: ' A7“, 8: „A8“, 9: „A9“ m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> m

{'d': 4, 'a': 1, 'b': 2, 'c': 3}

>>> {v: k für k, v in m.items()}

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

　　

1.19 命名元组

>>> Point =collections.namedtuple('Point', ['x', 'y'])
>>> p = Punkt(x=1,0, y=2,0)

>>> p

Punkt(x=1,0, y=2,0)

>>> p.x

1,0

>>> p.y

2,0


 

1,20 继承命名元组

>>> 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 = Punkt(x=1,0, y=2,0)
>>> q = Punkt(x=2,0, y=3,0)
>>> p + q
Punkt(x=3,0, y=5,0)

 

1,21 操作集合

 

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

　　

1.22 操作多重集合

> ;>> A = Sammlungen.Counter([1, 2, 2])
>>> B = Sammlungen.Counter([2, 2, 3])
>>> A
Zähler({2: 2, 1: 1})
>>> B
Zähler({2: 2, 3: 1})
>>> A | B
Zähler({2: 2, 1: 1, 3: 1})
>>> A & B
Zähler({2: 2})
>>> A + B
Zähler({2: 4, 1: 1, 3: 1})
>>> A - B
Zähler({1: 1})
>>> B - A
Zähler({3: 1})

　　

1.23 统计在可迭代器中最常出现的元素

 

>>> A = Sammlungen.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7])
>>> A
Zähler({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 两端都可操作的队列

 

>>> 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 有最大长度的双端队列

>>> ; last_ three =collections.deque(maxlen=3)
>>> for i in xrange(10):
...     last_two.append(i)
...     PRint ', '.join(str(x) for x in last_two)
...
0
0, 1
0, 1, 2
1, 2, 3
2, 3, 4
3, 4, 5
4, 5, 6
5, 6, 7
6, 7, 8
7, 8, 9

　　

1.26 可排序词典

 

>>> m = dict((str(x), x) für x im Bereich(10))
>>> print ', '.join(m.keys())
1, 0, 3, 2, 5, 4, 7, 6, 9, 8
>>> m = Sammlungen.OrderedDict((str(x), x) für x in Bereich(10))
>>> print ', '.join(m.keys())
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
>>> m = Sammlungen.OrderedDict((str(x), x) für x im Bereich(10, 0, -1))
>>> print ', '.join(m.keys())
10, 9, 8, 7, 6, 5, 4, 3, 2, 1

　　

1,27 默认词典

>>> m = dict()
>>> m['a']
Traceback (letzter Aufruf zuletzt):
 Datei „“, Zeile 1, in
KeyError: 'a'
>> ;>
>>> m = Sammlungen.defaultdict(int)
>>> m['a']
0
>>> m['b']
0
>>> m = Sammlungen.defaultdict(str)
>>> m['a']
''
>>> m['b'] += 'a'
>>> m['b']
'a'
>>> m =collections.defaultdict(lambda: '[Standardwert]')
>>> m['a']
'[Standardwert]'
>>> m['b']
'[Standardwert]'

　　

1.28 默认字典的简单树状表达

>>> json importieren
>>> tree = lambda:collections.defaultdict(tree)
>>> root = tree()
>>> root['menu']['id'] = 'file'
>>> root['menu']['value'] = 'Datei'
>>> root['menu']['menuitems']['new']['value'] = 'Neu'
>>> root['menu']['menuitems']['new']['onclick'] = 'new();'
>>> root['menu']['menuitems']['open']['value'] = 'Öffnen'
>>> 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, Separatoren=(',', ': '))
{
   "menu": {
       "id": "file",
       "menuitems": {
           "close": {
               "onclick": "close();",
               "value": "Close"
          },
           "neu ": {
               "onclick": "new();",
             "value": "New"
           },
           "open": {
              "onclick": "open( );",
               "value": "Open"
           

 

1.29 对象到唯一计数的映射

 

>>> itertools, Sammlungen importieren

>>> 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 ; > a = [random.randint(0, 100) für __ in xrange(100)]
>>> heapq.nsmallest(5, a)
[3, 3, 5, 6, 8]
>>> heapq.nlargest(5, a)

[100, 100, 99, 98, 98]

　　

1.31 两个列表的笛卡尔积

 

>>> für p in itertools.product([1, 2, 3], [4, 5]):
(1, 4)
(1, 5)
(2, 4)

( 2, 5)

(3, 4)

(3, 5)

>>> für 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 列表组合和列表元素替代组合

 

>>> für 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
>>> für 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 列表元素排列组合

>>> ; für 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
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321




1,34 可链接迭代器

 

>>> a = [1, 2, 3, 4]
>>> für 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)
>>> für Teilmenge in itertools.chain.from_iterable(itertools.combinations(a, n) für n in range(len(a) + 1))
...     Teilmenge drucken
...
()
(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 根据文件指定列类聚

 

>>> itertools importieren
>>> mit open('contactlenses.csv', 'r') als 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 (Daten)
junges Myope nein reduziert keine
junges Myop normal                  weich
jung               hypermetrop          ja                   reduziert               keine
jung              e            ja                     normal                  stark
präpresbyope      Myopie                                                  keine
vor Presbyopie      Myopie                   nein                    normal                              ja                     reduziert                 keine
Präpresbyopie                 ja                                               reduziert                 keine
präpresbyopisch      hypermetrop                                  normal                       hypermetropisch            ja                   reduziert               keine
präpresbyopisch      hypermetropisch                                   keine
Presbyopie          Kurzsichtigkeit                   nein                    reduziert                 keine
Presbyopic Myope nein normal keine
Presbyopisches Myope Ja reduziert keine
Presbyopisches Myope Ja Normale Hard
Presbyopic Hypermetrop nein reduziert keine
präsbyopisch hypermetrop ja                     normal                  keine

>>> data.sort(key=lambda r: r[-1])
>>> für Wert, Gruppe in itertools.groupby(data, lambda r: r[-1]):
...     print '-----------'
...     print 'Group : ' + value
...     print_data(group)
...
-----------
Group: hard
young               myope                 ja                   normal                 hart
jung               hypermetropisch            ja                     normal                schwer              normal                  schwer
Presbyopie          kurzsichtig                 ja                   normal                  ---------
Gruppe: keine
jung               Kurzsichtigkeit                   nein reduziert                 keine
jung               Kurzsichtigkeit                           reduziert               keine
jung              metrope            nein                      reduziert               keine
jung             hypermetrope            ja           reduziert                keine
Präpresbyopie                   nein                    reduziert               keine
Präpresbyopie                  ja                     reduziert                 keine
präpresbyopisch      hypermetropisch                      reduziert                 keine
präpresbyopisch      hypermetropisch                    reduziert                 keine
präpresbyope      hypermetrope                   normal                keine
presbyope         Myopie                   nein                                   keine
Presbyopie                         normal                  keine
Presbyopie          Kurzsichtigkeit                   ja                     reduziert keine
presbyopisch          hypermetropisch            nein                    reduziert               keine
presbyopisch          hypermetropisch                              reduziert                 keine
presbyope          hypermetrope            ja                   normal                  keine
-----------
Gruppe: weich
jung               Kurzsichtigkeit nein                    normal                  weich
jung               hypermetropisch                      weich
präpresbyopisch      kurzsichtig                   nein                    normal                weich
präpresbyopisch      hypermetrop                             normal                  weich
presbyopisch          hypermetropisch                      normal                  🎜>

　　

以上就是30个有关Python的小技巧的内容,更多相关文章请关注PHP中文网（www.php.cn）！