Телеграм канал «Постоянный репозиторий по Python»

Почему список списков через * может сломать вам всю логику
На первый взгляд этот код выглядит абсолютно нормально:
# хотим создать таблицу 3x3, заполненную нулями
matrix = [[0] * 3] * 3

# меняем один элемент
matrix[0][1] = 7

print(matrix)
Многие ожидают такой результат:
[[0, 7, 0],
[0, 0, 0],
[0, 0, 0]]
Но на деле получится:
[[0, 7, 0],
[0, 7, 0],
[0, 7, 0]]
И вот это уже выглядит как магия.
Хотя на самом деле это просто особенность ссылок в Python.

Что здесь происходит?
Проблема в этой строке:
matrix = [[0] * 3] * 3
Кажется, будто Python создаёт три независимых списка.
Но нет.

Он создаёт один внутренний список и затем повторяет ссылку на него три раза.
То есть все строки матрицы указывают на один и тот же объект в памяти.
Поэтому изменение одного элемента фактически меняет сразу все «строки».

Как создать матрицу правильно
Нужно, чтобы каждая строка создавалась отдельно:
matrix = [[0] * 3 for _ in range(3)]

matrix[0][1] = 7
print(matrix)
Теперь результат будет корректным:
[[0, 7, 0],
[0, 0, 0],
[0, 0, 0]]
Потому что каждая строка — это уже свой собственный список.

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

Как быстро запомнить
Если внутри структура изменяемая, то конструкция через * может быть опасной.
То есть вот так:
[ [0] * 3 ] * 3
— подозрительно.
А вот так:
[ [0] * 3 for _ in range(3) ]
— безопасно.

Главное правило
Оператор * хорошо подходит для простых списков,
но плохо подходит для вложенных изменяемых структур.
Именно поэтому матрицы через умножение списков — классическая ловушка Python.

🐍 .loc vs .iloc в pandas – почему это важно понимать

Очень частая ситуация: нужно выбрать данные из таблицы.

И тут начинается магия (и ошибки)

Как обычно делают
import pandas as pd

df = pd.DataFrame({
"name": ["Alice", "Bob", "Charlie"],
"score": [85, 92, 78]
}, index=[10, 20, 30])

И дальше кто-то пишет:

df.loc[0]

И получает… ошибку
В чём разница?

👉 .loc – работает с метками (labels)
👉 .iloc – работает с позициями (индексами)

Разберём на примере
# доступ по индексу (метке)
df.loc[10]

Вернёт строку с индексом 10.
# доступ по позиции
df.iloc[0]
Вернёт первую строку, независимо от значения индекса.

Где чаще всего ошибаются
Когда индекс не 0,1,2…, а, например:
• ID пользователей
• даты
• кастомные значения
df.loc[0] # ❌ может не существовать
df.iloc[0] # ✔️ первая строка

Ещё один важный момент
Срезы работают по-разному:
df.loc[10:20] # включает 20
df.iloc[0:2] # НЕ включает 2
Это тоже часто ломает логику.

Как запомнить
• .loc → логика данных (label)
• .iloc → логика позиции (index)

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

✔️ .loc:
• работаешь с реальными ID
• фильтруешь по значениям индекса
• пишешь читаемый аналитический код

✔️ .iloc:
• нужен доступ по позиции
• работаешь как с массивом
• делаешь быстрые прототипы

Вывод
Если путаешь .loc и .iloc – рано или поздно словишь очень неприятный баг.
Это не синтаксис — это логика работы с данными.

Почему iterrows() в pandas почти всегда плохая идея

Когда нужно пройти по строкам DataFrame, многие пишут так:
import pandas as pd

df = pd.DataFrame({
"name": ["Alice", "Bob", "Charlie"],
"score": [85, 92, 78]
})

# Проходим по строкам
for index, row in df.iterrows():

# row — это объект Series
# можно обращаться к значениям по имени столбца

if row["score"] >= 90:
print(f"{row['name']} — отличный результат")

На первый взгляд всё выглядит логично: мы перебираем строки и работаем с ними как с объектами. Но у такого подхода есть несколько серьёзных проблем.

Почему iterrows() плохо масштабируется

Главная проблема – потеря производительности.

Когда используется iterrows():
• каждая строка превращается в объект Series
• создаётся новый объект Python
• цикл выполняется на уровне Python

То есть мы фактически превращаем pandas в обычный for-цикл.
А pandas создан именно для векторных операций, которые выполняются гораздо быстрее.

Как это обычно можно переписать

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

Вместо цикла:
# медленный подход
for index, row in df.iterrows():
if row["score"] >= 90:
print(row["name"])
Можно сделать одну векторную операцию:
# быстрый и "пандовский" способ
high_scores = df[df["score"] >= 90]
print(high_scores["name"])

Что здесь происходит:
• создаётся логическая маска df["score"] >= 90
• pandas применяет её ко всему столбцу сразу
• никакого Python-цикла не требуется
На больших таблицах разница может быть в десятки раз по скорости.
Когда iterrows() всё же можно использовать
Иногда без него не обойтись.
Например:
• при сложной логике, которую трудно векторизовать
• при работе с внешними API
• при отладке данных
Но даже в этих случаях лучше сначала подумать, можно ли решить задачу через операции над колонками.

Главное правило

Если вы пишете iterrows() — почти всегда есть более быстрый и простой способ.
В pandas стоит мыслить не строками, а столбцами.
И именно это делает код:
• быстрее
• короче
• более «пандовским».