Скидка на программу обучения FullStack Developer and Data Scientist (Python+JS+Data) действует до 31 марта 🔥🔥🔥

Этот код создаёт ASCII-анимацию в стиле фильма «Матрица», где столбики случайных символов медленно падают сверху вниз в терминале. Символы генерируются случайно и отображаются в плотных потоках, обновляясь на экране каждые 0.1 секунды. Эффект достигается с помощью Python, циклического обновления экрана и генерации случайных позиций и символов для каждого столбика.

import os
import random
import time

# ASCII-анимация «Матрицы» с медленными и плотными столбиками
def matrix_rain(width=80, height=24):
    chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*()'
    drops = [random.randint(-height, 0) for _ in range(width)]

    try:
        while True:
            os.system('cls' if os.name == 'nt' else 'clear')
            output = [' ' * width for _ in range(height)]

            for i in range(width):
                if drops[i] >= 0:
                    for j in range(drops[i], min(drops[i] + 8, height)):
                        output[j] = output[j][:i] + random.choice(chars) + output[j][i + 1:]
                drops[i] += 1
                if drops[i] > height and random.random() > 0.8:
                    drops[i] = random.randint(-10, 0)

            print('\n'.join(output))
            time.sleep(0.1)
    except KeyboardInterrupt:
        os.system('cls' if os.name == 'nt' else 'clear')
        print("Animation stopped.")

matrix_rain()

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

Вот Python-скрипт, демонстрирующий основные алгоритмы обработки изображений (Digital Image Processing) с использованием OpenCV и NumPy.

Он выполняет:
1. Чтение изображения.
2. Преобразование в оттенки серого.
3. Размытие по Гауссу.
4. Детекцию границ методом Canny.
5. Бинаризацию (пороговую обработку).
6. Применение фильтра Собеля для выделения границ.

import cv2
import numpy as np

# Загрузка изображения
image = cv2.imread('input.jpg')  # Замените 'input.jpg' на путь к вашему изображению
if image is None:
    print("Ошибка загрузки изображения!")
    exit()

# Преобразование в градации серого
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Размытие по Гауссу
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# Детектор границ Canny
edges = cv2.Canny(blurred, 50, 150)

# Бинаризация (пороговая обработка)
_, thresholded = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# Фильтр Собеля
sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
sobel_combined = cv2.magnitude(sobel_x, sobel_y)

# Отображение результатов
cv2.imshow('Original', image)
cv2.imshow('Grayscale', gray)
cv2.imshow('Blurred', blurred)
cv2.imshow('Canny Edges', edges)
cv2.imshow('Thresholded', thresholded)
cv2.imshow('Sobel Filter', np.uint8(sobel_combined))

cv2.waitKey(0)
cv2.destroyAllWindows()

Требования:
Установите OpenCV перед запуском:

pip install opencv-python numpy

Как использовать:
1. Сохраните этот скрипт как image_processing_demo.py.
2. Добавьте изображение input.jpg в ту же папку.
3. Запустите:

   python image_processing_demo.py
   

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

Дикая скидка на максимальную программу обучения FullStack Developer and Data Scientist (Python+JS+Data+CookBook) до 31 марта 🔥🔥🔥

Вышла третья часть моей статьи на Habr по созданию RAG в нашей компании 👉👉👉 AI агенты — клоны сотрудников (часть 3) 🔥🔥🔥

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

📌 Демо алгоритмов "Разделяй и властвуй" (Divide and Conquer) на Python

🔥 Разделяй и властвуй — это мощная парадигма, основанная на разбиении задачи на подзадачи, их решении и объединении результатов.

🔹 Пример 1: Быстрая сортировка (QuickSort)

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

arr = [33, 10, 68, 19, 76, 55, 21]
print("Отсортированный массив:", quicksort(arr))

🔹 Пример 2: Алгоритм "Максимальная сумма подмассива" (Kadane’s Algorithm)

def max_subarray(arr):
    def helper(left, right):
        if left == right:
            return arr[left]
        mid = (left + right) // 2
        left_sum = helper(left, mid)
        right_sum = helper(mid + 1, right)

        left_max = right_max = float('-inf')
        temp = 0
        for i in range(mid, left - 1, -1):
            temp += arr[i]
            left_max = max(left_max, temp)
        temp = 0
        for i in range(mid + 1, right + 1):
            temp += arr[i]
            right_max = max(right_max, temp)

        return max(left_sum, right_sum, left_max + right_max)

    return helper(0, len(arr) - 1)

arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print("Максимальная сумма подмассива:", max_subarray(arr))

🔹 Пример 3: Возведение в степень (Binary Exponentiation)

def power(x, n):
    if n == 0:
        return 1
    half = power(x, n // 2)
    return half * half if n % 2 == 0 else half * half * x

print("2^10 =", power(2, 10))

⚡️ Где это применяется?
✅ Быстрая сортировка → обработка данных
✅ Поиск подмассива → финансовый анализ
✅ Быстрое возведение в степень → криптография

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

📌 Демо алгоритмов "Динамическое программирование" (Dynamic Programming) на Python

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

🔹 Пример 1: Числа Фибоначчи (с мемоизацией)

def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

print("Fibonacci(10) =", fibonacci(10))

📌 *Оптимизированный рекурсивный подход с мемоизацией* (кешируем уже вычисленные значения).

---

🔹 Пример 2: Задача о рюкзаке (0/1 Knapsack)

def knapsack(weights, values, W):
    n = len(weights)
    dp = [[0] * (W + 1) for _ in range(n + 1)]
    
    for i in range(1, n + 1):
        for w in range(W + 1):
            if weights[i - 1] <= w:
                dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1])
            else:
                dp[i][w] = dp[i - 1][w]
    
    return dp[n][W]

weights = [2, 3, 4, 5]
values = [3, 4, 5, 6]
capacity = 5
print("Максимальная стоимость рюкзака:", knapsack(weights, values, capacity))

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

---

🔹 Пример 3: Поиск наибольшей общей подпоследовательности (LCS)

def lcs(s1, s2):
    m, n = len(s1), len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    
    return dp[m][n]

print("LCS длина:", lcs("AGGTAB", "GXTXAYB"))

📌 *Используется в биоинформатике и сравнении строк (например, Git diff).*

---

⚡ Где это применяется?
✅ Оптимизация алгоритмов 🔄
✅ Геномика и биоинформатика 🧬
✅ Финансовый анализ 📊
✅ Комбинаторные задачи 🎯

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

📌 Необычный Python-код, который вас удивит! 🤯

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

🔎 Попробуйте понять, как он работает!

import sys, random, time
from itertools import permutations as prm
from functools import reduce as rd

class QuantumNeuroAnalyzer:
    def __init__(self):
        self.entropy = [random.randint(10, 99) for _ in range(6)]

    def _deep_quantum_eval(self):
        perms = list(prm(self.entropy))
        return [rd(lambda x,y: (x*y+x^y) % 256, p) for p in perms]

    def analyze(self):
        quantum_states = self._deep_quantum_eval()
        prime_factor = sum(qs for qs in quantum_states if qs % 7 == 0) % 1024
        return prime_factor

def perform_analysis():
    print("Запущен квантовый нейроанализатор нового поколения...")
    for percent in range(0, 101, random.randint(5, 15)):
        sys.stdout.write(f"\rВычисления завершены на {percent}%")
        sys.stdout.flush()
        time.sleep(random.uniform(0.2, 0.6))

    result = QuantumNeuroAnalyzer().analyze()
    time.sleep(0.5)
    print("\rВычисления завершены на 100%")
    print("Обработка результата:")
    secret_codes = [1057, 32, 49, 32, 1040, 1087, 1088, 1077, 1083, 1103, 33]
    for code in secret_codes:
        sys.stdout.write(chr(code))
        sys.stdout.flush()
        time.sleep(0.3)
    print()

if __name__ == "__main__":
    perform_analysis()

🔍 Что делает этот код?
✅ Использует хаотические вычисления для генерации уникального результата
✅ Включает итеративную оптимизацию, чтобы найти правильную комбинацию
✅ Демонстрирует непредсказуемость вычислений в действии

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

📌 Демо алгоритмов для электроники на Python ⚡🔋

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

🔹 Пример 1: Закон Ома (V = IR)

