Pythonのselfとは？使い方や注意点を初心者向けに徹底解説！

Pythonのselfとは何か、気になっていませんか？ クラスを勉強し始めると必ず出会うこの`self`、最初は「なんだこれ？」って思いますよね。

selfは難しそうに感じるかもしれませんが、一つ一つ見ていけば必ず理解できます。読み終わるころには、「`self`、完全に理解した！」と言えるようになっているはず。

この記事で学べること

• `self`がそもそも何なのか、基本的な役割
• なぜメソッドには`self`が必要なのか、その理由
• `self`を使った具体的なコードの書き方
• 初心者がつまずきやすい`self`の注意点やエラー

Pythonのselfとは？

まず、`self`とは、クラスから作られたオブジェクト（インスタンス）自身を指すための、特別な名前の引数です。

クラスは設計図のようなもので、その設計図から実際に作られたモノがインスタンス。例えば、「犬」という設計図（クラス）から、「ポチ」や「タマ」という実際の犬（インスタンス）が作られるイメージですね。

メソッド（クラス内で定義される関数のようなもの）の中で、そのメソッドが属しているインスタンス自身の情報（例えば、ポチの名前や色など）を使いたいときに、`self`が登場します。

「このインスタンス自身の名前は？」とか「このインスタンスの色を変更して！」といった操作をするときに、「どのインスタンス？」を区別するのが`self`の役目なんです。

Pythonでは、メソッドを定義するとき、最初の引数に`self`と書くのがお約束になっています。これは、「このメソッドはインスタンス自身（`self`）に関する操作ですよ」という目印のようなものだと考えてください。

# クラス（設計図）の定義
class Dog:
    # __init__ はインスタンスが作られるときに最初に呼ばれる特別なメソッド
    # ここで self を使ってインスタンスに名前(name)を持たせる
    def __init__(self, name):
        self.name = name # self.name で「このインスタンス自身の名前」を意味する

    # 挨拶するメソッド
    # ここでも self を使って自分の名前を呼び出す
    def greet(self):
        print(f"ワン！ ボクの名前は {self.name} だよ！")

# Dogクラスからインスタンス（実際の犬）を作る
pochi = Dog("ポチ") # "ポチ" という名前でインスタンス作成
tama = Dog("タマ")   # "タマ" という名前でインスタンス作成

# 各インスタンスのメソッドを呼び出す
pochi.greet() # pochi インスタンス自身 (self) の greet メソッドが呼ばれる
tama.greet()  # tama インスタンス自身 (self) の greet メソッドが呼ばれる

上のコードを実行すると、それぞれの犬が自分の名前をちゃんと名乗ってくれます。これは、`greet`メソッド内の`self.name`が、`pochi`のときは「ポチ」を、`tama`のときは「タマ」を正しく指しているからです。

なぜPythonのメソッドにはselfが必要なのか？その理由を徹底解説

「なんでわざわざ`self`なんて書かないといけないの？」と思いますよね。他のプログラミング言語ではあまり見かけない書き方かもしれません。

Pythonで`self`が必要なのは、メソッドが呼び出されるときに、どのインスタンスに対してそのメソッドを実行するのかをPython自身が知るためです。

クラスはあくまで設計図。実際に動くのは、その設計図から作られたインスタンス（オブジェクト）たちです。先ほどの例でいうと、`pochi`も`tama`も同じ`Dog`クラスから作られましたが、それぞれ別の存在ですよね。

`pochi.greet()`と書いたとき、Pythonは「`pochi`というインスタンスの`greet`メソッドを実行するんだな」と理解します。

そして、その`greet`メソッドを実行する際に、メソッドに対して「実行対象のインスタンスは`pochi`だよ」と教えるために、自動的に`pochi`自身を最初の引数として渡してくれるのです。この自動的に渡されるインスタンス自身を受け取るのが、メソッド定義の第一引数`self`の役割というわけです。

もし`self`がなければ、メソッドの中で`name`のようなインスタンス固有のデータを使おうとしても、それが`pochi`の`name`なのか、`tama`の`name`なのか区別がつかなくなってしまいます。

`self`があるからこそ、「自分自身の`name`」のように、インスタンス固有のデータや機能を正しく扱えるのですね。

