python - Python の隠れた機能

Question

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

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

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

score 740 · Accepted Answer

比較演算子の連鎖:

>>> 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です、それからいいえ、それは実際には何が起こるかではありません (最後の例を参照してください) 。 term は一度だけ評価されます。1 < x and x < 10x < 10 and 10 < x * 10 and x*10 < 100

score 512 · Accepted Answer

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

構文を理解すると、エラーを見つけることができます。[]inをエスケープするのを忘れていたことがわかります[/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)

score 460 · Accepted Answer

列挙する

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

参照：

score 419 · Accepted Answer

ジェネレーターオブジェクトの作成

あなたが書くなら

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

ジェネレーターを取り出して x に割り当てることができます。今、それはあなたができることを意味します

for n in x:

これの利点は、中間ストレージが必要ないことです。

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

場合によっては、これにより大幅な高速化が可能になります。

基本的にネストされた for ループを複製して、多くの if ステートメントをジェネレーターの最後に追加できます。

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

score 353 · Accepted Answer

iter（）は呼び出し可能な引数を取ることができます

例えば：

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

iter(callable, until_value)関数は繰り返し呼び出し、が返さcallableれるまでその結果を生成しuntil_valueます。

score 339 · Accepted Answer

変更可能なデフォルト引数に注意してください

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

score 317 · Accepted Answer

値をジェネレーター関数に送信します。たとえば、次の機能があります。

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

score 312 · Accepted Answer

スコープを示すために空白を使用したくない場合は、次のように発行して C スタイルの {} を使用できます。

from __future__ import braces

score 305 · Accepted Answer

スライス演算子のステップ引数。例えば：

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]

score 289 · Accepted Answer

デコレータ

デコレーターを使用すると、機能を追加したり、引数や結果を変更したりできる別の関数で関数またはメソッドをラップできます。デコレーターは、「アット」記号 (@) で始まる関数定義の 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

score 288 · Accepted Answer

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

score 258 · Accepted Answer

2.5 以降の辞書には、__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。defaultdict

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

そのようなサブクラスを予期しない関数に渡す前に、そのような辞書を通常の辞書に変換することをお勧めします。多くのコードd[a_key]が KeyErrors を使用してキャッチし、辞書に新しい項目を追加する項目が存在するかどうかを確認します。

score 247 · Accepted Answer

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

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

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

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

代入後、新しいタプルは参照されず、ガベージコレクションの対象としてマークされ、値がバインドさaれbてスワップされます。

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

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

score 235 · Accepted Answer

読み取り可能な正規表現

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})$"

score 222 · Accepted Answer

関数の引数のアンパック

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

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

score 183 · Accepted Answer

完全に動的な方法で新しいタイプを作成する

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

これはまったく同じです

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

おそらく最も有用なことではありませんが、知っておくと便利です。

編集：新しいタイプの固定名。ステートメントNewTypeとまったく同じものにする必要があります。class

編集：機能をより正確に説明するようにタイトルを調整しました。

score 179 · Accepted Answer

コンテキストマネージャーと" 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」ステートメントがファイルオブジェクトのspecialメソッド__enter__とメソッドを呼び出すことです。withステートメント本体から例外が発生した場合__exit__にも例外の詳細が渡され、そこで例外処理を実行できるようになります。__exit__

この特定のケースでこれが行うことは、実行がwithスイートのスコープ外になったときに、それが正常に発生したかどうか、または例外がスローされたかどうかに関係なく、ファイルが閉じられることを保証することです。これは基本的に、一般的な例外処理コードを抽象化する方法です。

これの他の一般的な使用例には、スレッドとデータベーストランザクションによるロックが含まれます。

score 168 · Accepted Answer

辞書にはget（）メソッドがあります

辞書には「get（）」メソッドがあります。d ['key']を実行し、keyが存在しない場合、例外が発生します。d.get（'key'）を実行すると、'key'が存在しない場合はNoneに戻ります。Noneの代わりにそのアイテムを取り戻すために2番目の引数を追加できます（例：d.get（'key'、0））。

数字を足し合わせるなどに最適です。

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

score 152 · Accepted Answer

記述子

それらは、多数のコア 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 は優れたチュートリアルを持っており、私よりもはるかに優れた説明を行っています。

score 142 · Accepted Answer

条件付き代入

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

「y が 1 の場合は x に 3 を割り当て、それ以外の場合は x に 2 を割り当てます」というように、まさにそのように動作します。かっこは必須ではありませんが、読みやすくするために好きです。より複雑なものがある場合は、チェーンすることもできます。

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 つのクラスです。

score 141 · Accepted Answer

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

score 138 · Accepted Answer

名前付き書式

% -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() も辞書であるため、それを dict として渡すだけで、ローカル変数から % 置換を行うことができます。これは眉をひそめていると思いますが、物事を単純化します..

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

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

score 132 · Accepted Answer

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

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

score 122 · Accepted Answer

例外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を参照してください

score 114 · Accepted Answer

例外の再発生:

# 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」モジュールを使用します。

score 106 · Accepted Answer

メインメッセージ:)

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

解読済み:

Python の禅、Tim Peters 著

美しいことは醜いことよりも優れています。
明示的は暗黙的よりも優れています。
シンプルは複雑よりも優れています。
複雑は複雑よりも優れています。
フラットはネストよりも優れています。
疎は密よりも優れています。
読みやすさが重要です。
特別なケースは、ルールを破るほど特別なものではありません。
実用性は純粋さに勝りますが。
エラーは黙って通過するべきではありません。
明示的に黙らせない限り。
あいまいさに直面しても、推測する誘惑を断ってください。それを行う明白な方法が 1 つ (できれば 1 つだけ) ある必要があります。
あなたがオランダ人でない限り、その方法は最初は明白ではないかもしれませんが.
今は決してないよりはましです。
決してより良いことはありませんが今すぐ。
実装を説明するのが難しい場合、それは悪い考えです。
実装が説明しやすい場合は、良い考えかもしれません。
名前空間は素晴らしいアイデアの 1 つです。もっと多くのことをしましょう!

score 105 · Accepted Answer

インタラクティブインタープリタータブ補完

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 環境変数も設定する必要があります。

score 91 · Accepted Answer

ネストされたリスト内包表記とジェネレータ式：

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

これらは、ネストされたループコードの巨大なチャンクを置き換えることができます。

score 91 · Accepted Answer

ビルトインの演算子のオーバーロード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}

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

score 85 · Accepted Answer

マイナスラウンド

このround()関数は、浮動小数点数を 10 進数で指定された精度に丸めますが、精度は負になる場合があります。

>>> str(round(1234.5678, -2))
'1200.0'
>>> str(round(1234.5678, 2))
'1234.57'

注: round()上記の例では常に float を返します。これstr()は、浮動小数点演算が不正確であるためです。2.x では、2 番目の例は1234.5700000000001. decimalモジュールも参照してください。

score 81 · Accepted Answer

ブール値の乗算

Web 開発で常に行っていることの 1 つは、オプションで HTML パラメーターを出力することです。私たちは皆、他の言語で次のようなコードを見てきました:

class='<% isSelected ? "selected" : "" %>'

Python では、ブール値を掛けることができ、期待どおりの結果が得られます。

class='<% "selected" * isSelected %>'

これは、乗算がブール値を整数 (False の場合は 0、True の場合は 1) に変換し、Python で文字列を int で乗算すると、文字列が N 回繰り返されるためです。

score 74 · Accepted Answer

Python の高度なスライス操作には、ほとんど知られていない構文要素である省略記号があります。

>>> class C(object):
...  def __getitem__(self, item):
...   return item
... 
>>> C()[1:2, ..., 3]
(slice(1, 2, None), Ellipsis, 3)

残念ながら、省略記号はタプルが含まれている場合にのみサポートされるため、ほとんど役に立ちません。

score 70 · Accepted Answer

Python 3でのタプルアンパック

Python 3 では、タプルのアンパックの関数定義でオプションの引数と同じ構文を使用できます。

>>> first,second,*rest = (1,2,3,4,5,6,7,8)
>>> first
1
>>> second
2
>>> rest
[3, 4, 5, 6, 7, 8]

しかし、あまり知られていないがより強力な機能により、リストの途中に不明な数の要素を含めることができます。

>>> first,*rest,last = (1,2,3,4,5,6,7,8)
>>> first
1
>>> rest
[2, 3, 4, 5, 6, 7]
>>> last
8

score 67 · Accepted Answer

複数行の文字列

1 つの方法は、バックスラッシュを使用することです。

>>> sql = "select * from some_table \
where id > 10"
>>> print sql
select * from some_table where id > 10

別の方法は、三重引用符を使用することです。

>>> sql = """select * from some_table 
where id > 10"""
>>> print sql
select * from some_table where id > 10

それらの問題は、それらがインデントされていないことです (コードが見栄えが悪い)。インデントしようとすると、配置した空白が印刷されます。

最近見つけた 3 番目の解決策は、文字列を行に分割し、括弧で囲むことです。

>>> sql = ("select * from some_table " # <-- no comma, whitespace at end
           "where id > 10 "
           "order by name") 
>>> print sql
select * from some_table where id > 10 order by name

行間にコンマがないことに注意してください (これはタプルではありません)。文字列に必要な末尾/先頭の空白を考慮する必要があります。ちなみに、これらはすべてプレースホルダーで機能します（など"my name is %s" % name）。

score 63 · Accepted Answer

63

多くの人からの要望に応じて、この回答は質問自体に移されました。

于 2010-07-16T19:18:42.487 に答える

score 59 · Accepted Answer

アンダースコアには、インタプリタによって（対話型セッションで）表示される最新の出力値が含まれます。

>>>（xrange（10000）内のaの場合）
<0x81a8fccのジェネレータオブジェクト>
>>> b='何とか'
>>> _
<0x81a8fccのジェネレータオブジェクト>

便利なWebブラウザコントローラ：

>>>ウェブブラウザをインポートする
>>> webbrowser.open_new_tab（'http://www.stackoverflow.com'）

組み込みのhttpサーバー。現在のディレクトリ内のファイルを提供するには：

python -m SimpleHTTPServer 8000

AtExit

>>>インポートatexit

score 56 · Accepted Answer

pow() は (x ** y) % z も効率的に計算できます。

組み込み関数のあまり知られていない 3 番目の引数があり、単純にを実行するよりも効率的に x ^ypow() modulo zを計算できます。(x ** y) % z

>>> x, y, z = 1234567890, 2345678901, 17
>>> pow(x, y, z)            # almost instantaneous
6

比較すると、(x ** y) % z私のマシンでは同じ値に対して 1 分間で結果が得られませんでした。

score 52 · Accepted Answer

異なる開始インデックスで列挙する

enumerateこの回答で部分的にカバーされていますが、最近enumerate、単なるコメントではなく、独自の投稿に値すると思われるさらに隠された機能を見つけました。

enumeratePython 2.6 以降、2 番目の引数で開始インデックスを指定できます。

>>> l = ["spam", "ham", "eggs"]
>>> list(enumerate(l))
>>> [(0, "spam"), (1, "ham"), (2, "eggs")]
>>> list(enumerate(l, 1))
>>> [(1, "spam"), (2, "ham"), (3, "eggs")]

