Python学习--比较方法详解

class Person:    def __init__(self, name, age):        self.name = name        self.age = age    def __eq__(self, other):        """== 运算符"""        if not isinstance(other, Person):            return NotImplemented        return self.name == other.name and self.age == other.age    def __ne__(self, other):        """!= 运算符"""        # Python 3会自动从__eq__取反，但也可以手动实现        result = self.__eq__(other)        if result is NotImplemented:            return NotImplemented        return not result    def __lt__(self, other):        """< 运算符"""        if not isinstance(other, Person):            return NotImplemented        # 先按年龄比较，再按姓名比较        if self.age != other.age:            return self.age < other.age        return self.name < other.name    def __le__(self, other):        """<= 运算符"""        if not isinstance(other, Person):            return NotImplemented        return self.__lt__(other) or self.__eq__(other)    def __gt__(self, other):        """> 运算符"""        if not isinstance(other, Person):            return NotImplemented        return not self.__le__(other)    def __ge__(self, other):        """>= 运算符"""        if not isinstance(other, Person):            return NotImplemented        return not self.__lt__(other)# 使用p1 = Person("Alice", 25)p2 = Person("Bob", 30)p3 = Person("Alice", 25)print(f"p1 == p2: {p1 == p2}")  # Falseprint(f"p1 == p3: {p1 == p3}")  # Trueprint(f"p1 < p2: {p1 < p2}")    # Trueprint(f"p1 <= p2: {p1 <= p2}")  # Trueprint(f"p2 > p1: {p2 > p1}")    # True

from functools import total_ordering@total_ordering  # 自动补全其他比较方法class Book:    def __init__(self, title, author, price):        self.title = title        self.author = author        self.price = price    def __eq__(self, other):        """只需要实现 __eq__"""        if not isinstance(other, Book):            return NotImplemented        return (self.title, self.author, self.price) == \               (other.title, other.author, other.price)    def __lt__(self, other):        """只需要实现 __lt__（用于排序）"""        if not isinstance(other, Book):            return NotImplemented        # 按价格排序，价格相同按书名排序        if self.price != other.price:            return self.price < other.price        return self.title < other.title    def __repr__(self):        return f"Book('{self.title}', '{self.author}', {self.price})"# 使用books = [    Book("Python编程", "张三", 89),    Book("Java编程", "李四", 79),    Book("Python编程", "张三", 69),    Book("C++编程", "王五", 89)]print("排序前:")for book in books:    print(f"  {book}")print("\n排序后:")for book in sorted(books):    print(f"  {book}")print(f"\n书籍比较:")print(f"books[0] < books[1]: {books[0] < books[1]}")print(f"books[0] <= books[2]: {books[0] <= books[2]}")print(f"books[0] > books[3]: {books[0] > books[3]}")

class Point:    def __init__(self, x, y):        self.x = x        self.y = y    def __eq__(self, other):        if not isinstance(other, Point):            return NotImplemented        return self.x == other.x and self.y == other.y    def __hash__(self):        """返回对象的哈希值"""        # 使用元组的哈希（不可变且可哈希）        return hash((self.x, self.y))    def __repr__(self):        return f"Point({self.x}, {self.y})"# 使用p1 = Point(1, 2)p2 = Point(1, 2)p3 = Point(3, 4)# 作为字典键使用point_dict = {    p1: "起点",    p3: "终点"}print(f"p1 的值: {point_dict[p1]}")print(f"p2 的值: {point_dict[p2]}")  # p2 等于 p1，所以能访问到print(f"p1 is p2: {p1 is p2}")       # False（不同对象）print(f"p1 == p2: {p1 == p2}")       # True（内容相等）print(f"hash(p1): {hash(p1)}")print(f"hash(p2): {hash(p2)}")       # 相同的哈希值

class ImmutablePerson:    """不可变的人（适合作为字典键）"""    def __init__(self, name, birth_year):        # 使用双下划线表示私有属性        self._name = name        self._birth_year = birth_year        self._hash = None  # 缓存哈希值    @property    def name(self):        return self._name    @property    def birth_year(self):        return self._birth_year    def __eq__(self, other):        if not isinstance(other, ImmutablePerson):            return NotImplemented        return (self._name == other._name and                 self._birth_year == other._birth_year)    def __hash__(self):        """缓存哈希值以提高性能"""        if self._hash is None:            self._hash = hash((self._name, self._birth_year))        return self._hash    def __repr__(self):        return f"ImmutablePerson('{self._name}', {self._birth_year})"# 使用people = {    ImmutablePerson("Alice", 1995): "工程师",    ImmutablePerson("Bob", 1990): "设计师",    ImmutablePerson("Charlie", 2000): "学生"}print("人员字典:")for person, job in people.items():    print(f"  {person} -> {job}")# 创建相同内容的人alice2 = ImmutablePerson("Alice", 1995)print(f"\nalice2 在字典中: {alice2 in people}")  # Trueprint(f"alice2 的工作: {people[alice2]}")        # "工程师"

