Последовательности и циклы

В программировании существует весьма востребованная задача: хранить и обрабатывать наборы данных, объединённых общим смыслом.

Например, финтес-трекер хранит число пройденных шагов за каждый день недели. Простейший путь — сохранить данные за каждый день в отдельные переменные:

Скопировать кодPYTHON
monday_steps = 12000
tuesday_steps = 9000
wednesday_steps = 10000
thursday_steps = 2500
friday_steps = 14000
saturday_steps = 8903
sunday_steps = 9000

Сколько же переменных придётся создать, чтобы передать данные за месяц или за год! Получится путано, громоздко и нечитаемо. Гораздо удобнее сохранить весь набор данных в одну переменную с понятным объединяющим названием.

Скопировать кодPYTHON
week_steps = [12000, 9000, 10000, 2500, 14000, 8903, 9000]

Такие наборы данных, присвоенные одной переменной (сохранённые в один объект), называются коллекциями.

Упорядоченные и неупорядоченные последовательности

Коллекции подразделяют на упорядоченные и неупорядоченные.

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

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

Знакомство с коллекциями начнём с последовательностей.

Виды последовательностей в Python

В Python определены несколько типов последовательностей (Sequence Type):

list – список;
tuple – кортеж;
range – диапазон.

Подклассы последовательностей:

str — строки (Text Sequence Type );
Бинарные списки (Binary Sequence Types):
- bytes – байты;
- bytearray – массивы байт;
- memoryview – специальные объекты для доступа к внутренним данным объекта через буфер обмена памяти.

Каждый тип имеет индивидуальные особенности; но все эти коллекции не относились бы к одному виду, если бы не имели чего-то общего.

Общие особенности и методы последовательностей

В общем виде вы уже знакомы с последовательностями, а со строками и списками успешно поработали. На них и разберём те методы и свойства, которые доступны для разных типов последовательностей.

Адресация элементов

Доступ к значениям элементов последовательности можно получить через их индекс — целое число, обозначающее позицию элемента.

Отсчёт индексов начинается с нуля.

Скопировать кодPYTHON
# Последовательность типа list (список); 
# значения элементов списка - числа типа float.
movie_ratings = [4.7, 5.0, 4.3, 3.8]

# Последовательность типа list (список); 
# значения элементов списка - строки (str)
movies = ['Матрица', 'Хакеры', 'Трон']

# Последовательность типа cтрока (str); 
# элементы этой последовательности - символы, составляющие строку
name_movie = 'Джонни Мнемоник' 

# Последовательности могут иметь элементы разных типов
# Например, одновременно элемент типа str и float
movie_info = ['Трон', 4.7]
# Элементами последовательности могут быть другие последовательности
movies_info = [['Трон', 4.7], ['Хакеры', 5.0], ['Матрица', 4.5]]

# Чтобы получить значение определённого элемента, 
# его индекс следует указать в квадратных скобках после имени последовательности.
print(movie_ratings[2])
# Вывод в терминал: 4.3

print(name_movie[0])
# Вывод в терминал: Д

# При попытке обратиться несуществующему элементу интерпретатор вернет ошибку:
print(movies[10])
# Вывод в терминал: IndexError: list index out of range

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

Скопировать кодPYTHON
Д
о
м
и
к

 
name_movie = 'Джонни Мнемоник'
print(name_movie[0])
print(name_movie[2])
print(name_movie[10])
print(name_movie[5])
print(name_movie[-1])

Сравнение последовательностей

При сравнении последовательностей поочерёдно сравниваются элементы с одинаковыми индексами, и при первом же различии определяется результат сравнения.

Сначала сравниваются элементы с индексом 0, и если они равны, сравниваются следующие два элемента и так далее, пока не будет исчерпана любая последовательность.

Результатом сравнения будет логическое значение True или False.

Скопировать кодPYTHON
print([1, 2, 3] < [1, 2, 4])
# Вывод в терминал: True

