Python
PR

Pythonのクラスの基本|__init__・self・メソッド・継承を実例で解説

Pythonのクラスの基本|__init__・self・メソッド・継承を実例で解説
hr
記事内に商品プロモーションを含む場合があります

Python の入門書でつまずきやすいのがクラスです。class・__init__・self と見慣れない言葉が一度に出てくるうえ、書き方を少し間違えると、意味の分かりにくいエラーになります。

この記事では、クラスとインスタンスの関係を図で確かめたあと、__init__ と self、クラス変数、継承と super()、_ と __ の付いた名前までを、よくあるエラーを実際に起こしながら説明します。載せている出力は、Windows 11・Python 3.12.6 で実際に実行して確かめたものです。

クラスは「設計図」、インスタンスは「実物」

クラスは、「どんなデータを持ち、どんな操作ができるか」を決めた設計図です。設計図から作った 1 つ 1 つの実物をインスタンス(またはオブジェクト)と呼びます。たとえば「犬」というクラスを 1 つ書いておけば、そこから「ポチ」「ハチ」のように何匹でも犬を作れます。

インスタンスが持つデータ(名前・年齢など)を属性、インスタンスに対してできる操作(吠える・年を取るなど)をメソッドといいます。メソッドはクラスの中に書いた関数のことです。

class 文・__init__・self の基本

名前と年齢を持ち、吠えることと年を取ることができる犬のクラスを書いてみます。次のコードを sample.py という名前で保存します。

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name}:ワン!")

    def birthday(self):
        self.age += 1
        return self.age


pochi = Dog("ポチ", 3)
hachi = Dog("ハチ", 5)
print(pochi.name, pochi.age)
print(hachi.name, hachi.age)
pochi.bark()
hachi.bark()
print(pochi.birthday())
print(pochi.age, hachi.age)
print(type(pochi))

PowerShell で、sample.py を保存したフォルダーに移動してから実行します。

py sample.py
ポチ 3
ハチ 5
ポチ:ワン!
ハチ:ワン!
4
4 5
<class '__main__.Dog'>

上から順に、書いた部分の意味を説明します。

  • class Dog: … Dog という名前のクラスを作ります。クラス名は Dog・UserAccount のように単語の先頭を大文字にするのが慣習です(PEP 8)
  • def __init__(self, name, age): … インスタンスを作ったときに自動で呼ばれる特別なメソッドです。初期化(最初の値を入れること)に使います。名前の前後はアンダースコア 2 つずつです
  • self.name = name … 引数で受け取った name を、このインスタンスの属性 name として保存します
  • Dog("ポチ", 3) … クラスを関数のように呼ぶとインスタンスができます。渡した値は __init__ の name と age に入ります。self には何も渡しません
  • pochi.bark() … 「インスタンス.メソッド名()」でメソッドを呼びます。属性は pochi.name のようにかっこなしで読みます

pochi.birthday() で年を取ったのはポチだけで、ハチの年齢は 5 のままです。同じクラスから作っても、属性はインスタンスごとに別々に持っています。

左に Dog クラスの設計図があり、初期化で name と age を受け取ること、bark と birthday のメソッドを持つことが書かれている。設計図から矢印が 2 本出て、右の pochi(name はポチ、age は 3)と hachi(name はハチ、age は 5)の 2 つのインスタンスができ、それぞれが自分の属性を持っている。
図 1:1 つのクラスから作った 2 つのインスタンスは、別々の属性を持つ

self の正体は「メソッドを呼んだインスタンス」

self は、そのメソッドを呼び出したインスタンス自身です。pochi.bark() と書くと、Python は裏で Dog.bark(pochi) と同じ呼び出しをして、pochi を最初の引数 self に入れます。だから bark の中の self.name はポチの名前になります。実際に両方の書き方を試すと、同じ結果になります。

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

    def bark(self):
        print(f"{self.name}:ワン!")


pochi = Dog("ポチ")
pochi.bark()
Dog.bark(pochi)
ポチ:ワン!
ポチ:ワン!