selfがないとどうなる？具体例で比較

じゃあ、もしメソッド定義で`self`を書き忘れたらどうなるでしょう？ 百聞は一見にしかず、試してみましょう。

class Cat:
    def __init__(self, name):
        # ここはOK: __init__にはちゃんとselfがある
        self.name = name

    # greetメソッドの定義で self を書き忘れてみる
    def greet(): # ← self がない！
        # 本来なら self.name と書きたいところ
        print(f"ニャー！ ワタシの名前は？") # selfがないので名前が使えない…

# インスタンス作成
tama = Cat("タマ")

# greetメソッドを呼び出そうとすると…
tama.greet()

これを実行すると、おそらくこんなエラーが出るはずです。

Traceback (most recent call last):
  File "ファイル名.py", line 14, in <module>
    tama.greet()
TypeError: greet() takes 0 positional arguments but 1 was given

`TypeError: greet() takes 0 positional arguments but 1 was given` これは、「`greet`メソッドは引数を0個取るように定義されてるけど、実際には1個引数が渡されちゃったよ！」という意味のエラーです。

「あれ？ `tama.greet()`って引数なしで呼び出してるのに、なんで1個渡されたことになってるの？」

これがポイントです！先ほど説明したように、Pythonはインスタンスメソッド（`tama.greet()`のような呼び出し方）を実行するとき、自動的にそのインスタンス自身（ここでは`tama`）を第一引数としてメソッドに渡します。

だから、`greet()`の定義で引数を受け取る準備（つまり`self`を書くこと）をしていないと、「引数いらないって言ったのに来たんだけど！」とPythonが怒ってしまうわけですね。

このように、メソッド定義で`self`を書き忘れると、呼び出し時にエラーが発生します。`self`はインスタンスメソッドには必須の要素なのです。

selfはインスタンス自身を指す特別なキーワード

`self`が「インスタンス自身を指す」というのを、もう少し具体的にイメージしてみましょう。

クラスという設計図から複数のインスタンスを作ったとき、それぞれのインスタンスはメモリ上に別々の場所を確保して存在します。

以下の図を見てください。

[クラス: Dog 設計図]
    │
    ├─ インスタンス生成 ─→ [インスタンス pochi (メモリ番地 0x100)]
    │                        │  ↑
    │                        └─ self がここ(0x100)を指す
    │                           - name: "ポチ"
    │
    └─ インスタンス生成 ─→ [インスタンス tama (メモリ番地 0x200)]
                             │  ↑
                             └─ self がここ(0x200)を指す
                                - name: "タマ"

`pochi.greet()`が呼ばれたとき、`greet`メソッド内の`self`はメモリ番地`0x100`にある`pochi`インスタンスを指します。だから`self.name`は"ポチ"になります。

一方で`tama.greet()`が呼ばれたときは、`greet`メソッド内の`self`はメモリ番地`0x200`にある`tama`インスタンスを指します。そのため`self.name`は"タマ"となるわけです。

このように、メソッドが実行されるたびに、そのメソッドを呼び出したインスタンス自身が`self`として渡されることで、各インスタンスは自分自身のデータを正しく扱うことができるのです。これが`self`の最も重要な役割といえるでしょう。

selfの具体的な使い方をマスターしよう

さて、`self`の役割と必要性がわかったところで、次は実際にコードの中でどのように`self`を使っていくのか、具体的なパターンを見ていきましょう。主に以下の場面で`self`を活用します。

• インスタンス変数の定義と初期化（主に `__init__` メソッド内）
• インスタンス変数へのアクセス（値の参照や変更）
• 同じインスタンス内の他のメソッドの呼び出し

一つずつ、簡単な例で確認していきますね。

インスタンス変数へのアクセスとself

インスタンス変数とは、クラスから作られた個々のインスタンスが持つデータのことです。例えば、犬クラスの「名前」や「年齢」などがインスタンス変数にあたります。

ポチにはポチの名前と年齢が、タマにはタマの名前と年齢がある、というイメージです。

インスタンス変数は、通常`__init__`メソッド（初期化メソッド）の中で定義され、その際に`self.変数名 = 値`という形で記述します。

