ОмуаМуа - это межзвездный объект, который проходит через нашу Солнечную систему. Из-за его высокой скорости и уникальной траектории вычисление его орбиты представляет собой интересную задачу.

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

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

Предположим, что у нас есть следующие приближенные значения для ОмуаМуа:

- Эксцентриситет \( e = 1.2 \)
- Полуосновная ось \( a \) равна расстоянию от Солнца до ближайшей точки траектории ОмуаМуа.

Учитывая это, код будет следующим:

python
import numpy as np
import matplotlib.pyplot as plt

# Приближенные параметры ОмуаМуа
eccentricity = 1.2
semi_major_axis = 1.3  # Предположительное значение

theta = np.linspace(-np.pi/4, np.pi/4, 1000)  # Углы для моделирования

# Уравнение гиперболы в полярных координатах
r = semi_major_axis * (eccentricity**2 - 1) / (1 + eccentricity * np.cos(theta))

x = r * np.cos(theta)
y = r * np.sin(theta)

# Построение графика
plt.figure(figsize=(10,6))
plt.plot(x, y, label="Trajectory of Oumuamua")
plt.scatter(0, 0, color='yellow', s=200, label="Sun")  # Солнце в центре
plt.title("Trajectory of Oumuamua (Simplified Model)")
plt.xlabel("X (au)")
plt.ylabel("Y (au)")
plt.legend()
plt.grid(True)
plt.axis('equal')  # Чтобы сделать масштабы осей X и Y одинаковыми
plt.show()

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

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

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

1. Вам потребуется установить библиотеку:

pip install face_recognition

2. Пример кода:

python
import face_recognition
import sys
from PIL import Image, ImageDraw

# Загрузите изображение, на котором хотите найти лицо
image_path = "path_to_your_image.jpg"
image = face_recognition.load_image_file(image_path)

# Найдите все лица на изображении
face_locations = face_recognition.face_locations(image)

number_of_faces = len(face_locations)
print(f"Found {number_of_faces} face(s) in {image_path}")

# Преобразуем изображение в объект PIL для рисования на нем
pil_image = Image.fromarray(image)
draw = ImageDraw.Draw(pil_image)

for face_location in face_locations:
    top, right, bottom, left = face_location

    # Рисуем прямоугольник вокруг лица
    draw.rectangle([left, top, right, bottom], outline="red")

# Сохраните обработанное изображение
pil_image.show()

Замените path_to_your_image.jpg на путь к вашему изображению. Код найдет лица на изображении и выделит их красными прямоугольниками.

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

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

Рассмотрим другой интересный пример. На этот раз мы будем использовать библиотеку textgenrnn для генерации текста с помощью рекуррентных нейронных сетей.

1. Вам потребуется установить библиотеку:

pip install textgenrnn

2. Пример кода:

python
from textgenrnn import textgenrnn

# Инициализация модели
textgen = textgenrnn.TextgenRnn()

# Обучение модели на некоторых текстах (можно заменить своими данными)
texts = [
    "Hello, how are you?",
    "I'm doing well, thanks for asking!",
    "What are you up to?",
    "Just doing some machine learning.",
    "Sounds fun!"
]

textgen.train_on_texts(texts, num_epochs=10)

# Генерация текста на основе обученной модели
generated_texts = textgen.generate(n=5, return_as_list=True)

for text in generated_texts:
    print(text)

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

Обратите внимание, что данная модель лучше всего работает на больших объемах данных и большом количестве эпох обучения, поэтому результаты, полученные с нашим небольшим набором данных, могут быть довольно примитивными. Но это отличный способ познакомиться с генерацией текста на основе рекуррентных нейронных сетей.

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

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

В этом примере мы будем классифицировать ирисы на основе их характеристик, используя k-ближайших соседей (k-NN) алгоритм.

1. Установите необходимые библиотеки:

bash
pip install matplotlib scikit-learn

2. Пример кода:

python
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Загрузим датасет ирисов
iris = load_iris()
X, y = iris.data, iris.target

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

# Используем k-NN классификатор с k=3
knn = KNeighborsClassifier(n_neighbors=3)

# Обучим классификатор на тренировочных данных
knn.fit(X_train, y_train)

