Лекция №1
Python (в русском языке встречаются названия питон или пайтон) – высокоуровневый язык
программирования общего назначения с динамической строгой типизацией и
автоматическим
управлением
памятью,
ориентированный
на
повышение
производительности разработчика, читаемости кода и его качества, а также на обеспечение
переносимости написанных на нём программ
Сфера применения Python:
Web-разработка. Всю серверную часть веб-сайта можно написать на Python.
Визуальный интерфейс. В области графики многие задачи тоже решаются с помощью
языка программирования Python.
Базы данных. Современная версия языка создавалась таким образом, чтобы
максимально просто и ясно взаимодействовать с любыми базами данных.
Системное программирование и администрирование. У Python есть интерфейсы для
управления службами различных ОС, в которых она работает – Linux, Windows и др.
Сложные расчёты. В области вычислений язык программирования Python не менее
продвинут, чем C++ и FORTRAN. Для осуществления математических вычислений
создано расширение NumPy.
Машинное обучение. В машинном обучении активно используются не только
основной инструментарий языка, но и фреймворки, а также дополнительные
библиотеки, «заточенные» специальное под ML.
Автоматизация бизнес-процессов. Одна из наиболее востребованных ниш в IT, где
используется Python – это написание коротких скриптов для автоматизации ряда
рабочих процессов и стандартных процедур.
Геймдев.
Где взять Python?
«Чистый» Python на официальном сайте.
Anaconda – это дистрибутивы Python и R. Он предоставляет все необходимые для
решения задач по анализу и обработке данных (с применимостью к Python).
В новых версиях дистрибутивов Linux Python версии 3 уже предустановлен.
Интегрированная среда разработки, ИСР (англ. Integrated development environment – IDE),
также единая среда разработки, ЕСР – комплекс программных средств, используемый
программистами для разработки программного обеспечения (ПО). (IDLE, MU, Thonny,
Spyder IDE, Wing Python IDE, PyCharm Community)
Среда разработки включает в себя:
Текстовый редактор;
Транслятор (компилятор и/или интерпретатор);
Средства автоматизации сборки;
Отладчик.
Интерактивные курсы о Python:
УЧИТЕ ПИТОН. Бесплатные курсы по программированию с нуля. Работает прямо в
браузере.
Code Basics. Это открытый бесплатный проект для изучения основ программирования.
Интерактивные курсы с практикой рассчитаны на тех, кто только начал интересоваться
разработкой.
Лекция №2
Python – интерпретируемый язык программирования, это означает, что действия
выполняются пошагово, друг за другом.
Строки – это последовательности символов в кодировке Unicode. Строки в Python
записываются в кавычках. Можно использовать пару двойных кавычек или пару одинарных
(апострофов).
В Python нет понятия символа.
IDE, работающие с Пайтоном, сохраняют файлы в кодировке UTF-8.
Операции над строками:
Конкатенация или «склеивание» строк: ‘Python’ + “editor” => ‘Pythoneditor’
Повторение строк: 3 * ‘@-*’ => ‘@-*@-*@-*’
Управляющие символы. Чтобы задать собственное форматирование текста, достаточно
применять специальные управляющие символы с обратным слэшем. Следующая таблица
демонстрирует перечень всех используемых в языке Python служебных символов для
форматирования строк:
\n – Перевод каретки на новую строку
\b – Возврат каретки на один символ назад
\f – Перевод каретки на новую страницу
\r – Возврат каретки на начало строки
\t – Горизонтальная табуляция
\v – Вертикальная табуляция
\a – Подача звукового сигнала
\N – Идентификатор базы данных
\u, \U – 16-битовый и 32-битовый символ Unicode
\x – Символ в 16-ричной системе исчисления
Служебные символы для форматирования строк выполняют свои функции автоматически,
но иногда это мешает, например, когда требуется сохранить путь к файлу на диске.
Пример – print(“D:\dir\new”).
Необработанная строка. Чтобы отключить служебные символы, необходимо применить
специальный префикс r перед первой кавычкой литерала. Таким образом, обратные слэши
будут игнорироваться программой во время её запуска. Пример – print(r“D:\dir\new”). Или
же можно использовать двойные обратные слэшы. Пример – print(“D:\\dir\\new”).
Кавычки. Парная кавычка закрывает строку (как скобки в математике закрывают часть
выражения).
Обращение к символам строки. Мы можем обратиться к отдельным символам строки по
индексу в квадратных скобках. Индексация начинается с нуля, поэтому первый символ
строки будет иметь индекс 0. Пример – ‘Python’ [1] => ‘y’. Если мы попытаемся обратиться
к индексу, которого нет в строке, мы получим исключение IndexError. Чтобы получить
доступ к символам, начиная с конца строки, можно использовать отрицательные индексы.
Так, индекс -1 будет представлять последний символ, а -2 – предпоследний символ и так
далее.
Длина строки. В некоторых случаях при работе со строками в Python нам необходимо
определить длину строки. Для её нахождения мы можем использовать функцию len(object) –
возвращает длину (количество элементов) объекта. Пример – len(‘”Чистый” python’) => 15.
Типы данных и оператор присваивания.
Python – язык программирования со строгой динамической типизацией. «Строгая» означает,
что язык не производит неявные преобразования типов (в некоторых «очевидных» случаях
делает, но об этом позже) и не создаёт сюрпризов при их случайном смешении.
Если мы попытаемся, например, сложить целое число и строку, то мы получим исключение
TypeError.
Оператор присваивания. Выражение, стоящее справа от оператора присваивания (=),
вычисляется, и полученное значение присваивается переменной, стоящей слева от оператора
присваивания. При этом предыдущее значение, хранящееся в переменной, «забывается» и
связывается с новым. Если такой переменной не существует, то она создается и с ней
связывается значение.
«Динамическая» типизация означает, что типы объектов определяются в процессе
исполнения программы (runtime). Поэтому в Python можно не указывать типы переменных.
Переменные в Python – это ссылки на объекты, они не содержат информации о типе.
Изменяемые и неизменяемые типы данных. Типы данных в Python можно разделить на
изменяемые (mutable) и неизменяемые (immutable).
К неизменяемым относятся целые числа (int), числа с плавающей запятой (float),
комплексные числа (complex), буквы значения (boot), строки (str), кортежи (tuple) и
неизменяемые множества (frozen set).
К изменяемым – списки (list), множества (set), байтовые массивы (byte arrays) и словари
(dict).
Когда мы присваиваем новое значение к неизменяемому объекту, Python не перезаписывает
его, а создает новый объект с тем же именем. Чтобы в этом убедиться, достаточно проверить
id (уникальный номер), который присваивается к каждому объекту.
Функция id(object) возвращает идентификатор объекта (можно интерпретировать как адрес
объекта в памяти).
Сложение двух целых чисел. «От перемены мест слагаемых сумма не меняется» – это один
из базовых законов арифметики, который также называется коммутативным законом.
Бинарная операция считается коммутативной, если вы получаете тот же самый результат,
поменяв местами операнды.
Вычитание двух целых чисел. Это не коммутативная операция.
Умножение двух целых чисел. Это коммутативная операция.
Деление с остатком целым положительных чисел. Деление – это разбиение целого на равные
части. Деление с остатком – это деление одного натурального числа на другое, при котором
остаток не равен нулю.
Деление двух целых чисел. Это не коммутативная операция. При делении двух чисел
частное всегда будет числом с плавающей запятой.
Возведение в степень осуществляется через две звёздочки (**).
Математические функции, без которых трудно обойтись: abs(number) – абсолютное значение
числа (значение по модулю), round(number, ndigits=None) – возвращает число, округленное
до ndigits знаков после запятой. Если ndigits пропущен или равен None, на вход возвращается
ближайшее целое число.
Комплексные числа (complex) – двумерные числа. Оно имеет вид z = a + b * I, где a и b –
действительные числа, i – так называемая мнимая единица. Число a называется
действительной частью (Re z) комплексного числа z, число b называется мнимой частью (Im
z) комплексного числа z.
Теория функций комплексной переменной находит широкое применение при решении
важных практических задач картографии, электротехники, теплопроводности и др.
Булевы значения. Логический тип данных (bool) (или булевый тип) – это тип данных,
который принимает 2 значения – истина (True) или ложь (False).
Конъюнкция (and) – это логическая операция, принятая в формализованных языках для
образования сложных высказываний из простых и по смыслу эквивалентная
соединительному союзу «и» в естественном языке.
Дизъюнкция – это логическая операция, принятая в формализованных языках для
образования сложных высказываний из простых и по смыслу эквивалентная нестрогому
союзу «или» в естественном языке.
Отрицание – это логико-философская категория, которая определяет несуществование или
непризнание и выражается средствами естественного или искусственного языка.
Сложение по модулю 2 (xor).
Побитовые операторы. Язык Python поддерживает работу с двоичными разрядами (битами)
целочисленных значений, где каждый бит числа рассматривается в отдельности. Для
обеспечения этого в Python используются так называемые битовые или подразрядные
операторы, которые реализуют общеизвестные битовые операции. Поддержка битовых
операторов есть также в других языках программирования.
В битовых операторах (операциях) каждый операнд рассматривается как
последовательность двоичных разрядов (бит), которые принимают значение 0 или 1
(двоичная система исчисления). Над этими разрядами можно выполнять известные
операции (логическое «И», логическое «Или» и т.д.)
& – Побитовое «И»
| – Побитовое «ИЛИ»
~ – Побитовое «НЕ»
^ – Побитовое «XOR»
>> – Побитовый сдвиг вправо
<< – Побитовый сдвиг влево
Цепочки сравнений. Сравнения могут быть связаны произвольно и записаны в цепочки
сравнений, в которых для соединения сравнений используются неявные логические
операторы and.
Сравнение строк – это сравнение их символов по отдельности, которое происходит
последовательно. Сначала сравниваются первые символы, затем – вторые, дальше – третьи
и так далее, пока не закончатся обе строки, при этом учитываются не сами символы, а их
значения Unicode.
Операторы принадлежности (in и not in). Они проверяют, есть ли значение или переменная
в последовательности (строке, списке, кортеже, множестве или словаре). Иначе говоря,
проверяют вхождение элемента в коллекцию. В словаре можно проверить только
присутствие ключа, не значения.
Явное приведение типов. Синтаксис – <требуемый_тип_данных>(выражение). Если
значение не может быть преобразовано, то функция int() генерирует исключение ValueError.
Приоритетности операторов. Вычисления выполняются слева направо, то есть, если в
выражении встретятся операторы одинаковых приоритетов, первым будет выполнен тот, что
слева. Оператор возведения в степень исключение из этого правила. Из двух операторов **
сначала выполнится правый, а потом левый.
Множественное присваивание. Пример – a, b, c = 5.
Алгоритм обмена значений двух переменных (swap). Пример – a, b = b, a.
Составное присваивание. Операция составного присваивания состоит из простой операции
присваивания, скомбинированной с какой-либо другой бинарной операцией. При составном
присваивании вначале выполняется действие, специфицированное бинарной операцией, а
затем результат присваивается левому операнду.
Ввод с консоли. Функция input(). Функция input(prompt) считывает строку символом с
консоли и возвращает её. Если присутствует аргумент prompt, он записывается в
стандартный вывод без перехода на новую строку.
«Ленивые» логические выражения. В ленивых вычислениях каждый элемент данных
вычисляется тогда, когда он понадобится, а не заранее. Эта техника позволяет работать с
потенциально бесконечными структурами данных. В каждый момент времени имеется
только конечное число их элементов, которые уже были зачем-то нужны. Если потом
понадобятся ещё какие-нибудь элементы этой структуры данных, то они тоже будут
вычислены и запомнены.
Логические выражения в Python могут вычисляться не полностью, если в какой-то момент
становится понятен результат вычислений.
Зачем это нужно?
Это экономит вычисления (иногда есть смысл «тяжёлое» выражение ставить справа в
надежде, что его редко придётся вычислять).
Это позволяет избежать ошибок.
Лекция №3
Вывод данных в консоль. Функция print().
Аргумент sep определяет, что будет стоять между переданными объектами, записанными
через запятую. По умолчанию параметр sep имеет значение «пробел».
Аргумент end определяет символ, которым заканчивается выполнение функции print(). По
умолчанию это символ переноса строки на /n.
Аргумент file позволяет переопределить поток вывода. По умолчанию установлено значение
«sys.stdout», то есть данные выводятся в консоль. Если вместо этого указать какой-нибудь
файл, то данные запишутся в него.
Необязательный аргумент flush позволяет отчистить поток вывода. По умолчанию имеет
значение False, когда вывод буферизуется, программист может указать значение «True»,
чтобы вывод производился сразу. Например, если вы пишете в файл данные, то они
попадают в буфер и записываются реально в файл, когда буфер заполнится или будет закрыт
файл. Аналогично и с выводом в консоль, данные записываются, данные записываются в
буфер и выводятся из него в консоль. Если flush выставлен в True, то вывод производится
немедленно.
Форматированный вывод. Для того, чтобы выведенную в консоль информацию можно было
без проблем прочитать и понять, она должна быть форматирована.
Оператор % часто используется для форматирования, и хорошо известен не только
программистам на Python, но и программистам на C/C++б По сути, оператор % - это метка,
вместо которой подставляется значение переменной или выражение.
Общий синтаксис спецификатора %\[флаги]\[ширина]\[.точность]\[длина]спецификатор.
Спецификатор – это самый важный компонент. Он определяет тип переменной и способ её
вывода.
Спецификаторы: d или i (Целое со знаком в десятичном виде); u (Целое без знака в
десятичном виде); o(Беззнаковое в восьмеричной системе счисления); x (Беззнаковое целое
в шестнадцатеричной системе счисления); X (Беззнаковое целое в шестнадцатеричной
системе счисления, верхний регистр); f или F (Число с плавающей точкой); e
(Экспоненциальная форма для числа с плавающей точкой); E (Экспоненциальная форма для
числа с плавающей точкой, верхний регистр); s (Строка).
Флаги: - (Выключка влево на заданное шириной значение); + (Явно указывать знак у числа,
даже для положительных чисел); пробел (Если знак не будет выведен, то вставляет пробел
перед выводимым числом); # (Когда используется вместе с o, x или X, вставляет перед число
0o, 0x или 0X); 0 (Вставляет нули, когда объявлен спецификатор ширины).
Ширина: число (Минимальное количество знаков, которое необходимо вывести. Если в
числе меньше знаков, то вставляет пробелы (или нули).
.Точность: .число (Для спецификаторов целых (d, i, o, u, x, X) точность определяет
минимальное количество знаков, которое необходимо вывести. Если значение короче, то
выводятся нули перед числом. Значение не обрезается, даже если оно длиннее. Точность 0
означает, что для значения 0 ничего не выводится. Для спецификаторов чисел с плавающей
точкой (a, A, e, E, f, F) это число знаков, которые необходимо вывести после десятичной
точки (по умолчанию 6). Для g и G – это число значащий разрядов, которые необходимо
вывести. Для s – выводится указанное число символов. По умолчанию выводятся все
символы до первого нулевого. Если число не стоит, то по умолчанию точность равна 0).
Метод format. Спецификаторы типа: b (Беззнаковое в двоичной системе счисления), %
(Переводит в проценты).
F-строки. Начиная с версии 3.6 в Python появился новый тип строк – f-строки, которые
буквально означают «formatted string». Эти строки улучшают читаемость кода, а также
работают быстрее, чем другие способы форматирования. F-строки задаются с помощью
литерала «f» перед кавычками.
PEP 8 – документ, описывающий соглашение о том, как писать код на языке Python.
Ветвление. Пример синтаксиса №1. (Отступ – 4 пробела)
If a > b:
print(“Первое число больше второго.”)
else:
print(“Второе число больше правого.”)
Пример синтаксиса №2.
If a > b:
print(“Первое число больше второго.”)
else:
if a < b:
print(“Второе число больше правого.”)
else:
if a ==b:
print(“Числа равны.”)
else:
print(“Что-то пошло не так.”)
Пример синтаксиса №3.
If a > b:
print(“Первое число больше второго.”)
else:
if a < b:
print(“Второе число больше правого.”)
else:
print(“Числа равны.”)
Пример синтаксиса «по-пайтоновски» №1:
If a > b:
print(“Первое число больше второго.”)
elif: a < b:
print(“Второе число больше правого.”)
else:
print(“Числа равны.”)
Пример синтаксиса №4:
if x > y > z:
Pass
elif x > z > y:
y, z = z, y
elif y > x > z:
x, y = y, x
elif y > z > x:
x, y, z = y, z, x
elif z > x > y:
x, y, z = z, x, y
elif z > y > x:
x, y, z = z, y, x
print (x, y, z)
Пример синтаксиса «по-пайтоновски» №2:
if x > z > y:
y, z = z, y
elif y > x > z:
x, y = y, x
elif y > z > x:
x, y, z = y, z, x
elif z > x > y:
x, y, z = z, x, y
else
x, y, z = z, y, x
print (x, y, z)
Задача про определение цвета клетки шахматной доски:
x, y = 1, 3
if x % 2 == 0 and y % 2 == 0 or x % 2 == 1 and y % 2 == 1:
print(“Клетка чёрная”.)
else
print(“Клетка белая”.)
Задача про определение цвета клетки шахматной доски (упрощённое решение):
x, y = 2, 8
if x % 2 == y % 2:
print(“Клетка белая.")
else:
print (“Клетка чёрная.”)
Задача про определение количества дней в месяце:
month = 3
if month == 1 or month == 3 or month == 5 or month == 7 or month == 8 or month = 10 or month
= 12:
day = 31
elif month = 4 or month == 6 or month == 9 or month ==11:
day = 30
elif month == 2:
day = 28
else:
day = 0
print(day)
Задача про определение количества дней в месяце (упрощённое решение):
month = 3
if month in (1, 3, 5, 7, 8, 10, 12):
day = 31
elif month in (4, 6, 9, 11):
day = 30
elif month == 2:
day = 28
else:
day = 0
print(day)
Задача про определение количества дней в месяце (красивое решение):
month = 3
match month:
case 1 | 3 | 5 | 7 | 8 | 10 | 12:
day = 31
case 2:
day = 28
case 4 | 6 | 9 | 11:
day = 30
case _:
day = 0
print(day)
Лекция №4
Алгоритм – точное предписание, определяющее вычислительный процесс, ведущий от
варьируемых начальных данных к искомому результату (ГОСТ 19781-74).
Циклическим называется алгоритм, в котором серия команд выполняется определённое
количество раз.
Виды циклическим алгоритмов:
С параметром (счётчиком) – циклы, в которых число повторений известно до начала
выполнения.
С условием – циклы, в которых число повторений неизвестно до начала выполнения:
с предусловием и с постусловием
Пример цикла с параметром №1:
for i in “python”:
print(i)
Пример цикла с параметром №2:
word = “Python”
for i in range(len(word)):
print(word[i])
Пример цикла с параметром №3:
For i in range(5):
print(f“number = {i}”)
Пример цикла с параметром №4:
start, end = 12, 45
for i in range (start, end):
print(f“number = {i}”)
Пример цикла с параметром №5:
start, end, step = 12, 45, 2
for i in range (start, end, step):
print(f“number = {i}”)
Пример цикла с параметром №6:
start, end, step = 12, 45, 2
for i in range (start, end, step):
print(f“number = {i}”)
else:
print(“End.”)
Пример цикла с предусловием №1:
i=0
while i < 7:
print(f“number = {i}”)
Пример цикла с предусловием №2:
start, end, step = 45, -12, -3
i = start
while i > end:
print(f“number = {i}”)
i += step
Вложенные (внутренние) циклы. Внутри алгоритма циклической структуры может быть
помещен другой цикл – вложенный (внутренний) цикл. Вложенный цикл должен полностью
находиться в области внешнего цикла.
Пример вложенного цикла:
for i in range(1, 10):
for j in range(1, 10):
print(f“{i * j:3d}”, end=“”)
print()
Метод «грубой силы» (англ. brute force) или метод решения «в лоб» представляет собой
прямой подход к решению задачи, обычно основанный непосредственно на формулировке
задачи и определениях используемых ею концепций.
Возведение числа в степень с натуральным показателем. По определению степень числа a с
натуральным показателем n равна произведению n множителей, каждый из которых равен a,
то есть, an = (a * a * … * a) / n.
a, n = int(input()), int(input())
result = 1
for _ in range(1, n + 1):
result *= a
print(f“{a} ^ {n} = {a ** n}”)
print(f“{a} ^ {n} = {result}”)
Метод «Разделяй и властвуй» – схема разработки алгоритмов, заключающаяся в
рекурсивном разбиении решаемой задачи на две или более подзадачи того же типа, но
меньшего размера, и комбинировании их решений для получения ответа к исходной задаче;
разбиения выполняются до тех пор, пока все подзадачи не окажутся элементарными.
a, n = int(input()), int(input())
result, x, m = 1, a, n
while m > 0:
if m % 2 != 0:
result *= x
x *= x
m //=2
print(f“{a} ^ {n} = {a ** n}”)
print(f“{a} ^ {n} = {result}”)
Наибольшее натуральное число, на которое делятся без остатка числа m и n, называют
наибольшим общим делителем (НОД) этих чисел.
Возможные обозначения наибольшего общего делителя чисел m и n:
НОД(m; n);
gcd(m, n) (от англ. Greatest common divisor);
hcf(m, n) (от брит. highest common factor).
Алгоритм нахождения НОД чисел m и n:
Разложить данные числа на простые множители.
Выписать все простые числа, которые одновременно входят в каждое из полученных
разложений.
Каждое из выписанных простых чисел взять с наименьшим из показателей степени, с
которыми оно входит в разложения данных чисел.
Записать произведение полученных степеней.
Алгоритм Евклида:
Из большего числа вычитаем меньшее.
Если получается 0, значит, числа равны друг другу и являются НОД (следует выйти из
цикла).
Если результат вычитания не равен 0, то большее число заменяем на результат
вычитания.
Переходим к пункту 1.
m, n = int(input()), int(input())
while m != n:
if m > n:
m -=
else:
n -= m
print(m)
Модифицированный алгоритм Евклида.
Большее число делим на меньшее.
Если делится без остатка, то меньшее число и есть НОД (следует выйти из цикла).
Если есть остаток, то большее число заменяем на остаток от деления.
Переходим к пункту 1.
m, n = int(input()), int(input())
while m != 0 and n != 0:
if m > n:
m %= n
else:
n %= m
print (m + n)
Или…
import math
print(math.gcd(m, n))
Наименьшее общее кратное (НОК) натуральных чисел m и n называют наименьшее
натуральное число, которое кратно и m, и n. Возможные обозначения наименьшего общего
кратного чисел m и n:
НОК(m, n);
LCM(m, n) или lcm(m, n).
Алгоритм нахождения НОК:
Разложить данные числа на простые множители.
Выписать все простые числа, которые входят хотя бы в одно из полученных
разложений.
Каждое из выписанных простых чисел взять с наибольшим из показателей степени, с
которыми оно входит в разложения данных чисел.
Записать произведение полученных степеней.
Для любых натуральных чисел a и b справедливо равенство: НОД(a; b) * НОК(a; b) = a * b.
print(math.lcm(56, 196))
Числа Фибоначчи (только положительные):
f0, f1 = 0, 1
n = int(input())
if n == 0:
print(f“f*({n}) = {f0}”)
else:
for _ in range(2, n + 1):
f0, f1 = f1, f0 + f1
print(f“f({n}) = {f1}”)
Числа Фибоначчи:
f0, f1 = 0, 1
n = int(input())
if n < 0:
n, sign = abs(n), (-1) ** ((n + 1) % 2)
if n == 0:
print(f“f*({n}) = {f0}”)
else:
for _ in range(2, n + 1):
f0, f1 = f1, f0 + f1
print(f“f({n}) = {sign * f1}”)
Лекция №5
Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента
(подстроки).
Пример: text = “PyCharm Community Edition” | text[8:16].
text[16:8] выдаст ‘’.
text[8:] выдаст текст от 7-ого символа до последнего.
text[:8] выдаст текст от 0-ого символа до 7-ого.
text[:] выдаст весь текст.
text[-9:-3] – срез с конца.
text[5: 23: 2] – каждый второй символ в диапазоне от 4-ого до 22-ого.
text[16:7:-1] – запись отрезка в обратном порядке ИЛИ text[::-1].
text[::2] – каждый чётный.
text[1::2] – каждый нечётный.
text.capitalize() – капитализация. Первое слово с красной строки, все остальные строчные.
“PyCharm Community Edition”.capitalize() => “Pycharm community edition”.
text.casefold() – приводит к одному регистру все символы.
text.center(30) – выравнивание текста по центру.
text.center(30, “_”) – выравнивание с заполнителем (в один символ).
text.count(“m”) – подсчёт символа в строке.
text.count(“m, 10”) – подсчёт символа, начиная с 9-ого символа.
text.count(“m, 10, 30”) – подсчёт символа, начиная с 9-ого символа, а заканчивая 29-ым.
text.endswith(‘ion’) – выдаёт True, если строка заканчивается сочетанием “ion”.
text.endswith(‘ion’, 10, 17) - выдаёт True, если выделенный сектор заканчивается сочетанием
“ion”.
“0/t01/t012/t0123”.expandtabs(4) – расширяет расстояние между символами.
text.find(‘ty’) – выдаст, с какого символа начинается это сочетание в строке, причём первое
вхождение. ИЛИ text.index(“y”).
text.find(“y”, 2) – выдаст второе вхождение символа. Если выдаётся отрицательное значение,
то такого символа нет в строке.
text.isalnum() – проверяет, состоит ли строка из одних цифр, но включает не только
десятичные цифры.
text.isalpha() – проверяет, состоит ли строка из одних букв. Пробел – не буква.
“02133”.isdecimal() – проверяет, состоит ли строка из одних цифр, но включает только
десятичные цифры.
“12.3”.isdigit() – проверяет, является ли всё цифрами.
text.islower() – проверяет, находятся ли все символы в нижнем регистре.
text.isupper() – проверяет, находятся ли все символы в верхнем регистре.
text.ljust(30) – выравнивает строку по левому краю.
text.ljust(30, “_”) – выравнивает строку по левому краю с заполнителем.
text.lstrip() – убирает все пробельные символы слева.
text.rstrip() – убирает все пробельные символы справа.
“PyCharm Community Edition”.replace(“y”, “$”) – заменяет символы “y” на “$”.
“PyCharm Community Edition”.replace(“y”, “$”, 1) – заменяет первый символ “y” на “$”.
text.rfind(“y”) – поиск символа с правого конца.
text.rjust(30) – выравнивает строку по правому краю.
text.rjust(30, “_”) – выравнивает строку по правому краю с заполнителем.
text.startswith(“Py”) – проверяет, начинается ли строка с этого сочетания.
text.strip() – убирает все пробельные символы справа и слева.
text.title() – все слова начинаются с большой буквы.
text.upper() – все слова в верхнем регистре.
text.lower() – все слова в нижнем регистре.
Лекция №6
Списки в Python – упорядоченный изменяемый набор объектов произвольных типов,
пронумерованных от 0. Они используются для хранения и работы с данными.
a = [1, 2, 3, 4, 5]
list(‘123456789’)
Целое число нельзя сделать списком.
В Python можно делать срезы списков.
Возможна контаминация списков.
del[3:9] – удалить элементы в определённом диапазоне.
Можно делать списки списков (вложенные списки).
Как сделать матрицу:
a = []
for _ in range (10):
a += [[0] * 10]
Матрица со случайным заполнением:
import random
a = []
for _ in range(10)
a += [random.randint(10,99)]
Поиск элемента №1:
flag = False
x = 33
for i in range(len(a)):
if x == 1:
flag = True
if flag:
print(‘yes’)
else:
print(‘no’)
Поиск элемента №2:
flag = False
x = 33
for i in a:
if x == 1:
flag = True
print(‘yes’ if flag else ‘no’)
Поиск элемента №3:
flag = False
i=0
x = 10
while i < len(a) and not flag:
if x == a[i]:
flag = True
i += 1
print(‘yes’ if flag else ‘no’)
Поиск элемента №4:
flag = False
x = 33
for i in range(len(a)):
if x == a[i]:
print(‘yes’)
break
else:
print(‘no’)
Поиск элемента №5:
flag = False
x = 33
for i in range(len(a)):
if x == a[i]:
index = i
break
else:
index = -1
print(index)
Упорядоченная последовательность:
print(*a)
n = len(a)
for i in range(n – 1):
minimum = i
for j in range(i + 1, n)
if a[j] < a[minimum]:
minimum = j
a[i], a[minimum] = a[minimum], a[i]
print(*a)
Методы сортировки: sorted(a) / a.sort()
С помощью random.shuffle(a) можно перемешать список.
Лекция №7
Во множестве могут быть элементы любой природы (кроме изменяемых).
В кортежах, в отличие от списков, элементы нельзя менять.
a = {1, “3434”, (1, 2)}.
Пустое множество задаётся через set().
a.remove() – удалить элемент из множества.
a.clear() – очистить множество.
a = set([1, 2, 3, 4, 5, 1, 3, 3, 4, 5]) – Преобразование списка в множество. Не может быть
одинаковых элементов в множестве, поэтому оно будет выглядеть так – {1, 2, 3, 4, 5}.
a.union(b) ; a | b – объединить два множества.
b.intersection(a) ; a & b – общие элементы множеств.
a.difference(b) – вывести a, удалив общие элементы с b.
a.symmetric_difference(b) – сложить, удалив общие элементы.
Множества можно сравнивать.
Пример с задачей про пароль
set.paswd = set(password)
if len(password) < 16:
print(“Длина пароля должна быть больше 16 символов.”)
elif not set.paswd & (abc | ABC):
print(“Пароль должен содержать строчные и заглавные латинские буквы”.)
elif not set.paswd & abc:
print(“Пароль должен содержать строчные латинские буквы“.)
elif not set.paswd & ABC:
print(“Пароль должен содержать заглавные латинские буквы“.)
elif not set.paswd & numbers:
print(“Пароль должен содержать цифры“.)
elif not set.paswd & symbols:
print(f“Пароль должен содержать специальные символы: {‘, ‘.join(symbols)}.”.)
elif set.paswd – abc – ABC – numbers – symbols:
print(f“Пароль должен содержать только строчные и заглавные латинские буквы,
цифры и специальные символы: {‘, ‘.join(numbers)}.”.)
else:
print(“Хороший пароль.”)
Лекция №8
Функции.
Пример функции №1:
def print_hello():
print(“Hello”)
print_hello()
Пример функции №2:
def print_name(name):
print(f“Hello, {name}”)
print_name(“Dad”)
Пример функции №3:
def print_person(name, age=18):
print(f“Name: {name} Age: {age}”)
print_person(“Andrew”, 45)
Пример функции №4:
def sum(*numbers):
result = 0
for number in numbers:
result += number
print(f“sum = {result}”)
sum(1, 2, 3)
Пример функции №5:
def final_price(price, discount=1:
return price – price * discount / 100
print final_price(1000, discount=10)
Лямбда-функции в Python являются анонимными. Это означает, что функция безымянна. Как
известно, ключевое слов def используется в Python для определения обычной функции. В
свою очередь, ключевое слово lambda используется для определения анонимной функции.
Лямбда-функция имеет следующий синтаксис – lambda аргументы: выражение
Лямбда-функция:
final_price = lambda price, discount: price – price * discount / 100
Нужно быть аккуратным с названиям функций, чтобы они не повторялись с базовыми
(например, print и sum)
Словари.
dictionary = dict() ИЛИ dictionary = {}
У словаря есть ключ и значение (key and value)
dictionary = {1: “Hello”, 2: “World”}
Оператор * чаще всего ассоциируется у людей с операцией умножения, но в Python он имеет
и другой смысл. Этот оператор позволяет «распаковывать» объекты, внутри которых
хранятся некие элементы.
Итак, мы знаем о том, что оператор «звёздочка» в Python способен «вытаскивать» из
объектов составляющие их элементы. Знаем мы и о том, что существует два вида параметров
функций. Вполне возможно, что вы уже додумались до этого сами, но я, на всякий случай,
скажу об этом. А именно, *args — это сокращение от «arguments» (аргументы), а **kwargs
— сокращение от «keyword arguments» (именованные аргументы).
Каждая из этих конструкций используется для распаковки аргументов соответствующего
типа, позволяя вызывать функции со списком аргументов переменной длины.
