Методы 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 🤖

Код генерации цветов выше 👆👆👆

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

Создание простой 3D-игры в Python можно выполнить с использованием библиотеки Ursina, которая позволяет работать с 3D-графикой, физикой и вводом данных.

### Установка Ursina
Если у вас не установлена библиотека Ursina, выполните:

pip install ursina

### Пример 3D-игры: Куб игрока и падающие препятствия
Вот код:

from ursina import *

# Создание приложения
app = Ursina()

# Игрок (управляемый куб)
player = Entity(model='cube', color=color.orange, scale=(1, 1, 1), position=(0, 0, 0))

# Препятствия
obstacles = []
for i in range(5):
    obstacle = Entity(model='cube', color=color.red, scale=(1, 1, 1),
                      position=(i * 2 - 4, 5, 0))
    obstacles.append(obstacle)

# Переменные игры
speed = 5
obstacle_speed = 2
score = 0
is_game_over = False

# Счётчик
score_text = Text(text=f'Score: {score}', position=(-0.7, 0.4), scale=2)

# Функция обновления
def update():
    global score, is_game_over

    if is_game_over:
        return

    # Управление игроком
    if held_keys['a']:
        player.x -= speed * time.dt
    if held_keys['d']:
        player.x += speed * time.dt

    # Движение препятствий
    for obstacle in obstacles:
        obstacle.y -= obstacle_speed * time.dt

        # Если препятствие достигло нижней части экрана
        if obstacle.y < -5:
            obstacle.y = 5
            obstacle.x = random.uniform(-4, 4)
            score += 1
            score_text.text = f'Score: {score}'

        # Проверка на столкновение с игроком
        if player.intersects(obstacle).hit:
            game_over()

def game_over():
    global is_game_over
    is_game_over = True
    Text(text="Game Over", origin=(0, 0), scale=2, color=color.red, position=(0, 0))
    score_text.text = f'Final Score: {score}'

# Функция для перезапуска игры
def restart():
    global is_game_over, score
    is_game_over = False
    score = 0
    score_text.text = f'Score: {score}'
    for obstacle in obstacles:
        obstacle.y = random.uniform(5, 10)
        obstacle.x = random.uniform(-4, 4)
    player.position = (0, 0, 0)

# Кнопка перезапуска
restart_button = Button(text="Restart", position=(0, -0.4), scale=(0.2, 0.1), visible=False)

def input(key):
    if key == 'space' and is_game_over:
        restart()

restart_button.on_click = restart

# Запуск приложения
app.run()

---

### Что делает этот код:
1. Игрок:
- Управляется клавишами A (влево) и D (вправо).
- Это оранжевый куб, который перемещается по горизонтали.

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

3. Счёт:
- Увеличивается на 1 каждый раз, когда препятствие пересекает нижнюю границу экрана.

4. Конец игры:
- При столкновении появляется текст "Game Over".
- Игру можно перезапустить нажатием клавиши Space.

---

### Как улучшить:
1. Добавить уровни сложности:
- Увеличивать скорость препятствий по мере увеличения счёта.
2. Добавить 3D-модель игрока:
- Заменить куб на, например, модель самолёта:

     player.model = 'sphere'
     

3. Добавить фон:
- Добавить текстуры или окружение с помощью Sky():

     sky = Entity(model='sphere', texture='sky_sunset', scale=100, double_sided=True)
     

4. Музыка и звуки:
- Добавить звуки при столкновении или наборе очков:

     Audio('explosion.wav', loop=False)
     

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

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

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