{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Объектно-ориентированное программирование и информационная безопасность\n", "\n", "*Валерий Семенов, Самарский университет*\n", "\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Инструкции

\n", " \n", "
Инструкцией (оператором) называют минимальный самостоятельный элемент языка, определяющий действие, которое требуется выполнить программе.
\n", "
Модулем в Python называется любой файл с программным кодом.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Обычно инструкции (операторы) в программе пишутся по порядку и отделяются друг от друга переходом на следующую строку:
" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "12\n" ] } ], "source": [ "a = 5 # Инструкция \n", "b = 7 # Инструкция \n", "print(a + b) # Инструкция " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Но есть и другой способ, - их можно разделить точкой с запятой ; :
" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mother of Dragons.\n", "Drakarys!\n" ] } ], "source": [ "print('Mother of Dragons.'); print('Drakarys!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Технической разницы между первым и вторым вариантом нет — интерпретатор поймет инструкции одинаково.
\n", "
Разница только в том, что человеку будет неудобно читать второй вариант.
\n", "\n", "
Лучше инструкции располагать друг под другом.
\n", "
Так будет удобнее читать ваш код, обслуживать его и вносить изменения.
\n", "\n", "\n", "

Отступы в Python

\n", "\n", "
Большая часть высокоуровневых языков программирования (C, C++, C#, Java, JavaScript) используют фигурные скобки для выделения блоков кода.
\n", " \n", "
Python делает это с помощью отступов.
\n", "\n", "
Блок кода, представляющий тело функции или цикл, начинается с отступа и заканчивается первой строкой без отступа.
\n", " \n", "

Сколько места занимает один отступ?

\n", "\n", "
Согласно правилам стиля Python (PEP8), размер отступа — 4 символа.
\n", " \n", "
Однако у Google есть собственные правила, ограничивающие этот размер 2 символами. Так что можно руководствоваться и собственным стилем, но лучше следовать PEP8.
\n", " \n", "

Почему отступы так важны в Python?

\n", "\n", "
В большинстве языков программирования отступы используются для улучшения читабельности, но добавлять их необязательно. Но в Python их обязательно нужно использовать. Обычно каждую строку предваряет отступ в 4 символа для одного блока кода.
\n", "\n", "

Составные инструкции

\n", "\n", "
Основная инструкция: (заголовок)
\n", "
Вложенный блок инструкций (тело)
" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7 5\n", "12\n" ] } ], "source": [ "if b > a: # Заголовок\n", " print(b, a) # Тело\n", " print(b + a) # Тело" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Условный оператор if ... elif ... else (ветвление)

\n", " \n", "
Позволяет исполнять определенные инструкции только в том случае, если соблюдаются определенные условия:
" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "12\n" ] } ], "source": [ "a = 5\n", "b = 7\n", "if b > a: # Если b больше а,\n", " print(b+a) # то выводим сумму чисел a и b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
В начале заголовка условного оператора записывается служебное слово if.
\n", "
Далее записывается логическое выражение (условие), которое возвращает логическое значение True (истина) или False (ложь).
\n", "\n", "
Примечание. В языке Python логическое выражение считается истинным (True), если его результат — не ноль или выражение не является пустым объектом. Соответственно, оно считается ложным (False), если результат — ноль или пустой объект, в том числе значение None. При использовании операторов сравнения результатом выражения будет True, если условие выполняется, и False — в противном случае.
\n", "\n", "
Завершается строка символом «двоеточие».
\n", " \n", "
Тело условного оператора может содержать одну или несколько инструкций (строк). Каждая строка начинается с обязательного отступа в четыре пробела, он показывает, что строки объединяются в один блок. Отступ аналогичен использованию фигурных скобок или ключевых слов begin и end в других языках программирования.
\n", "\n", "

Блок-схема конструкции if (ветвление с одной альтернативой)

\n", "
" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] } ], "source": [ "a = 7\n", "b = 5\n", "if b > a: # Если b больше а \n", " print(b+a) # Не выполняется, т.к. a > b!\n", "print(0) # Следующая (не вложенная) инструкция" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] } ], "source": [ "if a > b and a < 10: # Если a больше b и a меньше 10,\n", " print(a) # то выводим a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Блок-схема конструкции if ... else (ветвление с двумя альтернативами)

\n", "
\n", "\n", "
Конструкция if ... else позволяет выполнить один из двух блоков кода в зависимости от того, выполняется условие или нет.
\n", "
Если условие истинно, выполняется блок кода под if.
\n", "
Если условие ложно — под else.
" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "if b > a: # Если b больше a,\n", " print(a) # то выводим а\n", "else: # Иначе\n", " print(b) # выводим b" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Нечетное\n" ] } ], "source": [ "# Запись условия в одной строке функции вывода\n", "x = 3\n", "print('Четное' if x%2 == 0 else 'Нечетное')" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "# Если тело состоит только из 1-й инструкции, \n", "# то можно расположить его на одной строке с заголовком\n", "if b > a: print(a) \n", "else: print(b) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Вложенные операторы if и if ... else

\n", "\n", "
Можно использовать одни условные операторы внутри других. С такими конструкциями можно строить более сложные логические структуры в зависимости от множества условий. Такие операторы полезны, когда нужно проверить несколько условий с дополнительными логическими шагами внутри каждого.
" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x - положительное число\n", "x - четное число\n" ] } ], "source": [ "x = 12\n", "if x > 0:\n", " print(\"x - положительное число\")\n", " if x % 2 == 0: # Оператор if внутри другого оператора if\n", " print(\"x - четное число\")\n", " else:\n", " print(\"x - нечетное число\")\n", "else:\n", " print(\"x - не положительное число\")" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x больше 10\n" ] } ], "source": [ "x = 15\n", "if x > 10:\n", " print(\"x больше 10\")\n", "else:\n", " print(\"x не больше 10\")\n", " if x % 2 == 0: # Оператор if-else внутри условия else\n", " print(\"x - четное число\")\n", " else:\n", " print(\"x - нечетное число\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Блок-схема конструкции if ... elif ... else (множественное ветвление)

\n", "\n", "
По завершении тела может идти следующее условие, которое начинается с оператора elif (сокращение от else if — «иначе если»). Оно проверяется только в случае, если предыдущее условие не было истинным.
\n", "\n", "
Синтаксис в elif аналогичен if.
\n", "
Операторов elif для одного блока условного оператора может быть несколько, а может не быть совсем.
\n", "\n", "
\n", " \n", "
Последним идет оператор else, который не содержит условия, а выполняется, только если ни одно из предыдущих условий в if и elif не выполнилось. Оператор else не является обязательным.
" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "if b > a: # Если b > a,\n", " print(a) # то выводим а\n", "elif b < a: # Иначе если b < a,\n", " print(b) # то выводим b\n", "else: # Иначе\n", " print(0) # выводим 0" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Неплохо, но можно лучше. Ваша оценка — 4.\n" ] } ], "source": [ "grade = 78\n", "if 90 <= grade <= 100:\n", " print(\"Отличная работа! Ваша оценка — 5.\")\n", "elif 80 <= grade < 90:\n", " print(\"Хорошо сделано! Ваша оценка — 4.\")\n", "elif 70 <= grade < 80:\n", " print(\"Неплохо, но можно лучше. Ваша оценка — 4.\")\n", "elif 60 <= grade < 70:\n", " print(\"Средне. Ваша оценка — 3.\")\n", "elif 0 <= grade < 60:\n", " print(\"К сожалению, вы не прошли. Ваша оценка — 2.\")\n", "else:\n", " print(\"Ошибка: Некорректная оценка. Проверьте ввод.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Циклы

\n", "\n", "
В Python циклы работают так же, как в большинстве других языков программирования. Программа повторяет определенный блок кода несколько раз. Повторяющийся блок кода задан в теле цикла, число повторений — в его условии. В условии может быть вполне конкретное число, например пять или десять. А может быть более сложная проверка — например, анализ переменной из тела цикла. Одно повторение тела цикла называется итерацией.
\n", "\n", "

Цикл while

\n", "\n", "
Цикл while (до тех пор пока) позволяет выполнять повторяющиеся действия до тех пор, пока не будет достигнуто определенное условие. Его еще называют циклом с предусловием.
\n", " \n", "
В общем виде конструкция while выглядит следующим образом:
\n", "\n", "
while условие:
\n", "
Вложенный блок инструкций (тело)
" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "4\n", "3\n", "2\n", "1\n" ] } ], "source": [ "i = 5\n", "while i: # Пока i истинно, т.е. не равно 0,\n", " print(i) # выводим i\n", " i -= 1 # Отнимаем от i единицу (то же, что i = i - 1)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n" ] } ], "source": [ "i = 0\n", "while i < 3: # Пока i меньше 3,\n", " print(i) # выводим i\n", " i += 1 # Прибавляем к i единицу (то же, что i = i + 1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
В простоте цикла while кроется опасность, он может быть бесконечным, если в теле цикла всегда будет выполняться условие.
\n", " \n", "
Например, если в коде выше мы уберем x += 1, то получится \"зацикливание\":
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "i = 0\n", "while i < 3: # Пока i меньше 3,\n", " print(i) # выводим i" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
У циклов в Python есть особенность. Внутри тела цикла можно использовать инструкцию else, который сработает, когда условие цикла перестанет выполняться. То есть цикл не просто завершится, а перед окончательным выходом совершит последнее действие.
\n", "\n", "
Например, в условии задано повторение цикла 25 раз, в теле — вывод чисел из условия последовательно, а в инструкции else — слово «Хватит». Тогда цикл сначала выведет по очереди числа от 1 до 25, а потом «Хватит».
\n", "\n", "
В большинстве других языков для этого пришлось бы использовать кроме цикла еще и конструкцию if-else, то есть немного усложнять код. Python позволяет встроить условие else прямо внутрь цикла.
" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "Конец\n" ] } ], "source": [ "i = 0\n", "while i < 3: # Пока i меньше 3,\n", " print(i) # выводим i\n", " i += 1 # прибавляем к i единицу (то же, что i = i + 1)\n", "else: print('Конец')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Итак, цикл while обычно применяется в тех случаях, когда заранее не известно, сколько итераций (повторений) будет выполнено, но известно условие, при котором цикл продолжает работу.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Цикл for

\n", "\n", "
Если количество итераций заранее известно, то предпочтительнее использовать цикл for, который используется для перебора элементов последовательности (списки, кортежи, строки и диапазоны). Этот цикл часто называют счетным циклом.
\n", "\n", "
В общем виде конструкция for выглядит следующим образом:
\n", "\n", "
for текущий элемент in Последовательность :
\n", "
Вложенный блок инструкций (тело цикла)
\n", "\n", "
\n", "
  • Последовательность – объект, поддерживающий механизм итерации;
    • \n", "
  • Текущий элемент – на каждой итерации через этот параметр доступен текущий элемент последовательности.
    • \n", "
    " ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "3\n", "5\n", "7\n", "9\n" ] } ], "source": [ "# Перебор элементов диапазона\n", "for i in range(1,10,2): \n", " print(i)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "22\n", "bb\n", "11.0\n" ] } ], "source": [ "# Перебор элементов списка\n", "y = [1, '2', 'b', 5.5]\n", "for i in y:\n", " print(i*2)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "s\n", "t\n", "r\n", "i\n", "n\n", "g\n", "Цикл выполнен\n" ] } ], "source": [ "# Перебор элементов строки\n", "for s in 'string':\n", " print(s)\n", "else: print('Цикл выполнен')" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2\n", "3 4\n", "5 6\n" ] } ], "source": [ "# С помощью for можно перебирать сложные структуры данных\n", "arr = [(1,2), (3, 4), (5, 6)]\n", "for a, b in arr:\n", " print(a, b)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x 1\n", "y 2\n", "z 3\n" ] } ], "source": [ "# Перебор словаря\n", "d = {'x': 1, 'y': 2, 'z': 3}\n", "for k in d.keys():\n", " print(k, d[k])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Генератор списков

    \n", "\n", "
    В языке программирования Python существует специальная синтаксическая конструкция, которая позволяет по определенным правилам создавать заполненные списки. Такие конструкции называются генераторами списков. Их удобство заключается в более короткой записи программного кода, чем если бы создавался список обычным способом.
    \n", "\n", "
    Например, надо создать список, заполненный натуральными числами до определенного числа. \"Классический\" способ будет выглядеть примерно так:
    " ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = [] # Пустой список a\n", "for i in range(1,15):\n", " a.append(i) # Добавляем i в конец списка a\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    На создание списка ушло три строчки кода. Генератор же сделает это за одну:
    " ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = [i for i in range(1,15)]\n", "\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Здесь конструкция [i for i in range(1,15)] является генератором списка.
    \n", " \n", "
    Вся конструкция заключается в квадратные скобки, что как бы говорит, что будет создан список.
    \n", " \n", "
    Внутри квадратных скобок можно выделить три части:
    \n", "\n", "
    \n", "
  • Выражение, которое будет вычислено для каждого элемента списка (в данном случае ничего не делаем, просто добавляем в список).
    • \n", "
  • Переменная, которая будет использоваться для итерации по элементам последовательности.
    • \n", "
  • Последовательность (например: диапазон, список, кортеж, множество, словарь, строка).
    • \n", "
  • Части отделены друг от друга ключевыми словами for и in.
    • \n", "
    " ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['ss', 'tt', 'rr']" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sss = [i*2 for i in 'str']\n", "sss" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    А еще в генераторе списка может быть условие:
    " ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[9, 4, 2, 3, 1, 9]" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = \"lsj94ksd2319\"\n", "b = [int(i) for i in a if '0'<=i<='9']\n", "b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    В циклах в языке Python можно использовать еще две полезные иструкции: break и continue.
    \n", "\n", "

    Инструкция break

    \n", " \n", "
    Инструкция break прерывает текущий цикл и продолжает выполнение следующих, после оператора цикла, инструкций.
    " ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9\n", "8\n", "7\n", "6\n", "5\n" ] } ], "source": [ "x = 10\n", "while x: # Пока x истинно (не равно нулю)\n", " x -= 1 # Отнимаем 1 (x = x-1)\n", " print(x) # Выводим x\n", " if x == 5: # Если значение x достигло 5,\n", " break # то прерываем выполнение цикла" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "for num in range(10):\n", " if num == 5: break\n", " print(num)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Инструкция continue

    \n", "\n", "
    Инструкция continue позволяет перейти к следующей итерации цикла до завершения выполнения всех инструкций внутри цикла.
    " ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "3\n", "5\n", "7\n", "9\n" ] } ], "source": [ "for num in range(11):\n", " if num%2 == 0: continue # Если num - четное число, то переходим к следующей итерации цикла\n", " print(num)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "9\n", "10\n" ] } ], "source": [ "for num in range(11): # Цикл без continue\n", " print(num)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Инструкция pass

    \n", "\n", "
    Инструкция pass абсолютно ничего не делает. Это особая заглушка, который не выполняет никаких действий. Инструкция pass находит свое применение в тех местах, где синтаксис языка требует наличие блока кода, но мы еще не готовы его написать.
    \n", "\n", "
    Разница между комментариями и pass заключается в том, что комментарии полностью игнорируются интерпретатором Python, а pass не игнорируется.
    " ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "for num in range(5):\n", " if num < 3: pass # Здесь я напишу потом вызов подпрограммы\n", " print(num)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.7" } }, "nbformat": 4, "nbformat_minor": 4 }