Методы списков, сортировка и списочные выражения

«Второй элемент» — это индекс 1: нумерация с нуля.

Добавить сразу три числа умеет extend(), а удвоить список — умножение на 2.

1. numbers[1] = 17 — замена по индексу.
2. numbers.extend([4, 5, 6]) — добавление трёх элементов.
3. del numbers[0] — удаление первого.
4. numbers *= 2 — удвоение.
5. numbers.insert(3, 25) — вставка по индексу.

numbers = [8, 9, 10, 11]

numbers[1] = 17            # второй элемент — это индекс 1
print(numbers)

numbers.extend([4, 5, 6])  # добавляем сразу три числа
print(numbers)

del numbers[0]
print(numbers)

numbers *= 2               # то же, что numbers = numbers * 2
print(numbers)

numbers.insert(3, 25)      # вставка сдвигает остальные вправо
print(numbers)

print(numbers)

Каждая операция меняет сам список, поэтому следующая работает уже с новым содержимым. Отсюда и разница между «вторым элементом» в начале и в конце: список успел перестроиться дважды.

Чтобы поменять элементы местами, нужны их индексы, а min() и max() дают значения.

Индекс значения находит метод index().

1. Читаем числа и переводим их из строк в числа.
2. Находим наименьшее и наибольшее значения, а по ним — их индексы.
3. Меняем элементы местами приёмом a, b = b, a.
4. Печатаем список через пробел распаковкой.

numbers = input().split()
for i in range(len(numbers)):
    numbers[i] = int(numbers[i])   # split() дал строки, нужны числа

smallest = numbers.index(min(numbers))   # индекс наименьшего
largest = numbers.index(max(numbers))    # индекс наибольшего

numbers[smallest], numbers[largest] = numbers[largest], numbers[smallest]

print(*numbers)

Перевод в числа здесь обязателен: у строк min() сравнивал бы по алфавиту, и в списке '10 9' наименьшим оказалось бы '10'. Строка '10' меньше строки '9', потому что первый символ 1 идёт раньше 9.

Искать подстроку 'a' в тексте нельзя — она есть в половине слов. Считать надо целые слова.

Целые слова даёт split(), а разницу в регистре снимает lower().

1. Приводим строку к нижнему регистру и разбиваем на слова.
2. Перебираем слова и считаем те, что равны a, an или the.
3. Печатаем результат с подписью.

words = input().lower().split()   # нижний регистр — чтобы The считалось наравне с the

count = 0
for word in words:
    if word == 'a' or word == 'an' or word == 'the':
        count += 1

print('Общее количество артиклей:', count)

Слова со знаками препинания — вроде plays, — артиклями не бывают, поэтому очищать их не нужно. А вот если бы считали, скажем, слово and, пришлось бы: and. не равно and.

Число n спрятано в первой строке после решётки — его достают срезом.

Где начинается комментарий, покажет find('#'); всё, что правее, отрезается срезом.

1. Первая строка: отбрасываем решётку срезом [1:] и переводим остаток в число.
2. n раз читаем строку и ищем в ней решётку.
3. Если решётка нашлась — оставляем всё, что левее неё.
4. Убираем концевые пробелы методом rstrip() и печатаем.

n = int(input()[1:])       # первая строка — решётка и число: срез убирает решётку

for i in range(n):
    line = input()
    sharp = line.find('#')
    if sharp != -1:        # -1 означает «решётки нет»
        line = line[:sharp]
    print(line.rstrip())   # убираем пробелы, оставшиеся перед комментарием

Строка, которая была комментарием целиком, превращается в пустую — её всё равно печатают, потому что в программе она занимала строку. А вот find() здесь безопаснее index(): у строки без комментария index() остановил бы программу ошибкой.

После split() в списке строки — сначала переведите их в числа, иначе сортировка пойдёт по алфавиту.

Второй раз сортировать заново не обязательно: у sort() есть параметр reverse.

1. Читаем строку, разбиваем и переводим элементы в числа.
2. Сортируем и печатаем.
3. Сортируем с reverse=True и печатаем снова.

numbers = input().split()
for i in range(len(numbers)):
    numbers[i] = int(numbers[i])

numbers.sort()
print(*numbers)

numbers.sort(reverse=True)   # тот же список, порядок обратный
print(*numbers)

Второй sort() работает уже с отсортированным списком — и это ничему не мешает. А вот numbers = numbers.sort() сломало бы всё: метод ничего не возвращает, и в переменной оказалось бы пустое значение.

Удалить первый символ строки умеет срез.

Выражение применяется к каждому слову: [… for word in keywords].

1. Срез word[1:] — это слово без первого символа.
2. Ставим его выражением списочного выражения.

keywords = ['False', 'True', 'None', 'and', 'with', 'as', 'assert', 'break',
            'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
            'finally', 'try', 'for', 'from', 'global', 'if', 'import', 'in',
            'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
            'return', 'while', 'yield']

