Как сделать импликацию в питоне

Добавил пользователь Алексей Ф.
Обновлено: 05.10.2024

В этом руководстве мы будем работать с двумя типами данных в Python – целыми числами ( integer) и числами с плавающей точкой ( floats) :

Целые – числа без дробной части, которые могут быть положительными, отрицательными или нулём (…, -1, 0, 1, …).
С плавающей точкой – это числа, содержащие десятичную точку (например, 9.0 или -2.25).

В этой статье будут описаны операции с числовыми типами данных в Python.

Математические операторы Python 3

Оператор – это символ, которая обозначает операцию. Например, в математике знак плюса или + – это оператор сложения.

Мы рассмотрим схожие операторы, которые перешли в Python из математики. Но другие операторы специфичны именно для программирования.

Ниже представлена таблица с кратким обзором математических операторов, доступных в Python.

Операция	Возвращаемое значение
x + y	Сумма x и y.
x — y	Разность x и y.
-x	Изменение знака x.
+x	Тождественность x.
x * y	Произведение x и y.
x / y	Частное от деления x на y.
x // y	Частное от целочисленного деления x на y.
x % y	Остаток от деления x / y.
x ** y	x в степени y.

Сумма в питоне и разность в питоне

В Python операторы суммы и разности выполняют те же операции, что и в математике. Поэтому вы можете использовать этот язык программирования как калькулятор.

Рассмотрим некоторые примеры. Начнём с целых чисел:

Вместо передачи целых чисел напрямую в функцию print мы можем инициализировать переменные для этих значений:

Целые числа могут быть как положительными, так и отрицательными. Поэтому можно добавлять отрицательные числа к положительным:

Прибавление работает аналогично и с числами с плавающей запятой:

Синтаксис разности тот же, что и для прибавления, за исключением того, что вместо оператора сложения ( + ) необходимо использовать оператор вычитания ( - ):

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

Унарные арифметические операции Python

Унарное математическое выражение состоит из одного элемента. Знаки плюса и минуса в питоне могут быть использованы как единичный оператор, чтобы вернуть тождественное значение (+) или сменить знак числа (-).

Знак плюса означает тождественное значение. Мы можем использовать его с положительными значениями:

Когда мы используем знак плюса с отрицательным значением, он также вернёт значение тождественное данному. В этом случае он вернёт отрицательное значение:

При использовании с отрицательным значением знак плюса возвращает то же отрицательное значение.

Минус (в отличие от знака плюса) изменяет знак числа. Поэтому при передаче положительного числа мы получим отрицательное значение:

А когда мы используем минус в качестве унарного оператора с отрицательным значением, будет возвращено положительное число:

Унарные арифметические операторы возвращают тождественное значение в случае с +i, или противоположное по знаку число в случае с -i.

Умножение и деление в питоне

Когда вы выполняете деление в Python 3, частное всегда будет числом с плавающей точкой, даже если вы используете два целых числа:

Деление с остатком Python

Оператор % используется для деления по модулю, и возвращает остаток от деления, а не частное. Это полезно, например, для нахождения множителей числа.

Деление по модулю Python (с остатком) — пример:

В этом примере 85 делится на 15. Результат – 5 с остатком 10. Значение 10 выводится, поскольку оператор возвращает остаток от деления.

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

В приведенном выше примере 36.0 делится на 6.0 без остатка, поэтому возвращается значение 0.0.

Возведение в степень Python

В математике часто используется выражение 5³. То есть 5 умножается на себя три раза. В Python мы получим тот же результат (125) выполнив 5 ** 3 или 5 * 5 * 5.

Пример с переменными:

Возведение числа с плавающей точкой 52.25 в степень 7 с помощью оператора ** приводит к выводу большого числа с плавающей точкой.

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

Операторы Python выполняются в порядке приоритета. Посмотрим на следующее выражение:

Умножение выполняется первым. Поэтому, если мы вызовем метод print(u) , то получим следующее значение:

Это потому, что 10 * 5 равно 50 , а затем мы прибавляем 10 , чтобы получить 60 .

Если нужно было сложить 10 и 10 , и умножить сумму на 5 , то пришлось бы использовать скобки, как в математике:

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

Сначала мы задаём переменной w значение 5 . Затем используем составной оператор присваивания += , чтобы прибавить число справа, к переменной, расположенной слева, и присвоить результат переменной w .

Составные операторы присваивания часто используются в циклах for:

В Python предусмотрен составной оператор присваивания для каждой арифметической операции:

Составные операторы присваивания полезны в тех случаях, когда переменная должна увеличиваться или уменьшаться с помощью инкремента. А также когда необходимо автоматизировать некоторый процесс в создаваемой программе.

Заключение

В этой статье рассмотрены операторы, которые используются для математических операций с целыми и дробными десятичными числами.

Пожалуйста, опубликуйте свои комментарии по текущей теме материала. Мы крайне благодарны вам за ваши комментарии, подписки, лайки, дизлайки, отклики!

Пожалуйста, оставляйте ваши мнения по текущей теме статьи. Мы крайне благодарны вам за ваши комментарии, дизлайки, отклики, подписки, лайки!

Чтобы начать играть с Python, нам нужно открыть командную строку на твоём компьютере. Ты уже должна знать, как это сделать — мы изучали это в главе Введение в интерфейс командной строки.

Когда будешь готова, следуй приведенным ниже инструкциям.

Мы хотим открыть консоль Python, так что набери python , если работаешь в Windows, или python3 для Mac OS/Linux, и нажми enter .

Твоя первая команда Python!

После запуска Python командная строка изменилась на >>> . Для нас это означает, что сейчас мы можем использовать только команды на языке Python. Тебе не нужно вводить >>> — Python будет делать это за нас.

Если ты хочешь выйти из консоли Python, в любой момент — просто введи exit() или используй сочетание клавиш Ctrl + Z для Windows и Ctrl + D для Mac/Linux. Тогда ты больше не будешь видеть >>> .

Пока что мы не хотим выходить из консоли Python. Мы хотим узнать больше о ней. Давай начнём с чего-нибудь совсем простого. Например, попробуй набрать простое математическое выражение, вроде 2 + 3 , и нажми enter .

