WTF Python!😱（Python、まじかよ！）後編

以下の文章はこちらのページを翻訳したものです。（後編）

https://github.com/satwikkansal/wtfpython

こちらのGitHubプロジェクト「What the f*ck Python! 😱」は、予想外のコードスニペットを通じてPythonを探求し、理解することを目指しています。多くの言語に翻訳されており、ウェブサイトやノートブック、コマンドラインツールを通じてインタラクティブに学ぶこともできます。

他のモード: Interactive Website | Interactive Notebook | CLI

Pythonは高水準な解釈型のプログラミング言語であり、開発者が快適に利用するために多くの機能を搭載しています。しかし、一見しただけでは理解し難いPythonスニペットの結果というのもあります。

こちらのワクワクするプロジェクトでは、直感に反するスニペットやPythonのあまり知られていない特徴の背後にある正確なメカニズムの解説を試みます。そこまで驚くものではないような例も取り上げられているかもしれませんが、Pythonの面白いところを理解しやすくしてくれます。このプロジェクトはプログラミング言語の奥深さを学ぶ良い手段です。読者であるあなたにとっても興味深いものになるでしょう。

経験豊富なPythonプログラマーの方は、一発で正解が分かるか、お試しください。いくつかの事象は以前に経験されているかもしれません。古い記憶を呼び戻すことができるでしょうか？

P.S. この記事を読むのが二度目以降だという方は、最新版ついてはこちらをご覧ください（最新の改訂で追加された例にはアスタリスクが付いています）。

それでは、始めましょう...

目次

• 例の構造
• 使い方
• 実例
  • セクション: 脳トレチャレンジ！
    • まずは大事なことから！
    • やっかいな文字列
    • 連鎖した操作には注意が必要
    • **is**演算子の落とし穴
    • ハッシュブラウニー
    • 本質的にはみんな同じ
    • 秩序の中の無秩序
    • トライし続けよう！
    • 何のためなのか
    • 評価時間の不一致
    • is notはis notではない
    • 一発でXが勝つ三目並べ！
    • シュレーディンガーの変数
    • 鶏が先か卵が先か
    • サブクラスのリレーション
    • メソッドの等価性と同一性
    • すべて真である
    • 驚きのコンマ
    • 文字列とバックスラッシュ
    • notの結び目
    • 半分のトリプルクォート文字列
    • ブール値の意外な挙動
    • クラス属性とインスタンス属性の違い
    • Noneの生成
    • returnからyield
    • Nan再帰性
    • 不変の変異
    • 外部スコープから消える変数
    • 謎のキー型変換
    • これは分かるかな？
    • 整数の文字列変換が限界を超えるとき
  • セクション: 滑りやすい斜面
    • イテレート中の辞書変更問題
    • しつこいdel操作
    • スコープ外の変数
    • イテレート中のリスト項目削除
    • イテレータのロッシー圧縮
    • ループ変数が漏れる！
    • デフォルトの可変引数に注意！
    • 例外処理の落とし穴
    • 同じオペランド、異なる結果！
    • クラススコープを無視する名前解決
    • 「銀行家の丸め」
    • 藁の中の針
    • Splitsies
    • ワイルドインポート
    • すべてsorted？
    • 真夜中は存在しない？
  • セクション: 隠された宝物たち！
    • Python、空を飛びたいんだけど…
    • なぜgotoなのか
    • カッコつけよう！
    • barryおじさん
    • Pythonでも知っていること：愛は複雑
    • 実は存在するんです！
    • Ellipsis
    • インピニティ
    • マングリングしよう
  • セクション: 見た目に惑わされるな
    • 行をスキップ？
    • テレポートテーション
    • 何かがおかしい...
  • セクション: さまざまなトピック
    • +=の方が早い
    • 巨大な文字列の作成
    • dict 検索の遅延
    • インスタンスdict の膨張
    • その他の小さな発見

例の構造

全ての例は以下のような構造で表示されています:

▶ 面白いタイトル

#コード
#面白いことが起きますよ...

出力（Pythonのバージョン）

>>> トリガーとなる文
何らかの予測できない出力

（場合によっては）ここで一言

💡 解説:

何が起きているのか、なぜ起きているのかの簡単な説明。

#コード
#必要あれば、解説のために例を追加

出力（Pythonのバージョン）

>>> トリガー # 何が起きているのかを簡単に理解するための例
#　正しい出力

注意：全ての例はPython 3.5.2の対話型インタープリタでテストされており、出力の前に特に指定がない限り、全てのPythonバージョンで動作するはずです。

使い方

作者の考える、それぞれの例を最大限に活用するための方法です。

• 例の最初のコードを注意深く読んでください。経験豊富なPythonプログラマーであれば、ほとんどの場合、次に何が起こるかを予測できるでしょう。

• 出力スニペットを読み、

  • あなたが期待するものと同じかどうかをご確認ください。
  • そのような状態になっている理由を正確に理解できていますか？
    • 答えが「いいえ」であれば（全く問題ありません）、深呼吸をして、解説を読んでください。
    • 答えが「はい」であれば、自分のことを褒めた上で、次の例に進んでください。

  P.S.：コマンドラインを使用してWTFPythonを読むこともできます。pypi packageを使用して、

  $ pip install wtfpython -U
  $ wtfpython
  

  ---

👀 例

セクション: 滑りやすい斜面

▶ イテレート中の辞書の変更

x = {0: None}

for i in x:
    del x[i]
    x[i+1] = None
    print(i)

出力 (Python 2.7- Python 3.5):

0
1
2
3
4
5
6
7

はい、ちょうど8回 実行されて停止しています。

💡 解説:

• 同時に編集する辞書のイテレーションはサポートされていません。
• 8回実行されるのは、その時点で辞書がリサイズされてより多くのキーを保持するためです（8つの削除エントリがあるので、リサイズが必要です）。これは実際には実装の詳細です。
• 削除されたキーがどのように扱われ、リサイズがいつ発生するかは、Pythonの実装によって異なる場合があります。
• Python 2.7 - Python 3.5以外のバージョンでは、8回とは異なる回数になるかもしれませんが（その数が実行のたびに変わることはありません）。これについての議論はこちらやこの StackOverflowスレッドをご参照ください。
• Python 3.7.6以降では、これを試みると RuntimeError: dictionary keys changed during iteration 例外が発生します。

▶ しつこい del 操作

class SomeClass:
    def __del__(self):
        print("Deleted!")

出力:
1.

>>> x = SomeClass()
>>> y = x
>>> del x # これは "Deleted!" を出力するはずです
>>> del y
Deleted

ようやく削除されました。最初の試みで x を削除したときに __del__ が呼ばれなかった理由は推測できましたか？この例にもっとひねりを加えましょう。

