Давайте рассмотрим еще один пример сложного кода на Python, который включает использование объектов и наследование. В этом примере мы создадим систему управления университетом с разными типами пользователей (студенты и преподаватели), где каждый тип пользователя имеет свои уникальные характеристики и методы.

### Пример: Система управления университетом

#### Шаг 1: Определим базовый класс Person

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

    def get_details(self):
        return f"Name: {self.name}, Age: {self.age}"

#### Шаг 2: Определим класс Student, наследующий от Person

class Student(Person):
    def __init__(self, name, age, student_id, courses=None):
        super().__init__(name, age)
        self.student_id = student_id
        self.courses = courses if courses is not None else []

    def enroll(self, course):
        self.courses.append(course)

    def get_details(self):
        details = super().get_details()
        return f"{details}, Student ID: {self.student_id}, Courses: {', '.join(self.courses)}"

#### Шаг 3: Определим класс Teacher, наследующий от Person

class Teacher(Person):
    def __init__(self, name, age, employee_id, subjects=None):
        super().__init__(name, age)
        self.employee_id = employee_id
        self.subjects = subjects if subjects is not None else []

    def assign_subject(self, subject):
        self.subjects.append(subject)

    def get_details(self):
        details = super().get_details()
        return f"{details}, Employee ID: {self.employee_id}, Subjects: {', '.join(self.subjects)}"

#### Шаг 4: Создадим экземпляры классов и продемонстрируем их использование

def main():
    # Создаем студента
    student = Student(name="Alice", age=20, student_id="S12345")
    student.enroll("Math")
    student.enroll("Physics")
    
    # Создаем преподавателя
    teacher = Teacher(name="Dr. Smith", age=45, employee_id="T98765")
    teacher.assign_subject("Math")
    teacher.assign_subject("Computer Science")
    
    # Выводим детали
    print("Student Details:")
    print(student.get_details())
    
    print("\nTeacher Details:")
    print(teacher.get_details())

if __name__ == "__main__":
    main()

### Объяснение кода

