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

def drive(self, distance):
self.odometer += distance
return f"Driving {distance} km. Total: {self.odometer} km"

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

# Создание объекта
my_car = Car("Toyota", "Corolla", 2020)
print(my_car.get_description()) # 2020 Toyota Corolla
print(my_car.drive(100)) # Driving 100 km. Total: 100 km

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

def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)

def __str__(self):
return f"Vector({self.x}, {self.y})"

def __len__(self):
return int((self.x**2 + self.y**2)**0.5)

v1 = Vector(2, 4)
v2 = Vector(3, 1)
v3 = v1 + v2 # Использует метод __add__
print(v3) # Vector(5, 5) – использует метод __str__
print(len(v1)) # 4 – использует метод __len__

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

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

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

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

account = BankAccount("John", 1000)
account.deposit(500)
print(account._balance) # 1500 – доступно, но не рекомендуется
# print(account.__transaction_log) # Ошибка! Атрибут недоступен
# print(account._BankAccount__transaction_log) # ['deposit: 500'] – name mangling

# Базовый класс
class Vehicle:
def __init__(self, make, model):
self.make = make
self.model = model

def start_engine(self):
return "Engine started!"

def stop_engine(self):
return "Engine stopped!"

# Дочерний класс
class Car(Vehicle):
def __init__(self, make, model, fuel_type):
super().__init__(make, model) # Вызов конструктора родителя
self.fuel_type = fuel_type
self.wheels = 4

def honk(self):
return "Beep beep!"

# Использование
my_car = Car("Toyota", "Camry", "Petrol")
print(my_car.make) # Toyota (унаследовано от Vehicle)
print(my_car.start_engine()) # Engine started! (метод Vehicle)
print(my_car.honk()) # Beep beep! (метод Car)

class Engine:
def start(self):
return "Engine running"

def stop(self):
return "Engine stopped"

class ElectricSystem:
def charge(self):
return "Charging..."

def start(self):
return "Electric systems online"

# Множественное наследование
class HybridVehicle(Vehicle, Engine, ElectricSystem):
def __init__(self, make, model):
super().__init__(make, model)
self.battery_level = 100

def start_vehicle(self):
engine_status = self.start() # Какой метод start будет вызван?
return f"{engine_status}, vehicle ready to go!"

hybrid = HybridVehicle("Toyota", "Prius")
print(hybrid.start_vehicle())

print(HybridVehicle.__mro__)
# (<class '__main__.HybridVehicle'>, <class '__main__.Vehicle'>, <class '__main__.Engine'>, 
# <class '__main__.ElectricSystem'>, <class 'object'>)

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)

# shape = Shape() # TypeError: Can't instantiate abstract class
rect = Rectangle(5, 3)
print(rect.area()) # 15
print(rect.perimeter()) # 16

class Animal:
def speak(self):
pass

class Dog(Animal):
def speak(self):
return "Woof!"

class Cat(Animal):
def speak(self):
return "Meow!"

class Duck(Animal):
def speak(self):
return "Quack!"

# Функция, демонстрирующая полиморфизм
def animal_sound(animal):
return animal.speak()

# Создаем разных животных
dog = Dog()
cat = Cat()
duck = Duck()

# Один интерфейс – разные результаты
print(animal_sound(dog)) # Woof!
print(animal_sound(cat)) # Meow!
print(animal_sound(duck)) # Quack!

class Car:
def move(self):
return "Driving on the road"

class Boat:
def move(self):
return "Sailing on water"

class Plane:
def move(self):
return "Flying in the air"

def journey(vehicle):
# Duck typing: неважно, какой класс у vehicle, главное, что есть метод move()
return vehicle.move()

transport_modes = [Car(), Boat(), Plane()]

for vehicle in transport_modes:
print(journey(vehicle))
# Driving on the road
# Sailing on water
# Flying in the air

class Money:
def __init__(self, amount, currency):
self.amount = amount
self.currency = currency

def __add__(self, other):
if self.currency != other.currency:
raise ValueError("Cannot add different currencies")
return Money(self.amount + other.amount, self.currency)

def __sub__(self, other):
if self.currency != other.currency:
raise ValueError("Cannot subtract different currencies")
return Money(self.amount – other.amount, self.currency)

def __str__(self):
return f"{self.amount} {self.currency}"

def __eq__(self, other):
return self.amount == other.amount and self.currency == other.currency

# Использование перегруженных операторов
usd1 = Money(100, "USD")
usd2 = Money(50, "USD")
eur = Money(100, "EUR")

print(usd1 + usd2) # 150 USD
print(usd1 – usd2) # 50 USD
print(usd1 == usd2) # False
# print(usd1 + eur) # ValueError: Cannot add different currencies

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

def calculate_bonus(self):
return self.salary * 0.1

class Manager(Employee):
def calculate_bonus(self):
return self.salary * 0.2

class Executive(Employee):
def calculate_bonus(self):
return self.salary * 0.3

# Полиморфный код для расчета бонусов
employees = [
Employee("John", 50000),
Manager("Sarah", 70000),
Executive("Michael", 90000)
]

for employee in employees:
print(f"{employee.name}: ${employee.calculate_bonus()}")
# John: $5000.0
# Sarah: $14000.0
# Michael: $27000.0

import tkinter as tk

class Calculator:
def __init__(self, master):
self.master = master
master.title("Simple Calculator")

