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 🤖

Как насчет мини-игры "Поймай комету"? В этой игре игроку нужно угадывать позицию кометы на основе ее предыдущих местоположений.

Пример на Python:

python
import random

class Comet:
    def __init__(self, size):
        self.size = size  # размер игрового поля
        self.position = self.random_position()  # начальное положение кометы

    def random_position(self):
        return random.randint(0, self.size - 1)

    def move(self):
        # двигаем комету в случайном направлении
        direction = random.choice([-1, 1])
        new_position = self.position + direction
        # если комета выходит за пределы поля, двигаем ее в обратном направлении
        if new_position < 0 or new_position >= self.size:
            direction = -direction
        self.position += direction

if __name__ == "__main__":
    comet = Comet(10)
    guesses = 3

    print(f"Комета находится где-то на поле размером {comet.size}.")

    while guesses > 0:
        print(f"У вас осталось попыток: {guesses}")
        guess = int(input("Угадайте позицию кометы (0-9): "))
        
        comet.move()

        if guess == comet.position:
            print("Вы угадали! Вы поймали комету!")
            break
        else:
            print("Вы промахнулись!")
            guesses -= 1

    if guesses == 0:
        print(f"Вы проиграли! Комета была на позиции {comet.position}.")

В этой игре комета случайным образом движется по игровому полю размером 10. Игрок пытается угадать позицию кометы, имея только 3 попытки. Каждый раз, когда игрок делает попытку, комета двигается на одну позицию влево или вправо.

Цель игры - угадать текущее местоположение кометы с ограниченным числом попыток.

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

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

python
class Planet:
    def __init__(self, name, distance_from_sun):
        self.name = name
        self.distance_from_sun = distance_from_sun  # среднее расстояние от Солнца в миллионах километров

class SpaceCalculator:
    def __init__(self):
        self.planets = {
            "Меркурий": Planet("Меркурий", 57.9),
            "Венера": Planet("Венера", 108.2),
            "Земля": Planet("Земля", 149.6),
            "Марс": Planet("Марс", 227.9),
            "Юпитер": Planet("Юпитер", 778.5),
            "Сатурн": Planet("Сатурн", 1427),
            "Уран": Planet("Уран", 2871),
            "Нептун": Planet("Нептун", 4498)
        }

    def calculate_distance(self, planet1_name, planet2_name):
        planet1 = self.planets.get(planet1_name)
        planet2 = self.planets.get(planet2_name)

        if not planet1 or not planet2:
            return "Одна из планет не найдена."

        distance = abs(planet1.distance_from_sun - planet2.distance_from_sun)
        return f"Расстояние между {planet1_name} и {planet2_name} составляет {distance} млн км."

if __name__ == "__main__":
    calculator = SpaceCalculator()

    planet1 = input("Введите имя первой планеты: ")
    planet2 = input("Введите имя второй планеты: ")

    print(calculator.calculate_distance(planet1, planet2))

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

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

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

Прежде всего, вам потребуется установить matplotlib, если у вас его еще нет:

bash
pip install matplotlib

Теперь давайте создадим симулятор:

python
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import math

class Planet:
    def __init__(self, name, distance_from_sun, orbital_period):
        self.name = name
        self.distance_from_sun = distance_from_sun
        self.orbital_period = orbital_period

    def position(self, day):
        """Вычисление положения планеты по заданному дню."""
        angle = (day % self.orbital_period) * (2 * math.pi) / self.orbital_period
        x = self.distance_from_sun * math.cos(angle)
        y = self.distance_from_sun * math.sin(angle)
        return x, y

class SolarSystem:
    def __init__(self):
        self.planets = [
            Planet("Меркурий", 57.9, 88),
            Planet("Венера", 108.2, 225),
            Planet("Земля", 149.6, 365),
            Planet("Марс", 227.9, 687),
            Planet("Юпитер", 778.5, 4332),
            Planet("Сатурн", 1427, 10759),
            Planet("Уран", 2871, 30687),
            Planet("Нептун", 4498, 60190)
        ]

    def plot(self, day):
        fig, ax = plt.subplots(figsize=(10, 10))
        ax.set_xlim(-5000, 5000)
        ax.set_ylim(-5000, 5000)

        # Рисуем Солнце в центре
        ax.scatter(0, 0, s=200, c='yellow', label="Солнце")

        for planet in self.planets:
            x, y = planet.position(day)
            ax.scatter(x, y, label=planet.name)

        ax.legend()
        plt.show()

if __name__ == "__main__":
    solar_system = SolarSystem()
    day = int(input("Введите день (0 - бесконечность): "))
    solar_system.plot(day)

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

Учтите, что это упрощенная модель и для более точной симуляции потребуются более сложные расчеты и другие параметры.

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

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

