Слайд 1Москва, 2018
Информационные
технологии
Основы
программирования
на Python 3
Каф. ИКТ РХТУ им.
Д.И. Менделеева
Ст. преп. Васецкий А.М.
Слайд 2Лекция 4.
Инструкции и операторы
Операторы языка Python
Условные операторы
Циклы
Последовательности
Слайд 3Список источников
Оригинальная документация https://docs.python.org/3/
Изучаем Python. Программирование игр, визуализация данных,
веб-приложения. — СПб.: Питер, 2017. — 496 с.: ил. —
(Серия «Библиотека программиста»).
Рейтц К., Шлюссер Т. Автостопом по Python. — СПб.: Питер, 2017. — 336 с.: ил. — (Серия «Бестселлеры O’Reilly»).
Лутц М. Изучаем Python, 4-е издание. – Пер. с англ. – СПб.: Символ-Плюс, 2011. – 1280 с., ил.
Прохоренок Н. А., Дронов В. А., «Python 3. Самое необходимое» — СПб.: БХВ-Петербург. – 2016, 464 с
Прохоренок Н.А. Дронов В. А., «Python 3 и PyQt. Разработка приложений» — СПб.: БХВ-Петербург. – 2016, 832 с.
Любанович Б: Простой Python. Современный стиль программирования. – СПб.: Питер, – 2016, 480 с.
http://pythonicway.com
http://pythonz.net
https://tproger.ru/tag/python/
https://pythonworld.ru
http://pythontutor.ru
Слайд 7Операторы Python
Арифметические операторы
Операторы сравнения (реляционные)
Операторы присваивания
Побитовые операторы
Логические операторы
Операторы членства (Membership
operators)
Операторы тождественности (Identity operators)
Слайд 9По вычислению корней
Корень кубический вычисляется исходя из
Слайд 10Пример корня
-27 ** (1/3) # -3.0
(-27) ** (1/3) # (1.5+2.598076211353316j)
Проверка:
(1.5
+ 2.598076211353316j)**3 # (-27+0j)
Сопряжённый корень проверка:
(1.5 – 2.598076211353316j)**3 # (-27+0j)
Аналогично
a
= -27
a ** (1/3) # (1.5+2.598076211353316j)
Слайд 12Составные операторы сравнения
x = 5
2 < x < 10 #
True
10 < x < 20 # False
x < 10
< x*10 < 100 # True
10 > x <= 9 # True
5 == x > 4 # True
Слайд 15Побитовые операторы
a = 0b0011 1100 (6010)
b = 0b0000 1101 (1310)
Слайд 16Побитовые операторы
a = 0b0011 1100 (6010)
b = 0b0000 1101 (1310)
Слайд 21Условный оператор
В Python инструкция if выбирает, какое действие следует выполнить.
Это основной инструмент выбора в Python, который отражает большую часть
логики программы.
Синтаксис:
if <логическое условие1>:
< Инструкции-1>
elif <логическое условие2>:
< Инструкции-2>
else: < Инструкции-3>
Слайд 22Пример
a = int(input())
if a < -3:
print("Мало")
elif -3
a
0, или непустой объект – истина.
Числа, равные 0, пустые объекты и значение None – ложь
Операции сравнения применяются к структурам данных рекурсивно
Слайд 23Рекомендации по использованию
Пользуйтесь .startswith() и .endswith() вместо обработки срезов строк
для проверки суффиксов или префиксов.
if s.startswith("pfx"): # правильно
if s[:3] == "pfx":
# неправильно
Сравнение типов объектов делайте с помощью isinstance(), а не прямым сравнением типов:
if isinstance(obj, int): # правильно
if type(obj) is type(1): # неправильно
Переключатель True/False
x = y > 0 # правильно
if y > 0: # неправильно
x = True
else:
x = False
Слайд 24Рекомендации, продолжение
Не сравнивайте логические типы с True и False с
помощью ==
if condit: # правильно
if condit == True: # неправильно
if
condit is True: # неправильно
Для последовательностей (строк, списков, кортежей) используйте то, что пустая последовательность есть false
if not seq: # правильно
if seq: # правильно
if len(seq) # неправильно
if not len(seq) # неправильно
Слайд 25Трехместное выражение if/else
Пример инструкции вида
if x > 5:
x =
y
else:
x = z
Можно заменить на более короткий вариант
x =
truepart if <условие> else falsepart
Теперь пример можно переписать как:
x = y if x > 5 else z
Примечание: аналог в языке С/С++:
<условие> ? :
Слайд 26Замена switch-case через elif
В Python нет конструкций множественного выбора типа
switch-case.
Один из вариантов замены – использование elif:
# Производится последовательное
сравнение переменной n.
# Если n>70 выполняется код code70 и выполнение переходит на строку final, иначе выполняется дальнейшая проверка.
if n > 70:
print("code70")
# Если n>50 – выполняется код code50 и выполнение переходит на строку final, иначе продолжаем…
elif n > 50:
print("code50")
elif n > 20:
print("code20")
# Если результат всех проверок оказался ложным
выполняется блок code0, после чего переходим на строку final
else:
print("code0")
print("final")
Слайд 27Другие замены switch-case
Существует множество рекомендаций по замене.
С использованием словаря:
choices
= {"a": 1, "b": 2}
result = choices.get(key, "default")
Другие способы см.
http://qaru.site/questions/10714/replacements-for-switch-statement-in-python
Слайд 28Циклы
В Python существуют следующие два типа цикличных выражений:
Цикл while (цикл
типа "пока")
Цикл for (цикл типа "для")
Слайд 29Цикл типа while
while – один из самых универсальных циклов в
Python, поэтому довольно медленный
Инструкция while повторяет указанный блок кода до
тех пор, пока указанное в цикле условие истинно.
Синтаксис:
while <условие>: # Условное выражение
<инструкции> # тело цикла
else: # необязательная часть
<инструкции>
необязательная часть else выполняется, если выход из цикла был произведён не инструкцией break
Слайд 30Инструкции цикла while
break – производит выход из цикла.
continue – производит
переход к началу цикла.
pass – пустая инструкция-заполнитель.
Общий вид цикла while
можно тогда записать как:
while <условие1>:
<инструкции>
if <условие2>: break # Выйти из цикла, пропустив else
if < условие3>: continue # Перейти в начало цикла
else:
<инструкции> # Выполняется, если не была использована инструкция "break"
Пара else/break часто позволяет избавиться от необходимости сохранять флаг штатного выхода из цикла по условию1. (см. примеры ниже)
Блок else выполняется ещё и в том случае, когда тело цикла ни разу не выполнялось.
Слайд 31Пример цикла while с флагом
Поиск некоторого значения
found = False #
флаг найденного значения
while x and not found:
# Пока х
не пустой и не найдено значение
if match(x[0]): # Искомое значение является первым? (match(x) – некоторая функция, устанавливающее соответствие x критериям поиска)
print("Нашли")
found = True
else:
x = x[1:] # Вырезать первое значение и повторить (это медленный способ)
if not found:
print("Не нашли")
Слайд 32Пример с else без флага
while x: # Выйти, когда x
опустеет
if match(x[0]): # (match(x) – некоторая функция, устанавливающее соответствие
x критериям поиска)
print("Нашли")
break # Выход, в обход блока else
x = x[1:]
else:
print("Не нашли") # Этот блок отработает, только если строка x исчерпана
Эта версия более компактна по сравнению с предыдущей.
Слайд 33Цикл типа for
Цикл for – универсальный итератор последовательностей.
Он выполняет обход
элементов в любых упорядоченных объектах.
for может работать со списками, кортежами,
строками и другими встроенными итерируемыми объектами, в т.ч. и с новыми объектами, созданными с помощью классов.
Циклы for могут применяться даже к объектам, которые не являются последовательностями, таким как файлы и словари.
Слайд 34Общий формат циклов for
for in : # Связывает элементы
объекта с переменной цикла
# тело цикла
else:
< инструкции>
# произведён штатный выход из цикла без "break"
Полная форма:
for <цель> in <объект>:
<инструкции> # тело цикла
if <условие1>: break # Выход из цикла
if < условие2>: continue # Переход в начало цикла
else:
<инструкции> # произведён штатный выход из цикла без "break"
Слайд 35Примеры
Простейший перебор элементов списка:
for x in ["a", "b", "c"]:
print(x,
end=" ") # (в одну строчку) – a b c
Обход строки:
for x in "строка":
print(x, end=" ") # с т р о к а
А вот так со списком не пройдёт:
L = [1, 2, 3, 4, 5]
for x in L:
x += 1 # Элемент списка это не изменит!
print(L) # [1, 2, 3, 4, 5]
Слайд 36Обход кортежа:
for (a, b) in [(1, 2), (3, 4), (5,
6)]: # создаём кортеж (a, b)
print((a, b), "/", end=" ")
# (1, 2) / (3, 4) / (5, 6) /
В результате в каждой итерации автоматически выполняется операция присваивания кортежа.
Аналогично сработает и:
for x in [(1, 2), (3, 4), (5, 6)]: # x – кортеж
print(x, "/", end=" ") # (1, 2) / (3, 4) / (5, 6) /
Не обязательно использовать в качестве итератора кортеж. Можно, например, итерировать по новому списку [a, b]
for [a, b] in [(1, 2), (3, 4), (5, 6)]: # список [a, b]
print([a, b], "/", end=" ") # [1, 2] / [3, 4] / [5, 6] /
Слайд 37Обход словаря
D = {"a": 1, "b": 2, "c": 3}
for key
in D: # Используется итератор словаря и операция индексирования
print(key, ":", D[key],
",", end=" ")
# на выходе – a : 1 , b : 2 , c : 3 ,
D = {"a": 1, "b": 2, "c": 3}
for (key, value) in D.items():
print(key, ":", value, ",", end=" ")
# Обход ключей и значений одновременно
# a : 1 , b : 2 , c : 3
Слайд 38Многоуровневые данные
for ((a, b), c) in [([1, 2], 3), ["XY",
6]]:
x = ((a, b), c)
print(x, type(x))
((1, 2), 3)
'tuple'>
(('X', 'Y'), 6)
Каждый х – это кортеж, сборка которого происходит на каждом шаге цикла.
Можно данный цикл переписать так:
for x in [([1, 2], 3), ["XY", 6]]:
print(x, type(x))
([1, 2], 3)
['XY', 6]
х – видоизменяется в зависимости от текущего члена списка
Слайд 39 Поиск пересечений
items = ["aaa", 111, (4, 5), 2.01] # Объекты
tests
= [(4, 5), "aaa"] # Ищем ключи
for
key in tests: # Для всех ключей
for item in items: # Для всех элементов
if item == key: # Проверить совпадение
print(item, key, "нашли")
break
else:
print(item, key, "не нашли!")
Можно и упростить так:
for key in tests: # Для всех ключей
s = "нашли" if key in items else "не нашли"
print(key, s)
aaa (4, 5) не нашли!
111 (4, 5) не нашли!
(4, 5) (4, 5) нашли
aaa aaa нашли
Вложенные циклы
(4, 5) нашли
aaa нашли
Слайд 40Последовательности
Часто возникают задачи программирования нестандартных обходов последовательностей или параллельного обхода
нескольких последовательностей.
Совместно с циклами зачастую используются специальные функции-генераторы последовательностей:
range,
zip,
map,
enumerate
Слайд 41Итерации
Когда создаётся список, можно считывать его элементы один за другим
– это называется итерацией
Всё, то к чему можно применить конструкцию
for… in..., является итерируемым объектом:, строки, файлы, списки, и т.п.…
Итерации:
L = [1, 2, 3]
for i in L:
print(i)
Слайд 42Генераторы
Генераторы – это итерируемые объекты, но прочитать их можно лишь
один раз, поскольку они не хранят значения в памяти, а
генерируют их на лету.
Пример генератора:
mygen = (x*x for x in range(3))
for i in mygen:
print(i, end=" ") # 0 1 4
Нельзя применить конструкцию for i in mygen второй раз, т.к. генератор может быть использован только единожды:
он последовательно вычисляет 0, 1, 4 одно за другим, забывая предыдущие свои значения.
Слайд 43Генератор range
range возвращает непрерывную последовательность увеличивающихся целых чисел, которые можно
задействовать в качестве индексов внутри цикла for.
dir(range ) #[…'count',
'index', 'start', 'step', 'stop']
Синтаксис: range(start_or_stop, stop[, step])
start_or_stop – начальное значение
stop – конечное значение (не включая его!)
step – шаг последовательности. (по умолчанию 1)
Проверка диапазонов на равенство при помощи == и != сравнивает их как последовательности. Т.е. два диапазона равны, если они представляют одинаковую последовательность значений.
Примеры: range(0) == range(2, 1, 3) # True
range(0, 3, 2) == range(0, 4, 2) # True
Слайд 44Свойства range
range использует класс collections.abc.Sequence и поддерживает проверку на содержание,
индексацию и срезы.
count(элемент) – количество вхождений элемента
index(элемент) – индекс элемента,
или ошибку, ValueError, если такой не найден.
Примеры:
r = range(0, 20, 2) # 0, 2, 4…18
11 in r # False
10 in r # True
r.index(10) # 5
r[5] # 10
r[:5] # range(0, 10, 2)
r[-1] # 18
r.count(4) # 1
Слайд 45Примеры последовательностей
list(range(6)) # [0, 1, 2, 3, 4, 5]
list(range(2, 5))
# [2, 3, 4]
list(range(0, 10, 3)) # [0, 3, 6,
9]
list(range(0, -5, -1)) # [0, -1, -2, -3, -4]
list(range(0)) # []
list(range(1, 0)) # []
Использование последовательности в цикле для доступа по индексу:
X = ["a", "b", "c"]
for i in range(len(X)):
print(X[i], end=" ") # a b c
Слайд 46Инициализация списков
Метод 1
x = [[1,2,3,4]] * 3
# [[1, 2, 3,
4], [1, 2, 3, 4], [1, 2, 3, 4]]
Метод 2
y
= [[1,2,3,4] for __ in range(3)]
[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
Однако:
x[0][2] = 9 # [[1, 2, 9, 4], [1, 2, 9, 4], [1, 2, 9, 4]]
y[0][2] = 9 # [[1, 2, 9, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
Слайд 47Конкатенация диапазонов
Операции для списков не работают с диапазонами.
Попробуем создать несвязанный
диапазон:
range(0, 2) + range(10, 13) # ОШИБКА
Использовав функцию chain из
itertools:
from itertools import chain
conc = chain(range(0, 2), range(10, 13))
for i in conc:
print(i)
Реализация функции chain:
def chain(*iterables):
# chain('ABC', 'DEF') --> A B C D E F
for it in iterables:
for element in it:
yield element
По itertools см. https://pythonworld.ru/moduli/modul-itertools.html
0
1
10
11
12
Слайд 48Включения
Включение (comprehension) – это компактный способ создать структуру данных из
одного или более итераторов.
Включения позволяют объединять циклы с условными
проверками, не используя при этом громоздкий синтаксис.
Это одна из характерных особенностей Python.
Слайд 49Включение списка
Список может быть сгенерирован как
number_list = list(range(1, 5)) #
[1, 2, 3, 4]
Формат включения списка является более характерным для
Python:
[<выражение> for <элемент> in <итерабельный объект>]
Предыдущий пример можно переписать так:
number_list = [number for number in range(1, 5)]
# сгенерирован список [1, 2, 3, 4]
Читаем: Собрать в список number_list числа number из диапазона 1…4 [с шагом 1].
Слайд 50Пример включения списка
Сначала идет выражение, которое будет задавать элементы списка,
потом – цикл, с помощью которого можно изменять выражение
Подсчёт квадратов
чётных чисел от 2 до 8
res = [x**2 for x in range(2, 8, 2)] #[4, 16, 36]
Читаем: в список res собрать все x**2 для х из диапазона от 2 до 7 с шагом 2
Слайд 51Условное включение списка
Включение списка может содержать условное выражение:
[ for
in
if ]
Создадим список чётных чисел в диапазоне
от 1 до 9:
Традиционно (если не использовать шаг):
a_list = []
for num in range(1, 10):
if num % 2 == 0:
a_list.append(num)
print(a_list) # [1, 3, 5, 7, 9]
С условным включением:
a_list = [num for num in range(1, 10) if num % 2 == 0]
print(a_list) # [1, 3, 5, 7, 9]
Читаем: В список a_list включаем те элементы num из диапазона (1…9), если num % 2 == 0
Слайд 52Замена вложенного цикла
rows = range(1, 4)
cols = range(1, 3)
for row
in rows:
for col in cols:
print(row, col)
Заменяем
rows = range(1,
4)
cols = range(1, 3)
cells = [(row, col) for row in rows for col in cols]
for row, col in cells:
print(row, col) # см. справа =>
# в cells [(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)]
Читаем: в список cells собираем кортежи
(row, col), где первый элемент кортежа row
из диапазона rows, второй элемент
col – из диапазона cols.
1 1
1 2
2 1
2 2
3 1
3 2
1 1
1 2
2 1
2 2
3 1
3 2
Слайд 53Включение для словаря
Синтаксис:
{: for in }
Пример. Проходя по
каждой из letter букв в строке wd, считаем сколько раз
появляется эта буква.
wd = "текст"
count = {letter: wd.count(letter) for letter in wd}
print(count) # {'т': 2, 'е': 1, 'к': 1, 'с': 1}
Читаем: включить в словарь count c ключами letter количество вхождений буквы letter в строку wd.
Слайд 54Кортежи и включения
Для кортежей не существует включений.
При необходимости можно конвертировать
список в кортеж обычным способом:
a_list = [num for num in
range(1, 10) if num % 2 == 1]
a_tup = tuple(a_list)
print(a_tup) # (1, 3, 5, 7, 9)
Слайд 55Генерирование индексов и элементов: enumerate
В некоторых программах требуется получить
и элемент, и его индекс.
Обычное решение:
S = "текст"
i =
0
for item in S:
print(item, "индекс", i)
i += 1
Но можно короче:
for (i, item) in enumerate(S):
print(item, " индекс", i)
т индекс 0
е индекс 1
к индекс 2
с индекс 3
т индекс 4
т индекс 0
е индекс 1
к индекс 2
с индекс 3
т индекс 4
Слайд 56Cинтаксис enumerate
enumerate(iterable[, start=0]) – возвращает кортеж (index, value) для каждого
элемента списка.
Эквивалентная запись:
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield
n, elem
n += 1
yield –это ключевое слово, которое используется примерно как return – отличие в том, что функция вернёт генератор.
Слайд 57Примеры
S = "текст"
E = enumerate(S)
print(list(E))
# [(0, 'т'), (1, 'е'),
(2, 'к'), (3, 'с'), (4, 'т')]
Генератор поддерживает метод next
S =
"текст" #
E = enumerate(S)
print(E)
print(next(E)) # (0, 'т')
print(next(E)) # (1, 'е')
print(next(E)) # (2, 'к')
print(next(E)) # (3, 'с')
print(next(E)) # (4, 'т')
Слайд 58Другие итераторы встроенных типов
Помимо файлов и фактических последовательностей, таких как
списки, удобные итераторы также имеют и другие типы.
Классический обход словаря:
d
= {"a":1, "b":2, "c":3}
for key in d.keys():
print(key, d[key])
И с помощью итератора iter
it = iter(d)
print(next(it))
print(next(it))
print(next(it))
a 1
b 2
c 3
a
b
c