Python | Вопросы собесов

package/

py
item.py
subpackage/

py
subitem.py

import package.item

# Теперь вы можете использовать функции и классы из package.item
package.item.some_function()

math_operations/

py
addition.py
subtraction.py

def add(a, b):
return a + b

def subtract(a, b):
return a - b

import math_operations.addition
import math_operations.subtraction

result_add = math_operations.addition.add(5, 3)
result_subtract = math_operations.subtraction.subtract(5, 3)

print("Addition:", result_add)  # Выведет: Addition: 8
print("Subtraction:", result_subtract)  # Выведет: Subtraction: 2

     GET https://api.example.com/users/123
     

def task_1():
    raise ValueError("Ошибка в задаче 1")

def task_2():
    raise TypeError("Ошибка в задаче 2")

try:
    # Создаем группу исключений
    raise ExceptionGroup(
        "Ошибки в задачах",
        [ValueError("Ошибка в задаче 1"), TypeError("Ошибка в задаче 2")]
    )
except ExceptionGroup as eg:
    for exc in eg.exceptions:
        print(f"Обнаружено исключение: {exc}")

Обнаружено исключение: Ошибка в задаче 1
Обнаружено исключение: Ошибка в задаче 2

try:
    raise ExceptionGroup(
        "Ошибки в задачах",
        [ValueError("Ошибка 1"), TypeError("Ошибка 2"), ValueError("Ошибка 3")]
    )
except* ValueError as ve:
    print("Обрабатываем ValueError:", ve)
except* TypeError as te:
    print("Обрабатываем TypeError:", te)

Обрабатываем ValueError: Ошибка 1
Обрабатываем ValueError: Ошибка 3
Обрабатываем TypeError: Ошибка 2

import asyncio

async def fetch_data():
    print("Начинаем загрузку данных...")
    await asyncio.sleep(2)  # Асинхронная пауза (имитирует длительную операцию)
    print("Данные загружены!")
    return {"data": "some data"}

async def main():
    print("Старт программы")
    data = await fetch_data()
    print(f"Результат: {data}")
    print("Конец программы")

# Запуск цикла событий
asyncio.run(main())

import threading
import time

def task(name):
    print(f"Начало задачи {name}")
    time.sleep(2)  # Имитация длительной операции
    print(f"Конец задачи {name}")

# Создаем и запускаем потоки
thread1 = threading.Thread(target=task, args=("A",))
thread2 = threading.Thread(target=task, args=("B",))

thread1.start()
thread2.start()

# Ожидаем завершения потоков
thread1.join()
thread2.join()
print("Все задачи завершены")

   employees = [
       {"name": "Alice", "age": 30, "salary": 70000},
       {"name": "Bob", "age": 25, "salary": 50000},
       {"name": "Charlie", "age": 35, "salary": 120000}
   ]

   # Сортировка по возрасту
   sorted_employees = sorted(employees, key=lambda x: x["age"])

   print(sorted_employees)
   

   [{'name': 'Bob', 'age': 25, 'salary': 50000},
    {'name': 'Alice', 'age': 30, 'salary': 70000},
    {'name': 'Charlie', 'age': 35, 'salary': 120000}]
   

   employees = [
       {"name": "Alice", "age": 30, "salary": 70000},
       {"name": "Bob", "age": 25, "salary": 50000},
       {"name": "Charlie", "age": 35, "salary": 120000}
   ]

   # Сортировка по зарплате
   employees.sort(key=lambda x: x["salary"])

   print(employees)
   

   [{'name': 'Bob', 'age': 25, 'salary': 50000},
    {'name': 'Alice', 'age': 30, 'salary': 70000},
    {'name': 'Charlie', 'age': 35, 'salary': 120000}]
   

   sorted_employees_desc = sorted(employees, key=lambda x: x["age"], reverse=True)
   print(sorted_employees_desc)
   

   from operator import itemgetter

   sorted_employees = sorted(employees, key=itemgetter("age"))
   print(sorted_employees)
   

employees = [
    {"name": "Alice", "age": 30},
    {"name": "Bob"},
    {"name": "Charlie", "age": 35}
]

sorted_employees = sorted(employees, key=lambda x: x.get("age", 0))
print(sorted_employees)

[{'name': 'Bob'},
 {'name': 'Alice', 'age': 30},
 {'name': 'Charlie', 'age': 35}]

class MyClass:
    def __init__(self, value):
        self.value = value

    def increment(self):
        self.value += 1

# Использование
obj = MyClass(10)
obj.increment()
print(obj.value)  # Вывод: 11