対称行列のエントリを列挙しているときは、これが非常に役立つことがわかった場所の 1 つです。行列は対称であるため、上の三角形のみを反復することで時間を節約できますが、その場合、行と列のインデックスを適切に追跡するためenumerateに、内側のループで別の開始インデックスを使用する必要があります。for

for ri, row in enumerate(matrix):
    for ci, column in enumerate(matrix[ri:], ri):
        # ci now refers to the proper column index

不思議なことに、のこの動作enumerateはでは文書化されておらず、オンラインドキュメントhelp(enumerate)でのみ文書化されています。

score 52 · Accepted Answer

zip を使用して配列を簡単に転置できます。

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

score 50 · Accepted Answer

プロパティを使用して、クラスインターフェイスをより厳密にすることができます。

class C(object):
    def __init__(self, foo, bar):
        self.foo = foo # read-write property
        self.bar = bar # simple attribute

    def _set_foo(self, value):
        self._foo = value

    def _get_foo(self):
        return self._foo

    def _del_foo(self):
        del self._foo

    # any of fget, fset, fdel and doc are optional,
    # so you can make a write-only and/or delete-only property.
    foo = property(fget = _get_foo, fset = _set_foo,
                   fdel = _del_foo, doc = 'Hello, I am foo!')

class D(C):
    def _get_foo(self):
        return self._foo * 2

    def _set_foo(self, value):
        self._foo = value / 2

    foo = property(fget = _get_foo, fset = _set_foo,
                   fdel = C.foo.fdel, doc = C.foo.__doc__)

Python 2.6 および 3.0 の場合:

class C(object):
    def __init__(self, foo, bar):
        self.foo = foo # read-write property
        self.bar = bar # simple attribute

    @property
    def foo(self):
        '''Hello, I am foo!'''

        return self._foo

    @foo.setter
    def foo(self, value):
        self._foo = value

    @foo.deleter
    def foo(self):
        del self._foo

class D(C):
    @C.foo.getter
    def foo(self):
        return self._foo * 2

    @foo.setter
    def foo(self, value):
        self._foo = value / 2

プロパティの仕組みの詳細については、記述子を参照してください。

score 48 · Accepted Answer

多くの人は「dir」機能について知りません。オブジェクトがインタプリタから何ができるかを理解するのに最適な方法です。たとえば、すべての文字列メソッドのリストを表示する場合:

>>> dir("foo")
['__add__', '__class__', '__contains__', (snipped a bunch), 'title',
 'translate', 'upper', 'zfill']

そして、特定のメソッドに関する詳細情報が必要な場合は、「ヘルプ」を呼び出すことができます。

>>> help("foo".upper)
    Help on built-in function upper:

upper(...)
    S.upper() -> string

    Return a copy of the string S converted to uppercase.

score 47 · Accepted Answer

セット/冷凍セット

おそらく見過ごされがちな python ビルトインは「set/frozenset」です。

[1,2,1,1,2,3,4] のようなリストがあり、[1,2,3,4] のような一意のものだけが必要な場合に便利です。

set() を使用すると、まさにそれが得られます。

>>> x = [1,2,1,1,2,3,4] 
>>> 
>>> set(x) 
set([1, 2, 3, 4]) 
>>>
>>> for i in set(x):
...     print i
...
1
2
3
4

そしてもちろん、リスト内の一意の数を取得するには:

>>> len(set([1,2,1,1,2,3,4]))
4

set().issubset() を使用して、リストが別のリストのサブセットであるかどうかを確認することもできます。

>>> set([1,2,3,4]).issubset([0,1,2,3,4,5])
True

Python 2.7 および 3.0 では、中括弧を使用してセットを作成できます。

myset = {1,2,3,4}

内包表記と同様に:

{x for x in stuff}

詳細: http://docs.python.org/library/stdtypes.html#set

score 46 · Accepted Answer

組み込みの base64、zlib、および rot13 コーデック

文字列にはメソッドがencodeありdecodeます。通常、これはとの間の変換strに使用されます。しかし、他にも便利な組み込みコーデックがいくつかあります。zlib (および bz2) を使用した圧縮と解凍は、明示的なインポートなしで利用できます。unicodeu = s.encode('utf8')

>>> s = 'a' * 100
>>> s.encode('zlib')
'x\x9cKL\xa4=\x00\x00zG%\xe5'

同様に、base64 をエンコードおよびデコードできます。

>>> 'Hello world'.encode('base64')
'SGVsbG8gd29ybGQ=\n'
>>> 'SGVsbG8gd29ybGQ=\n'.decode('base64')
'Hello world'

もちろん、rot13 もできます:

>>> 'Secret message'.encode('rot13')
'Frperg zrffntr'

score 43 · Accepted Answer

通訳者の中の通訳者

標準ライブラリのコードモジュールを使用すると、プログラム内に独自の read-eval-print ループを含めたり、ネストされたインタープリター全体を実行したりできます。例（ここから私の例をコピーしました）

$ python
Python 2.5.1 (r251:54863, Jan 17 2008, 19:35:17) 
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> shared_var = "Set in main console"
>>> import code
>>> ic = code.InteractiveConsole({ 'shared_var': shared_var })
>>> try:
...     ic.interact("My custom console banner!")
... except SystemExit, e:
...     print "Got SystemExit!"
... 
My custom console banner!
>>> shared_var
'Set in main console'
>>> shared_var = "Set in sub-console"
>>> import sys
>>> sys.exit()
Got SystemExit!
>>> shared_var
'Set in main console'

これは、ユーザーからのスクリプト入力を受け入れたい場合や、VM の状態をリアルタイムで照会したい場合に非常に役立ちます。

TurboGearsは、ライブ Web アプリの状態を照会できる WebConsole を用意することで、これを非常に効果的に使用しています。

score 40 · Accepted Answer

>>> from functools import partial
>>> bound_func = partial(range, 0, 10)
>>> bound_func()
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> bound_func(2)
[0, 2, 4, 6, 8]

実際には隠された機能ではありませんが、partial は関数の評価を遅らせるのに非常に役立ちます。

必要に応じて、最初の呼び出しで必要な数のパラメーターをパーシャルにバインドし、後で残りのパラメーターを使用して呼び出すことができます (この例では、開始/終了引数を範囲にバインドしましたが、2 回目に呼び出すにはステップ引数)

ドキュメントを参照してください。

score 36 · Accepted Answer

複雑なデータ構造をデバッグするときは、pprintモジュールが便利です。

ドキュメントからの引用..

>>> import pprint    
>>> stuff = sys.path[:]
>>> stuff.insert(0, stuff)
>>> pprint.pprint(stuff)
[<Recursion on list with id=869440>,
 '',
 '/usr/local/lib/python1.5',
 '/usr/local/lib/python1.5/test',
 '/usr/local/lib/python1.5/sunos5',
 '/usr/local/lib/python1.5/sharedmodules',
 '/usr/local/lib/python1.5/tkinter']

score 34 · Accepted Answer

PythonにはGOTOがあります

...そしてそれは外部の純粋なPythonモジュールによって実装されています:)

from goto import goto, label
for i in range(1, 10):
    for j in range(1, 20):
        for k in range(1, 30):
            print i, j, k
            if k == 3:
                goto .end # breaking out from a deeply nested loop
label .end
print "Finished"

score 32 · Accepted Answer

dict のコンストラクターは、キーワード引数を受け入れます。

>>> dict(foo=1, bar=2)
{'foo': 1, 'bar': 2}

score 29 · Accepted Answer

シーケンス乗算と反映されたオペランド

>>> 'xyz' * 3
'xyzxyzxyz'

>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]

>>> (1, 2) * 3
(1, 2, 1, 2, 1, 2)

反映された (交換された) オペランドでも同じ結果が得られます

>>> 3 * 'xyz'
'xyzxyzxyz'

それはこのように動作します：

>>> s = 'xyz'
>>> num = 3

式s * numを評価するには、インタプリタはs.___mul___(num)を呼び出します

>>> s * num
'xyzxyzxyz'

>>> s.__mul__(num)
'xyzxyzxyz'

式num * sを評価するには、インタプリタはnum.___mul___(s)を呼び出します

>>> num * s
'xyzxyzxyz'

>>> num.__mul__(s)
NotImplemented

呼び出しがNotImplementedを返す場合、オペランドの型が異なる場合、インタープリターは反映された操作s.___rmul___(num)を呼び出します

>>> s.__rmul__(num)
'xyzxyzxyz'

http://docs.python.org/reference/datamodel.html#objectを参照してください。rmul

score 28 · Accepted Answer

インターリーブifとforリスト内包表記

>>> [(x, y) for x in range(4) if x % 2 == 1 for y in range(4)]
[(1, 0), (1, 1), (1, 2), (1, 3), (3, 0), (3, 1), (3, 2), (3, 3)]

Haskellを学ぶまで、私はこれに気づきませんでした。

score 28 · Accepted Answer

モジュール演算子のゲッター関数

関数attrgetter()とitemgetter()in モジュールoperatorを使用して、オブジェクトと辞書の並べ替えと検索に使用する高速アクセス関数を生成できます。

Python Library Docs の第 6.7 章

score 27 · Accepted Answer

27

明らかに、反重力モジュール。 xkcd＃353

于 2008-09-29T10:36:12.670 に答える

score 27 · Accepted Answer

タプルのアンパック:

>>> (a, (b, c), d) = [(1, 2), (3, 4), (5, 6)]
>>> a
(1, 2)
>>> b
3
>>> c, d
(4, (5, 6))

もっとあいまいなことに、関数の引数でこれを行うことができます (Python 2.x では; Python 3.x ではこれはもう許可されません):

>>> def addpoints((x1, y1), (x2, y2)):
...     return (x1+x2, y1+y2)
>>> addpoints((5, 0), (3, 5))
(8, 5)

score 26 · Accepted Answer

Pythonインタープリター

>>>

あまり知られていないかもしれませんが、確かにPythonの私のお気に入りの機能の1つです。

score 25 · Accepted Answer

構築中のリスト内包表記を参照しています...

記号「_[1]」によって作成されているリスト内包表記を参照できます。たとえば、次の関数は、リスト内包表記を参照することにより、順序を変更せずに要素のリストを一意にします。

def unique(my_list):
    return [x for x in my_list if x not in locals()['_[1]']]

score 25 · Accepted Answer

Pythonの並べ替え関数は、タプルを正しく並べ替えます（つまり、使い慣れた辞書式順序を使用します）。

a = [(2, "b"), (1, "a"), (2, "a"), (3, "c")]
print sorted(a)
#[(1, 'a'), (2, 'a'), (2, 'b'), (3, 'c')]

年齢と名前の後に人のリストを並べ替える場合に便利です。

score 25 · Accepted Answer

の単純さ:

>>> 'str' in 'string'
True
>>> 'no' in 'yes'
False
>>>

私はPythonが大好きです。代わりに、あまりpythonicではないイディオムをたくさん見てきました。

if 'yes'.find("no") == -1:
    pass

score 24 · Accepted Answer

24

メタクラス

もちろん :-) Python のメタクラスとは何ですか?

于 2008-09-19T11:55:12.420 に答える