1. Класс `Person`:
- Базовый класс, содержащий общие атрибуты (`name` и age`) и метод `get_details для получения информации о человеке.

2. Класс `Student`, наследующий от `Person`:
- Расширяет базовый класс, добавляя атрибуты student_id и courses.
- Метод enroll добавляет курс в список курсов студента.
- Переопределяет метод get_details для включения информации о студенте.

3. Класс `Teacher`, наследующий от `Person`:
- Расширяет базовый класс, добавляя атрибуты employee_id и subjects.
- Метод assign_subject добавляет предмет в список преподаваемых предметов.
- Переопределяет метод get_details для включения информации о преподавателе.

4. Функция `main`:
- Создает экземпляры классов Student и Teacher.
- Заполняет данные о курсах для студента и предметах для преподавателя.
- Выводит информацию о каждом объекте с использованием метода get_details.


Этот пример демонстрирует использование ООП для создания сложной системы управления данными с использованием наследования и полиморфизма, что позволяет эффективно моделировать различные типы пользователей и их поведение.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим пример сложного кода на Python, который включает использование баз данных и ORM (Object-Relational Mapping) с использованием библиотеки SQLAlchemy. В этом примере мы создадим небольшую систему управления библиотекой, где будем хранить информацию о книгах и авторах в базе данных.

### Пример: Система управления библиотекой с использованием SQLAlchemy

#### Шаг 1: Импортируем необходимые модули

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, sessionmaker

#### Шаг 2: Настроим базу данных и ORM

# Создаем базу данных SQLite в памяти
engine = create_engine('sqlite:///:memory:', echo=True)

# Создаем базовый класс для декларативных классов
Base = declarative_base()

#### Шаг 3: Определим модель Author

class Author(Base):
    __tablename__ = 'authors'
    
    id = Column(Integer, primary_key=True)
    name = Column(String)
    
    # Связь с книгами
    books = relationship('Book', back_populates='author')
    
    def __repr__(self):
        return f"<Author(name='{self.name}')>"

#### Шаг 4: Определим модель Book

class Book(Base):
    __tablename__ = 'books'
    
    id = Column(Integer, primary_key=True)
    title = Column(String)
    author_id = Column(Integer, ForeignKey('authors.id'))
    
    # Связь с автором
    author = relationship('Author', back_populates='books')
    
    def __repr__(self):
        return f"<Book(title='{self.title}', author='{self.author.name}')>"

#### Шаг 5: Создадим таблицы в базе данных

Base.metadata.create_all(engine)

#### Шаг 6: Создадим сессию для взаимодействия с базой данных

Session = sessionmaker(bind=engine)
session = Session()

#### Шаг 7: Добавим данные в базу данных

# Создаем авторов
author1 = Author(name='George Orwell')
author2 = Author(name='J.K. Rowling')

# Создаем книги
book1 = Book(title='1984', author=author1)
book2 = Book(title='Animal Farm', author=author1)
book3 = Book(title='Harry Potter and the Philosopher\'s Stone', author=author2)
book4 = Book(title='Harry Potter and the Chamber of Secrets', author=author2)

# Добавляем авторов (книги добавятся автоматически благодаря связи)
session.add(author1)
session.add(author2)

# Фиксируем изменения
session.commit()

#### Шаг 8: Запросим данные из базы данных

# Получаем всех авторов и их книги
authors = session.query(Author).all()
for author in authors:
    print(author)
    for book in author.books:
        print(f"  - {book}")

### Объяснение кода

1. Импорт модулей:
- sqlalchemy: основной модуль для работы с базой данных и ORM.
- declarative_base: базовый класс для декларативных классов.
- Column, Integer, String, ForeignKey: классы для определения типов столбцов и связей.
- relationship, sessionmaker: для установления отношений между таблицами и создания сессий.

2. Создание базы данных и базового класса:
- Создаем базу данных SQLite в памяти.
- Создаем базовый класс для декларативных классов.

3. Модель `Author`:
- Определяет таблицу authors с полями id и name.
- Устанавливает связь с моделью Book через relationship.
- Определяет метод __repr__ для удобного отображения объектов.

4. Модель `Book`:
- Определяет таблицу books с полями id, title и author_id.
- Устанавливает связь с моделью Author через relationship.
- Определяет метод __repr__ для удобного отображения объектов.

5. Создание таблиц в базе данных:
- Создает все таблицы, определенные в моделях, в базе данных.

6. Создание сессии:
- Создает сессию для взаимодействия с базой данных.

7. Добавление данных:
- Создаем объекты Author и Book.
- Добавляем авторов в сессию (книги добавятся автоматически благодаря связи).
- Фиксируем изменения в базе данных.

8. Запрос данных:
- Запрашиваем всех авторов и выводим их книги.

Этот пример демонстрирует использование SQLAlchemy для создания и управления базой данных, а также показывает, как эффективно работать с ORM для моделирования и взаимодействия с данными.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим пример сложного кода на Python, который включает использование асинхронного программирования с asyncio, а также работу с сетевыми сокетами. В этом примере мы создадим асинхронный чат-сервер и клиент, которые могут обмениваться сообщениями в режиме реального времени.

### Пример: Асинхронный чат-сервер и клиент

#### Шаг 1: Асинхронный чат-сервер

import asyncio

clients = []

async def handle_client(reader, writer):
    address = writer.get_extra_info('peername')
    print(f"New connection from {address}")
    clients.append(writer)

    try:
        while True:
            data = await reader.read(100)
            message = data.decode()
            if not message:
                break

            print(f"Received message from {address}: {message}")
            broadcast_message = f"{address}: {message}"
            for client in clients:
                if client != writer:
                    client.write(broadcast_message.encode())
                    await client.drain()

    except asyncio.CancelledError:
        print(f"Connection closed from {address}")
    finally:
        writer.close()
        await writer.wait_closed()
        clients.remove(writer)

async def main():
    server = await asyncio.start_server(handle_client, '127.0.0.1', 8888)
    print("Server started on 127.0.0.1:8888")

    async with server:
        await server.serve_forever()

if __name__ == "__main__":
    asyncio.run(main())

#### Шаг 2: Асинхронный чат-клиент

import asyncio

async def read_message(reader):
    while True:
        data = await reader.read(100)
        if not data:
            break
        print(data.decode())

async def write_message(writer):
    while True:
        message = input("Enter message: ")
        writer.write(message.encode())
        await writer.drain()

async def main():
    reader, writer = await asyncio.open_connection('127.0.0.1', 8888)
    print("Connected to the server")

    await asyncio.gather(
        read_message(reader),
        write_message(writer),
    )

if __name__ == "__main__":
    asyncio.run(main())

### Объяснение кода

1. Асинхронный чат-сервер:
- Импорт модуля: asyncio для асинхронного программирования.
- Глобальная переменная: clients для хранения списка активных соединений.
- Функция `handle_client`:
- Принимает соединения от клиентов.
- Добавляет нового клиента в список clients.
- Читает сообщения от клиента и отправляет их всем остальным клиентам.
- Обрабатывает отключение клиента и удаляет его из списка.
- Функция `main`:
- Запускает сервер на 127.0.0.1:8888.
- Использует serve_forever для постоянного ожидания новых подключений.

2. Асинхронный чат-клиент:
- Импорт модуля: asyncio для асинхронного программирования.
- Функция `read_message`:
- Постоянно читает сообщения от сервера и выводит их на экран.
- Функция `write_message`:
- Постоянно считывает ввод пользователя и отправляет сообщения на сервер.
- Функция `main`:
- Подключается к серверу на 127.0.0.1:8888.
- Использует gather для одновременного выполнения функций чтения и записи сообщений.

### Почему это сложно?

1. Асинхронное программирование:
- Понимание принципов асинхронного выполнения задач и их координации с использованием asyncio.
- Обработка асинхронных операций ввода-вывода.

2. Работа с сетевыми сокетами:
- Настройка и управление сетевыми соединениями для обмена данными.
- Обработка подключения и отключения клиентов.

3. Конкурентность и координация:
- Обеспечение корректного обмена сообщениями между несколькими клиентами.
- Обработка ошибок и корректное закрытие соединений.

Этот пример демонстрирует использование асинхронного программирования для создания реального чат-приложения, где сервер может обслуживать несколько клиентов одновременно, а клиенты могут обмениваться сообщениями в режиме реального времени.

Подпишись 👉🏻 @KodduuPython 🤖

Как применить скидку в 1100 рублей на следующие курсы Python:

👉 Python в нескучных примерах (50) 👍

👉 Python: самый быстрый курс 👍

1️⃣ Переходите по ссылке выше
2️⃣ Там уже есть скидка для всех в 1000 рублей
3️⃣ Но вы не все, поэтому жмете купить
4️⃣ Удаляете текущий промокод
5️⃣ Добавляете промокод TGJUNE2024
6️⃣ Покупаете со скидкой в 1100 рублей
7️⃣ В своем темпе проходите курс
8️⃣ А мы отвечаем на все ваши вопросы

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим пример сложного кода на Python, который включает машинное обучение с использованием библиотеки scikit-learn. В этом примере мы создадим модель для классификации цветов ириса на основе датасета Iris, который является стандартным набором данных для демонстрации методов машинного обучения.

### Пример: Классификация цветов ириса с использованием scikit-learn

#### Шаг 1: Импортируем необходимые модули

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

#### Шаг 2: Загрузим и подготовим данные

# Загружаем датасет Iris
iris = load_iris()
X = iris.data
y = iris.target

# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Нормализуем данные
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

#### Шаг 3: Обучим модель k-ближайших соседей (k-NN)

# Создаем и обучаем модель k-NN
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# Делаем прогнозы на тестовой выборке
y_pred = knn.predict(X_test)

#### Шаг 4: Оценим модель

# Вычисляем точность модели
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

# Выводим отчет о классификации
print("Classification Report:")
print(classification_report(y_test, y_pred))

# Выводим матрицу путаницы
conf_matrix = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(conf_matrix)

# Визуализируем матрицу путаницы
plt.figure(figsize=(8, 6))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=iris.target_names, yticklabels=iris.target_names)
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

### Объяснение кода

1. Импорт модулей:
- numpy, pandas: библиотеки для работы с массивами и таблицами данных.
- scikit-learn: библиотека для машинного обучения, включающая различные алгоритмы и инструменты для предобработки данных.
- matplotlib, seaborn: библиотеки для визуализации данных.

