Управляющие конструкции

Списки

Операции над списками

Обращаnmся к элементам списка можно по индексу. Обращение по несуществующему индексу вызовет ошибку

>>> e = [12, 345, 65, 72]
>>> e[0]
12
>>> e[-1] # последний элемент
72

Списки можно изменять в отличие от строки

>>> e = [12, 345, 65, 72]
>>> e[1] = 421
>>> e
[12, 421, 65, 72]

Функции списков

len(L) – возвращает число элементов в списке L
max(L) – возвращает максимальное значение в списке L
min(L) – возвращает минимальное значение в списке L
sum(L) – возвращает сумму значений в списке L
sorted(L) – возвращает копию списка L, в котором элементы упорядочены
по возрастанию. Не изменяет список L

Операция сложения, умножения и удаления

>>> s = [23, 14, 51]
>>> t = s + [4] # сложение
>>> t
[23, 14, 51, 4]
>>> t = t * 2 # умножение
>>> t
[23, 14, 51, 4, 23, 14, 51, 4]
>>> del t[1] # удаление
>>> t
[23, 51, 4, 23, 14, 51, 4]

Опеартор in

e = [12, 32, 62]
if 32 in e:
    print ('Значение есть в списке')

Операции взятия среза и удаления

>>> t = [21, 42, 21, 421]
>>> n = t[1:3] # срез
>>> n
[42, 21]
>>> del n[1:2] # удаление
>>> n
[42]

Срезы выполняются аналогично строкам

Псевдонимы и копирование списков

Важная особенность списков

>>> h = [23, 53, 15, 63]
>>> p = h        # содержат указатель на один и тот же список
>>> p
[23, 53, 15, 63]
>>> p[0] = 555   # модифицируем одну из переменных
>>> p
[555, 53, 15, 63]
>>> h            # изменилась другая переменная!
[555, 53, 15, 63]

В Python две переменные называются псевдонимами, когда они содержат одинаковые адреса памяти

Проверка ссылаются ли переменные на один и тот же объект:

>>> x = y = [2, 4]
>>> x is y
True
>>> x = [2, 4]
>>> y = [2, 4]
>>> x is y
False

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

Поверхностное

>>> a = [1,2,3,4]
>>> b = a
>>> b[1] = 7
>>> a
[1, 7, 3, 4]

Глубокое

>>> a = [1,2,3,4]
>>> import copy
>>> b  = copy.deepcopy(a)
>>> b[1] = 7
>>> a
[1, 2, 3, 4]

Дополнительная информация

Методы списка

Примеры

>>> colors = ['red', 'orange', 'green']
>>> colors.extend(['black','blue']) # расширяет список списком
>>> colors
['red', 'orange', 'green', 'black', 'blue']
>>> colors.append('purple') # добавляет элемент в список
>>> colors
['red', 'orange', 'green', 'black', 'blue', 'purple']
>>> colors.insert(2,'yellow') # добавляет элемент в указанную позицию
>>> colors
['red', 'orange', 'yellow', 'green', 'black', 'blue', 'purple']
>>> colors.remove('black') # удаляет элемент из списка
>>> colors
['red', 'orange', 'yellow', 'green', 'blue', 'purple']
>>> colors.count('red') # считает количество повторений аргумента метода
1
>>> colors.index('green') # возвращает позицию в списке аргумента метода
3

Еще несколько полезных методов для списка

>>> colors
['red', 'orange', 'yellow', 'green', 'blue', 'purple']
>>> colors.pop() # удаляет и возвращает последний элемент списка
'purple'
>>> colors
['red', 'orange', 'yellow', 'green', 'blue']
>>> colors.reverse() # список в обратном порядке
>>> colors
['blue', 'green', 'yellow', 'orange', 'red']
>>> colors.sort() # сортирует список (вспомните о сравнении строк)
>>> colors
['blue', 'green', 'orange', 'red', 'yellow']
>>> colors.clear() # очищает список. Метод появился в версии 3.3. Аналог del color[:]
>>> colors
[]

Преобразование типов

Пеобразуем строки в список, измение списка, затем возврат его в строку

>>> s = 'это строка'
>>> list(s) # функция list() пытается преобразовать аргумент в список
['э', 'т', 'о', ' ', 'с', 'т', 'р', 'о', 'к', 'а']
>>> lst = list(s)
>>> lst[0] = 'Е' # изменяем список, полученный из строки
>>> lst
['Е', 'т', 'о', ' ', 'с', 'т', 'р', 'о', 'к', 'а']
>>> s = ''.join(lst) # преобразуем список в строку с помощью строкового метода join()
>>> s
'Ето строка'

Метод join() принимает на вход список, который необходимо преобразовать в строку, а в качестве строкового объекта указывается соединитель элементов списка

>>> L = ['tra', 'ta', 'ta']
>>> ' '.join(L)
'tra ta ta'

Аналогично можно преобразовать число к списку (через строку) и затем изменить полученный список