python
class Particle:
    def __init__(self, name, mass, charge, description):
        self.name = name
        self.mass = mass  # в гигаэлектронвольтах/c^2
        self.charge = charge  # в единицах элементарного заряда
        self.description = description

class ParticleCatalog:
    def __init__(self):
        self.particles = {
            "фотон": Particle("фотон", 0, 0, "Фотон — бесмассовая частица, квант электромагнитного поля."),
            "бозон Хиггса": Particle("бозон Хиггса", 125.1, 0, "Бозон Хиггса — элементарная частица, предсказанная теорией для объяснения механизма приобретения массы другими элементарными частицами."),
            "электрон": Particle("электрон", 0.511, -1, "Электрон — элементарная частица, имеющая отрицательный заряд и участвующая во многих электромагнитных взаимодействиях.")
        }

    def display_particle_info(self, name):
        particle = self.particles.get(name.lower())
        if not particle:
            return "Частица не найдена."
        return f"Имя: {particle.name}\nМасса: {particle.mass} ГэВ/c^2\nЗаряд: {particle.charge}е\nОписание: {particle.description}"

if __name__ == "__main__":
    catalog = ParticleCatalog()
    
    while True:
        particle_name = input("\nВведите название частицы (или 'выход' для завершения): ")
        
        if particle_name.lower() == "выход":
            break

        print(catalog.display_particle_info(particle_name))

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

Заметьте, что это лишь базовая модель, и настоящий каталог частиц, такой как Стандартная модель, содержит гораздо больше деталей и частиц.

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

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

python
import random
import matplotlib.pyplot as plt

class Photon:
    def __init__(self, angle=0):
        self.angle = angle  # угол движения фотона относительно оси X

    def scatter(self):
        """Моделирует рассеяние фотона на электроне."""
        delta_angle = random.uniform(-90, 90)  # изменение угла после столкновения, в градусах
        self.angle += delta_angle
        if self.angle > 360:
            self.angle -= 360
        elif self.angle < 0:
            self.angle += 360

def simulate_photon_path(steps):
    photon = Photon()
    x, y = [0], [0]  # начальное положение фотона

    for step in range(steps):
        photon.scatter()
        dx = 1 * (random.uniform(0.9, 1.1)) * (random.choice([1, -1]))  # небольшое случайное изменение для моделирования реалистичного движения
        dy = dx * (random.uniform(0.9, 1.1)) * (random.choice([1, -1]))

        # обновляем координаты фотона на основе его угла
        x.append(x[-1] + dx)
        y.append(y[-1] + dy)

    return x, y

if __name__ == "__main__":
    steps = 100
    x, y = simulate_photon_path(steps)

    plt.figure(figsize=(10, 10))
    plt.plot(x, y, '-o', label="Траектория фотона")
    plt.legend()
    plt.xlabel("X")
    plt.ylabel("Y")
    plt.title("Моделирование пути фотона через материал")
    plt.grid(True)
    plt.show()

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

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

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

Давайте создадим мини-приложение с использованием библиотеки pygame. Это будет простой пример, в котором пользователь может двигать квадрат на экране с помощью клавиш.

1. Установите pygame:

bash
pip install pygame

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

python
import pygame
from pygame.locals import *

# Инициализация pygame
pygame.init()

# Установка параметров дисплея
WIDTH, HEIGHT = 640, 480
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Двигайте квадрат!")

# Установка параметров квадрата
square_size = 50
x, y = (WIDTH - square_size) // 2, (HEIGHT - square_size) // 2
color = (0, 128, 255)
speed = 5

# Основной цикл игры
running = True
while running:
    for event in pygame.event.get():
        if event.type == QUIT:
            running = False

    keys = pygame.key.get_pressed()
    if keys[K_UP]:
        y -= speed
    if keys[K_DOWN]:
        y += speed
    if keys[K_LEFT]:
        x -= speed
    if keys[K_RIGHT]:
        x += speed

    # Ограничение перемещения квадрата внутри окна
    x = max(0, min(WIDTH - square_size, x))
    y = max(0, min(HEIGHT - square_size, y))

    screen.fill((255, 255, 255))  # очистка экрана
    pygame.draw.rect(screen, color, (x, y, square_size, square_size))
    
    pygame.display.flip()

pygame.quit()

Этот код создает простое окно с квадратом, который вы можете двигать с помощью клавиш-стрелок на вашей клавиатуре. Наслаждайтесь и экспериментируйте с разными параметрами!

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

Давайте попробуем создать небольшую визуализацию с помощью библиотеки matplotlib и numpy. Например, создадим анимированный график, где синусоида "двигается" с течением времени.

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