>>> x = SomeClass()
>>> y = x
>>> del x
>>> y # y が存在するか確認します
<__main__.SomeClass instance at 0x7f98a1a67fc8>
>>> del y # これも "Deleted!" を出力するはずです
>>> globals() # おっと。では、グローバル変数をすべて確認してみましょう
Deleted!
{'__builtins__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__package__': None, '__name__': '__main__', '__doc__': None}

はい。削除されました 😕

💡 解説:

• del x は直接 x.__del__() を呼び出しません。
• del x に遭遇すると、Pythonは名前 x を現在のスコープから削除し、参照されているオブジェクト x の参照カウントを1減らします。__del__() はオブジェクトの参照カウントがゼロになったときにのみ呼ばれます。
• 第二の出力スニペットで、__del__() が呼ばれなかったのは、対話型インタプリタでの前の文 (>>> y) が同じオブジェクトへの別の参照を作成したためです（具体的には、REPLで最後の None 以外の式の結果を参照する _ マジック変数がこれに該当します）。そのため、del y に遭遇したときに参照カウントがゼロになるのを防いでいました。
• globals（または非 None の結果になる何か）を呼び出すことで、_ が新しい結果を参照するようになり、既存の参照が削除されました。ここで参照カウントが0になり、"Deleted!" が出力されたのを見ることができます（ついに！）。

▶ スコープ外の変数

a = 1
def some_func():
    return a

def another_func():
    a += 1
    return a

def some_closure_func():
    a = 1
    def some_inner_func():
        return a
    return some_inner_func()

def another_closure_func():
    a = 1
    def another_inner_func():
        a += 1
        return a
    return another_inner_func()

出力:

>>> some_func()
1
>>> another_func()
UnboundLocalError: local variable 'a' referenced before assignment

>>> some_closure_func()
1
>>> another_closure_func()
UnboundLocalError: local variable 'a' referenced before assignment

💡 解説:

• スコープ内に変数を割り当てると、そのスコープにローカルとなります。したがって、another_func のスコープでは a がローカルになりますが、同じスコープ内で以前に初期化されていないため、エラーが発生します。

• another_func 内で外部スコープの変数 a を変更するには、global キーワードを使用する必要があります。

  def another_func()
      global a
      a += 1
      return a
  

出力:

>>> another_func()
2

• another_closure_func の another_inner_func のスコープでは、a がローカルになりますが、同じスコープ内で事前に初期化されていないため、エラーが発生します。

• another_inner_func 内で外部スコープの変数 a を変更するには、nonlocal キーワードを使用します。nonlocal 文は、最も近い外部スコープ（グローバルを除く）で定義された変数を参照するために使用されます。

  def another_func():
      a = 1
      def another_inner_func():
          nonlocal a
          a += 1
          return a
      return another_inner_func()
  

出力:

>>> another_func()
2

• キーワード global と nonlocal は、Pythonインタプリタに新しい変数を宣言せずに、対応する外部スコープでそれらを探すように指示します。
• Pythonでの名前空間とスコープ解決がどのように機能するかを学ぶためには、こちらの簡潔の素晴らしいガイドをご覧ください。

▶ イテレーション中のリストのアイテムの削除

list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
list_3 = [1, 2, 3, 4]
list_4 = [1, 2, 3, 4]

for idx, item in enumerate(list_1):
    del item

for idx, item in enumerate(list_2):
    list_2.remove(item)

for idx, item in enumerate(list_3[:]):
    list_3.remove(item)

for idx, item in enumerate(list_4):
    list_4.pop(idx)

出力:

>>> list_1
[1, 2, 3, 4]
>>> list_2
[2, 4]
>>> list_3
[]
>>> list_4
[2, 4]

出力が [2, 4] になる理由は分かりましたか？

💡 解説:

• イテレート中のオブジェクトを変更するのは良くないです。正しい方法は、オブジェクトのコピーをイテレートすることです。list_3[:] はまさにそれを行います。

>>> some_list = [1, 2, 3, 4]
>>> id(some_list)
139798789457608
>>> id(some_list[:]) # スライスされたリストに対して新しいオブジェクトを作成することに留意。
139798779601192

del、remove、popの違い:

• del var_name は、var_name のローカルまたはグローバル名前空間からのバインディングを削除します（そのため list_1 は影響を受けません）。
• remove は特定のインデックスではなく、最初に一致した値を削除し、値が見つからない場合は ValueError を発生させます。
• pop は特定のインデックスの要素を削除して返し、無効なインデックスが指定された場合は IndexError を発生させます。

なぜ出力が [2, 4] になるのか？:

• リストのイテレーションはインデックスごとに行われ、list_2 や list_4 から 1 を削除すると、リストの内容は [2, 3, 4] となります。残りの要素は下にシフトされます、つまり 2 はインデックス0に、3 はインデックス1になります。次のイテレーションはインデックス1を見ることになるので（これは 3 です）、2 は完全にスキップされます。リストシーケンスの他のすべての交互要素に対しても同じことが起こります。
• イテレーション中にリスト要素を削除すると何が起こるかを説明するStackOverflowのスレッドをご参照ください。
• Pythonの辞書に関する類似の例については、こちらのStackOverflowのスレッドも参考になります。

▶ イテレータのロッシー圧縮

>>> numbers = list(range(7))
>>> numbers
[0, 1, 2, 3, 4, 5, 6]
>>> first_three, remaining = numbers[:3], numbers[3:]
>>> first_three, remaining
([0, 1, 2], [3, 4, 5, 6])
>>> numbers_iter = iter(numbers)
>>> list(zip(numbers_iter, first_three))
[(0, 0), (1, 1), (2, 2)]
# ここまでは良い。残りは？
>>> list(zip(numbers_iter, remaining))
[(4, 3), (5, 4), (6, 5)]

numbers リストから要素 3 はどこに消えたのでしょうか？

💡 解説:

• Python ドキュメントにある zip 関数の概略的な実装は以下の通りです。

  
  def zip(*iterables):
      sentinel = object()
      iterators = [iter(it) for it in iterables]
      while iterators:
          result = []
          for it in iterators:
              elem = next(it, sentinel)
              if elem is sentinel: return
              result.append(elem)
          yield tuple(result)
  

• したがって、この関数は任意の数のiterableオブジェクトを取り込み、それらに対して next 関数を呼び出し、 result リストに各アイテムを追加し、いずれかのiterableが尽きると停止します。

• ここでの注意点は、任意のiterableが尽きた場合、result リストの既存の要素が破棄されることです。numbers_iter の 3 にもこれが起きました。

