Популярные библиотеки Python: ключевые инструменты разработчика

import requests

# Получение данных о курсах валют
response = requests.get('https://api.exchangerate-api.com/v4/latest/USD')

# Проверка успешности запроса
if response.status_code == 200:
data = response.json()
print(f"Курс EUR к USD: {data['rates']['EUR']}")
print(f"Курс RUB к USD: {data['rates']['RUB']}")
else:
print(f"Ошибка запроса: {response.status_code}")

import numpy as np

# Создание массива
arr = np.array([1, 2, 3, 4, 5])
print(f"Массив: {arr}")
print(f"Тип данных: {arr.dtype}")
print(f"Размерность: {arr.shape}")

# Математические операции
print(f"Среднее значение: {np.mean(arr)}")
print(f"Стандартное отклонение: {np.std(arr)}")

# Операции с матрицами
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
print(f"Произведение матриц:\n{np.dot(matrix1, matrix2)}")

import pandas as pd

# Создание DataFrame из словаря
data = {
'Имя': ['Анна', 'Борис', 'Виктор', 'Галина'],
'Возраст': [25, 30, 35, 40],
'Город': ['Москва', 'Санкт-Петербург', 'Новосибирск', 'Екатеринбург'],
'Зарплата': [70000, 85000, 90000, 95000]
}
df = pd.DataFrame(data)
print(df)

# Базовая статистика
print(f"Статистика по возрасту:\n{df['Возраст'].describe()}")

# Фильтрация данных
high_salary = df[df['Зарплата'] > 80000]
print(f"Сотрудники с высокой зарплатой:\n{high_salary}")

# Группировка и агрегация
city_stats = df.groupby('Город').agg({
'Зарплата': ['mean', 'min', 'max'],
'Возраст': 'mean'
})
print(f"Статистика по городам:\n{city_stats}")

# Неэффективно
result = []
for i in range(len(array)):
result.append(array[i] * 2)

# Эффективно с NumPy
result = array * 2

# Оптимизация использования памяти
df_optimized = df.copy()
for col in df.select_dtypes(include=['int']).columns:
df_optimized[col] = pd.to_numeric(df_optimized[col], downcast='integer')
for col in df.select_dtypes(include=['float']).columns:
df_optimized[col] = pd.to_numeric(df_optimized[col], downcast='float')

print(f"Исходный размер: {df.memory_usage().sum() / 1024} KB")
print(f"Оптимизированный размер: {df_optimized.memory_usage().sum() / 1024} KB")

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
return 'Hello, World!'

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

# views.py
from django.http import HttpResponse

def hello_world(request):
return HttpResponse('Hello, World!')

# urls.py
from django.urls import path
from . import views

urlpatterns = [
path('', views.hello_world, name='hello_world'),
]

# models.py
from django.db import models

class Task(models.Model):
title = models.CharField(max_length=200)
completed = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)

def __str__(self):
return self.title

# serializers.py
from rest_framework import serializers
from .models import Task

class TaskSerializer(serializers.ModelSerializer):
class Meta:
model = Task
fields = ['id', 'title', 'completed', 'created_at']

# views.py
from rest_framework import viewsets
from .models import Task
from .serializers import TaskSerializer

class TaskViewSet(viewsets.ModelViewSet):
queryset = Task.objects.all()
serializer_class = TaskSerializer

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import TaskViewSet

router = DefaultRouter()
router.register(r'tasks', TaskViewSet)

urlpatterns = [
path('api/', include(router.urls)),
]

from flask import Flask, request
from flask_restful import Resource, Api, reqparse
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime

app = Flask(__name__)
api = Api(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tasks.db'
db = SQLAlchemy(app)

class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), nullable=False)
completed = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)

def __repr__(self):
return f"<Task {self.title}>"

parser = reqparse.RequestParser()
parser.add_argument('title', type=str, required=True)
parser.add_argument('completed', type=bool, default=False)

class TaskResource(Resource):
def get(self, task_id=None):
if task_id:
task = Task.query.get_or_404(task_id)
return {
'id': task.id,
'title': task.title,
'completed': task.completed,
'created_at': task.created_at.isoformat()
}
else:
tasks = Task.query.all()
return [{
'id': task.id,
'title': task.title,
'completed': task.completed,
'created_at': task.created_at.isoformat()
} for task in tasks]

