Давайте создадим программу, которая моделирует логистику доставки подарков гномами на Рождество и Новый Год. В этой программе мы:

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

import random
from collections import defaultdict

class Gift:
    """Class representing a gift with a recipient and type."""
    def __init__(self, recipient, gift_type):
        self.recipient = recipient
        self.gift_type = gift_type

    def __str__(self):
        return f"Gift for {self.recipient} of type {self.gift_type}"

class Elf:
    """Class representing an elf responsible for delivering gifts."""
    def __init__(self, name):
        self.name = name
        self.gifts_to_deliver = []

    def assign_gift(self, gift):
        self.gifts_to_deliver.append(gift)

    def deliver_gifts(self):
        for gift in self.gifts_to_deliver:
            print(f"{self.name} delivered {gift}.")

class SantaWorkshop:
    """Class representing Santa's workshop handling gift logistics."""
    def __init__(self, elves_names):
        self.elves = [Elf(name) for name in elves_names]

    def distribute_gifts(self, gifts):
        # Distribute gifts to elves in a round-robin fashion
        elf_index = 0
        for gift in gifts:
            self.elves[elf_index].assign_gift(gift)
            elf_index = (elf_index + 1) % len(self.elves)

    def start_delivery(self):
        for elf in self.elves:
            elf.deliver_gifts()

# Example usage
gifts = [Gift(f"Child {i}", random.choice(["Toy", "Book", "Game"])) for i in range(10)]
elves_names = ["Dasher", "Dancer", "Prancer", "Vixen"]
workshop = SantaWorkshop(elves_names)

# Distribute and deliver gifts
workshop.distribute_gifts(gifts)
workshop.start_delivery()

1. Класс `Gift` (Подарок):
- Представляет подарок с указанием получателя и типа подарка.

2. Класс `Elf` (Гном):
- Отвечает за сбор и доставку подарков. Каждый гном имеет список подарков, которые он должен доставить.

3. Класс `SantaWorkshop` (Мастерская Санты):
- Управляет гномами и распределяет подарки между ними. Подарки распределяются в раунд-робин (циклическом) порядке между гномами.

Пример использования:
- Создаются подарки для детей различных типов (игрушки, книги, игры).
- Задаются имена гномов.
- Мастерская Санты распределяет подарки между гномами.
- Гномы доставляют подарки.

Вывод программы демонстрирует, как каждый гном доставляет свои подарки.

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

На этот раз мы разработаем систему для организации и управления новогодними мероприятиями. Программа будет включать:

1. Класс Event, который представляет событие с деталями, такими как название, время и место проведения.
2. Класс EventManager, который управляет списком событий, позволяет добавлять новые мероприятия и выводит расписание.
3. Функционал для фильтрации событий по различным критериям, например, по дате или типу мероприятия.

from datetime import datetime

class Event:
    """Class representing a New Year event with details."""
    def __init__(self, name, date, location):
        self.name = name
        self.date = date
        self.location = location

    def __str__(self):
        return f"{self.name} on {self.date.strftime('%Y-%m-%d %H:%M')} at {self.location}"

class EventManager:
    """Class managing a list of events."""
    def __init__(self):
        self.events = []

    def add_event(self, event):
        self.events.append(event)

    def display_events(self):
        for event in self.events:
            print(event)

    def get_events_by_date(self, date):
        return [event for event in self.events if event.date.date() == date]

# Example usage
event_manager = EventManager()
event_manager.add_event(Event("New Year's Eve Party", datetime(2023, 12, 31, 22, 0), "Town Hall"))
event_manager.add_event(Event("New Year's Concert", datetime(2023, 12, 31, 19, 0), "Central Park"))
event_manager.add_event(Event("Fireworks Show", datetime(2024, 1, 1, 0, 15), "River Side"))

# Display all events
print("Scheduled New Year Events:")
event_manager.display_events()

# Get events on a specific date
date_to_filter = datetime(2023, 12, 31).date()
print(f"\nEvents on {date_to_filter}:")
for event in event_manager.get_events_by_date(date_to_filter):
    print(event)

1. Класс `Event`:
- Представляет новогоднее событие с деталями, такими как название, время и место проведения.

2. Класс `EventManager`:
- Управляет списком событий, позволяет добавлять новые мероприятия и выводит расписание.
- Предоставляет функционал для получения событий по конкретной дате.

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

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

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

Давайте создадим еще одну программу на Python, связанную с Новым Годом, но на этот раз сосредоточимся на другом аспекте праздника. Мы напишем программу для создания и управления новогодними резолюциями (новогодними обещаниями или планами). Программа будет включать:

1. Класс Resolution, который представляет новогоднюю резолюцию с деталями, такими как описание и статус выполнения.
2. Класс ResolutionManager, который управляет списком резолюций, позволяет добавлять новые резолюции и отслеживать их выполнение.
3. Функционал для отображения всех резолюций и их текущего статуса.

class Resolution:
    """Class representing a New Year's resolution."""
    def __init__(self, description):
        self.description = description
        self.completed = False

    def complete(self):
        self.completed = True

    def __str__(self):
        status = "Completed" if self.completed else "Not Completed"
        return f"Resolution: {self.description} - {status}"

class ResolutionManager:
    """Class managing a list of resolutions."""
    def __init__(self):
        self.resolutions = []

    def add_resolution(self, resolution):
        self.resolutions.append(resolution)

    def complete_resolution(self, index):
        if 0 <= index < len(self.resolutions):
            self.resolutions[index].complete()

    def display_resolutions(self):
        for resolution in self.resolutions:
            print(resolution)

# Example usage
resolution_manager = ResolutionManager()
resolution_manager.add_resolution(Resolution("Exercise more regularly"))
resolution_manager.add_resolution(Resolution("Read at least one book per month"))
resolution_manager.add_resolution(Resolution("Learn a new language"))

