Что такое объект в Python?

Что такое объект в Python

Объект в Python — это основная единица данных, которая имеет тип, идентичность и значение. Всё в Python является объектом: от простых чисел до сложных классов. Понимание этого концепта критично для работы с Python.

Три основные характеристики объекта

Каждый объект в Python имеет три главные свойства:

x = 42

# 1. Тип (type) — определяет, что это такое
print(type(x))      # <class 'int'>

# 2. Идентичность (id) — уникальный адрес в памяти
print(id(x))        # 140234356789456

# 3. Значение (value) — информация, которую хранит объект
print(x)            # 42

Это работает для всего:

# Строка
s = "hello"
print(type(s))      # <class 'str'>
print(id(s))        # Уникальный адрес
print(s)            # hello

# Список
lst = [1, 2, 3]
print(type(lst))    # <class 'list'>
print(id(lst))      # Уникальный адрес
print(lst)          # [1, 2, 3]

# Функция
def my_func():
    pass

print(type(my_func))  # <class 'function'>
print(id(my_func))    # Уникальный адрес
print(my_func)        # <function my_func at 0x...>

Всё является объектом

Программисты часто удивляются, но в Python действительно всё является объектом:

# Числа — объекты
num = 10
print(hasattr(num, '__class__'))  # True

# Функции — объекты
def greet(name):
    return f"Hello, {name}"

print(type(greet))  # <class 'function'>
print(greet.__name__)  # 'greet' (у функции есть атрибуты!)

# Классы — объекты
class Person:
    pass

print(type(Person))  # <class 'type'> (класс — это объект типа 'type')
print(Person.__name__)  # 'Person'

# Даже None — объект
print(type(None))    # <class 'NoneType'>
print(id(None))      # У него есть адрес в памяти

Создание объектов

1. Встроенные объекты (литералы)

# Числа
num = 42
float_num = 3.14
complex_num = 1 + 2j

# Строки
text = "Hello"

# Коллекции
my_list = [1, 2, 3]
my_dict = {'key': 'value'}
my_set = {1, 2, 3}
my_tuple = (1, 2, 3)

# Логические значения (тоже объекты!)
bool_val = True
print(type(bool_val))  # <class 'bool'>

2. Создание из встроенных функций

int_from_str = int("123")  # Создаём объект int
list_from_str = list("abc")  # Создаём объект list: ['a', 'b', 'c']
dict_from_list = dict([('a', 1), ('b', 2)])  # Создаём объект dict

3. Через классы

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        return f"{self.name} barks!"

# Создание объекта класса Dog
my_dog = Dog("Buddy", 3)

print(type(my_dog))      # <class '__main__.Dog'>
print(my_dog.name)       # Buddy
print(my_dog.age)        # 3
print(my_dog.bark())     # Buddy barks!

Атрибуты и методы объектов

class BankAccount:
    # Атрибут класса
    interest_rate = 0.05
    
    def __init__(self, owner, balance):
        # Атрибуты экземпляра
        self.owner = owner
        self.balance = balance
    
    # Методы (функции, привязанные к объекту)
    def deposit(self, amount):
        self.balance += amount
        return f"Deposited {amount}. New balance: {self.balance}"
    
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            return f"Withdrew {amount}. New balance: {self.balance}"
        return "Insufficient funds"
    
    def apply_interest(self):
        self.balance *= (1 + self.interest_rate)
        return f"Interest applied. New balance: {self.balance}"

# Создание объекта
account = BankAccount("John", 1000)

# Доступ к атрибутам
print(account.owner)          # John
print(account.balance)        # 1000
print(account.interest_rate)  # 0.05

# Вызов методов (методы — это функции, привязанные к объекту)
print(account.deposit(500))      # Deposited 500. New balance: 1500
print(account.apply_interest())  # Interest applied. New balance: 1575.0
print(account.withdraw(2000))    # Insufficient funds

Объекты как ссылки

Оченьважно понимать: переменная не содержит сам объект, а содержит ссылку на него:

# Два объекта
a = [1, 2, 3]
b = [1, 2, 3]

# Они имеют одинаковое содержимое, но разные адреса
print(a == b)  # True (значения равны)
print(a is b)  # False (разные объекты)
print(id(a), id(b))  # Разные идентичности

# Присваивание — это создание ещё одной ссылки на один объект
c = a
print(c is a)  # True (один и тот же объект)
print(id(c) == id(a))  # True