2. Загрузка и подготовка данных:
- load_iris: загружает стандартный набор данных Iris.
- train_test_split: разделяет данные на обучающую и тестовую выборки.
- StandardScaler: нормализует данные для улучшения производительности модели.

3. Обучение модели k-NN:
- KNeighborsClassifier: создает модель k-ближайших соседей.
- fit: обучает модель на обучающей выборке.
- predict: делает прогнозы на тестовой выборке.

4. Оценка модели:
- accuracy_score: вычисляет точность модели.
- classification_report: выводит отчет о классификации, включая метрики точности, полноты и F1.
- confusion_matrix: вычисляет матрицу путаницы для анализа ошибок модели.
- Визуализация матрицы путаницы с помощью seaborn.heatmap.

Этот пример демонстрирует использование библиотеки scikit-learn для решения задачи классификации с применением алгоритма k-ближайших соседей, а также включает все этапы работы с данными, начиная от их предобработки и заканчивая оценкой модели и визуализацией результатов.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим библиотеку Pydantic. Эта библиотека используется для валидации данных и управления настройками в Python. Она является одной из ключевых составляющих FastAPI, но может использоваться и отдельно.

Вот пример использования Pydantic для валидации данных:

1. Сначала установите библиотеку Pydantic:

   pip install pydantic
   

2. Затем напишите следующий код:

   from pydantic import BaseModel, ValidationError, validator

   class User(BaseModel):
       id: int
       name: str
       age: int
       email: str

       @validator('age')
       def age_must_be_positive(cls, value):
           if value <= 0:
               raise ValueError('age must be a positive number')
           return value

       @validator('email')
       def email_must_contain_at(cls, value):
           if '@' not in value:
               raise ValueError('email must contain "@"')
           return value

   # Создание экземпляра модели
   try:
       user = User(id=1, name="John Doe", age=30, email="john.doe@example.com")
       print(user)
   except ValidationError as e:
       print(e)

   # Пример с ошибкой в данных
   try:
       user = User(id=2, name="Jane Doe", age=-5, email="jane.doeexample.com")
   except ValidationError as e:
       print(e)
   

В этом примере:

1. Мы определяем модель User с полями id, name, age и email.
2. Мы используем валидаторы для проверки значения поля age (оно должно быть положительным) и поля email (оно должно содержать символ "@").
3. Мы создаем экземпляр модели User и пытаемся создать еще один с ошибками, чтобы показать работу валидации.

Этот пример демонстрирует, как Pydantic может использоваться для валидации данных и обеспечения их корректности перед использованием в приложении.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим библиотеку Poetry. Это современный инструмент для управления зависимостями и упаковки в Python, который упрощает управление проектами и зависимостями.

Пример использования Poetry для создания нового проекта и управления зависимостями:

1. Сначала установите Poetry. Следуйте инструкциям на официальном сайте: https://python-poetry.org/docs/#installation

2. Создайте новый проект с помощью Poetry:

   poetry new my_project
   

3. Перейдите в каталог проекта:

   cd my_project
   

4. Добавьте зависимость в проект, например, requests:

   poetry add requests
   

5. Создайте файл main.py с примером кода, использующим библиотеку requests:

   import requests

   response = requests.get('https://api.github.com')
   if response.status_code == 200:
       print("Success!")
       print(response.json())
   else:
       print("An error occurred.")
   

6. Запустите проект с помощью Poetry:

   poetry run python main.py
   

Пример использования Poetry в более сложном проекте:

1. Создайте проект с несколькими модулями:

   my_project/
   ├── my_project/
   │   ├── __init__.py
   │   └── core.py
   ├── tests/
   │   └── test_core.py
   ├── pyproject.toml
   └── README.md
   

2. Добавьте код в файл core.py:

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

3. Добавьте тесты в файл test_core.py:

   from my_project.core import add

   def test_add():
       assert add(1, 2) == 3
       assert add(-1, 1) == 0
   

4. Добавьте библиотеку для тестирования, например pytest:

   poetry add --dev pytest
   

5. Запустите тесты с помощью Poetry:

   poetry run pytest
   

Этот пример демонстрирует, как с помощью Poetry можно создать новый проект, управлять зависимостями, структурировать проект и запускать тесты.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим библиотеку httpx. Это современный HTTP-клиент для Python, который поддерживает асинхронные запросы и позволяет легко выполнять HTTP-запросы с современными возможностями.

Вот пример использования httpx для выполнения синхронных и асинхронных HTTP-запросов:

1. Сначала установите библиотеку httpx:

   pip install httpx
   

2. Напишите следующий код для выполнения синхронных запросов:

   import httpx

   # Выполнение синхронного GET-запроса
   response = httpx.get('https://jsonplaceholder.typicode.com/posts/1')
   if response.status_code == 200:
       print("Success!")
       print(response.json())
   else:
       print("An error occurred.")
   

3. Напишите следующий код для выполнения асинхронных запросов:

   import httpx
   import asyncio

   async def fetch_post():
       async with httpx.AsyncClient() as client:
           response = await client.get('https://jsonplaceholder.typicode.com/posts/1')
           if response.status_code == 200:
               print("Success!")
               print(response.json())
           else:
               print("An error occurred.")

   asyncio.run(fetch_post())
   

В этом примере:

1. Мы используем библиотеку httpx для выполнения HTTP-запросов.
2. В первом коде показан пример выполнения синхронного запроса с использованием функции httpx.get.
3. Во втором коде показан пример выполнения асинхронного запроса с использованием контекстного менеджера httpx.AsyncClient и ключевого слова await.

Этот пример демонстрирует, как легко можно выполнять как синхронные, так и асинхронные HTTP-запросы с использованием библиотеки httpx, что делает ее мощным инструментом для взаимодействия с веб-API.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим библиотеку Pydantic в контексте использования с асинхронной библиотекой SQLModel для работы с базами данных. SQLModel объединяет возможности SQLAlchemy и Pydantic для создания моделей данных и выполнения запросов к базе данных.

Вот пример использования SQLModel для создания и управления базой данных SQLite:

1. Сначала установите библиотеки SQLModel и Pydantic:

   pip install sqlmodel
   

