👉 Tech.skills, или технические навыки, это основное для инженера в ИТ. Около ~70% кандидатов не проходят именно по tech.skills.

🙂 Soft.skills — это внешний вид автомобиля и салон. 🤖 Tech.skills — это двигатель, коробка и ходовая.

❔ Хорошо, когда есть все это, но без чего авто не поедет совсем?

🚀 Поэтому забейте на все, кроме tech.skills, качайте их в течение года, вот тут я писал подробный план на 2025 год.

🚂 Часто бывает тяжело самому, параллельно с работой, не сойти с пути качки тех.скиллов, тогда идите к нашему партнеру GeekBrains на курс Python. Они вас точно дотянут 👈

Реклама. Информация о рекламодателе по ссылкам в посте.

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

В Python неизменяемые словари можно создавать с помощью класса types.MappingProxyType. Этот класс предоставляет неизменяемую обёртку для обычного словаря, позволяя вам работать с его данными, но предотвращая изменение их напрямую.

### Пример кода

from types import MappingProxyType

# Исходный изменяемый словарь
mutable_dict = {"a": 1, "b": 2, "c": 3}

# Создаём неизменяемую обёртку
immutable_dict = MappingProxyType(mutable_dict)

# Чтение данных из неизменяемого словаря
print(immutable_dict["a"])  # 1
print(immutable_dict)  # {'a': 1, 'b': 2, 'c': 3}

# Попытка изменения вызывает ошибку
try:
    immutable_dict["a"] = 10  # Ошибка: TypeError
except TypeError as e:
    print(f"Error: {e}")

# Исходный словарь всё ещё можно изменять
mutable_dict["a"] = 42
print(immutable_dict["a"])  # 42 — изменения видны в обёртке

### Зачем нужны неизменяемые словари?

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

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

3. Кэширование и оптимизация:
Использование неизменяемых объектов, таких как неизменяемые словари, позволяет кэшировать результаты и повторно использовать их без риска изменения.

4. Предотвращение ошибок:
Защита от случайного изменения данных делает код более безопасным и удобным для отладки.

### Особенности:
1. Изменение оригинального словаря: Если исходный словарь изменяется, изменения отражаются и в неизменяемой обёртке.
2. Ограничение доступа: Хотя MappingProxyType защищает от изменений, это не делает словарь полностью безопасным от побочных эффектов, если доступ к оригинальному словарю остаётся.

### Дополнение:
Если вам нужен полностью неизменяемый словарь, вы можете использовать библиотеки, такие как immutables:

pip install immutables

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

from immutables import Map

immutable_map = Map({"a": 1, "b": 2})
print(immutable_map["a"])  # 1

# Попытка изменения
try:
    immutable_map["a"] = 10  # Ошибка
except TypeError as e:
    print(f"Error: {e}")

Неизменяемые структуры данных, такие как MappingProxyType или immutables.Map, идеально подходят для ситуаций, где необходима защита данных от изменения.

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

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

### Основные нововведения

1. `Int64`, `Float64` и `StringDtype`:
- Новый способ работы с типами данных, поддерживающий пропущенные значения без использования object.
- Удобно для больших данных, где важна экономия памяти.

2. `pandas` с `PyArrow`:
- Поддержка pyarrow для чтения и записи файлов ускоряет обработку больших данных.
- Особенно полезно при работе с форматами Parquet и Arrow.

3. Мультипроцессинг с `modin.pandas`:
- Простая замена pandas на modin.pandas для многопоточной обработки больших данных.

4. Оптимизированное чтение/запись:
- Улучшены методы чтения из файлов CSV, Parquet и других источников.

5. Методы `query` и `eval`:
- Позволяют писать эффективные SQL-подобные запросы.

---

### Пример кода, демонстрирующий новые возможности

import pandas as pd
import numpy as np

