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

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()

    visited.add(start)

    print(start)

    for next_node in graph[start] - visited:
        dfs(graph, next_node, visited)

    return visited


if __name__ == "__main__":
    graph = {'A': set(['B', 'C']),
             'B': set(['A', 'E']),
             'C': set(['A', 'F']),
             'E': set(['B', 'F']),
             'F': set(['C', 'E'])}

    dfs(graph, 'A')

В этом коде:

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

Запуск этого кода отобразит последовательность вершин, посещенных при обходе в глубину, начиная с вершины 'A'.

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

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

python
import matplotlib.pyplot as plt

def draw_graph():
    x = [1, 2, 3, 4, 5]
    y = [1, 4, 9, 16, 25]

    plt.plot(x, y)
    plt.title('Square Numbers')
    plt.xlabel('Values')
    plt.ylabel('Squares')

    plt.show()

if __name__ == "__main__":
    draw_graph()

В этом коде:

- Мы используем функцию plt.plot для построения графика данных.
- Мы задаем заголовок графика и подписи осей с помощью функций plt.title, plt.xlabel и plt.ylabel.
- В конце мы используем функцию plt.show для отображения графика.

Перед запуском этого скрипта убедитесь, что у вас установлена библиотека matplotlib. Вы можете установить ее, используя pip:

pip install matplotlib

Пример кода на Python, демонстрирующего рекурсию, может быть вычисление факториала числа. Факториал числа n определен как произведение всех положительных целых чисел от 1 до n.

python
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))  # Выведет: 120

В этом коде функция factorial вызывает сама себя внутри определения функции. Это и есть рекурсия.

Сначала проверяется базовый случай: если n равно 0, функция просто возвращает 1, потому что факториал 0 равен 1 по определению.

Если n не равно 0, функция возвращает n * factorial(n-1). Это означает, что для вычисления факториала числа n мы умножаем n на факториал от n-1. И так продолжается до тех пор, пока мы не дойдем до 0.

Например, вызов factorial(5) приведет к следующей последовательности вызовов функций:

factorial(5)
5 * factorial(4)
5 * (4 * factorial(3))
5 * (4 * (3 * factorial(2)))
5 * (4 * (3 * (2 * factorial(1))))
5 * (4 * (3 * (2 * (1 * factorial(0)))))
5 * (4 * (3 * (2 * (1 * 1))))
5 * (4 * (3 * (2 * 1)))
5 * (4 * (3 * 2))
5 * (4 * 6)
5 * 24
120

Именно так работает рекурсия!

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

Вот небольшой cheat-sheet на Python для новичков:

1. Основы синтаксиса:
- Вывод на экран: print("Текст")
- Присваивание переменной: имя_переменной = значение
- Комментарии: # Это комментарий

2. Типы данных:
- Числа: целые числа (int), числа с плавающей точкой (float)
- Строки: строковые литералы (str)
- Списки: список значений (list)
- Кортежи: неизменяемые списки (tuple)
- Словари: связь ключей и значений (dictionary)

3. Операторы:
- Математические: +, -, *, /, %, ** (сложение, вычитание, умножение, деление, остаток от деления, возведение в степень)
- Сравнения: ==, !=, >, <, >=, <= (равно, не равно, больше, меньше, больше или равно, меньше или равно)
- Логические: and, or, not (и, или, не)

4. Условные конструкции:
- if, elif, else
- Пример:

     if условие:
         блок кода
     elif другое_условие:
         блок кода
     else:
         блок кода
     

5. Циклы:
- for (для перебора элементов в коллекции)
- while (для выполнения блока кода до тех пор, пока выполняется условие)

6. Функции:
- Определение функции: def имя_функции(аргументы):
- Возвращение значения: return значение

7. Ввод и вывод данных:
- Ввод с клавиатуры: input("Сообщение приглашения")
- Пример:

     name = input("Введите ваше имя: ")
     print("Привет, " + name)
     