2. Напишите следующий код для создания модели данных и выполнения операций с базой данных:

   from sqlmodel import SQLModel, Field, create_engine, Session, select

   class Hero(SQLModel, table=True):
       id: int = Field(default=None, primary_key=True)
       name: str
       secret_name: str
       age: int = Field(default=None, index=True)

   # Создание базы данных SQLite
   sqlite_file_name = "database.db"
   sqlite_url = f"sqlite:///{sqlite_file_name}"
   engine = create_engine(sqlite_url, echo=True)

   # Создание таблицы
   SQLModel.metadata.create_all(engine)

   # Создание и добавление записей
   def create_heroes():
       with Session(engine) as session:
           hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson", age=30)
           hero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador", age=21)
           session.add(hero_1)
           session.add(hero_2)
           session.commit()

   create_heroes()

   # Запрос и вывод данных
   def get_heroes():
       with Session(engine) as session:
           statement = select(Hero)
           results = session.exec(statement)
           for hero in results:
               print(hero)

   get_heroes()
   

В этом примере:

1. Мы создаем модель данных Hero с полями id, name, secret_name и age, используя SQLModel.
2. Мы создаем базу данных SQLite и таблицу для нашей модели.
3. Мы создаем функцию create_heroes, которая добавляет записи героев в базу данных.
4. Мы создаем функцию get_heroes, которая извлекает и выводит записи из базы данных.

Этот пример демонстрирует, как можно использовать SQLModel для управления базами данных с использованием синтаксиса, основанного на Pydantic и SQLAlchemy, что делает процесс создания и работы с базами данных простым и удобным.

Подпишись 👉🏻 @KodduuPython 🤖

Четыре дня до окончания распродажи курса

👉👉👉 Python: самый быстрый курс 👍👍👍

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим библиотеку Streamlit. Эта библиотека позволяет создавать интерактивные веб-приложения для анализа данных и машинного обучения, используя простые скрипты на Python.

Вот пример использования Streamlit для создания простого веб-приложения, которое принимает ввод пользователя и отображает график:

1. Сначала установите библиотеку Streamlit:

   pip install streamlit
   

2. Создайте файл app.py и напишите следующий код:

   import streamlit as st
   import pandas as pd
   import numpy as np
   import matplotlib.pyplot as plt

   # Заголовок веб-приложения
   st.title("Simple Streamlit App")

   # Ползунок для выбора количества данных
   num_points = st.slider("Select number of data points", min_value=10, max_value=100, value=50)

   # Генерация случайных данных
   data = pd.DataFrame({
       'x': np.arange(num_points),
       'y': np.random.randn(num_points).cumsum()
   })

   # Отображение данных в таблице
   st.write("Generated data:")
   st.write(data)

   # Построение графика
   fig, ax = plt.subplots()
   ax.plot(data['x'], data['y'], marker='o')
   ax.set_xlabel("X-axis")
   ax.set_ylabel("Y-axis")
   ax.set_title("Random Data Plot")

   # Отображение графика
   st.pyplot(fig)
   

3. Запустите приложение с помощью Streamlit:

   streamlit run app.py
   

В этом примере:

1. Мы импортируем необходимые библиотеки: Streamlit, Pandas, NumPy и Matplotlib.
2. Мы создаем заголовок веб-приложения с помощью st.title.
3. Мы добавляем ползунок для выбора количества точек данных с помощью st.slider.
4. Мы генерируем случайные данные и отображаем их в таблице с помощью st.write.
5. Мы создаем график с использованием Matplotlib и отображаем его с помощью st.pyplot.

Этот пример демонстрирует, как легко можно создать интерактивное веб-приложение с использованием Streamlit, что позволяет быстро визуализировать данные и создавать пользовательские интерфейсы для анализа данных.

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример кода для простой рекомендательной системы на Python, которая использует метод коллаборативной фильтрации на основе пользователей. Для этого примера будем использовать библиотеку pandas для обработки данных и библиотеку scikit-learn для построения модели.

### Шаг 1: Импортировать необходимые библиотеки

import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.model_selection import train_test_split
import numpy as np

### Шаг 2: Подготовка данных

Допустим, у нас есть датасет с рейтингами фильмов, где строки представляют пользователей, столбцы представляют фильмы, а значения - это рейтинги, которые пользователи поставили фильмам.

# Пример данных
data = {
    'user_id': [1, 1, 1, 2, 2, 2, 3, 3, 3],
    'movie_id': [1, 2, 3, 1, 2, 4, 1, 3, 4],
    'rating': [5, 3, 4, 4, 2, 5, 2, 4, 3]
}

df = pd.DataFrame(data)

### Шаг 3: Создание матрицы пользователь-фильм

user_movie_matrix = df.pivot(index='user_id', columns='movie_id', values='rating').fillna(0)
print(user_movie_matrix)

### Шаг 4: Вычисление сходства между пользователями

user_similarity = cosine_similarity(user_movie_matrix)
user_similarity_df = pd.DataFrame(user_similarity, index=user_movie_matrix.index, columns=user_movie_matrix.index)
print(user_similarity_df)

### Шаг 5: Создание рекомендательной функции

def get_user_recommendations(user_id, user_movie_matrix, user_similarity_df, k=3):
    # Получаем индексы фильмов, которые пользователь не смотрел
    watched_movies = user_movie_matrix.loc[user_id] > 0
    unwatched_movies = user_movie_matrix.columns[~watched_movies]
    
    # Получаем сходство текущего пользователя с другими пользователями
    user_similarities = user_similarity_df[user_id]
    
    # Предсказание рейтингов для каждого несмотренного фильма
    recommendations = {}
    for movie in unwatched_movies:
        weighted_sum = 0
        similarity_sum = 0
        for other_user in user_movie_matrix.index:
            if user_movie_matrix.loc[other_user, movie] > 0:
                weighted_sum += user_similarities[other_user] * user_movie_matrix.loc[other_user, movie]
                similarity_sum += user_similarities[other_user]
        
        if similarity_sum > 0:
            recommendations[movie] = weighted_sum / similarity_sum
        else:
            recommendations[movie] = 0
    
    # Сортировка рекомендаций по предсказанному рейтингу
    sorted_recommendations = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)
    
    # Возвращаем топ-K рекомендаций
    return sorted_recommendations[:k]