class MyClass:
    count = 0

    def __init__(self):
        MyClass.count += 1

    @classmethod
    def get_count(cls):
        return cls.count

# Использование
obj1 = MyClass()
obj2 = MyClass()
print(MyClass.get_count())  # Вывод: 2

class MyClass:
    @staticmethod
    def greet(name):
        return f"Hello, {name}!"

# Использование
print(MyClass.greet("Alice"))  # Вывод: Hello, Alice!

        class MyClass:
        def init(self, value):
            self.value = value

    obj = MyClass(10)

        class MyClass:
        def init(self, value):
            self.value = value

        def str(self):
            return f"MyClass with value: {self.value}"

    obj = MyClass(10)
    print(obj)  # Вывод: MyClass with value: 10

    class MyList:
        def __init__(self, items):
            self.items = items

        def __getitem__(self, index):
            return self.items[index]

        def __setitem__(self, index, value):
            self.items[index] = value

        def __delitem__(self, index):
            del self.items[index]

    lst = MyList([1, 2, 3])
    print(lst[1])  # Вывод: 2
    lst[1] = 20
    print(lst[1])  # Вывод: 20
    del lst[1]
    print(lst.items)  # Вывод: [1, 3]
    

    ```python
    class ManagedResource:
        def enter(self):
            print("Entering the context")
            return self

        def exit(self, exc_type, exc_value, traceback):
            print("Exiting the context")
            return False

    with ManagedResource():
        print("Inside the context")

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

# Использование
p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
p3 = Person("Bob", 25)

print(p1 == p2)  # Вывод: True
print(p1 == p3)  # Вывод: False

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __ne__(self, other):
        if isinstance(other, Person):
            return self.name != other.name or self.age != other.age
        return True

# Использование
p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
p3 = Person("Bob", 25)

print(p1 != p2)  # Вывод: False
print(p1 != p3)  # Вывод: True

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __lt__(self, other):
        if isinstance(other, Person):
            return self.age < other.age
        return NotImplemented

# Использование
p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(p1 < p2)  # Вывод: False
print(p2 < p1)  # Вывод: True

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __le__(self, other):
        if isinstance(other, Person):
            return self.age <= other.age
        return NotImplemented

# Использование
p1 = Person("Alice", 30)
p2 = Person("Bob", 25)
p3 = Person("Charlie", 30)

print(p1 <= p2)  # Вывод: False
print(p2 <= p1)  # Вывод: True
print(p1 <= p3)  # Вывод: True

class Box:
    def __init__(self, items):
        self.items = items

    def __bool__(self):
        return bool(self.items)

    def __repr__(self):
        return f"Box({self.items})"

# Использование
box1 = Box([1, 2, 3])
box2 = Box([])

print(bool(box1))  # Вывод: True
print(bool(box2))  # Вывод: False

if box1:
    print("box1 is not empty")  # Вывод: box1 is not empty

if not box2:
    print("box2 is empty")  # Вывод: box2 is empty

class Box:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)

    def __repr__(self):
        return f"Box({self.items})"

# Использование
box1 = Box([1, 2, 3])
box2 = Box([])

print(bool(box1))  # Вывод: True
print(bool(box2))  # Вывод: False

if box1:
    print("box1 is not empty")  # Вывод: box1 is not empty

if not box2:
    print("box2 is empty")  # Вывод: box2 is empty

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 __repr__(self):
        return f"Vector({self.x}, {self.y})"

# Использование
v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2
print(v3)  # Вывод: Vector(4, 6)

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

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

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

# Использование
v = Vector(1, 2)
v2 = v * 3
print(v2)  # Вывод: Vector(3, 6)

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

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

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

# Использование
v1 = Vector(5, 7)
v2 = Vector(2, 3)
v3 = v1 - v2
print(v3)  # Вывод: Vector(3, 4)

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

    def __truediv__(self, scalar):
        return Vector(self.x / scalar, self.y / scalar)

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

# Использование
v = Vector(6, 8)
v2 = v / 2
print(v2)  # Вывод: Vector(3.0, 4.0)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def display(self):
        print(f"Name: {self.name}, Age: {self.age}")

# Создание экземпляра класса Person
person1 = Person("Alice", 30)
person1.display()  # Вывод: Name: Alice, Age: 30

person2 = Person("Bob", 25)
person2.display()  # Вывод: Name: Bob, Age: 25

#include <iostream>
using namespace std;

class Person {
public:
    string name;
    int age;

    // Конструктор по умолчанию
    Person() {
        name = "Unknown";
        age = 0;
    }

    // Конструктор с параметрами
    Person(string n, int a) {
        name = n;
        age = a;
    }

    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

int main() {
    Person person1;
    person1.display();  // Вывод: Name: Unknown, Age: 0

    Person person2("Alice", 30);
    person2.display();  // Вывод: Name: Alice, Age: 30

    return 0;
}

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

class A:
    def method(self):
        print("A")

class B(A):
    def method(self):
        print("B")

class C(A):
    def method(self):
        print("C")

class D(B, C):
    pass

d = D()
d.method()  # Вывод: B

class A:
    def method(self):
        print("Method from class A")

class B:
    def method(self):
        print("Method from class B")

class C(A, B):
    pass

c = C()
c.method()  # Вывод: Method from class A (MRO выбрал метод из класса A)

      class Engine:
       def start(self):
           print("Engine started")

   class Car:
       def __init__(self):
           self.engine = Engine()

       def start(self):
           self.engine.start()
           print("Car started")

   car = Car()
   car.start()
   

class ManagedResource:
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")
        if exc_type:
            print(f"Exception type: {exc_type}")
            print(f"Exception value: {exc_value}")
            print(f"Traceback: {traceback}")
        return True  # True указывает на то, что исключение было обработано

# Использование
with ManagedResource() as resource:
    print("Inside the context")

print("Outside the context")

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        self.file.close()
        if exc_type:
            print(f"Exception type: {exc_type}")
            print(f"Exception value: {exc_value}")
            print(f"Traceback: {traceback}")
        return True

# Использование
with FileManager("example.txt", "w") as f:
    f.write("Hello, World!")

print("File operation completed")

class CustomList:
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return self.items[index]

# Использование
my_list = CustomList([1, 2, 3, 4, 5])
print(my_list[2])  # Вывод: 3

class CustomList:
    def __init__(self, items):
        self.items = items

    def __setitem__(self, index, value):
        self.items[index] = value

# Использование
my_list = CustomList([1, 2, 3, 4, 5])
my_list[2] = 10
print(my_list.items)  # Вывод: [1, 2, 10, 4, 5]

class CustomList:
    def __init__(self, items):
        self.items = items

    def __delitem__(self, index):
        del self.items[index]

# Использование
my_list = CustomList([1, 2, 3, 4, 5])
del my_list[2]
print(my_list.items)  # Вывод: [1, 2, 4, 5]

class CustomDict:
    def __init__(self):
        self.items = {}

    def __getitem__(self, key):
        return self.items[key]

    def __setitem__(self, key, value):
        self.items[key] = value

    def __delitem__(self, key):
        del self.items[key]

    def __repr__(self):
        return f"{self.items}"

# Использование
my_dict = CustomDict()
my_dict['a'] = 1
my_dict['b'] = 2
print(my_dict['a'])  # Вывод: 1
print(my_dict)       # Вывод: {'a': 1, 'b': 2}
del my_dict['a']
print(my_dict)       # Вывод: {'b': 2}

{
  "alg": "HS256",
  "typ": "JWT"
}

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

pip install pyjwt

import jwt
import datetime

# Секретный ключ
secret_key = "your-256-bit-secret"

# Заголовок
header = {
    "alg": "HS256",
    "typ": "JWT"
}

# Полезная нагрузка
payload = {
    "sub": "1234567890",
    "name": "John Doe",
    "admin": True,
    "exp": datetime.datetime.utcnow() + datetime.timedelta(seconds=30)  # Время истечения действия токена
}

# Создание JWT
token = jwt.encode(payload, secret_key, algorithm="HS256", headers=header)
print(token)

import jwt

# Секретный ключ
secret_key = "your-256-bit-secret"

# Декодирование JWT
try:
    decoded_payload = jwt.decode(token, secret_key, algorithms=["HS256"])
    print(decoded_payload)
except jwt.ExpiredSignatureError:
    print("Signature has expired")
except jwt.InvalidTokenError:
    print("Invalid token")

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

# Использование
counter = Counter()
print(counter())  # Вывод: 1
print(counter())  # Вывод: 2
print(counter())  # Вывод: 3

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor

# Использование
double = Multiplier(2)
triple = Multiplier(3)

print(double(5))  # Вывод: 10
print(triple(5))  # Вывод: 15

class CachedFibonacci:
    def __init__(self):
        self.cache = {}

    def __call__(self, n):
        if n in self.cache:
            return self.cache[n]
        if n <= 1:
            return n
        self.cache[n] = self(n - 1) + self(n - 2)
        return self.cache[n]

# Использование
fibonacci = CachedFibonacci()
print(fibonacci(10))  # Вывод: 55
print(fibonacci(15))  # Вывод: 610

import socket

# Создание TCP-сокета
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Привязка сокета к адресу и порту
server_socket.bind(('localhost', 12345))

# Ожидание входящих соединений
server_socket.listen()

print('Сервер ожидает соединения...')

while True:
    # Принятие нового соединения
    client_socket, client_address = server_socket.accept()
    print(f'Подключение от {client_address}')
    
    # Получение данных от клиента
    data = client_socket.recv(1024).decode()
    print(f'Получено: {data}')
    
    # Отправка ответа клиенту
    client_socket.sendall('Hello, Client!'.encode())
    
    # Закрытие соединения
    client_socket.close()

import socket

# Создание TCP-сокета
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Подключение к серверу
client_socket.connect(('localhost', 12345))

# Отправка данных серверу
client_socket.sendall('Hello, Server!'.encode())

# Получение ответа от сервера
data = client_socket.recv(1024).decode()
print(f'Получено: {data}')

# Закрытие соединения
client_socket.close()

import socket

# Создание UDP-сокета
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# Привязка сокета к адресу и порту
server_socket.bind(('localhost', 12345))

print('UDP сервер ожидает сообщений...')

while True:
    # Получение данных от клиента
    data, client_address = server_socket.recvfrom(1024)
    print(f'Получено от {client_address}: {data.decode()}')
    
    # Отправка ответа клиенту
    server_socket.sendto('Hello, Client!'.encode(), client_address)

import socket

# Создание UDP-сокета
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# Отправка данных серверу
client_socket.sendto('Hello, Server!'.encode(), ('localhost', 12345))

# Получение ответа от сервера
data, server_address = client_socket.recvfrom(1024)
print(f'Получено: {data.decode()}')

# Закрытие сокета
client_socket.close()

from django.contrib.auth.models import User

# Создание нового пользователя
user = User.objects.create_user(username='john', password='password123')

# Аутентификация пользователя
from django.contrib.auth import authenticate, login

user = authenticate(username='john', password='password123')
if user is not None:
    login(request, user)

from django.db import models
from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(blank=True)
    birth_date = models.DateField(null=True, blank=True)

# Сигналы для автоматического создания и сохранения профиля пользователя
from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)

@receiver(post_save, sender=User)
def save_user_profile(sender, instance, **kwargs):
    instance.userprofile.save()

# Получение и изменение профиля пользователя
user = User.objects.get(username='john')
profile = user.userprofile
profile.bio = "Hello, I'm John!"
profile.save()

from django.contrib.auth.models import AbstractBaseUser, BaseUserManager
from django.db import models

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)

        return self.create_user(email, password, **extra_fields)

class CustomUser(AbstractBaseUser):
    email = models.EmailField(unique=True)
    first_name = models.CharField(max_length=30, blank=True)
    last_name = models.CharField(max_length=30, blank=True)
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)

    objects = CustomUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name']

    def __str__(self):
        return self.email

from django.db import models

class Status(models.IntegerChoices):
    PENDING = 1, 'Pending'
    APPROVED = 2, 'Approved'
    REJECTED = 3, 'Rejected'

from django.db import models

class Application(models.Model):
    status = models.IntegerField(choices=Status.choices, default=Status.PENDING)
    name = models.CharField(max_length=100)
    submitted_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"{self.name} - {self.get_status_display()}"

# Создание новой записи
app = Application.objects.create(name='John Doe')

# Проверка статуса
print(app.status)  # 1
print(app.get_status_display())  # 'Pending'

# Изменение статуса
app.status = Status.APPROVED
app.save()

# Проверка обновленного статуса
print(app.status)  # 2
print(app.get_status_display())  # 'Approved'

from django.db import models

class Status(models.IntegerChoices):
    PENDING = 1, 'Pending'
    APPROVED = 2, 'Approved'
    REJECTED = 3, 'Rejected'

    @classmethod
    def get_choices(cls):
        return [(choice.value, choice.label) for choice in cls]

# Пример использования
print(Status.get_choices())  # [(1, 'Pending'), (2, 'Approved'), (3, 'Rejected')]

# Фильтрация записей по статусу
pending_apps = Application.objects.filter(status=Status.PENDING)
for app in pending_apps:
    print(app.name)

# Фильтрация записей по множеству статусов
approved_or_rejected_apps = Application.objects.filter(status__in=[Status.APPROVED, Status.REJECTED])
for app in approved_or_rejected_apps:
    print(app.name)

{
    "name": "John Doe",
    "age": 30,
    "isStudent": false,
    "courses": ["Math", "Science", "History"],
    "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "zip": "12345"
    }
}

"name": "John Doe"    

"age": 30    

"isStudent": false    

"courses": ["Math", "Science", "History"]    

"address": {
    "street": "123 Main St",
    "city": "Anytown",
    "zip": "12345"
}    

"middleName": null    

import json

data = {
    "name": "John Doe",
    "age": 30,
    "isStudent": False,
    "courses": ["Math", "Science", "History"],
    "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "zip": "12345"
    }
}

# Преобразование Python объекта в JSON строку
json_string = json.dumps(data, indent=4)
print(json_string)

import json

json_string = '''
{
    "name": "John Doe",
    "age": 30,
    "isStudent": false,
    "courses": ["Math", "Science", "History"],
    "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "zip": "12345"
    }
}
'''

# Преобразование JSON строки в Python объект
data = json.loads(json_string)
print(data)
print(data['name'])  # John Doe

import json

data = {
    "name": "John Doe",
    "age": 30,
    "isStudent": False,
    "courses": ["Math", "Science", "History"],
    "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "zip": "12345"
    }
}

with open('data.json', 'w') as file:
    json.dump(data, file, indent=4)

import json

with open('data.json', 'r') as file:
    data = json.load(file)
    print(data)
    print(data['name'])  # John Doe

x = 10
print(type(x))  # <class 'int'>   

class MyClass:
    def __init__(self, value):
        self.value = value

obj = MyClass(5)

# Проверка наличия атрибута
print(hasattr(obj, 'value'))  # True

# Получение значения атрибута
print(getattr(obj, 'value'))  # 5

# Установка значения атрибута
setattr(obj, 'value', 10)
print(getattr(obj, 'value'))  # 10   

import inspect

class MyClass:
    def method(self):
        pass

# Получение всех методов класса
methods = inspect.getmembers(MyClass, predicate=inspect.isfunction)
print(methods)  # [('method', <function MyClass.method at 0x...>)]   

class MyClass:
    def method(self):
       pass

obj = MyClass()

print(dir(obj))
# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__',
# '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'method']

import inspect

def my_function():
    pass

# Получение информации о функции
print(inspect.getmembers(my_function)) 

id = models.AutoField(primary_key=True)    

name = models.CharField(max_length=100)    

description = models.TextField()    

age = models.IntegerField()    

price = models.FloatField()    

is_active = models.BooleanField(default=True)    

created_at = models.DateTimeField(auto_now_add=True)    

author = models.ForeignKey('Author', on_delete=models.CASCADE)    

categories = models.ManyToManyField('Category')    

profile = models.OneToOneField('Profile', on_delete=models.CASCADE)    

from django.db import models
from django.utils import timezone

class BookManager(models.Manager):
    def by_author(self, author_name):
        return self.filter(author__name=author_name)

    def published_recently(self):
        one_month_ago = timezone.now() - timezone.timedelta(days=30)
        return self.filter(publication_date__gte=one_month_ago)

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    publication_date = models.DateTimeField()
    
    # Подключение кастомного менеджера
    objects = BookManager()

# Получение книг по автору
books_by_author = Book.objects.by_author('John Doe')
for book in books_by_author:
    print(book.title)

# Получение книг, опубликованных за последний месяц
recent_books = Book.objects.published_recently()
for book in recent_books:
    print(book.title)

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

    def save(self):
        # Сохранение данных пользователя в базу данных
        print(f"Saving user {self.name} to the database.")

    def send_welcome_email(self):
        # Отправка приветственного сообщения на электронную почту
        print(f"Sending welcome email to {self.email}.")

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

class UserRepository:
    def save(self, user):
        # Сохранение данных пользователя в базу данных
        print(f"Saving user {user.name} to the database.")

class EmailService:
    def send_welcome_email(self, user):
        # Отправка приветственного сообщения на электронную почту
        print(f"Sending welcome email to {user.email}.")

# Использование классов
user = User("Alice", "[email protected]")
user_repository = UserRepository()
email_service = EmailService()

user_repository.save(user)
email_service.send_welcome_email(user)

npx create-next-app@latest my-isomorphic-app
cd my-isomorphic-app
npm run dev

// pages/index.js
import React from 'react';

const Home = ({ message }) => (
  <div>
    <h1>{message}</h1>
  </div>
);

export async function getServerSideProps() {
  return {
    props: {
      message: 'Hello from the server!',
    },
  };
}

export default Home;

class Animal:
    def speak(self):
        return "Some sound"

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

dog = Dog()
print(dog.speak())  # Woof!

class Animal:
    def eat(self):
        return "Eating"

class Pet:
    def play(self):
        return "Playing"

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

dog = Dog()
print(dog.eat())    # Eating
print(dog.play())   # Playing
print(dog.speak())  # Woof!

class Animal:
    def eat(self):
        return "Eating"

class Mammal(Animal):
    def walk(self):
        return "Walking"

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

dog = Dog()
print(dog.eat())    # Eating
print(dog.walk())   # Walking
print(dog.speak())  # Woof!

class Animal:
    def speak(self):
        return "Some sound"

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

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

dog = Dog()
cat = Cat()
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

class Animal:
    def eat(self):
        return "Eating"

class Mammal(Animal):
    def walk(self):
        return "Walking"

class Bird(Animal):
    def fly(self):
        return "Flying"

class Bat(Mammal, Bird):
    def use_sonar(self):
        return "Using sonar"

bat = Bat()
print(bat.eat())      # Eating
print(bat.walk())     # Walking
print(bat.fly())      # Flying
print(bat.use_sonar())  # Using sonar

from abc import ABC, abstractmethod

# Создание абстрактного класса
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# Попытка создания экземпляра абстрактного класса приведет к ошибке
# animal = Animal()  # TypeError: Can't instantiate abstract class Animal with abstract methods make_sound

# Создание подклассов, которые реализуют абстрактные методы
class Dog(Animal):
    def make_sound(self):
        return "Woof!"

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

# Теперь можно создать экземпляры подклассов
dog = Dog()
print(dog.make_sound())  # Woof!

cat = Cat()
print(cat.make_sound())  # Meow!

class MyClass:
    pass

# Проверка типа класса
print(type(MyClass))  # <class 'type'>

def create_class(name):
    if name == "Dog":
        class Dog:
            def speak(self):
                return "Woof!"
        return Dog
    else:
        class Cat:
            def speak(self):
                return "Meow!"
        return Cat

AnimalClass = create_class("Dog")
animal = AnimalClass()
print(animal.speak())  # Woof!

def print_class_name(cls):
    print(cls.__name__)

class MyClass:
    pass

print_class_name(MyClass)  # MyClass

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    pass

# Вывод: Creating class MyClass

import time

# Оригинальная функция
def original_sleep(seconds):
    time.sleep(seconds)
    print(f"Slept for {seconds} seconds")

# Monkey patching функции sleep
def patched_sleep(seconds):
    print(f"Patched! Should have slept for {seconds} seconds")

# Применение monkey patching
time.sleep = patched_sleep

# Примеры использования
time.sleep(3)  # Вывод: Patched! Should have slept for 3 seconds

file = None
try:
    file = open('example.txt', 'r')
    content = file.read()
    print(content)
finally:
    if file:
        file.close()

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()

# Примеры использования
file_manager = FileManager('example.txt', 'r')
try:
    file = file_manager.__enter__()
    content = file.read()
    print(content)
finally:
    file_manager.__exit__(None, None, None)

from functools import wraps

def open_file(filename, mode):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            file = open(filename, mode)
            try:
                result = func(file, *args, **kwargs)
            finally:
                file.close()
            return result
        return wrapper
    return decorator

@open_file('example.txt', 'r')
def read_file(f):
    return f.read()

# Примеры использования
print(read_file())

from contextlib import contextmanager

@contextmanager
def open_file(filename, mode):
    file = open(filename, mode)
    try:
        yield file
    finally:
        file.close()

# Примеры использования
file_manager = open_file('example.txt', 'r')
file = file_manager.__enter__()
try:
    content = file.read()
    print(content)
finally:
    file_manager.__exit__(None, None, None)

class MyClass:
    def __init__(self, value):
        self._value = value  # Приватный атрибут

    def get_value(self):
        return self._value

    def set_value(self, value):
        if value >= 0:
            self._value = value
        else:
            raise ValueError("Value must be non-negative")

# Примеры использования
obj = MyClass(10)
print(obj.get_value())  # Вывод: 10

obj.set_value(20)
print(obj.get_value())  # Вывод: 20

try:
    obj.set_value(-10)  # Пример вызова исключения
except ValueError as e:
    print(e)  # Вывод: Value must be non-negative

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        if value >= 0:
            self._value = value
        else:
            raise ValueError("Value must be non-negative")

# Примеры использования
obj = MyClass(10)
print(obj.value)  # Вывод: 10 (используется геттер)

obj.value = 20
print(obj.value)  # Вывод: 20 (используется сеттер)

try:
    obj.value = -10  # Пример вызова исключения через сеттер
except ValueError as e:
    print(e)  # Вывод: Value must be non-negative

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        if value >= 0:
            self._value = value
        else:
            raise ValueError("Value must be non-negative")

    @value.deleter
    def value(self):
        del self._value

# Примеры использования
obj = MyClass(10)
print(obj.value)  # Вывод: 10

obj.value = 20
print(obj.value)  # Вывод: 20

del obj.value
try:
    print(obj.value)  # Ошибка, так как атрибут удален
except AttributeError as e:
    print(e)  # Вывод: 'MyClass' object has no attribute '_value'

class MyClass:
    class_attribute = 42  # Атрибут класса

# Доступ к атрибуту класса
print(MyClass.class_attribute)  # Вывод: 42

# Создание экземпляров
obj1 = MyClass()
obj2 = MyClass()

# Доступ к атрибуту класса через экземпляры
print(obj1.class_attribute)  # Вывод: 42
print(obj2.class_attribute)  # Вывод: 42

# Изменение атрибута класса
MyClass.class_attribute = 100
print(obj1.class_attribute)  # Вывод: 100
print(obj2.class_attribute)  # Вывод: 100

class MyClass:
    def __init__(self, value):
        self.instance_attribute = value  # Атрибут объекта

# Создание экземпляров
obj1 = MyClass(10)
obj2 = MyClass(20)

# Доступ к атрибутам объекта
print(obj1.instance_attribute)  # Вывод: 10
print(obj2.instance_attribute)  # Вывод: 20

# Изменение атрибутов объекта
obj1.instance_attribute = 15
print(obj1.instance_attribute)  # Вывод: 15
print(obj2.instance_attribute)  # Вывод: 20

class MyClass:
    class_attribute = 'class value'

    def __init__(self, value):
        self.instance_attribute = value

# Создание экземпляров
obj1 = MyClass('instance value 1')
obj2 = MyClass('instance value 2')

# Доступ к атрибутам класса и объекта
print(MyClass.class_attribute)      # Вывод: class value
print(obj1.class_attribute)         # Вывод: class value
print(obj2.class_attribute)         # Вывод: class value

print(obj1.instance_attribute)      # Вывод: instance value 1
print(obj2.instance_attribute)      # Вывод: instance value 2

# Изменение атрибута класса через класс
MyClass.class_attribute = 'new class value'
print(obj1.class_attribute)         # Вывод: new class value
print(obj2.class_attribute)         # Вывод: new class value

# Изменение атрибута объекта
obj1.instance_attribute = 'new instance value 1'
print(obj1.instance_attribute)      # Вывод: new instance value 1
print(obj2.instance_attribute)      # Вывод: instance value 2

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

# Примеры использования
person1 = Person(name="Alice", age=30)
person2 = Person(name="Bob", age=25)

print(person1)  # Вывод: Person(name='Alice', age=30)
print(person2)  # Вывод: Person(name='Bob', age=25)
print(person1 == person2)  # Вывод: False

from dataclasses import dataclass

@dataclass(order=True, frozen=True)
class Person:
    name: str
    age: int

person1 = Person(name="Alice", age=30)
person2 = Person(name="Bob", age=25)

print(person1 > person2)  # Вывод: True (поскольку 'Alice' > 'Bob' по алфавиту, если имена равны, сравниваются возраста)
# person1.age = 31  # Ошибка: FrozenInstanceError (поскольку класс заморожен)

from dataclasses import dataclass, field

@dataclass
class Person:
    name: str
    age: int = 0
    address: str = field(default="Unknown", repr=False)

person = Person(name="Alice")
print(person)  # Вывод: Person(name='Alice', age=0)

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b

# Вызов статических методов
print(MathUtils.add(5, 3))  # Вывод: 8
print(MathUtils.multiply(5, 3))  # Вывод: 15

class Validator:
    @staticmethod
    def is_valid_email(email):
        return "@" in email and "." in email

# Вызов статического метода
print(Validator.is_valid_email("[email protected]"))  # Вывод: True
print(Validator.is_valid_email("invalid-email"))  # Вывод: False

class Example:
    def instance_method(self):
        print("This is an instance method")
    
    @classmethod
    def class_method(cls):
        print("This is a class method")
    
    @staticmethod
    def static_method():
        print("This is a static method")

# Создание экземпляра класса
obj = Example()

# Вызов методов
obj.instance_method()  # Вывод: This is an instance method
Example.class_method()  # Вывод: This is a class method
Example.static_method()  # Вывод: This is a static method

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()

# Примеры использования
with FileManager('example.txt', 'w') as f:
    f.write('Hello, World!')

# Пример с обработкой исключений
try:
    with FileManager('example.txt', 'r') as f:
        content = f.read()
        print(content)
except Exception as e:
    print(f"An error occurred: {e}")

class DatabaseConnection:
    def __init__(self, db_name):
        self.db_name = db_name
        self.connection = None
    
    def __enter__(self):
        self.connection = self.connect_to_database(self.db_name)
        return self.connection
    
    def __exit__(self, exc_type, exc_value, traceback):
        if self.connection:
            self.connection.close()
    
    def connect_to_database(self, db_name):
        # Реализация соединения с базой данных (псевдокод)
        print(f"Connecting to database {db_name}")
        return f"Connection to {db_name}"

    def close(self):
        # Реализация закрытия соединения (псевдокод)
        print("Closing the connection")

# Примеры использования
with DatabaseConnection('my_database') as conn:
    print(conn)
    # Выполнение операций с базой данных

# Пример с обработкой исключений
try:
    with DatabaseConnection('my_database') as conn:
        raise ValueError("Some error occurred")
except Exception as e:
    print(f"An error occurred: {e}")

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __getitem__(self, index):
        return self.items[index]

# Примеры использования
my_list = MyList([1, 2, 3, 4])
print(my_list[0])  # Вывод: 1
print(my_list[2])  # Вывод: 3

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __setitem__(self, index, value):
        self.items[index] = value

# Примеры использования
my_list = MyList([1, 2, 3, 4])
my_list[1] = 10
print(my_list.items)  # Вывод: [1, 10, 3, 4]

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __delitem__(self, index):
        del self.items[index]

# Примеры использования
my_list = MyList([1, 2, 3, 4])
del my_list[2]
print(my_list.items)  # Вывод: [1, 2, 4]

class CustomDict:
    def __init__(self):
        self.data = {}
    
    def __getitem__(self, key):
        return self.data[key]
    
    def __setitem__(self, key, value):
        self.data[key] = value
    
    def __delitem__(self, key):
        del self.data[key]

# Примеры использования
custom_dict = CustomDict()
custom_dict['a'] = 1
custom_dict['b'] = 2
print(custom_dict['a'])  # Вывод: 1
print(custom_dict['b'])  # Вывод: 2

del custom_dict['a']
print(custom_dict.data)  # Вывод: {'b': 2}

class Counter:
    def __init__(self):
        self.count = 0
    
    def __call__(self):
        self.count += 1
        print(f"Count is now {self.count}")

# Примеры использования
counter = Counter()
counter()  # Вывод: Count is now 1
counter()  # Вывод: Count is now 2
counter()  # Вывод: Count is now 3

class Adder:
    def __init__(self, value):
        self.value = value
    
    def __call__(self, x):
        return self.value + x

# Примеры использования
add5 = Adder(5)
print(add5(10))  # Вывод: 15
print(add5(20))  # Вывод: 25

class Polynomial:
    def __init__(self, coefficients):
        self.coefficients = coefficients
    
    def __call__(self, x):
        result = 0
        for power, coef in enumerate(self.coefficients):
            result += coef * (x ** power)
        return result

# Примеры использования
p = Polynomial([1, 0, 2])  # Создает полином 1 + 0x + 2x^2
print(p(2))  # Вывод: 9 (1 + 0*2 + 2*2^2)
print(p(3))  # Вывод: 19 (1 + 0*3 + 2*3^2)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
p3 = Person("Bob", 25)

print(p1 == p2)  # Вывод: True
print(p1 == p3)  # Вывод: False

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __ne__ (self, other):
        return self.name != other.name or self.age != other.age

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
p3 = Person("Bob", 25)

print(p1 != p2)  # Вывод: False
print(p1 != p3)  # Вывод: True

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __lt__(self, other):
        return self.age < other.age

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(p1 < p2)  # Вывод: False
print(p2 < p1)  # Вывод: True

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __le__(self, other):
        return self.age <= other.age

p1 = Person("Alice", 30)
p2 = Person("Bob", 30)
p3 = Person("Charlie", 25)

print(p1 <= p2)  # Вывод: True
print(p1 <= p3)  # Вывод: False

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __gt__(self, other):
        return self.age > other.age

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(p1 > p2)  # Вывод: True
print(p2 > p1)  # Вывод: False