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

import hashlib
import time

class Block:
    def __init__(self, index, previous_hash, timestamp, data, hash):
        self.index = index
        self.previous_hash = previous_hash
        self.timestamp = timestamp
        self.data = data
        self.hash = hash

def calculate_hash(index, previous_hash, timestamp, data):
    value = str(index) + str(previous_hash) + str(timestamp) + str(data)
    return hashlib.sha256(value.encode('utf-8')).hexdigest()

def create_genesis_block():
    return Block(0, "0", int(time.time()), "Genesis Block", calculate_hash(0, "0", int(time.time()), "Genesis Block"))

def create_new_block(previous_block, data):
    index = previous_block.index + 1
    timestamp = int(time.time())
    hash = calculate_hash(index, previous_block.hash, timestamp, data)
    return Block(index, previous_block.hash, timestamp, data, hash)

def tamper_and_update_blockchain(blockchain, start_index, new_data):
    """
    Функция для подмены данных начиная с определенного блока и пересчета хешей для всех последующих блоков.
    """
    if start_index < 1 or start_index >= len(blockchain):
        return False  # Невозможно изменить генезис блок или блок за пределами диапазона

    for i in range(start_index, len(blockchain)):
        if i == start_index:
            blockchain[i].data = new_data
        else:
            blockchain[i].data = f"Updated Block #{i} after tampering"
        blockchain[i].timestamp = int(time.time())
        previous_hash = blockchain[i-1].hash
        blockchain[i].hash = calculate_hash(blockchain[i].index, previous_hash, blockchain[i].timestamp, blockchain[i].data)

    return True

def validate_blockchain(blockchain):
    for i in range(1, len(blockchain)):
        current = blockchain[i]
        previous = blockchain[i-1]
        if current.hash != calculate_hash(current.index, previous.hash, current.timestamp, current.data):
            return False
    return True

# Создаем блокчейн и добавляем генезис блок
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

# Добавляем блоки в блокчейн
num_blocks_to_add = 10
for i in range(num_blocks_to_add):
    block_to_add = create_new_block(previous_block, f"Block #{i} has been added to the blockchain!")
    blockchain.append(block_to_add)
    previous_block = block_to_add
    print(f"Block #{block_to_add.index} has been added to the blockchain!")
    print(f"Hash: {block_to_add.hash}\n")

# Подменяем данные начиная с 5-го блока и обновляем все последующие блоки
tamper_and_update_blockchain(blockchain, 5, "Tampered Data")
print("Blockchain after tampering and updating:")
for block in blockchain:
    print(f"Block #{block.index}, Data: {block.data}, Hash: {block.hash}")

# Проверяем целостность блокчейна
is_valid = validate_blockchain(blockchain)
print("\nBlockchain is valid:", is_valid)

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

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

Создание сверточной нейронной сети (CNN) в Python обычно выполняется с использованием библиотеки Keras, которая является частью TensorFlow. Вот пример кода для создания простой CNN:

import tensorflow as tf
from tensorflow.keras import layers, models

# Определение модели
model = models.Sequential()
# Добавление сверточного слоя: 32 фильтра, ядро размером 3x3, функция активации ReLU
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
# Добавление слоя пулинга: пулинг 2x2
model.add(layers.MaxPooling2D((2, 2)))
# Добавление еще одного сверточного слоя
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
# Добавление слоя пулинга
model.add(layers.MaxPooling2D((2, 2)))
# Добавление сверточного слоя
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

# Добавление слоев для классификации
model.add(layers.Flatten()) # Разворачивание данных в вектор
model.add(layers.Dense(64, activation='relu')) # Полносвязный слой
model.add(layers.Dense(10)) # Выходной слой, предполагается 10 классов

# Компиляция модели
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# Вывод структуры модели
model.summary()

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

Важно отметить, что перед использованием этой сети для обучения или предсказаний, вам нужно будет подготовить и загрузить данные, а также провести обучение сети, используя метод model.fit(). Этот код также предполагает, что ваши входные данные имеют размер 28x28 пикселей и один канал (например, черно-белые изображения).

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

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