# Пример использования функции для пользователя с ID 1
recommendations = get_user_recommendations(1, user_movie_matrix, user_similarity_df, k=3)
print(recommendations)

Этот пример кода создает простую рекомендательную систему, которая рекомендует фильмы на основе сходства между пользователями. Конечно, это базовая версия, и в реальных приложениях можно использовать более сложные методы, такие как матричная факторизация, нейронные сети и гибридные подходы, чтобы улучшить точность рекомендаций.

Подпишись 👉🏻 @KodduuPython 🤖

Для примера системы логистики на Python, можно рассмотреть задачу оптимизации маршрутов доставки. Этот пример использует алгоритм "ближайшего соседа" для решения задачи коммивояжера (TSP), что позволяет определить оптимальный маршрут для доставки товаров по нескольким пунктам назначения.

### Шаг 1: Импортировать необходимые библиотеки

import numpy as np
import pandas as pd
from scipy.spatial import distance_matrix

### Шаг 2: Определение данных

Допустим, у нас есть набор точек (склады и точки доставки), заданных координатами.

# Пример данных: координаты складов и точек доставки
locations = {
    'Location': ['Warehouse', 'Point 1', 'Point 2', 'Point 3', 'Point 4'],
    'Latitude': [52.5200, 52.5300, 52.5150, 52.5205, 52.5100],
    'Longitude': [13.4050, 13.4100, 13.4200, 13.4000, 13.4300]
}

df = pd.DataFrame(locations)

### Шаг 3: Вычисление матрицы расстояний

# Вычисление матрицы расстояний
coords = df[['Latitude', 'Longitude']].to_numpy()
dist_matrix = distance_matrix(coords, coords)
print(dist_matrix)

### Шаг 4: Реализация алгоритма "ближайшего соседа"

def nearest_neighbor(dist_matrix):
    num_points = dist_matrix.shape[0]
    visited = [False] * num_points
    path = [0]  # Начинаем с точки 0 (склад)
    visited[0] = True
    
    while len(path) < num_points:
        last_point = path[-1]
        nearest_point = None
        nearest_distance = float('inf')
        
        for i in range(num_points):
            if not visited[i] and dist_matrix[last_point][i] < nearest_distance:
                nearest_distance = dist_matrix[last_point][i]
                nearest_point = i
        
        path.append(nearest_point)
        visited[nearest_point] = True
    
    path.append(0)  # Возвращаемся к складу
    return path

# Определение оптимального маршрута
optimal_route_indices = nearest_neighbor(dist_matrix)
optimal_route = df.iloc[optimal_route_indices]
print(optimal_route)

### Шаг 5: Визуализация маршрута (опционально)

Для визуализации маршрута можно использовать библиотеку matplotlib.

import matplotlib.pyplot as plt

def plot_route(df, route):
    plt.figure(figsize=(10, 6))
    for i in range(len(route) - 1):
        start = route[i]
        end = route[i + 1]
        plt.plot([df.iloc[start]['Longitude'], df.iloc[end]['Longitude']], 
                 [df.iloc[start]['Latitude'], df.iloc[end]['Latitude']], 'bo-')
    
    plt.scatter(df['Longitude'], df['Latitude'], c='red')
    for i, txt in enumerate(df['Location']):
        plt.annotate(txt, (df.iloc[i]['Longitude'], df.iloc[i]['Latitude']), textcoords="offset points", xytext=(0,10), ha='center')
    
    plt.xlabel('Longitude')
    plt.ylabel('Latitude')
    plt.title('Optimal Delivery Route')
    plt.grid(True)
    plt.show()

plot_route(df, optimal_route_indices)

Этот пример создает простую логистическую систему для оптимизации маршрутов доставки на основе алгоритма "ближайшего соседа". Конечно, для более сложных задач могут использоваться более продвинутые алгоритмы, такие как алгоритмы линейного программирования, метаэвристики (например, генетические алгоритмы) и другие подходы.

Подпишись 👉🏻 @KodduuPython 🤖

Пример кода для симуляции запуска и разделения ступеней корабля Starship на Python можно реализовать, используя библиотеку matplotlib для визуализации и простую логику для моделирования процесса. Этот пример включает запуск, подъем первой ступени, разделение ступеней и подъем второй ступени.

### Шаг 1: Импортировать необходимые библиотеки

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

### Шаг 2: Определение параметров запуска

# Определение параметров
launch_time = 10      # Время запуска в секундах
separation_time = 50  # Время разделения ступеней в секундах
total_time = 100      # Общее время симуляции в секундах

# Параметры движения
g = 9.81  # Ускорение свободного падения (м/с^2)

# Скорости ступеней
first_stage_velocity = 50  # м/с
second_stage_velocity = 100  # м/с

### Шаг 3: Создание функций для моделирования движения

def position(t, velocity):
    return velocity * t - 0.5 * g * t**2

def velocity(t, initial_velocity):
    return initial_velocity - g * t

### Шаг 4: Настройка визуализации

fig, ax = plt.subplots()
ax.set_xlim(0, total_time)
ax.set_ylim(0, 3000)
ax.set_xlabel('Time (s)')
ax.set_ylabel('Height (m)')
ax.set_title('Starship Launch and Stage Separation')

line1, = ax.plot([], [], 'r-', label='First Stage')
line2, = ax.plot([], [], 'b-', label='Second Stage')
ax.legend()

time_data = []
height_data_first_stage = []
height_data_second_stage = []

def init():
    line1.set_data([], [])
    line2.set_data([], [])
    return line1, line2

### Шаг 5: Анимация движения

def update(frame):
    time_data.append(frame)
    
    if frame <= separation_time:
        height_first_stage = position(frame, first_stage_velocity)
        height_data_first_stage.append(height_first_stage)
        height_data_second_stage.append(None)  # Пока вторая ступень не стартовала
        
    else:
        height_second_stage = position(frame - separation_time, second_stage_velocity)
        height_data_second_stage.append(height_second_stage)
        height_data_first_stage.append(None)  # Первая ступень прекратила подъем
    
    line1.set_data(time_data, height_data_first_stage)
    line2.set_data(time_data, height_data_second_stage)
    
    return line1, line2

### Шаг 6: Запуск анимации

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, total_time, 1), init_func=init, blit=True, repeat=False)

