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

### Шаг 1: Определение структуры базы данных

Для нашей базы данных потребуются минимум две таблицы:
- Persons: для хранения информации о каждом человеке.
- Relationships: для хранения информации об отношениях между людьми (например, родитель-ребенок).

### Шаг 2: Создание и инициализация базы данных

import sqlite3

def init_db():
    conn = sqlite3.connect('genealogy.db')
    c = conn.cursor()
    c.execute('''
        CREATE TABLE IF NOT EXISTS persons (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            birth_year INTEGER,
            death_year INTEGER
        )
    ''')
    c.execute('''
        CREATE TABLE IF NOT EXISTS relationships (
            person_id INTEGER,
            parent_id INTEGER,
            FOREIGN KEY (person_id) REFERENCES persons (id),
            FOREIGN KEY (parent_id) REFERENCES persons (id)
        )
    ''')
    conn.commit()
    conn.close()

init_db()

### Шаг 3: Добавление примеров данных

python
def add_sample_data():
    conn = sqlite3.connect('genealogy.db')
    c = conn.cursor()
    # Добавление людей
    persons = [
        ('John Doe', 1960, None),
        ('Jane Doe', 1965, None),
        ('Jimmy Doe', 1988, None),
        ('Jenny Doe', 1990, None)
    ]
    c.executemany('INSERT INTO persons (name, birth_year, death_year) VALUES (?, ?, ?)', persons)
    
    # Получение ID добавленных людей
    c.execute("SELECT id FROM persons WHERE name='John Doe'")
    john_id = c.fetchone()[0]
    c.execute("SELECT id FROM persons WHERE name='Jane Doe'")
    jane_id = c.fetchone()[0]
    c.execute("SELECT id FROM persons WHERE name='Jimmy Doe'")
    jimmy_id = c.fetchone()[0]
    c.execute("SELECT id FROM persons WHERE name='Jenny Doe'")
    jenny_id = c.fetchone()[0]
    
    # Добавление отношений
    relationships = [
        (jimmy_id, john_id),
        (jimmy_id, jane_id),
        (jenny_id, john_id),
        (jenny_id, jane_id)
    ]
    c.executemany('INSERT INTO relationships (person_id, parent_id) VALUES (?, ?)', relationships)
    
    conn.commit()
    conn.close()

add_sample_data()

### Шаг 4: Функции для работы с базой данных

python
def get_person_by_name(name):
    conn = sqlite3.connect('genealogy.db')
    c = conn.cursor()
    c.execute('SELECT * FROM persons WHERE name=?', (name,))
    person = c.fetchone()
    conn.close()
    return person

def get_parents_of_person(person_id):
    conn = sqlite3.connect('genealogy.db')
    c = conn.cursor()
    c.execute('SELECT parent_id FROM relationships WHERE person_id=?', (person_id,))
    parent_ids = c.fetchall()
    parents = []
    for parent_id in parent_ids:
        c.execute('SELECT * FROM persons WHERE id=?', (parent_id[0],))
        parents.append(c.fetchone())
    conn.close()
    return parents

# Пример использования
person = get_person_by_name('Jimmy Doe')
if person:
    print(f"Person: {person[1]}, Born: {person[2]}")
    parents = get_parents_of_person(person[0])
    for parent in parents:
        print(f"Parent: {parent[1]}, Born: {parent[2]}")

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

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

Давайте создадим простой пример кода на Python, который анализирует данные о погоде с использованием библиотеки pandas для обработки данных и matplotlib для визуализации результатов. В этом примере мы будем работать с набором данных о погоде, который содержит информацию о температуре, осадках и ветре за определенный период времени. Мы выполним базовый анализ данных и построим график средней температуры по месяцам.

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

Если у вас еще не установлены pandas и matplotlib, вы можете установить их с помощью pip:

bash
pip install pandas matplotlib

### Шаг 2: Создание и анализ данных

Предположим, у нас есть набор данных о погоде в формате CSV с колонками: Date, Temperature, Precipitation, и WindSpeed. В этом примере мы сгенерируем простой набор данных прямо в коде.

import pandas as pd
import matplotlib.pyplot as plt

# Генерация примера данных
data = {
    'Date': pd.date_range(start='2023-01-01', end='2023-12-31', freq='D'),
    'Temperature': pd.np.random.normal(20, 5, 365),  # Средняя температура 20, стандартное отклонение 5
    'Precipitation': pd.np.random.randint(0, 20, 365),  # Осадки в мм
    'WindSpeed': pd.np.random.randint(0, 15, 365)  # Скорость ветра в км/ч
}

# Создание DataFrame
df = pd.DataFrame(data)

# Установка Date как индекса DataFrame
df.set_index('Date', inplace=True)

# Анализ данных: Средняя температура по месяцам
monthly_temp = df['Temperature'].resample('M').mean()