score 24 · Accepted Answer

私は個人的に3つの異なる引用が大好きです

str = "I'm a string 'but still I can use quotes' inside myself!"
str = """ For some messy multi line strings.
Such as
<html>
<head> ... </head>"""

また、クール: 正規表現をエスケープする必要がなく、生の文字列を使用することで恐ろしいバックスラッシュサラダを回避できます。

str2 = r"\n" 
print str2
>> \n

score 23 · Accepted Answer

発電機

初心者の Python 開発者の多くは、ジェネレーターが何のためにあるのか、その力をまったく理解せずに、ジェネレーターを見過ごしていると思います。ジェネレーターに関する David M. Beazley の PyCon プレゼンテーション (ここから入手できます) を読んで初めて、ジェネレーターがどれほど有用であるか (非常に重要であるか) に気づきました。そのプレゼンテーションは、私にとってまったく新しいプログラミング方法であることに光を当てました。ジェネレーターについて深く理解していない人には、このプレゼンテーションをお勧めします。

score 22 · Accepted Answer

ゼロ引数と可変引数のラムダ

Lambda 関数は通常、ある値を別の値にすばやく変換するために使用されますが、値を関数にラップするためにも使用できます。

>>> f = lambda: 'foo'
>>> f()
'foo'

通常の*argsand**kwargs構文も使用できます。

>>> g = lambda *args, **kwargs: args[0], kwargs['thing']
>>> g(1, 2, 3, thing='stuff')
(1, 'stuff')

score 22 · Accepted Answer

暗黙の連結:

>>> print "Hello " "World"
Hello World

長いテキストをスクリプトの複数の行に収めたい場合に便利です:

hello = "Greaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Hello " \
        "Word"

また

hello = ("Greaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Hello " 
         "Word")

score 22 · Accepted Answer

インタラクティブシェルを使用する場合、「_」には最後に出力されたアイテムの値が含まれます。

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> _
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

score 22 · Accepted Answer

Pythonのtextwrap.dedentユーティリティ関数は、ユニットテストのインデントを壊さずに、返された複数行の文字列が期待される出力と等しいことをテストするのに非常に便利です。

import unittest, textwrap

class XMLTests(unittest.TestCase):
    def test_returned_xml_value(self):
        returned_xml = call_to_function_that_returns_xml()
        expected_value = textwrap.dedent("""\
        <?xml version="1.0" encoding="utf-8"?>
        <root_node>
            <my_node>my_content</my_node>
        </root_node>
        """)

        self.assertEqual(expected_value, returned_xml)

score 21 · Accepted Answer

代入としてのキーワード引数の使用

1 つまたは複数のパラメーターに応じて、さまざまな関数を作成したい場合があります。ただし、これにより、すべてが同じオブジェクトと値を参照するクロージャーが簡単に発生する可能性があります。

funcs = [] 
for k in range(10):
     funcs.append( lambda: k)

>>> funcs[0]()
9
>>> funcs[7]()
9

この動作は、引数のみに依存するラムダ式を関数に変換することで回避できます。キーワードパラメータには、バインドされている現在の値が格納されます。関数呼び出しを変更する必要はありません。

funcs = [] 
for k in range(10):
     funcs.append( lambda k = k: k)

>>> funcs[0]()
0
>>> funcs[7]()
7

score 20 · Accepted Answer

Mod は負の数でも正しく動作します

-1 % 5 は4であり、JavaScript などの他の言語の -1 ではありません。これにより、Python で「ラップアラウンドウィンドウ」がよりクリーンになります。次のようにするだけです。

index = (index + increment) % WINDOW_SIZE

score 19 · Accepted Answer

辞書での無限再帰の適切な処理:

>>> a = {}
>>> b = {}
>>> a['b'] = b
>>> b['a'] = a
>>> print a
{'b': {'a': {...}}}

score 19 · Accepted Answer

一流の関数

隠れた機能というわけではありませんが、関数がファーストクラスオブジェクトであるという事実は、単純に素晴らしいことです。他の変数と同じように渡すことができます。

>>> def jim(phrase):
...   return 'Jim says, "%s".' % phrase
>>> def say_something(person, phrase):
...   print person(phrase)

>>> say_something(jim, 'hey guys')
'Jim says, "hey guys".'

score 19 · Accepted Answer

スライスの割り当てと削除:

>>> a = range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[:5] = [42]
>>> a
[42, 5, 6, 7, 8, 9]
>>> a[:1] = range(5)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del a[::2]
>>> a
[1, 3, 5, 7, 9]
>>> a[::2] = a[::-2]
>>> a
[9, 3, 5, 7, 1]

注: 拡張スライス ( s[start:stop:step]) に割り当てる場合、割り当てられた iterable はスライスと同じ長さでなければなりません。

score 19 · Accepted Answer

あまり隠されていませんが、関数には属性があります:

def doNothing():
    pass

doNothing.monkeys = 4
print doNothing.monkeys
4

score 19 · Accepted Answer

三項演算子

>>> 'ham' if True else 'spam'
'ham'
>>> 'ham' if False else 'spam'
'spam'

これは 2.5 で追加されましたが、それ以前は以下を使用できました。

>>> True and 'ham' or 'spam'
'ham'
>>> False and 'ham' or 'spam'
'spam'

ただし、操作する値が false と見なされる場合は、違いがあります。

>>> [] if True else 'spam'
[]
>>> True and [] or 'spam'
'spam'

score 19 · Accepted Answer

タプルを組み込み関数に渡す

多くの Python 関数はタプルを受け入れますが、そうでもないようです。たとえば、変数が数値かどうかをテストするには、次のようにします。

if isinstance (number, float) or isinstance (number, int):  
   print "yaay"

しかし、タプルを渡すと、これはよりきれいに見えます。

if isinstance (number, (float, int)):  
   print "yaay"

score 18 · Accepted Answer

おそらく、これはそれ自体がプログラミング機能ではありませんが、非常に便利なので投稿します。

$ python -m http.server

$ wget http://<ipnumber>:8000/filename...どこか別の場所が続きます。

古い (2.x) バージョンの Python をまだ実行している場合:

$ python -m SimpleHTTPServer

たとえば、ポートを指定することもできますpython -m http.server 80(サーバー側にルートがある場合は、URL でポートを省略できます)。

score 18 · Accepted Answer

負のステップを使用してイテラブルを逆にする

>>> s = "Hello World"
>>> s[::-1]
'dlroW olleH'
>>> a = (1,2,3,4,5,6)
>>> a[::-1]
(6, 5, 4, 3, 2, 1)
>>> a = [5,4,3,2,1]
>>> a[::-1]
[1, 2, 3, 4, 5]

score 18 · Accepted Answer

「隠されている」わけではありませんが、非常に便利で一般的には使用されていません

文字列結合関数をすばやく作成する

 comma_join = ",".join
 semi_join  = ";".join

 print comma_join(["foo","bar","baz"])
 'foo,bar,baz

と

引用符やコンマの混乱よりもエレガントに文字列のリストを作成する機能。

l = ["item1", "item2", "item3"]

と取り換える

l = "item1 item2 item3".split()

score 17 · Accepted Answer

Python 3.1 (2.7) 以降では、辞書と集合内包表記がサポートされています。

{ a:a for a in range(10) }
{ a for a in range(10) }

score 17 · Accepted Answer

イテレータへの複数の参照

リスト乗算を使用して、同じ反復子への複数の参照を作成できます。

>>> i = (1,2,3,4,5,6,7,8,9,10) # or any iterable object
>>> iterators = [iter(i)] * 2
>>> iterators[0].next()
1
>>> iterators[1].next()
2
>>> iterators[0].next()
3

これは、ドキュメントのこの例のように、イテラブルをチャンクにグループ化するために使用できます。itertools

def grouper(n, iterable, fillvalue=None):
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

score 15 · Accepted Answer

Pythonは、ASCIIの種類だけでなく、あらゆる種類のUnicode桁を理解できます。

>>> s = u'１０５８５'
>>> s
u'\uff11\uff10\uff15\uff18\uff15'
>>> print s
１０５８５
>>> int(s)
10585
>>> float(s)
10585.0

score 14 · Accepted Answer

__slots__メモリを節約する良い方法ですが、オブジェクトの値の辞書を取得するのは非常に困難です。次のオブジェクトを想像してください。

class Point(object):
    __slots__ = ('x', 'y')

このオブジェクトには明らかに 2 つの属性があります。これで、そのインスタンスを作成し、この方法で辞書を作成できます。

>>> p = Point()
>>> p.x = 3
>>> p.y = 5
>>> dict((k, getattr(p, k)) for k in p.__slots__)
{'y': 5, 'x': 3}

ただし、ポイントがサブクラス化され、新しいスロットが追加された場合、これは機能しません。ただし、Pythonはモジュール__reduce_ex__を支援するために自動的に実装しcopyます。これは、値の辞書を取得するために悪用される可能性があります。

>>> p.__reduce_ex__(2)[2][1]
{'y': 5, 'x': 3}

score 14 · Accepted Answer

__ module__ プロパティを調べることで、オブジェクトがどのモジュールから来たのかを尋ねることができます。これは、たとえば、コマンドラインで実験を行っていて、多くのものをインポートした場合に便利です。

同様に、モジュールの __ file__ プロパティを調べることで、それがどこから来たのかをモジュールに尋ねることができます。これは、パスの問題をデバッグするときに役立ちます。

score 14 · Accepted Answer

sys.modules の操作

モジュールキャッシュを直接操作して、必要に応じてモジュールを使用可能または使用不可にすることができます。

>>> import sys
>>> import ham
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named ham

# Make the 'ham' module available -- as a non-module object even!
>>> sys.modules['ham'] = 'ham, eggs, saussages and spam.'
>>> import ham
>>> ham
'ham, eggs, saussages and spam.'

# Now remove it again.
>>> sys.modules['ham'] = None
>>> import ham
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named ham

これは、利用可能なモジュールに対しても機能し、すでにインポートされているモジュールに対してもある程度機能します:

>>> import os
# Stop future imports of 'os'.
>>> sys.modules['os'] = None
>>> import os
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named os
# Our old imported module is still available.
>>> os
<module 'os' from '/usr/lib/python2.5/os.pyc'>

最後の行が示すように、sys.modules の変更は、import過去のステートメントではなく、将来のステートメントにのみ影響します。そのため、他のモジュールに影響を与えたい場合は、モジュールを試してインポートする機会を与える前に、これらの変更を行うことが重要です。通常、それらをインポートします。Noneはの特別な値でsys.modulesあり、ネガティブキャッシングに使用されます (モジュールが最初に見つからなかったことを示すため、再度検索しても意味がないことを示します)。それ以外の値はimport、モジュールオブジェクトではない場合でも、操作の結果になります。 . これを使用して、モジュールを希望どおりに動作するオブジェクトに置き換えることができます。sys.modulesからエントリを完全に削除するimportと、たとえそれが以前にインポートされていたとしても、next はモジュールの通常の検索を行います。

score 14 · Accepted Answer

イターツール

このモジュールは見過ごされがちです。次の例ではitertools.chain() 、リストを平坦化するために使用しています。

