Код для обнаружения космический лучей:

# Бесконечный цикл, который "обнаруживает" космические лучи
while True:
    if False:
        print("Космический луч обнаружен!")
    else:
        print("Обнаружение космических лучей...")

    # Добавим задержку, чтобы не заспамить консоль
    import time
    time.sleep(1)

Этот код будет бесконечно печатать "Обнаружение космических лучей...", пока не обнаружит космический луч! С днем космонавтики всех 🧑‍🚀

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

Давайте рассмотрим два интересных кейса из астрономии и космонавтики, которые можно реализовать на Python:

1. Расчет орбитальных параметров спутника — вычисление параметров орбиты, таких как большая полуось, период обращения и эксцентриситет орбиты.
2. Определение видимости космических объектов — определение, когда и где на Земле можно наблюдать определенные космические объекты, такие как планеты или спутники.

### 1. Расчет орбитальных параметров спутника

Этот код будет использовать закон третьего Кеплера для расчета периода обращения спутника на основе его большой полуоси.

def orbital_period(semi_major_axis, central_mass):
    """
    Calculate the orbital period of a satellite using Kepler's third law.
    
    Args:
    semi_major_axis (float): Semi-major axis of the orbit in meters.
    central_mass (float): Mass of the central body around which the satellite orbits in kilograms.
    
    Returns:
    float: Orbital period in seconds.
    """
    G = 6.67430e-11  # Gravitational constant in m^3 kg^-1 s^-2
    period = 2 * 3.14159 * (semi_major_axis ** 3 / (G * central_mass)) ** 0.5
    return period

# Example usage:
# Earth's mass ~ 5.972e24 kg, GEO orbit semi-major axis ~ 42,164 km
# orbital_period(42164000, 5.972e24)

### 2. Определение видимости космических объектов

Этот код будет использовать библиотеку ephem для определения, когда и где на Земле можно увидеть Марс.

import ephem

def mars_visibility(observer_latitude, observer_longitude):
    """
    Determine the next time Mars is visible from a given location on Earth.
    
    Args:
    observer_latitude (float): Latitude of the observer in degrees.
    observer_longitude (float): Longitude of the observer in degrees.
    
    Returns:
    str: Date and time when Mars is visible next.
    """
    observer = ephem.Observer()
    observer.lat = str(observer_latitude)
    observer.long = str(observer_longitude)
    mars = ephem.Mars()
    next_rising = observer.next_rising(mars)
    return next_rising.datetime().strftime('%Y-%m-%d %H:%M:%S')

# Example usage:
# mars_visibility(48.8566, 2.3522)  # Paris coordinates

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

Дескрипторы в Python — это объекты, которые реализуют методы протокола дескрипторов (__get__, __set__, и __delete__). Они позволяют вам контролировать доступ к атрибутам. Дескрипторы используются для реализации свойств, методов, статических методов, классовых методов и многого другого.

Ниже приведен простой пример, демонстрирующий использование дескрипторов для управления доступом к атрибуту класса:

class TypedProperty:
    def __init__(self, name, type, default=None):
        self.name = "_" + name
        self.type = type
        self.default = default if default else type()

    def __get__(self, instance, cls):
        return getattr(instance, self.name, self.default)

    def __set__(self, instance, value):
        if not isinstance(value, self.type):
            raise TypeError(f"Значение должно быть типа {self.type}")
        setattr(instance, self.name, value)

    def __delete__(self, instance):
        raise AttributeError("Невозможно удалить атрибут")

class Person:
    name = TypedProperty("name", str)
    age = TypedProperty("age", int)

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

# Создание экземпляра класса Person
p = Person("Алексей", 34)

# Получение доступа к атрибутам
print(p.name)  # Алексей
print(p.age)   # 34

# Попытка присвоить некорректный тип данных атрибуту
try:
    p.age = "тридцать четыре"
except TypeError as e:
    print(e)  # Значение должно быть типа <class 'int'>

# Попытка удалить атрибут
try:
    del p.age
except AttributeError as e:
    print(e)  # Невозможно удалить атрибут

