Pythonの隠し機能[終了]

Pythonプログラミング言語のあまり知られていないが便利な機能は何ですか？

• Pythonコアへの回答を制限してください。
• 回答ごとに1つの機能。
• ドキュメントへのリンクだけでなく、機能の例と短い説明を提供します。
• タイトルを最初の行として使用して、フィーチャにラベルを付けます。

回答へのクイックリンク：

• 引数の解凍
• ブレース
• 比較演算子の連鎖
• デコレータ
• デフォルト引数の問題/変更可能なデフォルト引数の危険性
• 記述子
• 辞書のデフォルト.get値
• Docstringテスト
• 省略記号のスライス構文
• 列挙
• for / else
• iter（）引数として機能
• ジェネレータ式
• import this
• インプレースバリュースワッピング
• リストのステップ
• __missing__ アイテム
• 複数行の正規表現
• 名前付き文字列のフォーマット
• ネストされたリスト/ジェネレータの内包表記
• 実行時の新しいタイプ
• .pth ファイル
• ROT13エンコーディング
• 正規表現のデバッグ
• ジェネレーターに送る
• インタラクティブインタープリタのタブ補完
• 三元表現
• try/except/else
• Unpacking + 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、あまりタイピングとそれぞれに用語は一度だけ評価されます。

Python正規表現解析ツリーを取得して、正規表現をデバッグします。

正規表現はpythonの優れた機能ですが、それらをデバッグするのは面倒な場合があり、正規表現を間違えるのは簡単すぎます。

幸い、Pythonは、文書化されていない実験的な隠しフラグ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)

列挙する

イテレート可能オブジェクトをenumerateでラップすると、アイテムがインデックスとともに生成されます。

例えば：

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

参照：

• Pythonチュートリアル-ループ手法
• Pythonドキュメント—組み込み関数—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反転」の便利なイディオムです。

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

デコレータ

デコレーターを使用すると、機能やメソッドを別の関数にラップして、機能を追加したり、引数や結果を変更したりすることができます。

例は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」ブロックは、breakが呼び出されない限り、通常は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]}

また、ほとんど同じように機能しますが、既存の項目ではなく引数なしで関数を呼び出す、dictサブクラスがcollections呼び出されdefaultdictます。

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

そのようなサブクラスを期待しない関数に渡す前に、そのようなディクテーションを通常のディクテーションに変換することをお勧めします。多くのコードはd[a_key]、KeyErrorを使用およびキャッチして、新しいアイテムをdictに追加するアイテムが存在するかどうかを確認します。

インプレース値スワッピング

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

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

割り当ての右側は、新しいタプルを作成する式です。割り当ての左側は、その（参照されていない）タプルを名前aとに直ちにアンパックしbます。

割り当て後、新しいタプルは参照されず、ガベージコレクションのマークが付けられ、値がバインドされa、bスワップされます。

データ構造に関するPythonチュートリアルセクションで述べたように、

複数の割り当ては、実際にはタプルのパッキングとシーケンスのアンパッキングの組み合わせにすぎないことに注意してください。

読みやすい正規表現

Pythonでは、正規表現を複数の行に分割し、一致に名前を付け、コメントを挿入できます。

詳細な構文の例（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)

名前の一致の例（正規表現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})$"

関数引数の解凍

*およびを使用して、関数の引数としてリストまたは辞書をアンパックできます**。

例えば：

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)

リスト、タプル、辞書はコンテナとして広く使用されているため、非常に便利なショートカットです。

コードファイルの先頭で適切なコーディング宣言を使用する場合、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で導入でたコンテキストマネージャーは、一連のステートメントのランタイムコンテキストとして機能するオブジェクトです。

この機能は新しいキーワードを利用するため、段階的に導入されています。Python2.5では、 __future__。ディレクティブを。Python 2.6以降（Python 3を含む）では、デフォルトで使用可能です。

「with」ステートメントを使用しました非常に便利な構成だと思うのでます。簡単なデモをます。

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が返されます。2番目の引数を追加して、Noneの代わりにそのアイテムを取得できます。例：d.get（ 'key'、0）。