# Mark the first resolution as complete
resolution_manager.complete_resolution(0)

# Display all resolutions
print("New Year's Resolutions:")
resolution_manager.display_resolutions()

1. Класс `Resolution`:
- Представляет новогоднюю резолюцию с описанием и статусом выполнения. Можно пометить резолюцию как выполненную с помощью метода complete.

2. Класс `ResolutionManager`:
- Управляет списком резолюций, позволяет добавлять новые резолюции и отслеживать их выполнение.
- Предоставляет функционал для отображения всех резолюций и их текущего статуса.

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

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

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

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

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

Вот пример работы кода:

# Словарь для азбуки Морзе
MORSE_CODE_DICT = {
    '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': '--..', '1': '.----', '2': '..---', '3': '...--', 
    '4': '....-', '5': '.....', '6': '-....', '7': '--...', '8': '---..', 
    '9': '----.', '0': '-----', ', ': '--..--', '.': '.-.-.-', '?': '..--..', 
    '/': '-..-.', '-': '-....-', '(': '-.--.', ')': '-.--.-'
}

# Функция для перевода текста в азбуку Морзе
def text_to_morse(text):
    morse_code = ''
    for char in text.upper():
        if char in MORSE_CODE_DICT:
            morse_code += MORSE_CODE_DICT[char] + ' '
        elif char == ' ':
            morse_code += ' '
    return morse_code.strip()

# Функция для перевода азбуки Морзе в текст
def morse_to_text(morse_code):
    text = ''
    morse_code += ' '
    morse_char = ''
    for char in morse_code:
        if char != ' ':
            morse_char += char
            space_found = 0
        else:
            space_found += 1
            if space_found == 2 :
                text += ' '
            else:
                text += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(morse_char)]
                morse_char = ''
    return text

# Тестирование функций
sample_text = "Hello World"
sample_morse = text_to_morse(sample_text)
reverted_text = morse_to_text(sample_morse)

sample_text, sample_morse, reverted_text

Пример работы кода:

('Hello World', '.... . .-.. .-.. ---  .-- --- .-. .-.. -..', 'HELLO WORLD')

- Исходный текст: "Hello World"
- Текст, переведённый в код Морзе: ".... . .-.. .-.. --- .-- --- .-. .-.. -.."
- Текст, восстановленный из кода Морзе: "HELLO WORLD"

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

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

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

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

Напишем этот код:

# Словарь для двоичного кода
BINARY_CODE_DICT = {
    'A': '01', 'B': '0001', 'C': '0010', 'D': '0011', 'E': '10', 
    'F': '0100', 'G': '0101', 'H': '0110', 'I': '0111', 'J': '1000', 
    'K': '1001', 'L': '1010', 'M': '1011', 'N': '1100', 'O': '1101', 
    'P': '1110', 'Q': '1111', 'R': '0000', 'S': '00000', 'T': '00001', 
    'U': '00010', 'V': '00011', 'W': '00100', 'X': '00101', 'Y': '00110', 
    'Z': '00111'
}

# Функция для перевода текста в двоичный код
def text_to_binary_code(text):
    binary_code = ''
    for char in text.upper():
        if char in BINARY_CODE_DICT:
            binary_code += BINARY_CODE_DICT[char] + ' '
        elif char == ' ':
            binary_code += '  '
    return binary_code.strip()

# Функция для перевода двоичного кода в текст
def binary_code_to_text(binary_code):
    text = ''
    binary_code += '  '  # Дополнительный пробел для обозначения конца строки
    binary_char = ''
    for char in binary_code:
        if char != ' ':
            binary_char += char
        else:
            if binary_char:
                if binary_char in BINARY_CODE_DICT.values():
                    text += list(BINARY_CODE_DICT.keys())[list(BINARY_CODE_DICT.values()).index(binary_char)]
                binary_char = ''
            else:
                text += ' '
    return text.strip()

# Тестирование функций
sample_text_binary = "Hello"
sample_binary = text_to_binary_code(sample_text_binary)
reverted_text_binary = binary_code_to_text(sample_binary)

sample_text_binary, sample_binary, reverted_text_binary

Пример работы кода для двоичной системы:

('Hello', '0110 10 1010 1010 1101', 'HELLO')

- Исходный текст: "Hello"
- Текст, переведённый в двоичный код: "0110 10 1010 1010 1101"
- Текст, восстановленный из двоичного кода: "HELLO"

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

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

Импульсные нейросети (SNNs, Spiking Neural Networks) — это класс нейросетей, который моделирует более реалистичное поведение нейронов, чем традиционные искусственные нейронные сети. В импульсных нейросетях нейроны обмениваются информацией не постоянными значениями активации, а короткими импульсами (спайками), что приближает их к работе биологических нейронных сетей.

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

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

from brian2 import *

# Параметры модели нейрона
tau = 10*ms
eqs = '''
dv/dt = (1-v)/tau : 1 (unless refractory)
'''

# Создание нейрона
G = NeuronGroup(1, eqs, threshold='v>0.8', reset='v = 0', refractory=5*ms, method='exact')

# Инициализация переменной состояния
G.v = 0

# Мониторинг переменных
state_monitor = StateMonitor(G, 'v', record=True)
spike_monitor = SpikeMonitor(G)

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

# Визуализация данных
figure(figsize=(12, 4))
subplot(121)
plot(state_monitor.t/ms, state_monitor.v[0])
xlabel('Time (ms)')
ylabel('v')
subplot(122)
plot(spike_monitor.t/ms, spike_monitor.i, 'ob')
xlabel('Time (ms)')
ylabel('Spikes')

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

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

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

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

Мы будем использовать библиотеку 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 🤖