Классификация символов, форматирование, Unicode и списки

Чтобы isalnum() дал False, достаточно одного символа, который не буква и не цифра.

Чтобы islower() стал False, нужна заглавная буква; чтобы isupper() стал True — убрать единственную строчную.

1. isalnum() было True — добавляем любой знак, например !.
2. isalpha() было False из-за цифр — убираем цифры.
3. isdigit() было False из-за букв — оставляем только цифры.
4. islower() было True — делаем одну букву заглавной.
5. isupper() было False из-за строчной b — делаем её заглавной.
6. isspace() было False из-за букв — оставляем одни пробелы.

# 7.1.1 — под каждую проверку своя строка
print('aabbAA111ccDDaa!'.isalnum())   # добавили знак → False
print('aabbAAccDDaa'.isalpha())      # убрали цифры → True
print('111'.isdigit())               # оставили цифры → True

# 7.1.2
print('aaBb!@#$11cc'.islower())      # одна заглавная → False

# 7.1.3
print('AAB!@#$11CC'.isupper())       # исправили строчную b → True

# 7.1.4
print('     '.isspace())             # только пробелы → True

Задача не про код, а про точное чтение описания: islower() и isupper() не обращают внимания на цифры и знаки, а isalnum() — обращает. Одно лишнее слово в описании метода меняет ответ.

Заполнители пронумерованы: {0}, {1}, {2} — значит, значения встанут в том же порядке, в каком переданы.

Метод применяется к строке: s.format(...).

1. {0} — год, {1} — количество, {2} — название валюты.
2. Передаём их методу в этом же порядке.

s = 'In {0}, someone paid {1} {2} for two pizzas.'
print(s.format(2010, '10k', 'Bitcoin'))

Число 2010 передано числом, а не строкой, — format() сам превратит его в текст. В этом и удобство: str() писать не приходится.

Перед открывающей кавычкой нужна буква f.

В скобках пишутся имена переменных, а не номера.

1. Ставим f перед строкой.
2. В первый заполнитель пишем year, во второй amount, в третий currency.

currency = 'Bitcoin'
amount = '10K'
year = 2010

print(f'In {year}, someone paid {amount} {currency} for two pizzas.')

Порядок переменных в объявлении и в строке разный — и это не мешает: f-строка подставляет по имени, а не по очереди. С format() пришлось бы следить за номерами.

Коды идут подряд — значит, обычный range() от a до b включительно.

Чтобы символы печатались в одну строку, нужен end=' '.

1. Перебираем коды от a до b включительно.
2. Каждый переводим в символ функцией chr() и печатаем.

a = int(input())
b = int(input())

for code in range(a, b + 1):
    print(chr(code), end=' ')

Попробуйте задать диапазон 1040–1071 — получите русский алфавит заглавными буквами. Латиница, кириллица и цифры лежат в таблице сплошными кусками, и это часто выручает.

Здесь нужны сами символы, а не их номера в строке.

Каждый символ переводится в код функцией ord().

1. Перебираем символы строки.
2. Печатаем ord(c) через пробел.

s = input()

for c in s:
    print(ord(c), end=' ')

В примере хорошо виден код 32 — это пробел. Пробел ничем не отличается от других символов: у него есть код, он занимает место в строке и участвует в переборе.

Нужная последовательность уже есть — её даёт range().

Осталось превратить её в список функцией list().

1. range(1, n + 1) — числа от 1 до n включительно.
2. list(...) делает из них список, и print() печатает его со скобками и запятыми.

n = int(input())

print(list(range(1, n + 1)))

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

Алфавит можно просто написать строкой — двадцать шесть букв подряд.

Первые n символов даёт срез, а список из них — функция list().

1. Берём строку с алфавитом.
2. Отрезаем первые n символов срезом [:n].
3. Превращаем в список.

n = int(input())
alphabet = 'abcdefghijklmnopqrstuvwxyz'

print(list(alphabet[:n]))

Алфавит можно было бы и не писать руками, а собрать через chr(ord('a') + i) в цикле. Но когда данные короткие и известны заранее, написать их прямо — честнее и понятнее, чем вычислять.

min() и max() принимают не только несколько аргументов, но и список целиком.

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

1. min(numbers) — наименьший элемент, max(numbers) — наибольший.
2. Печатаем их сумму.

numbers = [12.5, 3.1415, 2.718, 9.8, 1.414, 1.1618, 1.324]

print(min(numbers) + max(numbers))

На третьем занятии min() принимал числа через запятую, а здесь — один список. Это одна и та же функция: ей всё равно, перечислили вы значения или отдали их одним списком.

Среднее — это сумма, делённая на количество.

И сумму, и количество считают готовые функции.

1. sum(evens) — сумма всех элементов.
2. len(evens) — сколько их.
3. Делим одно на другое.

evens = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

average = sum(evens) / len(evens)
print(average)

Деление здесь обычное, а не целочисленное: среднее почти всегда дробное. Даже когда оно выходит ровным, как здесь, print() покажет 11.0 — признак того, что тип вещественный.

