什么是Python中的基本重载方法

在Python中，基本的重载方法是可以在派生类中重写的方法，以改变对象的行为。基本重载方法是Python中预定义的特殊方法，可用于定义用户定义类上的运算符和内置函数的工作方式。通过重载这些方法，我们可以自定义对象的行为，并根据我们的要求让它们起作用。

示例：重载 `add()` 方法

__add__() 方法用于在Python中重载加法运算符（+）。通过重载此方法，我们可以使用“ +”运算符添加我们类的两个对象。

在此示例中，我们已定义了__add__() 方法来重载 Point 类的加法运算符。该方法将 Point 类的另一个对象作为参数，并返回两个点之和的新 Point 对象。

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Point(x, y)

p1 = Point(2, 3)
p2 = Point(4, 5)
p3 = p1 + p2

print("p1 =", (p1.x, p1.y))
print("p2 =", (p2.x, p2.y))
print("p3 =", (p3.x, p3.y))

输出结果为：

p1 = (2, 3)
p2 = (4, 5)
p3 = (6, 8)

示例：重载 `len()` 方法

__len__() 方法用于在Python中重载 len() 函数。通过重载此方法，在调用 len() 函数时，我们可以定义对象的长度。

在此示例中，我们已定义了__len__() 方法来重载 MyList 类的 len() 函数。当调用 len() 函数时，该方法返回存储在对象中的列表的长度。

class MyList:
    def __init__(self, lst):
        self.lst = lst

    def __len__(self):
        return len(self.lst)

my_lst = MyList([1, 2, 3, 4, 5])
print(len(my_lst))

输出结果为：

示例：重载 `str()` 方法

__str__() 方法用于在Python中重载 str() 函数。通过重载此方法，我们可以定义对象作为字符串的表示方式。

在此代码中，我们使用 __init__ 方法定义 Person 类，并初始化实例的名称和年龄属性。我们还定义了 __str__ 方法，它返回实例的字符串表示形式。然后，我们创建一个名称为“ Jane”、年龄为25岁的 Person 类实例，并将其分配给变量 p。最后，我们使用 print() 函数打印 p 对象的字符串表示形式，该函数隐式调用 __str__ 方法。

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

    def __str__(self):
        return f"{self.name} {self.age} years old"

p = Person("Jane", 25)
print(p)

输出结果为：

Jane 25 years old

示例

在此示例中，我们将创建一个类，重载 __len__ 方法。__len__ 方法返回对象中的项目数。

在这里，我们定义了自定义 __len__ 方法，该方法返回对象数据属性的长度。我们可以使用内置的 len 函数来获取对象的长度。

class MyClass:
    def __init__(self, data):
        self.data = data

    def __len__(self):
        return len(self.data)

my_object = MyClass([1, 2, 3, 4, 5])
print(len(my_object))

输出结果为：

示例

在此示例中，我们将创建一个类，并重载 __add__ 方法。__add__ 方法重载了 + 操作符，并允许我们将两个对象相加。

在这里，我们定义了自定义 __add__ 方法，使我们能够将两个 MyClass 对象相加。__add__ 方法创建一个新的 MyClass 对象，其中包含两个对象的组合数据。

class MyClass:
    def __init__(self, data):
        self.data = data

    def __add__(self, other):
        new_data = self.data.copy()
        new_data.extend(other.data)
        return MyClass(new_data)

my_object_1 = MyClass([1, 2, 3])
my_object_2 = MyClass([4, 5, 6])
my_object_3 = my_object_1 + my_object_2

print(my_object_3.data)

输出结果为：

[1, 2, 3, 4, 5, 6]

示例

在此示例中，我们创建了一个 Point 类，该类具有两个实例变量 x 和 y，并重载 __add__ 方法，该方法返回两个点的总和。我们创建了两个 Point 类的对象 p1 和 p2，并使用 + 运算符将它们相加。自动调用了重载的 __add__ 方法，并将结果存储在 p3 中。

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
# overloading the + operator
    def __add__(self, other):
         x = self.x + other.x
         y = self.y + other.y
         return Point(x, y)
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2
print(p3.x, p3.y) # Output: 4 6

输出结果为：

4 6

示例

在此示例中，我们创建了一个 Employee 类，该类具有两个实例变量 name 和 salary，并重载 __eq__ 方法，该方法比较两个 Employee 对象的相等性。我们创建了 Employee 类的两个对象 emp1 和 emp2，并使用 == 运算符将它们进行比较。自动调用了重载的 __eq__ 方法，并在两个对象的名称和薪水相同时返回 True。

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

# overloading the == operator
    def __eq__(self, other):
      if isinstance(other, Employee):
        return self.name == other.name and self.salary == other.salary
        return False
emp1 = Employee('John', 5000)
emp2 = Employee('John', 5000)
print(emp1 == emp2) # Output: True