Python の公式チュートリアル(9 章「クラス」)にも、x.f() は MyClass.f(x) と完全に同じで、メソッドの特別な点はインスタンスが関数の最初の引数として渡されることだと書かれています。

なお、チュートリアルによると self という名前は慣習で、Python にとって特別な意味はありません。読みやすさのため、必ず self と書きましょう。

self を書き忘れると TypeError

メソッドの定義で self を書き忘れるのは、いちばんよくある間違いです。

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

    def bark():
        print("ワン!")


pochi = Dog("ポチ")
pochi.bark()
Traceback (most recent call last):
  ...
TypeError: Dog.bark() takes 0 positional arguments but 1 was given

「Dog.bark() は引数を 0 個受け取るのに、1 個渡された」という意味です。呼び出し側では引数を 1 つも書いていないのに「1 個渡された」となるのは、先ほど説明したとおり、Python がインスタンス(pochi)を自動で最初の引数として渡しているためです。def bark(self): と直せば動きます。「takes N positional arguments but N+1 were given」のように 1 つずれていたら、まず self の書き忘れを疑うと覚えておくと早く直せます。

self. を付け忘れると AttributeError

__init__ の中で self. を付けずに代入すると、その値は __init__ の中だけの普通の変数(ローカル変数)になり、メソッドが終わると消えてしまいます。

class Dog:
    def __init__(self, name):
        name = name

    def bark(self):
        print(f"{self.name}:ワン!")


pochi = Dog("ポチ")
pochi.bark()
Traceback (most recent call last):
  ...
    print(f"{self.name}:ワン!")
             ^^^^^^^^^
AttributeError: 'Dog' object has no attribute 'name'

エラーは代入した __init__ ではなく bark で出るので、原因に気づきにくいのが厄介です。「has no attribute」と出たら、その属性に値を入れる行に self. が付いているかを確かめます。関数の中の変数がどこまで有効かは「Pythonの変数のスコープ入門」で詳しく解説しています。

インスタンス変数とクラス変数の違い

self.name = … のようにインスタンスごとに持つ変数をインスタンス変数、クラスの本体(メソッドの外)に書いた変数をクラス変数といいます。クラス変数は、そのクラスのすべてのインスタンスで共有されます。

class Dog:
    species = "イヌ"
    count = 0

    def __init__(self, name):
        self.name = name
        Dog.count += 1


pochi = Dog("ポチ")
hachi = Dog("ハチ")
print(pochi.species, hachi.species, Dog.species)
print(Dog.count)
Dog.species = "犬"
print(pochi.species, hachi.species)
pochi.species = "柴犬"
print(pochi.species, hachi.species, Dog.species)
print(pochi.__dict__)
print(hachi.__dict__)
イヌ イヌ イヌ
2
犬 犬
柴犬 犬 犬
{'name': 'ポチ', 'species': '柴犬'}
{'name': 'ハチ'}

ポイントは 3 つです。

  • インスタンスに無い名前は、クラスまで探しに行きます。だから Dog.species を変えると、両方の犬の値が変わります
  • pochi.species = "柴犬" とインスタンス経由で代入すると、クラス変数は書き換わらず、pochi にだけ同じ名前のインスタンス変数ができます。チュートリアルにも、同じ名前がインスタンスとクラスの両方にあればインスタンスが優先される、とあります
  • __dict__ を表示すると、そのインスタンス自身が持つ属性だけが見えます

count のように全体で 1 つだけ持ちたい値は、Dog.count += 1 とクラス名から書き換えます。self.count += 1 だと、インスタンス側に新しい変数ができるだけで、クラス変数は 0 のままでした。

class Counter:
    count = 0

    def up(self):
        self.count += 1


a = Counter()
b = Counter()
a.up()
a.up()
print(a.count, b.count, Counter.count)
2 0 0

落とし穴:クラス変数にリストを置くと全員で共有される

上の count では代入のたびに新しい数値が作られましたが、リストに append するときは代入ではなく「中身の変更」なので、インスタンス変数は作られません。その結果、クラス変数のリストを全員で書き換えてしまいます。