В этом примере TypedProperty является дескриптором, который контролирует, что значения, присваиваемые атрибутам name и age экземпляра класса Person, соответствуют указанным типам. Попытка присвоить значение неправильного типа приведет к возникновению исключения TypeError. Также, в данном примере, удаление атрибута с помощью del запрещено и приведет к возникновению AttributeError.

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

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

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

Ниже приведен пример, демонстрирующий создание и использование метакласса для изменения атрибутов класса во время его создания:

# Определение метакласса
class UpperAttrMetaclass(type):
    # Метод __new__ вызывается в момент создания класса
    def __new__(cls, name, bases, dct):
        # Преобразование всех атрибутов класса в верхний регистр
        uppercase_attr = {}
        for name, value in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = value
            else:
                uppercase_attr[name] = value
        # Создание класса с помощью type.__new__
        return type.__new__(cls, name, bases, uppercase_attr)

# Использование метакласса для создания класса
class MyClass(metaclass=UpperAttrMetaclass):
    bar = 'bip'

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

# Попытка доступа к атрибуту в его исходном регистре не сработает
# print(instance.bar)  # Это вызовет AttributeError

# Доступ к атрибуту после его преобразования в верхний регистр
print(instance.BAR)  # Выведет: bip

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

В этом примере UpperAttrMetaclass изменяет все атрибуты класса, созданного с его использованием, преобразуя их имена в верхний регистр. Это достигается за счет переопределения метода __new__ метакласса, который вызывается в момент создания класса. Важно отметить, что метаклассы — это продвинутая и мощная особенность Python, использование которой может сделать код сложнее для понимания. Поэтому применять их следует осторожно и с умом.

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

Понял, давайте попробуем что-то уникальное и полезное в другой области. Рассмотрим библиотеку Pendulum для работы с датами и временем в Python. Pendulum предоставляет удобные инструменты для парсинга, манипуляции и форматирования дат и времени. Она обладает рядом преимуществ перед стандартными библиотеками datetime и pytz, такими как улучшенная поддержка временных зон и более интуитивный API.

### Установка Pendulum

Перед использованием Pendulum убедитесь, что вы установили его через pip:

pip install pendulum

### Пример использования Pendulum

Давайте посмотрим на простой пример, демонстрирующий некоторые возможности Pendulum:

import pendulum

# Создание объекта datetime сейчас
now = pendulum.now()
print(f"Сейчас: {now.to_datetime_string()}")

# Парсинг строки в дату/время
dt = pendulum.parse('2024-04-02T15:30:00')
print(f"Парсинг строки в дату/время: {dt.to_datetime_string()}")

# Работа с временными зонами
paris = pendulum.now('Europe/Paris')
print(f"Время в Париже: {paris.to_datetime_string()}")

# Манипуляции с датой/временем
in_two_weeks = now.add(weeks=2)
print(f"Через две недели будет: {in_two_weeks.to_date_string()}")

# Разница между двумя датами
diff = pendulum.now().diff(pendulum.now().subtract(hours=2))
print(f"Разница между датами: {diff.in_hours()} часов")

# Локализация
localized = now.in_locale('ru')
print(f"Месяц по-русски: {localized.format('MMMM')}")

# Форматирование
formatted = now.format('YYYY-MM-DD HH:mm:ss')
print(f"Отформатированная дата: {formatted}")

Этот пример демонстрирует базовые возможности Pendulum, такие как создание объектов даты/времени, парсинг, работа с временными зонами, манипуляции с датами и временем, разница между датами, локализация и форматирование. Pendulum делает работу с датами и временем в Python значительно проще и интуитивно понятнее.

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

Одной из новых и интересных библиотек в Python, которая появилась на горизонте и привлекла внимание сообщества, является Textual. Textual — это библиотека для создания современных терминальных интерфейсов с использованием асинхронного программирования, что делает её особенно подходящей для создания сложных текстовых пользовательских интерфейсов (TUI).

Textual использует возможности современных терминалов для создания богатых текстовых интерфейсов с элементами управления, анимацией и даже поддержкой веб-технологий в терминале. Она строится на асинхронных возможностях Python и позволяет создавать реактивные TUI с минимальными затратами времени и усилий.