bash
pip install matplotlib numpy

2. Вот код для создания анимированного графика:

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

# Установка параметров фигуры и осей
fig, ax = plt.subplots()
x = np.linspace(0, 2 * np.pi, 100)
line, = ax.plot(x, np.sin(x))

def animate(i):
    line.set_ydata(np.sin(x + i / 10.0))  # Обновление значения Y
    return line,

ani = animation.FuncAnimation(fig, animate, interval=50, blit=True)

plt.show()

Этот код создает анимированный график, где волна синусоиды "перемещается" влево со временем. Вы можете настраивать параметры, такие как скорость анимации, изменяя значение в функции animate или изменяя параметр interval в FuncAnimation.

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

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

from tkinter import *

# Создание окна приложения
root = Tk()

# Добавление кнопок на окно
button1 = Button(root, text="Нажми меня!", command=lambda: print("Кнопка нажата!"))
button2 = Button(root, text="Отмена", command=root.destroy)

# Добавление текста на кнопки
button1.pack()
button2.pack()

# Добавление фонового цвета для кнопок
button1.configure(background="red")
button2.configure(background="blue")

# Добавление обработчика событий для кнопок
button1.bind("<Button-1>", lambda event: print("Кнопка нажата!"))
button2.bind("<Button-1>", lambda event: print("Кнопка нажата!"))

# Запуск цикла обработки событий
root.mainloop()

Этот код создает главное окно приложения с двумя кнопками и текстом "Нажми меня!" и "Отмена". Затем он добавляет обработчики событий для каждой кнопки, которые вызывают функцию print() при нажатии на кнопку. Функция print() выводит сообщение на экран. Наконец, функция mainloop() запускает бесконечный цикл обработки событий, который продолжает работать до тех пор, пока пользователь не закроет приложение.

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

Вот пример кода на Python, который использует библиотеку scipy для анализа данных:

import scipy.stats as stats

# Создание массива данных
data = np.array([[1, 2], [3, 4]])

# Анализ распределения данных
mean = stats.mean(data)
sd = stats.stdev(data)

# Вычисление стандартного отклонения и среднего значения
sd_mean = sd / mean
mean_sd = mean / sd_mean

# Вывод результатов
print("Среднее значение:", mean_sd)
print("Стандартное отклонение:", sd_mean)

Этот код создает массив данных data, содержащий два элемента. Затем он использует функцию mean() из библиотеки scipy для вычисления среднего значения массива. Аналогично, он использует функцию stdev() из той же библиотеки для вычисления стандартного отклонения массива. Результаты выводятся на экран.

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

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

Допустим, наша цель — улучшить текущие показатели на 5% за следующие 8 недель. План будет включать в себя 3 тренировки в неделю по каждому из видов спорта (бег, велосипед, плавание).

python
def training_plan(run_pace_10k, bike_speed_50k, swim_pace_100m):
    # Рассчитываем целевые показатели для улучшения на 5%
    target_run_pace_10k = run_pace_10k * 0.95
    target_bike_speed_50k = bike_speed_50k * 1.05
    target_swim_pace_100m = swim_pace_100m * 0.95

    plan = {}

    # План для бега
    run_sessions = [
        "Длительный бег с комфортным темпом.",
        "Интервальные бега: 5x1000 м с темпом, быстрее текущего на 5%.",
        "Восстановительный бег или прогулка."
    ]

    # План для велосипеда
    bike_sessions = [
        "Длительная поездка с комфортным темпом.",
        "Интервальная тренировка: 6x5 км с темпом, быстрее текущего на 5%.",
        "Легкая поездка или тренировка на стационарном велосипеде."
    ]

    # План для плавания
    swim_sessions = [
        "Плавание средней длительности с комфортным темпом.",
        "Интервальное плавание: 10x100 м с темпом, быстрее текущего на 5%.",
        "Техническая тренировка (упражнения на технику плавания)."
    ]

    plan["Бег"] = run_sessions
    plan["Велосипед"] = bike_sessions
    plan["Плавание"] = swim_sessions

    return plan

if __name__ == "__main__":
    run_pace_10k = float(input("Введите ваш текущий темп на 10 км (в мин/км): "))
    bike_speed_50k = float(input("Введите вашу среднюю скорость на 50 км (км/ч): "))
    swim_pace_100m = float(input("Введите ваш текущий темп на 100 м плавания (в сек/100м): "))

    plan = training_plan(run_pace_10k, bike_speed_50k, swim_pace_100m)

    for discipline, sessions in plan.items():
        print(f"\nТренировки для {discipline}:")
        for session in sessions:
            print(f"- {session}")

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

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

Рассмотрим интересную задачу определения "золотого разреза" числа.

