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

Для этого нам понадобится библиотека turtle для рисования, которая является стандартной в Python и не требует установки дополнительных модулей.

import turtle
import math

# Установка параметров черепахи
turtle.speed('fastest')
turtle.left(90)
turtle.penup()
turtle.goto(0, -200)
turtle.pendown()

# Функция рисования дерева Пифагора
def draw_pythagoras_tree(length, min_length=10):
    if length < min_length:
        return

    turtle.forward(length)
    turtle.left(45)

    draw_pythagoras_tree(length / math.sqrt(2), min_length)

    turtle.right(90)
    turtle.forward(length / math.sqrt(2))

    draw_pythagoras_tree(length / math.sqrt(2), min_length)

    turtle.left(45)
    turtle.backward(length)

# Вызов функции с начальной длиной ветви
draw_pythagoras_tree(100)

# Завершаем рисование
turtle.done()

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

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

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

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

Перед запуском скрипта установите необходимую библиотеку numpy:

pip install numpy

Вот сам скрипт:

import numpy as np
from queue import PriorityQueue

# Инициализация лабиринта
def init_maze(size=10):
    maze = np.random.choice([0, 1], size=(size, size), p=[0.2, 0.8])
    start, end = (0, 0), (size - 1, size - 1)
    maze[start], maze[end] = 0, 0
    return maze, start, end

# Функция для печати лабиринта
def print_maze(maze, path=[]):
    for r, row in enumerate(maze):
        for c, val in enumerate(row):
            if (r, c) in path:
                print("·", end=" ")
            else:
                print("█" if val == 1 else " ", end=" ")
        print()

# Алгоритм A*
def a_star(maze, start, end):
    size = maze.shape[0]
    queue = PriorityQueue()
    queue.put((0, start))
    costs = {start: 0}
    prev = {start: None}
    visited = set()
    
    while not queue.empty():
        cost, current = queue.get()
        visited.add(current)
        
        if current == end:
            break
        
        for direction in [(0, 1), (1, 0), (0, -1), (-1, 0)]: # Вправо, вниз, влево, вверх
            row, col = current[0] + direction[0], current[1] + direction[1]
            next_cell = (row, col)
            if 0 <= row < size and 0 <= col < size and maze[row][col] == 0:
                new_cost = costs[current] + 1
                if next_cell not in costs or new_cost < costs[next_cell]:
                    costs[next_cell] = new_cost
                    priority = new_cost + abs(end[0] - row) + abs(end[1] - col)
                    queue.put((priority, next_cell))
                    prev[next_cell] = current
    
    # Восстанавливаем путь
    cell, path = end, []
    while prev[cell]:
        path.append(cell)
        cell = prev[cell]
    path.append(start)
    path.reverse()
    
    return path

# Генерация и решение лабиринта
maze, start, end = init_maze(10)
path = a_star(maze, start, end)
print_maze(maze, path)

Этот скрипт делает следующее:

1. Генерирует случайный лабиринт с препятствиями.
2. Ищет путь от верхнего левого угла (0, 0) до нижнего правого (size-1, size-1) с помощью алгоритма A*.
3. Выводит лабиринт и найденный путь на экран.

Запустите скрипт, и вы увидите в терминале отображение лабиринта и путь, найденный алгоритмом A*. Символ "·" будет указывать пройденный путь через лабиринт.

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

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

import turtle
import math
import colorsys

def draw_spiral(t, length, angle, increase, colors, width):
    for i in range(length):
        color = colors[i % len(colors)]
        t.pencolor(color)
        t.forward(i * increase)
        t.right(angle)
        t.width(width)

def get_color_gradient(length, saturation=1, lightness=0.5):
    return [colorsys.hls_to_rgb(h / length, lightness, saturation) for h in range(length)]

# Настройки для черепахи
window = turtle.Screen()
window.bgcolor("black")

spiral_turtle = turtle.Turtle()
spiral_turtle.speed(0)  # Максимальная скорость рисования

# Генерация градиента цветов
colors = get_color_gradient(360, 1, 0.5)

# Рисуем спираль
draw_spiral(spiral_turtle, 100, 120, 0.1, colors, 2)