Прекрасно! Видишь, как выскочил ответ? Python знает математику! Ты можешь попробовать другие команды, например:

Чтобы вычислить степень числа, например, 2 в кубе, мы вводим:

Поиграй с этим немного и затем вернись сюда :).

Как видишь, Python является прекрасным калькулятором. Если тебе интересно, что ещё можно сделать.

Строки

Как насчет твоего имени? Введи своё имя в кавычках, вот так:

Ты только что создала свою первую строку! Это последовательность символов, которые могут быть обработаны компьютером. Строка должна всегда начинаться и заканчиваться одинаковым символом. Им может быть одинарная ( ' ) или двойная ( " ) кавычка (разницы нет!) Кавычки говорят Python'у, что внутри них находится строка.

Строки могут быть слиты воедино. Попробуй так:

Ты также можешь умножать строки на число:

Если тебе нужно поставить апостроф внутри строки, то есть два способа сделать это.

Используй двойные кавычки:

или поставь перед апострофом обратную косую черту ( \ ):

Прикольно, да? Чтобы увидеть своё имя прописными буквами, просто набери:

Ты только что использовала метод upper своей строки! Метод (такой как upper() ) представляет собой набор инструкций, который должен выполнить Python над заданным объектом (в нашем случае: "Ola" ) при его вызове.

Если ты хочешь узнать количество букв в своём имени, то и для этого тоже существует функция!

Интересно, почему иногда мы вызываем функцию добавлением . к концу строки (как "Ola".upper() ), а иногда сначала пишем имя функции и затем помещаем строку в скобки? Ну, в некоторых случаях функции принадлежат объектам, например, функция upper() , которая может быть применена только к строкам. В этом случае мы называем функцию методом. В другом случае функции не относятся к чему-то конкретному и могут использоваться для различных типов объектов, например, функция len() . Вот почему мы передаем "Ola" в качестве параметра функции len .

Подведём итог

Хорошо, достаточно о строках. Пока ты узнала следующее:

командная строка — ввод команд (кода) в интерактивную командную строку Python приводит к ответам на Python;
числа и строки — в Python числа используются для вычислений, а строки - для текстовых объектов;
операторы, такие как + и *, объединяют значения для получения нового;
функции, такие как upper() и len(), выполняют действия над объектами.

Таковы основы каждого языка программирования, который ты можешь выучить. Готова к чему-то посложнее? Мы уверены, что готова!

Ошибки

Давай попробуем кое-что новенькое. Можем ли мы получить длину числа так же, как длину твоего имени? Введи len(304023) и нажми Enter :

Мы получили нашу первую ошибку! Иконкой мы будем обозначать код, который при запуске сработает не так, как ожидается. Совершение ошибок (даже преднамеренных) -- важная часть обучения!

Сработало! Мы использовали функцию str внутри функции len . str() преобразует всё в строки.

Функция str преобразует объекты в строки
Функция int преобразует объекты в целые числа

Важно: мы можем преобразовать число в текст, но не всегда удается преобразовать текст в числа — например, каков будет результат int('hello') ?

Переменные

Переменные — важное понятие в программировании. Переменная — это всего лишь имя для чего-то, чтобы использовать его позднее. Программисты используют переменные для хранения данных, чтобы их код был более читабельным, и для того, чтобы им не пришлось запоминать, что есть что.

Допустим, мы хотим создать новую переменную с именем name :

Видишь? Это очень легко! Просто введи: name равно Ola.

Как ты уже заметила, твоя программа не возвращает ничего, как было ранее. Так откуда мы знаем, что переменная действительно существует? Просто введи name и нажми Enter :

Ура! Твоя первая переменная:)! Ты всегда можешь изменить то, к чему она относится:

Ты также можешь использовать переменные и в функциях:

Круто, правда? Переменными, конечно, может быть что угодно, и цифры тоже! Попробуй следующее:

Но что делать, если мы использовали неправильное имя? Можешь догадаться, что произойдет? Давай попробуем!

Ошибка! Как ты можешь видеть, в Python есть различные типы ошибок, эта называется NameError. Python выдаст эту ошибку при попытке использовать переменную, которая пока не определена. При возникновении этой ошибки проверь свой код, чтобы узнать, не написала ли ты неправильно имя переменной.

Попрактикуйся в этом какое-то время и посмотри, что ты сможешь сделать!

Функция print

Если просто ввести name , интерпретатор Python вернет строковое представление переменной 'name', которым, в нашем случае, являются буквы M-a-r-i-a, окруженные одинарными кавычками, ''. Когда ты вводишь print(name) , Python "печатает" содержание переменной на экран, без кавычек, что удобнее.

Как мы увидим позднее, print() пригодится, когда нам будет нужно печатать что-то изнутри функций или когда мы захотим напечатать что-то на нескольких строчках.

Списки

Помимо строк и целых чисел Python имеет богатую коллекцию других типов объектов. Сейчас мы собираемся представить тебе один из них — list (список). Списки — это именно то, о чём ты подумала: объекты, которые являются списками других объектов :)

Давай начнем с создания списка:

Отлично, это пустой список. Не особенно полезен, да? Давай создадим список лотерейных номеров. Мы не хотим повторять их каждый раз, так что присвоим список переменной:

Замечательно, у нас есть список! Что мы можем с ним сделать? Для начала посмотрим, как много лотерейных номеров в нашем списке. Есть идеи, какую функцию можно использовать для этого? Ты её уже знаешь!

Точно! len() вернет тебе количество объектов в списке. Удобно, правда? Пожалуй, мы теперь отсортируем его:

Эта команда не возвращает ничего, она просто меняет порядок номеров в списке. Давайте выведем его на экран и посмотрим, что получилось:

Как видишь, номера в списке теперь отсортированы от меньшего к большему. Поздравляем!

Может, нам нужно обратить порядок? Давай сделаем это!

Просто, правда? Если хочешь добавить что-то к своему списку, то можешь воспользоваться этой командой:

Если ты хочешь получить только первый номер в списке, то можешь воспользоваться индексами. Индекс — это номер позиции в списке, на котором находится нужное нам значение. Программисты предпочитают начать считать с 0, так что первому объекту в списке соответствует индекс 0, следующему —1, и так далее. Попробуй ввести:

Как видишь, ты можешь обратиться к различным объектам в своем списке, используя имя списка и индекс объекта в квадратных скобках.

Чтобы удалить что-либо из списка, тебе понадобятся индексы, с которыми мы уже разобрались выше, и команда pop() . Давай попробуем закрепить пройденное на примере: мы будем удалять первый элемент из нашего списка.

Сработало как по маслу!

В качестве дополнительной тренировки попробуй следующие индексы: 6, 7, 1000, -1, -6 и -1000. Можешь предсказать результат? Видишь логику работы?

Словари

Для проходящих руководство дома: этот раздел рассмотрен в видео Python Basics: Dictionaries.

Словари схожи со списками, но ты обращаешься к значениям словаря по ключу, а не по индексу. Ключом может быть любая строка или число. Давай создадим пустой словарь:

Это показывает, что мы создали пустой словарь. Ура!

Теперь попробуй следующую команду (можешь заменить значения на своё имя, страну и т.д.):

Этой командой ты создала переменную participant с тремя парами ключ/значение:

ключ name , указывающий на значение 'Ola' (объект типа строка ),
ключ country , указывающий на значение 'Poland' (еще одна строка ),
и ключ favorite_numbers , указывающий на значение [7, 42, 92] (объект типа список с тремя числами внутри).

Значение конкретного ключа можно узнать следующим образом:

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

Что случится, если мы спросим у Python значение несуществующего в словаре ключа? Можешь предположить? Давай попробуем и узнаем наверняка!

Смотри, другая ошибка! Эта называется KeyError. Python услужливо напоминает, что ключа 'age' нет в словаре.

Когда стоит использовать словарь, а когда список? Это хороший вопрос для самостоятельного размышления. Сделай предположение перед тем, как читать дальше.

Тебе нужна упорядоченная последовательность элементов? Список — наш выбор.
Тебе нужны сочетания ключ/значение, чтобы быстро искать значения (по ключу) в дальнейшем? Словарь отлично подойдет.

Словари, как и списки, изменяемы, т. е. они могут быть изменены после того, как были созданы. Ты можешь добавить новые пары ключ/значение в словарь следующим образом:

Так же как в примере со списками, использование функции len() вернёт число пар ключ/значение в словаре. Попробуй сама:

Надеюсь, всё вышеизложенное понятно. :) Готова к новым приключениям со словарями? На следующей строке тебя ждут изумительные вещи.

Ты можешь использовать команду pop() для удаления элементов из словаря. Скажем, ты хочешь удалить элемент с ключом 'favorite_numbers' . Просто набери следующую команду:

Как видишь, пара ключ/значение с ключом 'favorite_numbers' была удалена.

Помимо этого, ты можешь заменить значение, связанное с уже существующим ключом. Набери:

Значение, на которое ссылается ключ 'country' , изменилось с 'Poland' на 'Germany' . :) Захватывает? Ещё бы! Ты выучила еще одну потрясающую штуку!

Подведём итог

Шикарно! Теперь ты знаешь немало о программировании. Мы познакомились с:

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

Готова к продолжению? :)

Сравнения

Для проходящих руководство дома: этот раздел рассмотрен в видео Python Basics: Comparisons.

В программировании часто надо что-то сравнивать. Что проще всего сравнить друг с другом? Числа, конечно. Давай посмотрим, как это работает:

Мы передали Python несколько чисел для сравнения. Как ты можешь заметить, Python сравнивает не только числа, но и результаты методов (например, умножения). Неплохо, правда?

Хочешь спросить, почему мы написали двойной символ равенства == , чтобы проверить, одинаковы ли числа? Потому что одинарные символ равенства = уже задействован под присваивание значения переменным. Ты всегда, всегда должна писать два символа равенства == , если хочешь проверить, одинаковы ли объекты. Мы также можем проверить, различаются ли объекты. Для этого мы используем != , как показано в примере выше.

Дадим Python еще два задания:

С > и все понятно, но что значат >= и ? Читай их следующим образом:

x > y означает: x больше y
x y означает: x меньше y
x y означает: x меньше или равен y
x >= y означает: x больше или равен y

Супер! Хочешь еще? Тогда попробуй вот это:

Ты можешь передать Python столько чисел, сколько захочешь, и он будет возвращать ответ! Хитро, правда?

and — если ты используешь оператор and , оба сравнения по обе стороны от него должны быть True (верны), чтобы результат всей команды был равен True.
or — если ты используешь оператор or , достаточно одному из сравнений по обе стороны от него быть равным True, чтобы результат всей команды также равнялся True.

Ты когда-нибудь слышала выражение "сравнивать тёплое с мягким"? Попробуем сделать что-то подобное в Python:

Как мы видим, Python не знает, как сравнить число ( int ) и строку ( str ) между собой. Поэтому он просто возвращает нам ошибку TypeError и предупреждает, что объекты заданных типов не могут быть сравнены.

Логические значения

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

Существует только два логических объекта в Python:

Чтобы Python понимал тебя, ты всегда должна писать True с заглавной буквы (остальные прописные). true, TRUE, tRUE не будут восприниматься — только True. (Та же логика применима к False, само собой.)

Ты можешь присваивать переменным логические значения! Смотри сюда:

Попрактикуйся с логическими значениями на примере этих выражений:

True and True
False and True
True or 1 == 1
1 != 2

Поздравляем! Логические значения — одна из самых классных фишек программирования, и ты только что научилась ими пользоваться!

До сих пор мы писали весь код в интерактивной консоли, где Python сразу анализировал, обрабатывал и выполнял наши команды. Мы были ограничены одной строкой. Обычно, программы сохраняются в файлах и выполняются интерпретатором или компилятором нашего языка программирования. Пока мы только просили интерпретатор Python выполнять наши однострочные команды из консоли. Однако нам понадобится больше места для следующих задач, поэтому задача минимум:

закрыть интерактивную консоль Python;
открыть наш текстовый редактор;
сохранить код в новом файле;
запустить его!

Чтобы закрыть интерактивную консоль Python, просто набери функцию exit() :

Это вернёт тебя в командную строку.