Золотой разрез числа — это такое деление числа на две части, при котором отношение большей части к меньшей равно отношению всего числа к большей части.

Пусть a и b — две части числа (где a > b), и пусть x — исходное число. Тогда золотое разделение можно записать как:

a / b = x / a

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

Давайте напишем функцию, которая находит золотой разрез числа:

python
def golden_ratio_split(x):
    phi = (1 + 5 ** 0.5) / 2
    a = x / (phi + 1)
    b = x - a
    return a, b

if __name__ == "__main__":
    number = float(input("Введите число для его 'золотого разреза': "))
    part1, part2 = golden_ratio_split(number)
    
    print(f"Золотой разрез числа {number}:")
    print(f"Большая часть: {part1:.2f}")
    print(f"Меньшая часть: {part2:.2f}")

Когда вы введете число, программа выдаст его "золотой разрез", разделив число в пропорции золотого сечения.

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

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

Давайте напишем простой скрипт, который будет генерировать стих из предоставленного набора слов, основываясь на схеме рифмовки ABAB:

python
import random

def find_rhymes(word, word_list):
    # Ищем слова с похожим окончанием (последние 2 буквы)
    suffix = word[-2:]
    rhymed_words = [w for w in word_list if w.endswith(suffix) and w != word]
    return rhymed_words

def generate_poem(words):
    if len(words) < 4:
        return "Необходимо больше слов для генерации стиха!"

    random.shuffle(words)  # Перемешиваем слова
    word_a = random.choice(words)

    rhymes_for_a = find_rhymes(word_a, words)
    if not rhymes_for_a:
        return "Не удалось найти рифму для генерации стиха."

    word_b = random.choice(rhymes_for_a)
    words.remove(word_a)
    words.remove(word_b)

    word_c = random.choice(words)
    rhymes_for_c = find_rhymes(word_c, words)

    if not rhymes_for_c:
        return "Не удалось найти рифму для генерации стиха."

    word_d = random.choice(rhymes_for_c)

    return f"{word_a}\n{word_c}\n{word_b}\n{word_d}"

if __name__ == "__main__":
    words = input("Введите слова через пробел: ").split()
    poem = generate_poem(words)
    print("\nСгенерированный стих:")
    print(poem)

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

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

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

python
import random

def generate_story():
    # Фрагменты для начала рассказа
    beginnings = [
        "Однажды, в тёмной и таинственной джунглях,",
        "В далеком царстве, за семью морями,",
        "В городе, где никогда не светило солнце,"
    ]

    # Фрагменты для середины рассказа
    middles = [
        "принцесса была похищена злым драконом,",
        "маг нашёл древнюю книгу с заклинаниями,",
        "кот по имени Барсик стал мэром города,"
    ]

    # Фрагменты для конца рассказа
    endings = [
        "и тогда герой пришел и спас всех.",
        "и они все жили долго и счастливо.",
        "но никто не узнал об этом."
    ]

    # Случайным образом выбираем начало, середину и конец
    beginning = random.choice(beginnings)
    middle = random.choice(middles)
    ending = random.choice(endings)

    # Соединяем все части вместе
    story = f"{beginning} {middle} {ending}"
    return story

if __name__ == "__main__":
    story = generate_story()
    print("Ваша история:")
    print(story)

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

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

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

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

bash
pip install fortuna

Теперь давайте создадим простой пример генерации случайной даты с использованием fortuna.

python
import fortuna

def random_date_example():
    random_date = fortuna.date()  # Генерируем случайную дату
    print(f"Случайная дата: {random_date}")

    random_date_past = fortuna.date(past=True)  # Генерируем случайную дату из прошлого
    print(f"Случайная дата из прошлого: {random_date_past}")

    random_date_future = fortuna.date(future=True)  # Генерируем случайную дату из будущего
    print(f"Случайная дата из будущего: {random_date_future}")

if __name__ == "__main__":
    random_date_example()

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

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

Воспользуемся библиотекой fortuna для генерации полной случайной личности:

Прежде всего, убедитесь, что у вас установлена библиотека:

bash
pip install fortuna

Теперь давайте напишем код:

python
import fortuna

def generate_random_person():
    name = fortuna.full_name()
    birth_date = fortuna.date(past=True, after=1900)
    gender = fortuna.random_element(["Male", "Female", "Other"])
    address = fortuna.address()
    email = fortuna.email()
    phone_number = fortuna.phone_number()

    return {
        "Name": name,
        "Birth Date": birth_date,
        "Gender": gender,
        "Address": address,
        "Email": email,
        "Phone Number": phone_number
    }

if __name__ == "__main__":
    person = generate_random_person()
    for key, value in person.items():
        print(f"{key}: {value}")

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

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