# Завершаем рисование
window.mainloop()

Запустив этот скрипт, вы увидите, как черепаха рисует спиральный узор, постепенно изменяя цвета радуги. В функции draw_spiral, length задает количество шагов в спирали, angle определяет угол поворота, increase влияет на увеличение длины шага, colors содержит список цветов, а width устанавливает толщину линии.

Функция get_color_gradient генерирует равномерный список цветов в HLS формате (оттенок, светлость, насыщенность), который затем используется для установки цвета линии на каждом шаге рисования.

Вы можете изменять параметры для получения различных видов спиралей и узоров.

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

Что такое ООП?

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

Примеры:

- Классы - это как рецепты или инструкции для создания игрушек. Если у вас есть инструкция для машинки, вы можете сделать много разных машинок.
- Объекты - это сами игрушки, которые вы сделали по инструкции. Каждая машинка - это отдельный объект.
- Атрибуты - это детали ваших игрушек. У машинки могут быть цвет, размер, количество колес.
- Методы - это действия, которые могут выполнять ваши игрушки. Например, машинка может ехать.

Почему ООП важно?

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

Примеры ООП в Python

### Класс "Котик":

class Cat:
    def __init__(self, name):
        self.name = name

    def meow(self):
        return f"{self.name} говорит мяу!"

- Cat — это класс.
- name — это атрибут, который говорит нам имя котика.
- meow — это метод, который заставляет котика мяукать.

### Создание объекта "Котик":

my_cat = Cat("Барсик")
print(my_cat.meow())  # Барсик говорит мяу!

my_cat — это объект, который мы создали по классу Cat.

А что если без ООП?

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

Вариант без ООП:

def create_cat(name):
    return {"name": name}
def cat_meow(cat):
    return f"{cat['name']} говорит мяу!"

my_cat = create_cat("Барсик")
print(cat_meow(my_cat))

my_cat2 = create_cat("Маруся")
print(cat_meow(my_cat))

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

ООП на примере кулинарии 🍰

Сегодня мы познакомимся с увлекательным миром программирования на Python через призму кулинарии, а именно через Объектно-Ориентированное Программирование (ООП). Давайте узнаем, как это может упростить нашу жизнь в кухне.

Что такое ООП?

Представьте, что у вас есть книга с рецептами. Каждый рецепт - это инструкция для приготовления определенного блюда. В программировании, эти рецепты и блюда - это "классы" и "объекты".

### Примеры:

- Классы - это как рецепты. Например, у вас есть рецепт пирога.
- Объекты - это конкретные блюда, приготовленные по рецептам. Из рецепта пирога можно приготовить множество разных пирогов.
- Атрибуты - это ингредиенты и характеристики блюда, например, тип начинки или размер пирога.
- Методы - это действия, которые мы выполняем с блюдами, например, выпекать пирог.

Почему ООП важно?

Использование ООП в программировании - это как иметь набор проверенных рецептов, которые можно легко адаптировать и использовать снова и снова. Это делает процесс готовки (или написания кода) более организованным и эффективным.

Примеры ООП в Python

### Класс "Пирог":

class Pie:
    def __init__(self, filling, size):
        self.filling = filling
        self.size = size

    def bake(self):
        return f"Выпекаем {self.size} пирог с {self.filling} начинкой."

- Pie — это класс (рецепт).
- filling и size — это атрибуты (начинка и размер).
- bake — это метод (действие выпекания).

### Создание объектов "Пирог":

apple_pie = Pie("яблочной", "большой")
cherry_pie = Pie("вишневой", "средний")

print(apple_pie.bake())  # Выпекаем большой пирог с яблочной начинкой.
print(cherry_pie.bake())  # Выпекаем средний пирог с вишневой начинкой.

А что если без ООП?

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

### Без ООП:

def create_pie(filling, size):
    return {"filling": filling, "size": size}

def bake_pie(pie):
    return f"Выпекаем {pie['size']} пирог с {pie['filling']} начинкой."

apple_pie = create_pie("яблочной", "большой")
cherry_pie = create_pie("вишневой", "средний")

print(bake_pie(apple_pie))
print(bake_pie(cherry_pie))

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

Заключение

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

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