Пример простого текстового интерфейса с использованием Textual:

# Убедитесь, что у вас установлена библиотека Textual
# pip install textual

from textual.app import App
from textual.widgets import Header, Footer, Placeholder

class SimpleApp(App):
    async def on_mount(self) -> None:
        """Метод вызывается при монтировании приложения."""
        # Добавляем виджеты: заголовок, подвал и заполнитель в тело приложения
        await self.view.dock(Header(), edge="top")
        await self.view.dock(Footer(), edge="bottom")
        await self.view.dock(Placeholder(), edge="left", size=40)
        await self.view.dock(Placeholder(), edge="right")

# Запуск приложения
if __name__ == "__main__":
    app = SimpleApp()
    app.run()

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

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

Обратите внимание, что для работы с Textual и асинхронным программированием вам потребуется понимание асинхронных функций и сопрограмм в Python.

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

🔥🔥🔥 Апрельская распродажа курсов 🤖🤖🤖

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

Это курс cook book или книга рецептов, где можно как пройти всю базу по Python, так и попробовать совершенно разные библиотеки от рисования до нейросетей.

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

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

👉 JavaScript: самый быстрый курс 🔥

Перед Вами самый быстрый курс по JavaScript, тут есть все что нужно чтобы начать программировать на JS. Для тех кому некогда, но очень надо выучить JS или подтянуть базу перед собеседованием. Мы отвечаем на все ваши комментарии и вопросы в курсе.

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

### Установка faker

Если у вас еще не установлена библиотека faker, вы можете сделать это с помощью pip:

pip install faker

### Пример использования faker

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

from faker import Faker

# Создаем объект Faker. Можно указать язык/локаль для генерации данных, например, 'ru_RU' для русскоязычных данных.
fake = Faker()

# Генерируем и выводим фиктивные данные
print("Фиктивные данные пользователя:")

for _ in range(5):  # Генерируем данные для 5 пользователей
    name = fake.name()  # Имя
    address = fake.address()  # Адрес
    email = fake.email()  # Электронная почта
    job = fake.job()  # Профессия
    date_of_birth = fake.date_of_birth()  # Дата рождения
    
    # Выводим сгенерированные данные
    print(f"Имя: {name}, Дата рождения: {date_of_birth}, Профессия: {job}, Email: {email}, Адрес: {address}\n")

# Генерация текста на "рыбном" языке
lorem_text = fake.text()
print("Пример текста на 'рыбном' языке:")
print(lorem_text)

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

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

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

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

import re
from collections import Counter

def analyze_text(text):
    # Убираем знаки препинания и приводим к нижнему регистру
    words = re.findall(r'\b\w+\b', text.lower())
    # Подсчёт слов
    total_words = len(words)
    unique_words = len(set(words))
    # Подсчёт предложений
    sentences = re.split(r'[.!?]+', text)
    total_sentences = len(sentences) - 1  # Вычитаем пустое последнее предложение после разделения

    # Часто встречающиеся слова
    word_counts = Counter(words)
    most_common_words = word_counts.most_common(10)

    return {
        "total_words": total_words,
        "unique_words": unique_words,
        "total_sentences": total_sentences,
        "most_common_words": most_common_words
    }