plt.show()

Этот пример кода создает анимацию процесса запуска и разделения ступеней корабля Starship. Первая ступень поднимается до момента разделения, затем вторая ступень продолжает подъем. Высота каждой ступени рассчитывается с учетом ускорения свободного падения.

Для упрощения в этом примере не учитываются многие реальные физические факторы, такие как изменение массы топлива, аэродинамическое сопротивление и другие. Однако этот код демонстрирует основные принципы моделирования и визуализации такого процесса.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте создадим симуляцию движения бактерий в двухмерном пространстве. Для этого используем библиотеку matplotlib для визуализации и библиотеку numpy для работы с массивами и генерации случайных чисел. Бактерии будут двигаться случайным образом, моделируя броуновское движение.

### Шаг 1: Импортирование необходимых библиотек

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

### Шаг 2: Настройка параметров симуляции

# Параметры симуляции
num_bacteria = 50  # Количество бактерий
space_size = 100   # Размер пространства (100x100)
num_steps = 200    # Количество шагов симуляции

# Создание начальных позиций бактерий
positions = np.random.rand(num_bacteria, 2) * space_size

### Шаг 3: Функции для обновления позиций бактерий

def update_positions(positions, step_size=1):
    # Случайные направления движения
    angles = np.random.rand(num_bacteria) * 2 * np.pi
    dx = np.cos(angles) * step_size
    dy = np.sin(angles) * step_size

    # Обновление позиций
    positions[:, 0] += dx
    positions[:, 1] += dy

    # Отражение от границ пространства
    positions[:, 0] = np.clip(positions[:, 0], 0, space_size)
    positions[:, 1] = np.clip(positions[:, 1], 0, space_size)

    return positions

### Шаг 4: Настройка визуализации

fig, ax = plt.subplots()
scat = ax.scatter(positions[:, 0], positions[:, 1], c='blue', marker='o')

ax.set_xlim(0, space_size)
ax.set_ylim(0, space_size)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Bacteria Simulation')

### Шаг 5: Анимация движения бактерий

def animate(frame):
    global positions
    positions = update_positions(positions)
    scat.set_offsets(positions)
    return scat,

ani = animation.FuncAnimation(fig, animate, frames=num_steps, interval=50, blit=True)
plt.show()

Этот код создает симуляцию движения бактерий в двухмерном пространстве. Бактерии начинают с случайных начальных позиций и двигаются случайным образом, моделируя броунКонечно! Давайте создадим симуляцию движения бактерий в двухмерном пространстве. Для этого используем библиотеку matplotlib для визуализации и библиотеку numpy для работы с массивами и генерации случайных чисел. Бактерии будут двигаться случайным образом, моделируя броуновское движение.

### Шаг 1: Импортирование необходимых библиотек

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

### Шаг 2: Настройка параметров симуляции

# Параметры симуляции
num_bacteria = 50  # Количество бактерий
space_size = 100   # Размер пространства (100x100)
num_steps = 200    # Количество шагов симуляции

# Создание начальных позиций бактерий
positions = np.random.rand(num_bacteria, 2) * space_size

### Шаг 3: Функции для обновления позиций бактерий

def update_positions(positions, step_size=1):
    # Случайные направления движения
    angles = np.random.rand(num_bacteria) * 2 * np.pi
    dx = np.cos(angles) * step_size
    dy = np.sin(angles) * step_size

    # Обновление позиций
    positions[:, 0] += dx
    positions[:, 1] += dy

    # Отражение от границ пространства
    positions[:, 0] = np.clip(positions[:, 0], 0, space_size)
    positions[:, 1] = np.clip(positions[:, 1], 0, space_size)

    return positions

### Шаг 4: Настройка визуализации

fig, ax = plt.subplots()
scat = ax.scatter(positions[:, 0], positions[:, 1], c='blue', marker='o')

ax.set_xlim(0, space_size)
ax.set_ylim(0, space_size)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Bacteria Simulation')

### Шаг 5: Анимация движения бактерий

def animate(frame):
    global positions
    positions = update_positions(positions)
    scat.set_offsets(positions)
    return scat,

ani = animation.FuncAnimation(fig, animate, frames=num_steps, interval=50, blit=True)
plt.show()

Этот код создает симуляцию движения бактерий в двухмерном пространстве. Бактерии начинают с случайных начальных позиций и двигаются случайным образом.

Подпишись 👉🏻 @KodduuPython 🤖

Симулировать квантовый мир можно с использованием библиотеки Qiskit, которая предоставляет инструменты для создания и симуляции квантовых схем. В этом примере мы создадим простую квантовую симуляцию, включающую квантовые суперпозиции и запутанность.

### Шаг 1: Установка Qiskit

Если Qiskit не установлен, установите его с помощью следующей команды:

pip install qiskit

### Шаг 2: Импортирование необходимых библиотек

from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
from qiskit.visualization import plot_histogram, plot_bloch_multivector
import matplotlib.pyplot as plt

### Шаг 3: Создание квантовой схемы

Создадим квантовую схему с двумя кубитами. В этой схеме мы будем использовать гейт Адамара для создания суперпозиции и гейт CNOT для создания запутанности между кубитами.

# Создание квантовой схемы с двумя кубитами
qc = QuantumCircuit(2)

# Применение гейта Адамара к первому кубиту
qc.h(0)

# Применение гейта CNOT (контрольный кубит - 0, целевой кубит - 1)
qc.cx(0, 1)

# Отображение квантовой схемы
qc.draw('mpl')
plt.show()

### Шаг 4: Симуляция квантовой схемы

Симуляция квантовой схемы с использованием Aer симулятора из Qiskit.

# Использование симулятора для квантовой схемы
simulator = Aer.get_backend('statevector_simulator')

# Компиляция и выполнение квантовой схемы
compiled_circuit = transpile(qc, simulator)
job = execute(compiled_circuit, simulator)
result = job.result()

# Получение квантового состояния
statevector = result.get_statevector()

# Отображение квантового состояния на сфере Блоха
plot_bloch_multivector(statevector)
plt.show()

### Шаг 5: Измерение квантового состояния

Добавление измерений к квантовой схеме и выполнение симуляции для получения результатов измерений.

# Добавление измерений к квантовой схеме
qc.measure_all()

