Методы списков и встроенные функции

append(x) – дописывает один элемент x в конец списка. Длина становится на 1 больше, номера старых элементов не меняются.

Три способа добавить различаются тем, сколько элементов добавляется и куда:

Главная путаница – append против extend. a.append([7, 8]) добавит один элемент, и этим элементом будет целый список. a.extend([7, 8]) добавит два элемента.

insert() меняет номера всех элементов правее точки вставки. Индекс за границей ошибки не даёт – значение прижимается к краю: insert(100, x) допишет в конец.

marks = [5, 4]
marks.append(3)          # [5, 4, 3]
marks.extend([5, 4])     # [5, 4, 3, 5, 4]
marks.insert(1, 2)       # [5, 2, 4, 3, 5, 4]
print(marks)

a = [1, 2]
a.append([7, 8])
print(a, len(a))         # [1, 2, [7, 8]] 3 – один элемент

b = [1, 2]
b.extend([7, 8])
print(b, len(b))         # [1, 2, 7, 8] 4 – два элемента

names = ['Аня', 'Вера']
names.insert(1, 'Борис')
print(names)             # ['Аня', 'Борис', 'Вера']
names.insert(100, 'Яна')
print(names[-1])         # Яна – слишком большой индекс
                         # прижимается к концу

У строки метод не мог изменить объект – строка неизменяема, поэтому s.upper() строит и возвращает новую строку, и пишут s = s.upper().

Список меняется на месте, и возвращать методу нечего. Поэтому append(), extend(), insert(), sort(), reverse(), clear() всегда дают None.

None – значение «ничего»: так метод сообщает, что результата нет, потому что работа сделана прямо в списке.

Ошибка, которую делают по одному разу: a = a.append(5). Список пополнится, но в a тут же положат None, и имя списка потеряно. Следующая строка упадёт с TypeError.

Правило: у строки – s = s.метод(), у списка – просто a.метод() отдельной строкой.

s = 'привет'
print(s.upper())     # ПРИВЕТ – вернулся новый объект
print(s)             # привет – исходная не изменилась

a = [1, 2, 3]
print(a.append(4))   # None – возвращать нечего
print(a)             # [1, 2, 3, 4] – но список изменился

a = a.append(5)      # типичная ошибка
print(a)             # None – имя списка потеряно
print(len(a))        # TypeError: object of type 'NoneType'
                     # has no len()

Выбор способа – это выбор того, что известно об удаляемом элементе:

pop() – единственный метод списка, который возвращает удалённое значение: иначе оно пропало бы безвозвратно. remove() удаляет только первое совпадение, остальные такие же остаются.

clear() опустошает тот же список, а a = [] создаёт новый. Второе имя, если оно было, увидит разницу: после clear() – пустоту, после a = [] – старый полный список.

a = [10, 20, 30, 20]

print(a.pop(0))   # 10 – pop отдаёт удалённое
print(a)          # [20, 30, 20]
print(a.pop())    # 20 – без аргумента последний
print(a)          # [20, 30]

a.remove(20)      # первое совпадение
print(a)          # [30]
a.remove(99)      # ValueError: list.remove(x): x not in list

a = [10, 20, 30]
del a[1]
print(a)          # [10, 30]
a.clear()
print(a)          # []

• x in a отвечает True или False и ничего не ищет внутри элементов;
• a.index(x) возвращает номер первого совпадения, а если значения нет – останавливает программу с ValueError;
• a.count(x) считает, сколько раз значение встретилось.

Из-за ValueError у index() обычный порядок такой: сначала проверить if x in a, и только внутри условия звать index().

С find() у строки та же работа устроена иначе: там «не найдено» – это -1, а не ошибка. У списка такого значения нет, потому что -1 – законный индекс.

a = [10, 20, 30, 20]
print(20 in a)      # True
print(99 in a)      # False
print(a.count(20))  # 2
print(a.index(30))  # 2

a.index(99)         # ValueError: 99 is not in list

if 99 in a:         # сначала проверка, потом index
    print(a.index(99))