• 上記の処理を zip を使って正しく行う方法は以下の通りです。

  >>> numbers = list(range(7))
  >>> numbers_iter = iter(numbers)
  >>> list(zip(first_three, numbers_iter))
  [(0, 0), (1, 1), (2, 2)]
  >>> list(zip(remaining, numbers_iter))
  [(3, 3), (4, 4), (5, 5), (6, 6)]
  
  

• zipの最初の引数は、最も少ない要素を持つものであるべきです。

▶ ループ変数が漏れる！

for x in range(7):
    if x == 6:
        print(x, ': for x inside loop')
print(x, ': x in global')

出力:

6 : for x inside loop
6 : x in global

x はforループのスコープの外では定義されていませんでした…

# 今度は最初にxを初期化してみます
x = -1
for x in range(7):
    if x == 6:
        print(x, ': for x inside loop')
print(x, ': x in global')

出力:

6 : for x inside loop
6 : x in global

出力 (Python 2.x):

>>> x = 1
>>> print([x for x in range(5)])
[0, 1, 2, 3, 4]
>>> print(x)
4

出力 (Python 3.x):

>>> x = 1
>>> print([x for x in range(5)])
[0, 1, 2, 3, 4]
>>> print(x)
1

💡 解説:

• Pythonでは、forループは存在するスコープを使用し、定義されたループ変数を後に残します。これは、明示的にforループ変数をグローバル名前空間で定義した場合にも適用されます。この場合、既存の変数に再バインドします。

• リスト内包表記の例におけるPython 2.xとPython 3.xのインタープリターの出力の違いは、What’s New In Python 3.0の変更履歴にて解説されています。

  "リスト内包表記はもう [... for var in item1, item2, ...] の構文形式をサポートしていません。代わりに [... for var in (item1, item2, ...)] をご使用ください。また、リスト内包表記は異なるセマンティクスを持っていることにご注意ください。list() コンストラクタ内のジェネレータ式に対する構文糖に近いもので、特にループ制御変数はもはや周囲のスコープには漏れません。"

デフォルトの可変引数に注意！

def some_func(default_arg=[]):
    default_arg.append("some_string")
    return default_arg

出力:

>>> some_func()
['some_string']
>>> some_func()
['some_string', 'some_string']
>>> some_func([])
['some_string']
>>> some_func()
['some_string', 'some_string', 'some_string']

💡 解説:

Python関数のデフォルトの可変引数は、関数を呼び出すたびに本当に初期化されるわけではありません。代わりに、最近割り当てられた値がデフォルト値として使用されます。明示的に[]をsome_funcに引数として渡した場合、default_arg変数のデフォルト値は使用されないため、関数は期待通りの結果を返します。

def some_func(default_arg=[]):
    default_arg.append("some_string")
    return default_arg

出力:

>>> some_func.__defaults__ # これは関数のデフォルト引数値を示します
([],)
>>> some_func()
>>> some_func.__defaults__
(['some_string'],)
>>> some_func()
>>> some_func.__defaults__
(['some_string', 'some_string'],)
>>> some_func([])
>>> some_func.__defaults__
(['some_string', 'some_string'],)

可変引数によるバグを避けるための一般的な方法は、デフォルト値としてNoneを割り当て、後でその引数に対して値が関数に渡されたかどうかをチェックすることです。例:

def some_func(default_arg=None):
    if default_arg is None:
        default_arg = []
    default_arg.append("some_string")
    return default_arg

▶ 例外処理の落とし穴

some_list = [1, 2, 3]
try:
    # これは ``IndexError`` を発生させるはずです
    print(some_list[4])
except IndexError, ValueError:
    print("Caught!")

try:
    # これは ``ValueError`` を発生させるはずです
    some_list.remove(4)
except IndexError, ValueError:
    print("Caught again!")

出力 (Python 2.x):

Caught!

ValueError: list.remove(x): x not in list

出力 (Python 3.x):

  File "<input>", line 3
    except IndexError, ValueError:
                     ^
SyntaxError: invalid syntax

💡 解説:

複数の例外をexcept節に追加するには、最初の引数として丸括弧で囲ったタプルを渡す必要があります。2番目の引数はオプションで、提供された場合には発生した例外インスタンスにバインドされます。例、

some_list = [1, 2, 3]
try:
   # これは ``ValueError`` を発生させるはずです
   some_list.remove(4)
except (IndexError, ValueError), e:
   print("Caught again!")
   print(e)

出力 (Python 2.x):

Caught again!
list.remove(x): x not in list

出力 (Python 3.x):

  File "<input>", line 4
    except (IndexError, ValueError), e:
                                     ^
IndentationError: unindent does not match any outer indentation level

例外と変数をコンマで区切ることは非推奨であり、Python 3では機能しません。正しくはasを使用します。例、

some_list = [1, 2, 3]
try:
    some_list.remove(4)

except (IndexError, ValueError) as e:
    print("Caught again!")
    print(e)

出力

Caught again!
list.remove(x): x not in list

▶ 同じオペランド、異なる結果！

a = [1, 2, 3, 4]
b = a
a = a + [5, 6, 7, 8]

出力:

>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4]

a = [1, 2, 3, 4]
b = a
a += [5, 6, 7, 8]

出力:

>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4, 5, 6, 7, 8]

💡 解説:

• a += b は常に a = a + b と同じようには動作しません。クラスは op= 演算子を異なる方法で実装することもでき、リストはそうします。
• 式 a = a + [5,6,7,8] は新しいリストを生成し、aの参照をその新しいリストに設定しますが、bは変更されません。
• 式 a += [5,6,7,8] は実際には "extend" 関数にマップされ、その関数はリストに対して操作されるので、a と b は同じリストを指し続けますが、そのリストはその場で変更されます。

▶ クラススコープを無視する名前解決

x = 5
class SomeClass:
    x = 17
    y = (x for i in range(10))

出力:

>>> list(SomeClass.y)[0]
5

x = 5
class SomeClass:
    x = 17
    y = [x for i in range(10)]

出力 (Python 2.x):

>>> SomeClass.y[0]
17

出力 (Python 3.x):

>>> SomeClass.y[0]
5

💡 解説:

• クラス定義内にネストされたスコープは、クラスレベルでバインドされた名前を無視します。
• ジェネレータ式には独自のスコープがあります。
• Python 3.Xから、リスト内包表記も独自のスコープを持ちます。

▶ 「銀行家の丸め」

リストの中央の要素を取得する簡単な関数を実装してみましょう：

def get_middle(some_list):
    mid_index = round(len(some_list) / 2)
    return some_list[mid_index - 1]

Python 3.x:

>>> get_middle([1])  # よし
1
>>> get_middle([1,2,3])  # よし
2
>>> get_middle([1,2,3,4,5])  # え？
2
>>> len([1,2,3,4,5]) / 2  # よし
2.5
>>> round(len([1,2,3,4,5]) / 2)  # なんで？
2

Pythonによると2.5の四捨五入は2のようです。

💡 解説:

• これは浮動小数点の精度の問題ではなく、意図的な挙動なのです。Python 3.0から、round()は銀行家の丸めを使用しており、0.5の端数は最も近い偶数に丸められます：

>>> round(0.5)
0
>>> round(1.5)
2
>>> round(2.5)
2
>>> import numpy  # numpyも同じ結果を返します>>> numpy.round(0.5)
0.0
>>> numpy.round(1.5)
2.0
>>> numpy.round(2.5)
2.0

• これは、数値の端数を四捨五入する際に推奨される方法で、IEEE 754にも記載されています。ただし、これは通常学校で教えられる方法（ゼロから離れる方向への四捨五入）とは異なるため、「銀行家の丸め」はあまり一般的ではありません。実際、多くの人気のプログラミング言語（JavaScript、Java、C/C++、Ruby、Rustなど）では「銀行家の丸め」は使用されていません。そのため、Python独特の特徴として、端数の四捨五入に関しての混乱を招くことがあります。
• 詳しくは、round()関数のドキュメントやこのStackOverflowのスレッドをご参照ください。
• get_middle([1]) が1を返したのは、インデックスが round(0.5) - 1 = 0 - 1 = -1 と計算され、リストの最後の要素が返されたためです。

▶ 藁の中の針

経験豊富なPythonプログラマーで、以下のシナリオの1つ以上に遭遇していないという人は一人もいないでしょう。

x, y = (0, 1) if True else None, None

出力:

>>> x, y  # (0, 1)が期待される
((0, 1), None)

t = ('one', 'two')
for i in t:
    print(i)

t = ('one')
for i in t:
    print(i)

t = ()
print(t)

出力:

one
two
o
n
e
tuple()

ten_words_list = [
    "some",
    "very",
    "big",
    "list",
    "that"
    "consists",
    "of",
    "exactly",
    "ten",
    "words"
]

出力

>>> len(ten_words_list)
9

a = "python"
b = "javascript"

出力:

# アサーション失敗メッセージを持つassert文
>>> assert(a == b, "Both languages are different")
# AssertionErrorは発生しない

some_list = [1, 2, 3]
some_dict = {
  "key_1": 1,
  "key_2": 2,
  "key_3": 3
}

some_list = some_list.append(4)
some_dict = some_dict.update({"key_4": 4})

出力:

>>> print(some_list)
None
>>> print(some_dict)
None

def some_recursive_func(a):
    if a[0] == 0:
        return
    a[0] -= 1
    some_recursive_func(a)
    return a

def similar_recursive_func(a):
    if a == 0:
        return a
    a -= 1
    similar_recursive_func(a)
    return a

出力:

>>> some_recursive_func([5, 0])
[0, 0]
>>> similar_recursive_func(5)
4

💡 解説:

• 1について、期待される動作のための正しい文はx, y = (0, 1) if True else (None, None)です。

• 2について、期待される動作のための正しい文はt = ('one',)またはt = 'one',（コンマが抜けています）。そうでない場合、インタプリタはtをstrとみなし、文字ごとにイテレートします。

• ()は特別なトークンで、空のtupleを表します。

• 3では、おそらくすでに気づかれたかと思いますが、リストの5番目の要素（"that"）の後にコンマが抜けています。そのため、暗黙の文字列リテラル連結によって、

  >>> ten_words_list
  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
  

となります。

4番目のスニペットではAssertionErrorは発生しませんでした。なぜなら、個々の式a == bを主張するのではなく、全体のタプルを主張しているからです。以下のスニペットだとさらに分かりやすいでしょう。

>>> a = "python"
>>> b = "javascript"
>>> assert a == b
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
AssertionError

>>> assert (a == b, "Values are not equal")
<stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?

>>> assert a == b, "Values are not equal"
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
AssertionError: Values are not equal

• 5番目のスニペットに関しては、list.append、dict.update、list.sortなどのようにシーケンスやマッピングオブジェクトのアイテムを変更するほとんどのメソッドは、オブジェクトをその場で変更し、Noneを返します。これの背後にある理由は、操作がその場で行える場合にオブジェクトのコピーを作成することなくパフォーマンスを向上させるためです（こちらから引用）。
• 最後の例は明らかでしょうが、変更可能なオブジェクト（リストなど）は関数内で変更可能であり、イミュータブルな再代入（a -= 1）は値の変更ではありません。

これらの細かい点に気をつけることで、長期的にデバッグの労力を大幅に節約できます。

▶ Splitsies

>>> 'a'.split()
['a']

# 以下と同じ
>>> 'a'.split(' ')
['a']

# しかし
>>> len(''.split())
0

# 以下と同じではない
>>> len(''.split(' '))
1

💡 解説:

• 最初は、splitのデフォルト区切り文字が単一スペース ' ' であると考えるかもしれませんが、ドキュメントによると、

  sep が指定されていないか None の場合、異なる分割アルゴリズムが適用されます。連続する空白は単一の区切り文字とみなされ、文字列が先頭または末尾に空白を含んでいる場合、結果には空の文字列が含まれません。そのため、空の文字列や空白のみからなる文字列を None で分割すると [] が返されます。
  sep が与えられた場合、連続する区切り文字は一緒にグループ化されず、空の文字列を区切るものとみなされます（例えば、'1,,2'.split(',') は ['1', '', '2'] を返します）。指定された区切り文字で空の文字列を分割すると [''] が返されます。

• 以下の例で先頭と末尾の空白がどのように扱われるかを注意深く見ると、より分かりやすいです。

>>> ' a '.split(' ')
['', 'a', '']
>>> ' a '.split()
['a']
>>> ''.split(' ')
['']

▶ ワイルドインポート

# ファイル: module.py

def some_weird_name_func_():
    print("works!")

def _another_weird_name_func():
    print("works!")

出力

>>> from module import *
>>> some_weird_name_func_()
"works!"
>>> _another_weird_name_func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '_another_weird_name_func' is not defined

💡 解説:

• ワイルドカードインポートを使用しないことはよく推奨されます。その最も明白な理由の一つは、ワイルドカードインポートでは、アンダースコアで始まる名前がインポートされないことです。これによりランタイム中にエラーが発生する可能性があります。

• from ... import a, b, c の構文を使用していた場合、上記の NameError は発生しませんでした。

  >>> from module import some_weird_name_func_, _another_weird_name_func
  >>> _another_weird_name_func()
  works!
  

どうしてもワイルドカードインポートを使用したい場合は、__all__ リストをモジュール内で定義する必要があります。これはワイルドカードインポートを行った際に利用可能となる公開オブジェクトのリストを含むものです。

__all__ = ['_another_weird_name_func']

def some_weird_name_func_():
    print("works!")

def _another_weird_name_func():
    print("works!")

出力

>>> _another_weird_name_func()
"works!"
>>> some_weird_name_func_()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'some_weird_name_func_' is not defined

▶ すべてsorted？

>>> x = 7, 8, 9>>> sorted(x) == x
False
>>> sorted(x) == sorted(x)
True

>>> y = reversed(x)
>>> sorted(y) == sorted(y)
False

💡 解説:

• sorted メソッドは常にリストを返し、リストとタプルを比較するとPythonでは常に False を返します。

>>> [] == tuple()
False
>>> x = 7, 8, 9
>>> type(x), type(sorted(x))
(tuple, list)

• sorted とは異なり、reversed メソッドはイテレータを返します。なぜなら、ソートにはイテレータをその場で変更するか、追加のコンテナ（リスト）を使用する必要があるのに対し、逆順には単に最後のインデックスから最初のインデックスに向かってイテレートするだけで済むからです。
• したがって sorted(y) == sorted(y) の比較では、最初の sorted() の呼び出しでイテレータ y が消費され、次の呼び出しでは空のリストが返されます。

>>> x = 7, 8, 9
>>> y = reversed(x)
>>> sorted(y), sorted(y)
([7, 8, 9], [])

▶ 真夜中は存在しない？

from datetime import datetime

midnight = datetime(2018, 1, 1, 0, 0)
midnight_time = midnight.time()

noon = datetime(2018, 1, 1, 12, 0)
noon_time = noon.time()

if midnight_time:
    print("Time at midnight is", midnight_time)

if noon_time:
    print("Time at noon is", noon_time)

出力 (< 3.5):

('Time at noon is', datetime.time(12, 0))

真夜中の時間（Time at midnight）が表示されていません。

💡 解説:

Python 3.5より前では、datetime.time オブジェクトがUTCで真夜中を表している場合、そのブール値は False とみなされていました。if obj: 構文を使用して obj が None または「空」の同等物かどうかをチェックする場合、エラーが発生しやすいです。

セクション:隠された宝物たち！

このセクションでは、ほとんどの初心者が知らない、Pythonに関する興味深い特徴を取り上げていきます。

▶ Python、空を飛びたいんだけど…

では、これを試してみてください。

import antigravity

出力:
しー…秘密ですよ。

💡 解説:

• antigravity モジュールはPython開発者によってリリースされたいくつかのイースターエッグの内の一つです。
• import antigravity を実行すると、PythonについてのクラシックなXKCDコミックを表示するウェブブラウザが開きます。
• それだけではありません。実は、イースターエッグの中の別のイースターエッグもあります。コードを見ると、XKCDのジオハッシングアルゴリズムを実装すると主張する関数が定義されています。

▶ goto、でもなぜ？

from goto import goto, label
for i in range(9):
    for j in range(9):
        for k in range(9):
            print("I am trapped, please rescue!")
            if k == 2:
                goto .breakout # 深くネストされたループから抜け出す
label .breakout
print("Freedom!")

出力 (Python 2.3):

I am trapped, please rescue!
I am trapped, please rescue!
Freedom!

💡 解説:

• goto の動作するバージョンは、2004年4月1日のエイプリルフールのジョークとして発表されました。
• 現在のPythonバージョンにはこのモジュールは含まれていません。
• 動作はしますが、使用しないでください。Pythonに goto がない理由はこちら。

▶ カッコつけよう！

Pythonでスコープを示すために空白を使うのが好きでない人は、以下をインポートすることでC言語スタイルの {} を使うことができます。

from __future__ import braces

出力:

  File "some_file.py", line 1
    from __future__ import braces
SyntaxError: not a chance

「あれ？ブレースは？」と、失望された方はJavaをお使いください。さて、もう一つ驚くべきことですが、__future__ モジュールのコードにおいて SyntaxError がどこで発生するか見つけられますか？

💡 解説:

• __future__ モジュールは通常、Pythonの将来のバージョンからの機能を提供するために使用されます。しかし、この特定のコンテキストにおける "future" は、皮肉です。
• これは、この問題に関するコミュニティの感情に関するイースターエッグです。
• 実際のコードは future.c ファイルのここに存在します。
• CPythonコンパイラが future ステートメントに遭遇すると、通常のインポートステートメントとして扱う前に future.c の適切なコードを最初に実行します。

▶ Barryおじさん

出力 (Python 3.x)

>>> from __future__ import barry_as_FLUFL
>>> "Ruby" != "Python" # これは疑う余地がありません
  File "some_file.py", line 1
    "Ruby" != "Python"
              ^
SyntaxError: invalid syntax

>>> "Ruby" <> "Python"
True

それでは行きましょう。

💡 解説:

• これは、2009年4月1日に発表されたPEP-401に関連しています（今なら、どういう意味かお分かりでしょう）。

• PEP-401からの引用

  Python 3.0における != 不等号演算子はひどい間違いであり、指の痛みを誘発するものであったことが認識されたため、FLUFLは <> ダイアモンド演算子を唯一の綴りとして再導入する。

• Uncle BarryはPEPでさらに多くのことを共有しており、こちらで読むことができます。

• 対話的環境ではうまく機能しますが、Pythonファイル経由で実行すると SyntaxError が発生します（こちらを参照）。しかし、eval や compile 内でステートメントをラップすることで機能させることができます。

  from __future__ import barry_as_FLUFL
  print(eval('"Ruby" <> "Python"'))
  

▶ Pythonでも知っていること：愛は複雑

import this

お、これ（this）は何だ？this is love ❤️

出力:

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!

Zen of Pythonです！

>>> love = this
>>> this is love
True
>>> love is True
False
>>> love is False
False
>>> love is not True or False
True
>>> love is not True or False; love is love  # 愛は複雑だ
True

💡解説:

• Pythonの this モジュールは、The Zen of Python（PEP 20）のイースターエッグです。
• 興味のある方は、this.pyの実装をご確認ください。面白いことに、禅のコードは自身に違反しています（おそらく唯一のケースです）。
• love is not True or False; love is love という文に関しては、皮肉なことに自明です（もし分からないなら、is と is not 演算子に関する例をご覧ください）。

▶ 実は存在するんです！！

ループのための else 節。 以下は典型的な例です：

  def does_exists_num(l, to_find):
      for num in l:
          if num == to_find:
              print("存在します！")
              break
      else:
          print("存在しません")

出力:

>>> some_list = [1, 2, 3, 4, 5]
>>> does_exists_num(some_list, 4)
Exists!
>>> does_exists_num(some_list, -1)
Does not exist

例外処理における else 節。 例えば、

try:
    pass
except:
    print("Exception occurred!!!")
else:
    print("Try block executed successfully...")

出力:

Try block executed successfully...

