Что такое экземпляр класса?

Экземпляр класса в Python (объект)

Экземпляр класса — это конкретный объект, созданный на основе класса. Класс — это шаблон, а экземпляр — это реальный объект с конкретными данными.

Класс vs Экземпляр

Класс — это чертеж, описание структуры и поведения Экземпляр — это конкретный объект, созданный по этому чертежу

# КЛАСС — это шаблон
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        return f"{self.name} says: Woof!"

# ЭКЗЕМПЛЯРЫ — конкретные объекты
dog1 = Dog("Buddy", 5)
dog2 = Dog("Max", 3)
dog3 = Dog("Luna", 2)

print(dog1.bark())  # Buddy says: Woof!
print(dog2.bark())  # Max says: Woof!
print(dog3.bark())  # Luna says: Woof!

# Разные экземпляры, одинаковый класс
print(type(dog1))  # <class '__main__.Dog'>
print(type(dog2))  # <class '__main__.Dog'>
print(type(dog3))  # <class '__main__.Dog'>

Создание экземпляра

Экземпляр создается вызовом класса как функции:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
        self.speed = 0
    
    def accelerate(self):
        self.speed += 10
        return f"{self.brand} {self.model} accelerates to {self.speed} km/h"

# Создание экземпляра
# 1. Python создает новый пустой объект
# 2. Вызывает __init__ со аргументами
# 3. Возвращает заполненный объект
my_car = Car("Toyota", "Camry")

print(my_car.brand)    # Toyota
print(my_car.model)    # Camry
print(my_car.speed)    # 0
print(my_car.accelerate())  # Toyota Camry accelerates to 10 km/h

Атрибуты экземпляра (instance attributes)

Каждый экземпляр имеет собственные данные:

class Person:
    def __init__(self, name, age):
        # Атрибуты экземпляра — это переменные, уникальные для каждого объекта
        self.name = name
        self.age = age
        self.email = None

person1 = Person("John", 30)
person2 = Person("Jane", 25)

# Разные данные в разных экземплярах
print(person1.name, person1.age)  # John 30
print(person2.name, person2.age)  # Jane 25

# Изменение в одном не влияет на другой
person1.age = 31
print(person1.age)  # 31
print(person2.age)  # 25 (не изменился)

Методы экземпляра (instance methods)

Методы работают с данными конкретного экземпляра:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
    
    # Метод экземпляра — имеет self как первый параметр
    def deposit(self, amount):
        self.balance += amount
        return f"{self.owner} deposited {amount}. New balance: {self.balance}"
    
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            return f"Withdrew {amount}. Remaining: {self.balance}"
        return "Insufficient funds"

# Создаем экземпляры
acc1 = BankAccount("Alice", 1000)
acc2 = BankAccount("Bob", 500)

# Каждый экземпляр имеет свое состояние
print(acc1.deposit(200))    # Alice deposited 200. New balance: 1200
print(acc2.deposit(100))    # Bob deposited 100. New balance: 600
print(acc1.balance)          # 1200
print(acc2.balance)          # 600

Переменные класса vs экземпляра

class Counter:
    # Переменная класса — одна для всех экземпляров
    total_count = 0
    
    def __init__(self, name):
        # Переменная экземпляра — уникальна для каждого объекта
        self.name = name
        Counter.total_count += 1

c1 = Counter("First")
c2 = Counter("Second")
c3 = Counter("Third")

# Переменная экземпляра: разные значения
print(c1.name)  # First
print(c2.name)  # Second
print(c3.name)  # Third

# Переменная класса: одна для всех
print(Counter.total_count)  # 3
print(c1.total_count)        # 3 (обращение через экземпляр тоже работает)
print(c2.total_count)        # 3

Проверка, является ли объект экземпляром класса

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

# isinstance проверяет, является ли объект экземпляром класса
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True (наследование)
print(isinstance(dog, str))     # False

# type проверяет точный класс
print(type(dog) is Dog)         # True
print(type(dog) is Animal)      # False

init и создание экземпляров

class Product:
    def __init__(self, name, price, stock=0):
        # Инициализация экземпляра
        self.name = name
        self.price = price
        self.stock = stock
        self.created_at = None
    
    def __repr__(self):
        # Представление экземпляра в виде строки
        return f"Product('{self.name}', ${self.price}, {self.stock} in stock)"

# Создание экземпляров
product1 = Product("Laptop", 999.99, 5)
product2 = Product("Mouse", 29.99)  # stock не указан, используется 0

print(product1)  # Product('Laptop', $999.99, 5 in stock)
print(product2)  # Product('Mouse', $29.99, 0 in stock)

Изменение атрибутов экземпляра

class Student:
    def __init__(self, name, gpa=0.0):
        self.name = name
        self.gpa = gpa

student = Student("John", 3.5)

# Изменение существующего атрибута
student.gpa = 3.8
print(student.gpa)  # 3.8

# Добавление нового атрибута (Python позволяет!)
student.email = "john@university.edu"
print(student.email)  # john@university.edu

# Удаление атрибута
del student.gpa
print(hasattr(student, 'gpa'))  # False

Реальный пример: ORM модель (Django/SQLAlchemy)

from sqlalchemy import Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    
    id = Column(Integer, primary_key=True)
    username = Column(String, unique=True)
    email = Column(String)
    created_at = Column(DateTime, default=datetime.now)
    
    def __repr__(self):
        return f"<User(username='{self.username}', email='{self.email}')>"

# Создание экземпляров
user1 = User(username="john_doe", email="john@example.com")
user2 = User(username="jane_doe", email="jane@example.com")

# Каждый экземпляр — это объект из БД
print(user1)  # <User(username='john_doe', email='john@example.com')>
print(user2)  # <User(username='jane_doe', email='jane@example.com')>

# Сессия сохранит их в БД
session.add(user1)
session.add(user2)
session.commit()

Важные концепции

1. id(объект) — уникальный идентификатор в памяти

obj1 = Dog("Buddy")
obj2 = Dog("Buddy")  # Другой объект, другие данные в памяти

print(id(obj1))  # 140234567891234
print(id(obj2))  # 140234567891235
# Разные объекты, хотя имеют одинаковые имена

2. == vs is

obj1 = [1, 2, 3]
obj2 = [1, 2, 3]

print(obj1 == obj2)   # True (равные значения)
print(obj1 is obj2)   # False (разные объекты в памяти)

3. Правильное использование экземпляров

# ПРАВИЛЬНО: использование экземпляров для разных данных
student1 = Student("Alice")
student2 = Student("Bob")
student3 = Student("Charlie")

# НЕПРАВИЛЬНО: один объект для разных данных
data = {"name": "Alice"}  # Просто словарь, не гибко

Вывод

Экземпляр класса — это объект с конкретными данными. Основные моменты:

• Класс = шаблон, экземпляр = конкретный объект
• Каждый экземпляр имеет собственные атрибуты
• Методы работают с данными конкретного экземпляра
• Использование экземпляров делает код модульным и переиспользуемым
• В Python всё — объект, всё — экземпляр какого-то класса