def post(self):
args = parser.parse_args()
task = Task(title=args['title'], completed=args['completed'])
db.session.add(task)
db.session.commit()
return {
'id': task.id,
'title': task.title,
'completed': task.completed,
'created_at': task.created_at.isoformat()
}, 201

def put(self, task_id):
args = parser.parse_args()
task = Task.query.get_or_404(task_id)
task.title = args['title']
task.completed = args['completed']
db.session.commit()
return {
'id': task.id,
'title': task.title,
'completed': task.completed,
'created_at': task.created_at.isoformat()
}

def delete(self, task_id):
task = Task.query.get_or_404(task_id)
db.session.delete(task)
db.session.commit()
return '', 204

api.add_resource(TaskResource, '/api/tasks', '/api/tasks/<int:task_id>')

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

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import Adam

# Загрузка и предобработка данных
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Создание модели
model = Sequential([
Flatten(input_shape=(28, 28)),
Dense(128, activation='relu'),
Dense(10, activation='softmax')
])

# Компиляция модели
model.compile(optimizer=Adam(learning_rate=0.001),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

# Обучение модели
model.fit(x_train, y_train, epochs=5, batch_size=32, validation_split=0.1)

# Оценка модели
model.evaluate(x_test, y_test)

# Сохранение модели
model.save('mnist_model.h5')

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# Параметры
batch_size = 32
epochs = 5
learning_rate = 0.001
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# Загрузка данных
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
train_dataset = datasets.MNIST('data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('data', train=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size)

# Определение модели
class MNISTModel(nn.Module):
def __init__(self):
super(MNISTModel, self).__init__()
self.flatten = nn.Flatten()
self.linear1 = nn.Linear(28 * 28, 128)
self.relu = nn.ReLU()
self.linear2 = nn.Linear(128, 10)

def forward(self, x):
x = self.flatten(x)
x = self.linear1(x)
x = self.relu(x)
x = self.linear2(x)
return x

model = MNISTModel().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Обучение модели
for epoch in range(epochs):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

if batch_idx % 100 == 0:
print(f'Epoch: {epoch}, Batch: {batch_idx}, Loss: {loss.item():.4f}')

# Оценка модели
model.eval()
correct = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()

print(f'Epoch: {epoch}, Accuracy: {100. * correct / len(test_loader.dataset):.2f}%')

# Сохранение модели
torch.save(model.state_dict(), 'mnist_model.pt')

import pandas as pd
import numpy as np

# Создайте DataFrame с данными о продажах
data = {
'Дата': pd.date_range(start='2023-01-01', periods=100, freq='D'),
'Товар': np.random.choice(['Ноутбук', 'Смартфон', 'Планшет', 'Наушники'], 100),
'Количество': np.random.randint(1, 10, 100),
'Цена': np.random.uniform(1000, 100000, 100).round(2)
}
df = pd.DataFrame(data)
df['Выручка'] = df['Количество'] * df['Цена']

# Задания:
# 1. Рассчитайте общую выручку по каждому типу товара
# 2. Определите день с максимальной выручкой
# 3. Создайте новый столбец 'Месяц' и проанализируйте продажи по месяцам
# 4. Постройте график динамики продаж по дням недели
# 5. Найдите корреляцию между количеством проданных товаров и ценой

import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
import matplotlib.pyplot as plt

# Загрузите данные о ценах акций
# Можно использовать pandas_datareader для реальных данных:
# from pandas_datareader import data as pdr
# df = pdr.get_data_yahoo('AAPL', '2020-01-01', '2023-01-01')

# Или создайте синтетические данные
np.random.seed(42)
dates = pd.date_range(start='2020-01-01', periods=1000, freq='D')
prices = np.cumsum(np.random.normal(0, 1, 1000)) + 100
volume = np.random.randint(1000000, 10000000, 1000)
df = pd.DataFrame({'Close': prices, 'Volume': volume}, index=dates)

# Задания:
# 1. Рассчитайте скользящие средние за 7, 30 и 90 дней
# 2. Определите волатильность (стандартное отклонение) цен по месяцам
# 3. Создайте индикатор RSI (Relative Strength Index) для выявления перекупленности/перепроданности
# 4. Обучите ARIMA модель и сделайте прогноз цен на следующие 30 дней
# 5. Визуализируйте исходные данные, скользящие средние и прогноз на одном графике

# В models.py
from django.db import models
from django.contrib.auth.models import User

class Task(models.Model):
title = models.CharField(max_length=200)
description = models.TextField(blank=True)
completed = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)
user = models.ForeignKey(User, on_delete=models.CASCADE)

class Meta:
ordering = ['-created_at']

def __str__(self):
return self.title

# Задания:
# 1. Создайте сериализатор для модели Task
# 2. Реализуйте представления для CRUD операций с задачами
# 3. Настройте маршруты URL для API
# 4. Добавьте фильтрацию задач по статусу выполнения
# 5. Реализуйте аутентификацию и авторизацию, чтобы пользователи могли видеть только свои задачи

from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_jwt_extended import JWTManager, jwt_required, create_access_token, get_jwt_identity
from werkzeug.security import generate_password_hash, check_password_hash
from datetime import datetime, timedelta

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
app.config['JWT_SECRET_KEY'] = 'super-secret-key' # В реальном проекте используйте переменные окружения!
db = SQLAlchemy(app)
jwt = JWTManager(app)

# Определите модели
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)