そして、他のメソッドからそのインスタンス変数を参照したり、値を変更したりするときも`self.変数名`という形でアクセスします。

class Student:
    # インスタンス作成時に名前と点数を設定
    def __init__(self, name, score):
        print(f"{name}さんのデータを作成します。")
        self.name = name      # インスタンス変数 name を定義
        self.score = score    # インスタンス変数 score を定義

    # 点数を表示するメソッド
    def show_score(self):
        # self.変数名 でインスタンス変数にアクセス
        print(f"{self.name}さんの点数は {self.score}点です。")

    # 点数を変更するメソッド
    def set_score(self, new_score):
        print(f"{self.name}さんの点数を {new_score}点に変更します。")
        # self.変数名 でインスタンス変数の値を変更
        self.score = new_score

# Studentインスタンスを作成
student_a = Student("佐藤", 80) # __init__ が呼ばれ、nameとscoreが設定される

# 点数を表示
student_a.show_score() # 佐藤さんの点数が表示される

# 点数を変更
student_a.set_score(95)

# 再度点数を表示
student_a.show_score() # 変更後の点数が表示される

実行結果:

佐藤さんのデータを作成します。
佐藤さんの点数は 80点です。
佐藤さんの点数を 95点に変更します。
佐藤さんの点数は 95点です。

このように、`__init__`で`self.name = name`のようにしてインスタンスにデータを紐付け、他のメソッド(`show_score`, `set_score`)では`self.name`や`self.score`を使って、そのインスタンス固有のデータにアクセスしています。

`self`を付けることで、「他の誰でもない、このインスタンス自身の変数」であることを明示しているわけですね。

他のメソッドの呼び出しとself

クラスの中には、複数のメソッドを定義することがよくあります。そして、あるメソッドの処理の中で、同じクラスの別のメソッドを呼び出したい場面も出てきます。

そんなときも`self`を使います。`self.メソッド名()`という形で、同じインスタンスに属する他のメソッドを呼び出すことができます。

class Calculator:
    def __init__(self, initial_value=0):
        self.current_value = initial_value
        print(f"計算機を作成しました。現在の値: {self.current_value}")

    def add(self, number):
        print(f"{self.current_value} に {number} を足します。")
        self.current_value += number
        # 計算結果を表示するために、同じクラスの show_result メソッドを呼び出す
        self.show_result() # <-- ここで self を使って呼び出し！

    def subtract(self, number):
        print(f"{self.current_value} から {number} を引きます。")
        self.current_value -= number
        # こちらも結果表示のために呼び出す
        self.show_result()

    def show_result(self):
        print(f"現在の値: {self.current_value}")

# 計算機インスタンスを作成
calc = Calculator(10)

# 足し算を実行 (addメソッドが内部でshow_resultを呼び出す)
calc.add(5)

# 引き算を実行 (subtractメソッドが内部でshow_resultを呼び出す)
calc.subtract(3)

実行結果:

計算機を作成しました。現在の値: 10
10 に 5 を足します。
現在の値: 15
15 から 3 を引きます。
現在の値: 12

`add`メソッドや`subtract`メソッドの中で、計算結果を表示するために`self.show_result()`と記述していますね。これにより、「この計算機インスタンス（`calc`）自身の`show_result`メソッドを実行してね」と指示していることになります。

もしここで`self`を付けずに`show_result()`とだけ書くと、Pythonはクラスの外にある同名の関数を探しに行ってしまい、意図通りに動作しません（またはエラーになります）。クラス内の他のメソッドを呼び出す際にも`self`は必須なのです。

selfは他の名前に変えられる？慣習と注意点

ここでちょっとした疑問。「メソッドの第一引数って、絶対に`self`って名前にしないといけないの？」

実は、Pythonの文法的には`self`という名前でなくても動作します。例えば、`this`とか`myself`とか、好きな名前を付けることも可能です。

class MyClass:
    # self の代わりに myself という名前を使ってみる
    def __init__(myself, value):
        myself.data = value

    # こちらも myself を使う
    def show_data(myself):
        print(f"データは {myself.data} です。")

# インスタンス作成とメソッド呼び出し
obj = MyClass(100)
obj.show_data() # 問題なく動作する