Давайте рассмотрим пример неоптимального кода на Python и его оптимальный вариант.

Неоптимальный код:

numbers = [1, 2, 3, 4, 5]
squares = []
for number in numbers:
    squares.append(number * number)
print(squares)

Оптимальный код:

numbers = [1, 2, 3, 4, 5]
squares = [number * number for number in numbers]
print(squares)

В чем разница?

1. Читаемость кода: Оптимальный код использует list comprehension, что делает код более читаемым и компактным. Вместо нескольких строк с циклом for и методом append, в оптимальном коде всё это сделано в одной строке.

2. Производительность: List comprehension в Python обычно работает быстрее, чем соответствующий цикл for с append из-за внутренней оптимизации Python. Это особенно заметно при работе с большими списками.

3. Современные стандарты: Использование list comprehension является более "питоническим" способом работы со списками и рекомендуется как более элегантный и эффективный стиль программирования на Python.

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

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

Наш первый платный курс по Python на stepik на основе топ 50 примеров кода с задачами и ДЗ.

И скидка в 2000 руб 👀 только для читателей канала по линку https://stepik.org/a/185238/pay?promo=dcfeb683c217284e до 07.12.2023 включительно!

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

Давайте рассмотрим ещё один пример неоптимального кода на Python и его оптимальную версию.

Неоптимальный код:

def find_even_numbers(numbers):
    even_numbers = []
    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)
    return even_numbers

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(find_even_numbers(numbers))

Оптимальный код:

def find_even_numbers(numbers):
    return [number for number in numbers if number % 2 == 0]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(find_even_numbers(numbers))

В чем разница?

1. Читаемость: Оптимальный код снова использует list comprehension, что делает функцию более лаконичной и легко читаемой. Мы уменьшили количество строк и упростили структуру кода.

2. Производительность: Как и в предыдущем примере, list comprehension обычно работает быстрее, чем эквивалентный цикл for с условием и append. Особенно это становится заметным при обработке больших коллекций данных.

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

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

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

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

Неоптимальный код: Обработка строк

def format_date(year, month, day):
    formatted_year = str(year)
    if month < 10:
        formatted_month = '0' + str(month)
    else:
        formatted_month = str(month)
    
    if day < 10:
        formatted_day = '0' + str(day)
    else:
        formatted_day = str(day)
    
    return formatted_year + '-' + formatted_month + '-' + formatted_day

print(format_date(2023, 3, 7))

Оптимальный код: Обработка строк

def format_date(year, month, day):
    return f"{year:04d}-{month:02d}-{day:02d}"

print(format_date(2023, 3, 7))

В чем разница?

1. Читаемость и простота: В оптимальном коде используется форматирование строк с помощью f-строк (formatted string literals), что делает код более лаконичным и читаемым. Он избавляет от необходимости вручную проверять и форматировать каждую часть даты.

2. Сокращение кода: Оптимальный вариант уменьшает количество строк кода, делая его более компактным и легким для понимания. Всё, что касается форматирования даты, выполняется в одной строке.

3. Предотвращение ошибок: В неоптимальном коде легче допустить ошибку при ручном форматировании. Оптимальный подход с f-строками уменьшает вероятность таких ошибок.

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

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

Давайте рассмотрим ещё один пример оптимизации кода, на этот раз в контексте работы с файлами.

Неоптимальный код: Чтение файла

file = open('data.txt', 'r')
lines = file.readlines()
file.close()
processed_lines = []
for line in lines:
    processed_lines.append(line.strip())
print(processed_lines)

Оптимальный код: Чтение файла

with open('data.txt', 'r') as file:
    processed_lines = [line.strip() for line in file]
print(processed_lines)

В чем разница?

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

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

3. Читаемость и сокращение кода: Использование list comprehension вместо явного цикла for делает код более лаконичным и читаемым.

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

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

Давайте рассмотрим еще один пример, на этот раз связанный с работой со словарями в Python.

Неоптимальный код: Подсчет элементов

words = ['apple', 'banana', 'apple', 'pear', 'banana', 'orange', 'apple']
word_count = {}
for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1
print(word_count)

Оптимальный код: Подсчет элементов