8. Работа со строками:
- Сцепление строк: +
- Форматирование строк: f"Текст {переменная}"
- Пример:

     name = "Анна"
     age = 25
     print(f"Меня зовут {name} и мне {age} лет.")
     

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

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

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

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

Начнем с класса Station:

python
class Station:
    def __init__(self, name):
        self.name = name

Теперь создадим класс для ветки:

python
class Line:
    def __init__(self, name, color, number):
        self.name = name
        self.color = color
        self.number = number
        self.stations = []

    def add_station(self, station):
        if not isinstance(station, Station):
            raise ValueError("Argument should be an instance of the 'Station' class.")
        self.stations.append(station)

Теперь, создадим класс для поезда:

python
class Train:
    def __init__(self, line, current_station):
        if not isinstance(line, Line) or not isinstance(current_station, Station):
            raise ValueError("Arguments should be instances of the 'Line' and 'Station' classes.")
        self.line = line
        self.current_station = current_station

    def move_to(self, station):
        if station in self.line.stations:
            self.current_station = station
        else:
            raise ValueError("The train cannot move to a station not on its line.")

Теперь можно создать ветки метро, добавить станции и создать поезда.

Например:

python
# Создание веток
red_line = Line("Red Line", "red", 1)
blue_line = Line("Blue Line", "blue", 2)

# Добавление станций на ветки
red_line.add_station(Station("Station A"))
red_line.add_station(Station("Station B"))
blue_line.add_station(Station("Station C"))
blue_line.add_station(Station("Station D"))

# Создание поездов
train1 = Train(red_line, red_line.stations[0]) # на станции "Station A" красной ветки
train2 = Train(blue_line, blue_line.stations[1]) # на станции "Station D" синей ветки

# Перемещение поезда
train1.move_to(red_line.stations[1]) # перемещение поезда на станцию "Station B"

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

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

Попробуем добавить несколько настоящих веток и станций Московского метро:

python
# Создание веток
sokolnicheskaya_line = Line("Сокольническая линия", "red", 1)
zamoskvoretskaya_line = Line("Замоскворецкая линия", "green", 2)

# Добавление станций на ветки
sokolnicheskaya_line.add_station(Station("Бульвар Рокоссовского"))
sokolnicheskaya_line.add_station(Station("Черкизовская"))
sokolnicheskaya_line.add_station(Station("Преображенская площадь"))

zamoskvoretskaya_line.add_station(Station("Речной вокзал"))
zamoskvoretskaya_line.add_station(Station("Водный стадион"))
zamoskvoretskaya_line.add_station(Station("Войковская"))

# Создание поездов
train1 = Train(sokolnicheskaya_line, sokolnicheskaya_line.stations[0]) # на станции "Бульвар Рокоссовского" Сокольнической линии
train2 = Train(zamoskvoretskaya_line, zamoskvoretskaya_line.stations[1]) # на станции "Водный стадион" Замоскворецкой линии

# Перемещение поезда
train1.move_to(sokolnicheskaya_line.stations[1]) # перемещение поезда на станцию "Черкизовская"

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

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

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

python
class Train:
    def __init__(self, line, current_station, direction):
        if not isinstance(line, Line) or not isinstance(current_station, Station):
            raise ValueError("Arguments should be instances of the 'Line' and 'Station' classes.")
        self.line = line
        self.current_station = current_station
        self.direction = direction

    def move_to(self, station):
        if station in self.line.stations:
            # Проверка на соседнюю станцию
            current_station_index = self.line.stations.index(self.current_station)
            destination_station_index = self.line.stations.index(station)
            if abs(destination_station_index - current_station_index) != 1:
                raise ValueError("The train can only move to the next station.")
            # Проверка направления движения
            if (destination_station_index - current_station_index) * self.direction < 0:
                raise ValueError("The train cannot move in the opposite direction.")
            self.current_station = station
        else:
            raise ValueError("The train cannot move to a station not on its line.")