# Чтение текста из файла
def read_file(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        return file.read()

def main():
    file_path = input("Введите путь к файлу для анализа: ")
    text = read_file(file_path)
    result = analyze_text(text)
    
    print(f"Общее количество слов: {result['total_words']}")
    print(f"Количество уникальных слов: {result['unique_words']}")
    print(f"Количество предложений: {result['total_sentences']}")
    print("Наиболее часто встречающиеся слова:")
    for word, count in result['most_common_words']:
        print(f"{word}: {count}")

if __name__ == "__main__":
    main()

Этот код будет работать следующим образом:
1. Сначала он просит пользователя ввести путь к файлу, который необходимо анализировать.
2. Считывает текст из файла и передаёт его в функцию analyze_text.
3. Функция анализирует текст, удаляя знаки препинания, подсчитывая слова и предложения, и находя наиболее часто встречающиеся слова.
4. Выводит полученные результаты.

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

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

Создадим программу, которая генерирует музыкальные пьесы на основе заданной музыкальной гаммы с использованием библиотеки mido, которая предназначена для работы с MIDI файлами. Программа будет спрашивать у пользователя желаемый размер композиции и используемую гамму, после чего создаст случайную музыкальную последовательность.

Для начала установите библиотеку mido:

pip install mido

А вот и сам код:

import random
from mido import MidiFile, MidiTrack, Message, MetaMessage

def create_scale(root_note, scale_type):
    # Музыкальные интервалы для разных типов гамм
    scale_patterns = {
        'major': [2, 2, 1, 2, 2, 2, 1],
        'minor': [2, 1, 2, 2, 1, 2, 2],
    }
    pattern = scale_patterns[scale_type]
    scale = [root_note]
    current_note = root_note
    for step in pattern:
        current_note += step
        if current_note > 127:  # MIDI notes range from 0 to 127
            break
        scale.append(current_note)
    return scale

def generate_music(scale, num_notes, file_name):
    mid = MidiFile()
    track = MidiTrack()
    mid.tracks.append(track)

    track.append(MetaMessage('set_tempo', tempo=500000))  # Установить темп
    track.append(Message('program_change', program=12))   # Выбор инструмента

    for _ in range(num_notes):
        note = random.choice(scale)
        track.append(Message('note_on', note=note, velocity=64, time=120))
        track.append(Message('note_off', note=note, velocity=64, time=120))

    mid.save(file_name)
    print(f"Музыкальное произведение сохранено в {file_name}")

def main():
    root_note = int(input("Введите начальную ноту (MIDI номер): "))
    scale_type = input("Введите тип гаммы (major или minor): ")
    num_notes = int(input("Количество нот в композиции: "))
    file_name = input("Введите имя файла для сохранения композиции: ")

    scale = create_scale(root_note, scale_type)
    generate_music(scale, num_notes, file_name)

if __name__ == "__main__":
    main()

Эта программа выполняет следующие задачи:
1. Запрашивает у пользователя начальную ноту, тип гаммы, количество нот и имя файла.
2. Создаёт музыкальную гамму на основе заданных параметров.
3. Генерирует последовательность нот на основе этой гаммы.
4. Сохраняет полученную музыкальную композицию в MIDI-файл.

Это интересный способ познакомиться с генерацией музыки на Python!

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

Создадим программу на Python, которая моделирует эволюцию популяции с помощью генетического алгоритма. Генетические алгоритмы — это методы поиска и оптимизации, вдохновлённые процессом естественного отбора. Мы создадим простую симуляцию, в которой "особи" популяции будут стремиться к максимальному значению какой-то численной "приспособленности".

import random

# Параметры
population_size = 10
genome_length = 10
mutation_rate = 0.01
num_generations = 50

# Генерируем начальную популяцию
def generate_initial_population(size, genome_length):
    return [[random.randint(0, 1) for _ in range(genome_length)] for _ in range(size)]

# Оценка приспособленности
def fitness(genome):
    return sum(genome)  # Приспособленность особи пропорциональна количеству единиц в геноме

# Размножение
def reproduce(parent1, parent2):
    crossover_point = random.randint(0, len(parent1) - 1)
    child = parent1[:crossover_point] + parent2[crossover_point:]
    return child

# Мутация
def mutate(genome, mutation_rate):
    return [gene if random.random() > mutation_rate else 1 - gene for gene in genome]

# Отбор особей для размножения
def select_pair(population):
    return random.sample(population, 2)

def run_simulation():
    population = generate_initial_population(population_size, genome_length)
    
    for generation in range(num_generations):
        # Оцениваем приспособленность каждой особи
        population = sorted(population, key=fitness, reverse=True)
        
        # Выводим лучшую особь
        print(f"Поколение {generation}, Лучшая приспособленность: {fitness(population[0])}")
        
        # Создаем новую популяцию
        new_population = []
        while len(new_population) < population_size:
            parent1, parent2 = select_pair(population)
            child = reproduce(parent1, parent2)
            child = mutate(child, mutation_rate)
            new_population.append(child)
        
        population = new_population

if __name__ == "__main__":
    run_simulation()

В этой программе:
1. Начальная популяция генерируется случайным образом.
2. Каждое поколение оценивается по приспособленности, определяемой количеством единиц в геноме.
3. Родители выбираются случайно, их дети создаются путем скрещивания, а затем подвергаются мутации.
4. Программа выводит лучшую приспособленность в каждом поколении, что демонстрирует, как улучшается "приспособленность" популяции со временем.

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

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

В Python можно демонстрировать разные парадигмы программирования, такие как процедурное программирование, объектно-ориентированное программирование (ООП) и функциональное программирование. Я покажу примеры каждой из этих парадигм:

1. Процедурное программирование — использует последовательность процедурных вызовов для выполнения задач.
2. Объектно-ориентированное программирование (ООП) — организует программу вокруг объектов и данных, а не функций и логики.
3. Функциональное программирование — строит структуру программы с использованием функций, использует концепции неизменяемости и первоклассных функций.

### Пример кода

#### Процедурное программирование
Процедурный пример может быть реализован как простая функция для вычисления факториала числа:

python
def factorial(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

# factorial(5)

#### Объектно-ориентированное программирование (ООП)
Пример ООП может использовать класс для представления геометрической фигуры, например, круга, с методами для вычисления площади и периметра:

python
class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# circle = Circle(5)
# print(circle.area())
# print(circle.perimeter())

#### Функциональное программирование
Функциональный пример может включать использование функций высшего порядка и лямбда-функций для работы с данными:

python
from functools import reduce

def multiply(x, y):
    return x * y

numbers = [1, 2, 3, 4, 5]
product = reduce(multiply, numbers)

# product

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

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

import random

class MarkovChain:
    def __init__(self):
        self.lookup_dict = {}

    def add_words(self, words):
        for i in range(len(words) - 1):
            key = words[i]
            if key in self.lookup_dict:
                self.lookup_dict[key].append(words[i + 1])
            else:
                self.lookup_dict[key] = [words[i + 1]]

    def train(self, text):
        words = text.split()
        self.add_words(words)

    def generate_text(self, length):
        word1 = random.choice(list(self.lookup_dict.keys()))
        chain = [word1]
        for _ in range(length - 1):
            word2 = random.choice(self.lookup_dict[word1])
            chain.append(word2)
            word1 = word2
            if word1 not in self.lookup_dict:
                break
        return ' '.join(chain)

def main():
    text = """В своем путешествии по Америке я посетил множество интересных мест и увидел много красивых пейзажей."""
    markov = MarkovChain()
    markov.train(text)
    generated_text = markov.generate_text(20)
    print("Сгенерированный текст:", generated_text)

if __name__ == "__main__":
    main()

В этом примере:
1. Класс MarkovChain инициализирует внутренний словарь для хранения последовательностей слов.
2. Метод add_words обрабатывает список слов и добавляет каждое слово в словарь вместе со следующим словом как возможное продолжение.
3. Метод train разбивает исходный текст на слова и передает их в add_words.
4. Метод generate_text создает текст определенной длины, начиная со случайного слова и последовательно выбирая следующее слово из возможных вариантов.

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

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

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

Перед тем как начать, убедитесь, что у вас установлены необходимые библиотеки:

pip install matplotlib numpy

Вот код скрипта:

import numpy as np
import matplotlib.pyplot as plt

def generate_data():
    # Генерация случайных данных
    x = np.random.rand(50) * 100  # 50 случайных значений X от 0 до 100
    y = x * 0.5 + np.random.normal(size=50) * 10  # Y зависит от X, добавляем нормальный шум
    return x, y

def plot_data(x, y):
    plt.figure(figsize=(8, 5))
    plt.scatter(x, y, color='blue', alpha=0.5, label='Data points')
    plt.title('Random Data Scatter Plot')
    plt.xlabel('X values')
    plt.ylabel('Y values')
    plt.legend()
    plt.grid(True)
    plt.show()

def main():
    x, y = generate_data()
    plot_data(x, y)

if __name__ == "__main__":
    main()

В этой программе:
1. Функция generate_data() генерирует случайные данные для двух переменных x и y, где y частично зависит от x с добавлением случайного шума.
2. Функция plot_data() использует matplotlib для создания и отображения графика разброса. Мы настраиваем некоторые аспекты визуализации, такие как цвет точек, подписи осей и сетка.
3. main() вызывает эти функции для выполнения генерации данных и их визуализации.

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

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

Допустим, мы хотим создать микросервис для обработки запросов по REST API с использованием асинхронной библиотеки FastAPI. Этот микросервис будет принимать запросы на добавление пользователей в базу данных и возвращать информацию о пользователях.

from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel
from typing import List
import databases
import sqlalchemy
from sqlalchemy import create_engine, Column, Integer, String, MetaData
import asyncio

DATABASE_URL = "sqlite:///./test.db"
database = databases.Database(DATABASE_URL)
metadata = MetaData()

users = sqlalchemy.Table(
    "users",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("name", String(50)),
    Column("email", String(50))
)

engine = create_engine(DATABASE_URL)
metadata.create_all(engine)

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

class UserCreate(BaseModel):
    name: str
    email: str

app = FastAPI()

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

@app.post("/users/", response_model=User, status_code=status.HTTP_201_CREATED)
async def create_user(user: UserCreate):
    query = users.insert().values(name=user.name, email=user.email)
    last_record_id = await database.execute(query)
    return {**user.dict(), "id": last_record_id}

@app.get("/users/", response_model=List[User])
async def read_users():
    query = users.select()
    result = await database.fetch_all(query)
    return result

@app.get("/users/{user_id}", response_model=User)
async def read_user(user_id: int):
    query = users.select().where(users.c.id == user_id)
    user = await database.fetch_one(query)
    if user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return user

Этот код демонстрирует:

1. Создание базы данных и таблиц с помощью SQLAlchemy.
2. Асинхронное взаимодействие с базой данных через databases.
3. Определение моделей данных с использованием Pydantic для валидации.
4. Обработка API-запросов с помощью FastAPI для создания и чтения данных пользователей.
5. Асинхронный старт и остановка сервиса.

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

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

Давайте расширим предыдущий пример, добавив к нашему микросервису возможность обновления и удаления данных пользователей. Также мы добавим более сложные элементы, такие как валидация данных и использование средств логирования для отслеживания событий.

import logging
from fastapi import FastAPI, HTTPException, status, Depends
from pydantic import BaseModel, EmailStr, validator
from typing import List, Optional
import databases
import sqlalchemy
from sqlalchemy import create_engine, Column, Integer, String, MetaData
import asyncio

# Setup logger
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

DATABASE_URL = "sqlite:///./test.db"
database = databases.Database(DATABASE_URL)
metadata = MetaData()

users = sqlalchemy.Table(
    "users",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("name", String(50)),
    Column("email", String(50))
)

engine = create_engine(DATABASE_URL)
metadata.create_all(engine)

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

class UserCreate(BaseModel):
    name: str
    email: EmailStr

    @validator('name')
    def validate_name(cls, value):
        if not value.isalpha():
            raise ValueError('Name must contain only letters')
        return value

class UserUpdate(BaseModel):
    name: Optional[str] = None
    email: Optional[EmailStr] = None

app = FastAPI()

@app.on_event("startup")
async def startup():
    await database.connect()
    logger.info("Database connection established.")

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()
    logger.info("Database connection closed.")

@app.post("/users/", response_model=User, status_code=status.HTTP_201_CREATED)
async def create_user(user: UserCreate):
    query = users.insert().values(name=user.name, email=user.email)
    last_record_id = await database.execute(query)
    logger.info(f"User created with ID: {last_record_id}")
    return {**user.dict(), "id": last_record_id}

@app.get("/users/", response_model=List[User])
async def read_users():
    query = users.select()
    result = await database.fetch_all(query)
    logger.info("Read all users")
    return result

@app.get("/users/{user_id}", response_model=User)
async def read_user(user_id: int):
    query = users.select().where(users.c.id == user_id)
    user = await database.fetch_one(query)
    if user is None:
        logger.warning(f"User not found: {user_id}")
        raise HTTPException(status_code=404, detail="User not found")
    return user

@app.put("/users/{user_id}", response_model=User)
async def update_user(user_id: int, user: UserUpdate):
    query = users.update().where(users.c.id == user_id).values(**user.dict(exclude_unset=True))
    await database.execute(query)
    updated_user = await read_user(user_id)
    logger.info(f"User updated with ID: {user_id}")
    return updated_user

@app.delete("/users/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_user(user_id: int):
    query = users.delete().where(users.c.id == user_id)
    await database.execute(query)
    logger.info(f"User deleted with ID: {user_id}")
    return {"message": "User deleted successfully"}

Этот код включает следующие дополнительные функции:

1. **Валидация данных**: Используется Pydantic для валидации имен и адресов электронной почты пользователей.
2. Логирование: Ведение журнала операций для отслеживания действий пользователей и ошибок.
3. Обновление и удаление данных: API теперь поддерживает запросы PUT и DELETE для обновления и удаления пользователей.

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

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

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

Для реализации такого рода подхода можно использовать библиотеку TensorFlow или PyTorch, которые поддерживают различные техники квантования. Для примера, я покажу, как можно имитировать процесс квантования с использованием TensorFlow. В данном примере мы не будем достигать уровня 1.58 бита, но покажем, как можно квантовать модель с более высоким уровнем квантования, например, до 8 бит:

import tensorflow as tf
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# Загружаем и предобрабатываем данные
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train = x_train.reshape(-1, 28*28).astype('float32')
x_test = x_test.reshape(-1, 28*28).astype('float32')
y_train, y_test = to_categorical(y_train, 10), to_categorical(y_test, 10)

# Строим простую модель
inputs = Input(shape=(784,))
x = Dense(128, activation='relu')(inputs)
outputs = Dense(10, activation='softmax')(x)
model = Model(inputs=inputs, outputs=outputs)

# Компилируем модель
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

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

# Квантуем модель
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
quantized_model = converter.convert()

# Сохраняем квантованную модель
with open('quantized_model.tflite', 'wb') as f:
    f.write(quantized_model)

print("Модель квантована и сохранена.")

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

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

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

Один из интересных и нестандартных подходов в сфере искусственного интеллекта связан с использованием генеративно-состязательных сетей (GANs) для создания синтетических данных. Этот метод позволяет генерировать новые, реалистичные образцы данных, которые могут быть использованы для обучения других машинных моделей, увеличения объемов данных без нарушения приватности и для улучшения моделей машинного обучения в условиях дефицита данных.

Примером применения GAN для создания синтетических изображений может служить следующий код на Python с использованием Keras (библиотеки над TensorFlow):

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, LeakyReLU, BatchNormalization, Reshape, Flatten
from keras.layers.convolutional import Conv2D, Conv2DTranspose
from keras.optimizers import Adam
from keras.datasets import mnist

# Загрузка и подготовка данных
(x_train, _), (_, _) = mnist.load_data()
x_train = (x_train - 127.5) / 127.5  # Нормализация данных в диапазон [-1, 1]
x_train = np.expand_dims(x_train, axis=3)

# Параметры
img_rows, img_cols, channels = 28, 28, 1
img_shape = (img_rows, img_cols, channels)

# Генератор
generator = Sequential([
    Dense(256, input_dim=100),
    LeakyReLU(alpha=0.2),
    BatchNormalization(momentum=0.8),
    Dense(512),
    LeakyReLU(alpha=0.2),
    BatchNormalization(momentum=0.8),
    Dense(1024),
    LeakyReLU(alpha=0.2),
    BatchNormalization(momentum=0.8),
    Dense(np.prod(img_shape), activation='tanh'),
    Reshape(img_shape)
])
generator.summary()

# Дискриминатор
discriminator = Sequential([
    Flatten(input_shape=img_shape),
    Dense(512),
    LeakyReLU(alpha=0.2),
    Dense(256),
    LeakyReLU(alpha=0.2),
    Dense(1, activation='sigmoid')
])
discriminator.summary()
discriminator.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5), metrics=['accuracy'])

# Состязательная модель
discriminator.trainable = False
gan = Sequential([generator, discriminator])
gan.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5))

