30가지 파이썬 팁-파이썬 튜토리얼-php.cn

파이썬을 배우기 시작하면서 파이썬 팁 모음을 정리하기 시작했습니다. 나중에 Stack Overflow
또는 일부 오픈 소스 소프트웨어에서 멋진 코드를 보고 놀랐습니다. 이 작업이 여전히 수행될 수 있다는 사실이 밝혀졌습니다! , 그 당시 나는 이 코드를 직접 시도하려고 최선을 다했습니다. 전체적인 아이디어를 이해한 후 이 코드를 내 컬렉션에 추가했습니다. 이 블로그는 실제로 이 컬렉션의 마지막 부분을 공개적으로 소개하는 블로그입니다. 이미 Python 전문가라면 기본적으로 여기에서 대부분의 사용법을 알고 있어야 하지만, 자신이 모르는 몇 가지 새로운 요령도 발견할 수 있어야 한다고 생각합니다. 그리고 C, C++, Java 프로그래머이면서 Python을 동시에 배우고 있거나 단순히 프로그래밍을 배운 초보자라면 이전과 마찬가지로 특히 유용하고 놀라운 실용적인 팁을 많이 볼 수 있을 것입니다. .

모든 기술과 언어 사용법은 예를 통해 모든 사람에게 보여지며 다른 설명은 필요하지 않습니다. 각 예제를 이해하기 쉽게 만들기 위해 최선을 다했지만 독자들의 Python 친숙도 수준이 다르기 때문에 여전히 모호한 부분이 있을 수 있습니다. 따라서 예제 자체가 이해가 되지 않는 경우 적어도 예제 제목은 나중에 Google에서 검색할 때 도움이 될 것입니다.

전체 컬렉션은 난이도에 따라 대략적으로 정렬되어 있으며, 앞쪽에는 단순하고 일반적인 항목이 있고 마지막에는 희귀한 항목이 있습니다.

1.1 언박싱

>>> 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]
>>>a
1
>>>b
2
>>>c
3
>>d

🎜>

1.2 언박싱 변수 교환

>>> a, b = 1, 2

>>>

>>> a, b

(2, 1)

　

1.3 확장 프로그램 언박싱(python3과만 호환 가능)

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

>>a

>> >[2, 3, 4]
>>>c
5

　

1.4 음수

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

>>>a[-1]

>>>a[-3]

8

1.5 절단 목록

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

>>> , 6, 7]

1.6 음수 인덱스 컷 목록

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

[7, 8]

1.7 단계 크기 절단 목록 지정

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

>>> ::2]

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

>>> >>>a[2:8:2]

[2, 4, 6]

1.8 음수 단계 크기 절단 목록

>> ;> ; 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 목록 자르기 할당

>>> 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 명명된 목록 잘라내기 방법

>>> = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = 슬라이스(-3, 없음)
>>> LASTTHREE
슬라이스(- 3, 없음, 없음)
>>> a[LASTTHREE]

[3, 4, 5]

1.11 목록 및 반복자의 압축 및 압축 풀기

>>> 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 목록은 인접 요소 압축기

>>> a = [1, 2, 3, 4, 5, 6]
>>> zip(*([iter(a)] * 2))
[(1, 2), (3, 4), (5, 6)]

>>> group_adjacent = 람다 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 = 람다 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]]
>>> 목록(itertools.chain.from_iterable(a))
[1, 2, 3, 4, 5, 6]

>>> 합계(a, [])
[1, 2, 3, 4, 5, 6]

