python中str运算符重载

在Python中，字符串（str）是不可变的对象，因此它的运算符重载相对有限。下面是一些常见的字符串运算符重载：

1. 字符串拼接：使用加号（+）运算符可以将两个字符串拼接在一起。例如：

   s1 = "Hello"
   s2 = "World"
   s3 = s1 + s2  # 结果为"HelloWorld"

2. 重复运算符：使用乘号（*）运算符可以重复一个字符串多次。例如：

   s = "Hello"
   repeated_s = s * 3  # 结果为"HelloHelloHello"

3. 成员关系运算符：使用in和not in运算符可以检查一个字符串是否包含另一个子字符串。例如：

   s = "HelloWorld"
   if "Hello" in s:
       print("包含Hello")

4. 比较运算符：字符串之间可以使用比较运算符进行大小比较。它们按照字典顺序进行比较。例如：

   s1 = "apple"
   s2 = "banana"
   if s1 < s2:
       print("apple在banana之前")

这些是一些常见的字符串运算符重载示例。请注意，Python中的字符串类型不支持像加法、减法或除法等算术运算符的重载。

相关问题

python运算符重载

Python中的运算符重载是指通过定义类的特殊方法，使得类的实例对象能够响应内置运算符和函数的调用。这些特殊方法包括：

1. `__add__(self, other)`：定义加法运算符`+`的行为；
2. `__sub__(self, other)`：定义减法运算符`-`的行为；
3. `__mul__(self, other)`：定义乘法运算符`*`的行为；
4. `__truediv__(self, other)`：定义除法运算符`/`的行为；
5. `__floordiv__(self, other)`：定义整除运算符`//`的行为；
6. `__mod__(self, other)`：定义取模运算符`%`的行为；
7. `__pow__(self, other)`：定义幂运算符`**`的行为；
8. `__lt__(self, other)`：定义小于运算符`<`的行为；
9. `__le__(self, other)`：定义小于等于运算符`<=`的行为；
10. `__eq__(self, other)`：定义等于运算符`==`的行为；
11. `__ne__(self, other)`：定义不等于运算符`!=`的行为；
12. `__gt__(self, other)`：定义大于运算符`>`的行为；
13. `__ge__(self, other)`：定义大于等于运算符`>=`的行为；
14. `__len__(self)`：定义`len()`函数的行为；
15. `__str__(self)`：定义`str()`函数的行为。

下面是一个简单的例子：

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

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

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

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

在上面的例子中，我们定义了一个`Vector`类，重载了加法、减法和乘法运算符，以及`str()`函数。这样，我们就可以通过运算符和函数来操作`Vector`对象。例如：

v1 = Vector(1, 2)
v2 = Vector(3, 4)

# 加法
v3 = v1 + v2
print(v3)  # 输出：(4, 6)

# 减法
v4 = v2 - v1
print(v4)  # 输出：(2, 2)

# 乘法
v5 = v1 * 2
print(v5)  # 输出：(2, 4)

# str()函数
print(str(v1))  # 输出：(1, 2)

两个有理数运算符重载

以下是两个有理数运算符重载的例子：

class Rational:
    def __init__(self, numerator, denominator):
        if denominator == 0:
            raise ZeroDivisionError("分母不能为0")
        self.numerator = numerator
        self.denominator = denominator
        self._simplify()

    def _simplify(self):
        gcd_num = self._gcd(self.numerator, self.denominator)
        self.numerator //= gcd_num
        self.denominator //= gcd_num

    def _gcd(self, a, b):
        if b == 0:
            return a
        return self._gcd(b, a % b)

    def __add__(self, other):
        new_numerator = self.numerator * other.denominator + self.denominator * other.numerator
        new_denominator = self.denominator * other.denominator
        return Rational(new_numerator, new_denominator)

    def __sub__(self, other):
        new_numerator = self.numerator * other.denominator - self.denominator * other.numerator
        new_denominator = self.denominator * other.denominator
        return Rational(new_numerator, new_denominator)

    def __mul__(self, other):
        new_numerator = self.numerator * other.numerator
        new_denominator = self.denominator * other.denominator
        return Rational(new_numerator, new_denominator)

    def __truediv__(self, other):
        new_numerator = self.numerator * other.denominator
        new_denominator = self.denominator * other.numerator
        return Rational(new_numerator, new_denominator)

    def __eq__(self, other):
        return self.numerator == other.numerator and self.denominator == other.denominator
    def __str__(self):
        return str(self.numerator) + '/' + str(self.denominator)

上述代码中，我们定义了一个有理数类Rational，其中包含了分子和分母两个整数成员变量，以及初始化函数、化简函数、加减乘除和相等判断等运算符重载函数。在加减乘除函数中，我们分别计算了新的分子和分母，并返回一个新的有理数对象。在相等判断函数中，我们判断了两个有理数的分子和分母是否相等。最后，我们还定义了一个__str__函数，用于将有理数对象转换为字符串输出。