# Визуализация
monthly_temp.plot(kind='bar', color='skyblue')
plt.title('Средняя месячная температура')
plt.xlabel('Месяц')
plt.ylabel('Температура, °C')
plt.xticks(rotation=45)
plt.show()

### Обратите внимание

В коде выше используется метод resample('M').mean() для группировки данных по месяцам и расчета средней температуры в каждом месяце. Затем мы используем matplotlib для построения столбчатой диаграммы, которая показывает среднюю температуру по месяцам.

### Важно

В коде использовалось pd.np.random, однако начиная с версий Pandas, где pd.np является устаревшим, рекомендуется использовать напрямую numpy для генерации случайных чисел:

import numpy as np

# Используйте np.random.normal и np.random.randint вместо pd.np

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

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

Давайте создадим простой пример скрипта на Python, который использует библиотеку requests для отправки HTTP-запросов и BeautifulSoup из bs4 для парсинга HTML-страниц. Этот скрипт будет получать заголовки новостей с веб-сайта новостей и выводить их. Это простой пример веб-скрейпинга.

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

Если у вас еще не установлены requests и beautifulsoup4, вы можете установить их с помощью pip:

bash
pip install requests beautifulsoup4

### Шаг 2: Написание скрипта для веб-скрейпинга

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

python
import requests
from bs4 import BeautifulSoup

# URL, который мы будем скрейпить
url = 'https://python.org/'

# Отправка HTTP-запроса GET к URL
response = requests.get(url)

# Проверка успешного ответа
if response.status_code == 200:
    # Создание объекта BeautifulSoup для парсинга HTML
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # Поиск всех элементов <a> внутри блока с id 'top'
    headlines = soup.find(id='top').find_all('a')
    
    # Вывод текста каждой найденной ссылки
    for headline in headlines:
        print(headline.text.strip())
else:
    print('Не удалось получить содержимое страницы')

### Обратите внимание

- Этот код использует requests для получения HTML-кода страницы https://python.org/.
- BeautifulSoup используется для парсинга полученного HTML и извлечения нужной информации. В этом случае мы ищем все ссылки (<a>) в блоке с ID top.
- В реальных задачах веб-скрейпинга важно учитывать политику использования сайта в отношении автоматизированного доступа к его содержимому. Всегда проверяйте файл robots.txt на сайте и уважайте его указания.

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

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

Давайте создадим пример Python скрипта, который использует библиотеку nltk (Natural Language Toolkit) для анализа текста и определения частоты слов. Этот скрипт будет полезен для выполнения базового анализа текстовых данных, например, для выявления наиболее часто встречающихся слов в тексте.

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

Если у вас еще не установлен nltk, вы можете установить его с помощью pip:

bash
pip install nltk

После установки вам, возможно, потребуется загрузить некоторые ресурсы NLTK, такие как токенизаторы и списки стоп-слов. Это можно сделать с помощью NLTK Downloader.

### Шаг 2: Написание скрипта для анализа текста

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from collections import Counter

# Загрузка необходимых ресурсов NLTK
nltk.download('punkt')
nltk.download('stopwords')

# Пример текста для анализа
text = """Natural language processing (NLP) is a field of computer science, artificial intelligence, 
and linguistics concerned with the interactions between computers and human (natural) languages. 
As such, NLP is related to the area of human-computer interaction. Many challenges in NLP involve 
natural language understanding, that is, enabling computers to derive meaning from human or natural language input."""

# Токенизация текста
tokens = word_tokenize(text)

# Приведение к нижнему регистру и удаление пунктуации и стоп-слов
words = [word.lower() for word in tokens if word.isalpha()]
filtered_words = [word for word in words if not word in stopwords.words('english')]

# Подсчет частоты слов
word_counts = Counter(filtered_words)

# Вывод 10 наиболее часто встречающихся слов
most_common_words = word_counts.most_common(10)
print("Наиболее часто встречающиеся слова:")
for word, count in most_common_words:
    print(f"{word}: {count}")

### Обратите внимание

- Скрипт использует nltk для токенизации текста, что является процессом разбиения текста на слова или фразы.
- Затем текст фильтруется для удаления стоп-слов (слов, которые встречаются слишком часто, чтобы быть полезными для анализа, например, "the", "is", "in") и пунктуации.
- После фильтрации используется Counter из модуля collections для подсчета частоты встречаемости каждого слова в тексте.
- В конце скрипт выводит 10 наиболее часто встречающихся слов в тексте.

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

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

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

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

Если у вас еще не установлены scikit-learn, pandas и numpy, вы можете установить их с помощью pip:

bash
pip install numpy pandas scikit-learn

### Шаг 2: Подготовка данных

