Циклы и последовательности

Разбор домашних заданий

• Персональный, с объяснением словами

Списки

Списки — это последовательности, которые хранят произвольные объекты.

• Задание списка [элемент, … ,]

  • Вот это довольно осмысленный список

       1 >>> a = [12, 435, 657, -23, 56]
       2 >>> a
       3 [12, 435, 657, -23, 56]
    

    А вот это — не очень (ну зачем он может понадобиться?):

       1 >>> strange = [ "SDF", [21,3,"WW"], None, [], max]
       2 >>> strange
       3 ['SDF', [21, 3, 'WW'], None, [], <built-in function max>]
    

Цикл `for` для списка

• Устроен так:

     1  for имя in последовательность:
     2      тело
  

  • Цикл совершает столько оборотов, сколько элементов в последовательности, и на каждом обороте имя «имя» связывает очередной элемент этой последовательности:

     1 >>> a = [12, 435, 657, -23, 56]
     2 >>> a
     3 [12, 435, 657, -23, 56]
     4 >>> for e in a:
     5 ...     print(e)
     6 ...
     7 12
     8 435
     9 657
    10 -23
    11 56
    12 >>>
  

• Упражнение: вывести только положительные числа из заданного списка

     1 lst = [12,-657,34,-67,0,467,-78,-45,0,56,-78,89,-89,80,0,2]
     2 
     3 for elem in lst:
     4     if elem>0:
     5         print(elem)
  

Индексирование

• У списка есть длина :

     1 >>> a = [12,-657,34,-67,0,467,-78,-45,0,56,-78,89,-89,80,0,2]
     2 >>> len(a)
     3 16
  

• Элементы списка нумеруются с 0 до len(список)-1:

     1 >>> a[0]
     2 12
     3 >>> a[1]
     4 -657
     5 >>> a[5]
     6 467
     7 >>> a[14]
     8 0
     9 >>> a[15]
    10 2
  

• Попытка обратиться к элементу с индексом большим, чем есть в списке, приведёт к исключению:

     1 >>> len(a)
     2 16
     3 >>> a[100500]
     4 Traceback (most recent call last):
     5   File "<stdin>", line 1, in <module>
     6 IndexError: list index out of range
     7 >>> a[16]
     8 Traceback (most recent call last):
     9   File "<stdin>", line 1, in <module>
    10 IndexError: list index out of range
  

  • Обратите внимание: в списке 16 элементов с индексами от 0 до 15 включительно — или до 16 не включая:

• Индексы бывают отрицательные — с конца списка:

     1 >>> a
     2 [12, -657, 34, -67, 0, 467, -78, -45, 0, 56, -78, 89, -89, 80, 0, 2]
     3 >>> len(a)
     4 16
     5 >>> a[16-1]
     6 2
     7 >>> a[-1]
     8 2
     9 >>> a[-5]
    10 89
    11 >>> a[-100500]
    12 Traceback (most recent call last):
    13   File "<stdin>", line 1, in <module>
    14 IndexError: list index out of range
  

• Список — модифицируемая последовательность, мы можем заменять один объект другим:

     1 >>> a
     2 [12, -657, 34, -67, 0, 467, -78, -45, 0, 56, -78, 89, -89, 80, 0, 2]
     3 >>> a[3] = "QQ"
     4 >>> a
     5 [12, -657, 34, 'QQ', 0, 467, -78, -45, 0, 56, -78, 89, -89, 80, 0, 2]
     6 >>> a[-6] = "QKRQ"
     7 >>> a
     8 [12, -657, 34, 'QQ', 0, 467, -78, -45, 0, 56, 'QKRQ', 89, -89, 80, 0, 2]
     9 >>> a[3], a[-6] = 0, 0
    10 >>> a
    11 [12, -657, 34, 0, 0, 467, -78, -45, 0, 56, 0, 89, -89, 80, 0, 2]
  

• Упражнение: проход списка по индексам с помощью while

     1 l = [12, -657, 34, -67, 0, 467, -78, -45, 0, 56, -78, 89, -89, 80, 0, 2]
     2 
     3 i = 0
     4 while i<len(l):
     5     print(l[i])
     6     i += 1
  

Объекты типа range

Range (диапазон) — это вычислимая последовательность. Можно представить себе, что это список, элементы которого не хранятся в памяти, а вычисляются по ходу:

• Простейший пример: range(N):

     1 >>> for i in range(6):
     2 ...     print(i)
     3 ...
     4 0
     5 1
     6 2
     7 3
     8 4
     9 5
  

  • Range с одним параметром N — это диапазон от 0 до N (не включая N, разумеется):

       1 >>> R = range(5)
       2 >>> R
       3 range(0, 5)
       4 >>> for i in R:
       5 ...      print(i)
       6 ...
       7 0
       8 1
       9 2
      10 3
      11 4
    

  • С двумя — range(M, N) — диапазон от M до N:

       1 >>> for i in range(300, 306):
       2 ...      print(i)
       3 ...
       4 300
       5 301
       6 302
       7 303
       8 304
       9 305
    

  • С тремя — range(M, N, S) — диапазон от M до N с шагом S:

       1 >>> for i in range(10,22,3):
       2 ...      print(i)
       3 ...
       4 10
       5 13
       6 16
       7 19
       8 >>> for i in range(130,22,-18):
       9 ...      print(i)
      10 ...
      11 130
      12 112
      13 94
      14 76
      15 58
      16 40
    

    • Обратите внимание на то, что 22, как полагается, не вошло в диапазон
• Range — настоящая последовательность, её можно использовать везде, где используются последовательности!
  • Распаковывать при связывании:

       1 >>> a, b, c, d = range(3,7)
       2 >>> a
       3 3
       4 >>> b
       5 4
       6 >>> c
       7 5
       8 >>> d
       9 6
    

  • Превращать в список:

       1 >>> r = range(10,20,3)
       2 >>> r
       3 range(10, 20, 3)
       4 >>> list(r)
       5 [10, 13, 16, 19]
    

  • Использовать в цикле for:

       1 >>> a = [12,-657,34,-67,0,467,-78,-45,0,56,-78,89,-89,80,0,2]
       2 >>> for i in range(len(a)):
       3 ...     print(i, ":", a[i])
       4 ...
       5 0 : 12
       6 1 : -657
       7 2 : 34
       8 3 : -67
       9 4 : 0
      10 5 : 467
      11 6 : -78
      12 7 : -45
      13 8 : 0
      14 9 : 56
      15 10 : -78
      16 11 : 89
      17 12 : -89
      18 13 : 80
      19 14 : 0
      20 15 : 2
    

  • Индексировать!

       1 >>> r = range(100,120)
       2 >>> r
       3 range(100, 120)
       4 >>> r[0]
       5 100
       6 >>> r[-1]
       7 119
       8 >>> r[10]
       9 110
      10 >>> r = range(80,20,-11)
      11 >>> r
      12 range(80, 20, -11)
      13 >>> r[0]
      14 80
      15 >>> r[-1]
      16 25
      17 >>> r[5]
      18 25
      19 >>> r[-5]
      20 69
    

Упражнение: заменить отрицательные элементы положительными

   1 a = [12,-657,34,-67,0,467,-78,-45,0,56,-78,89,-89,80,0,2]
   2 
   3 for i in range(len(a)):
   4     if a[i] < 0:
   5         a[i] = -a[i]
   6 print(a)

Некоторые методы списков

• Добавить один элемент в конец списка можно так:

     1 >>> a = [34, 667, 7]
     2 >>> a.append("QQ")
     3 >>> a
     4 [34, 667, 7, 'QQ']
     5 >>> a.append(0)
     6 >>> a
     7 [34, 667, 7, 'QQ', 0]
  

• Получить последний элемент в списке (a[-1]) и одновременно удалить его оттуда — так:

     1 >>> a
     2 [34, 667, 7, 'QQ', 0]
     3 >>> a.pop()
     4 0
     5 >>> a
     6 [34, 667, 7, 'QQ']
     7 >>> s = a.pop()
     8 >>> a
     9 [34, 667, 7]
    10 >>> s
    11 'QQ'
  

  • Можно получить и удалить элемент с произвольным индексом:

       1 >>> a = [12,-657,34,-67,0,467,-78,-45,0,56,-78,89,-89,80,0,2]
       2 >>> a
       3 [12, -657, 34, -67, 0, 467, -78, -45, 0, 56, -78, 89, -89, 80, 0, 2]
       4 >>> a.pop(0)
       5 12
       6 >>> a
       7 [-657, 34, -67, 0, 467, -78, -45, 0, 56, -78, 89, -89, 80, 0, 2]
       8 >>> a.pop(3)
       9 0
      10 >>> a
      11 [-657, 34, -67, 467, -78, -45, 0, 56, -78, 89, -89, 80, 0, 2]
      12 >>> a.pop(-4)
      13 -89
      14 >>> a
      15 [-657, 34, -67, 467, -78, -45, 0, 56, -78, 89, 80, 0, 2]
    