Шаг 1: Установка необходимых библиотек
Для начала убедитесь, что у вас установлены необходимые библиотеки: tensorflow, numpy, pandas, и matplotlib. Вы можете установить их с помощью pip:

pip install tensorflow numpy pandas matplotlib

Шаг 2: Загрузка и предобработка данных

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection import train_test_split

# Загрузка данных
data = pd.read_csv('fer2013.csv')
pixels = data['pixels'].tolist()
width, height = 48, 48
faces = []

for pixel_sequence in pixels:
    face = [int(pixel) for pixel in pixel_sequence.split(' ')]
    face = np.asarray(face).reshape(width, height)
    faces.append(face.astype('float32'))

faces = np.asarray(faces)
faces = np.expand_dims(faces, -1)

emotions = pd.get_dummies(data['emotion']).to_numpy()

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

# Нормализация данных
X_train /= 255
X_test /= 255

# Аугментация данных (опционально)
data_generator = ImageDataGenerator(featurewise_center=False,
                                    featurewise_std_normalization=False,
                                    rotation_range=10,
                                    width_shift_range=0.1,
                                    height_shift_range=0.1,
                                    zoom_range=.1,
                                    horizontal_flip=True)

Шаг 3: Создание модели нейронной сети

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization

model = Sequential()

model.add(Conv2D(64, kernel_size=(3, 3), activation='relu', input_shape=(width, height, 1)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(256, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dropout(0.5))

model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))

# Компиляция модели
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

model.summary()

Шаг 4: Обучение модели

batch_size = 64
epochs = 50

# Обучение модели
history = model.fit(data_generator.flow(X_train, y_train, batch_size),
                    steps_per_epoch=len(X_train) / batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_data=(X_test, y_test))

Шаг 5: Оценка модели

# Оценка модели на тестовых данных
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print('Test accuracy:', test_accuracy)

Заметки
- Убедитесь, что у вас есть файл fer2013.csv в вашей рабочей директории.

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

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

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

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

pip install tensorflow numpy pandas matplotlib

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

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Dropout, RepeatVector, TimeDistributed

# Генерация случайных данных
np.random.seed(0)
time_steps = 100
samples = 1000
data = np.random.normal(0, 0.5, (samples, time_steps))

# Нормализация данных
scaler = MinMaxScaler()
data_normalized = scaler.fit_transform(data)

### Шаг 3: Создание модели автоэнкодера

# Размерность входных данных
n_features = 1

# Построение модели автоэнкодера
model = Sequential([
    LSTM(128, activation='relu', input_shape=(time_steps, n_features), return_sequences=True),
    Dropout(0.2),
    LSTM(64, activation='relu', return_sequences=False),
    RepeatVector(time_steps),
    LSTM(64, activation='relu', return_sequences=True),
    Dropout(0.2),
    LSTM(128, activation='relu', return_sequences=True),
    TimeDistributed(Dense(n_features))
])

model.compile(optimizer='adam', loss='mse')
model.summary()

Шаг 4: Обучение модели

# Подготовка данных для обучения
data_expanded = np.expand_dims(data_normalized, axis=2)

# Обучение
model.fit(data_expanded, data_expanded, epochs=50, batch_size=32, validation_split=0.1, shuffle=True)

Шаг 5: Обнаружение аномалий

# Предсказания модели
reconstructions = model.predict(data_expanded)
reconstruction_errors = np.mean(np.abs(data_expanded - reconstructions), axis=1)
threshold = np.percentile(reconstruction_errors, 95)

# Определение аномалий
anomalies = reconstruction_errors > threshold

Шаг 6: Визуализация результатов

# Визуализация ошибок реконструкции
plt.hist(reconstruction_errors, bins=50)
plt.axvline(x=threshold, color='r', linestyle='--')
plt.title('Распределение ошибок реконструкции')
plt.xlabel('Ошибка реконструкции')
plt.ylabel('Количество')
plt.show()