В этом коде, direction - это число, которое равно 1, если поезд движется в прямом направлении (от начала списка станций к концу), и -1, если движение идет в обратном направлении (от конца списка к началу).

Создание и перемещение поезда может выглядеть следующим образом:

python
train1 = Train(sokolnicheskaya_line, sokolnicheskaya_line.stations[0], 1) # на станции "Бульвар Рокоссовского" Сокольнической линии, движение в прямом направлении
train1.move_to(sokolnicheskaya_line.stations[1]) # перемещение поезда на станцию "Черкизовская"

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

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

python
import string
import random

def generate_password(length):
    all_characters = string.ascii_letters + string.digits + string.punctuation
    if length < 4:
        print("Password length should be at least 4 characters.")
        return None
    password = []
    password.append(random.choice(string.ascii_uppercase))
    password.append(random.choice(string.ascii_lowercase))
    password.append(random.choice(string.digits))
    password.append(random.choice(string.punctuation))
    for i in range(length-4):
        password.append(random.choice(all_characters))
    random.shuffle(password)
    return ''.join(password)

print(generate_password(12))  # For example, generate a 12-character password

В этом скрипте мы используем модули string и random. Модуль string содержит различные полезные константы, такие как все буквы алфавита (в верхнем и нижнем регистрах), все цифры и все символы пунктуации.

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

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

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

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

Kivy - это открытая библиотека Python для быстрой разработки мультисенсорных приложений. Она поддерживает многокасание, управление жестами и даже возможность разработки собственных жестов.

Давайте создадим простое приложение с использованием Kivy. Это будет базовое приложение, в котором при нажатии на кнопку на экране, текст кнопки меняется.

Установка Kivy:

shell
pip install kivy

Пример кода:

python
from kivy.app import App
from kivy.uix.button import Button

class MyApp(App):
    def build(self):
        return Button(text='Hello Kivy',
                      size_hint=(.5, .5),
                      pos_hint={'center_x': .5, 'center_y': .5})

    def on_press_button(self, instance):
        print('You pressed the button!')
        instance.text = 'You pressed me!'

if __name__ == '__main__':
    MyApp().run()

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

Обратите внимание, что Kivy приложения требуют специальной структуры, и обычно состоят из класса, который наследует от App. Это основной класс вашего приложения и включает в себя различные методы, такие как build(), который используется для инициализации интерфейса приложения.

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

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

python
import numpy as np
import matplotlib.pyplot as plt

def mandelbrot(c, max_iter):
    z = c
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

def draw_mandelbrot(xmin,xmax,ymin,ymax,width,height,max_iter):
    r1 = np.linspace(xmin, xmax, width)
    r2 = np.linspace(ymin, ymax, height)
    return (r1,r2,np.array([[mandelbrot(complex(r, i),max_iter) for r in r1] for i in r2]))

def draw_image(xmin,xmax,ymin,ymax,width,height,max_iter):
    d = draw_mandelbrot(xmin,xmax,ymin,ymax,width,height,max_iter)
    plt.imshow(d[2], extent=(xmin, xmax, ymin, ymax))
    plt.show()

draw_image(-2.0,1.0,-1.5,1.5,1000,1000,256)

В этом коде функция mandelbrot(c, max_iter) выполняет итерацию формулы Мандельброта, начиная с заданного комплексного числа c. Если абсолютное значение z превысит 2, мы знаем, что последовательность стремится к бесконечности, и возвращаем количество выполненных итераций.

Функция draw_mandelbrot(xmin,xmax,ymin,ymax,width,height,max_iter) генерирует изображение, вычисляя mandelbrot(c, max_iter) для ряда точек c.

Функция draw_image(xmin,xmax,ymin,ymax,width,height,max_iter) использует matplotlib для отображения изображения фрактала Мандельброта.

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

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

python
import random
import time

# Ширина нашего "мирового пространства"
WIDTH = 70

# Создаем пустое мировое пространство
world = [' '] * WIDTH