💡 解説:

• ループの後の else 節は、すべての繰り返しの後に明示的な break がない場合にのみ実行されます。"nobreak" 節と考えることができます。
• try ブロックの後の else 節は、「完了節」とも呼ばれます。なぜなら try 文の else 節に到達するということは、tryブロックが実際に正常に完了したことを意味するからです。

▶ Ellipsis

def some_func():
    Ellipsis

出力

>>> some_func()
# 出力なし、エラーなし

>>> SomeRandomString
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'SomeRandomString' is not defined

>>> Ellipsis
Ellipsis

💡 解説:

• Pythonでは、Ellipsisはグローバルに利用可能な組み込みオブジェクトであり、...と同等です。

  >>> ...
  Ellipsis
  

省略記号はいくつかの目的で使用できます。

• まだ書かれていないコードのプレースホルダーとして（pass文と同様）
• スライス構文で、残りの方向の完全なスライスを表すために使用

>>> import numpy as np
>>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
array([
    [
        [0, 1],
        [2, 3]
    ],

    [
        [4, 5],
        [6, 7]
    ]
])

3次元配列 three_dimensional_array は配列の配列の配列です。内部の配列のすべての第2要素（インデックス 1）を出力したい場合は、省略記号を使用して前にある次元をバイパスできます。

>>> three_dimensional_array[:,:,1]
array([[1, 3],
   [5, 7]])
>>> three_dimensional_array[..., 1] # 省略記号を使用。
array([[1, 3],
   [5, 7]])

• これは任意の次元数で機能します。最初と最後の次元でスライスを選択し、中間の次元を無視することもできます（n_dimensional_array[firs_dim_slice, ..., last_dim_slice]）。
  • 型ヒントで型の一部だけを示すために使用（例：(Callable[..., int] や Tuple[str, ...]）。
  • 関数のデフォルト引数として省略記号を使用することもできます（"引数が渡されない"と"None値が渡される"のシナリオを区別したい場合）。

▶ インピニティ

（打ち間違えではありません。）

出力 (Python 3.x):

>>> infinity = float('infinity')
>>> hash(infinity)
314159
>>> hash(float('-inf'))
-314159

💡 解説:

• 無限のハッシュは10⁵ x πです。
• 面白いことに、Python 3では float('-inf') のハッシュは "-10⁵ x π" ですが、Python 2では "-10⁵ x e" です。

▶ マングリングしよう

class Yo(object):
    def __init__(self):
        self.__honey = True
        self.bro = True

出力:

>>> Yo().bro
True
>>> Yo().__honey
AttributeError: 'Yo' object has no attribute '__honey'
>>> Yo()._Yo__honey
True

class Yo(object):
    def __init__(self):
        # 今度は対称的なものを試してみましょう
        self.__honey__ = True
        self.bro = True

出力:

>>> Yo().bro
True

>>> Yo()._Yo__honey__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Yo' object has no attribute '_Yo__honey__'

なぜ Yo()._Yo__honey は機能したのでしょうか？

_A__variable = "Some value"

class A(object):
    def some_func(self):
        return __variable # まだどこにも初期化されていなません

出力:

>>> A().__variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute '__variable'

>>> A().some_func()
'Some value'

💡 解説:

• 名前のマングリングは、異なる名前空間間の命名衝突を避けるために使用されます。
• Pythonでは、__（ダブルアンダースコア、"dunder"とも呼ばれる）で始まり、一つ以上の末尾アンダースコアで終わらないクラスメンバー名は、クラス名の前に _NameOfTheClass を追加することで修正（マングリング）されます。
• したがって、最初のスニペットで __honey 属性にアクセスするには、前に _Yo を追加する必要がありました。これにより、他のクラスで定義された同じ名前の属性との衝突を防ぐことができます。
• では、なぜ2番目のスニペットでは機能しなかったのでしょうか？それは名前のマングリングが二重アンダースコアで終わる名前を除外するからです。
• 3番目のスニペットも名前のマングリングの結果です。return __variable のステートメント内の名前 __variable は _A__variable にマングリングされ、これは外部スコープで宣言した変数の名前と同じです。
• また、マングリングされた名前が255文字を超える場合は、切り捨てが行われます。

セクション:見た目に惑わされるな

▶ 行をスキップ？

出力:

>>> value = 11
>>> valuе = 32
>>> value
11

えっ？

注意: これを再現する最も簡単な方法は、上記のスニペットからステートメントをコピーしてファイル/シェルに貼り付けることです。

💡 解説:

一部の非西洋文字は英字アルファベットの文字と同一に見えますが、インタープリターによって異なるものと見なされます。

>>> ord('е') # キリル文字の 'e' (Ye)
1077
>>> ord('e') # ラテン文字の 'e'、英語で使用され、標準キーボードで入力
101
>>> 'е' == 'e'
False

>>> value = 42 # ラテン文字の e>>> valuе = 23 # キリル文字の 'e', Python 2.x インタープリターはここで `SyntaxError` を発生させる>>> value
42

組み込みの ord() 関数は文字のUnicode コードポイントを返し、キリル文字の 'e' とラテン文字の 'e' の異なるコード位置が上記の例の振る舞いを正当化します。

▶ テレポーテーション

# `pip install numpy` を先に実行
import numpy as np

def energy_send(x):
    # numpy配列を初期化
    np.array([float(x)])

def energy_receive():
    # 空のnumpy配列を返す
    return np.empty((), dtype=np.float).tolist()

出力:

>>> energy_send(123.456)
>>> energy_receive()
123.456

ノーベル賞はどこへ？

💡 解説:

• energy_send 関数で作成されたnumpy配列が返されないことにご注意ください。そのため、そのメモリスペースは再割り当て可能です。
• numpy.empty() は初期化せずに次の空きメモリスロットを返します。このメモリ位置はたまたまちょうど解放されたものと同じです（通常はそうですが、必ずしもそうではありません）。

▶ 何かがおかしい…

def square(x):
    """
    A simple function to calculate the square of a number by addition.
    """
    sum_so_far = 0
    for counter in range(x):
        sum_so_far = sum_so_far + x
  return sum_so_far

出力 (Python 2.x):

>>> square(10)
10

なぜ100ではないのでしょうか？

注: 再現できない場合は、シェル経由でファイル mixed_tabs_and_spaces.py を実行してみてください。

💡 解説:

• タブとスペースを混在させないでください！ return の直前の文字は "タブ" で、例の他の場所では "4スペース" の倍数でインデントされています。

• Pythonがタブをどのように扱うかは以下の通りです。

  まず、タブは左から右へと1から8のスペースに置き換えられ、置き換えを含めた総文字数が8の倍数となるようにされます<...>

• したがって、square 関数の最後の行の "タブ" は8つのスペースに置き換えられ、ループに入り込みます。

• Python 3は、このような場合に自動的にエラーを投げてくれるので親切です。

  出力 (Python 3.x):

  TabError: inconsistent use of tabs and spaces in indentation
  

セクション:さまざまなトピック

▶ += の方が速い

# "+", 三つの文字列を使って:
>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.25748300552368164
# "+=", 三つの文字列を使って:
>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.012188911437988281

💡 解説:

• 二つ以上の文字列を連結する場合、+= は + よりも速いです。なぜなら最初の文字列（s1 += s2 + s3 の場合の s1 など）が完全な文字列を計算する間に破壊されないからです。

▶ 巨大な文字列の作成

def add_string_with_plus(iters):
    s = ""
    for i in range(iters):
        s += "xyz"
    assert len(s) == 3*iters

def add_bytes_with_plus(iters):
    s = b""
    for i in range(iters):
        s += b"xyz"
    assert len(s) == 3*iters

def add_string_with_format(iters):
    fs = "{}"*iters
    s = fs.format(*(["xyz"]*iters))
    assert len(s) == 3*iters

def add_string_with_join(iters):
    l = []
    for i in range(iters):
        l.append("xyz")
    s = "".join(l)
    assert len(s) == 3*iters

def convert_list_to_string(l, iters):
    s = "".join(l)
    assert len(s) == 3*iters

出力:

# 結果の読みやすさのために ipython シェルで %timeit を使用して実行されました。
# 標準の python シェル/スクリプトでは timeit モジュールを使用することもできます。使用例は以下の通りです。
# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())

>>> NUM_ITERS = 1000
>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> l = ["xyz"]*NUM_ITERS
>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

イテレーション回数を10倍に増やしてみましょう。

>>> NUM_ITERS = 10000>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # 実行時間が線形に増加
1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # 二次的に増加
6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # 線形に増加
645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # 線形に増加
1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
>>> l = ["xyz"]*NUM_ITERS
>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # 線形に増加
86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

💡 解説:

• timeitや%timeitについては、リンク先で詳しい解説を読むことができます。これらはコードの実行時間を測定するために使用されます。

• 長い文字列の生成には + を使用しないでください — Pythonでは、str は不変なので、2つの文字列を連結するたびに、左右の文字列が新しい文字列にコピーされなければなりません。10文字の4つの文字列を連結する場合、40文字ではなく90文字（(10+10) + ((10+10)+10) + (((10+10)+10)+10)）をコピーすることになります。文字列の数とサイズが増えるにつれて、状況は二次的に悪化します（add_bytes_with_plus 関数の実行時間で正当化されています）。

• そのため、.format. または % 構文の使用が推奨されます（ただし、非常に短い文字列の場合は + よりもわずかに遅いです）。

• さらに良い方法は、既に内容がiterableオブジェクトの形で利用可能であれば、''.join(iterable_object)を使用することです。これは圧倒的に速いです。

• 前の例で議論された += の最適化のため、add_bytes_with_plus とは異なり、add_string_with_plus は実行時間の二次的な増加を示しませんでした。s += "xyz" の代わりに s = s + "x" + "y" + "z" であった場合、増加は二次的になります。

  def add_string_with_plus(iters): s = "" for i in range(iters): s = s + "x" + "y" + "z" assert len(s) == 3*iters
  >>> %timeit -n100 add_string_with_plus(1000)
  388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
  >>> %timeit -n100 add_string_with_plus(10000) # 実行時間の二次的な増加
  9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
  

• 巨大な文字列を形成し、フォーマットの方法が多すぎるのは、Zen of Pythonと対立しているようでもあります。以下引用。

  それを行う方法は一つだけであり、できればただ一つの明白な方法があるべきです。

▶ dict検索の遅延

some_dict = {str(i): 1 for i in range(1_000_000)}
another_dict = {str(i): 1 for i in range(1_000_000)}

出力:

>>> %timeit some_dict['5']
28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
>>> some_dict[1] = 1
>>> %timeit some_dict['5']
37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

>>> %timeit another_dict['5']
28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
>>> another_dict[1]  # Trying to access a key that doesn't exist
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 1
>>> %timeit another_dict['5']
38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

なぜ同じ検索が遅くなるのでしょうか？

💡 解説:

• CPythonには、すべてのキータイプ（str、int、任意のオブジェクト...）を扱う汎用の辞書検索関数と、strのみから構成される辞書の一般的なケース用の特化した関数があります。
• 特化した関数（CPythonのソースでは lookdict_unicode と命名されています）は、すべてのキー（検索されるキーを含む）が文字列であることを知っており、__eq__ メソッドを呼び出す代わりに、より高速かつ単純な文字列比較を使用してキーを比較します。
• dictインスタンスが非strキーでアクセスされると、将来の検索で汎用関数を使用するように変更されます。
• このプロセスは特定のdictインスタンスに対しては元に戻すことができず、キーが辞書に存在する必要もありません。そのため、失敗したルックアップを試みることでも同じ効果があります。

▶ インスタンスdictの膨張

import sys

class SomeClass:
    def __init__(self):
        self.some_attr1 = 1
        self.some_attr2 = 2
        self.some_attr3 = 3
        self.some_attr4 = 4

def dict_size(o):
    return sys.getsizeof(o.__dict__)

出力: (Python 3.8、他のPython 3バージョンは少し異なる場合があります)

>>> o1 = SomeClass()
>>> o2 = SomeClass()
>>> dict_size(o1)
104
>>> dict_size(o2)
104
>>> del o1.some_attr1
>>> o3 = SomeClass()
>>> dict_size(o3)
232
>>> dict_size(o1)
2

もう一度試してみましょう... 新しいインタープリターで:

>>> o1 = SomeClass()
>>> o2 = SomeClass()
>>> dict_size(o1)
104  # 予想通り
>>> o1.some_attr5 = 5>>> o1.some_attr6 = 6>>> dict_size(o1)
360
>>> dict_size(o2)
272
>>> o3 = SomeClass()
>>> dict_size(o3)
232

これらの辞書が膨張する原因は何でしょうか？また、新しく作成されたオブジェクトも膨張しているのはなぜでしょうか？

💡 解説:

• CPythonは複数の辞書で同じ"キー"オブジェクトを再利用することができます。これはPEP 412で追加され、特にインスタンスの辞書でメモリ使用量を削減することを目的としています - キー（インスタンス属性）はすべてのインスタンスに共通する傾向があります。
• この最適化はインスタンス辞書に完全に透過的ですが、特定の前提が破られると無効になります。
• キー共有辞書は削除をサポートしていません。インスタンス属性が削除されると、辞書は「共有解除」され、同じクラスの将来のすべてのインスタンスに対してキー共有が無効になります。
• さらに、辞書のキーがリサイズされた場合（新しいキーが挿入されたため）、それらは ただ一つの辞書 によって使用されている場合にのみ共有されます（これにより、最初に作成されたインスタンスの __init__ 内で多くの属性を追加しても「共有解除」が発生せず、共有が継続されます）。複数のインスタンスが存在する状態でリサイズが発生すると、同じクラスの将来のすべてのインスタンスに対してキー共有が無効になります：CPythonはインスタンスが同じ属性セットを使用しているかどうかを判断できなくなり、キーの共有を試みることを諦めます。
• プログラムのメモリフットプリントを低減させたい場合の小さなヒント：インスタンス属性を削除しないでください、そして __init__ 内ですべての属性を初期化してください！

▶ その他の小さな発見

• join() はリスト操作ではなく文字列操作です。（最初に使うときは直感に反するかもしれません）

  💡 説明: join() が文字列のメソッドなら、任意のイテラブル（リスト、タプル、イテレータ）に対して操作を行うことができます。リストのメソッドであれば、各タイプごとに別々に実装する必要があります。また、一般的な list オブジェクトのAPIに文字列専用のメソッドを設けることはあまり意味がありません。

• 奇妙に見えるが意味的には正しいステートメント：

  • [] = () は意味的に正しいステートメントです（空の tuple を空の list に展開しています）
  • 'a'[0][0][0][0][0] も意味的には正しいです。Pythonには他のCから派生した言語のようなキャラクターデータ型がないため、文字列から1文字を選択すると1文字の文字列が返されます。
  • 3 --0-- 5 == 8 と 5 == 5 は両方とも意味的に正しいステートメントで、結果は True になります。

• a が数値である場合、++a と a は有効なPythonステートメントですが、C、C++、Javaなどの言語での類似のステートメントとは同じような動作はしません。

  >>> a = 5
  >>> a
  5
  >>> ++a
  5
  >>> --a
  5
  

• 💡 解説:

  • Pythonの文法には ++ 演算子が存在しません。実際には2つの + 演算子があります。
  • ++a は +(+a) として解析され、結果として a になります。同様に、a のステートメントの出力も正当化できます。
  • Pythonにインクリメントとデクリメント演算子がない理由についてはこのStackOverflow スレッドで議論されています。

• セイウチ演算子については知っていますね。しかし、スペースインベーダー演算子については聞いたことがありますか？

  >>> a = 42
  >>> a -=- 1
  >>> a
  43
  

これは、別のインクリメント演算子と一緒に使われる代替のインクリメント演算子です。

>>> a +=+ 1
>>> a
>>> 44

• 💡 解説:

このジョークは Raymond Hettingerのツイートからきています。スペースインベーダー演算子は実際には間違った形式の a -= (-1) です。これは a = a - (- 1) と等価です。a += (+ 1) のケースも同様です。

• Pythonには文書化されていない逆含意演算子があります。

  >>> False ** False == True
  True
  >>> False ** True == False
  True
  >>> True ** False == True
  True
  >>> True ** True == True
  True
  

• 💡 解説: False と True を0と1に置き換えて計算すると、真理値表は逆含意演算子と等価になります。(出典)

• 演算子の話題ですから、行列乗算のための @ 演算子もあります（心配しないでください、今回は本物です）。

  >>> import numpy as np
  >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
  46
  

• 💡 解説: @ 演算子は、科学コミュニティを念頭に置いてPython 3.5で追加されました。任意のオブジェクトは __matmul__ マジックメソッドをオーバーロードしてこの演算子の動作を定義することができます。

• Python 3.8以降では、f'{some_var=} のような典型的なf文字列構文を使って素早くデバッグできます。例えば、

  >>> some_string = "wtfpython">>> f'{some_string=}'
  "some_string='wtfpython'"
  

Pythonでは関数内のローカル変数の格納に2バイトを使用します。理論的には、関数内に65536個の変数しか定義できないことを意味します。しかし、Pythonには2^16個以上の変数名を格納するための便利な内蔵ソリューションがあります。以下のコードは、65536個以上のローカル変数が定義されたときにスタックで何が起こるかを示しています（警告：このコードは約2^18行のテキストを出力するので、覚悟してください！）：

import dis
exec("""
def f():
   """ + """
   """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))

f()

print(dis.dis(f))

• 複数のPythonスレッドはPythonコードを同時に実行しません（聴き間違えではありませんよ！）。複数のスレッドを生成してPythonコードを同時に実行するのは直感的に思えるかもしれませんが、PythonのGlobal Interpreter Lockのため、実際にはスレッドを同じコアで交互に実行させているだけです。PythonのスレッドはIOバウンドタスクに適していますが、CPUバウンドタスクで実際の並列化を達成するには、Pythonのmultiprocessingモジュールを使用することを検討するかもしれません。

• print メソッドは値をすぐに出力しないことがあります。例えば、

  # ファイル some_file.py
  import time
  
  print("wtfpython", end="_")
  time.sleep(3)
  

• これは、end 引数のために、出力バッファが \n に遭遇するか、プログラムの実行が終了するまでフラッシュされないため、wtfpython が3秒後に出力されます。バッファをフラッシュするためには flush=True 引数を渡すことができます。

• 範囲外のインデックスを使ったリストのスライスはエラーを投げません。

  >>> some_list = [1, 2, 3, 4, 5]
  >>> some_list[111:]
  []
  

• iterableをスライスすると常に新しいオブジェクトが作られるわけではありません。例えば、

  >>> some_str = "wtfpython"
  >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
  >>> some_list is some_list[:] # 新しいオブジェクトが作られるのでFalseが予想される
  False
  >>> some_str is some_str[:] # 文字列は不変なので、新しいオブジェクトを作ることはあまり意味がないため、True。
  True
  

• Python 3では、int('١٢٣٤٥٦٧٨٩') は 123456789 を返します。PythonにおけるDecimal characters（十進数文字）には、数字文字と、十進数を形成するために使える全ての文字が含まれます。例えば、U+0660, ARABIC-INDIC DIGIT ZEROです。これに関連した面白い話があります。

• Python 3以降、数字リテラルはアンダースコア（_）を使って区切ることができます（読みやすさを向上させるため）。

>>> six_million = 6_000_000
>>> six_million
6000000
>>> hex_address = 0xF00D_CAFE
>>> hex_address
4027435774

• 'abc'.count('') == 4。ここに count メソッドのおおよその実装があり、これが事情をより明確にします。

  def count(s, sub):
      result = 0
      for i in range(len(s) + 1 - len(sub)):
          result += (s[i:i + len(sub)] == sub)
      return result
  

・この挙動は、オリジナルの文字列において長さ0のスライスと空の部分文字列（''）が一致するためです。