В главе Текстовый редактор мы выбрали себе редактор. Нам нужно открыть его сейчас и записать следующий код в новый файл (или, если ты используешь Chromebook, создай новый файл в облачной IDE и открой файл, который будет во встроенном редакторе кода):

Очевидно, ты уже искушенный Python разработчик, так что не стесняйся добавить что-нибудь по своему вкусу из ранее изученного.

Теперь нам нужно сохранить файл с кодом и дать ему подходящее имя. Давай назовем его python_intro.py и сохраним на рабочий стол. Мы можем назвать файл как хотим, но важно, чтобы название заканчивалось на .py. Расширение .py говорит операционной системе, что это исполняемый файл python, и Python может его запустить.

После сохранения файла пришло время запустить его! Используя навыки из раздела о командной строке, открой терминал и поменяй текущую директорию на рабочий стол.

Операторы (operators) * и ** встречаются в питоне очень часто. Иногда они немного непонятны и новичкам, и опытным ребятам, переходящим на питон с ряда других языков программирования (в которых операторы могут использоваться немного иначе). Статья известного питон-коуча Трея Ханнера (Trey Hunner), который помогает девелоперам расширять свои знания. Дата написания статьи: 10.11.2018.

Функционал операторов * и ** развивается уже много лет. Я хочу рассмотреть все способы их использования по состоянию на текущий момент. Буду указывать, что конкретно работает только в современных версиях питона. Поэтому, если вы изучали операторы * и ** еще во времена питона 2 (Python 2), советую хотя бы проглядеть данную статью, потому что в питоне 3 (Python 3) этим операторам добавили много новых возможностей.

Если вы начали изучать питон недавно и еще не освоили аргументы ключевых слов (keyword arguments; также известные как именованные аргументы, named arguments), предлагаю сперва прочитать мою статью про аргументы ключевых слов в питоне.

Что мы обсуждать не будем

В данной статье, говоря про операторы * и **, я имею в виду операторы-префиксы (prefix operators), а не инфиксы (infix). То есть, функции умножения и возведения в степень не входят в тему статьи.

Тогда про что же мы говорим

Мы говорим про операторы-префиксы * и **, которые используются перед переменной (variable). Например:

>>> numbers = [2, 1, 3, 4, 7]
>>> more_numbers = [*numbers, 11, 18]
>>> print(*more_numbers, sep=', ')
2, 1, 3, 4, 7, 11, 18

В данном коде можно увидеть два способа использования оператора *. Оператор ** отсутствует.

В сферу применения рассматриваемых операторов входит:
1. Операторы * и **: передача аргументов в функцию.
2. Операторы * и **: захват аргументов, переданных в функцию.
3. Оператор *: принятие аргументов, содержащих только ключевые слова.
4. Оператор *: захват элементов во время распаковки кортежа (tuple).
5. Оператор *: распаковка итерируемых объектов в списке или кортеже.
6. Оператор **: + распаковка словарей в других словарях.

Даже если вам кажется, что вы освоили все эти способы, позволяющие использовать операторы * и **, рекомендую посмотреть на все нижеприведенные блоки кода, чтобы убедиться, что они все вам знакомы. Последние несколько лет разработчики ядра питона продолжают добавлять этим операторам новые возможности, поэтому какие-то из новых применений можно проглядеть.

Операторы * и ** при распаковке во время вызова функции

При вызове функции оператор * можно задействовать для распаковки итерируемого объекта в аргументах, введенных для вызова:

>>> fruits = ['lemon', 'pear', 'watermelon', 'tomato']
>>> print(fruits[0], fruits[1], fruits[2], fruits[3])
lemon pear watermelon tomato
>>> print(*fruits)
lemon pear watermelon tomato

В строке print(*fruits) производится вызов всех элементов списка fruits в функции print. Они становятся отдельными аргументами. При этом нам даже не надо знать, сколько всего аргументов окажется в списке.

Еще один пример:

Функционал оператора ** примерно такой же, просто он применяется к аргументам ключевых слов. Он позволяет нам взять словарь, содержащий пары из ключей и значений, и распаковать его в аргументы ключевых слов при вызове функции.

Скажу из своего опыта. Оператор ** не часто используется для распаковки аргументов ключевых слов при вызове функции. Чаще всего я вижу такие примеры при работе с наследованием: вызовы super() часто включают в себя оба оператора.

Операторы * и ** можно использовать неоднократно при вызове функции. Данная возможность появилась в питоне 3.5. Иногда это может оказаться очень уместным:

>>> fruits = ['lemon', 'pear', 'watermelon', 'tomato']
>>> numbers = [2, 1, 3, 4, 7]
>>> print(*numbers, *fruits)
2 1 3 4 7 lemon pear watermelon tomato

Неоднократное использование ** выглядит примерно так же:

Однако не нужно терять бдительности при неоднократном использовании операторов * и **. Неоднократное указание одного и того же аргумента ключевых слов не допускается в функциях питона. Поэтому, если использовать ** для словарей, то ключи должны быть уникальными. В противном случае возникнет исключение.

Операторы * и ** при упаковке аргументов, переданных функции

При определении тела функции можно использовать оператор *, чтобы захватывать неограниченное количество позиционных аргументов, переданных этой функции. Они оформляются в кортеж.

Данная функция принимает любое количество аргументов.

Функции питона print и zip принимают любое количество позиционных аргументов. Такое использование оператора * при упаковке аргументов позволяет нам создавать свои функции, которые (аналогично print и zip) принимают любое количество аргументов.

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

def tag(tag_name, **attributes):
attribute_list = [
f'=""'
for name, value in attributes.items()
]
return f" "

В данном месте ** захватывает в словарь аргументы ключевых слов, которые мы передаем данной функции. Впоследствии аргументы атрибутов (attributes) данной функции смогут на него ссылаться.

>>> tag('a', href="http://treyhunner.com")
>>> tag('img', height=20, width=40, src="https://kirill-sklyarenko.ru/face.jpg")

Позиционные аргументы, содержащие аргументы только из ключевых слов

питон 3 ввел специальный синтаксис для передачи аргументов, содержащих только ключевые слова, в функцию. Они представляют собой такие аргументы функции, которые можно определить только с помощью синтаксиса для ключевых слов. Это означает, что их нельзя определить позиционно.