while True:
    # Создаем новый "капельку"
    world[random.randint(0, WIDTH - 1)] = '*'

    # Печатаем текущее состояние мира
    print(''.join(world))

    # Двигаем каждую каплю вниз (если возможно)
    for i in range(WIDTH - 2, -1, -1):
        if world[i] == '*' and world[i + 1] == ' ':
            world[i], world[i + 1] = world[i + 1], world[i]

    # Задержка перед следующим обновлением мира
    time.sleep(0.1)

В этом коде мы сначала создаем мир как список из 70 пробелов. Затем в бесконечном цикле мы сначала создаем новую "каплю" воды в случайном месте в мире, затем печатаем текущее состояние мира, затем двигаем каждую каплю вниз на одну позицию (если там нет другой капли).

Мы делаем это снова и снова, создавая небольшую анимацию падающих капель.

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

Давайте создадим пример кода, который создает простую текстовую RPG (ролевую игру).

python
class Character:
    def __init__(self, name, health, strength):
        self.name = name
        self.health = health
        self.strength = strength

    def attack(self, other):
        other.health -= self.strength

    def is_alive(self):
        return self.health > 0


def game():
    player = Character("Player", 100, 20)
    monster = Character("Monster", 80, 15)

    while True:
        print(f"Your health: {player.health}, Monster's health: {monster.health}")
        action = input("What will you do? (Attack/Escape) ")

        if action.lower() == "attack":
            player.attack(monster)
            if monster.is_alive():
                monster.attack(player)
            else:
                print("You slayed the monster!")
                break

        elif action.lower() == "escape":
            print("You ran away!")
            break

        if not player.is_alive():
            print("You were slain by the monster!")
            break


game()

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

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

Вот интересный пример использования Python для шифрования текста с помощью простого шифра Цезаря. Шифр Цезаря является одним из самых простых и наиболее широко известных методов шифрования.

python
def caesar_encrypt(text, shift):
    result = ""

    for char in text:
        if char.isalpha():
            ascii_offset = ord('a') if char.islower() else ord('A')
            encrypted_char = chr((ord(char) - ascii_offset + shift) % 26 + ascii_offset)
            result += encrypted_char
        else:
            result += char

    return result

def caesar_decrypt(text, shift):
    return caesar_encrypt(text, -shift)

text = "Hello, World!"
shift = 3

encrypted = caesar_encrypt(text, shift)
print(f"Encrypted: {encrypted}")

decrypted = caesar_decrypt(encrypted, shift)
print(f"Decrypted: {decrypted}")

В этом примере, мы используем функцию caesar_encrypt для шифрования текста с помощью заданного сдвига. Функция caesar_decrypt используется для дешифрования текста, который был зашифрован шифром Цезаря, сдвигая символы в обратную сторону.

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

Давайте напишем код, который моделирует "жизнь клеток" на основе правил "Игры жизни" Джона Конвея. "Игра жизни" - это клеточный автомат, где каждая клетка на двумерной сетке может быть в одном из двух состояний: "живая" или "мёртвая". Состояние каждой клетки на следующем шаге определяется её текущим состоянием и состояниями восьми соседних клеток.

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

def update(frameNum, img, grid, N):
    newGrid = grid.copy()
    for i in range(N):
        for j in range(N):
            total = (grid[i, (j-1)%N] + grid[i, (j+1)%N] +
                     grid[(i-1)%N, j] + grid[(i+1)%N, j] +
                     grid[(i-1)%N, (j-1)%N] + grid[(i-1)%N, (j+1)%N] +
                     grid[(i+1)%N, (j-1)%N] + grid[(i+1)%N, (j+1)%N])
            if grid[i, j]  == 1 and (total < 2 or total > 3):
                newGrid[i, j] = 0
            elif grid[i, j] == 0 and total == 3:
                newGrid[i, j] = 1
    img.set_data(newGrid)
    grid[:] = newGrid[:]
    return img,

N = 100
grid = np.random.choice([0,1], N*N, p=[0.9, 0.1]).reshape(N, N)

