9.1. 名前とオブジェクトについて¶

オブジェクトはそれぞれ固有の存在ですが、同じオブジェクトに複数のスコープから複数の名前を束縛できます。 ほかの言語では、これをエイリアス (別名) と呼びます。 Python を学び始めたばかりでは、この仕組みの重要性は分かりにくいかもしれません。 数値、文字列、タプルのようなイミュータブル (変更できない) な基本型を扱うときは、気にしなくても問題ありません。 一方、リストや辞書など多くの型のミュータブル (変更できる) なオブジェクトを扱うコードでは、 エイリアスによって意外な動作が起こることがあります。 エイリアスはいくつかの点でポインタのように振る舞うため、通常はその性質をプログラムに役立てられます。 例えば、オブジェクトを渡す際に実装上渡されるのはポインタだけなので、処理の負担は小さくなります。 また、関数が引数として受け取ったオブジェクトを変更すると、呼び出し側からもその変更が見えます。 このため、Pascal のように引数の渡し方を 2 種類用意する必要がありません。

9.2. Python のスコープと名前空間¶

クラスを紹介する前に、Python のスコープの規則について説明する必要があります。 クラス定義は名前空間を巧みに利用するので、その動作を十分に理解するには、スコープと名前空間の仕組みを知っておく必要があります。 なお、この知識は高度なプログラミングを行う Python プログラマーなら誰にとっても役立ちます。

まず定義から始めましょう。

名前空間 (namespace) とは、名前からオブジェクトへの対応付け (mapping) です。ほとんどの名前空間は、現状では Python の辞書として実装されていますが、そのことは通常は (パフォーマンス以外では) 目立つことはないし、将来は変更されるかもしれません。名前空間の例には、組込み名の集合 (abs() 等の関数や組込み例外名)、モジュール内のグローバルな名前、関数を呼び出したときのローカルな名前があります。オブジェクトの属性からなる集合もまた、ある意味では名前空間です。名前空間について知っておくべき重要なことは、異なった名前空間にある名前の間には全く関係がないということです。例えば、二つの別々のモジュールの両方で関数 maximize という関数を定義することができ、定義自体は混同されることはありません --- モジュールのユーザは名前の前にモジュール名をつけなければなりません。

ところで、 属性 という言葉は、ドットに続く名前すべてに対して使っています --- 例えば式 z.real で、 real はオブジェクト z の属性です。厳密にいえば、モジュール内の名前に対する参照は属性の参照です。式 modname.funcname では、 modname はあるモジュールオブジェクトで、 funcname はその属性です。この場合には、モジュールの属性とモジュールの中で定義されているグローバル名の間には、直接的な対応付けがされます。これらの名前は同じ名前空間を共有しているのです！ [1]

属性は読取り専用にも、書込み可能にもできます。書込み可能であれば、属性に代入することができます。モジュール属性は書込み可能で、 modname.the_answer = 42 と書くことができます。書込み可能な属性は、 del 文で削除することもできます。例えば、 del modname.the_answer は、 modname で指定されたオブジェクトから属性 the_answer を除去します。

名前空間は様々な時点で作成され、その寿命も様々です。組み込みの名前が入った名前空間は Python インタプリタが起動するときに作成され、決して削除されることはありません。モジュールのグローバルな名前空間は、モジュール定義が読み込まれたときに作成されます。通常、モジュールの名前空間は、インタプリタが終了するまで残ります。インタプリタのトップレベルで実行された文は、スクリプトファイルから読み出されたものでも対話的に読み出されたものでも、 __main__ という名前のモジュールの一部分であるとみなされるので、独自の名前空間を持つことになります。 (組み込みの名前は実際にはモジュール内に存在します。そのモジュールは builtins と呼ばれています。)

関数のローカルな名前空間は、関数が呼び出されたときに作成され、関数から戻ったときや、関数内で例外が送出され、かつ関数内で処理されなかった場合に削除されます。 (実際には、忘れられる、と言ったほうが起きていることをよく表しています。) もちろん、再帰呼出しのときには、各々の呼び出しで各自のローカルな名前空間があります。

スコープ (scope) とは、ある名前空間が直接アクセスできるような、 Python プログラムのテキスト上の領域です。 "直接アクセス可能" とは、修飾なしに (訳注: spam.egg ではなく単に egg のように) 名前を参照した際に、その名前空間から名前を見つけようと試みることを意味します。