class Dog:
    tricks = []

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

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


pochi = Dog("ポチ")
hachi = Dog("ハチ")
pochi.add_trick("お手")
hachi.add_trick("おすわり")
print(pochi.tricks)
print(hachi.tricks)
print(pochi.tricks is hachi.tricks)
['お手', 'おすわり']
['お手', 'おすわり']
True

ポチにはお手、ハチにはおすわりを教えたつもりが、両方の犬が両方の芸を覚えています。is が True なので、2 匹がまったく同じリストを見ていることが分かります。公式チュートリアルでも、ほぼ同じ例が「クラス変数の誤った使い方」として紹介されています。犬ごとに別のリストを持たせるには、__init__ の中で作ります。

class Dog:
    def __init__(self, name):
        self.name = name
        self.tricks = []

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


pochi = Dog("ポチ")
hachi = Dog("ハチ")
pochi.add_trick("お手")
hachi.add_trick("おすわり")
print(pochi.tricks)
print(hachi.tricks)
['お手']
['おすわり']
左はクラス変数に置いた場合で、pochi と hachi の両方から 1 つの Dog.tricks に矢印が向かい、中身はお手とおすわりの両方になっている。右はインスタンス変数にした場合で、pochi はお手だけ、hachi はおすわりだけの別々の self.tricks を持っている。
図 2:クラス変数のリストは共有され、インスタンス変数のリストは別々になる

辞書(dict)や集合(set)など、中身を変えられる値でも同じことが起きます。引数の既定値に [] を書いたときにも似た共有が起きる点は「Pythonの浅いコピーと深いコピー」で解説しています。

継承:既存のクラスを引き継いで新しいクラスを作る

継承は、あるクラスの属性やメソッドを引き継いで、新しいクラスを作る仕組みです。引き継がれる元のクラスを親クラス(基底クラス)、新しく作るクラスを子クラス(派生クラス)といいます。class Dog(Animal): のように、かっこの中に親クラスを書きます。

メソッドのオーバーライド

子クラスで親と同じ名前のメソッドを書くと、子クラスのほうが使われます。これをオーバーライド(上書き)といいます。

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

    def speak(self):
        return "……"

    def introduce(self):
        print(f"{self.name}です。{self.speak()}")


class Dog(Animal):
    def speak(self):
        return "ワン!"


class Cat(Animal):
    def speak(self):
        return "ニャー"


for a in [Dog("ポチ"), Cat("タマ"), Animal("ななし")]:
    a.introduce()
ポチです。ワン!
タマです。ニャー
ななしです。……

Dog と Cat には __init__ も introduce も書いていませんが、親の Animal から引き継いでいるので使えます。introduce の中の self.speak() は、self が Dog なら Dog の speak、Cat なら Cat の speak を呼びます。共通の処理を親に 1 回だけ書き、違うところだけを子で書き換えられるのが継承の利点です。

super().__init__ の呼び忘れで AttributeError

子クラスに独自の属性(犬種など)を足したくて、子クラスにも __init__ を書いたとします。このとき、子の __init__ が親の __init__ を上書きするため、親の初期化は自動では実行されません。

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


class Dog(Animal):
    def __init__(self, name, breed):
        self.breed = breed


pochi = Dog("ポチ", "柴犬")
print(pochi.breed)
print(pochi.name)
柴犬
Traceback (most recent call last):
  ...
    print(pochi.name)
          ^^^^^^^^^^
AttributeError: 'Dog' object has no attribute 'name'

breed は入っていますが、親の __init__ で入れるはずだった name がありません。子の __init__ の中で super().__init__(name) を呼んで、親の初期化を実行させます。super() は「親クラス」を指す書き方で、オーバーライドしたほかのメソッドから親の処理を呼ぶときにも使えます。

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

    def describe(self):
        return f"名前:{self.name}"


class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def describe(self):
        return super().describe() + f"/犬種:{self.breed}"