В этом примере мы используем упрощенную версию набора данных о пассажирах Титаника. Предположим, что у нас есть DataFrame df, который содержит следующие колонки: Survived (целевая переменная, 1 если пассажир выжил, 0 если нет), Pclass (класс билета), Sex (пол), и Age (возраст).

### Шаг 3: Написание скрипта

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Загрузка данных (пример, предполагается, что df уже загружен)
data = {
    'Survived': [0, 1, 1, 1, 0, 0],
    'Pclass': [3, 1, 3, 1, 3, 3],
    'Sex': ['male', 'female', 'female', 'female', 'male', 'male'],
    'Age': [22, 38, 26, 35, 35, 30]
}
df = pd.DataFrame(data)

# Преобразование категориальных переменных в числовые
le = LabelEncoder()
df['Sex'] = le.fit_transform(df['Sex'])

# Разделение данных на признаки (X) и целевую переменную (y)
X = df.drop('Survived', axis=1)
y = df['Survived']

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

# Создание и обучение модели логистической регрессии
model = LogisticRegression()
model.fit(X_train, y_train)

# Предсказание на тестовых данных
predictions = model.predict(X_test)

# Оценка модели
accuracy = accuracy_score(y_test, predictions)
print(f'Точность модели: {accuracy:.2f}')

### Обратите внимание

- В этом примере мы используем очень упрощенные данные и не учитываем многие важные аспекты предобработки данных (например, заполнение пропущенных значений в Age).
- В реальных задачах машинного обучения важно тщательно подготовить данные, возможно, применить более сложные методы для обработки категориальных переменных (например, one-hot encoding вместо LabelEncoding) и выбрать подходящую модель после сравнения нескольких кандидатов.

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

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

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

Прежде чем начать, убедитесь, что у вас установлены необходимые библиотеки. Если нет, вы можете установить их с помощью pip:

pip install matplotlib numpy

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

1. Импортируем необходимые библиотеки.
2. Создадим функцию для генерации координат точек, формирующих спираль торнадо.
3. Визуализируем торнадо с помощью matplotlib.

import numpy as np
import matplotlib.pyplot as plt

