Какой методы есть только у объекта неизменяемого типа?

Методы неизменяемых типов (immutable)

Неизменяемые типы в Python (str, tuple, frozenset, int, float, bytes и т.д.) имеют методы, которых нет у изменяемых типов. Наиболее характерный метод — hash(), но есть и другие особенности.

Главный признак: hash()

Только неизменяемые объекты имеют метод hash(), который позволяет использовать их в качестве ключей словарей и элементов множеств:

# Строка (неизменяемая)
s = 'hello'
print(hash(s))  # -2088426288 — хешируется успешно

# Кортеж (неизменяемая)
t = (1, 2, 3)
print(hash(t))  # 2528714747 — хешируется успешно

# Список (изменяемая)
l = [1, 2, 3]
print(hash(l))  # TypeError: unhashable type: 'list'

# Словарь (изменяемая)
d = {'a': 1}
print(hash(d))  # TypeError: unhashable type: 'dict'

Использование в словарях и множествах

Благодаря hash(), неизменяемые объекты могут быть ключами словаря и элементами множества:

# Хорошо — строки (неизменяемые)
data = {
    'name': 'Alice',
    'age': 30
}

# Хорошо — кортежи (неизменяемые)
point_set = {(0, 0), (1, 1), (2, 2)}
print((0, 0) in point_set)  # True

# Ошибка — списки (изменяемые) не могут быть ключами
data = {[1, 2]: 'value'}  # TypeError: unhashable type: 'list'

# Ошибка — списки не могут быть в множестве
my_set = {[1, 2, 3]}  # TypeError: unhashable type: 'list'

Методы конкретных неизменяемых типов

Методы str (строка):

# Уникальны для строк
text = 'hello world'

print(text.upper())          # HELLO WORLD
print(text.lower())          # hello world
print(text.capitalize())     # Hello world
print(text.title())          # Hello World
print(text.swapcase())       # HELLO WORLD
print(text.center(20))       # '    hello world    '
print(text.ljust(20))        # 'hello world        '
print(text.rjust(20))        # '        hello world'
print(text.replace('world', 'python'))  # hello python
print(text.split())          # ['hello', 'world']
print(text.join(['a', 'b']))  # ahello world b
print(text.find('world'))    # 6
print(text.startswith('hello'))  # True
print(text.endswith('world'))    # True
print(text.isalpha())        # False (пробел)
print(text.isdigit())        # False
print(text.isalnum())        # False (пробел)
print('123'.isdigit())       # True

Методы tuple (кортеж):

t = (1, 2, 3, 2, 1)

print(t.count(2))    # 2 — количество элемента
print(t.index(2))    # 1 — индекс первого вхождения

# Нет методов: append, remove, pop (в отличие от list)

Методы frozenset (неизменяемое множество):

fs = frozenset([1, 2, 3])

print(fs | {4, 5})           # {1, 2, 3, 4, 5} — объединение
print(fs & {2, 3, 4})        # {2, 3} — пересечение
print(fs - {2})              # {1, 3} — разность
print(fs.issubset({1, 2, 3, 4}))     # True
print(fs.issuperset({1, 2}))         # True
print(fs.isdisjoint({4, 5}))         # True

# Нет методов: add, remove, discard, pop (в отличие от set)

Методы bytes (неизменяемые байты):

b = b'hello'

print(b.decode('utf-8'))    # 'hello' — преобразование в строку
print(b.upper())             # b'HELLO'
print(b.lower())             # b'hello'
print(b.find(b'l'))          # 2
print(b.replace(b'l', b'L')) # b'heLLo'

# Нет методов изменения, есть декодирование

Почему только неизменяемые?

Метод hash() требует, чтобы объект никогда не менялся после создания. Иначе его хеш изменится, и он потеряется в словаре или множестве:

# Опасный пример с изменяемым объектом (если бы он был хешируемым)
class MutableKey:
    def __init__(self, data):
        self.data = data
    
    def __hash__(self):
        return hash(tuple(self.data))
    
    def __eq__(self, other):
        return self.data == other.data

# Если бы это работало (чего не должно быть!):
key = MutableKey([1, 2, 3])
d = {key: 'value'}
key.data.append(4)  # Изменяем объект!
print(d[key])       # KeyError — объект потеряется

Поэтому Python запрещает хеширование изменяемых объектов:

class BadImmutable:
    def __init__(self, items):
        self.items = items  # Изменяемый список!
    
    def __hash__(self):
        return id(self)

obj = BadImmutable([1, 2, 3])
d = {obj: 'value'}
obj.items.append(4)  # Внезапное изменение!

Ключевые моменты

• hash() — главный метод неизменяемых типов
• Только хешируемые объекты могут быть ключами словаря и элементами множества
• Строки, кортежи, frozenset, числа — хешируемы
• Списки, словари, множества — не хешируемы
• Каждый неизменяемый тип имеет специфические методы (str.upper, tuple.count и т.д.)
• Изменяемость и хешируемость неразрывно связаны