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

python
class Person:
    def __init__(self, name, parent=None):
        self.name = name
        self.parent = parent
        self.children = []

    def add_child(self, child):
        self.children.append(child)

    def display_family_tree(self, level=0):
        print('  ' * level + self.name)
        for child in self.children:
            child.display_family_tree(level + 1)

def find_person(root, name):
    if root.name == name:
        return root
    for child in root.children:
        result = find_person(child, name)
        if result:
            return result
    return None

if __name__ == "__main__":
    root_name = input("Введите имя основателя семьи: ")
    root = Person(root_name)

    while True:
        print("\nМеню генеалогического дерева:")
        print("1. Добавить члена семьи")
        print("2. Показать дерево")
        print("3. Выйти")
        
        choice = input("Выберите действие (1/2/3): ")
        
        if choice == "1":
            parent_name = input("Введите имя родителя: ")
            child_name = input("Введите имя ребенка: ")
            
            parent = find_person(root, parent_name)
            if parent:
                child = Person(child_name, parent)
                parent.add_child(child)
                print(f"{child_name} добавлен в семью как ребенок {parent_name}.")
            else:
                print(f"Не удалось найти {parent_name} в дереве!")
        elif choice == "2":
            root.display_family_tree()
        elif choice == "3":
            print("До свидания!")
            break
        else:
            print("Неверный выбор. Пожалуйста, попробуйте снова.")

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

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

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

python
class Room:
    def __init__(self, description):
        self.description = description
        self.exits = {}
        self.treasure = False

    def add_exit(self, direction, room):
        self.exits[direction] = room

    def navigate(self, direction):
        return self.exits.get(direction)

    def set_treasure(self):
        self.treasure = True

def game():
    # Создание комнат
    entrance = Room("Вы находитесь у входа в замок. Тяжелые деревянные двери приглашают вас внутрь.")
    hall = Room("Вы в огромном зале с каменными стенами. Портреты королей висят на стенах.")
    library = Room("Это огромная библиотека. Стеллажи с книгами тянутся до потолка.")
    treasury = Room("Это сокровищница! Золотые монеты, драгоценные камни блескают на полках.")

    # Установка выходов для каждой комнаты
    entrance.add_exit("вперед", hall)
    hall.add_exit("назад", entrance)
    hall.add_exit("влево", library)
    hall.add_exit("вперед", treasury)
    library.add_exit("вправо", hall)
    treasury.add_exit("назад", hall)

    # Устанавливаем сокровище в сокровищнице
    treasury.set_treasure()

    # Начало игры
    current_room = entrance
    while True:
        print(current_room.description)
        if current_room.treasure:
            print("Поздравляем! Вы нашли сокровище!")
            break

        direction = input("Куда вы хотите пойти? (вперед/назад/влево/вправо): ")
        if direction in current_room.exits:
            current_room = current_room.navigate(direction)
        else:
            print("Там нет двери. Попробуйте другое направление.")

if __name__ == "__main__":
    game()

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

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

Давайте создадим мини-программу, которая моделирует экосистему пруда с утками и водорослями. Утки едят водоросли и размножаются, водоросли растут сами по себе.

python
import random

class Pond:
    def __init__(self, ducks=2, algae=100):
        self.ducks = ducks
        self.algae = algae

    def pass_day(self):
        # Утки едят водоросли
        algae_eaten = min(self.ducks * 10, self.algae)
        self.algae -= algae_eaten

        # Водоросли растут
        self.algae += 20

        # Шанс на то, что утка размножится
        if random.random() < 0.1 * self.ducks:
            self.ducks += 1

        # Шанс на то, что утка погибнет (если нечего есть)
        if self.algae < 10 and random.random() < 0.3:
            self.ducks -= 1

    def __str__(self):
        return f"В пруду {self.ducks} уток и {self.algae} водорослей."

if __name__ == "__main__":
    pond = Pond()

    days = 30
    for day in range(days):
        pond.pass_day()
        print(f"День {day + 1}: {pond}")

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

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

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

python
class ParkingLot:
    def __init__(self, capacity=5):
        self.capacity = capacity
        self.occupied_slots = 0

    def park(self, car_number):
        if self.occupied_slots < self.capacity:
            self.occupied_slots += 1
            print(f"Автомобиль {car_number} припарковался. Свободных мест: {self.capacity - self.occupied_slots}")
        else:
            print(f"Парковка полна! Автомобиль {car_number} не смог припарковаться.")

    def leave(self, car_number):
        if self.occupied_slots > 0:
            self.occupied_slots -= 1
            print(f"Автомобиль {car_number} покинул парковку. Свободных мест: {self.capacity - self.occupied_slots}")
        else:
            print(f"Парковка пуста! Автомобиль {car_number} не может покинуть парковку.")

if __name__ == "__main__":
    parking_lot = ParkingLot(3)

    parking_lot.park("A123BC")
    parking_lot.park("B456DE")
    parking_lot.park("C789FG")
    parking_lot.park("D101GH")

    parking_lot.leave("A123BC")
    parking_lot.leave("C789FG")
    parking_lot.leave("B456DE")
    parking_lot.leave("D101GH")

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

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

Приведенный ниже код демонстрирует использование библиотеки beautifulsoup4 для парсинга HTML и requests для выполнения HTTP-запросов. С помощью этого кода мы будем извлекать заголовки новостей с главной страницы сайта BBC News:

python
import requests
from bs4 import BeautifulSoup