# Предсказание для тестового набора
y_pred = knn.predict(X_test)

# Оценка точности
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")

# Визуализация
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, marker='o', label='Training set')
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred, marker='^', label='Test set')
plt.title('Iris Classification using k-NN')
plt.xlabel(iris.feature_names[0])
plt.ylabel(iris.feature_names[1])
plt.legend()
plt.show()

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

Это позволяет быстро и просто оценить эффективность алгоритма k-NN для данной задачи классификации.

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

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

1. Установите необходимые библиотеки:

bash
pip install numpy matplotlib

2. Пример кода:

python
import numpy as np
import matplotlib.pyplot as plt

# Генерация сигнала: сумма двух синусоид
fs = 500  # частота дискретизации
t = np.linspace(0, 1, fs, endpoint=False)  # временной ряд
f1, f2 = 5, 50  # частоты
y = np.sin(2 * np.pi * f1 * t) + np.sin(2 * np.pi * f2 * t)

# Преобразование Фурье
yf = np.fft.fft(y)
xf = np.fft.fftfreq(t.size, 1 / fs)

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

plt.subplot(2, 1, 1)
plt.plot(t, y)
plt.title('Original Signal')
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')

plt.subplot(2, 1, 2)
plt.plot(xf, 2/fs * np.abs(yf))
plt.title('Magnitude Spectrum')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Magnitude')
plt.xlim(0, 100)  # ограничим частотный диапазон для наглядности

plt.tight_layout()
plt.show()

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

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

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

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

Вот простой пример, как это можно сделать с помощью библиотеки numpy и sounddevice:

1. Установите необходимые модули:

pip install numpy sounddevice

2. Используйте следующий код:

python
import numpy as np
import sounddevice as sd

SAMPLE_RATE = 44100

def generate_tone(freq, duration, sample_rate=SAMPLE_RATE, amplitude=0.5):
    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
    return amplitude * np.sin(2 * np.pi * freq * t)

def play_tone(freq, duration):
    tone = generate_tone(freq, duration)
    sd.play(tone, samplerate=SAMPLE_RATE)
    sd.wait()

# Определите частоты базовых нот
NOTE_C = 261.63  # Частота ноты До в Герц
NOTE_D = 293.66  # Частота ноты Ре в Герц

play_tone(NOTE_C, 1)  # Играть ноту До на 1 секунду
play_tone(NOTE_D, 1)  # Играть ноту Ре на 1 секунду

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

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

Рассмотрим песню "Счастливые дни" (Happy Birthday) в качестве примера.

Для этого нам понадобится больше нот, чем просто До и Ре. Давайте определим их:

python
import numpy as np
import sounddevice as sd

SAMPLE_RATE = 44100

def generate_tone(freq, duration, sample_rate=SAMPLE_RATE, amplitude=0.5):
    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
    return amplitude * np.sin(2 * np.pi * freq * t)

def play_tone(freq, duration):
    tone = generate_tone(freq, duration)
    sd.play(tone, samplerate=SAMPLE_RATE)
    sd.wait()

# Определите частоты базовых нот
NOTE_C = 261.63
NOTE_D = 293.66
NOTE_E = 329.63
NOTE_F = 349.23
NOTE_G = 392.00
NOTE_A = 440.00
NOTE_B = 493.88
NOTE_C_HIGH = 523.25

# Мелодия "Счастливые дни"
melody_sequence = [NOTE_C, NOTE_C, NOTE_D, NOTE_C, NOTE_F, NOTE_E, 
                   NOTE_C, NOTE_C, NOTE_D, NOTE_C, NOTE_G, NOTE_F, 
                   NOTE_C, NOTE_C, NOTE_C_HIGH, NOTE_A, NOTE_F, NOTE_E, NOTE_D,
                   NOTE_B, NOTE_B, NOTE_A, NOTE_F, NOTE_G, NOTE_F]

durations_sequence = [0.5, 0.5, 1, 1, 1, 2, 
                      0.5, 0.5, 1, 1, 1, 2, 
                      0.5, 0.5, 1, 1, 1, 1, 2,
                      0.5, 0.5, 1, 1, 1, 2]

for freq, duration in zip(melody_sequence, durations_sequence):
    play_tone(freq, duration)

Этот код будет играть упрощенную версию песни "Счастливые дни". Вы можете адаптировать этот код, чтобы воспроизвести другие мелодии, добавив соответствующие частоты и продолжительность нот.

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

Если у вас есть MIDI-версия песни, вы можете использовать библиотеку mido для чтения и воспроизведения MIDI-файла в Python.

Для воспроизведения мелодий из MIDI-файла в реальное время на вашем компьютере, вам также потребуется библиотека pygame.

Давайте пройдемся по шагам:

1. Установите необходимые библиотеки:

pip install mido pygame

2. Воспользуйтесь следующим кодом:

python
import mido
from mido import MidiFile
import pygame.midi
import time

# Инициализация pygame.midi
pygame.midi.init()
player = pygame.midi.Output(0)  # Номер может отличаться в зависимости от вашего MIDI устройства
player.set_instrument(0)  # Выберите инструмент (0 - это стандартный акустический гранд-пианино)

# Загрузка MIDI-файла
midi = MidiFile('path_to_your_midi_file.mid')

# Воспроизведение MIDI-файла
for msg in midi.play():
    if msg.type == 'note_on':
        player.note_on(msg.note, msg.velocity)
    elif msg.type == 'note_off':
        player.note_off(msg.note, msg.velocity)
    time.sleep(msg.time)

# Закрытие pygame.midi
player.close()
pygame.midi.quit()

Замените 'path_to_your_midi_file.mid' на путь к вашему MIDI-файлу.

Примечание: Этот код воспроизводит только ноты из MIDI-файла и не учитывает контрольные сообщения или другие атрибуты, которые могут быть в вашем файле. Вы можете дополнительно модифицировать код, чтобы учитывать другие аспекты MIDI-файла.

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

Вот простой пример кода на Python, который реализует алгоритм поиска пути в лабиринте с использованием алгоритма обхода в глубину (Depth First Search).

python
# Простой пример решения лабиринта с использованием DFS (Depth-First Search)

# Простой лабиринт, где 0 — это стена, 1 — проходимая ячейка, 2 — начальная точка, 3 — финиш
maze = [
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 2, 1, 0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0, 0, 0, 0],
    [0, 1, 0, 1, 1, 1, 1, 0],
    [0, 1, 0, 0, 0, 0, 1, 0],
    [0, 1, 1, 1, 1, 1, 1, 0],
    [0, 0, 0, 0, 0, 0, 3, 0],
    [0, 0, 0, 0, 0, 0, 0, 0]
]

def dfs(maze, x, y):
    # Если выход за границы лабиринта, вернуть False
    if x < 0 or x >= len(maze) or y < 0 or y >= len(maze[0]):
        return False
    
    # Если финиш найден, вернуть True
    if maze[x][y] == 3:
        return True
    
    # Если ячейка стена или уже посещена, вернуть False
    if maze[x][y] == 0 or maze[x][y] == 4:
        return False
    
    # Пометить ячейку как посещенную
    maze[x][y] = 4
    
    # Применить DFS к соседним ячейкам
    if dfs(maze, x+1, y) or dfs(maze, x-1, y) or dfs(maze, x, y+1) or dfs(maze, x, y-1):
        return True
    
    return False

# Начальная точка
start_x, start_y = 1, 1
# Поиск пути в лабиринте
found = dfs(maze, start_x, start_y)

# Вывод результата
if found:
    print("Путь найден!")
else:
    print("Путь не найден.")

# Вывод лабиринта с посещенными ячейками
for row in maze:
    print(" ".join(str(cell) for cell in row))

Этот код решает простой лабиринт, исходя из заданных условий. После выполнения кода лабиринт будет также выведен на экран с пометками посещенных ячеек (обозначенных как "4").

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

Вот интересный пример кода на Python, который позволяет генерировать фракталы, такие как "Множество Мандельброта":

python
import matplotlib.pyplot as plt
import numpy as np

def mandelbrot(c,max_iter):
    z = c
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

def display_mandelbrot(xmin,xmax,ymin,ymax,width,height,max_iter):
    r1 = np.linspace(xmin, xmax, width)
    r2 = np.linspace(ymin, ymax, height)
    return (r1, r2, np.array([[mandelbrot(complex(r, i),max_iter) for r in r1] for i in r2]))

def main():
    xmin, xmax, ymin, ymax = -2.0, 0.7, -1.35, 1.35
    width, height = 1000, 1000

    d = display_mandelbrot(xmin,xmax,ymin,ymax,width,height,256)

    plt.imshow(d[2], extent=(xmin, xmax, ymin, ymax))
    plt.show()

if __name__ == "__main__":
    main()

Этот код использует библиотеку matplotlib для отображения фрактала. Если у вас еще не установлена эта библиотека, вы можете установить ее с помощью pip:

pip install matplotlib

Запустите код и вы увидите прекрасное изображение Множества Мандельброта!

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

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

python
def simple_chat_bot(input_text):
    input_text = input_text.lower()
    
    if 'привет' in input_text:
        return "Привет! Как я могу помочь?"
    elif 'как дела' in input_text:
        return "Я же просто программа, у меня нет чувств. А у тебя?"
    elif 'пока' in input_text:
        return "До свидания!"
    else:
        return "Извините, я не понял вашу команду."
        
# Тестирование нашего чат-бота
while True:
    user_input = input("Вы: ")
    if 'выход' in user_input.lower():
        print("Чат-бот: До свидания!")
        break
    response = simple_chat_bot(user_input)
    print(f"Чат-бот: {response}")

Чтобы запустить этот код, скопируйте его и вставьте в вашу IDE или текстовый редактор, а затем выполните. Далее вы сможете взаимодействовать с этим простым чат-ботом. Закончить сессию можно, введя 'выход'.

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

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

1. Сначала установите colorama:

pip install colorama

2. Используйте следующий код:

python
from colorama import init, Fore, Back, Style
import random

# Инициализация colorama
init(autoreset=True)

def colored_output():
    colors = [Fore.RED, Fore.GREEN, Fore.YELLOW, Fore.BLUE, Fore.MAGENTA, Fore.CYAN, Fore.WHITE]

    print("Случайный цвет для каждой буквы в слове 'PYTHON':")

    for letter in 'PYTHON':
        print(random.choice(colors) + letter, end=' ')

    print("\n")

    print(Back.GREEN + "Текст на зеленом фоне")
    print(Back.CYAN + Style.BRIGHT + "Яркий текст на голубом фоне")

colored_output()

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

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

Давайте попробуем что-то интересное с библиотекой pyfiglet. Она позволяет выводить текст в интересных "артистических" шрифтах в консоли.

1. Сначала установите pyfiglet:

bash
pip install pyfiglet

2. Используйте следующий код:

python
import pyfiglet

def fancy_text_output():
    # Выбор шрифта
    font = pyfiglet.Figlet(font='slant')
    
    # Трансформация текста
    transformed_text = font.renderText('Hello, World!')

    print(transformed_text)

fancy_text_output()

Запустите этот код, и вы увидите текст "Hello, World!" в интересном шрифте. Вы можете изменять название шрифта (например, 'slant'), чтобы получить разные стили вывода. Посмотрите другие доступные шрифты в документации pyfiglet или просто попробуйте разные названия наугад.

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

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

Предположим, что у вас есть время t (в минутах) на дистанции d (в километрах). Тогда предсказанное время T на другой дистанции D можно рассчитать по следующей формуле:

T = t x (D/d)^1.06

Вот пример Python кода, который применяет эту формулу:

python
def predict_time(current_time, current_distance, target_distance):
    """
    Предсказание времени на целевой дистанции исходя из текущего результата на другой дистанции.

    :param current_time: Текущее время (в минутах) на дистанции current_distance.
    :param current_distance: Текущая дистанция (в километрах).
    :param target_distance: Целевая дистанция (в километрах).
    :return: Предсказанное время на целевой дистанции.
    """
    return current_time * (target_distance / current_distance) ** 1.06

if __name__ == "__main__":
    distances = {
        "5K": 5,
        "10K": 10,
        "Half Marathon": 21.0975,
        "Marathon": 42.195
    }
    
    current_distance = float(input("Введите текущую дистанцию (например, 5, 10, 21.0975, 42.195): "))
    current_time = float(input("Введите ваше время (в минутах) на этой дистанции: "))
    
    for name, dist in distances.items():
        predicted_time = predict_time(current_time, current_distance, dist)
        hours = int(predicted_time // 60)
        minutes = predicted_time % 60
        print(f"Предполагаемое время для {name}: {hours} часов {minutes:.2f} минут")

Запустите код, введите ваш текущий результат и дистанцию, и программа предоставит прогнозное время на других дистанциях.

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

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

Давайте создадим простой скрипт, который использует этот подход:

python
def predict_time(current_time, current_distance, target_distance, current_weight, target_weight):
    base_time = current_time * (target_distance / current_distance) ** 1.06

    # Эмпирический коэффициент улучшения времени на 1-2% за каждый кг уменьшения веса
    improvement_factor = 1 - 0.01 * (current_weight - target_weight)

    return base_time * improvement_factor

if __name__ == "__main__":
    distances = {
        "5K": 5,
        "10K": 10,
        "Half Marathon": 21.0975,
        "Marathon": 42.195
    }
    
    current_distance = float(input("Введите текущую дистанцию (например, 5, 10, 21.0975, 42.195): "))
    current_time = float(input("Введите ваше время (в минутах) на этой дистанции: "))
    current_weight = float(input("Введите ваш текущий вес (в кг): "))
    target_weight = float(input("Введите ваш целевой вес (в кг): "))

    for name, dist in distances.items():
        predicted_time = predict_time(current_time, current_distance, dist, current_weight, target_weight)
        hours = int(predicted_time // 60)
        minutes = predicted_time % 60
        print(f"Предполагаемое время для {name} при весе {target_weight} кг: {hours} часов {minutes:.2f} минут")

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

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

BMI (индекс массы тела) рассчитывается по следующей формуле:

BMI = вес (кг) / рост (метр)^2

Вот простой скрипт на Python для расчета BMI:

python
def calculate_bmi(weight, height):
    """
    Рассчитать индекс массы тела (BMI).

    :param weight: Вес в кг.
    :param height: Рост в метрах.
    :return: BMI.
    """
    return weight / (height ** 2)

if __name__ == "__main__":
    weight = float(input("Введите ваш вес (в кг): "))
    height = float(input("Введите ваш рост (в метрах, например, 1.75): "))

    bmi = calculate_bmi(weight, height)

    print(f"Ваш индекс массы тела (BMI): {bmi:.2f}")

    # Дополнительно можно добавить интерпретацию результата
    if bmi < 18.5:
        print("Недостаточная масса тела")
    elif 18.5 <= bmi < 24.9:
        print("Нормальная масса тела")
    elif 24.9 <= bmi < 29.9:
        print("Избыточная масса тела (предожирение)")
    else:
        print("Ожирение")

Запустите скрипт, введите свой вес и рост, и он покажет вам ваш индекс массы тела и соответствующую интерпретацию.

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

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

python
import random

# Пример блюд с калорийностью
dishes = {
    "Омлет": 200,
    "Мюсли": 150,
    "Бутерброд с авокадо": 250,
    "Салат Цезарь": 350,
    "Борщ": 220,
    "Спагетти Карбонара": 500,
    "Рис с овощами": 280,
    "Стейк из лосося": 370,
    "Фруктовый салат": 120,
    "Гречка с курой": 320
}

def get_meal(calories, ratio):
    """
    Возвращает блюдо исходя из заданной калорийности и соотношения.
    
    :param calories: Общая калорийность.
    :param ratio: Соотношение калорийности.
    :return: Случайное блюдо исходя из заданной калорийности.
    """
    meal_calories = calories * ratio
    suitable_dishes = [dish for dish, cal in dishes.items() if 0.9 * meal_calories < cal < 1.1 * meal_calories]
    return random.choice(suitable_dishes) if suitable_dishes else "Блюдо не найдено"

if __name__ == "__main__":
    total_calories = float(input("Введите желаемую калорийность на день: "))

    breakfast = get_meal(total_calories, 0.3)
    lunch = get_meal(total_calories, 0.4)
    dinner = get_meal(total_calories, 0.3)

    print(f"Завтрак: {breakfast}")
    print(f"Обед: {lunch}")
    print(f"Ужин: {dinner}")

Вы можете запустить этот код и ввести желаемую калорийность. Программа предложит вам блюда на завтрак, обед и ужин.

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

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

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

python
def fibonacci_stream():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

def find_fib_greater_than(n):
    for fib in fibonacci_stream():
        if fib > n:
            return fib

if __name__ == "__main__":
    print("Бесконечный поток чисел Фибоначчи:")
    
    fib_stream = fibonacci_stream()
    for _ in range(10):
        print(next(fib_stream), end=", ")
    print("...")

    print("\nПервое число Фибоначчи, большее 1000:")
    print(find_fib_greater_than(1000))

Когда этот код запускается, он сначала выводит первые 10 чисел Фибоначчи, а затем первое число Фибоначчи, превышающее 1000. Код использует генератор для эффективного создания потока чисел Фибоначчи без необходимости хранения всех предыдущих чисел в памяти.

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

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

python
import math
import time

class Planet:
    def __init__(self, name, radius, distance, orbital_period):
        self.name = name
        self.radius = radius  # радиус планеты
        self.distance = distance  # среднее расстояние до солнца
        self.orbital_period = orbital_period  # период обращения вокруг солнца (в днях)
        self.angle = 0  # текущий угол в радианах

    def move(self, days):
        """Переместить планету на определенное количество дней"""
        self.angle += (2 * math.pi * days) / self.orbital_period
        self.angle %= (2 * math.pi)

    def position(self):
        """Получить текущие координаты планеты"""
        x = self.distance * math.cos(self.angle)
        y = self.distance * math.sin(self.angle)
        return x, y

class SolarSystem:
    def __init__(self):
        self.planets = []

    def add_planet(self, planet):
        self.planets.append(planet)

    def move_all(self, days):
        for planet in self.planets:
            planet.move(days)

    def display(self):
        for planet in self.planets:
            x, y = planet.position()
            print(f"{planet.name}: x = {x:.2f}, y = {y:.2f}")

if __name__ == "__main__":
    earth = Planet("Земля", 6371, 149.6e6, 365.25)
    mars = Planet("Марс", 3389, 227.9e6, 687)
    venus = Planet("Венера", 6051, 108.2e6, 224.7)

    solar_system = SolarSystem()
    solar_system.add_planet(earth)
    solar_system.add_planet(mars)
    solar_system.add_planet(venus)

    for day in range(0, 366, 10):  # двигаемся на 10 дней за шаг
        print(f"День: {day}")
        solar_system.move_all(10)
        solar_system.display()
        time.sleep(1)

Этот код симулирует движение Земли, Марса и Венеры вокруг Солнца. Планеты перемещаются по своим орбитам с определенным шагом в днях. Текущие координаты каждой планеты выводятся на экране.

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

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

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

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

python
class Rocket:
    def __init__(self, fuel, power):
        self.fuel = fuel  # оставшийся топливо
        self.power = power  # максимальная мощность двигателя
        self.height = 0  # текущая высота
        self.velocity = 0  # текущая скорость
        self.gravity = -9.8  # гравитация планеты

    def thrust(self, percentage):
        """Тяга двигателя. Параметр - процент максимальной мощности."""
        if self.fuel <= 0:
            print("Нет топлива!")
            return
        force = (self.power * percentage) / 100
        self.fuel -= percentage
        self.velocity += force
        if self.fuel < 0:
            self.fuel = 0

    def update(self):
        """Обновляем состояние ракеты каждую секунду."""
        self.velocity += self.gravity
        self.height += self.velocity
        if self.height < 0:
            self.height = 0

if __name__ == "__main__":
    rocket = Rocket(100, 10)

    while rocket.height < 1000 and rocket.fuel > 0:
        print(f"Высота: {rocket.height:.2f} м. Оставшееся топливо: {rocket.fuel:.2f}%")
        percentage = float(input("Введите процент мощности (0-100): "))
        rocket.thrust(percentage)
        rocket.update()
    
    if rocket.height >= 1000:
        print("Успех! Вы достигли орбиты!")
    else:
        print("Топливо закончилось. Вы не смогли достичь орбиты.")

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

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