# Тренировка GAN
def train_gan(epochs, batch_size=128, save_interval=50):
    for epoch in range(epochs):
        # Генерация шума
        noise = np.random.normal(0, 1, (batch_size, 100))
        # Генерация изображений
        gen_imgs = generator.predict(noise)
        
        # Подготовка реальных и синтетических данных
        idx = np.random.randint(0, x_train.shape[0], batch_size)
        real_imgs = x_train[idx]
        valid = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))
        
        # Тренировка дискриминатора
        d_loss_real = discriminator.train_on_batch(real_imgs, valid)
        d_loss_fake = discriminator.train_on_batch(gen_imgs, fake)
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
        
        # Тренировка генератора
        noise = np.random.normal(0, 1, (batch_size, 100))
        g_loss = gan.train_on_batch(noise, valid)
        
        # Прогресс
        print(f"{epoch} [D loss: {d_loss[0]}, acc.: {100*d_loss[1]}%] [G loss: {g_loss}]")

        # Сохранение изображений
        if epoch % save_interval == 0:
            noise = np.random.normal(0, 1, (25, 100))
            gen_imgs = generator.predict(noise)
            gen_imgs = 0.5 * gen_imgs + 0.5  # Денормализация

train_gan(epochs=

10000, batch_size=32, save_interval=1000)