数字の加算などに最適です。

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

記述子

これらは、Pythonのコア機能全体の背後にある魔法です。

ドットアクセスを使用してメンバー（xyなど）を検索すると、Pythonは最初にインスタンスディクショナリでメンバーを検索します。見つからない場合は、クラスディクショナリで検索します。クラスディクショナリで見つかった場合、オブジェクトは記述子プロトコルを実装し、それを返すだけでなく、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)

組み込みのproperty（）と同じように使用します。

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

記述子はPythonで使用され、プロパティ、バインドされたメソッド、静的メソッド、クラスメソッド、スロットなどを実装します。それらを理解することで、以前はPythonの「癖」のように見えていた多くのものが現在の方法である理由が簡単にわかります。

Raymond Hettingerには、私よりもはるかに優れた説明を行う優れたチュートリアルがあります。

条件付き割り当て

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

これは、「yが1の場合はxに3を割り当て、それ以外の場合は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は2つのクラスです。

Doctest：ドキュメントと単体テストを同時に行います。

Pythonのドキュメントから抜粋した例：

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

名前付きフォーマット

％-formattingは辞書を使用します（％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（）も辞書であるため、ディクショナリとして単に渡すだけで、ローカル変数から％置換を取得できます。これは眉をひそめると思いますが、物事を簡素化します。

新しいスタイルのフォーマット

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

さらに多くのpythonモジュール（特にサードパーティのモジュール）を追加するには、ほとんどの人がPYTHONPATH環境変数を使用しているようです。または、サイトパッケージディレクトリにシンボリックリンクまたはディレクトリを追加しています。別の方法は、*。pthファイルを使用することです。公式のPythonドキュメントの説明は次のとおりです。

「[pythonの検索パスを変更する]最も便利な方法は、Pythonのパス上にあるディレクトリ、通常は... / site-packages /ディレクトリにパス構成ファイルを追加することです。パス構成ファイルの拡張子は.pthです。 、および各行にはsys.pathに追加される単一のパスが含まれている必要があります（新しいパスはsys.pathに追加されるため、追加されたディレクトリのモジュールは標準モジュールを上書きしません。つまり、このメカニズムを使用できません標準モジュールの固定バージョンをインストールします。）」

例外のelse句：

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

else ...句を使用すると、try ...句にコードが追加されていないため、try ... exceptステートメントで保護されているコードで発生しなかった例外を誤ってキャッチすることがなくなります。

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に指示し、「ああ、ごめん、ごめん、私はそれをキャッチするつもりはありませんでした、ごめん、ごめんなさい。 」

元のトレースバックを印刷、保存、またはいじる場合は、sys.exc_info（）を使用して取得できます。Pythonのように印刷するには、「traceback」モジュールを使用します。

主なメッセージ:)

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

暗号解読：

禅のPython、ティム・ピーターズ

醜いよりも美しい方がいいです。
明示的は暗黙的よりも優れています。
シンプルは複雑よりも優れています。
複雑は複雑よりも優れています。
ネストよりもフラットの方が適しています。
疎は密よりも優れています。
読みやすさが重要です。
特別なケースは、ルールを破るほど特別なものではありません。
実用性は純粋さを上回りますが。
エラーがサイレントに渡ることはありません。
明示的に沈黙させない限り。
あいまいな状況に直面して、推測する誘惑を拒否してください。それを行うには、明白な方法が1つ（できれば1つだけ）あるはずです。
あなたがオランダ人でない限り、その方法は最初は明白ではないかもしれませんが。
今は決してないよりはましです。
多くの場合、右今。
実装の説明が難しい場合は、悪い考えです。
実装が簡単に説明できる場合は、良いアイデアかもしれません。
名前空間は非常に魅力的なアイデアの1つです。もっと多くのことをしましょう。

インタラクティブな通訳タブの補完

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}

標準ライブラリリファレンスの詳細：セットタイプ