>>> n = 9987
>>> list(str(n))
['9', '9', '8', '7']

Если строка содержит разделитель, то ее можно преобразовать к списку с помощью строкового метода split(), который по умолчанию в качестве разделителя использует пробел

>>> s = 'da ad adadsasd adsasd'.split()
>>> s
['da', 'ad', 'adadsasd', 'adsasd']

Другой разделитель

>>> s = 's:f:g:h:e'.split(':')
>>> s
['s', 'f', 'g', 'h', 'e']

Вложенные списки

>>> lst = [['A', 1], ['B', 1], ['C', 3]]
>>> lst
[['A', 1], ['B', 1], ['C', 3]]
>>> lst[1]
['B', 1]
>>> lst[1][1] # обращение к вложенному списку
1

Операторы сравнения

Ещё один тип данных - логический тип (boolean): True или False.

Для сравнения значений используются операторы сравнения:

Синтаксис	Описание
>	Больше
<	Меньше
>=	Больше или равно
<=	Меньше или равно
==	Равно
1=	Не равно

Инструкции If, elif, else

if  <<условие>>:        # блок выражений выполняется только в том случае, если выражение, которое находится в условии, является истинным
    <<блок выражения>>
elif  <<условие>>:
    <<блок выражения>>
else:                   #  выполняется, когда все вышестоящие условия вернули False.
    <<блок выражения>>

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

Булевая логика

У Python есть три логических оператора and, or, not

Результатом применения логического оператора not (НЕ) произойдет отрицание операнда, т.е. если операнд истинный, то not вернет – ложь, если ложный, то – истину:

>>> x = 6 > 7
>>> x
False
>>> not x
True
>>> not None
True
>>> not 2
False
>>>

Логический оператор and (И) вернет True (истину) или False (ложь), если его операндами являются логические высказывания:

>>> 2 > 5 and 4 > 1 # комбинация False and (И) True вернет False
False

Если операндами оператора and являются объекты, то в результате Python вернет объект:

>>> '' and 4 # False and True
''

Для вычисления оператора and Python вычисляет операнды слева направо и возвращает первый объект, имеющий ложное значение:

>>> 0 and 2 # вернет первый ложный объект-операнд
0
>>> 5 and 4 вернет крайний правый объект-операнд
4

Если Python не удается найти ложный объект-операнд, то он возвращает крайний правый операнд.

Логический оператор or действует похожим образом, но для объектов-операндов Python возвращает первый объект, имеющий истинное значение. Python прекратит дальнейшие вычисления, как только будет найден первый объект, имеющий истинное значение

>>> 0 or 3 # вернет первый истинный объект-операнд
3
>>> None or 6 # вернет второй объект-операнд, т.к. первый всегда ложный
6
>>> None or 0 # вернет оставшийся объект-операнд
0
>>>

В Python любое число, не равное нулю, или непустой объект интерпретируется как истина/

Числа, равные нулю, пустые объекты и специальный объект None интерпретируются как ложь:

>>> '' and '3' # False and True
''
>>> '' or '3' # False or True
'3'
>>>

Логические выражения можно комбинировать:

>>> 1+(3+7) # приоритет + выше, чем >
11
>>> 1+(3>7) # скобки способствуют наглядности и избавляют от ошибок
1
>>> 1 + False
1
>>> 1 + True
2

В Python можно проверять принадлежность интервалу:

>>> x = 1
>>> -1 < x < 4 # эквивалентно: x > -1 and x < 14
True
>>>

Можно сравнить строки.

Определить какое число соответствует символу можно с помощью функции ord():

>>> ord('F')
70

>>> 'B' > 'b'
False

Для сравнения строк Python их сравнивает посимвольно:

>>> 'Aaaaa' < 'AAaaa'
False

Оператор in проверяет наличие подстроки в строке:

>>> 'a' in 'abc'
True
>>> 'A' in 'abc' # большой буквы А нет
False
>>> '' in 'abc' # пустая строка есть в любой строке
True
>>> '' in ''
True

Приоритет операторов

Оператор	Описание
**	Возведение в степень
~ + -	Комплиментарный оператор
* / % //	Умножение, деление, деление по модулю, целочисленное деление
+ -	Сложение и вычитание
>> <<	Побитовый сдвиг вправо и побитовый сдвиг влево
&	Бинарный "И"
^		Бинарный "Исключительное ИЛИ" и бинарный "ИЛИ"
<= < > >=	Операторы сравнения
<> == !=	Операторы равенства
= %= /= //= -= += = *=	Операторы присваивания
is is not	Тождественные операторы
in not in	Операторы членства
not or and	огические операторы

Циклы

while

while  <<выражение>>:        
    <<тело цикла>> # тело цикла выполняется многократно (итерация), пока выражение явдяется истинным
                   # или пока не вышли по break
                   # инструкция continue переводит выполнение цикла в начало

for

Цикл for позволяет перебрать все элементы указанного списка. Цикл сработает ровно столько раз, сколько элементов находится в списке. Имя переменной, в которую на каждом шаге будет помещаться элемент списка, выбирает программист.