# Визуализация аномалий
plt.plot(data[0])
plt.title('Пример временного ряда')
plt.xlabel('Время')
plt.ylabel('Значение')
plt.show()

print("Обнаружено аномалий:", np.sum(anomalies))

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

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

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

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

Пример кода

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

# Параметры симуляции
num_particles = 50
steps = 1000
xlim = (0, 100)
ylim = (0, 100)

# Инициализация позиций наночастиц
positions = np.random.rand(num_particles, 2) * np.array([xlim[1], ylim[1]])

# Функция для обновления позиции каждой частицы
def update(frame_num, positions, scatter):
    delta = np.random.randn(num_particles, 2)
    positions += delta
    positions = np.clip(positions, [xlim[0], ylim[0]], [xlim[1], ylim[1]])
    scatter.set_offsets(positions)
    return scatter,

# Создание фигуры для анимации
fig, ax = plt.subplots()
scatter = ax.scatter(positions[:, 0], positions[:, 1])
ax.set_xlim(xlim)
ax.set_ylim(ylim)
ax.set_title("Симуляция движения наночастиц")
anim = animation.FuncAnimation(fig, update, fargs=(positions, scatter), frames=steps, interval=50, blit=True)

# Отображение анимации
plt.show()

### Описание кода
1. Импорт библиотек: Используем numpy для работы с массивами и matplotlib для визуализации.

2. Инициализация параметров симуляции: Задаем количество частиц, количество шагов, и пределы области.

3. Инициализация позиций наночастиц: Располагаем наночастицы случайным образом внутри заданной области.

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

5. Создание и запуск анимации: Создаем анимацию с использованием FuncAnimation, где update - функция, вызываемая на каждом шаге анимации.

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

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

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

Пример кода

import matplotlib.pyplot as plt
import pandas as pd

# Данные о частицах
data = {
    "Particle": ["Up quark", "Down quark", "Electron", "Neutrino", "Photon", "W boson", "Z boson", "Higgs boson"],
    "Type": ["Quark", "Quark", "Lepton", "Lepton", "Boson", "Boson", "Boson", "Boson"],
    "Charge": ["+2/3", "-1/3", "-1", "0", "0", "+/-1", "0", "0"],
    "Mass": ["2.3 MeV/c²", "4.8 MeV/c²", "0.511 MeV/c²", "<1 eV/c²", "0", "80.4 GeV/c²", "91.2 GeV/c²", "125.1 GeV/c²"]
}

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

# Визуализация
fig, ax = plt.subplots(figsize=(10, 6))
ax.axis('tight')
ax.axis('off')
ax.table(cellText=df.values, colLabels=df.columns, cellLoc = 'center', loc='center')

plt.title("Standard Model of Particle Physics")
plt.show()

Описание кода
1. Импорт библиотек: Используем matplotlib для создания визуализации и pandas для удобной работы с данными.

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

3. Создание DataFrame: Преобразуем наши данные в pandas.DataFrame для удобства отображения.

4. Визуализация данных: Используем функцию table из Matplotlib для создания таблицы, которая отображает информацию о частицах.

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

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

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

Пример кода

import matplotlib.pyplot as plt
import pandas as pd

# Данные о некоторых элементах
elements = {
    "Атомный номер": [1, 2, 6, 7, 8, 26],
    "Символ": ["H", "He", "C", "N", "O", "Fe"],
    "Имя": ["Водород", "Гелий", "Углерод", "Азот", "Кислород", "Железо"],
    "Атомная масса": [1.008, 4.002602, 12.011, 14.007, 15.999, 55.845]
}

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

# Визуализация в виде таблицы
fig, ax = plt.subplots(figsize=(12, 4))
ax.axis('off')
table = ax.table(cellText=df.values, colLabels=df.columns, loc='center', cellLoc='center')
table.auto_set_font_size(False)
table.set_fontsize(12)
table.scale(1.2, 1.5)

plt.title("Фрагмент Таблицы Менделеева")
plt.show()

Описание кода
1. Импорт библиотек: Используем matplotlib для визуализации и pandas для удобного представления данных.

