【Python】メソッドのオーバーロードを解説｜関数・メソッド・演算子を一気に理解

// Javaの例
int add(int a, int b) { ... }
double add(double a, double b) { ... }
String add(String a, String b) { ... }

def add(a, b):
    return a + b

def add(a, b, c):
    return a + b + c

print(add(1, 2))  # これはどうなる？

def greet():
    print("Hello")

def greet(name):
    print(f"Hello, {name}")

greet()  # TypeError になる

def greet():
    print("Hello")

def greet(name):
    print(f"Hello, {name}")

try:
    greet()
except TypeError as e:
    print("TypeError:", e)

greet("Alice")

def greet(name=None):
    """name があれば名前付きで、なければ一般的な挨拶をする関数"""
    if name is None:
        print("Hello")
    else:
        print(f"Hello, {name}")

greet()          # 引数なし
greet("Bob")     # 引数あり

def power(base, exp=2):
    """べき乗を計算する。exp を省略すると 2 乗として扱う"""
    return base ** exp

print(power(3))     # 3^2
print(power(2, 3))  # 2^3

def describe_person(name, *traits, **extra):
    """
    name: 名前(必須)
    *traits: 性格や特徴(任意個)
    **extra: 年齢や職業などの追加情報(キーワード引数)
    """
    print(f"Name: {name}")

    if traits:
        print("Traits:", ", ".join(traits))

    if extra:
        for key, value in extra.items():
            print(f"{key.capitalize()}: {value}")

# いろいろな呼び出し方
describe_person("Alice")
print("-----")
describe_person("Bob", "kind", "smart")
print("-----")
describe_person("Charlie", "active", age=30, job="Engineer")

from functools import singledispatch

@singledispatch
def show(value):
    """デフォルトの実装(対応する型がなければこれが使われる)"""
    print(f"[default] {value!r}")

@show.register
def _(value: int):
    print(f"[int] {value} (二倍: {value * 2})")

@show.register
def _(value: str):
    print(f"[str] '{value}' (長さ: {len(value)})")

@show.register
def _(value: list):
    print(f"[list] 要素数: {len(value)}, 中身: {value}")

show(10)
show("hello")
show([1, 2, 3])
show(3.14)  # 対応していない型(float)はデフォルト実装が呼ばれる

class Calculator:
    def add(self, *args):
        """引数の個数に応じて加算を行うメソッド"""
        if not args:
            return 0
        elif len(args) == 2:
            a, b = args
            return a + b
        elif len(args) == 3:
            a, b, c = args
            return a + b + c
        else:
            # それ以外の個数はエラーにする
            raise TypeError("add() は 0, 2, 3 個の引数にのみ対応しています")

calc = Calculator()
print(calc.add())
print(calc.add(1, 2))
print(calc.add(1, 2, 3))

class Animal:
    def speak(self):
        print("...")

class Dog(Animal):
    def speak(self):
        # 親クラスの speak を「オーバーライド」している
        print("Woof!")

animal = Animal()
dog = Dog()

animal.speak()  # ...
dog.speak()     # Woof!

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

    # 別コンストラクタのようなクラスメソッド
    @classmethod
    def from_fullname(cls, first, last):
        return cls(f"{first} {last}")

    # ユーティリティ的なスタティックメソッド
    @staticmethod
    def format_name(name, upper=False):
        if upper:
            return name.upper()
        return name

p1 = Person("Alice")
p2 = Person.from_fullname("Bob", "Smith")  # クラスメソッドの利用

print(Person.format_name(p1.name))
print(Person.format_name(p2.name, upper=True))

from typing import overload, Union

@overload
def repeat(value: int, times: int) -> list[int]:
    ...

@overload
def repeat(value: str, times: int) -> list[str]:
    ...

def repeat(value, times):
    """value の型に応じて、同じ値を times 回並べたリストを返す"""
    return [value] * times

print(repeat(1, 3))
print(repeat("a", 4))

class Vector2D:
    """2次元ベクトルを表すクラス"""
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        """self + other の挙動を定義する"""
        if not isinstance(other, Vector2D):
            return NotImplemented  # 他の型との加算には対応しない
        return Vector2D(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector2D({self.x}, {self.y})"

v1 = Vector2D(1, 2)
v2 = Vector2D(3, 4)
v3 = v1 + v2   # 内部的には v1.__add__(v2) が呼ばれる

print(v3)

class Rectangle:
    """長方形を表すクラス"""
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def area(self):
        return self.width * self.height

    def __eq__(self, other):
        if not isinstance(other, Rectangle):
            return NotImplemented
        return self.area == other.area

    def __lt__(self, other):
        if not isinstance(other, Rectangle):
            return NotImplemented
        return self.area < other.area

    def __repr__(self):
        return f"Rectangle({self.width}, {self.height})"

r1 = Rectangle(2, 3)   # 面積 6
r2 = Rectangle(1, 6)   # 面積 6
r3 = Rectangle(3, 3)   # 面積 9

print(r1 == r2)  # 面積が同じ
print(r1 < r3)   # 6 < 9
print(r3 > r2)   # 9 > 6

class Money:
    """通貨付き金額を表すクラス"""
    def __init__(self, amount, currency="JPY"):
        self.amount = amount
        self.currency = currency

    def __add__(self, other):
        """同じ通貨同士の加算のみ許可する"""
        if not isinstance(other, Money):
            return NotImplemented
        if self.currency != other.currency:
            raise ValueError("通貨が異なる Money 同士は加算できません")
        return Money(self.amount + other.amount, self.currency)

    def __mul__(self, factor):
        """金額 × 倍率(数値)"""
        if not isinstance(factor, (int, float)):
            return NotImplemented
        return Money(self.amount * factor, self.currency)

    def __rmul__(self, factor):
        """倍率 × 金額 も許可する(右側版の演算)"""
        return self.__mul__(factor)

    def __repr__(self):
        return f"Money({self.amount}, '{self.currency}')"

salary = Money(200000)         # 20万円
bonus = Money(50000)           # 5万円
total = salary + bonus         # 内部的には salary.__add__(bonus)

double = 2 * salary            # __rmul__ が使われる
triple = salary * 3            # __mul__ が使われる

print(total)
print(double)
print(triple)

# 通貨が異なる場合
usd = Money(100, "USD")
try:
    print(salary + usd)
except ValueError as e:
    print("エラー:", e)