from numbers import Numberclass NumericValue:    def __init__(self, value):        self.value = value    def __eq__(self, other):        """能够与数字比较"""        if isinstance(other, NumericValue):            return self.value == other.value        elif isinstance(other, Number):            return self.value == other        return NotImplemented    def __lt__(self, other):        if isinstance(other, NumericValue):            return self.value < other.value        elif isinstance(other, Number):            return self.value < other        return NotImplemented    def __hash__(self):        return hash(self.value)    def __repr__(self):        return f"NumericValue({self.value})"# 使用nv1 = NumericValue(10)nv2 = NumericValue(10)nv3 = NumericValue(20)print(f"nv1 == nv2: {nv1 == nv2}")        # Trueprint(f"nv1 == 10: {nv1 == 10}")          # Trueprint(f"nv1 == 20: {nv1 == 20}")          # Falseprint(f"nv1 < nv3: {nv1 < nv3}")          # Trueprint(f"nv1 < 15: {nv1 < 15}")            # True

class SimpleHash:    """演示哈希冲突的类"""    def __init__(self, id):        self.id = id    def __eq__(self, other):        if not isinstance(other, SimpleHash):            return NotImplemented        return self.id == other.id    def __hash__(self):        # 故意制造哈希冲突：所有偶数ID哈希为0，奇数ID哈希为1        return self.id % 2    def __repr__(self):        return f"Item({self.id})"# 创建哈希冲突items = {}for i in range(5):    items[SimpleHash(i)] = f"值{i}"print("哈希表状态（有冲突）:")for key in items:    print(f"  {key} -> {items[key]} (hash={hash(key)})")print("\n字典的内部工作原理:")print("1. 首先用hash()找到桶")print("2. 然后用__eq__在桶内查找具体元素")print("3. 所以即使hash相同，只要__eq__能区分就没问题")

class MutablePoint:    """可变点 - 不适合作为字典键"""    def __init__(self, x, y):        self.x = x        self.y = y    def __eq__(self, other):        if not isinstance(other, MutablePoint):            return NotImplemented        return self.x == other.x and self.y == other.y    def __hash__(self):        # 警告：对象可能被修改，哈希值应该保持不变        return hash((self.x, self.y))    def move(self, dx, dy):        self.x += dx        self.y += dyclass ImmutablePoint:    """不可变点 - 适合作为字典键"""    def __init__(self, x, y):        # 冻结对象        self._x = x        self._y = y        self._hash = hash((x, y))    @property    def x(self):        return self._x    @property    def y(self):        return self._y    def __eq__(self, other):        if not isinstance(other, ImmutablePoint):            return NotImplemented        return self._x == other._x and self._y == other._y    def __hash__(self):        return self._hash    def __repr__(self):        return f"ImmutablePoint({self._x}, {self._y})"# 演示问题print("=== 可变对象的哈希问题 ===")mp = MutablePoint(1, 2)d = {mp: "点A"}print(f"初始字典: {d}")# 修改对象mp.move(1, 1)print(f"修改后的点: {mp}")print(f"还能找到吗: {mp in d}")  # 可能找不到print("\n=== 不可变对象的优势 ===")ip = ImmutablePoint(1, 2)d2 = {ip: "点B"}print(f"初始字典: {d2}")# 无法修改try:    ip.x = 3except AttributeError as e:    print(f"修改失败: {e}")

class Shape:    def __init__(self, color):        self.color = color    def __eq__(self, other):        if not isinstance(other, Shape):            return NotImplemented        return self.color == other.color    def __hash__(self):        return hash(self.color)class Circle(Shape):    def __init__(self, color, radius):        super().__init__(color)        self.radius = radius    def __eq__(self, other):        # 先调用父类的比较        if not super().__eq__(other):            return False        # 如果是同类型，比较radius        if isinstance(other, Circle):            return self.radius == other.radius        # 如果只是Shape类型，那么颜色相等就相等        return True    def __hash__(self):        # 包含所有重要属性        return hash((self.color, self.radius))class Rectangle(Shape):    def __init__(self, color, width, height):        super().__init__(color)        self.width = width        self.height = height    def __eq__(self, other):        if not super().__eq__(other):            return False        if isinstance(other, Rectangle):            return (self.width == other.width and                     self.height == other.height)        return True    def __hash__(self):        return hash((self.color, self.width, self.height))# 使用shapes = {    Circle("red", 5): "小圆",    Circle("red", 10): "大圆",    Rectangle("blue", 3, 4): "小矩形",    Rectangle("blue", 5, 6): "大矩形"}print("形状字典:")for shape, name in shapes.items():    print(f"  {shape} -> {name}")print("\n比较不同子类:")c1 = Circle("red", 5)r1 = Rectangle("red", 3, 4)print(f"c1 == r1: {c1 == r1}")  # True (颜色相同)print(f"hash(c1) == hash(r1): {hash(c1) == hash(r1)}")  # False

# 陷阱1：修改后哈希值变化class Bad:    def __init__(self, x):        self.x = x    def __hash__(self):        return hash(self.x)  # 如果x可变，危险！# 陷阱2：忘记实现__hash__class MissingHash:    def __eq__(self, other):        return True    # 没有__hash__，不能作为字典键# 陷阱3：__eq__和__hash__不一致class Inconsistent:    def __eq__(self, other):        return self.id == other.id    def __hash__(self):        return hash(self.name)  # 使用了不同的属性