Списочные выражения и вложенные списки

Списочное выражение – запись, которая строит новый список из элементов другого набора: [выражение for x in последовательность]. Читается «собрать выражение для каждого x из последовательности».

squares = []
for x in range(5):
    squares.append(x * x)

Эти три строки и [x * x for x in range(5)] дают один и тот же список [0, 1, 4, 9, 16]. Переменная x живёт только внутри выражения – наружу она не выходит.

Отсюда короткое чтение чисел, о котором шла речь в уроке 9.1: nums = [int(s) for s in input().split()] сразу даёт список чисел, без промежуточного parts.

print([x * x for x in range(5)])   # [0, 1, 4, 9, 16]

nums = [int(s) for s in input().split()]   # 4 8 15
print(nums)                        # [4, 8, 15]

words = ['кот', 'дом', 'лес']
print([len(w) for w in words])     # [3, 3, 3]
print([w.upper() for w in words])  # ['КОТ', 'ДОМ', 'ЛЕС']

if в списочном выражении может стоять в двух местах, и делает он разное:

Разница видна по результату: в первом случае список короче исходного, во втором – такой же длины. В первом if стоит в конце и работает как фильтр, во втором – в начале и требует else.

a = [3, -8, 5, -2, 7]

print([x for x in a if x > 0])         # [3, 5, 7] – отбор
print([x if x > 0 else 0 for x in a])  # [3, 0, 5, 0, 7]

# отбор и замена одновременно: отрицательные заменяем нулём
print([x if x > 0 else 0 for x in a if x != 5])
# [3, 0, 0, 7] – пять выброшено, остальные заменены

Списочное выражение – инструмент для одной простой операции над каждым элементом. Если внутри нужно несколько действий, вложенное условие, break или накопление другого рода (сумма, счётчик, строка), обычный цикл остаётся понятнее. Вложенное выражение из трёх условий читать тяжело, а развернуть его в цикл – минута работы.

Вложенный список – список, элементами которого служат другие списки. Двойная индексация a[i][j] означает: взять i-й элемент внешнего списка (строку), а из него – j-й элемент.

Журнал класса – четыре строки по три оценки:

len(journal) – число строк, len(journal[0]) – число столбцов. Второе работает, только если строки одинаковой длины; берут длину первой из них.

journal = [[5, 4, 3], [3, 3, 4], [5, 5, 5], [4, 2, 3]]
names = ['Аня', 'Борис', 'Вера', 'Глеб']

print(len(journal))     # 4 – строк
print(len(journal[0]))  # 3 – столбцов

print(journal[1])       # [3, 3, 4] – вторая строка целиком
print(journal[1][2])    # 4 – Борис, третья контрольная
print(names[1])         # Борис

journal[0][0] = 4       # исправили оценку Ани
print(journal[0])       # [4, 4, 3]

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

Сумма строки – просто sum(row). Сумма столбца требует цикла: столбцы в списке не хранятся отдельно, их приходится собирать из разных строк – journal[i][j] при постоянном j.

Напечатать строку через пробел можно print(*row): звёздочка раскладывает её в аргументы, как и у плоского списка.

total = 0
for row in journal:          # row – очередная строка
    total = total + sum(row)
print(total)                 # 46 – сумма всех оценок

for i in range(len(journal)):
    print(names[i], sum(journal[i]) / len(journal[i]))
# Аня 4.0 / Борис 3.3333... / Вера 5.0 / Глеб 3.0

# сумма столбца: внешний цикл – по столбцам, внутренний – по строкам
for j in range(len(journal[0])):
    s = 0
    for i in range(len(journal)):
        s = s + journal[i][j]
    print(s)                 # 17 14 15

for row in journal:
    print(*row)              # 5 4 3, затем 3 3 4 и так далее

Таблицу из нулей строят списочным выражением: [[0] * m for _ in range(n)] – n отдельных строк, в каждой m нулей. Имя _ здесь означает, что переменная цикла не нужна: строки одинаковые, номер не используется.

А вот запись [[0] * m] * n создаёт одну строку и n ссылок на неё. Внешний список из n элементов, но все они – один и тот же объект. Правка одной клетки меняет весь столбец во всех строках сразу.

Это та же ошибка из урока 9.1 (b = a вместо копии), только спрятанная в умножение.

n, m = 3, 4

table = [[0] * m for _ in range(n)]   # три разных строки
table[0][0] = 1
print(table)
# [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

bad = [[0] * m] * n                   # одна строка, n ссылок
bad[0][0] = 1
print(bad)
# [[1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]] – весь столбец

a.copy() и срез a[:] копируют только внешний список. Строки внутри остаются общими: копия – новая лента, в которой лежат ссылки на те же самые строки. Правка b[0][0] поэтому видна и в a.

Глубокая копия – копия, в которой скопированы и все вложенные объекты. Делается функцией deepcopy() из модуля copy.

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

Для плоского списка чисел хватает copy(): копировать там нечего, кроме самой ленты.

from copy import deepcopy

a = [[1, 2], [3, 4]]

b = a.copy()          # новый внешний список, строки общие
b[0][0] = 99
print(a)              # [[99, 2], [3, 4]] – правка видна в a
print(b)              # [[99, 2], [3, 4]]

a = [[1, 2], [3, 4]]
c = deepcopy(a)       # скопировано всё
c[0][0] = 99
print(a)              # [[1, 2], [3, 4]] – a не тронута
print(c)              # [[99, 2], [3, 4]]