def fetch_bbc_headlines():
    # Отправляем запрос на главную страницу BBC News
    response = requests.get('https://www.bbc.com/news')
    
    # Проверяем статус ответа
    if response.status_code != 200:
        print("Failed to fetch the webpage")
        return
    
    # Разбираем HTML с помощью BeautifulSoup
    soup = BeautifulSoup(response.content, 'html.parser')
    
    # Ищем все элементы с классом, который соответствует заголовкам новостей
    headlines = soup.find_all('h3', class_='gs-c-promo-heading__title gel-pica-bold nw-o-link-split__text')
    
    # Печатаем заголовки
    for headline in headlines:
        print(headline.text)

if __name__ == "__main__":
    fetch_bbc_headlines()

Для выполнения этого кода, убедитесь, что у вас установлены библиотеки beautifulsoup4 и requests. Вы можете установить их с помощью pip:

pip install beautifulsoup4 requests

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

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

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

python
import numpy as np
import matplotlib.pyplot as plt

def plot_sine_and_cosine_waves():
    # Создаем массив значений от 0 до 4*pi
    x = np.linspace(0, 4 * np.pi, 1000)
    
    # Вычисляем значения синуса и косинуса для каждой точки
    y_sin = np.sin(x)
    y_cos = np.cos(x)

    # Создаем график
    plt.figure(figsize=(10, 6))
    plt.plot(x, y_sin, label='sin(x)', color='blue')
    plt.plot(x, y_cos, label='cos(x)', color='red')
    
    # Настраиваем график
    plt.title('Sine and Cosine Waves')
    plt.xlabel('X values')
    plt.ylabel('Y values')
    plt.legend()
    plt.grid(True)
    
    # Отображаем график
    plt.show()

if __name__ == "__main__":
    plot_sine_and_cosine_waves()

Для выполнения этого кода вам понадобятся библиотеки numpy и matplotlib. Вы можете установить их с помощью pip:

pip install numpy matplotlib

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

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

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

Для простоты рассмотрим граф:

A - B - C
|   |   |
D - E - F

Веса рёбер у нас будут такие:

A-B=1, A-D=2, B-C=2, B-E=3, C-F=3, D-E=2, E-F=1

Исходный код:

python
import heapq

def shortest_path(graph, start, end):
    # Создаем словарь для хранения минимальных дистанций до каждой вершины
    distances = {vertex: float('infinity') for vertex in graph}
    distances[start] = 0

    # Очередь приоритетов
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_vertex = heapq.heappop(priority_queue)

        # Если текущий путь длиннее уже известного, пропускаем
        if current_distance > distances[current_vertex]:
            continue

        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            # Если найденный путь короче уже известного, обновляем его
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances[end]

# Описание графа
graph = {
    'A': {'B': 1, 'D': 2},
    'B': {'A': 1, 'C': 2, 'E': 3},
    'C': {'B': 2, 'F': 3},
    'D': {'A': 2, 'E': 2},
    'E': {'B': 3, 'D': 2, 'F': 1},
    'F': {'C': 3, 'E': 1}
}

print(shortest_path(graph, 'A', 'F'))  # Выведет 5, так как оптимальный путь A->B->C->F имеет длину 6, но есть еще путь A->B->E->F длиной 5

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

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

Рассмотрим алгоритм поиска в ширину (Breadth-First Search, BFS). Он хорошо подходит для поиска кратчайшего пути в невзвешенных графах.

Для примера возьмём такой же граф, но без весов:

A - B - C
|   |   |
D - E - F

Исходный код:

python
from collections import deque

def bfs_shortest_path(graph, start, end):
    # Очередь для хранения путей
    queue = deque([[start]])
    visited = set([start])
    
    while queue:
        # Получаем первый путь из очереди
        path = queue.popleft()
        vertex = path[-1]
        
        # Путь найден
        if vertex == end:
            return path
        
        # Перебор соседних вершин
        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                new_path = list(path)
                new_path.append(neighbor)
                queue.append(new_path)

    return None

# Описание графа
graph = {
    'A': ['B', 'D'],
    'B': ['A', 'C', 'E'],
    'C': ['B', 'F'],
    'D': ['A', 'E'],
    'E': ['B', 'D', 'F'],
    'F': ['C', 'E']
}

print(bfs_shortest_path(graph, 'A', 'F'))  # Выведет ['A', 'B', 'E', 'F'], так как это кратчайший путь от A к F

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

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

Вычисление орбиты планеты или карликовой планеты, такой как Плутон, обычно требует учета многих факторов, таких как гравитационное взаимодействие с другими телами в Солнечной системе, особенности его орбиты и др.

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

Примечание: Данный код будет лишь приближенным моделированием, основанным на усредненных параметрах орбиты Плутона и не учитывающим многие реальные факторы.

python
import numpy as np
import matplotlib.pyplot as plt

# Параметры орбиты Плутона (упрощенные)
semi_major_axis = 39.48  # Полуосновная ось (а.е.)
eccentricity = 0.2488    # Эксцентриситет

theta = np.linspace(0, 2*np.pi, 1000)  # Параметр, описывающий угол на эллиптической орбите

# Уравнение эллипса в полярных координатах
r = semi_major_axis * (1 - eccentricity**2) / (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="Orbit of Pluto")
plt.scatter(0, 0, color='yellow', s=200, label="Sun")  # Солнце в центре
plt.title("Orbit of Pluto (Simplified Model)")
plt.xlabel("X (au)")
plt.ylabel("Y (au)")
plt.legend()
plt.grid(True)
plt.axis('equal')  # Чтобы сделать масштабы осей X и Y одинаковыми
plt.show()

Этот код моделирует орбиту Плутона в виде эллипса с использованием параметрических уравнений эллипса. В реальности движение Плутона сложнее из-за взаимодействия с другими телами и не только из-за гравитации Солнца.

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

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

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

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

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

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

- Эксцентриситет \( 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 🤖