Чтобы принимать аргументы, содержащие только ключевые слова, мы можем поместить именованные аргументы после оператора * при определении тела функции:

def get_multiple(*keys, dictionary, default=None):
return [
dictionary.get(key, default)
for key in keys
]

Данную функцию можно использовать так:

Аргументы dictionary и default поставлены после *keys. То есть, их можно только в качестве аргументов ключевых слов. Если мы попытаемся определить их позиционно, то увидим ошибку:

>>> fruits = <'lemon': 'yellow', 'orange': 'orange', 'tomato': 'red'>
>>> get_multiple('lemon', 'tomato', 'squash', fruits, 'unknown')
Traceback (most recent call last):
+ File "", line 1, in
TypeError: get_multiple() missing 1 required keyword-only argument: 'dictionary'

Данное поведение внедрено в питон с помощью предложения PEP 3102.

Аргументы, содержащие только ключевые слова и не содержащие позиционные аргументы

Аргументы, содержащие только ключевые слова, – неплохое средство. Но что если вы хотите требовать ввода аргументов, содержащих только ключевые слова, не захватывая неограниченное количество позиционных аргументов?

питон позволяет сделать это с помощью немного странного синтаксиса, когда оператор * как бы сам по себе:

def with_previous(iterable, *, fillvalue=None):
"""Yield each iterable item along with the item before it."""
previous = fillvalue
for item in iterable:
yield previous, item
previous = item

Данная функция принимает аргумент, содержащий итерируемый объект (iterable). Его можно определить позиционно (то есть, первым) или с помощью названия и аргумента fillvalue, который входит в число аргументов, допускающих только ключевые слова. Это означает, что мы можем вызвать функцию with_previous вот так:

>>> list(with_previous([2, 1, 3], 0))
Traceback (most recent call last):
File "", line 1, in
TypeError: with_previous() takes 1 positional argument but 2 were given

Данная функция принимает два аргумента. Один из них, fillvalue, обязательно определяется как аргумент, содержащий ключевое слово.

Обычно я использую аргументы, допускающие только ключевые слова, при захвате неопределенного количества позиционных аргументов. Но иногда я использую данную возможность оператора *, чтобы форсировать исключительно позиционное определение аргумента.

На самом деле, данный подход используется встроенной функцией питона sorted. Если посмотреть справку для sorted, можно увидеть следующее:

>>> help(sorted)
Help on built-in function sorted in module builtins:
sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.

Пример использования оператора * как самого по себе прямо в документации по аргументам функции sorted.

Операторы * и ** при распаковке кортежа

Дополнительно к вышенаписанному, в питоне 3 добавлен новый способ применения *, который некоторым образом связан с вышеописанными возможностями этого оператора при определении тела функции и при вызове функции.

Оператор * теперь можно использовать при распаковке кортежа:

>>> fruits = ['lemon', 'pear', 'watermelon', 'tomato']
>>> first, second, *remaining = fruits
>>> remaining
['watermelon', 'tomato']
>>> first, *remaining = fruits
>>> remaining
['pear', 'watermelon', 'tomato']
>>> first, *middle, last = fruits
>>> middle
['pear', 'watermelon']

Если вы задаете себе вопрос: как же мне использовать это в своем коде, посмотрите примеры в моей статье про распаковку кортежей в питоне. В этой статье я показал, каким образом такое использование оператора * может, в некоторых случаях, стать альтернативой для срезания последовательностей (sequence slicing).

Обычно во время своих лекций об операторе * я говорю, что можно использовать только одно выражение с ним в отдельном вызове многократного присвоения (multiple assignment). Технически это некорректно, потому что можно его использовать два раза при вложенной распаковке (nested unpacking). Данный вопрос я рассмотрел подробно в статье про распаковку кортежей.

>>> fruits = ['lemon', 'pear', 'watermelon', 'tomato']
>>> ((first_letter, *remaining), *other_fruits) = fruits
>>> remaining
['e', 'm', 'o', 'n']
>>> other_fruits
['pear', 'watermelon', 'tomato']

Правда, я никогда не встречал хорошего примера такого использования. Не думаю, что стал бы его рекомендовать, даже если бы удалось найти. Он выглядит немного непонятно.

Данная возможность добавлена в питон на основе предложения PEP 3132. Следует отметить, что оно не относится к очень длинным.

Операторы * и ** в литерале списка

В питоне 3.5 добавлено очень много возможностей, связанных с оператором *, на основе предложения PEP 448. Одной из самых заметных новых возможностей стало использование * для вывода итерируемого объекта в новый список.

Допустим, у вас есть функция, которая принимает любые последовательности и возвращает список, содержащий каскад из последовательности и ее реверсивного варианта:

Данная функция должна пару раз провести конвертацию в список, чтобы объединить списки и вернуть результат. Начиная с питона 3.5, мы можем, вместо вышеприведенного примера, написать следующее:

В данном коде больше нет нескольких ненужных вызовов списков. Поэтому он стал эффективнее и лучше читается.

Данная функция возвращает новый список, в котором первый элемент переданного списка (или другой последовательности) перенесен в конец нового списка.

Это очень удачная возможность, позволяющая с помощью оператора * объединять итерируемые объекты различных типов. Оператор * работает с любыми итерируемыми объектами, а оператор + работает только с определенными последовательностями, при чем все из объединяемых должны быть одного типа.

Отмечу, что данная возможность не ограничивается только созданием списков. Мы можем выводить итерируемые объекты в новые кортежи или множества (set):

Обратите внимание, что последняя строка принимает список и генератор (generator), а потом выводит их в новое множество. Перед появлением этой возможности для оператора * было непросто сделать это в одну строку кода. Разумеется, способ сделать это существовал, но его было непросто вспомнить или обнаружить:

Оператор ** в литерале словаря

Помимо вышеприведенного на основе предложения PEP 448 в функционал ** добавлен вывод пар ключ/значение (key/value) из словаря в новый словарь:

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

Еще можно скопировать или слить словари, переписывая определенные значения:

Операторы * и ** обладают немалыми возможностями в питоне