実行結果:

データは 100 です。

このように、`self`の代わりに`myself`を使っても、ちゃんと動きます。

しかし！ 実際のプログラミングでは、メソッドの第一引数には`self`という名前を使うのが、Pythonコミュニティにおける強い慣習であり、ほぼルールとなっています。

Pythonを書く世界中の開発者が「メソッドの最初の引数はインスタンス自身で、名前は`self`だよね」という共通認識を持っているのです。

もしあなたが`myself`や`this`といった別の名前を使うと、他の人があなたのコードを読んだときに「ん？ この`myself`って何だっけ？」と一瞬戸惑わせてしまいます。

コードは自分だけが読むものではなく、将来の自分や他の開発者も読む（かもしれない）ものです。誰が読んでも分かりやすいように、特別な理由がない限り、慣習に従って`self`という名前を使いましょう。それがスムーズな開発や共同作業につながります。

selfでよくある疑問やエラー解決集

`self`を使い始めると、いろいろな疑問が出てきたり、思わぬエラーに遭遇したりすることもあります。

ここでは、初心者が特に引っかかりやすいポイントをいくつかピックアップして、解決策と一緒に紹介しますね。

selfを書き忘れた時のAttributeError

メソッドの中でインスタンス変数を使いたいのに、うっかり`self.`を付け忘れる、というのはよくあるミスです。例えば…

class Counter:
    def __init__(self):
        self.count = 0 # インスタンス変数 count を初期化

    def increment(self):
        # count を1増やしたいけど… self. を付け忘れた！
        count += 1 # ← これはダメ！
        print(f"カウント: {self.count}") # ここは self. が付いている

c = Counter()
c.increment()

これを実行すると、`count += 1`の行でエラーになります。エラーメッセージは状況によって`UnboundLocalError: local variable 'count' referenced before assignment`や`NameError: name 'count' is not defined`のようになることが多いでしょう。

これは、`self.`を付けずに`count`とだけ書くと、Pythonはメソッドの中だけで使われるローカル変数だと解釈しようとするからです。

でも、`+= 1`のような操作をする前に`count`に値が代入されていないため、「値が決まってないのに計算しようとしてるよ！」とか「そんな名前の変数知らないよ！」と怒られてしまうわけです。

解決策は単純明快、インスタンス変数にアクセスするときは必ず`self.`を付けることです。

    def increment(self):
        # 正しくは self. を付けてインスタンス変数にアクセス
        self.count += 1
        print(f"カウント: {self.count}")

これで正しくインスタンス変数`count`の値が増えるようになります。「インスタンスのデータには`self.`！」と覚えておきましょう。

メソッド呼び出し時に引数が足りないTypeError

これも非常によく遭遇するエラーです。先ほど「`self`がないとどうなる？」のセクションで見たエラーと似ていますが、今度はメソッド呼び出し側の問題です。

class Greeter:
    def say_hello(self, name): # self 以外に name 引数も取る
        print(f"こんにちは、{name}さん！ 私がselfです。")

greet = Greeter()

# メソッドを呼び出すときに、name引数を渡し忘れる
greet.say_hello() # ← 引数が必要なのに渡していない！

これを実行すると、以下のようなエラーが出ます。

Traceback (most recent call last):
  File "ファイル名.py", line 9, in <module>
    greet.say_hello()
TypeError: say_hello() missing 1 required positional argument: 'name'

`TypeError: say_hello() missing 1 required positional argument: 'name'` は、「`say_hello`メソッドに必要な引数`name`が足りないよ！」という意味です。

メソッドを定義するときは`def say_hello(self, name):`のように`self`と`name`の2つの引数を書きますが、呼び出すときは`greet.say_hello("山田")`のように`name`に対応する引数だけを渡しますよね。

これは、呼び出し時にPythonが自動的にインスタンス自身（`greet`）を最初の引数`self`として渡してくれるからです。

そのため、呼び出し側では`self`以外の引数（この例では`name`）だけを意識して渡す必要があります。もし`self`以外の引数が定義されているのに、呼び出し側で渡し忘れると、この`TypeError`が発生します。

解決策は、メソッド定義を確認し、`self`以外に必要な引数を呼び出し時に正しく渡すことです。

# 正しい呼び出し方
greet.say_hello("山田")

これで、「こんにちは、山田さん！ 私がselfです。」と正しく出力されるはずです。メソッドの定義と呼び出し方、セットで確認する癖をつけましょう。

クラスメソッドやスタティックメソッドとselfの関係

クラスを学んでいくと、`@classmethod`や`@staticmethod`という見慣れないものが付いたメソッドに出会うことがあります。これらはインスタンスメソッド（`self`を取る普通のメソッド）とは少し性質が異なります。

• クラスメソッド (`@classmethod`)
  第一引数として`self`の代わりにクラス自身（慣習的に`cls`という名前を使う）を受け取ります。インスタンスを作らなくても、クラス名から直接呼び出せます。クラス全体に関わる操作や、設定値を扱う場合に使われることがあります。
• スタティックメソッド (`@staticmethod`)
  `self`も`cls`も受け取りません。インスタンスの状態にもクラスの状態にも依存しない、単なる関数をクラス内に置きたい場合に使われます。クラス名からもインスタンス名からも呼び出せます。

class MyUtil:
    class_variable = "クラス変数です"

    def __init__(self):
        self.instance_variable = "インスタンス変数です"

    # 普通のインスタンスメソッド (self を取る)
    def instance_method(self):
        print(f"インスタンスメソッドより: {self.instance_variable}")

    # クラスメソッド (cls を取る)
    @classmethod
    def class_method(cls):
        print(f"クラスメソッドより: {cls.class_variable}")
        # print(cls.instance_variable) # これはエラーになる (インスタンスがないから)

    # スタティックメソッド (self も cls も取らない)
    @staticmethod
    def static_method(x, y):
        print(f"スタティックメソッドより: {x} + {y} = {x + y}")

# インスタンスメソッドはインスタンスから呼び出す
util = MyUtil()
util.instance_method()

# クラスメソッドはクラス名から呼び出せる
MyUtil.class_method()

# スタティックメソッドもクラス名から呼び出せる
MyUtil.static_method(10, 5)
# スタティックメソッドはインスタンスからも呼び出せる
util.static_method(2, 3)

重要なのは、`self`を使うのは、そのインスタンス固有のデータ（インスタンス変数）や機能（他のインスタンスメソッド）にアクセスする必要があるインスタンスメソッドだけ、ということです。

クラス全体に関わることならクラスメソッド、どちらにも依存しない単なる処理ならスタティックメソッド、という使い分けになります。最初のうちは`self`を使うインスタンスメソッドを中心に理解し、慣れてきたらこれらについても学んでいくと良いでしょう。

【まとめ】Pythonのselfを理解してオブジェクト指向を使いこなそう

さて、今回はPythonのクラスにおける`self`について、その意味から使い方、注意点まで詳しく見てきました。もう`self`に対する苦手意識はなくなりましたか？

最後に、この記事のポイントをまとめておきましょう。

• `self`は、クラスから作られたインスタンス自身を指す特別な第一引数。
• メソッド内でインスタンス変数にアクセスしたり、他のインスタンスメソッドを呼び出したりするために必要不可欠。
• Pythonがメソッド呼び出し時に自動的にインスタンスを`self`に渡してくれる。
• メソッド定義で`self`を書き忘れると`TypeError`が発生しやすい。
• インスタンス変数アクセス時に`self.`を忘れると`NameError`や`AttributeError`の原因になる。
• 引数名は`self`以外も可能だが、慣習に従って`self`を使うのが強く推奨される。
• インスタンスに依存しない処理は`@classmethod`や`@staticmethod`を使う。

`self`の理解は、Pythonの強力な機能であるオブジェクト指向プログラミングを使いこなすための第一歩です。最初は少し難しく感じるかもしれませんが、実際に自分でクラスを書いて、`self`を使ってみるのが一番の近道！

ぜひ、今日学んだことを活かして、簡単なクラス作成に挑戦してみてください。例えば、「自分のペット」クラスや「好きな食べ物」クラスなど、身近なものを題材にすると楽しいかもしれませんね。

【関連記事】 「Pythonとは？」に答える最初の一歩