# 1. Поддержка новых типов данных
data = {
    "id": pd.Series([1, 2, 3, None], dtype="Int64"),
    "value": pd.Series([10.5, None, 30.2, 40.8], dtype="Float64"),
    "name": pd.Series(["Alice", "Bob", None, "Eve"], dtype="string"),
}
df = pd.DataFrame(data)
print("DataFrame с новыми типами данных:")
print(df)
print(df.dtypes)

# 2. Чтение/запись с использованием pyarrow (формат Parquet)
df.to_parquet("example.parquet", engine="pyarrow")
df_read = pd.read_parquet("example.parquet", engine="pyarrow")
print("\nПример чтения/записи Parquet:")
print(df_read)

# 3. Использование query для SQL-подобных запросов
query_result = df.query("value > 20")
print("\nРезультат query:")
print(query_result)

# 4. Анализ больших данных с modin.pandas (замена pandas на modin)
# pip install modin[ray]
try:
    import modin.pandas as mpd
    large_data = mpd.DataFrame(np.random.rand(10**6, 3), columns=["A", "B", "C"])
    filtered_data = large_data[large_data["A"] > 0.5]
    print("\nОбработка больших данных с modin.pandas:")
    print(filtered_data.head())
except ImportError:
    print("\nДля работы с modin.pandas установите modin: pip install modin[ray]")

# 5. Векторные вычисления с eval
df["double_value"] = pd.eval("df.value * 2")
print("\nРезультат использования eval:")
print(df)

---

### Объяснение

1. Новые типы данных (`Int64`, `Float64`, `string`):
- Удобны для работы с пропущенными значениями (`NaN`) без потери производительности.

2. `PyArrow` и `Parquet`:
- Parquet — формат, оптимизированный для работы с большими наборами данных.
- Быстрее, чем CSV, особенно при чтении/записи.

3. `modin.pandas`:
- Использует мультипроцессинг для работы с большими наборами данных.
- Совместим с существующими API pandas.

4. `query` и `eval`:
- Ускоряют фильтрацию и вычисления, избегая создания промежуточных копий данных.

---

### Когда использовать эти функции?

- При работе с наборами данных, превышающими объём оперативной памяти.
- Для обработки данных, требующей высокой производительности.
- Для упрощения анализа с помощью SQL-подобного синтаксиса (`query`, `eval`).

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

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

1️⃣ В программировании важна практика, и только практика. На первом этапе нужно писать код каждый день. Лучше для начала на одном языке. Если выбрали Python, то берите примеры кода из этого канала и расширяйте их. Какой-то пример вам не зайдет, и вы просто его напишите, чуть-чуть измените и пойдете дальше, а какой-то пример, возможно, даже пригодится в вашей области, и вы из него сделаете большой рабочий код.

2️⃣ Главное, пишите код - с ошибками, с исправлениями, дополнениями. Много кода, особенно на разные темы и с разными библиотеками. Все это я описывал как часть плана на 2025 год 🚀🚀🚀

3️⃣ По программированию все знания доступны онлайн, а вот хирургом стать онлайн будет сложновато. Если вам тяжело дается, идите к нашему партнеру GeekBrain на курс Python. Они вас точно дотянут 🚂🚂🚂

Реклама. Информация о рекламодателе по ссылкам в посте.

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

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

---

### Пример разницы между query и loc

Использование `query`:

import pandas as pd

# Пример DataFrame
df = pd.DataFrame({
    "A": [1, 2, 3, 4],
    "B": [10, 20, 30, 40],
    "C": ["x", "y", "z", "x"]
})

# Фильтрация с помощью query
result_query = df.query("A > 2 and C == 'x'")
print("Результат query:")
print(result_query)

Использование `loc`:

# Фильтрация с помощью loc
result_loc = df.loc[(df["A"] > 2) & (df["C"] == "x")]
print("\nРезультат loc:")
print(result_loc)

### Когда использовать query?

1. Удобство синтаксиса:
- Если у вас SQL-подобный фон, query будет естественным выбором.
- Удобен для сложных условий:

     df.query("A > 2 and B < 35 or C == 'x'")
     

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

3. Читаемость:
- Код с query более читаемый для людей, особенно если много условий.