fig, ax = plt.subplots()
img = ax.imshow(grid, interpolation='nearest')
ani = animation.FuncAnimation(fig, update, fargs=(img, grid, N, ))
plt.show()

В этом коде мы создаем случайную исходную сетку из "живых" и "мёртвых" клеток, затем применяем правила "Игры жизни" для определения следующего состояния сетки. Мы используем matplotlib.animation для создания анимации эволюции сетки.

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

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

python
import numpy as np

# Создадим матрицу (левую часть системы)
A = np.array([[3, 1, -2], 
              [1, -1, 4], 
              [2, 0, 3]])

# Создадим вектор-столбец (правую часть системы)
b = np.array([7, -1, 6])

# Используем функцию solve из NumPy для решения системы уравнений
x = np.linalg.solve(A, b)

print("Решение системы:")
print("x =", x[0])
print("y =", x[1])
print("z =", x[2])

Предположим, что у нас есть следующая система линейных уравнений:

3x + y - 2z = 7

x - y + 4z = -1

2x + 3z = 6

Этот код будет находить значения x, y и z, которые удовлетворяют всем трем уравнениям.

Библиотека NumPy - это мощный инструмент для работы с числами и матрицами в Python.

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

Здесь пример кода Python, который реализует простой веб-сервер с использованием библиотеки Flask:

python
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, world!"

@app.route('/json')
def json_message():
    return jsonify(message="Hello, JSON")

if __name__ == '__main__':
    app.run(debug=True)

В этом примере мы создаем экземпляр Flask и определяем два маршрута. Первый маршрут ("/") возвращает просто строку "Hello, world!". Второй маршрут ("/json") возвращает JSON-объект с полем message, которое содержит строку "Hello, JSON".

Запустив этот сервер, вы сможете обращаться к нему через ваш веб-браузер или любой другой HTTP-клиент по адресу "http://localhost:5000" (для приветствия) и "http://localhost:5000/json" (для получения JSON-объекта).

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

В этом примере мы создадим простую систему управления товарами на складе с использованием классов и объектов Python.

python
class Product:
    def __init__(self, name, quantity):
        self.name = name
        self.quantity = quantity

class Warehouse:
    def __init__(self):
        self.products = []

    def add_product(self, name, quantity):
        self.products.append(Product(name, quantity))

    def list_products(self):
        for product in self.products:
            print(f"Product: {product.name}, Quantity: {product.quantity}")

warehouse = Warehouse()
warehouse.add_product("Apples", 100)
warehouse.add_product("Oranges", 200)
warehouse.list_products()

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

Запуск этого кода создаст склад, добавит на него два продукта и выведет список всех продуктов на складе.

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

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

python
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report

# Загрузим набор данных
iris = load_iris()

# Разобьем данные на обучающую и тестовую выборку
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

# Создадим модель классификатора ближайших соседей
knn = KNeighborsClassifier(n_neighbors=3)

# Обучим модель
knn.fit(X_train, y_train)

# Применим модель на тестовой выборке
y_pred = knn.predict(X_test)

# Выведем отчет о классификации
print(classification_report(y_test, y_pred, target_names=iris.target_names))

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

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

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

python
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D

# Загружаем набор данных MNIST
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Нормализуем данные
x_train, x_test = x_train / 255.0, x_test / 255.0

# Изменяем форму данных, чтобы они были подходящими для использования в модели
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)

# Определяем модель
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

# Компилируем модель
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Обучаем модель
model.fit(x_train, y_train, epochs=5)

# Оцениваем модель
model.evaluate(x_test,  y_test, verbose=2)

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

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

Пример кода на Python, который находит все простые числа от 2 до 100 с помощью решета Эратосфена:

# Создаем список чисел от 2 до 100
numbers = list(range(2, 101))

# Проходимся по списку и удаляем все кратные числа
for i in numbers:
    numbers = [x for x in numbers if ((x == i) or (x % i != 0))]

# Печатаем список простых чисел
print(numbers)

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

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