В питоне операторы * и ** – не просто синтактический выверт. Некоторые из их возможностей реализуются и другими средствами, но доступные альтернативы обычно более громоздкие и потребляют больше ресурсов. Кроме того, некоторые элементы в функционале этих операторов попросту не доступны без их использования. Например, без помощи * невозможно передать в функцию неопределенное количество позиционных аргументов.

Чаще всего я называю их звездой (star) и двойной звездой (double star) (или звездой-звездой (star star)). В данном случае разделения с их функциями как инфиксов не проводится (речь идет про операции умножения и возведения в степень). Но обычно из контекста очевидно, о чем идет речь, про префиксы или инфиксы.

Если вы не понимаете операторы * и ** или боитесь не запомнить все их возможности, не нужно беспокоиться. Способов использования много, и запоминать каждую конкретную возможность для каждого из них не так важно. Лучше будет осознать, в каких случаях к ним можно обратиться. Предлагать использовать данную статью как чек-лист или создать свой чек-лист, который поможет вам использовать операторы * и ** в питоне.

Кортежи (tuples) очень похожи на списки, но являются неизменяемыми. Как мы видели, использование изменяемых объектов может приводить к неприятным сюрпризам.

Кортежи пишутся в круглых скобках. Если элементов $>1$ или 0, это не вызывает проблем. Но как записать кортеж с одним элементом? Конструкция (x) абсолютно легальна в любом месте любого выражения, и означает просто x . Чтобы избежать неоднозначности, кортеж с одним элементом x записывается в виде (x,) .

Скобки ставить не обязательно, если кортеж — единственная вещь в правой части присваивания.

Работать с кортежами можно так же, как со списками. Нельзя только изменять их.

В левой части присваивания можно написать несколько переменных через запятую, а в правой кортеж. Это одновременное присваивание значений нескольким переменным.

Сначала вычисляется кортеж в правой части, исходя из старых значений переменных (до этого присваивания). Потом одновременно всем переменным присваиваются новые значения из этого кортежа. Поэтому так можно обменять значения двух переменных.

Это проще, чем в других языках, где приходится использовать третью переменную.

2. Множества¶

В соответствии с математическими обозначениями, множества пишутся в фигурных скобках. Элемент может содержаться в множестве только один раз. Порядок элементов в множестве не имеет значения, поэтому питон их сортирует. Элементы множества могут быть любых типов.

Принадлежит ли элемент множеству?

Множество можно получить из списка, или строки, или любого объекта, который можно использовать в for цикле (итерабельного).

Как записать пустое множество? Только так.

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

Работать с множествами можно как со списками.

Это генератор множества (set comprehension).

Проверка того, является ли одно множество подмножеством другого.

Разность и симметричная разность.

Множества (как и списки) являются изменяемыми объектами. Добавление элемента в множество и исключение из него.

Как и в случае += , можно скомбинировать теоретико-множественную операцию с присваиванием.

Приведенные выше операции можно записывать и в другом стиле

Существуют также неизменяемые множества. Этот тип данных называется frozenset . Операции над такими множествами подобны обычным, только невозможно изменять их, а всего лишь добавлять и исключать элементы.

3. Словари¶

Словарь содержит пары ключ — значение, причем порядо значений несущественен. Это один из наиболее полезных и часто используемых типов данных в питоне.

Можно узнать значение, соответствующее некоторому ключу. Словари реализованы как хэш-таблицы, так что поиск даже в больших словарях очень эффективен. В языках низкого уровня (например, C) для построения хэш-таблиц требуется использовать внешние библиотеки и писать заметное количество кода. В скриптовых языках (perl, python, php) они уже встроены в язык, и использовать их очень легко.

Можно проверить, есть ли в словаре данный ключ.

Можно присваивать значения как имеющимся ключам, так и отсутствующим (они добавятся к словарю).

Длина — число ключей в словаре.

Можно удалить ключ из словаря.

Метод get , если он будет вызван с отсутствующим ключом, не приводит к ошибке, а возвращает специальный объект None . Он используется всегда, когда необходимо указать, что объект отсутствует. В какой-то мере он аналогичен null в C. Если передать методу get второй аргумент — значение по умолчанию, то будет возвращаться это значение, а не None .

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

А это генератор словаря (dictionary comprehension).

Ключами могут быть любые неизменяемые объекты, например, целые числа, строки, кортежи.

Словари, подобно спискам, можно использовать в for циклах. Перебираются имеющиеся в словаре ключи, причем в каком-то непредсказуемом порядке.

Метод keys возвращает список ключей, метод values — список соответствующих значений (в том же порядке), а метод items — список пар (ключ, значение). Точнее говоря, это не списки, а некоторые объекты, которые можно использовать в for циклах или превратить в списки функцией list . Если хочется написать цикл по упорядоченному списку ключей, то можно использовать sorted(d.keys)) .

Что есть истина? И что есть ложь? Подойдём к этому философскому вопросу экспериментально.

На выражения, стоящие в булевых позициях (после if , elif и while ), неявно напускается функция bool . Некоторые объекты интерпретируются как False : число 0, пустая строка, пустой список, пустое множество, пустой словарь, None и некоторые другие. Все остальные объекты интерпретируются как True . В операторах if или while очень часто используется список, словарь или что-нибудь подобное, что означает делай что-то если этот список (словарь и т.д.) не пуст.

Заметим, что число с плавающей точкой 0.0 тоже интерпретируется как False . Это использовать категорически не рекомендуется: вычисления с плавающей точкой всегда приближённые, и неизвестно, получите Вы 0.0 или 1.234E-12 . Лучше напишите if abs(x) .

4. Функции¶

Это простейшая в мире функция. Она не имеет параметров, ничего не делает и ничего не возвращает. Оператор pass означает "ничего не делай"; он используется там, где синтаксически необходим оператор, а делать ничего не нужно, например, после if или elif , после def и т.д..

Функция в программировании не совсем то же самое, что функция в математике. В математике функция принимает одно значение и возвращает другое. В программировании — это программа в программе, отдельный участок кода, к которому можно обратиться по имени.

Зачем это нужно? Если у вас есть код, который используется несколько раз в рамках программы, то функция позволяет написать код один раз, а потом просто вызывать его при необходимости. Так мы не дублируем код и лучше его структурируем.