• Вставить элемент на произвольное место:

     1 >>> a
     2 [-657, 34, -67, 467, -78, -45, 0, 56, -78, 89, 80, 0, 2]
     3 >>> a.insert(0, "QQ")
     4 >>> a
     5 ['QQ', -657, 34, -67, 467, -78, -45, 0, 56, -78, 89, 80, 0, 2]
     6 >>> a.insert(10, "QKRQ")
     7 >>> a
     8 ['QQ', -657, 34, -67, 467, -78, -45, 0, 56, -78, 'QKRQ', 89, 80, 0, 2]
  

Операции insert(i,e) и pop(i) требуют перемещать элементы списка (соответственно, вправо, чтобы образовалось свободное место, и влево, чтобы после удаления не пустовало). Если вставлять/удалять в начале вписка, то переставлять придётся все его элементы.

А вот операции append()/pop() работают с концом списка и не требуют ничего перемешать. Эти «дешёвые» операции реализуют абстракцию «стек» (FILO), которая очен:ь часто встречается в различных алгоритмах.

Упражнение: ввод списка до 0

   1 a = []
   2 
   3 e = int(input())
   4 while e!=0:
   5     a.append(e)
   6     e = int(input())
   7 print(a)

Ввод списка с помощью eval(input())

• По умолчанию input() возвращает объект типа «строка» (str):

     1 >>> s=input()
     2 asfasdf asdf
     3 >>> s
     4 'asfasdf asdf '
     5 >>> type(s)
     6 <class 'str'>
  

• Даже если мы вводим что-то похожее на объект Python3, это всё равно просто строка:

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

• Эту строку можно обработать преобразованием типа, если мы точно знаем, что именно ввели:

     1 >>> s = input()
     2 100500
     3 >>> s
     4 '100500'
     5 >>> type(s)
     6 <class 'str'>
     7 >>> n = int(s)
     8 >>> n
     9 100500
    10 >>> type(n)
    11 <class 'int'>
  

• А вот если эту строку обработать eval(), эта функция вычислит выражение, находящееся в строке! Более точно, эту строку обработает Python3, как если бы бы её ввели в интерпретаторе:

     1 >>> 3+2+1
     2 6
     3 >>> s=eval(input())
     4 3+2+1
     5 >>> s
     6 6
     7 >>> type(s)
     8 <class 'int'>
  

• Соответственно, если в этой строке содержится в точности то, как мы записывает список, eval() преобразует её в список:

     1 >>> s=eval(input())
     2 [1,2,3,4]
     3 >>> s
     4 [1, 2, 3, 4]
     5 >>> s[0]
     6 1
     7 >>> s[1]
     8 2
     9 >>> type(s)
    10 <class 'list'>
  

(не успели) Поиск первого (например, отрицательного) и for, клауза exit не успели .remove()/index()/in

Д/З

• прочитать и прощёлкать десятую главу учебника

• EJudge: NotMax 'Меньше максимального'

  Ввести непустой список (с помощью eval(input())), и вывести в столбик все его элементы, которые меньше максимального. Функцией max() не пользоваться! Если все элементы одинаковые, не выводить ничего.

  Input:

  [1,6,3,3,8,5,3,8,5,3,7]

  Output:

  1
  6
  3
  3
  5
  3
  5
  3
  7

• EJudge: ListEdit 'Модифицировать список'

  Ввести и модифицировать список: элементы, стоящие на чётных местах умножить на 2, а на нечётных — поделить нацело (то есть с помощью. «//») на 3, если они сами делятся на 3 . Вывести результат (в виде списка).

  Input:

  [1,2,3,4,5,6,7,8]

  Output:

  [2, 2, 6, 4, 10, 2, 14, 8]

• EJudge: ThirdNeg 'Третье отрицательное'

  Ввести список. Вывести третье по счёту отрицательное число в этом списке, если оно там есть и "NO" иначе.

  Input:

  [1,2,-3,4,-5,6,-7,8,9]

  Output:

  -7

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

[100,90,100,90,100,-120,100,-120,100,-120,100,90,100,90]

даёт такую фигуру:

Нарисовать ещё что-нибудь осмысленное