Списки: добавление и удаление, вывод, split и join

Убрать нужно yellow и brown. Первое удаление верное — посмотрите, что стало со списком после него.

После первого del все элементы правее сдвинулись на одну позицию влево, и brown оказался не под шестым индексом, а под пятым.

1. del colors[2] убирает yellow — это верно.
2. В получившемся списке brown стоит под индексом 5, а не 6.
3. del colors[6] в исходном коде удаляет magenta — не тот цвет.

colors = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'brown', 'magenta']

del colors[2]   # убрали yellow — остальные сдвинулись влево
del colors[5]   # было colors[6]: brown теперь под пятым индексом

print(colors)

Это главная ловушка удаления по индексу: индексы «плывут» после каждого del. Когда удалений несколько, надёжнее идти с конца — тогда сдвиг не затрагивает ещё не удалённые элементы.

Четыре из пяти пунктов — это уже знакомые индексы и срезы.

«Содержит 5 и 17» — два условия через and, каждое проверяется оператором in.

1. Последний элемент — numbers[-1].
2. Обратный порядок — срез numbers[::-1].
3. Проверка: 5 in numbers and 17 in numbers; числа 17 в списке нет, поэтому ответ NO.
4. Без первого и последнего — срез numbers[1:-1].

numbers = [2, 6, 3, 14, 10, 4, 11, 16, 12, 5, 4, 16, 1, 0, 8, 16, 10, 10, 8, 5,
           1, 11, 10, 10, 12, 0, 0, 6, 14, 8, 2, 12, 14, 5, 6, 12, 1, 2, 10, 14,
           9, 1, 15, 1, 2, 14, 16, 6, 7, 5]

print(len(numbers))
print(numbers[-1])
print(numbers[::-1])

if 5 in numbers and 17 in numbers:
    print('YES')
else:
    print('NO')

print(numbers[1:-1])   # срез без первого и последнего элементов

Срез [1:-1] — типичный приём «отрезать края». Он не меняет исходный список: numbers остался прежним, а print() показал новый список.

Начинают с пустого списка — наполнять будем в цикле.

Каждую прочитанную строку добавляют методом append().

1. Читаем n.
2. Заводим пустой список.
3. n раз читаем строку и добавляем её в конец списка.
4. Печатаем список целиком.

n = int(input())

words = []                 # пустой список, который сейчас наполним
for i in range(n):
    words.append(input())

print(words)

Пара «пустой список плюс append() в цикле» — самый частый способ собрать данные. Обратите внимание: input() стоит прямо внутри append() — отдельная переменная тут ничего не добавляет.

Буквы идут подряд по кодам: chr(97) — это a, chr(98) — b.

Сколько раз повторить букву, зависит от её номера: первая — один раз, вторая — два.

1. Заводим пустой список.
2. Перебираем номера от 0 до 25.
3. Буква — это chr(97 + i), повторить её надо i + 1 раз.
4. Добавляем получившуюся строку в список.

letters = []

for i in range(26):
    letter = chr(97 + i)          # 97 — код буквы 'a'
    letters.append(letter * (i + 1))

print(letters)

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

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

Куб — это x ** 3.

1. Читаем n и заводим пустой список.
2. n раз читаем число, возводим в куб и добавляем результат.
3. Печатаем список.

n = int(input())

cubes = []
for i in range(n):
    x = int(input())
    cubes.append(x ** 3)

print(cubes)

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

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

Пар соседей на одну меньше, чем чисел.

1. Читаем все n чисел в список.
2. Перебираем индексы от 0 до n − 2.
3. Складываем numbers[i] и numbers[i + 1], добавляем сумму во второй список.

n = int(input())

numbers = []
for i in range(n):
    numbers.append(int(input()))

sums = []
for i in range(n - 1):        # пар соседей на одну меньше, чем чисел
    sums.append(numbers[i] + numbers[i + 1])

print(sums)

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

Удалять по одному в цикле опасно: после каждого удаления индексы сдвигаются.

del умеет работать со срезом, а у среза есть шаг.

1. Читаем числа в список.
2. Нечётные индексы — это срез [1::2]: начиная с первого, через один.
3. Удаляем весь срез одной командой.

n = int(input())

numbers = []
for i in range(n):
    numbers.append(int(input()))

del numbers[1::2]   # срез «с первого через один» — все нечётные индексы

print(numbers)

Попробуйте сделать это циклом — и наткнётесь ровно на ловушку из задачи 8.1: после первого же удаления половина индексов уедет. Срез удаляет всё разом, до всякого сдвига.

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

Формула переносится в код буквально: x ** 2 + 2 * x + 1.

1. Читаем n.
2. n раз читаем очередное число и сразу печатаем значение формулы.

n = int(input())

for i in range(n):
    x = int(input())
    print(x ** 2 + 2 * x + 1)

Список тут не нужен вовсе — и это стоит замечать. Заводить его «на всякий случай» вредно: чем меньше в программе хранится, тем меньше в ней может разъехаться.

Порядок менять нельзя — значит, сортировать список не надо. Нужно просто знать, какие два числа пропустить.