from collections import Counter

words = ['apple', 'banana', 'apple', 'pear', 'banana', 'orange', 'apple']
word_count = Counter(words)
print(word_count)

В чем разница?

1. Простота и читаемость: Оптимальный код использует Counter из модуля collections, что упрощает задачу подсчета элементов. Это делает код более читаемым и понятным.

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

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

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

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

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

Неоптимальный код: Агрегация данных

data = [
    {"name": "Alice", "score": 10},
    {"name": "Bob", "score": 15},
    {"name": "Alice", "score": 20},
    {"name": "Bob", "score": 25},
]

aggregated_data = {}
for entry in data:
    name = entry["name"]
    score = entry["score"]
    if name in aggregated_data:
        aggregated_data[name].append(score)
    else:
        aggregated_data[name] = [score]

average_scores = {}
for name, scores in aggregated_data.items():
    average_scores[name] = sum(scores) / len(scores)

print(average_scores)

Оптимальный код: Агрегация данных

from collections import defaultdict

data = [
    {"name": "Alice", "score": 10},
    {"name": "Bob", "score": 15},
    {"name": "Alice", "score": 20},
    {"name": "Bob", "score": 25},
]

aggregated_data = defaultdict(list)
for entry in data:
    aggregated_data[entry["name"]].append(entry["score"])

average_scores = {name: sum(scores) / len(scores) for name, scores in aggregated_data.items()}

print(average_scores)

В чем разница?

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

2. Читаемость и эффективность: Использование генератора словаря (dictionary comprehension) для расчета средних значений делает код более читаемым и компактным. Также это уменьшает вероятность ошибок и повышает эффективность.

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

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

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

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

import random

def generate_line(subjects, actions, features):
    return f"{random.choice(subjects)} {random.choice(actions)} {random.choice(features)}"

def generate_verse(style, lines=4):
    subjects = ['Я', 'Ты', 'Она', 'Оно', 'Мы', 'Вы']
    actions = ['люблю', 'вижу', 'чувствую', 'знаю', 'понимаю', 'слышу']
    features = ['быстро', 'сильно', 'ярко', 'громко', 'мощно', 'вечно']

    if style == 'modern':
        actions += ['танцую', 'мечтаю', 'сияю', 'летаю']
        features += ['в ночи', 'как звезда', 'среди толпы', 'на грани']

    verse = "\n".join(generate_line(subjects, actions, features) for _ in range(lines))
    return verse

# Генерация стиха в современном стиле
print(generate_verse('modern'))

Этот код создает стихи, выбирая случайные сочетания субъектов, глаголов и характеристик.

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

В Python можно использовать библиотеки, такие как pretty_midi или MIDIUtil, для создания MIDI-файлов. Ниже представлен базовый пример кода, который генерирует простую музыкальную композицию в формате MIDI.

Установите MIDIUtil для работы с этим кодом:

pip install MIDIUtil

Пример кода для создания MIDI-файла:

from midiutil import MIDIFile

def create_simple_melody():
    # Создаем MIDI файл с одним треком
    midi = MIDIFile(1)
    track = 0
    time = 0
    channel = 0
    volume = 100

    midi.addTrackName(track, time, "Track")
    midi.addTempo(track, time, 120)

    # Пример простой мелодии
    notes = [60, 62, 64, 65, 67, 69, 71, 72] # C мажор
    duration = 1

    for note in notes:
        midi.addNote(track, channel, note, time, duration, volume)
        time += duration

    with open("simple_melody.mid", "wb") as output_file:
        midi.writeFile(output_file)

create_simple_melody()

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

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

Для воспроизведения MIDI-файла непосредственно из Python, вы можете использовать библиотеку, такую как pygame, которая позволяет воспроизводить MIDI-файлы. Вот как вы можете это сделать:

1. Установите pygame:

    pip install pygame    