>>> from itertools import *
>>> l = [[1, 2], [3, 4]]
>>> list(chain(*l))
[1, 2, 3, 4]

その他のアプリケーションについては、 http://docs.python.org/library/itertools.html#recipesを参照してください。

score 13 · Accepted Answer

組み込みのお気に入りのいくつか、map（）、reduce（）、およびfilter（）。すべて非常に高速で強力です。

score 13 · Accepted Answer

整数ベースの推測

>>> int('10', 0)
10
>>> int('0x10', 0)
16
>>> int('010', 0)  # does not work on Python 3.x
8
>>> int('0o10', 0)  # Python >=2.6 and Python 3.x
8
>>> int('0b10', 0)  # Python >=2.6 and Python 3.x
2

score 13 · Accepted Answer

一言: IPython

タブのイントロスペクション、pretty-printing、%debug履歴管理、pylab... 時間をかけて十分に学習する価値があります。

score 12 · Accepted Answer

サブクラスのプロパティ (記述子として定義) の拡張

サブクラスの記述子によって「返された」値を拡張 (変更) すると便利な場合があります。それは簡単に行うことができますsuper()：

class A(object):
    @property
    def prop(self):
        return {'a': 1}

class B(A):
    @property
    def prop(self):
        return dict(super(B, self).prop, b=2)

これを保存しtest.pyて実行しますpython -i test.py（別の隠し機能：-iオプションがスクリプトを実行し、インタラクティブモードで続行できるようにします）：

>>> B().prop
{'a': 1, 'b': 2}

score 12 · Accepted Answer

長さ 2 のシーケンスのセットから辞書を作成できます。値のリストと配列のリストがある場合に非常に便利です。

>>> dict([ ('foo','bar'),('a',1),('b',2) ])
{'a': 1, 'b': 2, 'foo': 'bar'}

>>> names = ['Bob', 'Marie', 'Alice']
>>> ages = [23, 27, 36]
>>> dict(zip(names, ages))
{'Alice': 36, 'Bob': 23, 'Marie': 27}

score 11 · Accepted Answer

列挙型の作成

Pythonでは、これを実行して列挙型をすばやく作成できます。

>>> FOO, BAR, BAZ = range(3)
>>> FOO
0

ただし、「列挙型」は整数値である必要はありません。あなたもこれを行うことができます：

class Colors(object):
    RED, GREEN, BLUE, YELLOW = (255,0,0), (0,255,0), (0,0,255), (0,255,255)

#now Colors.RED is a 3-tuple that returns the 24-bit 8bpp RGB 
#value for saturated red

score 11 · Accepted Answer

python のわずかな不具合。文字列のリストを一緒に結合する通常の高速な方法は、

''.join(list_of_strings)

score 11 · Accepted Answer

re.Scannerクラス。http://code.activestate.com/recipes/457664-hidden-scanner-functionality-in-re-module/

score 11 · Accepted Answer

11

于 2010-12-28T06:18:56.610 に答える

score 10 · Accepted Answer

関数パラメータへの「解凍」

def foo(a, b, c):
        print a, b, c

bar = (3, 14, 15)
foo(*bar)

印刷を実行すると：

3 14 15

score 10 · Accepted Answer

実行時の関数ラベルの変更：

>>> class foo:
...   def normal_call(self): print "normal_call"
...   def call(self): 
...     print "first_call"
...     self.call = self.normal_call

>>> y = foo()
>>> y.call()
first_call
>>> y.call()
normal_call
>>> y.call()
normal_call
...

score 10 · Accepted Answer

string-escapeとunicode-escapeエンコーディング

\nなどを含む外部ソースからの文字列があるとしましょう\t。それらを改行またはタブに変換する方法は? エンコーディングを使用して文字列をデコードするだけstring-escapeです!

>>> print s
Hello\nStack\toverflow
>>> print s.decode('string-escape')
Hello
Stack   overflow

別の問題。のようなユニコードリテラルを含む通常の文字列があります\u01245。それを機能させる方法は？エンコーディングを使用して文字列をデコードするだけunicode-escapeです!

>>> s = '\u041f\u0440\u0438\u0432\u0456\u0442, \u0441\u0432\u0456\u0442!'
>>> print s
\u041f\u0440\u0438\u0432\u0456\u0442, \u0441\u0432\u0456\u0442!
>>> print unicode(s)
\u041f\u0440\u0438\u0432\u0456\u0442, \u0441\u0432\u0456\u0442!
>>> print unicode(s, 'unicode-escape')
Привіт, світ!

score 10 · Accepted Answer

ビルトインreversed()。多くの場合、反復処理がよりクリーンになります。

簡単な例:

for i in reversed([1, 2, 3]):
    print(i)

生成:

3
2
1

ただし、reversed()ファイル内の行やジェネレーター式など、任意の反復子でも機能します。

score 10 · Accepted Answer

Python の禅

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

score 9 · Accepted Answer

ボーグパターン

これはAlex Martelliのキラーです。Borg共有状態のすべてのインスタンス。これにより、シングルトンパターンを使用する必要がなくなり (状態が共有されている場合はインスタンスは関係ありません)、かなり洗練されています (ただし、新しいクラスではより複雑になります)。

の値はfooどのインスタンスでも再割り当てでき、すべてが更新されます。辞書全体を再割り当てすることもできます。ボーグは完璧な名前です。詳細はこちらをご覧ください。

class Borg:
    __shared_state = {'foo': 'bar'}
    def __init__(self):
        self.__dict__ = self.__shared_state
    # rest of your class here

これは、eventlet.GreenPool を共有して同時実行を制御するのに最適です。

score 9 · Accepted Answer

Pythonで不要な解凍

Python には zip() に対応する unzip 関数がないことについて誰かがブログに書きました。unzip は、次の理由で簡単に計算できます。

>>> t1 = (0,1,2,3)
>>> t2 = (7,6,5,4)
>>> [t1,t2] == zip(*zip(t1,t2))
True

ただし、熟考すると、明示的な unzip() が必要です。

score 9 · Accepted Answer

極秘属性

>>> class A(object): pass
>>> a = A()
>>> setattr(a, "can't touch this", 123)
>>> dir(a)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', "can't touch this"]
>>> a.can't touch this # duh
  File "<stdin>", line 1
    a.can't touch this
                     ^
SyntaxError: EOL while scanning string literal
>>> getattr(a, "can't touch this")
123
>>> setattr(a, "__class__.__name__", ":O")
>>> a.__class__.__name__
'A'
>>> getattr(a, "__class__.__name__")
':O'

score 9 · Accepted Answer

動的に追加された属性

これは、呼び出すだけでいくつかの属性をクラスに追加することを考えている場合に便利です。__getattribute__これは、ドットオペランドが使用されたときに呼び出されるメンバー関数をオーバーライドすることで実行できます。それでは、例えばダミークラスを見てみましょう:

class Dummy(object):
    def __getattribute__(self, name):
        f = lambda: 'Hello with %s'%name
        return f

Dummy オブジェクトをインスタンス化してメソッド呼び出しを行うと、次のようになります。

>>> d = Dummy()
>>> d.b()
'Hello with b'

最後に、動的に定義できるように、属性をクラスに設定することもできます。これは、Python Web フレームワークを使用していて、属性の名前を解析してクエリを実行したい場合に役立ちます。

この単純なコードと、友人が作成した Ruby での同等のコードを含む githubの要点があります。

気をつけて！

score 9 · Accepted Answer

namedtuple はタプルです

>>> node = namedtuple('node', "a b")
>>> node(1,2) + node(5,6)
(1, 2, 5, 6)
>>> (node(1,2), node(5,6))
(node(a=1, b=2), node(a=5, b=6))
>>>

コメントに応答するためのいくつかの実験:

>>> from collections import namedtuple
>>> from operator import *
>>> mytuple = namedtuple('A', "a b")
>>> yourtuple = namedtuple('Z', "x y")
>>> mytuple(1,2) + yourtuple(5,6)
(1, 2, 5, 6)
>>> q = [mytuple(1,2), yourtuple(5,6)]
>>> q
[A(a=1, b=2), Z(x=5, y=6)]
>>> reduce(operator.__add__, q)
(1, 2, 5, 6)

namedtupleはの興味深いサブタイプですtuple。

score 8 · Accepted Answer

threading.enumerate（）は、システム内のすべてのThreadオブジェクトへのアクセスを提供し、sys._current_frames（）は、システム内のすべてのスレッドの現在のスタックフレームを返すため、これら2つを組み合わせると、Javaスタイルのスタックダンプが得られます。

def dumpstacks(signal, frame):
    id2name = dict([(th.ident, th.name) for th in threading.enumerate()])
    code = []
    for threadId, stack in sys._current_frames().items():
        code.append("\n# Thread: %s(%d)" % (id2name[threadId], threadId))
        for filename, lineno, name, line in traceback.extract_stack(stack):
            code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
            if line:
                code.append("  %s" % (line.strip()))
    print "\n".join(code)

import signal
signal.signal(signal.SIGQUIT, dumpstacks)

マルチスレッドのPythonプログラムの開始時にこれを行うと、SIGQUITを送信することで、いつでもスレッドの現在の状態にアクセスできます。signal.SIGUSR1またはsignal.SIGUSR2を選択することもできます。

見る

score 8 · Accepted Answer

pdb — Python デバッガー

プログラマーとして、本格的なプログラム開発に最初に必要なものの 1 つはデバッガーです。Python には、pdb と呼ばれるモジュールとして利用できる組み込み機能が 1 つあります (当然、「Python DeBugger」の意味です!)。

http://docs.python.org/library/pdb.html

score 7 · Accepted Answer

リスト内の無限再帰

>>> a = [1,2]
>>> a.append(a)
>>> a
[1, 2, [...]]
>>> a[2]
[1, 2, [...]]
>>> a[2][2][2][2][2][2][2][2][2] == a
True

score 7 · Accepted Answer

モジュールをリロードすると、「ライブコーディング」スタイルが可能になります。ただし、クラスインスタンスは更新されません。その理由とその回避方法は次のとおりです。覚えておいてください、すべて、はい、すべてがオブジェクトです。

>>> from a_package import a_module
>>> cls = a_module.SomeClass
>>> obj = cls()
>>> obj.method()
(old method output)

ここで、a_module.pyのメソッドを変更し、オブジェクトを更新します。

>>> reload(a_module)
>>> a_module.SomeClass is cls
False # Because it just got freshly created by reload.
>>> obj.method()
(old method output)

これを更新する1つの方法があります（ただし、はさみで実行していると考えてください）。

>>> obj.__class__ is cls
True # it's the old class object
>>> obj.__class__ = a_module.SomeClass # pick up the new class
>>> obj.method()
(new method output)

オブジェクトの内部状態が新しいクラスが期待するものと異なる可能性があるため、これは「はさみで実行」です。これは本当に単純なケースで機能しますが、それを超えて、pickleあなたの友達です。ただし、これが機能する理由を理解することは依然として役立ちます。

score 7 · Accepted Answer

...デフォルト値dict.get()はNoneであるため、KeyErrorsを回避できます。

In [1]: test = { 1 : 'a' }

In [2]: test[2]
---------------------------------------------------------------------------
<type 'exceptions.KeyError'>              Traceback (most recent call last)

