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

Области видимости переменных

\n", "\n", "
В программировании особое внимание уделяется концепции локальных и глобальных переменных, а также связанное с ними представление об областях видимости.
\n", "\n", "
Глобальные переменные – это переменные, объявленные в программе вне функции. В Python глобальные переменные видны (то есть, - известны, доступны) в любой части модуля, включая функции. К ним можно обратиться по имени и получить связанное с ними значение.
\n", "\n", "
Локальные переменные – это переменные, объявленные внутри функции. Они видны только в локальной области видимости, которой является тело функции.
\n", "\n", "
К локальной переменной нельзя обратиться из глобальной области видимости, потому что локальная переменная существует только в момент выполнения тела функции. При выходе из нее, локальные переменные исчезают. Компьютерная память, которая под них отводилась, освобождается. Когда функция будет снова вызвана, локальные переменные будут созданы заново.
\n", "\n", "\n", "
Таким образом, локальные переменные отлично подходят для временного хранения промежуточных результатов, необходимых только в пределах одной функции.
\n", "\n", "
Рассмотрим следующий код:
" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "Введите номер фигуры (1-прямоугольник, 2-треугольник): 2\n", "Основание: 4\n", "Высота: 5\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Площадь: 10.00\n" ] } ], "source": [ "def rectangle(): # Площадь прямоугольника\n", " a = float(input(\"Ширина: \"))\n", " b = float(input(\"Высота: \"))\n", " print(\"Площадь: %.2f\" % (a * b))\n", "\n", "def triangle(): # Площадь треугольника\n", " a = float(input(\"Основание: \"))\n", " h = float(input(\"Высота: \"))\n", " print(\"Площадь: %.2f\" % (0.5 * a * h))\n", "\n", "figure = input(\"Введите номер фигуры (1-прямоугольник, 2-треугольник): \")\n", "\n", "if figure == '1':\n", " rectangle()\n", "elif figure == '2':\n", " triangle()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", "
\n", "
\"\"Сколько здесь переменных?
\n", "
Какие из них являются глобальными?
\n", "
Какие переменные являются локальными?    
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Здесь пять переменных.
\n", " \n", "
Глобальной является только figure.
\n", " \n", "
Переменные a и b из функции rectangle, а также a и h из triangle – локальные. При этом локальные переменные с одним и тем же идентификатором a, но объявленные в разных функциях, – разные переменные.
\n", "\n", "
Следует отметить, что идентификаторы rectangle и triangle, хотя и не являются именами переменных, а представляют собой имена функций, также имеют область видимости. В данном случае она глобальная, так как функции объявлены непосредственно в основной ветке программы.
\n", "\n", "
В приведенной программе к глобальной области видимости относятся заголовки объявлений функций, объявление и присваивание переменной figure, конструкция условного оператора.
\n", "\n", "
К локальной области относятся тела функций. Если, находясь в глобальной области видимости, мы попытаемся обратиться к локальной переменной, то возникнет ошибка:
" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "Ширина: 4\n", "Высота: 5\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Площадь: 20.00\n" ] }, { "ename": "NameError", "evalue": "name 'a' is not defined", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[2], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m rectangle()\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(a)\n", "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined" ] } ], "source": [ "rectangle()\n", "\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Однако мы можем обращаться из функций к глобальным переменным:
" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "Введите номер фигуры (1-прямоугольник, 2-треугольник): 1\n", "Ширина фигуры 1: 4\n", "Высота фигуры 1: 5\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Площадь: 20.00\n" ] } ], "source": [ "def rectangle(): # Площадь прямоугольника\n", " a = float(input(\"Ширина фигуры %s: \" % figure))\n", " b = float(input(\"Высота фигуры %s: \" % figure))\n", " print(\"Площадь: %.2f\" % (a * b))\n", "\n", "def triangle(): # Площадь треугольника\n", " a = float(input(\"Основание фигуры %s: \" % figure))\n", " h = float(input(\"Высота фигуры %s: \" % figure))\n", " print(\"Площадь: %.2f\" % (0.5 * a * h))\n", "\n", "figure = input(\"Введите номер фигуры (1-прямоугольник, 2-треугольник): \")\n", "\n", "if figure == '1':\n", " rectangle()\n", "elif figure == '2':\n", " triangle()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
В данном случае из тел функций происходит обращение к имени figure, которое, из-за того, что было объявлено в глобальной области видимости, видимо во всей программе.
\n", "\n", "
Наши функции не совсем идеальны. Они должны вычислять площади фигур, но выводить результат на экран им не следовало бы. Вполне вероятна ситуация, когда результат нужен в программе для каких-то дальнейших вычислений, а выводить ли его на экран – вопрос второстепенный.
\n", "\n", "
Если функции не будут выводить, а только вычислять результат, то его надо где-то сохранить для дальнейшего использования. Для этого подошли бы глобальные переменные. В них можно записать результат.
\n", " \n", "
Напишем программу вот так:
" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "Введите номер фигуры (1-прямоугольник, 2-треугольник): 2\n", "Основание: 4\n", "Высота: 5\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Площадь фигуры: 0.00\n" ] } ], "source": [ "def rectangle(): # Площадь прямоугольника\n", " a = float(input(\"Ширина: \"))\n", " b = float(input(\"Высота: \"))\n", " result = a * b\n", "\n", "def triangle(): # Площадь треугольника\n", " a = float(input(\"Основание: \"))\n", " h = float(input(\"Высота: \"))\n", " result = 0.5 * a * h\n", "\n", "result = 0\n", "\n", "figure = input(\"Введите номер фигуры (1-прямоугольник, 2-треугольник): \")\n", "\n", "if figure == '1':\n", " rectangle()\n", "elif figure == '2':\n", " triangle()\n", "\n", "print(\"Площадь фигуры: %.2f\" % result)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Итак, мы ввели в программу глобальную переменную result и инициировали ее нулем. В функциях ей присваивается результат вычислений. В конце программы ее значение выводится на экран. Мы ожидаем, что программа будет прекрасно работать.
\n", " \n", "
Однако… что-то пошло не так. :-(
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Дело в том, что в Python присвоение значения переменной совмещено с ее объявлением (во многих других языках это не так).
\n", " \n", "
Поэтому, когда имя result впервые упоминается в локальной области видимости, и при этом происходит присваивание ей значения, то создается локальная переменная result. Это другая переменная, никак не связанная с глобальной result.
\n", "\n", "
Когда функция завершает свою работу, то значение локальной result теряется, а глобальная не была изменена.
\n", "\n", "
Когда мы вызывали внутри функции переменную figure, то ничего ей не присваивали. Наоборот, мы запрашивали ее значение. Интерпретатор Питона искал такую переменную сначала в локальной области видимости и не находил. После этого шел в глобальную и находил.
\n", "\n", "
В случае с result он ничего не ищет. Он выполняет вычисления справа от знака присваивания, создает локальную переменную result, связывает ее с полученным значением.
\n", "\n", "\n", " \n", " \n", " \n", "
\n", "
\"\"На самом деле можно принудительно обратиться к глобальной переменной.
Для этого существует команда global:
\n", "
" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "Введите номер фигуры (1-прямоугольник, 2-треугольник): 2\n", "Основание: 4\n", "Высота: 5\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Площадь фигуры: 10.00\n" ] } ], "source": [ "def rectangle(): # Площадь прямоугольника\n", " a = float(input(\"Ширина: \"))\n", " b = float(input(\"Высота: \"))\n", " global result\n", " result = a * b\n", "\n", "def triangle(): # Площадь треугольника\n", " a = float(input(\"Основание: \"))\n", " h = float(input(\"Высота: \"))\n", " global result\n", " result = 0.5 * a * h\n", "\n", "result = 0\n", "\n", "figure = input(\"Введите номер фигуры (1-прямоугольник, 2-треугольник): \")\n", "\n", "if figure == '1':\n", " rectangle()\n", "elif figure == '2':\n", " triangle()\n", "\n", "print(\"Площадь фигуры: %.2f\" % result)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
В таком варианте программа будет работать правильно.
\n", "\n", "
Однако менять значения глобальных переменных в теле функции – плохая практика. В больших программах трудно отследить, где, какая функция и почему изменила их значение. Программист смотрит на исходное значение глобальной переменной и может подумать, что оно остается таким же. Сложно заметить, что какая-то функция поменяла его. Подобное может привести к логическим ошибкам.
\n", "\n", "
Чтобы избавиться от необходимости использовать глобальные переменные, для функций существует возможность возврата результата своей работы в основную ветку программы. И уже это полученное из функции значение можно присвоить глобальной переменной в глобальной области видимости. То есть программист видит изменение значения переменной в основной ветке программы. Это делает программу более понятной.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Рекурсия

\n", "\n", "
\n", "\n", "
В Python (как и в большинстве языков программирования) функция может вызывать другую функцию.
\n", " \n", "
Но функция также может вызывать саму себя.
\n", " \n", "\n", " \n", " \n", " \n", "
\n", "
\"\"Рекурсия - это прием программирования, при которой функция вызывает саму себя.
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Рекурсия бывает полезна при выполнении некоторых задач в программировании.
\n", "\n", "
Соответственно, рекурсивная функция — это такая функция, которая в процессе выполнения вызывает саму себя.
\n", "\n", "
Рекурсивные функции состоят из двух частей: базового случая и рекурсивного случая.
\n", " \n", "
Базовый случай — это условие, при котором функция прекращает вызывать саму себя и возвращает результат.
\n", " \n", "
Рекурсивный случай — это условие, при котором функция вызывает саму себя для решения меньшей подзадачи.
\n", "\n", "

Вычисление факториала

\n", "\n", "
Факториал числа n обозначается как n!. Это произведение всех натуральных чисел от 1 до n.
\n", " \n", "
Например, 5! = 5 * 4 * 3 * 2 * 1 = 120. \n", " \n", "
Факториал можно выразить через рекурсию следующим образом:
\n", "\n", "
Базовый случай - если n равно 1, то n! = 1
\n", " \n", "
Рекурсивный случай - если n больше 1, то n! = n * (n-1)!
\n", "\n", "
Для решения такой задачи можно использовать два алгоритма - итерационный и рекурсивный.
\n", "\n", "

Итерационный (или пошаговый) алгоритм

\n", " \n", "
Напишем цикл с количеством повторений, равным n, начиная с единицы, в котором на каждом шаге будем умножать номер шага на величину произведения factorial:
" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "120" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def factorial(n): # Функция вычисления факториала\n", " factorial = 1\n", " for i in range(1, n+1):\n", " factorial *= i\n", " return factorial\n", "\n", "factorial(5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Результат можно проверить здесь.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Рекурсивный алгоритм

\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "120" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def factorial(n): # Функция вычисления факториала\n", " if n == 1:\n", " return 1 # Базовое решение\n", " else:\n", " return n * factorial(n-1) # Рекурсивный вызов\n", "\n", "factorial(5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Преимущества рекурсии

\n", "\n", "
Рекурсивный подход многим нравится, потому что он изящный и емкий, а описать такой алгоритм часто быстрее, чем аналоги. Вот основные преимущества создания рекуррентных решений.
\n", "
Ясность. Прочитать рекурсивный код обычно проще, чем программу, полную ухищрений для решения той же задачи без рекурсии. Это важный плюс, если речь идет о коммерческом программировании, где код часто смотрят другие люди.
\n", "
Наглядность. Некоторые задачи, вроде тех же чисел Фибоначчи или факториалов, — рекурсивные по самому своему определению. То же самое касается задач на ряды, фракталы и так далее. Решить такую задачу через рекурсию — один из наиболее наглядных и интуитивно понятных способов. Более того: люди пользуются рекурсией все время, даже просто когда разговаривают, и это лишний раз работает на интуитивное ее понимание.
\n", "
Краткость. Рекурсивная функция обычно короче, чем реализация без рекурсии. Разработчику проще и удобнее написать несколько строк кода, чем создавать огромную программу, тратить время и силы и путаться в написанном.
\n", "
Красота. Наконец, сам концепт многие считают красивым и изящным. Это и правда так — посмотрите на фракталы и снежинки: в них есть определенная красота. Рекурсию используют даже в искусстве: от матрешек до сложных узоров, украшающих готические соборы.
\n", "\n", "

Недостатки рекурсии

\n", "\n", "
Недостатков у рекурсивного подхода два, но они критичные и серьезно ограничивают применение этой концепции даже там, где она напрашивается.\n", "
Риск переполнения. При всем перечисленном программисты пользуются рекурсией довольно осторожно. Она устроена так, что, пока не выполнится последний вызов функции, все предыдущие не завершатся — ведь они как бы «вкладывают» в себя последующие. Поэтому такие программы отнимают много ресурсов компьютера. Так что разработчики смотрят и на параметр производительности и решают, что выгоднее в конкретном случае — использовать рекурсию или нет.
\n", "
Риск бесконечности. Если что-то пошло не так и программист случайно получил бесконечную рекурсию, единственный выход — принудительно закрыть программу. А потом переписать ее, чтобы ошибка не повторялась при следующем запуске.
\n", "\n", "

Чем пользоваться, рекурсией или циклом?

\n", "\n", "
Недостатки выше — не повод отказываться от рекурсивных решений совсем. Просто в каждом случае, где можно применить рекурсию, разработчик должен спрашивать себя, оптимально это или нет.
\n", "\n", "
Если программе важна высокая скорость работы и низкая нагрузка или существует риск переполнения памяти — лучше выбрать вариант без рекурсии.
\n", "
Если скорость не так важна, а реализация без рекурсии отнимет много времени и строк кода — лучше воспользоваться рекурсивным подходом.
\n", "\n", "
Понимание, что лучше использовать в конкретном случае, приходит с опытом. Начинающим разработчикам в любом случае стоит освоить рекурсию: это важная часть программирования и информатики вообще.
\n", "\n", "
И, наконец, рекурсию можно встретить не только в программировании.
\n", "
Это вполне распространенное явление даже в повседневной жизни (ссылка и еще одна ссылка).
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Анонимные функции (lambda-выражения)

\n", "\n", "
В языке Python можно создавать функции с уникальными именами, но иногда имя не требуется. Например, функциям, использующимся единственный раз. В таких случаях применяют анонимные функции.
\n", "\n", "
Помимо стандартного определения функции, состоящего из заголовка с ключевым словом def и блока кода – тела функции, в Python можно создавать короткие однострочные функции с использованием ключевого слова lambda. Это анонимные функции или лямбда-функции (lambda-выражения).
\n", "\n", "\n", " \n", " \n", " \n", "
\n", "
\"\"Анонимные функции – функции с телом, но без имени.
\n", "
\n", "\n", "
Lambda-выражение может принимать любое количество аргументов, но оно всегда возвращает одно выражение.
\n", "\n", "
Общий формат определения анонимной функции: lambda список_параметров: выражение.
\n", "\n", "
список_параметров – список параметров через запятую;
\n", "
выражение – значение, либо код, дающий значение.
\n", "\n", "\n", " \n", " \n", " \n", "
\n", "
\"\"Параметры анонимных функций, в отличие от обычных, не нужно заключать в скобки.
\n", "
\n", "\n", "
Следующие два определения функций эквивалентны:
" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def standard_function(x): # Стандартное объявление функции\n", " return x*2\n", "\n", "lambda_function = lambda x: x*2 # Объявление анонимной функции" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Приведенный ниже код вводит одинаковый результат для обеих функций:
" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "14\n", "14\n" ] } ], "source": [ "print(standard_function(7))\n", "print(lambda_function(7))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Рассмотрим еще примеры. Приведенный ниже код:
" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "30\n", "15\n", "45\n" ] } ], "source": [ "f1 = lambda: 10 + 20 # Функция без параметров\n", "f2 = lambda х, у: х + у # Функция с двумя параметрами\n", "f3 = lambda х, у, z: х + у + z # Функция с тремя параметрами\n", "\n", "print(f1())\n", "print(f2(5, 10))\n", "print(f3(5, 10, 30))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Когда применение анонимных функций оправдано:
\n", "\n", "
\n", "
  • однократное использование простых функции;
    • \n", "
  • передача функций в качестве аргументов другим функциям;
    • \n", "
  • возвращение функции в качестве результата другой функции.
    • \n", "
    " ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "25\n", "27\n", "1024\n" ] } ], "source": [ "def create_power_function(stepen): # Функция возвращает анонимную функцию для возведения в степень stepen\n", " return lambda x: x**stepen\n", "\n", "# Создаем функции\n", "square_function = create_power_function(2) # Функция возведения в квадрат\n", "cube_function = create_power_function(3) # Функция возведения в куб\n", "dozen_function = create_power_function(10) # Функция возведения в десятую степень\n", "\n", "# Проверяем функции\n", "print(square_function(5)) # 5**2 = 25\n", "print(cube_function(3)) # 3**3 = 27\n", "print(dozen_function(2)) # 2**10 = 27" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    В этом коде функция create_power_function принимает один параметр stepen и возвращает анонимную функцию, которая возводит переданное значение x в степень, указанную в аргументе stepen.
    \n", " \n", "
    Далее мы создаем три функции: square_function для возведения в квадрат, cube_function для возведения в куб и dozen_function для возведения в десятую степень.
    \n", "\n", "
    Анонимные функции, возвращаемые из других функций, позволяют создавать гибкие и удобные для использования конструкции, что делает код более читаемым и компактным.
    " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Условный оператор в теле анонимной функции

    \n", "\n", "
    В теле анонимной функции не получится выполнить несколько действий и не получится использовать многострочные конструкции вроде циклов for и while. Однако можно использовать тернарный условный оператор.
    \n", "\n", "\n", "
    Общий вид тернарного условного оператора в теле анонимной функции выглядит так:
    \n", "\n", "
    значение-1 if условие else значение-2\n", "\n", "
    Пример:
    " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "# Lambda выражение, которое возвращает большее из двух чисел\n", "max_num = lambda x, y: x if x > y else y\n", "\n", "print(max_num(3, 5)) # Вывод: 5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    В этом примере, если x больше y, возвращается x, иначе возвращается y.
    \n", "\n", "
    Тернарный оператор позволяет создавать компактные и читаемые условия внутри lambda-выражений, что делает их более гибкими и мощными.
    \n", "\n", "
    В качестве следующего примера создадим lambda-выражение, которое классифицирует число как положительное, отрицательное или ноль:
    " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Положительное\n", "Отрицательное\n", "Ноль\n" ] } ], "source": [ "classify_number = lambda x: 'Положительное' if x > 0 else ('Отрицательное' if x < 0 else 'Ноль')\n", "print(classify_number(10)) # Вывод: Положительное\n", "print(classify_number(-5)) # Вывод: Отрицательное\n", "print(classify_number(0)) # Вывод: Ноль" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    В заключение рассмотрим пример для самых продвинутых:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[5, 4, 3, 2, 1]\n" ] } ], "source": [ "numbers = [1, 2, 5, 3, 4]\n", "numbers.sort(key=lambda x: -x)\n", "print(numbers)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "
    Сначала создается список numbers, который содержит пять чисел.
    \n", " \n", "
    После этого вызывается метод sort() на этом списке.
    \n", " \n", "
    Метод sort() используется для сортировки элементов списка в порядке возрастания или убывания. По умолчанию элементы сортируются в порядке возрастания, но мы можем указать собственный критерий сортировки с помощью параметра key.
    \n", "\n", "
    В данном случае в качестве значения параметра key используется лямбда-функция lambda x: -x. Лямбда-функция представляет собой анонимную функцию, которая принимает один аргумент x и возвращает его отрицательное значение -x. Это означает, что при сортировке список будет рассматриваться не в исходном виде, а с измененными значениями (отрицательные значения каждого элемента списка).
    \n", "\n", "
    Когда метод sort() применяет эту лямбда-функцию ко всем элементам списка, он фактически переворачивает их знаки, и получается следующий порядок на основе этих новых значений:
    \n", "\n", "
    \n", "
  • для 1 будет -1;
    • \n", "
  • для 2 будет -2;
    • \n", "
  • для 3 будет -3;
    • \n", "
  • для 4 будет -4;
    • \n", "
  • для 5 будет -5.
    • \n", "
    \n", "\n", "
    Следовательно, если сортировать список по убыванию, то в итоге получим порядок на основе положительных значений: 5, 4, 3, 2, 1.
    " ] } ], "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 }