В этом примере:
- Генератор строит изображения из шума.
- Дискриминатор оценивает, насколько реалистично изображение.
- GAN обучается таким образом, чтобы генератор становился все лучше в создании реалистичных изображений, а дискриминатор — в их распознавании.

Такие GANs могут быть использованы в различных областях, от создания искусственного контента до улучшения моделей машинного зрения.

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

Один из необычных и передовых подходов в искусственном интеллекте — использование нейронных сетей для управления коммуникацией между мозгом и компьютером (BCI, Brain-Computer Interface). Эти технологии позволяют людям управлять внешними устройствами, такими как протезы или компьютеры, используя только свои мыслительные процессы. Нейронные сети играют ключевую роль в декодировании нейронных сигналов, что делает возможным преобразование мысленных команд в управляющие сигналы.

В этом примере мы рассмотрим простую модель, которая использует нейронную сеть для классификации и декодирования ЭЭГ-сигналов. ЭЭГ (электроэнцефалограмма) — это метод регистрации электрической активности мозга, и его данные часто используются в системах BCI.

Пример модели на Python с использованием Keras для классификации ЭЭГ-сигналов:

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout, LSTM
from keras.utils import to_categorical
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Загрузка данных ЭЭГ (здесь мы используем гипотетическую функцию загрузки)
def load_eeg_data():
    # В реальном примере данные должны быть загружены и предобработаны соответствующим образом
    data = np.random.rand(1000, 128)  # 1000 примеров, 128 признаков (например, амплитуды сигналов в разные моменты времени)
    labels = np.random.randint(0, 2, 1000)  # Бинарные метки классов
    return data, labels

# Предобработка данных
data, labels = load_eeg_data()
labels = to_categorical(labels, num_classes=2)
data_train, data_test, labels_train, labels_test = train_test_split(data, labels, test_size=0.2)

# Масштабирование данных
scaler = StandardScaler()
data_train = scaler.fit_transform(data_train)
data_test = scaler.transform(data_test)

# Создание модели
model = Sequential([
    LSTM(64, input_shape=(data_train.shape[1], 1), return_sequences=True),
    Dropout(0.5),
    LSTM(32),
    Dropout(0.5),
    Dense(2, activation='softmax')
])

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

# Обучение модели
model.fit(data_train[:, :, np.newaxis], labels_train, epochs=20, batch_size=64)

# Оценка модели
loss, accuracy = model.evaluate(data_test[:, :, np.newaxis], labels_test)
print(f"Точность модели: {accuracy * 100}%")

В этом примере:
- Мы используем LSTM (Long Short-Term Memory) слои, так как они хорошо подходят для работы с временными рядами и последовательными данными, какими являются ЭЭГ-сигналы.
- Производится классификация между двумя состояниями на основе ЭЭГ-данных.
- Данные масштабируются для улучшения процесса обучения.

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

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