2. Добавьте следующий код для воспроизведения MIDI-файла:

    import pygame
    import time

    def play_midi(filename):
        freq = 44100    # аудио CD качество
        bitsize = -16   # беззнаковый короткий, little-endian
        channels = 2    # 1 для моно, 2 для стерео
        buffer = 1024   # количество сэмплов
        pygame.mixer.init(freq, bitsize, channels, buffer)

        # проверяем, что Mixer не занят другими задачами
        if not pygame.mixer:
            print("Не удалось инициализировать Mixer")
            return

        pygame.mixer.music.load(filename)
        pygame.mixer.music.play()

        while pygame.mixer.music.get_busy():
            # Воспроизведение музыки может занять некоторое время, 
            # поэтому используем задержку
            time.sleep(1)

    # Воспроизведение файла
    play_midi("simple_melody.mid")
    

Этот код сначала инициализирует pygame mixer, затем загружает и воспроизводит указанный MIDI-файл. После этого код ожидает завершения воспроизведения музыки перед тем, как завершить выполнение. Убедитесь, что файл simple_melody.mid находится в той же директории, что и ваш скрипт Python.

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

В наш курс по Python добавили 46 интерактивных задач и 11 тестов, а скидка в 2000 руб все еще в силе 👀 только для читателей канала по линку https://stepik.org/a/185238/pay?promo=dcfeb683c217284e до 07.12.2023 включительно!

Создание роевого искусственного интеллекта (AI) требует сложных алгоритмов и обширных знаний в области компьютерных наук, но я могу предоставить вам простой пример кода, который демонстрирует основную концепцию роевого интеллекта. В этом примере мы будем использовать алгоритм оптимизации роем частиц (Particle Swarm Optimization, PSO), который является одним из наиболее популярных методов роевого интеллекта.

Алгоритм PSO используется для оптимизации функции, где "частицы" (агенты) перемещаются по пространству решений, следуя за лучшими решениями, найденными ими и их соседями.

Вот базовый пример на Python:

import random
import numpy as np

# Функция для оптимизации
def objective_function(x):
    return x[0]**2 + x[1]**2

# Класс, представляющий одну частицу
class Particle:
    def __init__(self, bounds):
        self.position = np.array([random.uniform(bound[0], bound[1]) for bound in bounds])
        self.velocity = np.array([0.0, 0.0])
        self.best_position = np.copy(self.position)
        self.best_value = float('inf')

    def update(self, global_best):
        w = 0.5  # инерция
        c1, c2 = 1.0, 1.0  # коэффициенты социального и когнитивного влияния

        for i in range(len(self.position)):
            r1, r2 = random.random(), random.random()
            social = c1 * r1 * (global_best.position[i] - self.position[i])
            cognitive = c2 * r2 * (self.best_position[i] - self.position[i])
            self.velocity[i] = w * self.velocity[i] + social + cognitive

        self.position += self.velocity
        value = objective_function(self.position)

        if value < self.best_value:
            self.best_position = np.copy(self.position)
            self.best_value = value

# PSO алгоритм
def particle_swarm_optimization(bounds, num_particles, num_iterations):
    global_best = Particle(bounds)
    global_best.best_value = float('inf')
    particles = [Particle(bounds) for _ in range(num_particles)]

    for _ in range(num_iterations):
        for particle in particles:
            particle.update(global_best)

            if particle.best_value < global_best.best_value:
                global_best.position = np.copy(particle.best_position)
                global_best.best_value = particle.best_value

    return global_best.position, global_best.best_value

# Параметры
bounds = [(-10, 10), (-10, 10)]  # Границы поиска
num_particles = 30
num_iterations = 100

# Запуск PSO
best_position, best_value = particle_swarm_optimization(bounds, num_particles, num_iterations)
print("Лучшее положение:", best_position)
print("Лучшее значение:", best_value)

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

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

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

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

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

# Функция для оптимизации
def objective_function(x):
    return x[0]**2 + x[1]**2

# Класс Particle остается тем же

# Функция для визуализации
def visualize(particles, global_best, bounds, num_iterations):
    fig, ax = plt.subplots()
    ax.set_xlim(bounds[0])
    ax.set_ylim(bounds[1])
    points = [ax.plot(particle.position[0], particle.position[1], 'ro')[0] for particle in particles]

    def animate(i):
        for j, particle in enumerate(particles):
            particle.update(global_best)
            points[j].set_data(particle.position[0], particle.position[1])
            if particle.best_value < global_best.best_value:
                global_best.position = np.copy(particle.best_position)
                global_best.best_value = particle.best_value
        return points

    anim = FuncAnimation(fig, animate, frames=num_iterations, interval=200, blit=True)
    plt.show()

