Понятие последовательности и цикл for

Повторение — необходимые условия алгоритмической полноты:

• Аллегирование (обращение к данным). Python: связывание (например, именами).

• Выполнение или не выполнение действий в зависимости от свойств данных. Python: условный оператор.

• Выполнение действий несколько раз, пока свойства данных соответствую критерию.

  • Частный случай: некоторое числовое свойство объекта — это и есть количество действий

    • Ещё более частный случай: объект составлен из других объектов, и с каждым нужно выполнить одно и то же действие

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

• Помыть все тарелки в раковине
• Подняться по лестнице
• Выполнить гимнастическое упражнение 12 раз

Особенности:

• Количество действий (размер последовательности) может быть известно заранее, но это не обязательно для решения задачи

• Последовательность всегда актуально конечна
• Мы знаем, когда последовательность заканчивается

Последовательности (введение)

Кортежи

Самая простая последовательность — кортеж (tuple).

• Как сделать: это просто объекты через запятую:

     1 >>> a = 7, 2, 43, 77, 1
     2 >>> a
     3 (7, 2, 43, 77, 1)
     4 >>> print(a)
     5 (7, 2, 43, 77, 1)
     6 
  

• Объекты любые, не обязательно однотипные. Разумеется, можно писать выражения: сначала они вычисляются, получается объект, и он попадает в кортеж:

     1 >>> b = 1 / 3, None, "QWE", 7 > 4
     2 >>> b
     3 (0.3333333333333333, None, 'QWE', True)
     4 
  

  • В некоторых случаях (например, при связывании помощью =) круглые скобки можно не писать

Кортеж — это способ связать объект без имени.

• Чтобы обратиться к объекту в кортеже, надо указать сам кортеж и в квадратных скобках индекс. Объекты в кортеже индексируются с нуля.

     1 >>> a[0]
     2 7
     3 >>> a[1]
     4 2
     5 >>> a[4]
     6 1
     7 >>> a[5]
     8 Traceback (most recent call last):
     9   File "<stdin>", line 1, in <module>
    10 IndexError: tuple index out of range
    11 
    12 tuple index out of range
    13 >>> b[2]
    14 'QWE'
    15 
  

• Всегда известна длина кортежа. На месте индекса (как и практически на любом месте!) может стоять выражение. Оно вычислится, получится объект, они-то и послужит индексом.

     1 >>> len(a)
     2 5
     3 >>> len(b)
     4 4
     5 >>> b[4]
     6 Traceback (most recent call last):
     7   File "<stdin>", line 1, in <module>
     8 IndexError: tuple index out of range
     9 
    10 tuple index out of range
    11 >>> b[1+1]
    12 'QWE'
    13 >>> a[len(a) // 2]
    14 43
    15 
  

  • На всякий случай ещё раз: индексы от 0 до len(…)-1 (не до len())

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

•    1 >>> b + a
     2 (0.3333333333333333, None, 'QWE', True, 7, 2, 43, 77, 1)
     3 >>> a * 3
     4 (7, 2, 43, 77, 1, 7, 2, 43, 77, 1, 7, 2, 43, 77, 1)
     5 >>> c = a * 2
     6 >>> len(a)
     7 5
     8 >>> len(c)
     9 10
    10 >>> # Десять, Ватсон!
  

Все связанные в кортеж объекты одновременно хранятся в памяти.

Диапазоны

Диапазон (range) — это целочисленная последовательность вида «от такого-то числа до такого-то с таким-то шагом):

•    1 >>> r = range(7)
     2 >>> r
     3 range(0, 7)
     4 >>> r[0]
     5 0
     6 >>> r[1]
     7 1
     8 >>> r[6]
     9 6
    10 >>> r[7]
    11 Traceback (most recent call last):
    12   File "<stdin>", line 1, in <module>
    13 IndexError: range object index out of range
    14 
    15 range object index out of range
    16 >>> r2 = range(5, 12)
    17 >>> r2
    18 range(5, 12)
    19 >>> r2[0]
    20 5
    21 >>> r2[1]
    22 6
    23 >>> r2[2]
    24 7
    25 >>> r2[12]
    26 Traceback (most recent call last):
    27   File "<stdin>", line 1, in <module>
    28 IndexError: range object index out of range
    29 
    30 range object index out of range
    31 >>> r2[6]
    32 11
    33 >>> r2[7]
    34 Traceback (most recent call last):
    35   File "<stdin>", line 1, in <module>
    36 IndexError: range object index out of range
    37 
    38 range object index out of range
    39 >>> r3 = range(12, 100,21)
    40 >>> r3
    41 range(12, 100, 21)
    42 >>> tuple(r3)
    43 (12, 33, 54, 75, 96)
    44 >>> r3[1]
    45 33
    46 >>> r4 = range(35, 10, -3)
    47 >>> list(r4)
    48 [35, 32, 29, 26, 23, 20, 17, 14, 11]
    49 >>> len(r4)
    50 9
    51 
  

  • Из любой последовательности (в том числе из диапазона) можно сделать кортеж — нам так было проще показать, что лежало в исходном диапазоне
  • Шаг может быть отрицательным

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