def ohms_law(voltage=None, current=None, resistance=None):
    if voltage is None:
        return current * resistance
    elif current is None:
        return voltage / resistance
    elif resistance is None:
        return voltage / current
    else:
        return "Укажите два известных параметра"

print("Напряжение:", ohms_law(current=2, resistance=10), "В")
print("Сопротивление:", ohms_law(voltage=10, current=2), "Ом")

📌 *Используется для расчета основных параметров цепи.*

---

🔹 Пример 2: Фильтр низких частот (Low-Pass Filter, RC-фильтр)

import numpy as np
import matplotlib.pyplot as plt

# Параметры фильтра
R = 1e3  # 1 кОм
C = 1e-6  # 1 мкФ
fc = 1 / (2 * np.pi * R * C)  # Граничная частота

# Генерация сигнала (шум + синус)
t = np.linspace(0, 0.1, 1000)
signal = np.sin(2 * np.pi * 50 * t) + np.random.normal(0, 0.5, t.shape)

# Реализация фильтра
def low_pass_filter(signal, alpha=0.1):
    filtered_signal = np.zeros_like(signal)
    for i in range(1, len(signal)):
        filtered_signal[i] = alpha * signal[i] + (1 - alpha) * filtered_signal[i - 1]
    return filtered_signal

filtered_signal = low_pass_filter(signal)

# Графики
plt.figure(figsize=(10, 4))
plt.plot(t, signal, label="Шумный сигнал", alpha=0.5)
plt.plot(t, filtered_signal, label="После LPF", linewidth=2)
plt.legend()
plt.show()

📌 *Удаляет высокочастотный шум из сигнала.*

---

🔹 Пример 3: Преобразование Фурье (Анализ сигнала)

from scipy.fftpack import fft
import numpy as np
import matplotlib.pyplot as plt

# Генерация сигнала (две частоты)
Fs = 1000  # Частота дискретизации
T = 1 / Fs
L = 1000
t = np.linspace(0, L*T, L)
signal = np.sin(2 * np.pi * 50 * t) + np.sin(2 * np.pi * 120 * t)

# БПФ (FFT)
spectrum = fft(signal)
frequencies = np.fft.fftfreq(L, T)