---

### Когда использовать loc?

1. Совместимость с любыми именами столбцов:
- Если у вас есть столбцы с пробелами или символами, которые нельзя использовать в выражениях Python:

     df.loc[df["Column With Spaces"] > 10]
     

2. Гибкость:
- Можно использовать более сложные условия, включая операции с индексами:

     df.loc[df.index > 1]
     

3. Работа с переменными проще:
- Переменные подставляются без использования @:

     threshold = 2
     df.loc[df["A"] > threshold]
     

---

### Итог: Когда что выбрать?

- Используйте `query`, если:
- Ваши условия фильтрации сложные и их лучше выразить в SQL-подобном синтаксисе.
- Нужна максимальная читаемость и скорость на больших данных.
- Имена столбцов валидны для Python.

- Используйте `loc`, если:
- У вас нестандартные имена столбцов.
- Вы хотите фильтровать по индексам или комбинировать фильтрацию с другими методами pandas.
- Нужна максимальная универсальность.

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

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

Query vs Loc в Pandas

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

Концепция минимальной единицы времени основана на Планковской длине и скорости света. Это время представляет минимальный возможный интервал времени в квантовой физике. То есть время дискретно.

Ниже приведён код, демонстрирующий идею дискретности времени:

import numpy as np

# Фундаментальные константы
PLANCK_LENGTH = 1.616e-35  # м
SPEED_OF_LIGHT = 3e8       # м/с

# Планковское время
PLANCK_TIME = PLANCK_LENGTH / SPEED_OF_LIGHT  # с

print(f"Планковская длина: {PLANCK_LENGTH:.3e} м")
print(f"Скорость света: {SPEED_OF_LIGHT:.3e} м/с")
print(f"Планковское время: {PLANCK_TIME:.3e} с")

# Демонстрация дискретного времени
# Генерируем массив времени, дискретизированного на планковские интервалы
num_intervals = 10
time_intervals = np.arange(0, num_intervals * PLANCK_TIME, PLANCK_TIME)

print("\nДискретные временные интервалы:")
for t in time_intervals:
    print(f"{t:.3e} с")

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

### Результат
Код покажет значения времени, разделённые Планковским интервалом. Это демонстрирует идею дискретности времени в квантовой физике. Однако важно отметить, что физическая проверка этой концепции всё ещё является теоретической и экспериментально недоступной.

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

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

Однако мы можем создать демонстрационный таймер, который симулирует тики с очень малыми интервалами (например, наносекунды), чтобы представить концепцию. Вот пример:

import time

# Минимальный временной интервал (симулируем крошечные "тики")
MIN_INTERVAL = 1e-9  # 1 наносекунда (очень маленький интервал)

def tiny_tick_timer(total_duration):
    """
    Таймер с крошечными временными тиками.
    total_duration: общее время работы таймера (в секундах).
    """
    start_time = time.time()  # Засекаем начальное время
    elapsed = 0              # Прошедшее время
    tick_count = 0           # Счётчик тиков

    print("Запуск таймера...")

    # Таймер работает, пока общее время не истечёт
    while elapsed < total_duration:
        current_time = time.time()  # Получаем текущее время
        if current_time - start_time >= tick_count * MIN_INTERVAL:
            # Если время подходит для нового тика, печатаем его
            print(f"Тик {tick_count + 1}: Прошло времени {elapsed:.9f} секунд")
            tick_count += 1  # Увеличиваем счётчик тиков
        elapsed = current_time - start_time  # Обновляем прошедшее время

    print("Таймер завершён.")

# Запускаем таймер на 0.001 секунды (1 миллисекунда)
tiny_tick_timer(0.001)

### Что происходит:
1. Минимальный интервал:
- Используется фиксированный маленький промежуток времени (\( 1 \times 10^{-9} \), одна наносекунда), который задаёт "тики".
2. Таймер:
- Отслеживает общее время, используя текущее время и начальную отметку.
- Каждый раз, когда наступает время следующего "тика", выводится сообщение.
3. Общее время:
- Таймер останавливается, как только общее время работы достигает заданного значения.