&lt;ipython console&gt; in <module>()

<type 'exceptions.KeyError'>: 2

In [3]: test.get( 2 )

In [4]: test.get( 1 )
Out[4]: 'a'

In [5]: test.get( 2 ) == None
Out[5]: True

そして、これを「シーンで」指定することさえできます：

In [6]: test.get( 2, 'Some' ) == 'Some'
Out[6]: True

また、）を使用setdefault(して値を設定し、値が存在しない場合は返すことができます。

>>> a = {}
>>> b = a.setdefault('foo', 'bar')
>>> a
{'foo': 'bar'}
>>> b
'bar

score 7 · Accepted Answer

生の文字列内のバックスラッシュは、引き続き引用符をエスケープできます。これを参照してください：

>>> print repr(r"aaa\"bbb")
'aaa\\"bbb'

バックスラッシュと二重引用符の両方が最終文字列に含まれていることに注意してください。

結果として、生の文字列をバックスラッシュで終了することはできません:

>>> print repr(r"C:\")
SyntaxError: EOL while scanning string literal
>>> print repr(r"C:\"")
'C:\\"'

これは、Windows パスを記述するためではなく、正規表現を記述しやすくするために生の文字列が実装されているために発生します。これについては、 Gotcha — backslashes in Windows filenamesで長い議論を読んでください。

score 7 · Accepted Answer

演算子は関数として呼び出すことができます:

from operator import add
print reduce(add, [1,2,3,4,5,6])

score 7 · Accepted Answer

7

inspectモジュールもクールな機能です。

于 2009-03-10T22:47:20.587 に答える

score 6 · Accepted Answer

スライスと可変性

リストのコピー

>>> x = [1,2,3]
>>> y = x[:]
>>> y.pop()
3
>>> y
[1, 2]
>>> x
[1, 2, 3]

リストの置き換え

>>> x = [1,2,3]
>>> y = x
>>> y[:] = [4,5,6]
>>> x
[4, 5, 6]

score 6 · Accepted Answer

入れ子関数パラメーターの再バインド

def create_printers(n):
    for i in xrange(n):
        def printer(i=i): # Doesn't work without the i=i
            print i
        yield printer

score 6 · Accepted Answer

整数の丸め：Pythonには関数roundがあり、double型の数値を返します。

 >>> print round(1123.456789, 4)
1123.4568
 >>> print round(1123.456789, 2)
1123.46
 >>> print round(1123.456789, 0)
1123.0

この関数には素晴らしい魔法の特性があります。

 >>> print round(1123.456789, -1)
1120.0
 >>> print round(1123.456789, -2)
1100.0

結果として整数が必要な場合は、intを使用して型を変換します。

 >>> print int(round(1123.456789, -2))
1100
 >>> print int(round(8359980, -2))
8360000

グレゴールありがとう。

score 6 · Accepted Answer

クラスのmroをメタクラスでオーバーライドできます

>>> class A(object):
...     def a_method(self):
...         print("A")
... 
>>> class B(object):
...     def b_method(self):
...         print("B")
... 
>>> class MROMagicMeta(type):
...     def mro(cls):
...         return (cls, B, object)
... 
>>> class C(A, metaclass=MROMagicMeta):
...     def c_method(self):
...         print("C")
... 
>>> cls = C()
>>> cls.c_method()
C
>>> cls.a_method()
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AttributeError: 'C' object has no attribute 'a_method'
>>> cls.b_method()
B
>>> type(cls).__bases__
(<class '__main__.A'>,)
>>> type(cls).__mro__
(<class '__main__.C'>, <class '__main__.B'>, <class 'object'>)

それはおそらく正当な理由で隠されています。:)

score 6 · Accepted Answer

組み込みのメソッドまたは関数は記述子プロトコルを実装していないため、次のようなことはできません。

>>> class C(object):
...  id = id
... 
>>> C().id()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: id() takes exactly one argument (0 given)

ただし、これを可能にする小さなバインド記述子を作成できます。

>>> from types import MethodType
>>> class bind(object):
...  def __init__(self, callable):
...   self.callable = callable
...  def __get__(self, obj, type=None):
...   if obj is None:
...    return self
...   return MethodType(self.callable, obj, type)
... 
>>> class C(object):
...  id = bind(id)
... 
>>> C().id()
7414064

score 6 · Accepted Answer

Python 2.x は、シーケンスの最後の要素の後に見つかった場合、カンマを無視します。

>>> a_tuple_for_instance = (0,1,2,3,)
>>> another_tuple = (0,1,2,3)
>>> a_tuple_for_instance == another_tuple
True

末尾のコンマにより、括弧で囲まれた単一の要素がシーケンスとして扱われます。

>>> a_tuple_with_one_element = (8,)

score 6 · Accepted Answer

関数をクラスでデコレートできます - 関数をクラスインスタンスに置き換えます:

class countCalls(object):
    """ decorator replaces a function with a "countCalls" instance
    which behaves like the original function, but keeps track of calls

    >>> @countCalls
    ... def doNothing():
    ...     pass
    >>> doNothing()
    >>> doNothing()
    >>> print doNothing.timesCalled
    2
    """
    def __init__ (self, functionToTrack):
        self.functionToTrack = functionToTrack
        self.timesCalled = 0
    def __call__ (self, *args, **kwargs):
        self.timesCalled += 1
        return self.functionToTrack(*args, **kwargs)

score 6 · Accepted Answer

左辺値としてスライスします。このエラトステネスのふるいは、素数または 0 のいずれかを持つリストを生成します。要素は、ループ内のスライス割り当てで 0 になります。

def eras(n):
    last = n + 1
    sieve = [0,0] + list(range(2, last))
    sqn = int(round(n ** 0.5))
    it = (i for i in xrange(2, sqn + 1) if sieve[i])
    for i in it:
        sieve[i*i:last:i] = [0] * (n//i - i + 1)
    return filter(None, sieve)

動作させるには、左側のスライスに同じ長さの右側のリストを割り当てる必要があります。

score 6 · Accepted Answer

ファイルの削除、ファイルのオープンなどの代替機能 - 言語ライブラリの直接操作。これは、テスト時に大きな利点です。すべてを複雑なコンテナーにラップする必要はありません。関数/メソッドを置き換えるだけです。これはモンキーパッチとも呼ばれます。

score 6 · Accepted Answer

小さな整数 (-5 .. 256) のオブジェクトは 2 回作成されることはありません:


>>> a1 = -5; b1 = 256
>>> a2 = -5; b2 = 256
>>> id(a1) == id(a2), id(b1) == id(b2)
(True, True)
>>>
>>> c1 = -6; d1 = 257
>>> c2 = -6; d2 = 257
>>> id(c1) == id(c2), id(d1) == id(d2)
(False, False)
>>>

編集: リストオブジェクトは破棄されません (リスト内のオブジェクトのみ)。Python には、最大 80 個の空のリストを保持する配列があります。リストオブジェクトを破棄すると-pythonはそれをその配列に入れ、新しいリストを作成すると-pythonはこの配列から最後に入れられたリストを取得します:


>>> a = [1,2,3]; a_id = id(a)
>>> b = [1,2,3]; b_id = id(b)
>>> del a; del b
>>> c = [1,2,3]; id(c) == b_id
True
>>> d = [1,2,3]; id(d) == a_id
True
>>>

score 6 · Accepted Answer

再帰制限の操作

sys.getrecursionlimit() & sys.setrecursionlimit() で再帰の最大深度を取得または設定します。

無限再帰によって引き起こされるスタックオーバーフローを防ぐために制限することができます。

score 5 · Accepted Answer

__getattr__()

getattr is a really nice way to make generic classes, which is especially useful if you're writing an API. For example, in the FogBugz Python API, getattr is used to pass method calls on to the web service seamlessly:

class FogBugz:
    ...

    def __getattr__(self, name):
        # Let's leave the private stuff to Python
        if name.startswith("__"):
            raise AttributeError("No such attribute '%s'" % name)

        if not self.__handlerCache.has_key(name):
            def handler(**kwargs):
                return self.__makerequest(name, **kwargs)
            self.__handlerCache[name] = handler
        return self.__handlerCache[name]
    ...

When someone calls FogBugz.search(q='bug'), they don't get actually call a search method. Instead, getattr handles the call by creating a new function that wraps the makerequest method, which crafts the appropriate HTTP request to the web API. Any errors will be dispatched by the web service and passed back to the user.

score 5 · Accepted Answer

クラスで記述子を使用している場合、Python__dict__はそのキーを完全にバイパスするため、そのような値を保存するのに適した場所になります。

>>> class User(object):
...  def _get_username(self):
...   return self.__dict__['username']
...  def _set_username(self, value):
...   print 'username set'
...   self.__dict__['username'] = value
...  username = property(_get_username, _set_username)
...  del _get_username, _set_username
... 
>>> u = User()
>>> u.username = "foo"
username set
>>> u.__dict__
{'username': 'foo'}

dir()これは清潔に保つのに役立ちます。

score 5 · Accepted Answer

`getattr`3番目のパラメータを取ります

getattr(obj, attribute_name, default)のようなものです：

try:
    return obj.attribute
except AttributeError:
    return default

ただし、attribute_name任意の文字列にすることができます。

これは、ダックタイピングに非常に役立ちます。多分あなたは次のようなものを持っています:

class MyThing:
    pass
class MyOtherThing:
    pass
if isinstance(obj, (MyThing, MyOtherThing)):
    process(obj)

（ところで、isinstance(obj, (a,b))意味しisinstance(obj, a) or isinstance(obj, b)ます。）

新しい種類のものを作成するときは、それが発生するすべてのタプルに追加する必要があります。(この構造は、モジュールをリロードしたり、同じファイルを 2 つの名前でインポートしたりするときにも問題を引き起こします。これは、人々が認めるよりも多く発生します。) しかし、代わりに、次のように言うこともできます。

class MyThing:
    processable = True
class MyOtherThing:
    processable = True
if getattr(obj, 'processable', False):
    process(obj)

継承を追加すると、さらに良くなります。処理可能なオブジェクトの例はすべて、から継承できます

class Processable:
    processable = True

ただし、属性を設定するためだけに、基本クラスから継承するように全員を説得する必要はありません。

score 5 · Accepted Answer

ディクショナリのすべてのフィールドを初期化するのが面倒ですか? 問題ない：

Python > 2.3 の場合:

from collections import defaultdict

Python <= 2.3 の場合:

def defaultdict(type_):
    class Dict(dict):
        def __getitem__(self, key):
            return self.setdefault(key, type_())
    return Dict()

どのバージョンでも:

d = defaultdict(list)
for stuff in lots_of_stuff:
     d[stuff.name].append(stuff)

アップデート：

ありがとうケン・アーノルド。より洗練されたバージョンの defaultdict を再実装しました。これは、標準ライブラリのものとまったく同じように動作する必要があります。

def defaultdict(default_factory, *args, **kw):                              

    class defaultdict(dict):

        def __missing__(self, key):
            if default_factory is None:
                raise KeyError(key)
            return self.setdefault(key, default_factory())

        def __getitem__(self, key):
            try:
                return dict.__getitem__(self, key)
            except KeyError:
                return self.__missing__(key)

    return defaultdict(*args, **kw)

score 5 · Accepted Answer

内包表記を設定する

>>> {i**2 for i in range(5)}                                                       
set([0, 1, 4, 16, 9])

Python ドキュメント

ウィキペディアのエントリ

score 5 · Accepted Answer

ここに2つのイースターエッグがあります：

Python自体の1つ：

>>> import __hello__
Hello world...

Werkzeugそして、明らかにするのが少し複雑な、モジュール内のもう 1 つのものを次に示します。

Werkzeugののソースコードを見るとwerkzeug/__init__.py、注目すべき行があります。

'werkzeug._internal':   ['_easteregg']

少し興味がある場合は、これを参照してください。wsgi アプリケーションを引数に取る関数がwerkzeug/_internal.py見つかります。また、base64 でエンコードされたデータと 2 つのネストされた関数が含まれています。指定された引数がクエリ文字列で見つかった_easteregg()場合、何か特別なことを行います。macgybarchakku

_easteregg()したがって、このイースターエッグを明らかにするには、関数でアプリケーションをラップする必要があるようです。

from werkzeug import Request, Response, run_simple
from werkzeug import _easteregg

@Request.application
def application(request):
    return Response('Hello World!')

run_simple('localhost', 8080, _easteregg(application))

ここで、アプリを実行してhttp://localhost:8080/?macgybarchakkuにアクセスすると、イースターエッグが表示されるはずです。

score 5 · Accepted Answer

リスト内包表記

リスト内包表記

より伝統的なものを比較してください（リスト内包表記なし）：

foo = []
for x in xrange(10):
  if x % 2 == 0:
     foo.append(x)

に：

foo = [x for x in xrange(10) if x % 2 == 0]

score 5 · Accepted Answer

辞書内包表記

>>> {i: i**2 for i in range(5)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Python ドキュメント

ウィキペディアのエントリ

score 5 · Accepted Answer

シンプルなビルトインベンチマークツール

Python 標準ライブラリには、「timeit」と呼ばれる非常に使いやすいベンチマークモジュールが付属しています。コマンドラインから使用して、いくつかの言語構造のうちどれが最も高速かを確認することもできます。

例えば、

% python -m timeit 'r = range(0, 1000)' 'for i in r: pass'
10000 loops, best of 3: 48.4 usec per loop

% python -m timeit 'r = xrange(0, 1000)' 'for i in r: pass'
10000 loops, best of 3: 37.4 usec per loop

score 5 · Accepted Answer

5

輸入反重力

于 2008-10-16T10:52:13.827 に答える

score 5 · Accepted Answer

haridsvによって前述されたこれに加えて:

>>> foo = bar = baz = 1
>>> foo, bar, baz
(1, 1, 1)

これを行うことも可能です：

>>> foo, bar, baz = 1, 2, 3
>>> foo, bar, baz
(1, 2, 3)

score 5 · Accepted Answer

オブジェクトのモンキーパッチ

Python のすべてのオブジェクトには__dict__、オブジェクトの属性を格納するメンバーがあります。したがって、次のようなことができます。

class Foo(object):
    def __init__(self, arg1, arg2, **kwargs):
        #do stuff with arg1 and arg2
        self.__dict__.update(kwargs)

f = Foo('arg1', 'arg2', bar=20, baz=10)
#now f is a Foo object with two extra attributes

これを悪用して、属性と機能の両方を任意にオブジェクトに追加できます。これを悪用して、クイックアンドダーティstructタイプを作成することもできます。

class struct(object):
    def __init__(**kwargs):
       self.__dict__.update(kwargs)

s = struct(foo=10, bar=11, baz="i'm a string!')

score 5 · Accepted Answer

pythonic イディオムx = ... if ... else ...ははるかに優れてx = ... and ... or ...おり、その理由は次のとおりです。

声明ですが、

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

に等しい

x = y == 1 and 3 or 2

この慣用句を使用するx = ... and ... or ...と、いつか次のようなトリッキーな状況に陥る可能性があります。

x = 0 if True else 1    # sets x equal to 0

したがって、と同等ではありません

x = True and 0 or 1   # sets x equal to 1

これを行う適切な方法の詳細については、 Python の隠し機能を参照してください。

score 5 · Accepted Answer

可変バッファの公開

Python Buffer Protocolを使用して、 Python (2.5/2.6) で変更可能なバイト指向のバッファーを公開します。

(申し訳ありませんが、ここにコードはありません。低レベルの C API または既存のアダプターモジュールを使用する必要があります)。

score 4 · Accepted Answer

属性（プロパティ）としてディクショナリ要素にアクセスします。したがって、a1 = AttrDict（）にa1['name']の代わりにキー'name'->がある場合、->a1.nameを使用してa1のname属性に簡単にアクセスできます。

class AttrDict(dict):

    def __getattr__(self, name):
        if name in self:
            return self[name]
        raise AttributeError('%s not found' % name)

    def __setattr__(self, name, value):
        self[name] = value

    def __delattr__(self, name):
        del self[name]

person = AttrDict({'name': 'John Doe', 'age': 66})
print person['name']
print person.name

person.name = 'Frodo G'
print person.name

del person.age

print person

score 4 · Accepted Answer

for ループ、リスト内包表記、およびジェネレーター式でのタプルのアンパック:

>>> l=[(1,2),(3,4)]
>>> [a+b for a,b in l ] 
[3,7]

辞書で (キー、データ) のペアを反復処理するためのこのイディオムで役立ちます。

d = { 'x':'y', 'f':'e'}
for name, value in d.items():  # one can also use iteritems()
   print "name:%s, value:%s" % (name,value)

プリント:

name:x, value:y
name:f, value:e

score 4 · Accepted Answer

すべてが一流であること (「すべてがオブジェクトである」) と、これが引き起こす可能性のある騒乱。

>>> x = 5
>>> y = 10
>>> 
>>> def sq(x):
...   return x * x
... 
>>> def plus(x):
...   return x + x
... 
>>> (sq,plus)[y>x](y)
20

最後の行は、2 つの関数を含むタプルを作成し、y>x (True) を評価し、それをタプルへのインデックスとして使用し (int、1 にキャストすることにより)、パラメータ y を指定してその関数を呼び出し、結果。

さらに悪用するには、インデックス付きのオブジェクト (リストなど) を返す場合、最後にさらに角括弧を追加できます。内容が呼び出し可能な場合、括弧などが追加されます。さらに倒錯させるには、次のようなコードの結果を別の例の式として使用します (つまり、y>x をこのコードに置き換えます)。

(sq,plus)[y>x](y)[4](x)

これは、Python の 2 つの側面を示しています。「すべてはオブジェクトである」という哲学を極限まで追求したものと、言語の構文を不適切または不十分に使用すると、単一の式に収まる完全に読み取り不可能で保守不可能なスパゲッティコードになる可能性がある方法です。 .

score 4 · Accepted Answer

わずかな作業で、スレッド化モジュールは驚くほど使いやすくなります。このデコレーターは、関数を独自のスレッドで実行するように変更し、通常の結果ではなくプレースホルダークラスインスタンスを返します。placeolder.result をチェックして答えを調べるか、placeholder.awaitResult() を呼び出してそれを待つことができます。

def threadify(function):
    """
    exceptionally simple threading decorator. Just:
    >>> @threadify
    ... def longOperation(result):
    ...     time.sleep(3)
    ...     return result
    >>> A= longOperation("A has finished")
    >>> B= longOperation("B has finished")

    A doesn't have a result yet:
    >>> print A.result
    None

    until we wait for it:
    >>> print A.awaitResult()
    A has finished

    we could also wait manually - half a second more should be enough for B:
    >>> time.sleep(0.5); print B.result
    B has finished
    """
    class thr (threading.Thread,object):
        def __init__(self, *args, **kwargs):
            threading.Thread.__init__ ( self )  
            self.args, self.kwargs = args, kwargs
            self.result = None
            self.start()
        def awaitResult(self):
            self.join()
            return self.result        
        def run(self):
            self.result=function(*self.args, **self.kwargs)
    return thr

score 4 · Accepted Answer

4

特別な方法

絶対的な力！

于 2008-09-19T11:55:26.117 に答える

score 4 · Accepted Answer

4

Python には秘密はありません ;)

于 2010-02-13T22:09:00.667 に答える

score 4 · Accepted Answer

Python には非常に予想外の例外があります。

輸入品

これにより、ライブラリが見つからない場合に代替をインポートできます

try:
    import json
except ImportError:
    import simplejson as json

反復

for ループはこれを内部的に行い、StopIteration をキャッチします。

iter([]).next()
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    iter(a).next()
StopIteration

アサーション

>>> try:
...     assert []
... except AssertionError:
...     print "This list should not be empty"
This list should not be empty

これは 1 つのチェックではより冗長ですが、同じエラーメッセージで例外とブール演算子が混在する複数のチェックは、この方法で短縮できます。

score 4 · Accepted Answer

アンパックと print 関数を組み合わせる:

# in 2.6 <= python < 3.0, 3.0 + the print function is native
from __future__ import print_function 

mylist = ['foo', 'bar', 'some other value', 1,2,3,4]  
print(*mylist)

score 4 · Accepted Answer

Python の動的な性質を利用して、Python 構文でアプリの構成ファイルを作成します。たとえば、構成ファイルに次のものがあったとします。

{
  "name1": "value1",
  "name2": "value2"
}

次に、次のように簡単に読むことができます。

config = eval(open("filename").read())

score 4 · Accepted Answer

複数の変数を同じ値に割り当てることができます

>>> foo = bar = baz = 1
>>> foo, bar, baz
(1, 1, 1)

コンパクトな方法で、いくつかの変数を None に初期化するのに役立ちます。

score 4 · Accepted Answer

Python3 の Unicode 識別子:

>>> 'Unicode字符_تكوين_Variable'.isidentifier()
True
>>> Unicode字符_تكوين_Variable='Python3 rules!'
>>> Unicode字符_تكوين_Variable
'Python3 rules!'

score 4 · Accepted Answer

モジュールはその名前空間ですべてをエクスポートします

他のモジュールからインポートされた名前を含む!

# this is "answer42.py"
from operator import *
from inspect  import *

次に、モジュールからインポートできるものをテストします。

>>> import answer42
>>> answer42.__dict__.keys()
['gt', 'imul', 'ge', 'setslice', 'ArgInfo', 'getfile', 'isCallable', 'getsourcelines', 'CO_OPTIMIZED', 'le', 're', 'isgenerator', 'ArgSpec', 'imp', 'lt', 'delslice', 'BlockFinder', 'getargspec', 'currentframe', 'CO_NOFREE', 'namedtuple', 'rshift', 'string', 'getframeinfo', '__file__', 'strseq', 'iconcat', 'getmro', 'mod', 'getcallargs', 'isub', 'getouterframes', 'isdatadescriptor', 'modulesbyfile', 'setitem', 'truth', 'Attribute', 'div', 'CO_NESTED', 'ixor', 'getargvalues', 'ismemberdescriptor', 'getsource', 'isMappingType', 'eq', 'index', 'xor', 'sub', 'getcomments', 'neg', 'getslice', 'isframe', '__builtins__', 'abs', 'getmembers', 'mul', 'getclasstree', 'irepeat', 'is_', 'getitem', 'indexOf', 'Traceback', 'findsource', 'ModuleInfo', 'ipow', 'TPFLAGS_IS_ABSTRACT', 'or_', 'joinseq', 'is_not', 'itruediv', 'getsourcefile', 'dis', 'os', 'iand', 'countOf', 'getinnerframes', 'pow', 'pos', 'and_', 'lshift', '__name__', 'sequenceIncludes', 'isabstract', 'isbuiltin', 'invert', 'contains', 'add', 'isSequenceType', 'irshift', 'types', 'tokenize', 'isfunction', 'not_', 'istraceback', 'getmoduleinfo', 'isgeneratorfunction', 'getargs', 'CO_GENERATOR', 'cleandoc', 'classify_class_attrs', 'EndOfBlock', 'walktree', '__doc__', 'getmodule', 'isNumberType', 'ilshift', 'ismethod', 'ifloordiv', 'formatargvalues', 'indentsize', 'getmodulename', 'inv', 'Arguments', 'iscode', 'CO_NEWLOCALS', 'formatargspec', 'iadd', 'getlineno', 'imod', 'CO_VARKEYWORDS', 'ne', 'idiv', '__package__', 'CO_VARARGS', 'attrgetter', 'methodcaller', 'truediv', 'repeat', 'trace', 'isclass', 'ior', 'ismethoddescriptor', 'sys', 'isroutine', 'delitem', 'stack', 'concat', 'getdoc', 'getabsfile', 'ismodule', 'linecache', 'floordiv', 'isgetsetdescriptor', 'itemgetter', 'getblock']
>>> from answer42 import getmembers
>>> getmembers
<function getmembers at 0xb74b2924>
>>>

from x import *これは、を定義しない、または定義しない正当な理由__all__ =です。

score 4 · Accepted Answer

挿入と追加

機能ではありませんが、興味深いかもしれません

リストにデータを挿入し、それを逆にしたいとします。最も簡単なことは

count = 10 ** 5
nums = []
for x in range(count):
    nums.append(x)
nums.reverse()

代わりに、最初から数字を挿入するのはどうですか? それで：

count = 10 ** 5 
nums = [] 
for x in range(count):
    nums.insert(0, x)

しかし、それは100倍遅くなります！count = 10 ** 6 に設定すると、1,000 倍遅くなります。これは、insert が O(n^2) で、append が O(n) であるためです。

その違いの理由は、挿入が呼び出されるたびにリスト内の各要素を移動する必要があるためです。append 要素をリストの最後に追加するだけです (すべてを再割り当てする必要がある場合もありますが、それでもはるかに高速です)

score 4 · Accepted Answer

オブジェクトインスタンスのメソッド置換

すでに作成されているオブジェクトインスタンスのメソッドを置き換えることができます。これにより、異なる (例外的な) 機能を持つオブジェクトインスタンスを作成できます。

>>> class C(object):
...     def fun(self):
...         print "C.a", self
...
>>> inst = C()
>>> inst.fun()  # C.a method is executed
C.a <__main__.C object at 0x00AE74D0>
>>> instancemethod = type(C.fun)
>>>
>>> def fun2(self):
...     print "fun2", self
...
>>> inst.fun = instancemethod(fun2, inst, C)  # Now we are replace C.a by fun2
>>> inst.fun()  # ... and fun2 is executed
fun2 <__main__.C object at 0x00AE74D0>

できるように、インスタンスC.aに置き換えられました (変更されませんでした)。fun2()instself

別の方法としてモジュールを使用することもできnewますが、Python 2.6 以降では廃止されています。

>>> def fun3(self):
...     print "fun3", self
...
>>> import new
>>> inst.fun = new.instancemethod(fun3, inst, C)
>>> inst.fun()
fun3 <__main__.C object at 0x00AE74D0>

ノード:このソリューションは、継承メカニズムの一般的な代替として使用しないでください! ただし、特定の状況 (デバッグ、モック) では非常に便利な場合があります。

警告:この解決策は、組み込み型およびスロットを使用する新しいスタイルクラスでは機能しません。

score 3 · Accepted Answer

** Using sets to reference contents in sets of frozensets**

ご存知かもしれませんが、セットは可変であるためハッシュ可能ではないため、セットのセットを作成する（またはセットを辞書キーとして使用する）場合は、frozensetsを使用する必要があります。

>>> fabc = frozenset('abc')
>>> fxyz = frozenset('xyz')
>>> mset = set((fabc, fxyz))
>>> mset
{frozenset({'a', 'c', 'b'}), frozenset({'y', 'x', 'z'})}

ただし、通常のセットを使用して、メンバーシップをテストし、メンバーを削除/破棄することは可能です。

>>> abc = set('abc')
>>> abc in mset
True
>>> mset.remove(abc)
>>> mset
{frozenset({'y', 'x', 'z'})}

Python標準ライブラリのドキュメントから引用するには：

、、、およびメソッドのelem引数はセットである可能性があることに注意してください。同等のフリーズセットの検索をサポートするために、セットは検索中に一時的に変更されてから復元されます。検索中は、意味のある値がないため、セットを読み取ったり変更したりしないでください。__contains__()remove()discard()elemelem

残念ながら、そしておそらく驚くべきことに、同じことは辞書には当てはまりません。

>>> mdict = {fabc:1, fxyz:2}
>>> fabc in mdict
True
>>> abc in mdict
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
TypeError: unhashable type: 'set'

score 3 · Accepted Answer

プライベートメソッドとデータの隠蔽（カプセル化）

Pythonには、アンダースコアで始まる名前を付けることで、クラスの外部APIの一部となることを意図していないメソッドやその他のクラスメンバーを示す一般的なイディオムがあります。これは便利で実際には非常にうまく機能しますが、Pythonがプライベートコードやデータの真のカプセル化をサポートしていないという誤った印象を与えます。実際、Pythonは自動的に字句クロージャを提供します。これにより、状況が本当に必要な場合に、はるかに強力な方法でデータをカプセル化することが非常に簡単になります。この手法を利用するクラスの考案された例を次に示します。

class MyClass(object):
  def __init__(self):

    privateData = {}

    self.publicData = 123

    def privateMethod(k):
      print privateData[k] + self.publicData

    def privilegedMethod():
      privateData['foo'] = "hello "
      privateMethod('foo')

    self.privilegedMethod = privilegedMethod

  def publicMethod(self):
    print self.publicData

そして、これがその使用の不自然な例です：

>>> obj = MyClass()
>>> obj.publicMethod()
123
>>> obj.publicData = 'World'
>>> obj.publicMethod()
World
>>> obj.privilegedMethod()
hello World
>>> obj.privateMethod()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateMethod'
>>> obj.privateData
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateData'

重要なのは、実際にはobjの属性privateMethodでprivateDataはないため、外部からアクセスしたり、内部に表示したりすることはできないということdir()です。これらはコンストラクター内のローカル変数であり、。の外部では完全にアクセスできません__init__。ただし、クロージャの魔法のため、（この例では）を呼び出す以外に外部からクロージャにアクセスする方法はありませんが、実際には、それらが関連付けられているオブジェクトと同じライフタイムを持つインスタンスごとの変数ですprivilegedMethod。多くの場合、この種の非常に厳密なカプセル化はやり過ぎですが、APIや名前空間をきしむようにクリーンに保つのに非常に便利な場合もあります。

Python 2.xでは、変更可能なプライベート状態を設定する唯一の方法は、変更可能なオブジェクト（この例のdictなど）を使用することです。多くの人が、これがどれほど迷惑になるかについて述べています。Python 3.xは、 PEP 3104nonlocalで説明されているキーワードを導入することにより、この制限を取り除きます。

score 3 · Accepted Answer

すべてがオブジェクトであり、それ自体が拡張可能であるという事実。定義した関数にメタデータとしてメンバー変数を追加できます。

>>> def addInts(x,y): 
...    return x + y
>>> addInts.params = ['integer','integer']
>>> addInts.returnType = 'integer'

これは、動的な単体テストを作成する場合に非常に役立ちます。

score 3 · Accepted Answer

Python には「プライベート」変数があります

二重アンダースコアで始まるが終わらない変数は、慣習だけでなくプライベートになります。実際には __var は _Classname__var に変わります。ここで、Classname は変数が作成されたクラスです。それらは継承されず、オーバーライドできません。


>>> class A:
...     def __init__(self):
...             self.__var = 5
...     def getvar(self):
...             return self.__var
... 
>>> a = A()
>>> a.__var
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: A instance has no attribute '__var'
>>> a.getvar()
5
>>> dir(a)
['_A__var', '__doc__', '__init__', '__module__', 'getvar']
>>>

score 3 · Accepted Answer

キーが dict にあるかどうかをテストする簡単な方法:

>>> 'key' in { 'key' : 1 }
True

>>> d = dict(key=1, key2=2)
>>> if 'key' in d:
...     print 'Yup'
... 
Yup

score 3 · Accepted Answer

機能サポート。

具体的には、ジェネレーターとジェネレーター式。

Ruby はこれを再び主流にしましたが、Python も同様に行うことができます。Ruby のようにライブラリのどこにでもあるわけではありませんが、これは残念なことですが、私は構文の方が好きです。

それらはどこにでもあるわけではないので、なぜそれらが役立つかについての例はそれほど多くはありませんが、よりクリーンで効率的なコードを書くことができました.

score 3 · Accepted Answer

すべてがダイナミック

「コンパイル時間はありません」。Python のすべてはランタイムです。モジュールは、スクリプトのようにモジュールのソースを上から下に実行することによって「定義」され、結果の名前空間はモジュールの属性空間になります。同様に、クラスはクラス本体を上から下に実行することによって「定義」され、結果の名前空間はクラスの属性空間になります。クラス本体には、インポートステートメント、ループ、その他のクラスステートメントなど、完全に任意のコードを含めることができます。時々要求されるように、クラス、関数、またはモジュールを「動的に」作成することは難しくありません。実際、すべてが「動的」であるため、回避することは不可能です。

score 3 · Accepted Answer

あまりpythonicではありませんが、次を使用してファイルに書き込むことができますprint

print>>outFile, 'I am Being Written'

説明:

この形式は、「<code>print chevron」と呼ばれることがあります。write()この形式では、>> の後の最初の式は、「ファイルのような」オブジェクト、具体的には上記のメソッドを持つオブジェクトに評価される必要があります。この拡張形式では、後続の式がこのファイルオブジェクトに出力されます。最初の式がと評価された場合、Noneが sys.stdout出力用のファイルとして使用されます。

score 3 · Accepted Answer

ブールコンテキストのオブジェクト

空のタプル、リスト、ディクテーション、文字列、およびその他の多くのオブジェクトは、ブールコンテキストでは False と同等です (空でないものは True と同等です)。

empty_tuple = ()
empty_list = []
empty_dict = {}
empty_string = ''
empty_set = set()
if empty_tuple or empty_list or empty_dict or empty_string or empty_set:
  print 'Never happens!'

これにより、論理演算で True/False ではなくオペランドの 1 つを返すことができます。これは、状況によっては便利です。

s = t or "Default value" # s will be assigned "Default value"
                         # if t is false/empty/none

score 3 · Accepted Answer

ユーザーが保存したファイルを Pickle 経由でロードするアプリケーション内のクラスの名前を変更し、名前を変更したクラスの 1 つがユーザーの古い保存ファイルに格納されている場合、その pickle 化されたファイルをロードすることはできません。

ただし、クラス定義への参照を追加するだけで、すべてがうまくいきます。

例：前：

class Bleh:
    pass

今、

class Blah:
    pass

そのため、ユーザーの pickled 保存ファイルには、名前が変更されたために存在しない Bleh への参照が含まれています。修正？

Bleh = Blah

単純！

score 3 · Accepted Answer

一度に 1 画面分ずつ複数行の文字列を出力する

オブジェクトがインスタンスであるsite._Printerクラスに隠された、あまり役に立たない機能。license後者は、呼び出されると、Python ライセンスを出力します。2 番目の引数として文字列 (ファイルの内容など) を渡して、同じ型の別のオブジェクトを作成し、それを呼び出すことができます。

type(license)(0,open('textfile.txt').read(),0)()

これは、一度に特定の行数で分割されたファイルの内容を出力します。

...
file row 21
file row 22
file row 23

Hit Return for more, or q (and Return) to quit:

score 2 · Accepted Answer

getattr組み込み関数：

>>> class C():
    def getMontys(self):
        self.montys = ['Cleese','Palin','Idle','Gilliam','Jones','Chapman']
        return self.montys


>>> c = C()
>>> getattr(c,'getMontys')()
['Cleese', 'Palin', 'Idle', 'Gilliam', 'Jones', 'Chapman']
>>>

状況に応じて機能をディスパッチしたい場合に便利です。Dive Into Python（ここ）の例を参照してください

score 2 · Accepted Answer

メモリ管理

Pythonは動的にメモリを割り当て、ガベージコレクションを使用して未使用のスペースを回復します。オブジェクトがスコープ外になり、他の変数がそれを参照しなくなると、オブジェクトは回復されます。バッファオーバーランやサーバープロセスの成長が遅いことを心配する必要はありません。メモリ管理も他の動的言語の機能ですが、Pythonはそれを非常にうまく行っています。

もちろん、循環参照と不要になったオブジェクトへの参照を保持することに注意する必要がありますが、弱参照はここで大いに役立ちます。

score 2 · Accepted Answer

range(INT) の代わりに xrange(INT) を使用したことがあります....メモリ使用量が少なく、整数のサイズに実際には依存しません。ええ!! いいじゃないですか。

score 2 · Accepted Answer

`spam`標準の Pythonのモジュール

テスト目的で使用されます。

私はctypesチュートリアルからそれを選びました。自分で試してみてください：

>>> import __hello__
Hello world...
>>> type(__hello__)
<type 'module'>
>>> from __phello__ import spam
Hello world...
Hello world...
>>> type(spam)
<type 'module'>
>>> help(spam)
Help on module __phello__.spam in __phello__:

NAME
    __phello__.spam

FILE
    c:\python26\<frozen>

score 2 · Accepted Answer

関数で使用するexecと、変数のルックアップルールが大幅に変更されます。閉鎖はもはや不可能ですが、Python は関数内で任意の識別子を許可します。これにより、「変更可能な locals()」が提供され、識別子をスターインポートするために使用できます。欠点としては、変数がフレーム内のスロットではなく dict で終わるため、すべてのルックアップが遅くなります。

>>> def f():
...  exec "a = 42"
...  return a
... 
>>> def g():
...  a = 42
...  return a
... 
>>> import dis
>>> dis.dis(f)
  2           0 LOAD_CONST               1 ('a = 42')
              3 LOAD_CONST               0 (None)
              6 DUP_TOP             
              7 EXEC_STMT           

  3           8 LOAD_NAME                0 (a)
             11 RETURN_VALUE        
>>> dis.dis(g)
  2           0 LOAD_CONST               1 (42)
              3 STORE_FAST               0 (a)

  3           6 LOAD_FAST                0 (a)
              9 RETURN_VALUE

score 2 · Accepted Answer

隠れた機能ではありませんが、便利な機能です。

リスト内のアイテムをペアでループするため

for x, y in zip(s, s[1:]):

score 2 · Accepted Answer

隠された機能ではありませんが、それでも素晴らしいです:

import os.path as op

root_dir = op.abspath(op.join(op.dirname(__file__), ".."))

パスを操作するときに多くの文字を保存します!

score 2 · Accepted Answer

>>> float('infinity')
inf
>>> float('NaN')
nan

より詳しい情報：

score 2 · Accepted Answer

ファーストクラスオブジェクトとしてのクラス (動的クラス定義を通じて表示)

クロージャーの使用にも注意してください。この特定の例が問題への「正しい」アプローチのように見える場合は、慎重に再考してください...数回:)

def makeMeANewClass(parent, value):
  class IAmAnObjectToo(parent):
    def theValue(self):
      return value
  return IAmAnObjectToo

Klass = makeMeANewClass(str, "fred")
o = Klass()
print isinstance(o, str)  # => True
print o.theValue()        # => fred

score 1 · Accepted Answer

bashプログラミング機能ではありませんが、またはで Python を使用する場合に役立ちshell scriptsます。

python -c"import os; print(os.getcwd());"

こちらのpython ドキュメントを参照してください。より長い Python スクリプトを作成する際の追加の注意点については、このディスカッションで確認できます。

score 1 · Accepted Answer

Python の位置とキーワードの展開は、保存されたリストからだけでなく、オンザフライで使用できます。

l=lambda x,y,z:x+y+z
a=1,2,3
print l(*a)
print l(*[a[0],2,3])

通常、次のような場合により便利です。

a=[2,3]
l(*(a+[3]))

score 1 · Accepted Answer

map 関数と reduce 関数を使用した mapreduce

この方法で簡単な sumproduct を作成します。

def sumprod(x,y):
    return reduce(lambda a,b:a+b, map(lambda a, b: a*b,x,y))

例：

In [2]: sumprod([1,2,3],[4,5,6])
Out[2]: 32

score 1 · Accepted Answer

>>> x=[1,1,2,'a','a',3]
>>> y = [ _x for _x in x if not _x in locals()['_[1]'] ]
>>> y
[1, 2, 'a', 3]

"locals()['_[1]']" は、作成中のリストの「秘密の名前」です。ビルド中のリストの状態がその後のビルドの決定に影響する場合に非常に便利です。

score 0 · Accepted Answer

オンデマンドで関数kwargsを作成できます。

kwargs = {}
kwargs[str("%s__icontains" % field)] = some_value
some_function(**kwargs)

pythonは文字列ではないと文句を言うので、str（）呼び出しはどういうわけか必要です。理由はわかりません;）これをDjangosオブジェクトモデル内の動的フィルターに使用します。

result = model_class.objects.filter(**kwargs)

score 0 · Accepted Answer

これは、タイプエラーをデバッグするときに使用する便利な関数です。

def typePrint(object):
    print(str(object) + " - (" + str(type(object)) + ")")

たとえば、入力の後にタイプを出力するだけです。

>>> a = 101
>>> typePrint(a)
    101 - (<type 'int'>)

score 0 · Accepted Answer

0

文字列を掛けて繰り返す

print "SO"*5

与える

SOSOSOSOSO

于 2011-05-25T10:47:42.427 に答える

score 0 · Accepted Answer

reduce と operator を使用したクールな機能。

>>> from operator import add,mul
>>> reduce(add,[1,2,3,4])
10
>>> reduce(mul,[1,2,3,4])
24
>>> reduce(add,[[1,2,3,4],[1,2,3,4]])
[1, 2, 3, 4, 1, 2, 3, 4]
>>> reduce(add,(1,2,3,4))
10
>>> reduce(mul,(1,2,3,4))
24

score 0 · Accepted Answer

コマンド.getoutput

に直接出力する関数の出力を取得したい場合、stdoutまたはstderrの場合のようos.systemにcommands.getoutputが助けになります。モジュール全体は素晴らしいものでできています。

>>> print commands.getoutput('ls')
myFile1.txt    myFile2.txt    myFile3.txt    myFile4.txt    myFile5.txt
myFile6.txt    myFile7.txt    myFile8.txt    myFile9.txt    myFile10.txt
myFile11.txt   myFile12.txt   myFile13.txt   myFile14.txt   module.py

score 0 · Accepted Answer

スクリプト (および doctest 文字列) の対話型デバッグ

これはそれほど広く知られているとは思いませんが、次の行を python スクリプトに追加します。

import pdb; pdb.set_trace()

PDB デバッガーがポップアップし、コード内のその時点で実行カーソルが表示されます。さらにあまり知られていないのは、doctest で同じ行を使用できることです。

"""
>>> 1 in (1,2,3)   
Becomes
>>> import pdb; pdb.set_trace(); 1 in (1,2,3)
"""

その後、デバッガーを使用して doctest 環境をチェックアウトできます。各行は自律的に実行されるため、実際には doctest をステップ実行することはできませんが、doctest グロブと環境をデバッグするための優れたツールです。

score 0 · Accepted Answer

Python 2 では、式をバッククォートで囲むことにより、式の文字列表現を生成できます。

 >>> `sorted`
'<built-in function sorted>'

これは python 3.X ではなくなりました。

score -2 · Accepted Answer

for line in open('foo'):
    print(line)

これは、次のものと同等です (ただし、より優れています)。

f = open('foo', 'r')
for line in f.readlines():
   print(line)
f.close()

score -2 · Accepted Answer

-2

is_ok() and "Yes" or "No"

于 2008-11-27T03:24:04.943 に答える

score -5 · Accepted Answer

「こんにちは」を作成する代わりに、それを受け入れるIDE（IDLE、Editra、IEPなど）でオートコンプリートをアクティブにします。(そして TAB を押します)、IDE でごまかすことができます。ただ hi を作成してください". (そして TAB を熱します) (ご覧のとおり、最初に一重引用符はありません)。 : を追加して Enter キーを押すと、インデントが直接追加されます。変更されるかどうかはわかりませんが、これはもはやヒントではありません :)

score -9 · Accepted Answer

-9

中かっこ

def g():
    print 'hi!'

def f(): (
    g()
)

>>> f()
hi!

于 2010-05-13T20:23:55.223 に答える

python - Python の隠れた機能

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

191 に答える 191

比較演算子の連鎖:

完全に動的な方法で新しいタイプを作成する

辞書にはget（）メソッドがあります

記述子

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

名前付き書式

pow() は (x ** y) % z も効率的に計算できます。

異なる開始インデックスで列挙する

構築中のリスト内包表記を参照しています...

ゼロ引数と可変引数のラムダ

タプルを組み込み関数に渡す

sys.modules の操作

サブクラスのプロパティ (記述子として定義) の拡張

ボーグパターン

namedtuple はタプルです

getattr3番目のパラメータを取ります

プライベートメソッドとデータの隠蔽（カプセル化）

Python には「プライベート」変数があります

spam標準の Pythonのモジュール

Related

Reference

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

`getattr`3番目のパラメータを取ります

`spam`標準の Pythonのモジュール