from django.db import models

class UserProfile(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()

python manage.py makemigrations

migrations/
  0001_initial.py  # Файл с SQL-изменениями

python manage.py sqlmigrate myapp 0001

python manage.py migrate

class UserProfile(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()
    email = models.EmailField(default="example@example.com")  # Добавили поле

python manage.py makemigrations

python manage.py migrate

python manage.py migrate myapp 0001  # Откат до первой миграции

squares = {x: x**2 for x in range(1, 6)}
print(squares)

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

squares = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(squares)

{2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

names = ["Alice", "Bob", "Charlie"]
name_lengths = {name: len(name) for name in names}
print(name_lengths)

{'Alice': 5, 'Bob': 3, 'Charlie': 7}

original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)

{1: 'a', 2: 'b', 3: 'c'}

keys = ["name", "age", "city"]
values = ["Alice", 25, "New York"]

person = {k: v for k, v in zip(keys, values)}
print(person)

{'name': 'Alice', 'age': 25, 'city': 'New York'}

numbers = range(1, 6)
parity = {x: "чётное" if x % 2 == 0 else "нечётное" for x in numbers}
print(parity)

{1: 'нечётное', 2: 'чётное', 3: 'нечётное', 4: 'чётное', 5: 'нечётное'}

class MyClass:
    @staticmethod
    def static_method(arg1, arg2):
        return arg1 + arg2

result = MyClass.static_method(5, 10)
print(result)  # Вывод: 15

my_instance = MyClass()
result = my_instance.static_method(3, 7)
print(result)  # Вывод: 10

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

  class MyClass:
      class_variable = 0

      @classmethod
      def class_method(cls, value):
          cls.class_variable = value

  class MyClass:
      @staticmethod
      def static_method(arg1, arg2):
          return arg1 + arg2

def my_decorator(func):  
    def wrapper():  
        print("Декоратор сработал!")  
        return func()  # Вызываем исходную функцию  
    return wrapper  # Возвращаем обёрнутую функцию

def say_hello():
    print("Hello!")

say_hello = my_decorator(say_hello)  # Оборачиваем вручную
say_hello()

Декоратор сработал!
Hello!

def my_decorator(func):
    def wrapper():
        print("Декоратор сработал!")
        return func()
    return wrapper

@my_decorator  # Эквивалентно say_hello = my_decorator(say_hello)
def say_hello():
    print("Hello!")

say_hello()

def my_decorator(func):
    def wrapper(*args, **kwargs):  # Поддержка любых аргументов
        print(f"Вызываем {func.__name__} с аргументами: {args}, {kwargs}")
        return func(*args, **kwargs)  # Вызываем оригинальную функцию
    return wrapper

@my_decorator
def greet(name):
    print(f"Привет, {name}!")

greet("Alice")

Вызываем greet с аргументами: ('Alice',), {}
Привет, Alice!

def repeat(times):  # Функция с параметром
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):  # Повторяем вызов функции
                func(*args, **kwargs)
        return wrapper
    return decorator  # Возвращаем декоратор

@repeat(3)  # Передаём 3 → `repeat(3)` вернёт `decorator`
def hello():
    print("Hello!")

hello()

Hello!
Hello!
Hello!

import functools

def my_decorator(func):
    @functools.wraps(func)  # Сохраняем метаданные
    def wrapper(*args, **kwargs):
        print("Декоратор сработал!")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet():
    """Функция приветствия"""
    print("Hello!")

print(greet.__name__)  # greet (без wraps было бы wrapper)
print(greet.__doc__)  # Функция приветствия

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

def test_add():
    assert add(2, 3) == 5  # ✅ Юнит-тест

def test_api():
    response = requests.get("https://api.example.com/data")
    assert response.status_code == 200

def test_login():
    assert login("user", "password") == "Success"

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://example.com")
assert "Example" in driver.title

from locust import HttpUser, task

class MyUser(HttpUser):
    @task
    def test_homepage(self):
        self.client.get("/")

def split_list(lst, size):
    return [lst[i:i + size] for i in range(0, len(lst), size)]

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(split_list(data, 3))  

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

import numpy as np

def split_into_n_parts(lst, n):
    return np.array_split(lst, n)

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(split_into_n_parts(data, 4))  

[array([1, 2, 3]), array([4, 5]), array([6, 7]), array([8, 9])]

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]

even = [x for x in data if x % 2 == 0]
odd = [x for x in data if x % 2 != 0]

print(even, odd)

[2, 4, 6, 8] [1, 3, 5, 7, 9]

import threading
import time

def task(name):
    print(f"{name} начал работу")
    time.sleep(2)
    print(f"{name} завершил работу")

# Создаём два потока
t1 = threading.Thread(target=task, args=("Поток 1",))
t2 = threading.Thread(target=task, args=("Поток 2",))

t1.start()
t2.start()

t1.join()
t2.join()
print("Все потоки завершены")

Поток 1 начал работу
Поток 2 начал работу
Поток 1 завершил работу
Поток 2 завершил работу
Все потоки завершены

import multiprocessing
import time

def task(name):
    print(f"{name} начал работу")
    time.sleep(2)
    print(f"{name} завершил работу")

if __name__ == "__main__":
    p1 = multiprocessing.Process(target=task, args=("Процесс 1",))
    p2 = multiprocessing.Process(target=task, args=("Процесс 2",))

    p1.start()
    p2.start()

    p1.join()
    p2.join()
    print("Все процессы завершены")

Процесс 1 начал работу
Процесс 2 начал работу
Процесс 1 завершил работу
Процесс 2 завершил работу
Все процессы завершены

my_list = [1, "hello", 3.14]
print(my_list[1])  # "hello"

my_tuple = (10, 20, 30)
print(my_tuple[0])  # 10

my_set = {1, 2, 3, 2}
print(my_set)  # {1, 2, 3}

my_dict = {"name": "Alice", "age": 25}
print(my_dict["name"])  # Alice

stack = []
stack.append(10)  # Добавление
stack.append(20)
print(stack.pop())  # Удаление последнего элемента (20)

from collections import deque

queue = deque()
queue.append(10)
queue.append(20)
print(queue.popleft())  # 10

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        if not self.head:
            self.head = Node(data)
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = Node(data)

from concurrent.futures import ProcessPoolExecutor
from PIL import Image

def process_image(image_path):
    img = Image.open(image_path)
    img = img.convert("L")  # Перевод в черно-белый формат
    img.save(f"processed_{image_path}")

images = ["img1.jpg", "img2.jpg", "img3.jpg"]

with ProcessPoolExecutor() as executor:
    executor.map(process_image, images)

import numpy as np

A = np.random.rand(1000, 1000)
B = np.random.rand(1000, 1000)

C = A @ B  # Быстрое умножение матриц (использует несколько ядер процессора)

import asyncio
import aiohttp

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = ["https://example.com", "https://google.com"]
    tasks = [fetch(url) for url in urls]
    responses = await asyncio.gather(*tasks)
    print(responses)

asyncio.run(main())