new_keywords = [word[1:] for word in keywords]   # срез без первого символа
print(new_keywords)

Исходный список при этом не изменился — списочное выражение всегда создаёт новый. В этом его отличие от списочных методов, которые правят список на месте.

Длину строки даёт len().

Она и будет выражением в квадратных скобках.

1. Перебираем слова списка.
2. Для каждого берём len(word).

keywords = ['False', 'True', 'None', 'and', 'with', 'as', 'assert', 'break',
            'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
            'finally', 'try', 'for', 'from', 'global', 'if', 'import', 'in',
            'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
            'return', 'while', 'yield']

lengths = [len(word) for word in keywords]
print(lengths)

Обратите внимание: типы поменялись. Из списка строк получился список чисел — списочное выражение не обязано сохранять тип элементов.

Здесь нужен не только результат, но и отбор — то есть условие.

Условие пишется в конце выражения: [word for word in keywords if …].

1. Выражение — само слово, без изменений.
2. Условие — len(word) >= 5.

keywords = ['False', 'True', 'None', 'and', 'with', 'as', 'assert', 'break',
            'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
            'finally', 'try', 'for', 'from', 'global', 'if', 'import', 'in',
            'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
            'return', 'while', 'yield']

new_keywords = [word for word in keywords if len(word) >= 5]
print(new_keywords)

«Не менее пяти» — это >= 5, а не > 5: слово False длиной ровно пять символов и должно попасть в список. Такие границы стоит проверять на примере, а не на глаз.

Число само себя задом наперёд не читает — а вот строка умеет.

Переведите число в строку функцией str() и сравните её с развёрнутой копией [::-1].

1. Перебираем числа от 100 до 1000.
2. Каждое превращаем в строку.
3. Условие: строка совпадает со своим разворотом.

palindromes = [i for i in range(100, 1001) if str(i) == str(i)[::-1]]
print(palindromes)

Здесь два инструмента работают вместе: строковый разворот из шестого занятия и списочное выражение с условием. Число 1000 в диапазон входит, но палиндромом не является, так что на ответ это не влияет.

Список собирается одной строкой, а печатается циклом.

Квадрат — это i ** 2.

1. [i ** 2 for i in range(1, n + 1)] — готовый список квадратов.
2. Печатаем его элементы циклом, каждый на своей строке.

n = int(input())

squares = [i ** 2 for i in range(1, n + 1)]

for s in squares:
    print(s)

Разделение «собрать» и «показать» удобно: список можно сначала получить, а потом выводить как угодно — в столбик, через пробел или частями.

split() даёт список строк — перевод в число можно сделать прямо внутри списочного выражения.

Печать в одну строку — это end=' ' в цикле или распаковка.

1. [int(x) ** 3 for x in input().split()] — сразу и перевод, и возведение в куб.
2. Печатаем элементы через пробел.

cubes = [int(x) ** 3 for x in input().split()]

for c in cubes:
    print(c, end=' ')

В одном выражении здесь два действия: int() и ** 3. Это нормально, пока строка читается вслух: «взять каждый кусок, превратить в число и возвести в куб».

Разбить строку на слова умеет split().

А напечатать список в столбик — распаковка с sep.

1. input().split() даёт список слов.
2. print(*…, sep='\n') печатает их каждое с новой строки — и всё это помещается в одну команду.

print(*input().split(), sep='\n')

Та же задача уже встречалась на прошлом занятии — и решается так же. Это не недосмотр: короткие задачи полезно решать повторно, чтобы приём стал привычным.

Списочное выражение с условием отберёт нужные символы.

Собрать их в одну строку без пробелов поможет join() с пустым разделителем.

1. Отбираем символы, входящие в строку '0123456789'.
2. Склеиваем получившийся список пустым разделителем.

digits = [c for c in input() if c in '0123456789']

print(''.join(digits))

Пустая строка в роли разделителя — обычное дело: ''.join(...) просто склеивает всё подряд. Через print(*digits, sep='') вышло бы то же самое.

Условий два: число чётное и его квадрат не оканчивается на 4.

Проверьте себя на первом примере: квадрат двойки — 4, и он отбрасывается, хотя само число чётное.

1. Переводим введённое в список чисел.
2. Отбираем чётные: n % 2 == 0.
3. Из них оставляем те, у которых квадрат не оканчивается четвёркой: n ** 2 % 10 != 4.
4. Печатаем квадраты через пробел.

numbers = [int(x) for x in input().split()]

# отбираем чётные числа, но только те, чей квадрат не кончается на 4
squares = [n ** 2 for n in numbers if n % 2 == 0 and n ** 2 % 10 != 4]

print(*squares)

Условие задачи можно прочитать двояко: «числа, не оканчивающиеся на 4» или «квадраты, не оканчивающиеся на 4». Спор решают примеры: у первого из них в ответе нет числа 4 — квадрата двойки, — значит, проверяется именно квадрат. Когда условие допускает два чтения, примеры и есть точная формулировка.