def generate_tornado_points(num_points=1000):
    # Генерируем углы для спирали
    theta = np.linspace(0, 30 * np.pi, num_points)
    
    # Радиус изменяется от 1 до 10, потом уменьшается до 1, создавая форму торнадо
    radius = np.linspace(1, 10, num_points // 2)
    radius = np.concatenate([radius, radius[::-1]])
    
    # Рассчитываем координаты x и y
    x = radius * np.cos(theta)
    y = radius * np.sin(theta)
    
    # Возвращаем координаты
    return x, y

def plot_tornado():
    x, y = generate_tornado_points()
    
    plt.figure(figsize=(6, 12))
    plt.plot(x, y)
    plt.title('Симулятор торнадо')
    plt.axis('equal')
    plt.show()

# Запускаем симулятор
plot_tornado()

Этот код создаст базовую визуализацию торнадо в виде спирали. Вы можете изменить параметры, такие как количество точек (num_points) или масштаб радиуса, чтобы экспериментировать с разными формами и размерами торнадо.

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

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

import numpy as np
import matplotlib.pyplot as plt

# Определение параметров для спирали
height = np.linspace(0, 2*np.pi, 100)  # Высота от 0 до 2π
radius = np.linspace(0.1, 1, 100)  # Радиус изменяется от 0.1 до 1
theta = 8 * np.pi * height  # Угол вращения спирали
noise = np.random.uniform(-0.1, 0.1, size=height.shape)  # Случайные колебания

# Реалистичная спираль торнадо
x = (radius + noise) * np.cos(theta)
y = (radius + noise) * np.sin(theta)
z = height

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot(x, y, z)

ax.set_xlabel('X Axis')
ax.set_ylabel('Y Axis')
ax.set_zlabel('Z Axis')
plt.title('Реалистичная спираль торнадо')
plt.show()

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

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

Реалистичная спираль торнадо 🌪

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

import matplotlib.pyplot as plt
import numpy as np


def generate_lightning(steps=100, branching_chance=0.1):
    # Начальные координаты
    x = [0]
    y = [0]

    for i in range(steps):
        angle = np.random.uniform(0, 2 * np.pi)
        length = np.random.exponential(scale=1)  # Экспоненциальное распределение для длины шага

        x.append(x[-1] + np.cos(angle) * length)
        y.append(y[-1] + np.sin(angle) * length)

        # Ветвление
        if np.random.rand() < branching_chance:
            branch_length = int(np.random.rand() * steps * 0.2)  # Длина ветви
            branch_x, branch_y = generate_lightning(branch_length, branching_chance / 2)
            x += [x[-1] + bx for bx in branch_x]
            y += [y[-1] + by for by in branch_y]

    return x, y


# Генерация молнии
x, y = generate_lightning()

plt.figure(figsize=(6, 10))
plt.plot(x, y, color="blue")
plt.axis('equal')
plt.axis('off')
plt.title('Симуляция молнии')
plt.show()

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

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

Симуляции волн на воде

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

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

Давайте напишем код для создания такой симуляции.

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

# Параметры сетки
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.zeros_like(X)

# Параметры волн
frequency = 0.5
wavelength = 2
speed = 1.0
time = 0

# Функция для обновления волн
def update_wave(frame):
    global Z, time
    time += 0.1
    Z = np.sin(2 * np.pi * (np.sqrt(X**2 + Y**2) - speed * time) / wavelength) * np.exp(-0.1*np.sqrt(X**2 + Y**2))
    ax.clear()
    ax.set_zlim(-1, 1)
    ax.plot_surface(X, Y, Z, cmap='viridis')

fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ani = FuncAnimation(fig, update_wave, frames=100, interval=50)

plt.show()

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

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

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

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

import matplotlib.pyplot as plt
import numpy as np

def plot_fractal_tree(ax, start_point, angle, depth, max_depth, length_factor=0.8, angle_change=20):
    if depth == max_depth:
        return

    x, y = start_point
    end_point = x + np.cos(np.radians(angle)), y + np.sin(np.radians(angle))
    ax.plot([x, end_point[0]], [y, end_point[1]], lw=max_depth - depth + 1, color='green')

    # Рекурсивный вызов для ветвления
    plot_fractal_tree(ax, end_point, angle - angle_change, depth + 1, max_depth)
    plot_fractal_tree(ax, end_point, angle + angle_change, depth + 1, max_depth)


fig, ax = plt.subplots()
ax.set_aspect('equal')
ax.axis('off')

initial_point = (0, 0)
initial_angle = 90
initial_depth = 0
max_depth = 10

plot_fractal_tree(ax, initial_point, initial_angle, initial_depth, max_depth)

plt.show()

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

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

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

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

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

import matplotlib.pyplot as plt
import numpy as np

def generate_clouds(width, height, scale=0.1, octaves=3, persistence=0.5, lacunarity=2.0):
    from scipy.ndimage import gaussian_filter
    noise = np.random.rand(height, width)
    noise = gaussian_filter(noise, sigma=5)  # Применяем гауссово размытие для сглаживания

    # Нормализация и усиление контраста
    noise -= noise.min()
    noise /= noise.max()
    noise = np.power(noise, 3)  # Увеличиваем контраст, возводя в степень

    return noise


# Генерация и визуализация "облаков"
clouds = generate_clouds(200, 200)

plt.figure(figsize=(10, 10))
plt.imshow(clouds, cmap='gray', interpolation='lanczos')
plt.axis('off')
plt.title('Симуляция облаков')
plt.show()

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

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

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

Пожалуйста, имейте в виду, что этот код предназначен для запуска в терминале или командной строке и может потребовать небольших изменений для работы в вашей конкретной среде. Также стоит отметить, что curses работает в UNIX-подобных системах, включая Linux и MacOS, но для работы в Windows может потребоваться установка дополнительных библиотек (например, Windows Curses).

import random
import curses

# Инициализация экрана
stdscr = curses.initscr()
curses.curs_set(0)  # Скрыть курсор
height, width = stdscr.getmaxyx()  # Размер окна
stdscr.nodelay(1)  # Не блокировать ввод при stdscr.getch()
stdscr.timeout(100)  # Обновление экрана каждые 100 мс

# Символы, используемые для матрицы
chars = [chr(i) for i in range(32, 127)]  # ASCII символы от 32 до 126

# Создание начальных позиций для "падающих" символов
positions = [0] * width

try:
    while True:
        # Случайный выбор символов для каждой колонки
        output = [random.choice(chars) if x < height else ' ' for x in positions]
        
        # Вывод символов на экран
        for i in range(len(output)):
            char = output[i]
            # Задание разных цветов
            if positions[i] > 0 and positions[i] < height:
                stdscr.addstr(positions[i], i, char, curses.A_BOLD)
            else:
                stdscr.addstr(positions[i], i, ' ', curses.A_BOLD)
        
        # Обновление позиций
        positions = [x + 1 if x < height else 0 for x in positions]
        
        stdscr.refresh()
        
        # Ожидание следующего обновления экрана
        stdscr.getch()

finally:
    # Восстановление терминала в исходное состояние
    curses.endwin()

Этот скрипт инициализирует экран с помощью curses, создает эффект "падающих" символов, случайно выбирая символы ASCII для каждой колонки и перемещая их вниз. Эффект обновляется каждые 100 миллисекунд.

Помните, что для выхода из программы может потребоваться нажать Ctrl+C в терминале, так как стандартное управление вводом отключено через stdscr.nodelay(1) и stdscr.timeout(100).

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