# Остальная часть кода остается неизменной

# Параметры
bounds = [(-10, 10), (-10, 10)]
num_particles = 30
num_iterations = 50

# Создание частиц и глобального лучшего решения
global_best = Particle(bounds)
global_best.best_value = float('inf')
particles = [Particle(bounds) for _ in range(num_particles)]

# Запуск визуализации
visualize(particles, global_best, bounds, num_iterations)

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

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

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

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

import random

# Функция для оценки приспособленности
def fitness(individual):
    return sum(individual)

# Функция для создания начальной популяции
def create_population(pop_size, gene_length):
    return [[random.randint(0, 1) for _ in range(gene_length)] for _ in range(pop_size)]

# Функция для кроссовера (скрещивания)
def crossover(parent1, parent2):
    index = random.randint(1, len(parent1) - 2)
    return parent1[:index] + parent2[index:], parent2[:index] + parent1[index:]

# Функция для мутации
def mutate(individual, mutation_rate):
    for i in range(len(individual)):
        if random.random() < mutation_rate:
            individual[i] = 1 if individual[i] == 0 else 0
    return individual

# Функция для проведения одного поколения генетического алгоритма
def run_generation(population, mutation_rate):
    new_population = []
    while len(new_population) < len(population):
        parent1, parent2 = random.sample(population, 2)
        offspring1, offspring2 = crossover(parent1, parent2)
        offspring1 = mutate(offspring1, mutation_rate)
        offspring2 = mutate(offspring2, mutation_rate)
        new_population.extend([offspring1, offspring2])
    return sorted(new_population, key=fitness, reverse=True)[:len(population)]

# Основная функция
def genetic_algorithm(pop_size, gene_length, num_generations, mutation_rate):
    population = create_population(pop_size, gene_length)
    for _ in range(num_generations):
        population = run_generation(population, mutation_rate)
    return population[0]

# Параметры
pop_size = 100
gene_length = 20
num_generations = 50
mutation_rate = 0.01

# Запуск алгоритма
best_individual = genetic_algorithm(pop_size, gene_length, num_generations, mutation_rate)
print("Лучший индивид:", best_individual)
print("Приспособленность:", fitness(best_individual))

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

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

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

import random
import matplotlib.pyplot as plt

# Функция для оценки приспособленности и другие функции остаются без изменений

# Модифицированная функция для проведения одного поколения генетического алгоритма
def run_generation(population, mutation_rate):
    new_population = []
    population_fitness = []
    while len(new_population) < len(population):
        parent1, parent2 = random.sample(population, 2)
        offspring1, offspring2 = crossover(parent1, parent2)
        offspring1 = mutate(offspring1, mutation_rate)
        offspring2 = mutate(offspring2, mutation_rate)
        new_population.extend([offspring1, offspring2])
    sorted_population = sorted(new_population, key=fitness, reverse=True)
    best_fitness = fitness(sorted_population[0])
    population_fitness.append(best_fitness)
    return sorted_population[:len(population)], population_fitness

# Модифицированная основная функция
def genetic_algorithm(pop_size, gene_length, num_generations, mutation_rate):
    population = create_population(pop_size, gene_length)
    best_fitness_over_time = []
    for _ in range(num_generations):
        population, population_fitness = run_generation(population, mutation_rate)
        best_fitness_over_time.extend(population_fitness)
    return population[0], best_fitness_over_time

# Параметры
pop_size = 100
gene_length = 20
num_generations = 50
mutation_rate = 0.01

# Запуск алгоритма и визуализация
best_individual, fitness_over_time = genetic_algorithm(pop_size, gene_length, num_generations, mutation_rate)
plt.plot(fitness_over_time)
plt.xlabel('Поколение')
plt.ylabel('Приспособленность лучшего индивида')
plt.title('Прогресс приспособленности в генетическом алгоритме')
plt.show()

print("Лучший индивид:", best_individual)
print("Приспособленность:", fitness(best_individual))

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

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