Встроенные функции

В Питоне есть множество встроенных в (1) стандартный функционал (built-in functions) и (2) дополнительные библиотеки (library functions) функций, и мы много раз их использовали.

Рассмотрим функцию для создания гистограммы plt.hist(). Вначале импортируем библиотеки.

Сгенерируем данные, которые передадим этой функции (эти же данные мы создавали и использовали на восьмом занятии вводного курса).

Теперь построим гистограмму передав ей в качестве параметров и аргументов наши данные и количество интервалов.

Как мы видим, достаточно обратиться к соответствующей библиотеке ( plt ), вызвать эту функцию по имени ( hist ) и задать параметры и их аргументы ( height и bins = 10 ), и будет исполнен тот код, который заложили в нее создатели библиотеки Matplotlib.

Теперь несколько слов про параметры и аргументы функции.

Параметры и аргументы функции

Для начала определимся с терминами:

параметр — это то, что запрашивает функция при вызове (например, bins , количество интервалов)
аргумент — значение этого параметра (в нашем случае, 10 ).

Возникает вопрос, что же такое height ? Логично предположить, что это аргумент (ведь это наши данные). Но тогда как функция узнает, какому параметру он соответствует?

Все дело в том, что параметры и их аргументы могут быть позиционными (positional) и именованными (keyword).

В первом случае, достаточно указать аргумент и поставить его в правильном порядке (позиции). Функция сама поймет, какой параметр ей передают. Во втором случае, нужно указать и название параметра, и аргумент.

Позиционный параметр можно сделать именованным, и тогда порядок важен не будет.

Кроме того, функция может иметь параметры с аргументами по умолчанию. Это делает такой параметр не обязательным, а значит упрощает и ускоряет вызов функции.

Как вы видите, результат во всех трех случаях совершенно одинаковый.

Если вы сомневаетесь в том, какие параметры принимает функция и что является результатом ее работы, полезно обратиться к документации в Интернете. Например, по функции plt.hist() ее можно найти вот здесь⧉.

Стоит отметить, что функция может как принимать один, два или несколько параметров, так и не принимать их вовсе. Например, функция print(), если не указывать параметры, выдает пустую строку.

Функции и методы

Предположим, у нас есть строка, и мы хотим сделать первую букву каждого слова заглавной. Для этого у строки есть метод .title().

А теперь попробуем применить этот метод к списку, состоящему из тех же слов, что и строка.

Как мы видим, Питон выдал ошибку.

Собственные функции в Питоне

Объявление и вызов функции

Функции не обязательно должны быть встроены в базовый функционал или библиотеки. Мы вполне можем объявлять (т.е. создавать) собственные функции (user-defined functions). Рассмотрим пример.

Теперь давайте разберем каждый элемент этого кода. Вначале посмотрим как объявить функцию (declare a function).

ключевое слово def необходимо для объявления функции
далее идут название функции, которое вы сами определяете, и
параметры, которые может принимать ваша функция
после двоеточия на новой строке с отступом идет так называемое тело функции, то есть то, что будет исполняться при вызове функции
в конце ставится ключевое слово return, возвращающее результат работы функции

Затем, когда это необходимо, мы можем вызвать функцию (call a function), указав ее имя и передав, при их наличии, соответствующие аргументы внутри круглых скобок.

Пустое тело функции

Оставлять тело функции совсем пустым нельзя. Нужно как минимум указать ключевое слово return или оператор pass.

Хотя может показаться, что в этом случае функция ничего не выдает, на самом деле это не так. И в том, и в другом случае функция возвращает особый тип данных None (отсутствие значения).

Функция print() вместо return

Помимо ключевого слова return, результат работы функции можно вывести с помощью print().

Хотя визуально вывод идентичен, отличие все-таки есть:

Использование return возвращает значение функции (в нашем случае значение переменной res) и прерывает ее работу
Функция print() просто выводит это значение пользователю и не влияет на дальнейшее исполнение кода, если он есть

Параметры собственных функций

С точки зрения параметров, у собственных функций те же самые возможности, что и у встроенных функций. В частности, параметры могут быть позиционными и именованными.

Параметры собственной функции также могут быть заданы по умолчанию. В этом случае при вызове функции их указывать не обязательно.

И конечно функция может изначально не иметь параметров.

Дополнительные возможности функций

Вызов функции можно совмещать с арифметическими операциями.

Доступны и логические операции.

Если результатом вывода является строка, то у этой строки также есть индекс.

Функция может не использовать параметры, но получать данные от пользователя через input().

Появится окно для ввода числа.

Введем число пять и посмотрим на результат.

Результат вызова функции

Функция не обязательно возвращает только число или строку, это может быть, в частности, список, кортеж или словарь. Рассмотрим несколько примеров.

Функция может возвращать сразу несколько значений.

Если результат вызова этой функции записать в две переменных, то ожидаемо в них окажется строка и число.

Если записать в одну, то получится кортеж.

Функция может возвращать и логическое значение. Давайте объявим функцию, которая проверяет четное ли ей передали число (и в этом случае вернет True) или нечетное (и тогда False).

Использование библиотек

Внутри функций можно использовать дополнительные библиотеки Питона. Например, применим функцию mean() библиотеки Numpy для расчета среднего арифметического.

Глобальные и локальные переменные

Некоторые переменные существуют (или как еще говорят, видны) только внутри функции, другие во всей программе. В первом случае, говорят про локальные переменные, во втором — про глобальные. Сразу приведем несложный пример.

Здесь никаких проблем не возникло. Мы создали глобальную переменную и потом легко использовали ее внутри очередной функции. Обратное не всегда возможно.

Функция была вызвана без проблем. При этом если мы попробуем обратиться к переменной local_name вне этой функции, Питон выдаст ошибку.

Все дело в том, что область видимости этой переменной ограничена функцией show_local_name(). Для того чтобы она была видна во всей программе, можно использовать ключевое слово global.

Давайте посмотрим, что будет, если есть две переменные с одинаковым названием, причем одна из них глобальная, а вторая — локальная.

При этом значение глобальной переменной для остального кода не изменится.

Анонимные или lambda-функции