>>> l = [12, 124, 5135, 12]
>>> for i in l:
>>>    print(i)
12
124
5135
12

Цикл for работает и для строк

>>> for i in 'hello':
>>>    print(i)
h
e
l
l
o

Цикл for позволяет не только выводить элементы строки или списка на экран, но и производить над ними определенные операции

>>> l = [12, 124, 5135, 12]
>>> for i in l:
>>>     if i == 124:
>>>         print(i)
124

>>> word = 'Hello'
>>> for i in word:
>>>   if i.isupper():
>>>     print(i)
H

range

Функция range() создаёт последовательность (диапазон) чисел. В качестве аргументов функция принимает: начальное значение диапазона (по умолчанию 0), конечное значение (не включительно) и шаг (по умолчанию 1)

>>> for i in range(4):
>>>    print(i)
0
1
2
3

>>> for i in range(1, 7, 2):
>>>   print(i)
1
2
5

В обратном порядке

>>> for i in range(4, 1, -1):
>>>   print(i)
4
3
2

Вычислить сумму чисел в заданном диапазоне:

>>> t = 0
>>> for i in range(1,101):
>>>     t = t + i
>>> print(t)
5050

Альтернативный вариант

>>> sum(list(range(1, 101)))
5050

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

lst = [4, 10, 5, -1.9]
>>> print(lst)
>>> for i in range(len(lst)):
>>>   lst[i]=lst[i] * 2
>>> print(lst)
[4, 10, 5, -1.9]
[8, 20, 10, -3.8]

Способы создания списков

С помощью строкового метода append

>>> lst = []
>>> for i in range(1,11):
>>>     lst.append(i)
>>> print(lst)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

С помощью диапозона

a = list(range(1,4))
print(a)

С помощью "строкового влючения"

>>> a = [i for i in range(1,5)] # i - что делаем с элементом, второй i - что берём, range - откуда берём.
>>> print(a)
[1, 2, 3, 4]

Пример использования

>>> a = [i*2 for i in range(1,10)]
>>> print(a)
[2, 4, 6, 8, 10, 12, 14, 16, 18]

Списковое включение позволяет задавать условие для выбора значения из диапазона

>>> a = [i*2 for i in range(1,10) if i != 5]
>>> print(a)
[2, 4, 6, 8, 12, 14, 16, 18]

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

>>> b = [1, 2, 3, 4]
>>> b = [i*2 for i in b]
>>> print(b)
[2, 4, 6, 8]

По аналогии можно перебирать символы из строки и формировать из них список

>>> a = [i*2 for i in 'asf']
>>> print(a)
['aa', 'ss', 'ff']

В Python есть интересная функция map(), которая позволяет создавать новый список на основе существующего списка

>>> def func(x):
>>>     return x + 3
>>> b = list(map(func,[1,2,3])) # в качестве второго аргумента может принимать строку. Результат работы
функции добавляется как элемент нового списка
>>> print(b)
[4, 5, 6]

Получить результат вызова функцииmap() можно через цикл for или функцию list(). Функции, которые принимают на вход другие функции, называются функциями высшего порядка

Пример вызова для строки

>>> def func(s):
>>>     return s * 3
>>> b = list(map(func,'hello'))
>>> print(b)
['hhh', 'eee', 'lll', 'lll', 'ooo']

Получить список, состоящий из случайных целых чисел

>>> from random import randint
>>> a = [(randint(1,5)) for i in range(5)]
>>> print(a)
[3, 5, 1, 4, 1]

Ручной ввод значений для списка

>>> a = []
>>> n = int(input()) # количество элементов в списке
>>> for i in range(n):
>>>     new_alement = int(input()) # считывание очередного элемента
>>>     a.append(new_alement) # добавление его в список
>>>     # a.append(int(input()) # вместо двух последних строчек
>>> print(a)
3
2
3
1
[2, 3, 1]

Решение этой же задачи через списковое влючение:

A = [int(input()) for i in range(int(input()))]

Вложенные циклы

Циклы можно вкладывать друг в друга:

first = ['a', 'b', 'c']
second = [1, 2, 3]

for i in first:
    for j in second:
        print('i = ', i, 'j = ', j)

first = ['a', 'b', 'c']
second = [1, 2, 3]

for i in first:
    for j in second:
        print('i = ', i, 'j = ', j)

Данный прием активно используется при работе с вложенными списками. Сначала пример с одним циклом for:

lst = [['a', 'b', 'c'],[1, 2, 3]]

for i in lst:
    print(i)

['a', 'b', 'c']
[1, 2, 3]

В примере с помощью цикла for перебираются все элементы списка, которые также являются списками. Если мы хотим добраться до элементов вложенных списков, то придется использовать вложенный цикл for:

lst = [['a', 'b', 'c'],[1, 2, 3]]

for i in lst:
    print()
    for j in i:
        print(j, end="")

abc
123