pochi = Dog("ポチ", "柴犬")
print(pochi.name, pochi.breed)
print(pochi.describe())
print(isinstance(pochi, Dog), isinstance(pochi, Animal), isinstance(pochi, str))
print(type(pochi) == Animal)
print(issubclass(Dog, Animal), issubclass(Animal, Dog))
ポチ 柴犬
名前:ポチ/犬種:柴犬
True True False
False
True False

isinstance で「そのクラスのインスタンスか」を調べる

上のコードの後半では型を調べています。isinstance(pochi, Animal) が True になるとおり、子クラスのインスタンスは親クラスのインスタンスでもあると判定されます。一方、type(pochi) == Animal はクラスがぴったり同じかだけを見るので False です。issubclass(Dog, Animal) は「Dog は Animal の子クラスか」を調べます。

型によって処理を分けたいときは、通常は isinstance を使います。公式チュートリアルにも、bool は int の子クラスなので issubclass(bool, int) は True になる、という例があります。実際に isinstance(True, int) も True でした。

print するとアドレスのような文字が出る理由

自作クラスのインスタンスをそのまま print すると、<__main__.Cat object at 0x0000017BEFFA2EA0> のような表示になります。「__main__ モジュールの Cat クラスのオブジェクト」という意味で、0x の後ろは実行のたびに変わる識別用の数字です。中身が分からないのは、Python が「このクラスをどう文字にするか」を知らないためです。

__str__ という特別なメソッドを書くと、print したときの表示を決められます。

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

    def __str__(self):
        return f"犬の{self.name}"


print(Dog("ポチ"))
print([Dog("ポチ")])
犬のポチ
[<__main__.Dog object at 0x0000017BEFFA2EA0>]

ところが、リストに入れて print すると元の表示に戻りました。リストの中身の表示には、__str__ ではなく __repr__ という別のメソッドが使われるためです。__str__ と __repr__ の使い分けや、== で比べるための __eq__ などの特殊メソッドは「Pythonの特殊メソッド入門」で詳しく解説しています。

_ と __ で始まる名前(カプセル化の慣習)

中身を隠し、決まった操作だけで扱わせる考え方をカプセル化といいます。Python には Java のような private(外から触れない変数)はなく、名前の付け方で意図を伝えます。

  • _history(アンダースコア 1 つ)… 「内部用なので外から使わないでほしい」という目印。Python は何も制限しません
  • __balance(先頭にアンダースコア 2 つ)… 名前マングリング(名前の自動書き換え)が行われ、内部では _クラス名__balance という名前になります
class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self._history = []
        self.__balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("入金額は 1 円以上にしてください")
        self.__balance += amount
        self._history.append(amount)

    def balance(self):
        return self.__balance


acc = Account("田中", 1000)
acc.deposit(500)
print(acc.balance())
print(acc._history)
print(acc.__dict__)
print(acc._Account__balance)
print(acc.__balance)
1500
[500]
{'owner': '田中', '_history': [500], '_Account__balance': 1500}
1500
Traceback (most recent call last):
  ...
    print(acc.__balance)
          ^^^^^^^^^^^^^
AttributeError: 'Account' object has no attribute '__balance'. Did you mean: 'balance'?

クラスの中で書いた self.__balance は、__dict__ を見ると _Account__balance という名前で保存されています。外から acc.__balance と書いても見つからずエラーになりますが、acc._Account__balance と書けば読めてしまいます。公式チュートリアルにも、マングリングは主に事故を防ぐためのもので、private とみなされた変数にアクセスしたり変更したりすることはできる、と書かれています。パスワードなどを隠すセキュリティの仕組みではない点に注意してください。

マングリングの本来の目的は、子クラスで同じ名前を使っても親の変数を上書きしないようにすることです。普段は _ 1 つで十分です。値を変えるときにチェックを入れたいなら、メソッドを属性のように見せる @property も使えます(「Pythonのデコレーター入門」で解説)。

辞書で持つ場合との比較と、dataclass という選択肢