スコープは静的に決定されますが、動的に使用されます。実行中はいつでも、直接名前空間にアクセス可能な、3つまたは4つの入れ子になったスコープがあります:

• 最初に探される、最も内側のスコープは、ローカルな名前を持っています。

• 外側の(enclosing)関数のスコープは、近いほうから順に探され、ローカルでもグローバルでもない名前を持っています。

• 最後から 2 番目のスコープは現在のモジュールのグローバルな名前を持っています。

• 一番外側の(最後に検索される)スコープはビルトイン名を持っています。

名前を global と宣言すると、その名前への参照と代入はすべて、モジュールのグローバル名を持つ最後から 2 番目のスコープで直接行われます。 最も内側のスコープより外側にある変数を再束縛するには、nonlocal 文を使えます。 こうした外側の変数は、nonlocal と宣言しない限り読み出し専用です。 代入しようとすると、最も内側のスコープに同名の 新しい ローカル変数が作られ、外側の変数は変わりません。

通常、ローカルスコープは (プログラムテキスト上の) 現在の関数のローカルな名前を参照します。関数の外側では、ローカルスコープはグローバルな名前空間と同じ名前空間、モジュールの名前空間を参照します。クラス定義では、ローカルスコープの中にもう一つ名前空間が置かれます。

スコープはテキスト上で決定されていると理解することが重要です。モジュール内で定義される関数のグローバルなスコープは、関数がどこから呼び出されても、どんな別名をつけて呼び出されても、そのモジュールの名前空間になります。反対に、実際の名前の検索は実行時に動的に行われます --- とはいえ、言語の定義は、"コンパイル" 時の静的な名前解決の方向に進化しているので、動的な名前解決に頼ってはいけません！ (事実、ローカルな変数は既に静的に決定されています。)

global 文や nonlocal 文が有効でない場合、 Python では名前への代入は常に最も内側のスコープで行われます。 代入はデータをコピーせず、名前をオブジェクトに束縛するだけです。 削除も同様で、del x はローカルスコープの名前空間から x の束縛を削除します。 新しい名前を導入する操作はすべてローカルスコープを使います。 例えば import 文や関数定義は、モジュール名や関数名をローカルスコープで束縛します。

global 文を使うと、特定の変数がグローバルスコープに存在し、そこで再束縛されることを指示できます。 nonlocal 文は、特定の変数が外側のスコープに存在し、そこで再束縛されることを指示します。

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

9.3. クラス初見¶

クラスでは、新しい構文を少しと、三つの新たなオブジェクト型、そして新たな意味付けをいくつか取り入れています。

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass()

def __init__(self):
    self.data = []

x = MyClass()

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

x.counter = 1
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter)
del x.counter

x.f()

xf = x.f
while True:
    print(xf())

class Dog:

    kind = 'canine'         # 全インスタンスで共有されるクラス変数

    def __init__(self, name):
        self.name = name    # インスタンスごとに固有のインスタンス変数

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # すべての犬で共有
'canine'
>>> e.kind                  # すべての犬で共有
'canine'
>>> d.name                  # d 固有
'Fido'
>>> e.name                  # e 固有
'Buddy'

class Dog:

    tricks = []             # クラス変数の間違った使用

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # 意図せず すべての犬で共有
['roll over', 'play dead']

class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # 犬ごとに新しい空リストを作る

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

9.4. いろいろな注意点¶

インスタンスとクラスに同じ名前の属性がある場合、属性の検索ではインスタンス側が優先されます。

>>> class Warehouse:
...    purpose = 'storage'
...    region = 'west'
...
>>> w1 = Warehouse()
>>> print(w1.purpose, w1.region)
storage west
>>> w2 = Warehouse()
>>> w2.region = 'east'
>>> print(w2.purpose, w2.region)
storage east

データ属性は、メソッドからも、オブジェクトの通常の利用者 (「クライアント」) からも参照できます。 つまり、クラスを使って純粋な抽象データ型を実装することはできません。 実際、Python にはデータの隠蔽を強制する仕組みがなく、すべて規約に基づいています。 (一方、C で書かれた Python の実装では、必要に応じて実装の詳細を完全に隠し、オブジェクトへのアクセスを制御できます。 C で書く Python の拡張ではこの仕組みを使えます。)

クライアントはデータ属性を注意して使うべきです。 データ属性を書き換えると、メソッドが維持する不変条件を壊す可能性があります。 ただし、名前の衝突を避ければ、クライアントはメソッドの正常な動作に影響を与えずに、インスタンスオブジェクトへ独自のデータ属性を追加できます。 ここでも、名前付けの規約を使うと多くの問題を避けられます。

メソッドの中から、データ属性を (または別のメソッドも！) 参照するための短縮された記法はありません。私は、この仕様がメソッドの可読性を高めていると感じています。あるメソッドを眺めているときにローカルな変数とインスタンス変数をはっきり区別できるからです。

メソッドの最初の引数は self と呼ぶことが多いです。 これは単なる慣習であり、self という名前自体は Python にとって特別な意味を持ちません。 ただし、この慣習に従わないと、他の Python プログラマーにとってコードが読みにくくなる可能性があります。 また、この慣習に依存する クラスブラウザ (class browser) プログラムが書かれることも考えられます。

クラス属性である関数オブジェクトはいずれも、そのクラスのインスタンスのためのメソッドを定義しています。関数定義は、テキスト上でクラス定義の中に入っている必要はありません。関数オブジェクトをクラスのローカルな変数の中に代入するのも OK です。例えば以下のコードのようにします:

# クラス外で定義された関数
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1

    def g(self):
        return 'hello world'

    h = g

これで、 f 、 g 、および h は、すべて C の属性であり関数オブジェクトを参照しています。従って、これらは、すべて C のインスタンスのメソッドとなります --- h は g と全く等価です。これを実践しても、大抵は単にプログラムの読者に混乱をもたらすだけなので注意してください。

メソッドは、 self 引数のメソッド属性を使って、他のメソッドを呼び出すことができます:

class Bag:
    def __init__(self):
        self.data = []

    def add(self, x):
        self.data.append(x)

    def addtwice(self, x):
        self.add(x)
        self.add(x)

メソッドは通常の関数と同様にグローバル名を参照できます。 メソッドのグローバルスコープは、その定義を含むモジュールです (クラスがグローバルスコープになることはありません)。 メソッドでグローバルデータを使う適切な理由はまれですが、グローバルスコープには妥当な用途が数多くあります。 例えば、グローバルスコープにインポートした関数やモジュール、そのスコープで定義した関数やクラスは、メソッドからも使えます。 通常、そのメソッドを含むクラス自体もこのグローバルスコープで定義されています。 次の節では、メソッドが自身のクラスを参照したくなる理由を見ていきます。

個々の値はオブジェクトなので、 クラス (型 とも言います) を持っています。それは object.__class__ に保持されています。

9.5. 継承¶

言うまでもなく、継承の概念をサポートしない言語機能は "クラス" と呼ぶに値しません。派生クラス (derived class) を定義する構文は次のようになります:

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

基底クラス (base class) の名前 BaseClassName は、派生クラス定義の入っているスコープからアクセスできる名前空間で定義されていなければなりません。基底クラス名のかわりに任意の式を入れることもできます。これは次の例のように、基底クラスが別モジュールで定義されているときに便利なことがあります:

class DerivedClassName(modname.BaseClassName):

派生クラス定義の実行は、基底クラスの場合と同じように進められます。クラスオブジェクトが構築される時、基底クラスが記憶されます。記憶された基底クラスは、属性参照を解決するために使われます。要求された属性がクラスに見つからなかった場合、基底クラスに検索が進みます。この規則は、基底クラスが他の何らかのクラスから派生したものであった場合、再帰的に適用されます。

派生クラスのインスタンス化では、特別なことは何もありません。 DerivedClassName() はクラスの新たなインスタンスを生成します。メソッドの参照は次のようにして解決されます。まず対応するクラス属性が検索されます。検索は、必要に応じ、基底クラス連鎖を下って行われ、検索の結果として何らかの関数オブジェクトがもたらされた場合、メソッド参照は有効なものとなります。

派生クラスは基底クラスのメソッドを上書き (override) することができます。メソッドは同じオブジェクトの別のメソッドを呼び出す際に何ら特殊な権限を持ちません。このため、ある基底クラスのメソッドが、同じ基底クラスで定義されているもう一つのメソッド呼び出しを行っている場合、派生クラスで上書きされた何らかのメソッドが呼び出されることになるかもしれません。 (C++ プログラマへ: Python では、すべてのメソッドは事実上 virtual です。)

派生クラスで上書きしているメソッドでは、基底クラスの同名のメソッドを置き換えるのではなく、拡張したいのかもしれません。基底クラスのメソッドを直接呼び出す簡単な方法があります。単に BaseClassName.methodname(self, arguments) を呼び出すだけです。この仕様は、場合によってはクライアントでも役に立ちます。 (この呼び出し方が動作するのは、基底クラスがグローバルスコープの BaseClassName という名前でアクセスできるときだけです。)

Python には継承に関係する 2 つの組み込み関数があります:

• isinstance() を使うとインスタンスの型が調べられます。 isinstance(obj, int) は obj.__class__ が int や int の派生クラスの場合に限り True になります。

• issubclass() を使うとクラスの継承関係が調べられます。 bool は int のサブクラスなので issubclass(bool, int) は True です。しかし、 float は int のサブクラスではないので issubclass(float, int) は False です。

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

9.6. プライベート変数¶

オブジェクトの中からしかアクセス出来ない "プライベート" インスタンス変数は、 Python にはありません。しかし、ほとんどの Python コードが従っている慣習があります。アンダースコアで始まる名前 (例えば _spam) は、 (関数であれメソッドであれデータメンバであれ) 非 public なAPIとして扱います。これらは、予告なく変更されるかもしれない実装の詳細として扱われるべきです。

クラスのプライベートメンバは、サブクラスで定義された名前との衝突を避けるのに役立ちます。 この用途のために、Python は名前マングリング (name mangling) という限定的な仕組みを備えています。 __spam のように、先頭に 2 個以上、末尾に 1 個以下のアンダースコアを持つ識別子は、 テキスト上で _classname__spam に置き換えられます。 classname は現在のクラス名から先頭のアンダースコアを取り除いたものです。 対象の識別子がクラス定義内にあれば、構文上の位置に関係なくこの変換が行われます。

名前マングリングは、サブクラスが内部のメソッド呼び出しを壊さずにメソッドをオーバーライドするのに便利です。例えば:

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update   # 元の update() メソッドのプライベートコピー

class MappingSubclass(Mapping):

    def update(self, keys, values):
        # update() への新シグネチャ導入
        # しかし __init__() は壊さない
        for item in zip(keys, values):
            self.items_list.append(item)

上の例は、もし仮に MappingSubclass に __update 識別子を実装したとしてもきちんと動きます。 その理由は、 Mapping クラスではその識別子を _Mapping__update に、 MappingSubclass クラスでは _MappingSubclass__update にそれぞれ置き換えるからです。

名前マングリングの主な目的は、名前の衝突などの事故を防ぐことです。 プライベートとされている変数にも、アクセスしたり値を変更したりすることはできます。 デバッガなどでは、この性質が役立つこともあります。

exec() や eval() に渡したコードでは、呼び出し元のクラスは名前マングリングに使う現在のクラスとして扱われません。 これは global 文と同様で、効果が及ぶのは一緒にバイトコンパイルされるコードの範囲だけです。 getattr()、setattr()、delattr() を使う場合や、__dict__ を直接参照する場合も同じ制約があります。

9.7. 残りのはしばし¶

Pascal のレコードや C の構造体のように、名前付きのデータ項目をまとめる型があると便利なことがあります。 Python では、この用途に dataclasses を使うのが一般的です。

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    dept: str
    salary: int

>>> john = Employee('john', 'computer lab', 1000)
>>> john.dept
'computer lab'
>>> john.salary
1000

特定の抽象データ型を想定した Python コードには、その型と同じように動くメソッドを備えたクラスを代わりに使えることがよくあります。 例えば、ファイルオブジェクトから読み取ったデータをフォーマットする関数があるとします。 ファイルの代わりに文字列バッファからデータを読み取る read() と readline() メソッドを持つクラスを定義すれば、 そのインスタンスをこの関数の引数として渡せます。

Instance method objects にも属性があります。 m.__self__ はメソッド m() の属しているインスタンスオブジェクトで、m.__func__ はそのメソッドに対応する function object です。

9.8. イテレータ (iterator)¶

すでに気づいているでしょうが、 for 文を使うとほとんどのコンテナオブジェクトにわたってループを行うことができます:

for element in [1, 2, 3]:
    print(element)
for element in (1, 2, 3):
    print(element)
for key in {'one':1, 'two':2}:
    print(key)
for char in "123":
    print(char)
for line in open("myfile.txt"):
    print(line, end='')

こういう要素へのアクセス方法は明確で簡潔で使い易いものです。イテレータの活用は Python へ広く行き渡り、統一感を持たせています。裏では for 文はコンテナオブジェクトに対して iter() 関数を呼んでいます。関数は、コンテナの中の要素に1つずつアクセスする __next__() メソッドが定義されているイテレータオブジェクトを返します。これ以上要素が無い場合は、 __next__() メソッドは StopIteration 例外を送出し、その通知を受け for ループは終了します。組み込みの next() 関数を使って __next__() メソッドを直接呼ぶこともできます; この例は関数がどう働くのかを示しています:

>>> s = 'abc'
>>> it = iter(s)
>>> it
<str_iterator object at 0x10c90e650>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(it)
StopIteration

イテレータプロトコルの裏にある仕組みを観察していれば、自作のクラスにイテレータとしての振舞いを追加するのは簡単です。 __next__() メソッドを持つオブジェクトを返す __iter__() メソッドを定義するのです。クラスが __next__() メソッドを定義している場合、 __iter__() メソッドは単に self を返すことも可能です:

class Reverse:
    """シーケンスを後ろからまわるイテレータ."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
...     print(char)
...
m
a
p
s

9.9. ジェネレータ (generator)¶

ジェネレータ は、イテレータを作成するための簡潔で強力なツールです。ジェネレータは通常の関数のように書かれますが、何らかのデータを返すときには yield 文を使います。そのジェネレータに対して next() が呼び出されるたびに、ジェネレータは以前に中断した処理を再開します (ジェネレータは、全てのデータ値と最後にどの文が実行されたかを記憶しています)。以下の例を見れば、ジェネレータがとても簡単に作成できることがわかります:

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

>>> for char in reverse('golf'):
...     print(char)
...
f
l
o
g

ジェネレータでできることは、前の節で解説したクラスを使ったイテレータでも実現できます。ジェネレータの定義がコンパクトになるのは __iter__() メソッドと __next__() メソッドが自動で作成されるからです。

もう一つの重要な機能は、呼び出しと呼び出しの間にローカル変数と実行状態が自動的に保存されることです。 このため、self.index や self.data のようなインスタンス変数を使う方法よりも、関数を簡単に書け、コードもずっと明確になります。

メソッドを自動生成したりプログラムの実行状態を自動保存するほかに、ジェネレータは終了時に自動的に StopIteration を送出します。これらの機能を組み合わせると、通常の関数を書くのと同じ労力で、簡単にイテレータを生成できます。

9.10. ジェネレータ式¶

単純なジェネレータは、リスト内包表記の角括弧を丸括弧に替えたような構文で、短い式として書けます。 このジェネレータ式は、ジェネレータを関数の引数として渡し、その関数ですぐに使う場合に適しています。 ジェネレータを関数として定義するより用途は限られますが、短く書けます。 また、同じ内容のリスト内包表記よりメモリ使用量を抑えられることが多くなります。

例:

>>> sum(i*i for i in range(10))                 # 平方和
285

>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec))         # ドット積
260

>>> unique_words = set(word for line in page  for word in line.split())

>>> valedictorian = max((student.gpa, student.name) for student in graduates)

>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']

>>> x = [[1,2,3], [], [4, 5]]
>>> g = (*i for i in x)
>>> list(g)
[1, 2, 3, 4, 5]

多くの場合、ジェネレータ式は括弧で囲む必要があります。 ただし特例として、唯一の実引数として関数に渡す場合（前述の sum, set, max, list の例のように）は、ジェネレータ式を追加の括弧で囲む必要がありません。 すなわち、次の２つのコード片は意味的に等価です:

>>> f(x for x in y)
>>> f((x for x in y))

以下も同様です:

>>> f(*x for x in y)
>>> f((*x for x in y))

脚注