33. Python's Built-in Hash Functions

In Python, hashable objects are objects that can be used as keys in dictionaries or added to sets. To make a class hashable, you must implement the __hash__ and __eq__ methods in the class. The __hash__ method returns an integer, which is used to quickly compare and look up objects in hash-based containers like dictionaries and sets. The __eq__ method is used to check if two objects are equal.

Here are 10 Python code snippets that demonstrate how to create hashable objects using built-in hash functions:

---

1. Basic Hashable Object

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

    def __hash__(self):
        return hash((self.name, self.age))

    def __eq__(self, other):
        return (self.name, self.age) == (other.name, other.age)

# Usage
person1 = Person("Alice", 30)
person2 = Person("Alice", 30)
person3 = Person("Bob", 25)

# Using the objects in a set
people_set = {person1, person2, person3}
print(people_set)  # Outputs: {<__main__.Person object at 0x...>, <__main__.Person object at 0x...>}

---

2. Hashable Object with Tuple

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

    def __hash__(self):
        return hash((self.x, self.y))

    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

# Usage
point1 = Point(1, 2)
point2 = Point(1, 2)
point3 = Point(3, 4)

# Using the objects in a set
point_set = {point1, point2, point3}
print(point_set)  # Outputs: {<__main__.Point object at 0x...>, <__main__.Point object at 0x...>}

---

3. Hashable Object with Immutable Attributes

class Product:
    def __init__(self, id, name, price):
        self.id = id
        self.name = name
        self.price = price

    def __hash__(self):
        return hash((self.id, self.name, self.price))

    def __eq__(self, other):
        return (self.id, self.name, self.price) == (other.id, other.name, other.price)

# Usage
product1 = Product(1, "Laptop", 999.99)
product2 = Product(1, "Laptop", 999.99)
product3 = Product(2, "Phone", 499.99)

product_dict = {product1: "In stock", product2: "In stock", product3: "Out of stock"}
print(product_dict)

---

4. Custom Hashable Class Using __slots__

class User:
    __slots__ = ['username', 'email']

    def __init__(self, username, email):
        self.username = username
        self.email = email

    def __hash__(self):
        return hash((self.username, self.email))

    def __eq__(self, other):
        return (self.username, self.email) == (other.username, other.email)

# Usage
user1 = User("john_doe", "[e-mail]")
user2 = User("john_doe", "[e-mail]")
user3 = User("jane_doe", "[e-mail]")

user_set = {user1, user2, user3}
print(user_set)  # Outputs a set with two elements, user1 and user3

---

5. Hashable Object with Custom __repr__

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def __hash__(self):
        return hash((self.make, self.model, self.year))

    def __eq__(self, other):
        return (self.make, self.model, self.year) == (other.make, other.model, other.year)

    def __repr__(self):
        return f"Car({self.year} {self.make} {self.model})"

# Usage
car1 = Car("Toyota", "Corolla", 2020)
car2 = Car("Toyota", "Corolla", 2020)
car3 = Car("Honda", "Civic", 2019)

car_set = {car1, car2, car3}
print(car_set)  # Outputs: {Car(2020 Toyota Corolla), Car(2019 Honda Civic)}

---

6. Hashable Object with Custom Attributes

class Address:
    def __init__(self, street, city, postal_code):
        self.street = street
        self.city = city
        self.postal_code = postal_code

    def __hash__(self):
        return hash((self.street, self.city, self.postal_code))

    def __eq__(self, other):
        return (self.street, self.city, self.postal_code) == (other.street, other.city, other.postal_code)

# Usage
address1 = Address("123 Main St", "Springfield", "12345")
address2 = Address("123 Main St", "Springfield", "12345")
address3 = Address("456 Elm St", "Springfield", "67890")

address_set = {address1, address2, address3}
print(address_set)

---

7. Hashable Class Using frozenset

class Task:
    def __init__(self, name, tags):
        self.name = name
        self.tags = frozenset(tags)  # frozenset makes it immutable and hashable

    def __hash__(self):
        return hash((self.name, self.tags))

    def __eq__(self, other):
        return (self.name, self.tags) == (other.name, other.tags)

# Usage
task1 = Task("Task 1", ["urgent", "work"])
task2 = Task("Task 1", ["urgent", "work"])
task3 = Task("Task 2", ["personal"])

task_set = {task1, task2, task3}
print(task_set)

---

8. Hashable Object with Default Dictionary Behavior

from collections import defaultdict

class Author:
    def __init__(self, name, country):
        self.name = name
        self.country = country

    def __hash__(self):
        return hash((self.name, self.country))

    def __eq__(self, other):
        return (self.name, self.country) == (other.name, other.country)

# Usage
author1 = Author("George Orwell", "UK")
author2 = Author("George Orwell", "UK")
author3 = Author("J.K. Rowling", "UK")

book_collection = defaultdict(list)
book_collection[author1].append("1984")
book_collection[author2].append("Animal Farm")
book_collection[author3].append("Harry Potter")

print(book_collection)

---

9. Hashable Object with __eq__ and __ne__

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

    def __hash__(self):
        return hash((self.x, self.y, self.z))

    def __eq__(self, other):
        return (self.x, self.y, self.z) == (other.x, other.y, other.z)

    def __ne__(self, other):
        return not self.__eq__(other)

# Usage
point1 = Point3D(1, 2, 3)
point2 = Point3D(1, 2, 3)
point3 = Point3D(4, 5, 6)

point_dict = {point1: "First Point", point3: "Second Point"}
print(point_dict)

---

10. Hashable Object with Multiple Attributes

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

    def __hash__(self):
        return hash((self.id, self.name, self.department))

    def __eq__(self, other):
        return (self.id, self.name, self.department) == (other.id, other.name, other.department)

# Usage
emp1 = Employee(1, "John Doe", "HR")
emp2 = Employee(1, "John Doe", "HR")
emp3 = Employee(2, "Jane Smith", "IT")

emp_dict = {emp1: "HR Manager", emp3: "IT Specialist"}
print(emp_dict)

---

These examples show how to make custom objects hashable by implementing the __hash__ and __eq__ methods. This allows objects to be used in hash-based containers such as dictionaries and sets, which rely on hashing for fast lookups.