У цикла for есть внутренний счётчик позиции. После remove() все элементы справа сдвигаются влево, а счётчик всё равно растёт – и перескакивает через элемент, вставший на освободившееся место. Программа при этом не падает, просто делает не то, что имелось в виду.

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

• идти по копии, а менять оригинал: for x in nums[:];
• ничего не удалять, а собирать новый список через append().

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

# так – неправильно
nums = [1, 0, 0, 3]
for x in nums:
    if x == 0:
        nums.remove(x)
print(nums)     # [1, 0, 3] – один нуль уцелел

# идём по копии, меняем оригинал
nums = [1, 0, 0, 3]
for x in nums[:]:
    if x == 0:
        nums.remove(x)
print(nums)     # [1, 3]

# или собираем новый список
nums = [1, 0, 0, 3]
result = []
for x in nums:
    if x != 0:
        result.append(x)
print(result)   # [1, 3]

Это не методы списка: их вызывают от имени функции, и они работают с любой последовательностью.

Среднее арифметическое готовой функции не имеет: это sum(a) / len(a).

На пустом списке обе крайности – ошибки: max([]) даёт ValueError, а деление на len([]) – ZeroDivisionError. Поэтому перед средним список проверяют на пустоту.

a = [5, 4, 3]
print(len(a))          # 3
print(sum(a))          # 12
print(min(a))          # 3
print(max(a))          # 5
print(sum(a) / len(a)) # 4.0

print(sorted(a))       # [3, 4, 5] – новый список
print(a)               # [5, 4, 3] – исходный не тронут

print(max([]))         # ValueError: max() arg is an empty
                       # sequence
empty = []
print(sum(empty) / len(empty))   # ZeroDivisionError

if len(empty) > 0:     # а так – без ошибки
    print(sum(empty) / len(empty))

Сортируют одинаково, различаются двумя вещами:

Оба умеют reverse=True – по убыванию. Это параметр, а не функция: a.sort(reverse=True) пишется прямо в скобках.

Сортировать можно только однотипные значения: sorted([3, 'a']) даёт TypeError – число со строкой не сравнить.

Развернуть список можно и без сортировки: a.reverse() переставляет элементы на месте, а a[::-1] даёт развёрнутую копию и исходный список не трогает.

a = [3, 1, 2]
print(sorted(a))         # [1, 2, 3]
print(a)                 # [3, 1, 2] – функция не тронула

a.sort()
print(a)                 # [1, 2, 3] – метод перестроил сам
print(a.sort())          # None

a.sort(reverse=True)
print(a)                 # [3, 2, 1]

a.reverse()
print(a)                 # [1, 2, 3] – на месте
print(a[::-1])           # [3, 2, 1] – копия, a не изменился

max() отдаёт наибольшее значение, но не его номер. Если нужен индекс максимума, пишут цикл: запоминают лучший индекс и сравнивают с ним каждый следующий элемент.

Строгое > оставляет первый максимум: равный следующий элемент условие не проходит. Нужен последний – ставят >=.

Вторая задача – все позиции максимума. Здесь сначала узнают само значение через max(), а потом перебирают индексы и печатают подходящие.

Третья – первый подходящий элемент. Его ищут с break: как только нашли, дальше смотреть незачем. Признак «не нашли» – None: число тут не годится, у списка законны и отрицательные индексы.

# индекс максимума: строгое > оставляет первый
a = [5, 4, 3, 5, 4]
best = 0
for i in range(1, len(a)):
    if a[i] > a[best]:
        best = i
print(best, a[best])     # 0 5

# все позиции максимума
best = max(a)
for i in range(len(a)):
    if a[i] == best:
        print(i, end=' ')    # 0 3
print()

# первый отрицательный: break плюс флаг «не нашли»
temps = [3, 5, -1, 4]
found = None                 # пока не нашли
for i in range(len(temps)):
    if temps[i] < 0:
        found = i
        break
if found is None:
    print('отрицательных нет')
else:
    print(found)             # 2