2. Подготовка данных: Создаем словарь с данными об элементах. Здесь приведены данные лишь о нескольких элементах, но вы можете расширить этот список.

3. Создание DataFrame: Преобразуем наш словарь данных в pandas.DataFrame.

4. Визуализация: Используем matplotlib для создания визуализации в виде таблицы. Настройки шрифта и размера таблицы подгоняются для удобства просмотра.

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

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

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

Пример кода

import random
import time

def print_welcome():
    print("Добро пожаловать в игру 'Волк ловит яйца'!")
    print("Волк может стоять в одной из четырех позиций (1, 2, 3, 4).")
    print("Ваша задача - вводить номер позиции, чтобы поймать яйцо.")
    print("Если вы пропустите яйцо, игра закончится.\n")

def get_egg_position():
    return random.randint(1, 4)

def main():
    print_welcome()
    score = 0
    wolf_position = 2
    try:
        while True:
            egg_position = get_egg_position()
            print(f"Яйцо падает в позицию {egg_position}. Введите позицию волка:")
            try:
                wolf_position = int(input("> "))
                if wolf_position == egg_position:
                    score += 1
                    print(f"Вы поймали яйцо! Ваш счет: {score}")
                else:
                    print(f"Вы пропустили яйцо. Игра окончена. Ваш финальный счет: {score}")
                    break
            except ValueError:
                print("Пожалуйста, введите число от 1 до 4.")
    except KeyboardInterrupt:
        print("\nИгра окончена.")

if __name__ == "__main__":
    main()

Описание игры
- Игра начинается с приветственного сообщения и объяснения правил.
- Яйцо "падает" в одну из четырех позиций, выбранную случайным образом.
- Игрок должен ввести номер позиции, куда хочет переместить волка, чтобы поймать яйцо.
- Если волк находится в той же позиции, что и падающее яйцо, игрок зарабатывает очко.
- Если игрок вводит неверную позицию или пропускает яйцо, игра заканчивается.
- Игра продолжается, пока игрок не допустит ошибку.
- Игрок может прервать игру в любой момент, нажав Ctrl+C.

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

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

Для тех кто не успел, еще одна супер скидка на наш курс на stepik!

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

Однако, я могу показать вам, как создать простой TCP-сервер и клиент на Python, который можно использовать как отправную точку для изучения основ создания сетевых приложений. Для создания полноценного VPN-сервера вам потребуется использовать дополнительные инструменты и протоколы, такие как OpenVPN или WireGuard, и гораздо более сложная настройка.

Пример простого TCP-сервера и клиента на Python

TCP-сервер:

import socket

def start_server(port=12345):
    # Создаем сокет
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('0.0.0.0', port))
    server_socket.listen()

    print(f"Сервер запущен и слушает порт {port}...")

    # Принимаем соединение
    client_socket, client_address = server_socket.accept()
    print(f"Подключение от {client_address}")

    # Получаем и отправляем данные
    while True:
        message = client_socket.recv(1024).decode()
        if not message:
            break
        print(f"Получено от клиента: {message}")
        client_socket.send(f"Эхо: {message}".encode())

    client_socket.close()
    server_socket.close()

if __name__ == '__main__':
    start_server()

TCP-клиент:

import socket

def start_client(server_ip='127.0.0.1', port=12345):
    # Подключаемся к серверу
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect((server_ip, port))

    print(f"Подключено к серверу {server_ip} на порту {port}")

    # Отправка и получение данных
    try:
        while True:
            message = input("Введите сообщение: ")
            client_socket.send(message.encode())
            response = client_socket.recv(1024).decode()
            print(f"Ответ сервера: {response}")
    except KeyboardInterrupt:
        print("\nОтключение от сервера...")

    client_socket.close()

if __name__ == '__main__':
    start_client()

Описание
- TCP-сервер: Слушает входящие соединения и отправляет обратно эхо полученных сообщений.
- TCP-клиент: Подключается к серверу, отправляет сообщения и получает их эхо.

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

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