# Использование симулятора для выполнения измерений
qasm_simulator = Aer.get_backend('qasm_simulator')
compiled_circuit = transpile(qc, qasm_simulator)
qobj = assemble(compiled_circuit)
job = execute(qobj, qasm_simulator)
result = job.result()

# Получение результатов измерений
counts = result.get_counts()

# Отображение результатов измерений в виде гистограммы
plot_histogram(counts)
plt.show()

Этот код создает и симулирует квантовую схему с использованием библиотеки Qiskit. Схема включает создание суперпозиции и запутанности, после чего производятся измерения кубитов, результаты которых визуализируются в виде гистограммы. Это простой пример, демонстрирующий основы квантовых вычислений и квантовых эффектов, таких как суперпозиция и запутанность.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте выберем задачу из области биоинформатики. Например, анализ экспрессии генов с использованием кластеризации. Мы будем использовать библиотеку pandas для работы с данными, matplotlib для визуализации и scikit-learn для проведения кластеризации.

### Задача: Кластеризация данных экспрессии генов

#### Шаги решения:
1. Загрузка и подготовка данных.
2. Нормализация данных.
3. Проведение кластеризации методом K-средних.
4. Визуализация результатов.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

# Загрузка данных экспрессии генов
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/breast-cancer-wisconsin.data.csv"
columns = ["ID", "Clump Thickness", "Uniformity of Cell Size", "Uniformity of Cell Shape",
           "Marginal Adhesion", "Single Epithelial Cell Size", "Bare Nuclei",
           "Bland Chromatin", "Normal Nucleoli", "Mitoses", "Class"]
df = pd.read_csv(url, names=columns)

# Предварительная обработка данных
df.replace('?', np.nan, inplace=True)
df.dropna(inplace=True)
df.drop(['ID'], axis=1, inplace=True)

# Нормализация данных
scaler = StandardScaler()
X_scaled = scaler.fit_transform(df.drop('Class', axis=1))

# Кластеризация методом K-средних
kmeans = KMeans(n_clusters=2, random_state=42)
kmeans.fit(X_scaled)
df['Cluster'] = kmeans.labels_

# Снижение размерности для визуализации (PCA)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
df['PCA1'] = X_pca[:, 0]
df['PCA2'] = X_pca[:, 1]

# Визуализация результатов кластеризации
plt.figure(figsize=(10, 6))
plt.scatter(df['PCA1'], df['PCA2'], c=df['Cluster'], cmap='viridis', marker='o')
plt.title('K-means Clustering of Gene Expression Data')
plt.xlabel('PCA1')
plt.ylabel('PCA2')
plt.colorbar(label='Cluster')
plt.show()

### Описание кода:
1. Загрузка данных: Используем публичный набор данных о раке груди. Загружаем данные и даем им имена столбцов.
2. Предварительная обработка данных: Заменяем отсутствующие значения и удаляем их. Также убираем ненужный столбец "ID".
3. Нормализация данных: Используем StandardScaler для нормализации данных, чтобы все признаки имели среднее значение 0 и стандартное отклонение 1.
4. Кластеризация: Применяем алгоритм K-средних для кластеризации данных на две группы.
5. Снижение размерности: Используем метод главных компонент (PCA) для уменьшения размерности данных до 2 компонентов для последующей визуализации.
6. Визуализация: Строим график рассеяния, где данные окрашены в зависимости от кластера.

Этот пример демонстрирует типичную задачу анализа данных в биоинформатике, включая обработку данных, кластеризацию и визуализацию результатов.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте выберем задачу из области астрономии. В этом примере мы будем использовать библиотеку AstroPy для работы с астрономическими данными, Matplotlib для визуализации и SciPy для анализа данных.

### Задача: Анализ светимости звезд

#### Шаги решения:
1. Загрузка и подготовка данных о звездах.
2. Вычисление основных параметров звезд.
3. Построение диаграммы Герцшпрунга-Рассела (HR-диаграмма).

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from astropy.io import fits
from astropy.table import Table
from scipy.constants import parsec

# Загрузка данных о звездах
url = "https://data.sdss.org/sas/dr16/sdss/atlas/gal_star.fits"
hdul = fits.open(url)
data = Table(hdul[1].data).to_pandas()

# Предварительная обработка данных
# Отбираем звезды с известными расстояниями и видимыми величинами
stars = data.dropna(subset=['parallax', 'phot_g_mean_mag'])
stars['parallax'] = stars['parallax'].astype(float)
stars['phot_g_mean_mag'] = stars['phot_g_mean_mag'].astype(float)

# Вычисление абсолютной величины звезд
stars['distance_pc'] = parsec / (stars['parallax'] * 1e-3)
stars['abs_mag'] = stars['phot_g_mean_mag'] - 5 * np.log10(stars['distance_pc']) + 5

# Построение HR-диаграммы
plt.figure(figsize=(10, 6))
plt.scatter(stars['abs_mag'], stars['bp_rp'], s=1, c='blue')
plt.gca().invert_xaxis()
plt.gca().invert_yaxis()
plt.title('Hertzsprung-Russell Diagram')
plt.xlabel('Absolute Magnitude (M)')
plt.ylabel('Color Index (B-R)')
plt.show()

### Описание кода:
1. Загрузка данных: Используем FITS-файл, содержащий данные о звездах из каталога SDSS. Загружаем данные с помощью AstroPy.
2. Предварительная обработка данных: Отбираем звезды с известными параллаксами и видимыми величинами. Преобразуем значения параллаксов и видимых величин в числовой формат.
3. Вычисление абсолютной величины звезд: Используем формулу для вычисления расстояния до звезд в парсеках и абсолютных величин звезд.
4. Построение HR-диаграммы: Строим диаграмму Герцшпрунга-Рассела, где по оси X откладываем абсолютную величину звезд, а по оси Y — цветовой индекс (разность величин в синих и красных фильтрах).

Этот пример показывает, как можно использовать астрономические данные для анализа и визуализации характеристик звезд.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте выберем задачу из области экологии. В этом примере мы будем использовать библиотеку GeoPandas для работы с геопространственными данными, Matplotlib для визуализации и Shapely для геометрических операций.

### Задача: Анализ распространения лесов

