Объектно-ориентированное программирование на Python: принципы и практики

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

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

def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("Нельзя откручивать одометр назад!")

def increment_odometer(self, miles):
self.odometer_reading += miles

my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name()) # Выведет: 2019 audi a4
my_new_car.update_odometer(23500)
print(my_new_car.odometer_reading) # Выведет: 23500

class Book:
def __init__(self, title, author, pages):
self.title = title
self.author = author
self.pages = pages

def __str__(self):
return f"{self.title} by {self.author}"

def __len__(self):
return self.pages

def __del__(self):
print(f"Book {self.title} has been deleted")

book = Book("Python Crash Course", "Eric Matthes", 544)
print(book) # Вызывает __str__() и выводит: Python Crash Course by Eric Matthes
print(len(book)) # Вызывает __len__() и выводит: 544
del book # Вызывает __del__() и выводит: Book Python Crash Course has been deleted

class Dog:
# Атрибут класса – общий для всех экземпляров
species = "Canis familiaris"

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

# Родительский класс
class Animal:
def __init__(self, name, species):
self.name = name
self.species = species

def make_sound(self):
print("Некоторый звук животного")

def info(self):
return f"{self.name} принадлежит к виду {self.species}"

# Дочерний класс, наследующий от Animal
class Dog(Animal):
def __init__(self, name, breed):
# Вызываем конструктор родительского класса
super().__init__(name, "Canis familiaris")
self.breed = breed

# Переопределяем метод родительского класса
def make_sound(self):
return "Гав!"

# Добавляем новый метод
def wag_tail(self):
return f"{self.name} виляет хвостом"

# Еще один дочерний класс
class Cat(Animal):
def __init__(self, name, breed):
super().__init__(name, "Felis catus")
self.breed = breed

def make_sound(self):
return "Мяу!"

rex = Dog("Рекс", "Немецкая овчарка")
whiskers = Cat("Вискерс", "Сиамская")

print(rex.info()) # Выведет: Рекс принадлежит к виду Canis familiaris
print(rex.make_sound()) # Выведет: Гав!
print(rex.wag_tail()) # Выведет: Рекс виляет хвостом

print(whiskers.info()) # Выведет: Вискерс принадлежит к виду Felis catus
print(whiskers.make_sound()) # Выведет: Мяу!

class Flying:
def fly(self):
return "Я могу летать!"

class Swimming:
def swim(self):
return "Я могу плавать!"

class Duck(Animal, Flying, Swimming):
def __init__(self, name):
super().__init__(name, "Утка")

def make_sound(self):
return "Кря!"

donald = Duck("Дональд")
print(donald.make_sound()) # Выведет: Кря!
print(donald.fly()) # Выведет: Я могу летать!
print(donald.swim()) # Выведет: Я могу плавать!

def animal_chorus(animals):
for animal in animals:
print(animal.make_sound())

# Создаем разных животных
rex = Dog("Рекс", "Овчарка")
whiskers = Cat("Вискерс", "Сиамская")
donald = Duck("Дональд")

# Все они могут "петь" в нашем хоре, хотя звуки разные
animal_chorus([rex, whiskers, donald])
# Выведет:
# Гав!
# Мяу!
# Кря!

class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner # Публичный атрибут
self._balance = balance # Защищенный атрибут
self.__transaction_log = [] # Приватный атрибут

def deposit(self, amount):
if amount > 0:
self._balance += amount
self.__log_transaction("deposit", amount)
return True
return False

def withdraw(self, amount):
if 0 < amount <= self._balance:
self._balance -= amount
self.__log_transaction("withdrawal", amount)
return True
return False

def get_balance(self):
return self._balance

def __log_transaction(self, transaction_type, amount):
self.__transaction_log.append(f"{transaction_type}: {amount}")

# Свойство для безопасного доступа к защищенному атрибуту
@property
def balance(self):
return self._balance

# Свойство для безопасной установки значения
@balance.setter
def balance(self, value):
if value >= 0:
self._balance = value
else:
raise ValueError("Баланс не может быть отрицательным")

account = BankAccount("Иван Иванов", 1000)

# Работа с публичными методами
account.deposit(500)
account.withdraw(200)

# Доступ через свойство
print(account.balance) # Выведет: 1300

# Попытка напрямую изменить защищенный атрибут (не рекомендуется)
account._balance = 2000 # Технически возможно, но нарушает инкапсуляцию

# Попытка доступа к приватному атрибуту
try:
print(account.__transaction_log) # Вызовет AttributeError
except AttributeError:
print("Нет прямого доступа к приватным атрибутам")

from abc import ABC, abstractmethod

class Shape(ABC):
@abstractmethod
def area(self):
pass

@abstractmethod
def perimeter(self):
pass

class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height

def area(self):
return self.width * self.height

def perimeter(self):
return 2 * (self.width + self.height)

class Circle(Shape):
def __init__(self, radius):
self.radius = radius

def area(self):
import math
return math.pi * self.radius ** 2

def perimeter(self):
import math
return 2 * math.pi * self.radius

# Это вызовет ошибку: TypeError: Can't instantiate abstract class Shape
# shape = Shape()

# Это работает, так как Rectangle реализует все абстрактные методы
rectangle = Rectangle(5, 4)
print(f"Площадь прямоугольника: {rectangle.area()}") # 20
print(f"Периметр прямоугольника: {rectangle.perimeter()}") # 18

class Book:
def __init__(self, title, author, isbn):
self.title = title
self.author = author
self.isbn = isbn
self.is_available = True
self.current_holder = None