Срез списка пишется так же, как срез строки.

Левую границу можно опустить.

1. primes[:6] — первые шесть элементов.
2. Результат среза — тоже список, поэтому печатается со скобками.

primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]

print(primes[:6])

Срез строки давал строку, срез списка даёт список — правило одно: срез возвращает тот же тип, что и исходная последовательность.

Разворачивает последовательность отрицательный шаг среза.

Он работает со списком так же, как со строкой.

1. languages[::-1] — список в обратном порядке.
2. Печатаем результат.

languages = ['Chinese', 'Spanish', 'English', 'Hindi', 'Arabic', 'Bengali', 'Portuguese', 'Russian', 'Japanese', 'Lahnda']

print(languages[::-1])

Срез не меняет исходный список, а создаёт новый — в languages порядок остался прежним. На девятом занятии появится метод reverse(), который, наоборот, переворачивает список на месте.

Посмотрите на нужный список по частям: сколько раз повторяется каждый кусок?

[1, 2, 3] идёт дважды, шестёрка — девять раз, а третий список — один.

1. Первый кусок: numbers1 * 2.
2. Второй: numbers2 * 9.
3. Третий: numbers3 как есть.
4. Склеиваем всё через +.

numbers1 = [1, 2, 3]
numbers2 = [6]
numbers3 = [7, 8, 9, 10, 11, 12, 13]

print(numbers1 * 2 + numbers2 * 9 + numbers3)

Умножение списка на число — самый короткий способ получить повторяющиеся элементы. Особенно часто пишут [0] * n — список из n нулей, заготовку под будущие значения.

Ступени отличаются только отступом: у каждой следующей его на два пробела больше. У самой верхней стойки | нет — ей не к чему примыкать.

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

1. Лесенка — десять строк: у верхней ступени только полка _, у остальных стойка и полка |_, и каждая следующая на два пробела правее.
2. Список заводится сразу нужной длины ([''] * 12), а строки в нём заменяются по индексу: двух лишних строк в начале как раз хватает человечку на первой и второй ступени.
3. Ноги приклеиваются прямо к строке своей ступени — человечек встаёт на её полку.
4. Туловище идёт строкой выше и заканчивается на один символ левее ног, голова — ещё строкой выше и вровень с ногами. Нужное число пробелов считается по длине уже готовой строки.
5. Пустые строки, оставшиеся над человечком, не печатаются.

print('На какой ступени стоит человечек? Введите число от 1 до 10:')
step = int(input())

person = ['()', '/()\\', '/\\']       # голова, туловище с руками, ноги

# двенадцать строк: десять ступеней и две про запас — на них встанет
# человечек, если он стоит на первой или второй ступени
rows = [''] * 12

for i in range(1, 11):
    if i == 1:
        rows[i + 1] = ' _'            # у верхней ступени стойки нет
    else:
        rows[i + 1] = ' ' * 2 * (i - 1) + '|_'

# ноги приклеиваются к самой ступени, туловище и голова — на строки выше
rows[step + 1] = rows[step + 1] + person[2]
rows[step] = rows[step] + ' ' * (2 * step - 1 - len(rows[step])) + person[1]
rows[step - 1] = rows[step - 1] + ' ' * (2 * step - len(rows[step - 1])) + person[0]

for row in rows:
    if row != '':                     # пустые строки над человечком не печатаем
        print(row)

Обратите внимание на '/()\\': чтобы напечатать одну обратную косую черту, в коде её пишут дважды. Одиночная \ — управляющий символ, как в \n. И на то, зачем в списке две лишние строки: человечку надо куда-то поместиться над лесенкой, и завести это место заранее проще, чем разбирать два особых случая.

Обмен двух элементов пишется одной строкой: a[j], a[j + 1] = a[j + 1], a[j].

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

1. Получаем случайный список функцией random.sample().
2. Внешний цикл делает проходы — их нужно не больше, чем len(x) - 1.
3. Внутренний цикл сравнивает соседей и меняет их местами, если левый больше правого.
4. Каждый обмен отмечаем флажком; если за проход обменов не было, выходим по break.
5. После каждого прохода печатаем список.

import random

numbers = random.sample(range(0, 10), 6)   # шесть разных случайных чисел
print('исходный список:', numbers)

for i in range(len(numbers) - 1):
    swapped = False                        # обменов на этом проходе ещё не было

    # с каждым проходом хвост списка уже упорядочен, и его можно не трогать
    for j in range(len(numbers) - 1 - i):
        if numbers[j] > numbers[j + 1]:
            numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
            swapped = True

    print(f'проход {i + 1}: {numbers}')

    if not swapped:                        # список уже отсортирован
        break

Обмен через кортеж — a, b = b, a — тот самый приём со второго занятия. Без него понадобилась бы третья переменная: присвоив numbers[j] = numbers[j + 1], старое значение вы бы уже потеряли.