#### Шаги решения:
1. Загрузка и подготовка геопространственных данных о лесах.
2. Преобразование и фильтрация данных.
3. Визуализация данных на карте.

import geopandas as gpd
import matplotlib.pyplot as plt
from shapely.geometry import Polygon

# Загрузка данных о лесах
# Используем пример данных о лесах в формате GeoJSON
url = "https://raw.githubusercontent.com/datasets/geo-boundaries-world-110m/master/countries.geojson"
world = gpd.read_file(url)

# Создаем искусственные данные о лесах
forests = {
    'geometry': [
        Polygon([(-10, 60), (-10, 65), (-5, 65), (-5, 60), (-10, 60)]),
        Polygon([(-120, 30), (-120, 35), (-115, 35), (-115, 30), (-120, 30)])
    ],
    'name': ['Northern Forest', 'Western Forest']
}
forests_gdf = gpd.GeoDataFrame(forests, crs="EPSG:4326")

# Визуализация данных о лесах на карте мира
fig, ax = plt.subplots(figsize=(15, 10))
world.boundary.plot(ax=ax, linewidth=1)
forests_gdf.plot(ax=ax, color='green', alpha=0.5)

plt.title('Distribution of Forests')
plt.xlabel('Longitude')
plt.ylabel('Latitude')
plt.show()

### Описание кода:
1. Загрузка данных: Используем GeoJSON-файл, содержащий границы стран. Загружаем данные с помощью GeoPandas.
2. Создание данных о лесах: Создаем искусственные данные о лесах в виде полигона, используя Shapely.
3. Визуализация данных: Строим карту мира и накладываем на нее полигоны лесов, используя функции plot из GeoPandas.

Этот пример демонстрирует, как можно использовать геопространственные данные для анализа распространения лесов и визуализации этих данных на карте.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте выберем задачу из области экономики. В этом примере мы будем использовать библиотеки pandas для работы с данными, statsmodels для эконометрического анализа и matplotlib для визуализации.

### Задача: Анализ влияния безработицы на ВВП

#### Шаги решения:
1. Загрузка и подготовка экономических данных.
2. Построение модели регрессии.
3. Анализ и визуализация результатов.

import pandas as pd
import matplotlib.pyplot as plt
import statsmodels.api as sm

# Загрузка данных
# Используем искусственные данные для примера
data = {
    'Year': [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010],
    'GDP': [1000, 1020, 1040, 1080, 1100, 1120, 1150, 1170, 1160, 1130, 1150],
    'Unemployment_Rate': [5.0, 5.2, 5.5, 5.8, 6.0, 5.9, 5.7, 5.4, 6.2, 7.0, 6.8]
}
df = pd.DataFrame(data)

# Построение модели регрессии
X = df['Unemployment_Rate']
y = df['GDP']
X = sm.add_constant(X)  # Добавляем константу для регрессии

model = sm.OLS(y, X).fit()
predictions = model.predict(X)

# Анализ результатов
print(model.summary())

# Визуализация результатов
plt.figure(figsize=(10, 6))
plt.scatter(df['Unemployment_Rate'], df['GDP'], color='blue', label='Data')
plt.plot(df['Unemployment_Rate'], predictions, color='red', label='OLS Regression')
plt.xlabel('Unemployment Rate (%)')
plt.ylabel('GDP (in billion USD)')
plt.title('Impact of Unemployment Rate on GDP')
plt.legend()
plt.show()

### Описание кода:
1. Загрузка данных: Создаем искусственные данные, представляющие ВВП и уровень безработицы за несколько лет.
2. Построение модели регрессии: Используем библиотеку statsmodels для построения модели линейной регрессии, где зависимой переменной является ВВП, а независимой переменной — уровень безработицы.
3. Анализ результатов: Выводим резюме модели, включающее коэффициенты, стандартные ошибки и статистики значимости.
4. Визуализация результатов: Строим график зависимости ВВП от уровня безработицы и добавляем линию регрессии.

Этот пример демонстрирует, как можно использовать эконометрические методы для анализа экономических данных и визуализации результатов.

Подпишись 👉🏻 @KodduuPython 🤖

Давайте выберем задачу из области нейронаук. В этом примере мы будем использовать библиотеку MNE для анализа данных ЭЭГ (электроэнцефалографии), pandas для работы с данными и matplotlib для визуализации.

### Задача: Анализ данных ЭЭГ

#### Шаги решения:
1. Загрузка и подготовка данных ЭЭГ.
2. Фильтрация данных.
3. Визуализация данных.

import mne
import matplotlib.pyplot as plt
import pandas as pd

# Загрузка данных ЭЭГ
# Используем пример данных из библиотеки MNE
sample_data_folder = mne.datasets.sample.data_path()
sample_data_raw_file = sample_data_folder + '/MEG/sample/sample_audvis_raw.fif'

raw = mne.io.read_raw_fif(sample_data_raw_file, preload=True)
raw.crop(0, 60)  # Обрезаем данные до первой минуты для быстроты анализа

# Фильтрация данных
raw.filter(1., 40., fir_design='firwin')

# Визуализация данных
raw.plot(n_channels=30, duration=10, title='Raw EEG Data')

# Получение и визуализация спектра мощности
psd, freqs = mne.time_frequency.psd_welch(raw, fmin=1, fmax=40, n_fft=2048)
plt.figure(figsize=(10, 6))
plt.semilogy(freqs, psd.T)
plt.xlabel('Frequency (Hz)')
plt.ylabel('Power Spectral Density (dB)')
plt.title('Power Spectral Density')
plt.show()

### Описание кода:
1. Загрузка данных: Загружаем пример данных ЭЭГ из библиотеки MNE. Эти данные представляют собой запись активности мозга.
2. Фильтрация данных: Применяем полосовой фильтр к данным, чтобы оставить только сигналы в диапазоне от 1 до 40 Гц.
3. Визуализация данных: Визуализируем сырые данные ЭЭГ, отображая 30 каналов за 10 секунд. Затем вычисляем и визуализируем спектр мощности сигнала, чтобы увидеть распределение мощности по частотам.

Этот пример демонстрирует, как можно использовать методы анализа и визуализации данных ЭЭГ для исследования активности мозга.

Подпишись 👉🏻 @KodduuPython 🤖