def __str__(self):
status = "доступна" if self.is_available else f"выдана {self.current_holder}"
return f"Книга '{self.title}' ({self.author}), ISBN: {self.isbn}, статус: {status}"

class Member:
def __init__(self, name, member_id):
self.name = name
self.member_id = member_id
self.books_borrowed = []

def __str__(self):
return f"Читатель: {self.name}, ID: {self.member_id}, Книг на руках: {len(self.books_borrowed)}"

class Library:
def __init__(self, name):
self.name = name
self.books = {}
self.members = {}

def add_book(self, book):
self.books[book.isbn] = book
return True

def add_member(self, member):
self.members[member.member_id] = member
return True

def lend_book(self, isbn, member_id):
if isbn not in self.books or member_id not in self.members:
return False

book = self.books[isbn]
member = self.members[member_id]

if not book.is_available:
return False

book.is_available = False
book.current_holder = member.name
member.books_borrowed.append(book)
return True

def return_book(self, isbn, member_id):
if isbn not in self.books or member_id not in self.members:
return False

book = self.books[isbn]
member = self.members[member_id]

if book.is_available or book not in member.books_borrowed:
return False

book.is_available = True
book.current_holder = None
member.books_borrowed.remove(book)
return True

# Создание библиотеки
library = Library("Городская библиотека №1")

# Добавление книг
book1 = Book("1984", "Джордж Оруэлл", "9780451524935")
book2 = Book("Гарри Поттер и философский камень", "Дж. К. Роулинг", "9781408855652")
book3 = Book("Властелин колец", "Дж.Р.Р. Толкиен", "9780544003415")

library.add_book(book1)
library.add_book(book2)
library.add_book(book3)

# Регистрация читателей
member1 = Member("Иван Петров", "M001")
member2 = Member("Елена Сидорова", "M002")

library.add_member(member1)
library.add_member(member2)

# Выдача и возврат книг
library.lend_book("9780451524935", "M001")
library.lend_book("9781408855652", "M002")
print(book1) # Книга '1984' (Джордж Оруэлл), ISBN: 9780451524935, статус: выдана Иван Петров
print(member1) # Читатель: Иван Петров, ID: M001, Книг на руках: 1

library.return_book("9780451524935", "M001")
print(book1) # Книга '1984' (Джордж Оруэлл), ISBN: 9780451524935, статус: доступна

class Product:
def __init__(self, product_id, name, price, stock=0):
self.product_id = product_id
self.name = name
self.price = price
self.stock = stock

def __str__(self):
return f"{self.name} (ID: {self.product_id}): ${self.price:.2f}, На складе: {self.stock}"

class CartItem:
def __init__(self, product, quantity=1):
self.product = product
self.quantity = quantity

def get_subtotal(self):
return self.product.price * self.quantity

def __str__(self):
return f"{self.product.name} x {self.quantity}: ${self.get_subtotal():.2f}"

class ShoppingCart:
def __init__(self):
self.items = []

def add_item(self, product, quantity=1):
if product.stock < quantity:
return False

# Проверяем, есть ли уже такой товар в корзине
for item in self.items:
if item.product.product_id == product.product_id:
item.quantity += quantity
product.stock -= quantity
return True

# Если товара нет в корзине, добавляем новый
self.items.append(CartItem(product, quantity))
product.stock -= quantity
return True

def remove_item(self, product_id, quantity=None):
for i, item in enumerate(self.items):
if item.product.product_id == product_id:
if quantity is None or quantity >= item.quantity:
# Возвращаем товар на склад
item.product.stock += item.quantity
# Удаляем позицию полностью
self.items.pop(i)
else:
# Возвращаем часть товара на склад
item.product.stock += quantity
item.quantity -= quantity
return True
return False

def get_total(self):
return sum(item.get_subtotal() for item in self.items)

def __str__(self):
if not self.items:
return "Корзина пуста"

item_strings = [str(item) for item in self.items]
return "Корзина:\n" + "\n".join(item_strings) + f"\nИтого: ${self.get_total():.2f}"

class Customer:
def __init__(self, name, email):
self.name = name
self.email = email
self.cart = ShoppingCart()

def add_to_cart(self, product, quantity=1):
return self.cart.add_item(product, quantity)

def remove_from_cart(self, product_id, quantity=None):
return self.cart.remove_item(product_id, quantity)

def checkout(self):
if not self.cart.items:
return False

# В реальной системе здесь была бы логика оформления заказа
# Очищаем корзину после успешного оформления
order_total = self.cart.get_total()
self.cart = ShoppingCart()
return order_total

# Создаем товары
laptop = Product("P001", "Ноутбук Dell XPS 13", 1299.99, 5)
mouse = Product("P002", "Мышь Logitech MX Master", 99.99, 15)
keyboard = Product("P003", "Клавиатура Keychron K2", 79.99, 8)

# Создаем покупателя
customer = Customer("Мария Иванова", "maria@example.com")

# Добавляем товары в корзину
customer.add_to_cart(laptop)
customer.add_to_cart(mouse, 2)
print(customer.cart) # Выводит содержимое корзины

# Удаляем один экземпляр мыши из корзины
customer.remove_from_cart("P002", 1)
print(customer.cart) # Обновленное содержимое корзины

# Оформляем заказ
order_total = customer.checkout()
print(f"Заказ оформлен на сумму: ${order_total:.2f}")
print(customer.cart) # Корзина пуста