>>> [l의 x에 대한 l의 x]
[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 = 람다 x: [y for l in x for y in flatten(l)] if type(x)가 list else [x]
>>> flatten(a)
[1, 2, 3, 4, 5, 6, 7, 8]

1.16 生成器表达式

>>> g = (xrange(10)의 x에 대한 x ** 2)
>>> 다음(g)
0
>>> 다음(g)
1
>>> 다음(g)
4
>>> 다음(g)
9
>>> sum(xrange(10)의 x에 대해 x ** 3)
2025
>>> sum(x ** 3 for x in xrange(10) if x % 3 == 1)
408

1.17 字典推导

> ;>> m = {x: x ** 범위 내 x의 경우 2(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 용자典推导反转字典

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

>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = 점(x=1.0, y=2.0)
>>> p
포인트(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 = 점(x=1.0, y=2.0)
>>> q = 점(x=2.0, y=3.0)
>>> p + q
점(x=3.0, y=5.0)

1.21 操work集合

>> > A = {1, 2, 3, 3}
>>> A
세트([1, 2, 3])
>>> B = {3, 4, 5, 6, 7}
>>> B
세트([3, 4, 5, 6, 7])
>>> A | B
세트([1, 2, 3, 4, 5, 6, 7])
>>> A & B
세트([3])
>>> A - B
세트([1, 2])
>>> B - A
세트([4, 5, 6, 7])
>>> A ^ B
세트([1, 2, 4, 5, 6, 7])
>>> (A ^ B) == ((A - B) | (B - A))
참

1.22 操work多重集合

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

1.23 统计在可迭代器中最常流现적원素

>>> A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7])
>>> A
카운터({3:4, 1:2, 2:2, 4:1, 5:1, 6:1, 7:1})
>>> A.가장 흔한(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_ three.append(i)
... PRint ', '.join(str(x) for x in last_3)
...
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) 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 默认词典

>>> m = dict()
>>> m['a']
추적(가장 최근 호출 마지막):
파일 "", 첫 번째 줄,
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: '[기본값]')
>>> m['a']
'[기본값]'
>>> m['b']
'[기본값]'

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

>>> json 가져오기
>>> tree = 람다: collections.defaultdict(tree)
>>> 루트 = 트리()
>>> root['menu']['id'] = '파일'
>>> root['menu']['value'] = '파일'
>>> root['menu']['menuitems']['new']['value'] = '새 항목'
>>> root['menu']['menuitems']['new']['onclick'] = 'new();'
>>> root['menu']['menuitems']['open']['value'] = '열기'
>>> root['menu']['menuitems']['open']['onclick'] = 'open();'
>>> root['menu']['menuitems']['close']['value'] = '닫기'
>>> root['menu']['menuitems']['close']['onclick'] = 'close();'
>>> print json.dumps(root, sort_keys=True, indent=4, 구분 기호=(',', ': '))
{
"menu": {
"id": "file",
"menuitems": {
"close": {
"onclick": "close();",
"value": "닫기"
},
"new ": {
"onclick": "새로 만들기();",
"value": "새로 만들기"
},
"open": {
"onclick": "열기( );",
"value": "열기"
}
},
"value": "파일"
}
}

1.29 对象到唯一计数的映射

>>> itertools, 컬렉션 가져오기
>>> 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 最大和最small几个列表元素

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

1.31 两个列表的笛卡尔积

>>> 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], 반복=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 列表组和列表元素替代组合

> >> 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 列表元素排列组

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

1.34 可链接迭代器

>>> a = [1, 2, 3, 4]
>>> for p in itertools.chain(itertools.combinations(a, 2), itertools.combinations(a, 3)):
... 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)
>>> itertools.chain.from_iterable의 하위 집합(itertools.combinations(a, n) for n in range(len(a) + 1))
... 인쇄 하위 집합
...
()
(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 根据文件指정列类聚

>>> itertool 가져오기
>>> open('contactlenses.csv', 'r')을 infile로 사용:
... data = [infile의 라인에 대한 line.strip().split(',')]
...
>>>> 데이터 = 데이터[1:]
>>> def print_data(rows):
... print 'n'.join('t'.join('{: <16}'.format(s) for s in row) for row in Row)
...

>>> print_data(data)
젊은 근시 아니오 감소 없음
젊은 근시    아니오 보통 부드러운
젊은 근시 예 감소    없음
어린 근시 예 보통 어린 하이퍼메트로프 아니오 보통 부드러운
젊은 하이퍼메트로프 예 감소됨 없음
젊은 하이퍼메트로프 예 정상 단단한
노안 전 근시 아니요 감소    없음
노안 전 근시 없음 정상 연성
노안 전 근시    예 감소 없음
노안 전 근시 예 정상 단단한
노안 전 과도 아니요    감소 없음
노안 전 초과대 아니요 정상 연성
노안 전 원시 원시 예 감소됨 없음
노안 전 예 정상    없음
노안 근시 아니요 감소 없음
노골 마이오프 정상 없음
노선 myope yes 감소 none
노선 myope 예 정상적인 단단 예 정상 없음

>>> data.sort(key=lambda r: r[-1])
>>> 값의 경우 itertools.groupby(data, Lambda r: r[-1]):
... print '------------'
... print 'Group : ' + 값
... print_data(그룹)
...
------------
그룹: 하드
젊은 myope 예 보통    힘들다
젊은 하이퍼메트로프 예 정상 단단한
노안 전 근시 예    정상 단단한
노안 근시 예 정상 단단함
------ --
그룹: 없음
젊은 myope no 감소됨 없음
젊음 근시 예 감소됨 없음
젊음 e 아니요 감소 없음
젊은 하이퍼메트로프 예 감소    없음
노안 전 없음 감소 없음
노안 전 근시    예 감소 없음
노안 전 원시 원시 아니요 감소 없음
노안 전 원시 예    감소됨 없음
노안 전 예 정상 없음
노안   근시 아니요 감소 없음
노안 근시 아니요    정상 없음
노안 근시 예 감소 없음
노안 원시근시 아니요 감소 없음
노안 고시 예 > -----------
그룹: 부드러운
젊은 근시 아니요 보통 부드러운
젊은 하이퍼메트로프 아니요 보통 부드러운
노안 전 근시 아니요 정상 연성
노안 전 고도 아니요    정상 연성
노안 과시 아니요 정상 연성

　　

以上就是30个个关Python의 작은 응용 프로그램은 더 많은 사진을 제공합니다. PHP中文网（m.sbmmt.com）!