Функции создают не только через ключевое слово def и название функции. Можно использовать слово lambda и вообще обойтись без названия. Приведем простой пример.

Теперь давайте в деталях рассмотрим, как мы получили такой результат.

Разумеется, ничто не мешает поместить этот же функционал в обычную функцию.

Анонимную функции при этом удобно использовать в тех случаях, когда применение обычной функции избыточно. Продемонстрирую на примере.

Lambda-функция внутри функции filter()

Предположим, у нас есть список чисел, и мы хотим оставить в нем только те числа, которые больше 10. Давайте решим эту задачу с помощью функции filter() и lambda-функции.

Функция filter() принимает два параметра:

Во-первых, еще одну функцию, выполняющую роль критерия; она выдает True , если элемент нужно оставить, и False — если убрать
Во-вторых, набор элементов, которые нужно отфильтровать в виде списка, кортежа или множества

Получив их, filter() применяет критерий (функцию) к каждому из элементов набора.

Посмотрим на реализацию на Питоне. Вначале создадим список.

Теперь зададим фильтрующую lambda-функцию.

После этого поместим criterion и nums в функцию filter(). Так как сама функция filter() вернет нам не список, а специальный объект iterator, его в свою очередь нужно преобразовать обратно в список с помощью функции list().

Чаще такой функционал записывают в одну строчку.

И в этом и заключается удобство lambda-функции, ее не надо объявлять заранее. Через обычную функцию код выглядел бы так.

Lambda-функция внутри функции sorted()

Теперь рассмотрим lambda-функцию в коде, который мы использовали на занятии по рекомендательным системам. Воспроизведем в миниатюре часть решения из того занятия.

В какой-то момент мы получили список из кортежей. И в каждом кортеже был индекс фильма и расстояние до него.

Затем мы захотели отсортировать этот список по расстоянию, то есть по второму элементу кортежа.

Мы взяли функцию sorted() и в качестве параметра ключа, по которому сортировать список (key), передали ей lambda-функцию, принимающей кортеж из двух элементов на входе, и выдающей второй его элемент на выходе.

Параметр reverse = True , напомню, задает сортировку по убыванию.

*args и **kwargs

Прежде чем завершить, поговорим про еще одну важную тему, а именно про так называемые *args (сокращение от arguments) и **kwargs (keyword arguments).

Они позволяют передавать функции различное количество позиционных (*args) или именованных (**kwargs) аргументов.

Рассмотрим на примере. Начнем с *args.

Предположим, что у нас есть простая функция, которая принимает два числа и считает среднее арифметическое.

Все отлично работает, но мы не можем передать этой функции больше двух чисел. Возможным решением станет функция, которая изначально принимает список в качестве аргумента.

Все опять же работает, но нам каждый раз нужно создавать список. При попытке передать отдельные числа функция выдаст ошибку.

*args позволяет передавать функции произвольное количество отдельных чисел.

Как вы видите, главным элементом здесь является оператор распаковки * (unpacking operator). Он принимает все передаваемые в функцию числа и формирует из них кортеж.

Затем мы проходимся по элементам этого кортежа, рассчитываем их сумму и делим на количество элементов. Использовать слово args не обязательно, мы назвали наш позиционный аргумент nums.

Если мы по какой-то причине захотим передать функции список, мы можем это сделать.

В этом случае мы передаем название списка со звездочкой *.

Для того чтобы продемонстрировать преобразование чисел в кортеж, напишем вот такую несложную функцию.

**kwargs

При использовании **kwargs происходит почти то же самое за тем исключением, что мы распаковываем именованные, а не позиционные аргументы. И распаковываем их в словарь, а не в список. Сразу посмотрим на примере.

Приведем более сложный пример. Напишем функцию, которая на вход примет произвольное количество чисел (позиционный аргумент), преобразует в кортеж (*args) и рассчитает среднее арифметическое (mean) и среднее квадратическое отклонение (standard deviation).

Для каждой из метрик мы дополнительно создадим именованный параметр, который определит выводить эту метрику или нет. Параметры мы передадим через **kwargs. Внутри функции из них будет сформирован словарь.

Вызовем функцию simple_stats() и передадим ей числа и именованные аргументы.

Если для одного из параметров задать значение False, функция не выведет соответствующую метрику.

Для того чтобы передать параметры списком и словарем, нам нужно использовать операторы распаковки * и * * соответственно.

Количество именованных аргументов в **kwargs может быть любым. Ничто не мешает нам добавить еще один параметр.

Впрочем, для того чтобы это имело смысл, такой параметр должен быть прописан внутри функции.

В заключение скажу, что все приведенные выше примеры являются учебными и без *args и **kwargs здесь конечно можно обойтись. На практике, они применяются в более сложных конструкциях, например, в так называемых декораторах, однако эта тема выходит за рамки сегодняшнего занятия.

Подведем итог

Сегодня мы впервые поговорили про функции в программировании и выяснили, чем они отличаются от функций в математике. Кроме того мы узнали, что в Питоне можно:

использовать готовые функции, которые уже встроены либо в базовый функционал, либо в дополнительную библиотеку;
объявлять собственные функции через ключевое слово def и название функции; а также
создавать анонимные или lambda-функции, которые очень удобно применять там, где в полноценных собственных функциях нет необходимости

Помимо этого, мы выяснили, что любой функции можно передать параметры и аргументы, которые в зависимости от способа передачи могут быть позиционными или именованными.

Мы узнали, что у переменной может быть локальная и глобальная области видимости.

Наконец, мы поговорили про возможность передачи различного количества позиционных и именованных аргументов через *args и **kwargs.

Вопросы для закрепления

Какие три вида функций мы изучили?

Посмотреть правильный ответ

Ответ: встроенные, собственные, а также анонимные или lambda-функции.

Какие бывают параметры и аргументы функции?

Посмотреть правильный ответ

Ответ: позиционные (в этом случае мы указываем только аргумент, но ставим его в определенном порядке) и именованные (указываем и параметр, и аргумент, но порядок не важен).

Какова область видимости локальной переменной?

Посмотреть правильный ответ

Ответ: область видимости локальной переменной ограничена той функцией, в которой эта переменная была объявлена.

Читайте также: