파이썬의 숨겨진 기능

파이썬 프로그래밍 언어의 덜 알려졌지만 유용한 기능은 무엇입니까?

• 파이썬 코어에 대한 답변을 제한하십시오.
• 답변 당 하나의 기능.
• 문서에 대한 링크가 아니라 기능에 대한 예와 간단한 설명을 제공하십시오.
• 제목을 첫 번째 줄로 사용하여 기능에 레이블을 지정하십시오.

답변에 대한 빠른 링크 :

• 인수 풀기
• 바지 멜빵
• 체인 비교 연산자
• 데코레이터
• 기본 인수의 단점 / 변경 가능한 기본 인수의 위험
• 설명자
• 사전 디폴트 .get값
• 독 스트링 테스트
• 줄임표 슬라이싱 구문
• 열거
• 기타
• iter () 인수로서의 함수
• 생성기 표현식
• import this
• 적절한 가치 교환
• 스테핑 목록
• __missing__ 아이템
• 여러 줄 정규식
• 명명 된 문자열 형식
• 중첩 된 목록 / 생성기 이해
• 런타임시 새로운 유형
• .pth 파일들
• ROT13 인코딩
• 정규식 디버깅
• 발전기로 보내기
• 대화 형 인터프리터에서 탭 완성
• 삼항식
• try/except/else
• 포장 풀기 + print()기능
• with 성명서

체이닝 비교 연산자 :

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

경우 당신이 그것을하고있어 생각 1 < x으로 나오고있는 True다음과 비교되지 True < 10도이다, True무슨 정말 아니다 그 다음 더, 정말로 번역하는 것 (. 마지막 예제 참조) 1 < x and x < 10, 그리고 x < 10 and 10 < x * 10 and x*10 < 100, 미만 입력하고 각각 용어는 한 번만 평가됩니다.

파이썬 정규식 구문 분석 트리를 가져 와서 정규식을 디버깅하십시오.

정규 표현식은 파이썬의 훌륭한 기능이지만, 디버깅은 어려울 수 있으며 정규 표현식을 잘못 사용하는 것은 너무 쉽습니다.

다행히도 파이썬은 문서화되지 않은 실험적인 숨겨진 플래그 re.DEBUG(실제로 128)를 로 전달하여 정규식 구문 분석 트리를 인쇄 할 수 있습니다 re.compile.

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

구문을 이해하면 오류를 발견 할 수 있습니다. 거기서 우리는 내가 탈출하는 것을 잊었다는 것을 알 수 있습니다 [].[/font] .

물론 주석이 달린 정규 표현식과 같이 원하는 플래그와 결합 할 수 있습니다.

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)

낱낱이 세다

iterable을 열거 형으로 감싸면 인덱스와 함께 항목이 생성됩니다.

예를 들면 다음과 같습니다.

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

참고 문헌 :

• 파이썬 튜토리얼 — 루핑 기법
• 파이썬 문서 (내장 함수)enumerate
• PEP 279

생성기 객체 생성

당신이 쓰는 경우

x=(n for n in foo if bar(n))

생성기를 꺼내 x에 할당 할 수 있습니다. 이제는 할 수 있음을 의미합니다

for n in x:

이것의 장점은 중간 저장소가 필요하지 않다는 것입니다.

x = [n for n in foo if bar(n)]

경우에 따라 속도가 크게 향상 될 수 있습니다.

생성기 끝에 많은 if 문을 추가하여 기본적으로 중첩 된 for 루프를 복제 할 수 있습니다.

>>> n = ((a,b) for a in range(0,2) for b in range(4,6))
>>> for i in n:
...   print i 

(0, 4)
(0, 5)
(1, 4)
(1, 5)

iter ()는 호출 가능한 인수를 취할 수 있습니다

예를 들어 :

def seek_next_line(f):
    for c in iter(lambda: f.read(1),'\n'):
        pass

이 iter(callable, until_value)함수 는 반환 callable될 때까지 반복적으로 호출 하고 결과를 산출합니다 until_value.

변경 가능한 기본 인수에주의하십시오

>>> def foo(x=[]):
...     x.append(1)
...     print x
... 
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

대신 "제공되지 않음"을 나타내는 센티넬 값을 사용하고 기본값으로 변경하려는 변수로 대체해야합니다.

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]

생성기 함수로 값 보내기 . 예를 들어이 기능이있는 경우 :

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

당신은 할 수 있습니다 :

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7

공백을 사용하여 범위를 표시하지 않으려면 다음을 실행하여 C 스타일 {}을 사용할 수 있습니다.

from __future__ import braces

슬라이스 연산자의 단계 인수. 예를 들면 다음과 같습니다.

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

특별한 경우 x[::-1]는 'x reversed'에 대한 유용한 관용구입니다.

>>> a[::-1]
[5,4,3,2,1]

데코레이터

데코레이터 사용하면 기능을 추가하고 인수 또는 결과 등을 수정할 수있는 다른 함수로 함수 또는 메소드를 래핑 할 수 있습니다. "at"기호 (@)로 시작하여 데코레이터를 함수 정의보다 한 줄 위에 작성합니다.

예는 print_args데코레이터를 호출하기 전에 데코 레이팅 된 함수의 인수를 인쇄 하는 데코레이터를 보여줍니다 .

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo

for ... else 구문 ( http://docs.python.org/ref/for.html 참조 )

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

"else"블록은 일반적으로 중단이 호출되지 않는 한 for 루프의 끝에서 실행됩니다.

위 코드는 다음과 같이 에뮬레이트 할 수 있습니다.

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

2.5 이후로 dicts에는 __missing__누락 된 항목에 대해 호출 되는 특수 메소드 가 있습니다.

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

collections호출 된 dict 하위 클래스도 defaultdict거의 동일하지만 기존 항목이 아닌 인수를 사용하지 않고 함수를 호출합니다.

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

이러한 dict을 정규 dict로 변환하여 그러한 서브 클래스를 기대하지 않는 함수로 전달하는 것이 좋습니다. 많은 코드 d[a_key]가 KeyErrors를 사용 하고 포착하여 dict에 새 항목을 추가하는 항목이 있는지 확인합니다.

전체 가치 교환

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

과제의 오른쪽은 새로운 튜플을 생성하는 표현식입니다. 과제의 좌측 바로 해당 이름 (참조되지 않은) 튜플을 언팩 a하고b 합니다.

할당 한 후, 새로운 튜플을 참조 해제하고 가비지 컬렉션 대상으로 표시하고 값에 바인딩 a및b 교환되었다.

데이터 구조 에 관한 파이썬 튜토리얼 섹션에서 언급했듯이 ,

다중 할당은 실제로 튜플 패킹과 시퀀스 언 패킹의 조합 일뿐입니다.

읽을 수있는 정규식

파이썬에서는 정규 표현식을 여러 줄로 나누고 일치하는 이름을 지정하고 주석을 삽입 할 수 있습니다.

자세한 구문 예제 ( Dive에서 Python으로 ) :

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

명명 일치 예 ( Regular Expression HOWTO )

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'

re.VERBOSE문자열 리터럴 연결 덕분에 정규 표현식을 자세하게 작성할 수도 있습니다 .

>>> pattern = (
...     "^"                 # beginning of string
...     "M{0,4}"            # thousands - 0 to 4 M's
...     "(CM|CD|D?C{0,3})"  # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                         #            or 500-800 (D, followed by 0 to 3 C's)
...     "(XC|XL|L?X{0,3})"  # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                         #        or 50-80 (L, followed by 0 to 3 X's)
...     "(IX|IV|V?I{0,3})"  # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                         #        or 5-8 (V, followed by 0 to 3 I's)
...     "$"                 # end of string
... )
>>> print pattern
"^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$"

함수 인자 풀기

*and를 사용하여 목록 또는 사전을 함수 인수로 압축 해제 할 수 있습니다 **.

예를 들면 다음과 같습니다.

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

목록, 튜플 및 dicts가 컨테이너로 널리 사용되므로 매우 유용한 바로 가기입니다.

ROT13은 코드 파일 맨 위에서 올바른 코딩 선언을 사용할 때 소스 코드에 유효한 인코딩입니다.

#!/usr/bin/env python
# -*- coding: rot13 -*-

cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")

완전히 역동적 인 방식으로 새로운 유형 만들기

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

정확히 같은

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

아마도 가장 유용한 것은 아니지만 알아두면 좋을 것입니다.

편집 : 새로운 유형의 고정 이름 NewType은와 정확히 동일해야합니다.class 명령문 합니다.

편집 : 기능을보다 정확하게 설명하기 위해 제목을 조정했습니다.

컨텍스트 관리자 및 " with"문

에 도입 PEP (343) 하는 컨텍스트 매니저는 문 제품군에 대한 런타임 컨텍스트 역할을하는 객체입니다.

이 기능은 새로운 키워드를 사용하므로 점진적으로 도입됩니다. __future__지시문을 통해 Python 2.5에서 사용할 수 있습니다 . Python 2.6 이상 (Python 3 포함)에는 기본적으로 사용 가능합니다.

내가 사용하고 문 "과" 내가 여기에, 매우 유용한 구조의 빠른 데모입니다 생각하기 때문에 많은 :

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

여기서 뒤에서 일어나는 일은 "with"문 이 파일 객체 의 특수 __enter__및 __exit__메소드를 호출한다는 것입니다. __exit__with 문에서 예외가 발생하면 예외 세부 사항도 전달되어 예외 처리가 가능합니다.

이 특별한 경우에 당신을 위해하는 일은 with정상적으로 발생하는지 또는 예외가 발생했는지 여부에 관계없이 실행이 제품군 범위를 벗어날 때 파일이 닫히도록 보장한다는 것입니다 . 기본적으로 일반적인 예외 처리 코드를 추상화하는 방법입니다.

이것에 대한 다른 일반적인 사용 사례에는 스레드 및 데이터베이스 트랜잭션 잠금이 포함됩니다.

사전에는 get () 메소드가 있습니다.

사전에는 'get ()'메소드가 있습니다. d [ 'key']를하고 key가 없으면 예외가 발생합니다. d.get ( 'key')를 수행하면 'key'가 없으면 None을 반환합니다. 두 번째 인수를 추가하여 None 대신 해당 항목을 다시 가져올 수 있습니다 (예 : d.get ( 'key', 0)).

숫자 추가와 같은 일에 좋습니다.

sum[value] = sum.get(value, 0) + 1

설명자

그것들은 모든 핵심 파이썬 기능의 마술입니다.

점으로 구분 된 액세스를 사용하여 멤버 (예 : xy)를 조회하면 Python은 먼저 인스턴스 사전에서 멤버를 찾습니다. 찾을 수 없으면 클래스 사전에서 찾습니다. 클래스 사전에서 그것을 발견하고 객체가 설명자 프로토콜을 구현하는 대신 반환하지 않고 파이썬이 실행합니다. 디스크립터가 구현하는 모든 클래스 __get__, __set__또는 __delete__방법.

디스크립터를 사용하여 고유 한 (읽기 전용) 버전의 속성을 구현하는 방법은 다음과 같습니다.

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

내장 속성 ()과 같이 사용합니다.

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

설명자는 Python에서 속성, 바인딩 된 메서드, 정적 메서드, 클래스 메서드 및 슬롯 등을 구현하는 데 사용됩니다. 그것들을 이해하면 이전에 파이썬 '질투'처럼 보이는 많은 것들이 왜 그런지 쉽게 알 수 있습니다.

Raymond Hettinger는 저보다 더 잘 설명 하는 훌륭한 자습서를 제공 합니다.

조건부 할당

x = 3 if (y == 1) else 2

"y가 1이면 3을 x에 할당하고, 그렇지 않으면 2를 x에 할당"과 같은 소리를냅니다. 파렌은 필요하지 않지만 가독성을 좋아합니다. 더 복잡한 것이 있으면 체인을 연결할 수도 있습니다.

x = 3 if (y == 1) else 2 if (y == -1) else 1

특정 시점에 있지만 너무 멀리갑니다.

if ... else를 어떤 식으로도 사용할 수 있습니다. 예를 들면 다음과 같습니다.

(func1 if y == 1 else func2)(arg1, arg2) 

여기서 y가 1이면 func1이 호출되고 그렇지 않으면 func2가 호출됩니다. 두 경우 모두 해당 함수는 인수 arg1 및 arg2와 함께 호출됩니다.

마찬가지로 다음 사항도 유효합니다.

x = (class1 if y == 1 else class2)(arg1, arg2)

여기서 class1과 class2는 두 개의 클래스입니다.

Doctest : 문서화와 단위 테스트를 동시에 수행합니다.

파이썬 문서에서 추출한 예 :

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()

명명 된 서식

%-포맷팅은 사전을 취합니다 (% i / % s 등의 유효성 검사도 적용됨).

>>> print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

>>> foo, bar = 'question', 123

>>> print "The %(foo)s is %(bar)i." % locals()
The question is 123.

그리고 locals () 또한 사전이기 때문에이를 dict로 전달하고 지역 변수에서 % -substitions를 가질 수 있습니다. 나는 이것이 눈살을 찌푸리게 생각하지만 일을 단순화합니다 ..

새로운 스타일 형식

>>> print("The {foo} is {bar}".format(foo='answer', bar=42))

더 많은 파이썬 모듈 (특히 타사 모듈)을 추가하기 위해 대부분의 사람들은 PYTHONPATH 환경 변수를 사용하거나 사이트 패키지 디렉토리에 심볼릭 링크 또는 디렉토리를 추가합니다. 다른 방법은 * .pth 파일을 사용하는 것입니다. 공식 파이썬 문서의 설명은 다음과 같습니다.

"python의 검색 경로를 수정하는 가장 편리한 방법은 경로 구성 파일을 이미 Python 경로에있는 디렉토리, 일반적으로 ... / site-packages / 디렉토리에 추가하는 것입니다. 경로 구성 파일의 확장자는 .pth입니다. , 각 행에는 sys.path에 추가 될 단일 경로가 포함되어야합니다. (새 경로는 sys.path에 추가되므로 추가 된 디렉토리의 모듈은 표준 모듈을 무시하지 않습니다. 따라서이 메커니즘을 사용할 수 없습니다. 표준 모듈의 고정 버전을 설치하는 데 사용됩니다.) "

예외 다른 절 :

try:
  put_4000000000_volts_through_it(parrot)
except Voom:
  print "'E's pining!"
else:
  print "This parrot is no more!"
finally:
  end_sketch()

try ... except 문으로 보호되는 코드에 의해 발생하지 않은 예외를 실수로 포착하지 않기 때문에 else 절을 ​​사용하는 것이 try 절에 추가 코드를 추가하는 것보다 낫습니다.

http://docs.python.org/tut/node10.html을 참조 하십시오

재발급 예외 :

# Python 2 syntax
try:
    some_operation()
except SomeError, e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

# Python 3 syntax
try:
    some_operation()
except SomeError as e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

오류 처리기 내에 인수가없는 'raise'문은 Python에 원래의 역 추적 intact로 예외를 다시 발생 시키도록 지시 합니다. "

원래 트레이스 백으로 인쇄, 저장 또는 피들 링하려면 sys.exc_info ()로 가져 와서 파이썬처럼 인쇄하는 것은 'traceback'모듈로 수행됩니다.

주요 메시지 :)

import this
# btw look at this module's source :)

암호 해독 :

Tim Peters의 Python Zen

못생긴 것보다 아름답습니다.
암시적인 것보다 명시적인 것이 좋습니다.
단순보다 복잡합니다.
복잡한 것이 복잡한 것보다 낫습니다.
평평한 것이 중첩보다 낫습니다.
스파 스가 밀도보다 낫습니다.
가독성이 중요합니다.
특별한 경우는 규칙을 어길만큼 특별하지 않습니다.
실용성은 순도를 능가하지만.
오류가 자동으로 전달되지 않아야합니다.
명시 적으로 침묵하지 않는 한.
모호함에 직면하여 추측하려는 유혹을 거부하십시오. 그것을하는 명백한 방법이 있어야합니다.
네덜란드 인이 아니라면 처음에는 그 방법이 명확하지 않을 수 있습니다.
지금보다 결코 낫습니다.
결코 결코 낫지 않지만바로 지금
구현이 설명하기 어렵다면 나쁜 생각입니다.
구현이 설명하기 쉬운 경우 좋은 생각 일 수 있습니다.
네임 스페이스는 훌륭한 아이디어 중 하나입니다. 더 많은 것을 해보자!

대화식 통역사 탭 완성

try:
    import readline
except ImportError:
    print "Unable to load readline module."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")


>>> class myclass:
...    def function(self):
...       print "my function"
... 
>>> class_instance = myclass()
>>> class_instance.<TAB>
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.f<TAB>unction()

PYTHONSTARTUP 환경 변수도 설정해야합니다.

중첩 된 목록 이해 및 생성기 표현식 :

[(i,j) for i in range(3) for j in range(i) ]    
((i,j) for i in range(4) for j in range(i) )

이것들은 큰 덩어리의 중첩 루프 코드를 대체 할 수 있습니다.

set내장에 대한 연산자 과부하 :

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

표준 라이브러리 참조에서 자세한 내용 : 유형 설정