30 Python-Tipps-Python-Tutorial-php.cn

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

>>> >[2, 3, 4]

>>> c

5

　

1,4 Negativindex

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

>>> a[-1]

>>> a[-3]

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

>>> value_to_numeric_map['b']

>>> 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中文网（m.sbmmt.com）！