class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comments = db.relationship('Comment', backref='post', lazy=True, cascade='all, delete-orphan')

class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

# Задания:
# 1. Реализуйте эндпоинты для регистрации и аутентификации пользователей
# 2. Создайте CRUD эндпоинты для управления постами
# 3. Добавьте эндпоинты для работы с комментариями
# 4. Реализуйте пагинацию для получения списка постов и комментариев
# 5. Добавьте функциональность поиска по постам
# 6. Реализуйте кеширование ответов API с использованием Redis

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model
import matplotlib.pyplot as plt

# Загрузите датасет цветов (можно использовать TensorFlow Datasets или скачать с Kaggle)
# Предположим, что данные находятся в директории 'flowers' с подпапками для каждого класса

# Предобработка изображений
train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
validation_split=0.2
)

train_generator = train_datagen.flow_from_directory(
'flowers',
target_size=(224, 224),
batch_size=32,
class_mode='categorical',
subset='training'
)

validation_generator = train_datagen.flow_from_directory(
'flowers',
target_size=(224, 224),
batch_size=32,
class_mode='categorical',
subset='validation'
)

# Задания:
# 1. Создайте модель на основе MobileNetV2 с трансферным обучением
# 2. Обучите модель на датасете цветов
# 3. Визуализируйте процесс обучения (точность и потери)
# 4. Оцените модель на валидационных данных
# 5. Сохраните модель для дальнейшего использования
# 6. Реализуйте функцию для предсказания класса произвольного изображения

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader, random_split
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix
import seaborn as sns

# Предположим, у нас есть датасет FER (Facial Emotion Recognition) с 7 классами эмоций
# Датасет можно скачать с Kaggle: https://www.kaggle.com/c/challenges-in-representation-learning-facial-expression-recognition-challenge

# Предобработка данных
transform = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0\.485, 0.456, 0.406], std=[0\.229, 0.224, 0.225])
])

# Загрузка датасета
dataset = datasets.ImageFolder('fer2013/train', transform=transform)

# Разделение на обучающую и валидационную выборки
train_size = int(0.8 * len(dataset))
val_size = len(dataset) – train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32)

# Задания:
# 1. Создайте модель на основе ResNet18 с трансферным обучением
# 2. Модифицируйте модель для работы с черно-белыми изображениями (если в датасете такие)
# 3. Обучите модель с использованием техник регуляризации (dropout, L2)
# 4. Реализуйте early stopping для предотвращения переобучения
# 5. Визуализируйте активации нейронов на разных слоях для нескольких изображений
# 6. Постройте и проанализируйте матрицу ошибок на валидационных данных
# 7. Реализуйте градиентную визуализацию для интерпретации решений модели