•    1 >>> a0, c = 10, 6
     2 >>> r = range(10, 100, 6)
     3 >>> r[7]
     4 52
     5 >>> a0 + c * 7
     6 52
     7 >>> len(r)
     8 15
     9 >>> (100 - 10) // 6
    10 15
    11 
  

Попутное замечание

Да, в операции множественного связывания справа чаще всего стоит именно кортеж. Слева — нет, слева стоят имена.

•    1 >>> i, j, k, l, m = 1, 3, 5, 7, 9
     2 >>> print(i, j, k, l, m)
     3 1 3 5 7 9
     4 >>> i, j, k, l, m = a
     5 >>> print(i, j, k, l, m)
     6 7 2 43 77 1
     7 >>> i, j, k, l, m = range(3, 16, 3)
     8 >>> print(i, j, k, l, m)
     9 3 6 9 12 15
    10 
  

  • Но в действительности справа может стоять любая последовательность, лишь бы её длина совпадала с количеством имён слева.

Как ввести кортеж?

Самый простой способ — ввести строку с помощью input(), а затем сказать Питону: ты не собачка, ты курочка«это не строка, а выражение на Python, вычисли его».

• Достигается это с помощью функции eval():

     1 >>> s = input()
     2 1, 2, 3, 7
     3 >>> type(s)
     4 <class 'str'>
     5 >>> seq = eval(s)
     6 >>> type(seq)
     7 <class 'tuple'>
     8 >>> seq
     9 (1, 2, 3, 7)
    10 >>> seq[3]
    11 7
    12 
  

• Разумеется, eval() вычисляет любые выражения python, а не только распознаёт кортежи!

     1 >>> s = "(2 + 3) / 4, 'QQQ', None"
     2 >>> s
     3 "(2 + 3) / 4, 'QQQ', None"
     4 >>> f = eval(s)
     5 >>> type(f)
     6 <class 'tuple'>
     7 >>> f
     8 (1.25, 'QQQ', None)
     9 >>> f[1]
    10 'QQQ'
    11 >>> s = input()
    12 "WE" * 20
    13 >>> s
    14 '"WE" * 20'
    15 >>> f = eval(s)
    16 >>> f
    17 'WEWEWEWEWEWEWEWEWEWEWEWEWEWEWEWEWEWEWEWE'
    18 
  

• Если ввести строку, в которой будет содержаться что-то, не похожее на выражение Python, eval() выдаст ошибку:

     1 >>> s = input()
     2 qwe qwe
     3 >>> s
     4 'qwe qwe'
     5 >>> eval(s)
     6   File "<string>", line 1
     7     qwe qwe
     8         ^^^
     9 SyntaxError: invalid syntax
    10 
    11 invalid syntax (<string>, line 1)
    12 
  

Цикл for

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

•    1 for имя in последовательность:
     2     сделать что-то с объектом «имя»
  

  • Действия внутри блока с отступом выполняются несколько раз — столько, какова длина последовательности. Каждая итерация называется проходом цикла (нулевой проход, первый проход и т. д.)

  • На каждом проходе имя имя связывает очередной объект последовательности

• Например:

     1 for i in 3, 5, 7, 9:
     2     print(i)
     3     print("…also ×2=", i * 2)
  

Если нужно выполнить какое-то действие N раз — создаём range(N) и вставляем его в цикл в качестве последовательности:

•    1 for i in range(1, 10):
     2     print("6 *", i, "=", 6 * i)
  

  • В качестве бесплатной добавки получаем переменную, в которой лежит «номер раза» (начиная с 0)

Ввести кортеж из чисел и посчитать их среднее арифметическое

• Алгоритм:

  0. Ввести кортеж с помощью eval()

  1. Задать переменную для суммы, изначально она равна 0
  2. В цикле добавить к ней очередной элемент кортежа
  3. Поделить суммы на длину кортежа — это и есть ответ; вывести его

Что такое Треугольное число.

• Как посчитать треугольное число?

  

  • Т. е. $$ (N(N+1))/2 $$

Ввести N и вывести первые N треугольных чисел

Д/З

• Отщёлкать Четвёртое занятие учебника и решить все задачи (их всё-таки не 16, а 11, но могут показаться сложнее, не тяните, и спрашивайте обязательно, если что непонятно!)

• Скопировать решения в соответствующие файлы и проверить, что они всё ещё работают!

  • Имена файлов — от prog_4_1.py до prog_4_11.py

• Прислать эти 11 файлов в виде одиннадцати приложений к одному письму по адресу <uneexlectures AT cs DOT msu DOT ru>

  • В поле Subject должно быть «слово» PhilosoPython2022 (другие слова тоже можно ☺)