「名前と年齢」のようなデータは、辞書でも持てます。買い物かごを、辞書+関数で書いた場合とクラスで書いた場合を比べてみます。

def make_cart():
    return {"items": [], "total": 0}


def add_item(cart, name, price):
    cart["items"].append(name)
    cart["total"] += price


cart = make_cart()
add_item(cart, "ノート", 150)
add_item(cart, "ペン", 120)
print(cart)


class Cart:
    def __init__(self):
        self.items = []
        self.total = 0

    def add(self, name, price):
        if price < 0:
            raise ValueError("価格は 0 以上にしてください")
        self.items.append(name)
        self.total += price


c = Cart()
c.add("ノート", 150)
c.add("ペン", 120)
print(c.items, c.total)
{'items': ['ノート', 'ペン'], 'total': 270}
['ノート', 'ペン'] 270

結果は同じですが、クラスでは「データ」と「それを扱う処理」が 1 か所にまとまります。価格のチェックのような決まりも、必ず add を通るので守られやすくなります。

比べる点辞書クラス
書く量少ないclass 文と __init__ が必要
処理の置き場所別の関数に散らばりやすいメソッドとしてまとまる
名前の打ち間違い(読むとき)KeyError: 'nmae'AttributeError: 'User' object has no attribute 'nmae'
JSON との相互変換そのまま json.dumps できる辞書に変える手間がいる
向いている場面一時的なデータ、JSON の読み書き決まった形のデータと処理を何度も使う

主に値を入れておくためのクラスなら、dataclass を使うと __init__ や print 用の表示が自動で作られます。公式チュートリアルの 9 章でも、名前の付いたデータ項目をまとめるには dataclasses を使うのが慣用的だと紹介されています。書き方は「Pythonのdataclassの使い方」で解説しています。決まった選択肢だけを表すなら Enum もあります(「PythonのEnum(列挙型)の使い方」)。

よくある間違いとエラーの早見表

この記事の例と、追加で試したエラーをまとめます。

エラーメッセージよくある原因直し方
takes 0 positional arguments but 1 was givenメソッドの定義に self がないdef bark(self): にする
__init__() missing 1 required positional argumentインスタンスを作るときの引数が足りないDog("ポチ") のように渡す
object has no attribute 'name'代入に self. がない/super().__init__ を呼んでいないself.name = name、super().__init__(name)
'int' object is not callable属性とメソッドに同じ名前を付けた名前を分ける
(エラーにならず値が混ざる)クラス変数にリストや辞書を置いた__init__ の中で作る

4 行目は、__init__ で self.start に 0 を入れたクラスに start メソッドも書いた場合で、t.start() が数値の 0 を呼び出そうとしてエラーになりました。インスタンス変数がメソッドより先に見つかるためです。

よくある質問

__init__ は必ず書かないといけませんか?

いいえ。初期化することがなければ省略できます。上の Counter クラスのように __init__ がなくても Counter() でインスタンスを作れます。継承した子クラスで省略した場合は、親の __init__ が使われます。

関数だけで書くのと、クラスを使うのはどう使い分けますか?

買い物かごの例のように、関数の最初の引数がいつも同じデータ(cart)なら、クラスにまとめる合図です。それが self になります。入力から結果を返すだけの処理は、関数のままのほうが読みやすいです。

まとめ

  • クラスは設計図、インスタンスは実物。属性はインスタンスごとに別々に持つ
  • __init__ は作ったときに自動で呼ばれ、self は呼び出したインスタンス自身。メソッドの最初の引数には必ず self を書く
  • リストや辞書は、クラス変数ではなく __init__ の中で self.xxx = [] として作る
  • 子クラスで __init__ を書いたら super().__init__(…) を呼ぶ
  • _ は「内部用」の目印、__ は名前の書き換え。どちらも完全には隠せない

関連する記事・ツール

ABOUT ME
hr
hr
エンジニアとして働いている hr です。仕事や資格勉強で「こんなツールがあれば」と感じたものを、無料Webツールと解説記事にして発信しています。
記事URLをコピーしました