# Графики
plt.figure(figsize=(10, 4))
plt.plot(frequencies[:L//2], np.abs(spectrum[:L//2]))
plt.title("Частотный спектр сигнала")
plt.xlabel("Частота (Гц)")
plt.ylabel("Амплитуда")
plt.show()

📌 *Определяет частотный состав сигнала, применяется в анализе звука и радиосвязи.*

---

⚡ Где это применяется?
✅ Анализ схем 📡
✅ Обработка сигналов 🔊
✅ Управление микроконтроллерами (Raspberry Pi, Arduino) 🤖

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

Очередной набор в группу курсы с преподавателями Профессия Python-разработчик. На Python можно написать все что угодно, например RAG систему котрую я сделал для нашей компании 🔥🔥🔥

Реклама. Информация о рекламодателе по ссылкам в посте.

📌 Демо алгоритмов для передачи файлов (File Transfer) на Python 📂🚀

🔥 Передача файлов — ключевая задача в сетях и облачных системах. Рассмотрим локальный, сетевой и облачный методы передачи.

---

🔹 Пример 1: Копирование файла локально

import shutil

source = "example.txt"
destination = "backup/example_copy.txt"

shutil.copy(source, destination)
print(f"Файл скопирован в {destination}")

📌 *Быстрый способ сделать резервную копию файла.*

---

🔹 Пример 2: Передача файлов по сети (Socket)
🔸 Сервер (прием файла):

import socket

server = socket.socket()
server.bind(("0.0.0.0", 12345))
server.listen(1)
conn, addr = server.accept()

with open("received_file.txt", "wb") as file:
    while chunk := conn.recv(1024):
        file.write(chunk)

print("Файл успешно получен!")
conn.close()
server.close()

🔸 Клиент (отправка файла):

import socket

client = socket.socket()
client.connect(("127.0.0.1", 12345))

with open("example.txt", "rb") as file:
    client.sendall(file.read())

print("Файл отправлен!")
client.close()

📌 *Простой TCP-сервер и клиент для передачи файлов в локальной сети.*

---

🔹 Пример 3: Загрузка файла в облако (FTP)

from ftplib import FTP

ftp = FTP("ftp.example.com")
ftp.login("username", "password")

with open("example.txt", "rb") as file:
    ftp.storbinary("STOR example.txt", file)

print("Файл загружен на FTP-сервер")
ftp.quit()

📌 *Используется для загрузки файлов на серверы.*

---

🔹 Пример 4: Передача файла через HTTP (Flask API)
🔸 Сервер:

from flask import Flask, request

app = Flask(__name__)

@app.route("/upload", methods=["POST"])
def upload_file():
    file = request.files["file"]
    file.save("uploaded_" + file.filename)
    return "Файл загружен", 200

app.run(host="0.0.0.0", port=5000)

🔸 Клиент:

import requests

files = {"file": open("example.txt", "rb")}
response = requests.post("http://127.0.0.1:5000/upload", files=files)

print(response.text)

📌 *Простой REST API сервер для загрузки файлов.*

---

⚡ Где это применяется?
✅ Резервное копирование 📦
✅ Передача файлов между устройствами 🌍
✅ Облачные хранилища ☁

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

📌 Демо алгоритмов для финансов (Financial Algorithms) на Python 💰📈

🔥 Финансовые алгоритмы помогают анализировать рынки, рассчитывать доходность и управлять рисками. Рассмотрим ключевые финансовые вычисления.

---

🔹 Пример 1: Расчет сложных процентов

def compound_interest(principal, rate, years):
    return principal * (1 + rate / 100) ** years

p = 1000  # Начальный вклад ($)
r = 5     # Годовая ставка (%)
t = 10    # Количество лет

print(f"Будущая стоимость: ${compound_interest(p, r, t):.2f}")

📌 *Полезно для расчета сбережений и инвестиций.*

---

🔹 Пример 2: Скользящее среднее (Moving Average) для анализа акций

import numpy as np

prices = [100, 102, 101, 105, 107, 110, 108]
window = 3  # Окно среднего

moving_avg = np.convolve(prices, np.ones(window)/window, mode='valid')
print("Скользящее среднее:", moving_avg)

📌 *Используется для сглаживания цен на акции и выявления трендов.*

---

🔹 Пример 3: Коэффициент Шарпа (Sharpe Ratio) для оценки риска

import numpy as np

returns = [0.02, 0.03, -0.01, 0.04, 0.05]  # Дневная доходность
risk_free_rate = 0.01

excess_returns = np.array(returns) - risk_free_rate
sharpe_ratio = np.mean(excess_returns) / np.std(excess_returns)

print("Sharpe Ratio:", sharpe_ratio)

📌 *Помогает сравнивать доходность инвестиций с учетом риска.*

---

🔹 Пример 4: Прогнозирование цен акций с линейной регрессией

import numpy as np
from sklearn.linear_model import LinearRegression

days = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
prices = np.array([100, 102, 104, 108, 110])

model = LinearRegression().fit(days, prices)
future_price = model.predict([[6]])

print(f"Прогнозируемая цена на 6-й день: ${future_price[0]:.2f}")

📌 *Используется для предсказания будущих цен на основе трендов.*

---

🔹 Пример 5: Моделирование Монте-Карло для оценки риска портфеля

import numpy as np

np.random.seed(42)
simulations = 10000
mean_return = 0.07
std_dev = 0.15
years = 10
initial_investment = 10000

simulated_values = initial_investment * (1 + np.random.normal(mean_return, std_dev, simulations)) ** years
percentile_5 = np.percentile(simulated_values, 5)

print(f"Ожидаемая стоимость: ${np.mean(simulated_values):.2f}")
print(f"Наихудший сценарий (5-й перцентиль): ${percentile_5:.2f}")

📌 *Используется для оценки вероятных финансовых результатов.*

---

⚡ Где это применяется?
✅ Инвестиции и трейдинг 📊
✅ Оценка риска и доходности 📉
✅ Финансовое моделирование 📈

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

И очередной набор в группу курсы с преподавателями Профессия Data Scientist с нуля до Junior. Data Science это отдельная вселенная, надо прямо любить делать выводы из большого кол-ва данных, а Python изначально был сделал именно для таких целей 🔥🔥🔥

Реклама. Информация о рекламодателе по ссылкам в посте.

Итак, мы продолжаем создавать RAG (Retrieval Augmented Generation) систему для нашей компании. На этой неделе обсудили с Platform team текущую архитектуру и поняли, что нужно внедрять MCP Server. Да, мы пока делали без него 🤦

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

ЧИТАТЬ ДАЛЬШЕ В НОВОМ КАНАЛЕ 👉🏻👉🏻👉🏻 @aigentto 🤖🤖🤖

Декодирование сигнала с космических аппаратов, таких как Voyager, — это сложная задача, требующая использования передовых методов обработки сигналов и коррекции ошибок. Сигналы, отправляемые с таких аппаратов, крайне слабые из-за огромного расстояния (миллиарды километров), а также подвержены шумам и искажениям. Для надежной передачи данных используется комбинация методов модуляции, кодирования с коррекцией ошибок и фильтрации.

Вот пример Python-кода, который моделирует процесс декодирования сигнала, принимаемого с аппарата типа Voyager. Мы будем использовать следующие ключевые элементы:

1. Модуляция BPSK (Binary Phase Shift Keying): Это тип модуляции, используемый для передачи данных.
2. Код Хэмминга: Простой, но эффективный метод коррекции ошибок.
3. Добавление шума к сигналу: Моделирование влияния шума на сигнал.
4. Декодирование сигнала: Восстановление исходных данных после приема.

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import butter, lfilter

# Генерация случайных битов
def generate_data(num_bits):
    return np.random.randint(0, 2, num_bits)

# Кодирование Хэмминга (7,4)
def hamming_encode(data):
    encoded = []
    for i in range(0, len(data), 4):
        block = data[i:i+4]
        if len(block) < 4:
            block = np.pad(block, (0, 4 - len(block)), 'constant')
        p1 = (block[0] + block[1] + block[3]) % 2
        p2 = (block[0] + block[2] + block[3]) % 2
        p3 = (block[1] + block[2] + block[3]) % 2
        encoded.extend([p1, p2, block[0], p3, block[1], block[2], block[3]])
    return np.array(encoded)

# Декодирование Хэмминга (7,4)
def hamming_decode(received):
    decoded = []
    for i in range(0, len(received), 7):
        block = received[i:i+7]
        if len(block) < 7:
            break
        p1 = (block[0] + block[2] + block[4] + block[6]) % 2
        p2 = (block[1] + block[2] + block[5] + block[6]) % 2
        p3 = (block[3] + block[4] + block[5] + block[6]) % 2
        error_pos = p1 + 2*p2 + 4*p3
        if error_pos > 0 and error_pos <= 7:
            block[error_pos - 1] ^= 1
        decoded.extend([block[2], block[4], block[5], block[6]])
    return np.array(decoded)

# BPSK-модуляция
def bpsk_modulate(bits):
    return 2 * bits - 1

# BPSK-демодуляция
def bpsk_demodulate(signal):
    return (signal > 0).astype(int)

# Добавление гауссовского шума
def add_noise(signal, snr_db):
    snr = 10 ** (snr_db / 10)
    power = np.mean(signal ** 2)
    noise_power = power / snr
    noise = np.sqrt(noise_power) * np.random.randn(len(signal))
    return signal + noise

# Низкочастотный фильтр Баттерворта
def butter_lowpass_filter(data, cutoff, fs, order=2):
    nyq = 0.5 * fs
    normal_cutoff = cutoff / nyq
    b, a = butter(order, normal_cutoff, btype='low')
    return lfilter(b, a, data)

# Основной процесс
np.random.seed(42)
num_bits = 128
snr_db = 10
fs = 1000
cutoff = 300

# Генерация и кодирование
original_data = generate_data(num_bits)
encoded_data = hamming_encode(original_data)
modulated_signal = bpsk_modulate(encoded_data)
noisy_signal = add_noise(modulated_signal, snr_db)
filtered_signal = butter_lowpass_filter(noisy_signal, cutoff, fs)
demodulated_data = bpsk_demodulate(filtered_signal)
decoded_data = hamming_decode(demodulated_data)

# Сравнение
print("Original Data:", original_data)
print("Decoded Data :", decoded_data[:len(original_data)])
print("Match        :", np.array_equal(original_data, decoded_data[:len(original_data)]))

# Визуализация
plt.figure(figsize=(12, 8))

plt.subplot(4, 1, 1)
plt.title("Modulated Signal")
plt.plot(modulated_signal, label="Modulated", color="blue")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 2)
plt.title("Noisy Signal")
plt.plot(noisy_signal, label="Noisy", color="red")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 3)
plt.title("Filtered Signal")
plt.plot(filtered_signal, label="Filtered", color="green")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 4)
plt.title("Demodulated Data")
plt.plot(demodulated_data, label="Demodulated", drawstyle="steps-post")
plt.grid(True)
plt.legend()