min() и max() дадут эти значения, а дальше остаётся вывести всё, кроме них.

1. Читаем все числа в список.
2. Находим наименьшее и наибольшее.
3. Перебираем список и печатаем те элементы, которые не равны ни одному из них.

n = int(input())

numbers = []
for i in range(n):
    numbers.append(int(input()))

smallest = min(numbers)
largest = max(numbers)

for x in numbers:
    if x != smallest and x != largest:
        print(x)

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

Чтобы понять, встречалась ли строка раньше, её надо где-то помнить.

Оператор in работает и со списком: if s not in seen.

1. Заводим список уже встреченных строк.
2. Читаем очередную строку.
3. Если её ещё не было — печатаем и добавляем в список.
4. Если была — пропускаем.

n = int(input())

seen = []                  # строки, которые уже встречались
for i in range(n):
    s = input()
    if s not in seen:
        print(s)
        seen.append(s)

Печать стоит внутри условия, а не после цикла, — поэтому порядок вывода совпадает с порядком ввода сам собой. Это и требовалось: «в том же порядке».

Строка превращается в список слов одним методом.

А вывести список в столбик можно распаковкой с параметром sep.

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

words = input().split()

print(*words, sep='\n')

Та же задача циклом заняла бы три строки — и это тоже верное решение. Распаковка выигрывает именно здесь, где все элементы печатаются одинаково.

Разбейте строку на части — получится список из трёх слов.

Первая буква слова — это его нулевой символ: parts[0][0].

1. input().split() даёт список из трёх слов.
2. Берём у каждого нулевой символ и переводим в верхний регистр.
3. Склеиваем их с точками.

parts = input().split()

# у каждого слова берём первую букву и делаем её заглавной
first = parts[0][0].upper()
second = parts[1][0].upper()
third = parts[2][0].upper()

print(first + '.' + second + '.' + third + '.')

Запись parts[0][0] — это два обращения подряд: сначала берём слово из списка, потом символ из слова. Читается справа налево, но пишется слева направо.

Разделитель здесь задан явно, значит, у split() будет параметр.

Одиночная обратная косая черта в кавычках — управляющий символ. Чтобы получить её саму, пишут две.

1. Читаем строку.
2. Разбиваем её split('\\') — две косые черты в коде означают одну настоящую.
3. Печатаем части в столбик распаковкой.

path = input()

# '\\' в коде — это один символ обратной косой черты
parts = path.split('\\')

print(*parts, sep='\n')

Обратная косая черта — вечный источник путаницы: в исходном коде её пишут дважды, а на экране она одна. Проверить себя просто: len('\\') равно единице.

Числа приходят одной строкой — их надо разделить.

После split() элементы списка — строки, а умножать на строку нельзя: нужен int().

1. Разбиваем строку на список.
2. Перебираем элементы списка.
3. Каждый переводим в число и печатаем строку из такого количества плюсов.

numbers = input().split()

for n in numbers:
    print('+' * int(n))   # после split() элементы — строки, нужен int()

Забытый int() тут не сломает программу молча: '+' * '5' — ошибка, и Python скажет об этом сразу. Это тот редкий случай, когда язык ловит промах за вас.

Разделитель — точка, и её надо указать явно.

Проверять надо все четыре числа, а ответ «НЕТ» достаточно получить один раз — это задача на сигнальную метку.

1. Разбиваем строку по точке.
2. Ставим флажок «пока всё хорошо».
3. Перебираем части, переводим каждую в число и проверяем границы.
4. Печатаем ответ по флажку.

parts = input().split('.')

correct = True
for part in parts:
    number = int(part)
    if number < 0 or number > 255:
        correct = False

if correct:
    print('ДА')
else:
    print('НЕТ')

Флажок нужен именно потому, что печатать ответ внутри цикла нельзя: «ДА» станет известно только после проверки всех четырёх чисел. Тот же приём, что и в задаче про чётные числа на четвёртом занятии.

Собирает строку из частей метод join(), и вызывается он у разделителя.

А части здесь — символы строки. Отдельно разбивать её не нужно: join() работает и со строкой.

1. Читаем текст и разделитель.
2. Вызываем join() у разделителя, передав ему текст.
3. Печатаем результат.

text = input()
separator = input()

# join() вызывается у разделителя, а получает то, что надо склеить
print(separator.join(text))

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

Пара — это два элемента с разными индексами. Значит, перебирать надо пары индексов.

Чтобы не посчитать одну и ту же пару дважды, второй индекс всегда берут больше первого.

1. Разбиваем строку на список.
2. Внешний цикл идёт по индексу i, внутренний — по j, начиная с i + 1.
3. Если элементы равны — увеличиваем счётчик.
4. Печатаем счётчик.

numbers = input().split()

count = 0
for i in range(len(numbers)):
    for j in range(i + 1, len(numbers)):   # j всегда правее i: пара считается один раз
        if numbers[i] == numbers[j]:
            count += 1

print(count)

Проверьте себя на пяти тройках: пар получается 10 — это все сочетания из пяти по два. Начни внутренний цикл с нуля, счёт вышел бы вдвое больше, да ещё и каждый элемент составил бы пару сам с собой.