# Если мы изменяем объект через c, то a тоже изменится
c.append(4)
print(a)  # [1, 2, 3, 4]
print(c)  # [1, 2, 3, 4]

Типы объектов в Python

# Встроенные типы

# Числовые типы
print(type(42))           # <class 'int'>
print(type(3.14))        # <class 'float'>
print(type(True))        # <class 'bool'>
print(type(1+2j))        # <class 'complex'>

# Последовательности
print(type([1, 2]))       # <class 'list'>
print(type((1, 2)))       # <class 'tuple'>
print(type("hello"))      # <class 'str'>
print(type(b"hello"))     # <class 'bytes'>
print(type(bytearray()))  # <class 'bytearray'>

# Коллекции
print(type({'a': 1}))     # <class 'dict'>
print(type({1, 2, 3}))    # <class 'set'>
print(type(frozenset()))  # <class 'frozenset'>

# Специальные типы
print(type(None))         # <class 'NoneType'>
print(type(lambda x: x))  # <class 'function'>
print(type(print))        # <class 'builtin_function_or_method'>

Объекты и память

import sys

# Проверка размера объекта в памяти
x = 42
print(sys.getsizeof(x))  # 28 байт (даже число занимает место в памяти!)

# Список содержит ссылки на объекты
my_list = [1, 2, 3, "hello", [4, 5]]

# Каждый элемент — это ссылка на отдельный объект
for item in my_list:
    print(f"{item} -> ID: {id(item)}, Type: {type(item)}")

Специальные методы объектов

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    
    # Представление объекта в виде строки для пользователя
    def __str__(self):
        return f"{self.name} costs ${self.price}"
    
    # Техническое представление для разработчика
    def __repr__(self):
        return f"Product('{self.name}', {self.price})"
    
    # Сравнение объектов
    def __eq__(self, other):
        return self.price == other.price
    
    # Хеширование (для использования в dict и set)
    def __hash__(self):
        return hash((self.name, self.price))
    
    # Длина объекта
    def __len__(self):
        return len(self.name)
    
    # Что происходит при удалении объекта
    def __del__(self):
        print(f"Product {self.name} deleted")

product = Product("Laptop", 999)
print(product)        # "Laptop costs $999" (использует __str__)
print(repr(product))  # "Product('Laptop', 999)" (использует __repr__)
print(len(product))   # 6 (длина названия)

Проверка объектов

# Проверка типа
obj = [1, 2, 3]
print(isinstance(obj, list))   # True
print(isinstance(obj, (list, tuple)))  # True

# Проверка наличия атрибута
class User:
    def __init__(self, name):
        self.name = name

user = User("Alice")
print(hasattr(user, 'name'))      # True
print(hasattr(user, 'email'))     # False
print(getattr(user, 'name'))      # 'Alice'
print(getattr(user, 'email', 'no-email@example.com'))  # 'no-email@example.com'

# Проверка callable (можно ли вызвать как функцию)
print(callable(print))             # True
print(callable([1, 2, 3]))         # False
print(callable(User))              # True (классы вызываемы)

Практический пример: система управления объектами

class Vehicle:
    total_vehicles = 0  # Атрибут класса
    
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
        Vehicle.total_vehicles += 1
    
    def get_info(self):
        return f"{self.brand} {self.model}"
    
    def __str__(self):
        return self.get_info()

class Car(Vehicle):  # Наследование
    def __init__(self, brand, model, num_doors):
        super().__init__(brand, model)
        self.num_doors = num_doors

# Создание объектов
car1 = Car("Toyota", "Camry", 4)
car2 = Car("Honda", "Civic", 2)

print(car1)  # Toyota Camry
print(Vehicle.total_vehicles)  # 2
print(isinstance(car1, Vehicle))  # True
print(isinstance(car1, Car))      # True

Итог

Объект в Python — это:

1. Самостоятельная единица данных с типом, идентичностью и значением
2. Хранилище информации (атрибуты) и поведения (методы)
3. Ссылка в памяти — переменная содержит адрес объекта, не сам объект
4. Всё, что существует в Python (даже функции и классы)

Этот объектно-ориентированный подход делает Python мощным и гибким языком, позволяя работать с абстракциями высокого уровня, сохраняя при этом полный контроль над низкоуровневыми деталями.