plt.tight_layout()
plt.savefig("output_full.png", dpi=300)
plt.show()

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

1. Генерация данных:
- Создается массив случайных битов, которые будут передаваться.

2. Кодирование Хэмминга:
- Данные кодируются с использованием кода Хэмминга (7,4), который добавляет контрольные биты для обнаружения и исправления ошибок.

3. Модуляция BPSK:
- Биты преобразуются в аналоговый сигнал с использованием BPSK (0 -> -1, 1 -> 1).

4. Добавление шума:
- К сигналу добавляется гауссовский шум для моделирования реальных условий передачи.

5. Фильтрация сигнала:
- Низкочастотный фильтр используется для уменьшения шума.

6. Демодуляция BPSK:
- Аналоговый сигнал преобразуется обратно в цифровые биты.

7. Декодирование Хэмминга:
- Полученные биты декодируются, и исправляются возможные ошибки.

8. Визуализация:
- Показаны графики исходного сигнала, зашумленного сигнала, отфильтрованного сигнала и демодулированных данных.

Что можно улучшить?

1. Использование более сложных кодов:
- Например, сверточные коды или коды Рида-Соломона, которые используются в реальных системах связи.

2. Моделирование задержки сигнала:
- Учет времени прохождения сигнала через огромное расстояние.

3. Добавление эффектов Доплера:
- Учет изменения частоты сигнала из-за движения аппарата.

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

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

График кода выше 👆👆👆

Код, который использует matplotlib для анимации движения планет вокруг Солнца по законам Кеплера.

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

# Константы
num_planets = 5  # Количество планет
semi_major_axes = np.linspace(1, 3, num_planets)  # Большие полуоси орбит
orbital_periods = semi_major_axes ** 1.5  # Закон Кеплера T^2 ~ a^3
colors = ['r', 'g', 'b', 'c', 'm']  # Цвета планет

# Генерация орбитальных данных
theta = np.linspace(0, 2 * np.pi, 300)  # Углы для траекторий
orbits_x = [a * np.cos(theta) for a in semi_major_axes]
orbits_y = [0.7 * a * np.sin(theta) for a in semi_major_axes]  # Эллипсы

# Фигуры и оси
fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim(-3.5, 3.5)
ax.set_ylim(-3.5, 3.5)
ax.set_aspect('equal')
ax.set_xticks([])
ax.set_yticks([])
ax.set_title("Keplerian Orbits")

# Солнце
ax.scatter(0, 0, color='yellow', s=100, label='Sun')

# Линии орбит
for i in range(num_planets):
    ax.plot(orbits_x[i], orbits_y[i], linestyle='dashed', color=colors[i], alpha=0.5)

# Планеты и их траектории
planets = [ax.plot([], [], 'o', color=colors[i])[0] for i in range(num_planets)]
trajectories = [ax.plot([], [], '-', color=colors[i], alpha=0.6)[0] for i in range(num_planets)]
traces_x = [[] for _ in range(num_planets)]
traces_y = [[] for _ in range(num_planets)]

# Функция анимации
def update(frame):
    for i in range(num_planets):
        angle = 2 * np.pi * frame / (100 * orbital_periods[i])  # Угловая скорость
        x = semi_major_axes[i] * np.cos(angle)
        y = 0.7 * semi_major_axes[i] * np.sin(angle)
        planets[i].set_data([x], [y])  # Передаем списки
        traces_x[i].append(x)
        traces_y[i].append(y)
        trajectories[i].set_data(traces_x[i], traces_y[i])
    return planets + trajectories

ani = animation.FuncAnimation(fig, update, frames=500, interval=20, blit=True)
plt.show()

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

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

Анимация кода выше 👆👆👆

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