# Создаем и настраиваем виджеты
self.display = tk.Entry(master, width=30, borderwidth=5)
self.display.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

# Создаем кнопки
self.create_buttons()

# Текущее состояние
self.first_number = 0
self.operation = None

def create_buttons(self):
# Числовые кнопки
self.button_1 = self.create_number_button(1, 3, 0)
self.button_2 = self.create_number_button(2, 3, 1)
# ... другие кнопки ...

def create_number_button(self, number, row, column):
button = tk.Button(self.master, text=str(number), padx=40, pady=20,
command=lambda: self.button_click(number))
button.grid(row=row, column=column)
return button

def button_click(self, number):
current = self.display.get()
self.display.delete(0, tk.END)
self.display.insert(0, current + str(number))

# ... другие методы для операций калькулятора ...

# Использование класса
if __name__ == "__main__":
root = tk.Tk()
calculator = Calculator(root)
root.mainloop()

import sqlite3

class Database:
def __init__(self, db_name):
self.conn = sqlite3.connect(db_name)
self.cursor = self.conn.cursor()
self.setup_tables()

def setup_tables(self):
self.cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT,
email TEXT,
age INTEGER
)
''')
self.conn.commit()

def add_user(self, user):
self.cursor.execute('''
INSERT INTO users (name, email, age) VALUES (?, ?, ?)
''', (user.name, user.email, user.age))
self.conn.commit()
return self.cursor.lastrowid

def get_user_by_id(self, user_id):
self.cursor.execute('SELECT * FROM users WHERE id=?', (user_id,))
data = self.cursor.fetchone()
if data:
return User(data[1], data[2], data[3], data[0])
return None

def close(self):
self.conn.close()

class User:
def __init__(self, name, email, age, id=None):
self.id = id
self.name = name
self.email = email
self.age = age

def __str__(self):
return f"User(id={self.id}, name={self.name}, email={self.email}, age={self.age})"

# Использование
db = Database("users.db")
user1 = User("Alice", "alice@example.com", 28)
user_id = db.add_user(user1)
retrieved_user = db.get_user_by_id(user_id)
print(retrieved_user) # User(id=1, name=Alice, email=alice@example.com, age=28)
db.close()

from flask import Flask, request, jsonify
from flask.views import MethodView

app = Flask(__name__)

class UserAPI(MethodView):
users = {} # В реальном приложении здесь была бы база данных

def get(self, user_id=None):
if user_id is None:
# Возвращаем список всех пользователей
return jsonify(list(self.users.values()))
elif user_id in self.users:
# Возвращаем конкретного пользователя
return jsonify(self.users[user_id])
else:
return jsonify({"error": "User not found"}), 404

def post(self):
data = request.get_json()
user_id = len(self.users) + 1
user = {
"id": user_id,
"name": data.get("name"),
"email": data.get("email")
}
self.users[user_id] = user
return jsonify(user), 201

def put(self, user_id):
if user_id not in self.users:
return jsonify({"error": "User not found"}), 404

data = request.get_json()
user = self.users[user_id]

if "name" in data:
user["name"] = data["name"]
if "email" in data:
user["email"] = data["email"]

return jsonify(user)

def delete(self, user_id):
if user_id not in self.users:
return jsonify({"error": "User not found"}), 404

del self.users[user_id]
return "", 204

# Регистрация API endpoints
user_view = UserAPI.as_view("user_api")
app.add_url_rule('/users/', view_func=user_view, methods=['GET', 'POST'])
app.add_url_rule('/users/<int:user_id>', view_func=user_view, 
methods=['GET', 'PUT', 'DELETE'])

if __name__ == '__main__':
app.run(debug=True)

import pygame
import random

class GameObject:
def __init__(self, x, y, width, height, color):
self.x = x
self.y = y
self.width = width
self.height = height
self.color = color
self.rect = pygame.Rect(x, y, width, height)

def draw(self, screen):
pygame.draw.rect(screen, self.color, self.rect)

class Player(GameObject):
def __init__(self, x, y):
super().__init__(x, y, 50, 50, (0, 255, 0))
self.speed = 5

def update(self, keys):
if keys[pygame.K_LEFT]:
self.x -= self.speed
if keys[pygame.K_RIGHT]:
self.x += self.speed
if keys[pygame.K_UP]:
self.y -= self.speed
if keys[pygame.K_DOWN]:
self.y += self.speed

# Обновляем прямоугольник
self.rect.x = self.x
self.rect.y = self.y

class Enemy(GameObject):
def __init__(self, x, y):
super().__init__(x, y, 30, 30, (255, 0, 0))
self.speed = random.randint(1, 3)

def update(self):
self.y += self.speed
self.rect.y = self.y

# Если враг достиг нижней границы
if self.y > 600:
self.y = -30
self.x = random.randint(0, 770)
self.rect.x = self.x

# Основной игровой код (упрощенный)
def main():
pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()

player = Player(400, 500)
enemies = [Enemy(random.randint(0, 770), random.randint(-300, 0)) for _ in range(10)]

running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False

keys = pygame.key.get_pressed()
player.update(keys)

for enemy in enemies:
enemy.update()

# Проверка столкновений...

# Отрисовка
screen.fill((0, 0, 0))
player.draw(screen)
for enemy in enemies:
enemy.draw(screen)

pygame.display.flip()
clock.tick(60)

pygame.quit()

# if __name__ == "__main__":
# main()