### Как выглядит вывод:

Запуск таймера...
Тик 1: Прошло времени 0.000000000 секунд
Тик 2: Прошло времени 0.000000001 секунд
Тик 3: Прошло времени 0.000000002 секунд
...
Таймер завершён.

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

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

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

### Установка Open3D
Если у вас ещё не установлена библиотека Open3D, выполните команду:

pip install open3d

### Код для генерации и визуализации ракеты

import open3d as o3d
import numpy as np

# Функция для генерации точечного облака ракеты
def generate_rocket_point_cloud(num_points=10000, rocket_height=10, body_radius=1, nose_height=2):
    points = []

    # Корпус ракеты (цилиндр)
    body_height = rocket_height - nose_height
    for _ in range(num_points // 2):  # 50% точек для корпуса
        angle = np.random.uniform(0, 2 * np.pi)
        radius = np.random.uniform(0, body_radius)
        height = np.random.uniform(0, body_height)
        x = radius * np.cos(angle)
        y = radius * np.sin(angle)
        z = height
        points.append([x, y, z])

    # Носовая часть ракеты (конус)
    for _ in range(num_points // 4):  # 25% точек для носа
        height = np.random.uniform(body_height, rocket_height)
        radius = body_radius * (1 - (height - body_height) / nose_height)  # Сужение к вершине
        angle = np.random.uniform(0, 2 * np.pi)
        r = np.random.uniform(0, radius)
        x = r * np.cos(angle)
        y = r * np.sin(angle)
        z = height
        points.append([x, y, z])

    # Хвостовые стабилизаторы (плоские поверхности)
    fin_length = body_radius * 1.5
    fin_height = body_height * 0.2
    fin_offsets = [-body_radius, body_radius]
    for offset in fin_offsets:
        for _ in range(num_points // 8):  # 12.5% точек для хвостов
            x = np.random.uniform(offset, offset + fin_length * (1 if offset > 0 else -1))
            y = np.random.uniform(-fin_length / 4, fin_length / 4)
            z = np.random.uniform(0, fin_height)
            points.append([x, y, z])

    return np.array(points)

# Генерация точечного облака ракеты
rocket_points = generate_rocket_point_cloud()

# Создание объекта PointCloud для Open3D
pcd = o3d.geometry.PointCloud()
pcd.points = o3d.utility.Vector3dVector(rocket_points)

# Визуализация точечного облака
o3d.visualization.draw_geometries([pcd], window_name="3D Точечное облако ракеты", width=800, height=600)

### Что делает этот код:
1. Корпус ракеты: Представлен цилиндром.
2. Носовая часть: Представлена конусом, сужающимся к вершине.
3. Хвостовые стабилизаторы: Представлены плоскими пластинами, расположенными с двух сторон корпуса.

### Инструкции:
1. Скопируйте этот код в .py файл.
2. Запустите скрипт на вашем компьютере.
3. Вы увидите визуализацию 3D точечного облака ракеты в окне Open3D.

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

Ракеты по коду выше 👆👆👆

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

Пример кода для генерации 3D-модели ракеты в виде mesh с использованием библиотеки Open3D. Мы создадим ракету с корпусом, носовой частью, стабилизаторами и сохраним её как .obj или .stl.

### Код для генерации Mesh ракеты

import open3d as o3d
import numpy as np

# Функция для создания ракеты
def create_rocket_mesh(body_height=8, body_radius=1, nose_height=2, fin_height=1, fin_width=0.5):
    # Создание корпуса ракеты (цилиндр)
    body = o3d.geometry.TriangleMesh.create_cylinder(radius=body_radius, height=body_height)
    body.translate((0, 0, body_height / 2))  # Переместить цилиндр вверх
    body.paint_uniform_color([0.8, 0.2, 0.2])  # Красный цвет корпуса

    # Создание носа ракеты (конус)
    nose = o3d.geometry.TriangleMesh.create_cone(radius=body_radius, height=nose_height)
    nose.translate((0, 0, body_height + nose_height / 2))  # Поместить конус на корпус
    nose.paint_uniform_color([0.9, 0.9, 0.9])  # Белый цвет носа

    # Создание стабилизаторов (прямоугольные параллелепипеды)
    fins = []
    for angle in [0, np.pi / 2, np.pi, 3 * np.pi / 2]:  # Расположение стабилизаторов
        fin = o3d.geometry.TriangleMesh.create_box(width=fin_width, height=fin_height, depth=0.1)
        fin.translate((body_radius, -fin_height / 2, fin_height / 2))
        fin.rotate(o3d.geometry.get_rotation_matrix_from_axis_angle([0, 0, angle]), center=(0, 0, 0))
        fin.paint_uniform_color([0.2, 0.2, 0.8])  # Синий цвет стабилизаторов
        fins.append(fin)

    # Объединение всех частей ракеты
    rocket = body + nose
    for fin in fins:
        rocket += fin

    rocket.compute_vertex_normals()  # Расчет нормалей для правильной визуализации
    return rocket

# Генерация ракеты
rocket_mesh = create_rocket_mesh()

# Визуализация ракеты
o3d.visualization.draw_geometries([rocket_mesh], window_name="3D Mesh Ракеты", width=800, height=600)

# Сохранение ракеты в файл
o3d.io.write_triangle_mesh("rocket.obj", rocket_mesh)
print("Ракета сохранена в файл rocket.obj")

---

### Что делает этот код:
1. Корпус ракеты: Создаётся в виде цилиндра.
2. Нос ракеты: Создаётся в виде конуса.
3. Стабилизаторы: Четыре прямоугольных параллелепипеда, размещённых вокруг корпуса.
4. Цвет: Разным частям ракеты задаются разные цвета.
5. Сохранение: Генерируемая модель сохраняется в файл rocket.obj.

---

### Как использовать:
1. Сохраните код в .py файл.
2. Убедитесь, что библиотека Open3D установлена: pip install open3d.
3. Запустите скрипт.
4. Откройте визуализацию 3D модели или найдите сохранённый файл rocket.obj.

Вы можете открыть файл .obj в любой 3D-программе, такой как Blender или MeshLab.

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

Mesh ракета по коду выше 👆👆👆

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

Запили новый визуал для нашего софта сканирования помещений в CAD 🙂 Не смог не поделится такой красотой 🔥

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

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

### Установка PyGame
Если у вас не установлен PyGame, выполните команду:

pip install pygame

### Код для игры

import pygame
import random
import sys

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

# Настройки окна
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Простая игра на PyGame")

# Цвета
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)

# Переменные игрока
player_size = 50
player_x = WIDTH // 2
player_y = HEIGHT - 2 * player_size
player_speed = 10

# Препятствия
enemy_size = 50
enemy_x = random.randint(0, WIDTH - enemy_size)
enemy_y = 0
enemy_speed = 5

# Счёт
score = 0
font = pygame.font.Font(None, 36)

# Основной игровой цикл
clock = pygame.time.Clock()
running = True
while running:
    screen.fill(WHITE)

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

    # Движение игрока
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_x > 0:
        player_x -= player_speed
    if keys[pygame.K_RIGHT] and player_x < WIDTH - player_size:
        player_x += player_speed

    # Движение препятствия
    enemy_y += enemy_speed
    if enemy_y > HEIGHT:
        enemy_y = 0
        enemy_x = random.randint(0, WIDTH - enemy_size)
        score += 1  # Увеличение счёта

    # Проверка столкновений
    if (
        player_x < enemy_x + enemy_size
        and player_x + player_size > enemy_x
        and player_y < enemy_y + enemy_size
        and player_y + player_size > enemy_y
    ):
        running = False  # Игра заканчивается при столкновении

    # Рисование игрока и препятствия
    pygame.draw.rect(screen, GREEN, (player_x, player_y, player_size, player_size))
    pygame.draw.rect(screen, RED, (enemy_x, enemy_y, enemy_size, enemy_size))

    # Отображение счёта
    score_text = font.render(f"Счёт: {score}", True, BLACK)
    screen.blit(score_text, (10, 10))

    # Обновление экрана
    pygame.display.flip()
    clock.tick(30)  # FPS

# Завершение игры
pygame.quit()
sys.exit()

---

### Как работает игра:
1. Игрок управляет зелёным квадратом с помощью клавиш ← и →.
2. Красный квадрат (препятствие) падает сверху вниз.
3. Если игрок избегает препятствия, счёт увеличивается.
4. Если происходит столкновение, игра завершается.

---

### Как улучшить:
1. Добавить уровни сложности:
- Увеличивать скорость препятствий по мере роста счёта.
2. Множество препятствий:
- Добавить несколько красных квадратов с разными скоростями.
3. Звуковые эффекты:
- Добавить звуки при столкновении или при наборе очков.

   collision_sound = pygame.mixer.Sound("collision.wav")
   collision_sound.play()
   

4. Меню и перезапуск игры.

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

Код игры выше 👆👆👆

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

Отвечаем на все вопросы в курсах 👍 Радуемся лайкам и решениям студентов на курсах 😃😃😃

Три наших самых популярных курса на Stepik:

👉 Python: самый быстрый курс 🔥

👉 Python Data Science: самый быстрый курс 🔥

👉 Python в нескучных примерах (50) 🔥

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

Для генерации цветов на День Святого Валентина можно использовать библиотеку turtle, которая позволяет рисовать графику на основе команд. Ниже приведен пример кода для рисования романтических цветов:

import turtle
import random

def draw_flower(x, y, petal_color, center_color):
    turtle.penup()
    turtle.goto(x, y)
    turtle.pendown()

    # Рисуем лепестки
    turtle.color(petal_color)
    for _ in range(6):  # 6 лепестков
        turtle.begin_fill()
        turtle.circle(20, steps=3)  # Треугольные лепестки
        turtle.end_fill()
        turtle.right(60)  # Угол между лепестками

    # Рисуем центр цветка
    turtle.penup()
    turtle.goto(x, y - 10)
    turtle.pendown()
    turtle.color(center_color)
    turtle.begin_fill()
    turtle.circle(10)
    turtle.end_fill()

def draw_stem(x, y):
    turtle.penup()
    turtle.goto(x, y)
    turtle.pendown()

    # Рисуем стебель
    turtle.color("green")
    turtle.width(3)
    turtle.right(90)
    turtle.forward(50)

    # Рисуем лист
    turtle.penup()
    turtle.goto(x, y - 25)
    turtle.pendown()
    turtle.begin_fill()
    turtle.left(45)
    turtle.circle(10, 180)
    turtle.right(90)
    turtle.circle(10, 180)
    turtle.left(45)
    turtle.end_fill()

# Настройка экрана
turtle.setup(width=800, height=600)
turtle.speed(0)
turtle.hideturtle()
turtle.bgcolor("pink")

# Генерация цветов
for _ in range(10):
    x = random.randint(-300, 300)
    y = random.randint(-200, 200)
    petal_color = random.choice(["red", "yellow", "blue", "purple", "orange"])
    center_color = "yellow"

    draw_flower(x, y, petal_color, center_color)
    draw_stem(x, y - 20)

# Показать результат
turtle.done()

### Описание кода:
1. Цветы:
- Цветы состоят из шести лепестков, нарисованных кругами.
- Центр цветка — маленький желтый круг.
2. Стебель:
- Зелёный стебель с листиком сбоку.
3. Случайное размещение:
- Цветы размещаются в случайных позициях на экране.
4. Цвета лепестков:
- Лепестки окрашиваются в случайные яркие цвета: красный, жёлтый, синий и другие.

---

### Как использовать:
1. Скопируйте код в файл flowers.py.
2. Запустите его в Python.
3. На экране появится множество случайно размещённых цветов.

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