Выражение, переданное в print() — истинно. В обеих последовательностях элементы с индексами 0 и 1 равны, а элемент с индексом 2 в первой последовательности меньше соответствующего элемента во второй последовательности. Сравнение этих элементов и определило результат сравнения списков.

При сравнении строк принимаются во внимание символы и их регистр. Все текстовые символы (буквы, цифры, знаки препинания, пробел, иероглифы) имеют числовую кодировку. На основе этой кодировки и происходит арифметическое сравнение строк. Заглавные и строчные буквы — это разные символы, соответственно, и кодировка у них разная.

Группы символов можно распределить по возрастанию их числовых кодов примерно так:

спецсимволы, знаки препинания и цифры: начинается с 32 (это числовое значение символа «пробел».
латиница — заглавные буквы: A = 65;
латиница — строчные буквы: a = 97;
расширенная латиница, диакретические знаки, греческое письмо...
кириллица — заглавные буквы: А = 1040;
кириллица — строчные буквы: а = 1072;
...

Цифровой символ условно меньше, чем любой алфавитный символ. Алфавитный символ в верхнем регистре условно меньше, чем алфавитные символы в нижнем регистре, а кириллическая А «больше», чем a в латинице (хотя если взять оба символа из латиницы, то выражение 'A' < 'a' вернёт True).

Скопировать кодPYTHON
print('Слон' < 'слон')
# Вывод в терминал: True
# Элемент с индексом 0 первой строки - это буквенный символ в верхнем регистре,
# его числовой код меньше той же буквы в нижнем регистре

print('1b' > 'fb')
# Вывод в терминал: False
# Элемент с индексом 0 первой строки - цифра. Её числовой код меньше, чем у букв.

Длина последовательности при сравнении не имеет значения. Как только в последовательности Python найдёт неравные элементы, их отношение и определит результат сравнения:

Скопировать кодPYTHON
print('a' < 'ADC')
# Вывод в терминал: False

print([1, 2, 4] > [1, 2, 3, 4])
# Вывод в терминал: True

Коды символов можно найти в таблицах кодировок Unicode, а в Python эти коды можно получить через функцию ord():

Скопировать кодPYTHON
print(ord('Ф'))
# Вывод в терминал: 1060

Важно отметить, что операторы < , >, <=, >= поддерживаются только при сравнении последовательностей одного типа и однотипных элементов в этих последовательностях.

Каким будет ответ при сравнении [10, 'one'] > ['one', 10]?

True

Сравнение объектов различных типов с помощью операторов < или > допустимо при условии, что объекты имеют соответствующие методы сравнения. А в предложенных списках элементы с одинаковыми индексами имеют разный тип.

False

TypeError: '>' not supported between instances of 'int' and 'str'

Верно: сравнивать строки с числами — это как сравнивать тёплое с мягким: получить корректный ответ невозможно.

Что вернёт операция сравнения?

Скопировать кодPYTHON
first = [15, 2, '11', 10]
second = [15, 2, '101', 17]

print(first < second)

True

Неверно. Элементы first[2] и second[2] — строки, а строки сравниваются по элементам. Элемент с индексом 1 в строке first[2] больше элемента с индексом 1 в строке second[2]. Значит, список first больше списка second.

False

Совершенно верно! Вам удалось обойти капканы. Элементы first[2] и second[2] — строки, а строки сравниваются по элементам. Элемент с индексом 1 в строке first[2] больше элемента с индексом 1 в строке second[2]. Значит, список first больше списка second.

Наименьшее и наибольшее значение элементов последовательности

В последовательностях, содержащих элементы одного типа, можно найти элементы с наименьшим и наибольшим значением. Для этого применяют встроенные методы min() и max().

Скопировать кодPYTHON
my_string = '12345'
print(max(my_string))
# Вывод в терминал: 5

my_list = ['abc', 'Abc']
print(min(my_list))
# Вывод в терминал: Abc

«Под капотом» функции min() и max() применяются операторы > и <, поэтому ограничение на сравнение элементов разных типов действуют и для них.

Скопировать кодPYTHON
my_list = ['123', '456', 789]
print(max(my_list))

# Вывод в терминал:
# TypeError: '>' not supported between instances of 'int' and 'str'
# Нельзя сравнивать числа со строками (даже если строки притворяются числами).

Слияние (конкатенация)

Конкатенация (объединение двух последовательностей в одну) выполняется с помощью оператора +. Объединять возможно только последовательности одного типа.

Результатом конкатенации будет новый объект.

Скопировать кодPYTHON
first_baggage_list = ['Диван', 'Чемодан', 'Саквояж', 'Картина']

second_baggage_list= ['Корзина', 'Картонка', 'Маленькая собачонка']

full_baggage_list = first_baggage_list + second_baggage_list
print(full_baggage_list)
# Вывод в терминал: 
# ['Диван', 'Чемодан', 'Саквояж', 'Картина', 'Корзина', 'Картонка', 'Маленькая собачонка']

Повторение

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

Это приведёт к созданию нового объекта, в котором элементы исходной последовательности будут повторяться указанное число раз.

Скопировать кодPYTHON
pump = 'насос' * 4
print(pump)
# Вывод в терминал: насоснасоснасоснасос

small_baggage_list = ['Корзина', 'Картонка', 'Маленькая собачонка']
double_baggage_list = small_baggage_list * 2
print(double_baggage_list)

# Вывод в терминал:
['Корзина', 'Картонка', 'Маленькая собачонка', 'Корзина', 'Картонка', 'Маленькая собачонка']

Количество элементов последовательности

Чтобы узнать количество элементов последовательности — применяют встроенный метод len().

Скопировать кодPYTHON
movies = ['Матрица', 'Хакеры', 'Трон', 'Тихушники', 'Сеть']
print(len(movies))
# Вывод в терминал: 5

Количество элементов последовательности — пять: подсчёт элементов последовательности начинается с единицы. А индекс последнего элемента последовательности — 4: movies[4] == 'Сеть', ведь отсчёт индексов начинается с нуля.

Почти все путаются в этом.

Наличие элемента в последовательности

Python позволяет узнать, есть ли определённый элемент в последовательности. Для этого применяют оператор in, он возвращает True или False.

Скопировать кодPYTHON
movie_ratings = [4.7, 5.0, 4.3, 3.1]
print(4.7 in movie_ratings)
# Вывод в терминал: True

name_movie = 'Джонни Мнемоник'
print('ж' in name_movie)
# Вывод в терминал: True

С помощью оператора in можно проверить и отсутствие элемента в последовательности:

Скопировать кодPYTHON
full_baggage_list = ['Диван', 'Чемодан', 'Саквояж', 'Картина', 'Корзина', 'Картонка']

# Если собачонки нет
if 'Маленькая собачонка' not in full_baggage_list:
    # ...устраиваем скандал:
    print('— Товарищи! Где собачонка?')

Срезы

Из последовательности можно извлечь набор элементов по определённым условиям. Например, можно получить из исходной последовательности все элементы с индексами от 5 до 10 или взять каждый второй элемент последовательности.

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

Чтобы из последовательности sequence получить срез, в который войдут элементы, расположенные один за другим, применяют синтаксис sequence[start:end], где start и end — индексы элементов, определяющие диапазон, из которого будет взят срез.

Скопировать кодPYTHON
name_movie = 'Джонни Мнемоник'
print(name_movie[2:10]) # В терминал будут выведены символы со 2 по 9
# Вывод в терминал: онни Мне

В этом примере в терминал вернется набор элементов с индексами, которые можно описать математическим выражением 2 ≤ index < 10: элемент с индексом 10 не будет включен в срез.

В ситуациях, когда конечный индекс указывается явно — элемент с этим индексом не включается в срез.

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

Скопировать кодPYTHON
name_movie = 'Джонни Мнемоник'
# Взять срез с седьмого элемента и до конца последовательности
print(name_movie[7:])
# Вывод в терминал: Мнемоник

name_movie = 'Джонни Мнемоник'
# Взять срез от начала последовательности до шестого элемента (не включая шестой)
print(name_movie[:6])
# Вывод в терминал: Джонни

Чтобы получить срез из элементов, расположенных с определённым шагом, применяют синтаксис sequence[start:end:step]

Скопировать кодPYTHON
movies = ['Матрица', 'Хакеры', 'Трон', 'Тихушники', 'Сеть']
print(movies[0:5:2])
# Вывод в терминал: ['Матрица', 'Трон', 'Сеть']

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

Скопировать кодPYTHON
movies = ['Матрица', 'Хакеры', 'Трон', 'Тихушники', 'Сеть']
# Шаг должен иметь отрицательное зачение
print(movies[5:0:-1])
# Вывод в терминал: ['Сеть', 'Тихушники', 'Трон', 'Хакеры']

# Можно не указывать границы, а задать только отрицательное значение шага
print(movies[::-1])
# Вывод в терминал: ['Сеть', 'Тихушники', 'Трон', 'Хакеры', 'Матрица']
# Инвертирован весь список

Соберите и напечатайте словосочетание «ты программист» из строк a, b и c, используя срезы с двумя и тремя параметрами. Словосочетание должно начинаться с маленькой буквы.

 
a = 'Роботы стали важны'
b = 'в период'
c = 'эмиграции c Терры'
​
print(a[4:7]+b[2:7:2]+c[3:6]+c[1]*2+a[11]+a[7]+a[4])

Принцип DRY (Don't repeat yourself) не рекомендует повторять в программе однотипный код: в ином случае программа раздуется и станет неуправляемой.

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

Скопировать кодPYTHON
rating1 = 4.7
rating2 = 5.0
rating3 = 4.3
rating4 = 3.1

# Дальше - код обработчика
...

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

Скопировать кодPYTHON
movie_ratings = [4.7, 5.0, 4.3, 3.1]

if movie_ratings[0] > 4.7:
    # Код обработчика.
    ...

if movie_ratings[1] > 4.7:
    # Код обработчика, такой же, как и для предыдущего элемента.
    ...

# И так далее.
# Тоска.

Чтобы повторить выполнение определённого блока кода несколько раз — применяют циклы. Цикл будет выполнять вложенный в него код до тех пор, пока будет соблюдаться условие, заданное при объявлении цикла (например, пока какая-то переменная не достигнет определённого значения или, при переборе последовательности, не будет обработан последний элемент); сработает даже условие «выполняй цикл, пока не наступит полночь!».

В Python существует два типа циклов: for и while.

Цикл while

Этот цикл используется в ситуациях, когда необходимо выполнять блок кода до тех пор, пока (англ. while — «до тех пор, пока») заданное условие будет истинным.

Синтаксис цикла while:

Например, фанаты фильма «Матрица» по много раз в день запускают этот фильм в онлайн-кинотеатре; в результате сервер начинает «тормозить». Пяти просмотров в день любому фанату будет достаточно: для каждого пользователя будем печатать реплику Включить фильм «Матрица» фильма до тех пор пока не закончится установленное количество разрешённых просмотров:

Скопировать кодPYTHON
num_allowed_views = 5

while num_allowed_views != 0:  # Пока количество разрешенных просмотров не равно 0
    print('Включить фильм "Матрица"')  # В терминал будет выводиться эта фраза
    # После каждого вывода число разрешённых показов уменьшаем на единицу
    num_allowed_views -= 1

Цикл выполнит вложенный код пять раз. На каждой итерации переменная num_allowed_views будет уменьшаться на единицу, и при каждой следующей итерации вновь и вновь будет проверяться условие: «а не достигла ли эта переменная нуля?». Как только num_allowed_views станет равной 0 — цикл завершит работу.

Но если убрать из кода выражение, уменьшающее значение num_allowed_views, цикл будет выполняться бесконечно: переменная никогда не станет равной нулю, условие всегда будет истинно.

Бесконечных циклов лучше избегать, они могут просто остановить выполнение вашей программы. Ведь код, размещённый после любого цикла, выполнится только после того, как цикл завершит работу.

Цикл while поможет решить и задачу с перебором списка, в котором переданы рейтинги нескольких фильмов:

Скопировать кодPYTHON
movie_ratings = [4.7, 5.0, 4.3, 3.1]

# Вне цикла объявляем переменную-счётчик
i = 0
while i < len(movie_ratings):
    # Вместо индекса элемента подставляем переменную-счётчик
    if movie_ratings[i] > 4.7:
        # Код обработчика.
        ...
    # После выполнения кода
    # увеличиваем счётчик на единицу
    i += 1
    # И цикл выполнит следующую итерацию,
    # если условие, указанное после while, истинно.

Код получился лаконичный и без повторов! Это лучше, чем писать i раз один и тот же код, особенно если значение i неизвестно!

Но Python не был бы Python, если бы не упрощал синтаксис популярных операций до предела. А перебор последовательностей — это весьма популярная операция. Значит — можно проще!

Цикл for

Термин итерация означает повторное выполнение кого-то действия или ряда действий. В программировании итерации — это, например, операция получения каждого элемента из списка в цикле.

В Python все объекты коллекций (списки, словари, множества) поддерживают выполнение таких операций. Такие объекты называются итерируемыми.

У объектов итерируемых типов есть встроенный метод __iter__. Получить список встроенных методов объекта можно с помощью функции dir(). Она вернёт все имена атрибутов и методов объекта.

Скопировать кодPYTHON
recommended_movies = [
    'Хатико', '23', 'Достучаться до небес', 'Хакеры', 'Трон', '1408'
]

print(dir(recommended_movies))
# Вывод в терминал:
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', 
'__iter__', 
'__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Для обработки итерируемых объектов в Python применяют цикл for. В нём не надо объявлять счётчик (он спрятан «под капотом» и создаётся автоматически), а вместо проверяемого условия при объявлении цикла for указывают

переменную, в которую на каждой итерации цикла будет передаваться очередной элемент последовательности;
имя последовательности, которую нужно обработать.

В теле цикла размещают код, который будет выполняться на каждой итерации. Тело цикла отбивается четырьмя пробелами.

Скопировать кодPYTHON
movie_ratings = [4.7, 5.0, 4.3, 3.1]

# Переменная rating поочерёдно принимает элементы
# последовательности movie_ratings
for rating in movie_ratings:
    # Теперь переменную rating можно обработать в теле цикла
    if rating > 4.7:
        print('Фильм крут')
        ...

Вот теперь код получился совсем коротким. Отличный результат.

Другим примером может быть перебор элементов строки и вывод их в терминал: сделаем концептуальную афишу для культового фильма.

Python возьмёт из последовательности элемент с индексом 0, передаст его в переменную symbol и выполнит инструкцию, указанную в теле цикла: напечатает в терминале две строки. Затем перейдёт к следующему элементу последовательности — и повторит всю операцию.

Запустите код и посмотрите результат в консоли. Поэкспериментируйте, добавьте в афишу концептуальности!

 
name_movie = 'Матрица'
​
for symbol in name_movie:
    print((symbol + ' | ') * 7)
    print('——  ' * 7)

В переменной recommended_movies хранится список рекомендуемых фильмов, а в hackers_movies — список «Топ-12 фильмов о кодерах и хакерах».

Выведите в терминал только те рекомендуемые фильмы, которые есть в списке топовых. Для каждого фильма должна быть напечатана строка Рекомендуем программистам посмотреть фильм "<название_фильма>"

 
recommended_movies = ['Хатико', '23', 'Достучаться до небес',
                      'Хакеры', 'Трон', '1408']
​
hackers_movies = ['Трон', 'Военные игры', 'Тихушники',
                  'Джонни Мнемоник', 'Хакеры', 'Нирвана',
                  '23', 'Враг государства', 'Взлом',
                  'Пароль рыба-меч', 'Сеть', 'Кто я']
​
for i in recommended_movies:
    if i in hackers_movies:
        print('Рекомендуем программистам посмотреть фильм «'+i+'»')

Тип Range: диапазон чисел

Последовательность типа Range (англ. «диапазон») — это диапазон чисел, заданный по определённым правилам.

Объект Range создаётся при вызове функции range(). Границы диапазона передаются в аргументах:

Скопировать кодPYTHON
rng = range(1, 10)  # Создали последовательность чисел от 1 до 9
print(type(rng))

# Вывод в терминал: <class 'range'>

Как и в срезах, число, определяющее верхнюю границу диапазона, не попадёт в возвращаемую последовательность: число 10 не будет включено в диапазон range(1, 10).

Аргументов может быть от одного до трёх:

range(15) вернёт последовательность целых чисел от 0 до 14 включительно;
range(3, 15) вернёт последовательность целых чисел от 3 до 14 включительно;
range(3, 15, 2) вернёт последовательность целых чисел от 3 до 14 с шагом 2: 3, 5, 7, 9, 11, 13
range(15, 3, -2): границы диапазона инвертированы (первая больше второй), а шаг — отрицательный; такой диапазон создаст инвертированную последовательность от 15 до 4 с шагом 2: 15, 13, 11, 9, 7, 5.

Объект Range не так прост, как притворяется. Передадим результат функции range(1, 10, 2) в переменную и напечатаем её:

Скопировать кодPYTHON
rng = range(1, 10, 2)
print(rng)

# Вывод в терминал: range(1, 10, 2)
# А где числа-то?

Вывод оказался не таким, как ожидалось: последовательности чисел нет!

В объекте типа Range хранятся не значения диапазона, а лишь условия для вычисления этих значений. В результате объект Range занимает в памяти очень мало места, даже если хранит диапазон чисел от единицы до миллиарда.

Чтобы из объекта Range получить конкретные значения — нужно явно обратиться к элементам этого объекта:

Скопировать кодPYTHON
rng = range(1, 10, 2)
print(rng[3])

# Вывод в терминал: 7

Объекты типа Range — итерируемые, с ними можно работать так же, как с любой другой последовательностью.

Запустите код: даже с «виртуальными» элементами из объекта Range всё работает.

 
for num in range(1, 11):
    print('Это строка #', num)
​
print('Готово')

А вот и практическое применение range(): обработаем в цикле for диапазон и получим элементы с одинаковыми индексами из разных списков:

Скопировать кодPYTHON
movies = ['Матрица', 'Хакеры', 'Трон', 'Тихушники', 'Сеть']
movie_ratings = [4.7, 5.0, 4.3, 4.9, 3.4]

# В качестве верхней границы диапазона 
# передаётся длина списка movies.
print('Рейтинг пользователей')
for index in range(len(movies)):
    print(movies[index]+':', movie_ratings[index])

Теперь управлять последовательностями для вас не составит труда, но у каждой из них есть свои особенности, которые делают их уникальными.

Углублённый Python

Последовательности и циклы

Упорядоченные и неупорядоченные последовательности

Виды последовательностей в Python

Общие особенности и методы последовательностей

Адресация элементов

Сравнение последовательностей

Наименьшее и наибольшее значение элементов последовательности

Слияние (конкатенация)

Повторение

Количество элементов последовательности

Наличие элемента в последовательности

Срезы

Цикл while

Цикл for

Тип Range: диапазон чисел

Как всё устроено

Основы Python

Углублённый Python

Бэкенд на Django

API: интерфейс взаимодействия программ

Управление проектом на удалённом сервере

Проект «Продуктовый помощник»

Трудоустройство 2.1

Алгоритмы и структуры данных

Парсинг

Альтернативные фреймворки

Python для бизнеса

Проекты и подготовка к собеседованиям