Python оператор and

Содержание:

Содержание
Операторы присваивания Python
Использование ключевого слова yield
Операторы¶
Как работает if else
Оператор pass в Python
Операторы else и elif
Использование
Унарные арифметические операции Python
Python для систем счисления
Вложенные циклы
- Видео по теме
Ввод и вывод данных

Содержание

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

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

Вот тут-то и появляются операторы управления. Операторы управления занимаются порядком выполнения выражений в программе (называемой потоком управления программы).

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

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

В программе на Python оператор — это способ принятия такого рода решений. Он допускает условное выполнение оператора или группы операторов на основе значения выражения.

В общих чертах этот урок выглядит следующим образом:

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

Готовы? Поехали!

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

Изучаем оператор if else python

Оператор «=» присваивает значение, расположенное справа, переменной слева. Например, v = 23 присваивает значение числа 23 переменной v.

В программировании часто используют составные операторы присваивания. Они соединяют арифметический оператор с оператором «=». Поэтому для сложения мы используем оператор «+» с оператором «=», чтобы получить составной оператор «+=». Пример:

w = 5
w += 1
print(w)

Вывод

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

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

for x in range (0, 7):
    x *= 2
    print(x)

Вывод

При помощи for можно автоматизировать процесс использования оператора «. Он умножает переменную на число , а затем присваивает полученный результат переменной для следующей итерации цикла.

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

y += 1          # добавить число и присвоить результат
y -= 1          # отнять число и присвоить результат
y *= 2          # умножить на число и присвоить результат
y /= 3          # разделить на число и присвоить результат
y // = 5        # разделить без остатка на число и присвоить результат
y **= 2         # возвести в степень и присвоить результат
y %= 3          # вернуть остаток от деления и присвоить результат

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

Использование ключевого слова yield

Оператор if else в python

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

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

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

В этом скрипте создается функция cube_numbers, которая принимает список чисел, вычисляет их куб и возвращает вызывающему объекту список целиком. При вызове этой функции список кубов возвращается и сохраняется в переменную cubes. Как видно из вывода, возвращаемые данные – это список целиком:

Теперь, изменим сценарий, так чтобы он возвращал генератор.

В приведенном выше скрипте функция cube_numbers возвращает генератор вместо списка кубов чисел. Создать генератор с помощью ключевого слова yield очень просто. Здесь нам не нужна временная переменная cube_list для хранения куба числа, поэтому даже наш метод cube_numbers проще. Кроме того, не используется оператор return, но вместо него используется слово yield для возвращения куба числа внутри цикла.

Теперь, когда функция cube_number возвращает генератор, проверим его, запустив код:

Несмотря на то, что был произведён вызов функции cube_numbers, она фактически не выполняется на данный момент времени, и в памяти еще нет элементов.

Получение значение из генератора:

Вышеуказанная функция возвратит «1». Теперь, когда снова вызывается next генератора, функция cube_numbers возобновит выполнение с того места, где она ранее остановилась на yield. Функция будет продолжать выполняться до тех пор, пока снова не найдет yield. Следующая функция будет продолжать возвращать значение куба по одному, пока все значения в списке не будут проитерированы.

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

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

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

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

Операторы¶

Получение пользовательского ввода в python с input()

Кратко рассмотрим операторы и их применение:

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

>>> 2 + 3
5
>>> 3 * 5
15

Операторы и их применение

Оператор
Название
Объяснение
Примеры

Сложение
Суммирует два
объекта

даст ;
даст

Вычитание
Даёт разность
двух чисел;
если первый
операнд
отсутствует,
он считается
равным нулю

даст отрицательное число,
а даст .

Умножение
Даёт
произведение
двух чисел или
возвращает
строку,
повторённую
заданное число
раз.

даст .
даст .

Возведение
в степень
Возвращает
число ,
возведённое в
степень

даст
(т.е. )
Деление
Возвращает
частное от
деления
на

даст .

Целочисленное
деление
Возвращает
неполное
частное от
деления

даст .
даст .

Деление по
модулю
Возвращает
остаток от
деления

даст .
даст .

Сдвиг влево
Сдвигает биты
числа влево на
заданное
количество
позиций. (Любое
число в памяти
компьютера
представлено в
виде битов —
или двоичных
чисел, т.е.
0 и 1)

даст .
В двоичном виде представляет
собой . Сдвиг влево на 2 бита
даёт , что в десятичном
виде означает .

Сдвиг вправо
Сдвигает биты
числа вправо на
заданное число
позиций.

даст .
В двоичном виде представляется
как , что будучи смещённым на
1 бит вправо, даёт , а это, в
свою очередь, не что иное как
десятичное

Побитовое И
Побитовая
операция И над
числами

даёт .

Побитовое ИЛИ
Побитовая
операция ИЛИ
над числами

даёт

Побитовое
ИСКЛЮЧИТЕЛЬНО
ИЛИ
Побитовая
операция
ИСКЛЮЧИТЕЛЬНО
ИЛИ

даёт

Побитовое НЕ

Побитовая
операция НЕ для
числа
соответствует

даёт .

Меньше
Определяет,
верно ли, что
меньше

Все
операторы
сравнения
возвращают
или
.
Обратите
внимание на
заглавные буквы
в этих словах.

даст ,
а даст .
Можно составлять произвольные цепочки
сравнений: даёт .

Больше

Определяет,
верно ли, что
больше

даёт .
Если оба операнда — числа, то перед
сравнением они оба преобразуются к
одинаковому типу. В противном случае
всегда возвращается .

Меньше или
равно
Определяет,
верно ли, что
меньше
или равно

даёт
.

Больше или
равно
Определяет,
верно ли, что
больше
или равно

даёт
.

Равно
Проверяет,
одинаковы ли
объекты

даёт
.
даёт
.
даёт
.

Не равно
Проверяет,
верно ли, что
объекты не
равны

даёт
.

Логическое НЕ
Если
равно ,
оператор вернёт

Если
же равно
,
получим
.

даёт .

Логическое И

даёт ,
если
равно
, в противном
случае
возвращает
значение

возвращает , поскольку x равно
. В этом случае Python не
станет проверять значение , так
как уже знает, что левая часть
выражения ‘and’ равняется ,
что подразумевает, что и всё выражение
в целом будет равно ,
независимо от значений всех остальных
операндов. Это называется укороченной
оценкой булевых (логических) выражений.

Логическое
ИЛИ
Если
равно ,
в результате
получим
, в
противном
случае получим
значение

даёт
. Здесь также может
производиться укороченная оценка
выражений.

Как работает if else

Синтаксис

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

Синтаксически конструкция выглядит следующим образом:

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

Принцип работы оператора выбора в Python

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

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

Отступы

Отступы – важная и показательная часть языка Python. Их смысл интуитивно понятен, а определить их можно, как размер или ширину пустого пространства слева от начала программного кода.

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

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

Примеры

Рассмотрим несколько практических примеров использования условного оператора.

Пример №1: создание ежедневного бэкапа (например базы данных):

Пример №2: Проверка доступа пользователя к системе. В данном примере проверяет наличие элемента в списке:

Пример №3: Валидация входных данных. В примере к нам приходят данные в формате . Нам необходимо выбрать все записи определенного формата:

Оператор pass в Python

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

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

# This is not Python
if (x)
{
}

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

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

Рассмотрим этот скрипт foo.py:

if True:

print('foo')

После этого, вы получите:

C:\Users\john\Documents\Python\doc>python foo.py
  File "foo.py", line 3
    print('foo')
        ^
IndentationError: expected an indented block

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

if True:
    pass

print('foo')

Сейчас foo.py работает без ошибок:

C:\Users\john\Documents\Python\doc>python foo.py
foo

Операторы else и elif

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

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

if <expr>:
    <statement(s)>
else:
    <statement(s)>

Если имеет значение true, то выполняется первый набор, а второй пропускается. Если имеет значение false, то первый набор пропускается, а второй выполняется. В любом случае, выполнение затем возобновляется после второго набора. Оба набора определяются отступом, как описано выше.

В этом примере x меньше 50, поэтому выполняется первый набор (строки 4-5), а второй набор (строки 7-8) пропускается:

x = 20

if x < 50:
    print('(первый набор)')
    print('x is small')
else:
    print('(второй набор)')
    print('x is large')

Здесь, с другой стороны, x больше 50, поэтому первый набор передается, а второй выполняется:

x = 120

if x < 50:
    print('(первый набор)')
    print('x is small')
else:
    print('(второй набор)')
    print('x is large')

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

, то выполняется этот набор:

if <expr>:
    <statement(s)>
elif <expr>:
    <statement(s)>
elif <expr>:
    <statement(s)>
    ...
else:
    <statement(s)>

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

name = 'Joe'
if name == 'Fred':
    print('Hello Fred')
elif name == 'Xander':
    print('Hello Xander')
elif name == 'Joe':
    print('Hello Joe')
elif name == 'Arnold':
    print('Hello Arnold')
else:
    print("I don't know who you are!")

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

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

Вот одна из возможных альтернатив приведенному выше примеру с использованием метода dict. get() :

names = {
    'Fred': 'Hello Fred',
    'Xander': 'Hello Xander',
    'Joe': 'Hello Joe',
    'Arnold': 'Hello Arnold'
}

print(names.get('Joe', "I don't know who you are!"))

print(names.get('Rick', "I don't know who you are!"))

Вспомните из статьи про словари Python, что метод dict. get () ищет в словаре указанный ключ и возвращает соответствующее значение, если оно найдено, или заданное значение по умолчанию, если его нет.

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

var  # Not defined

   
if 'a' in 'bar':
    print('foo')
elif 1/0:
    print("This won't happen")
elif var:
    print("This won't either")

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

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

Теперь, несмотря на то, что существует множество классов, в которых реализована возможность использования , нам интересно посмотреть, как она работает, чтобы мы могли написать ее сами!

Во-первых, оператор with сохраняет ссылку на объект в объекте контекста.

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

А теперь идем дальше. После создания объекта контекста он вызывает метод dunder для объекта.

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

Теперь помните ключевое слово ? Это фактически возвращает объект контекста. Поскольку нам нужен объект, возвращаемый функцией open(), мы используем ключевое слово для получения объекта контекста.

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

После этого мы входим во вложенный блок операторов.

После того, как вложенный блок закончился, ИЛИ, если в нем есть исключение, программа всегда выполняет для объекта контекста.

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

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

Чтобы было понятнее, давайте рассмотрим пример создания нашего собственного диспетчера контекста для класса.

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

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

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

i = 3.3
print(+i)

Вывод

3.3

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

j = -19
print(+j)

Вывод

-19

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

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

i = 3.3
print(-i)

Вывод

-3.3

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

j = -19
print(-j)

Вывод

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

Python для систем счисления

bin(y) — целое число преобразовывается в двоичную строку.
hex(y) — целое число преобразовывается в шестнадцатеричную строку.
oct(y) — целое число преобразовывается в восьмеричную строку.

Рассмотрим примеры работы с системами счисления:

bin(17) # '0b10001'
oct(17) # '0o21'
hex(17) # '0x11'

Задание Python 1_2: Даны две переменные. Запросить их значение. Выполнить основные арифметические действия с переменными, целочисленное деление, возведение в квадрат. Осуществить перевод в системы счисления (в 8-ю и 16-ю). Вывести результат.

Задание Python 1_3: Найти длину окружности L и площадь круга S заданного радиуса R:

L=2*pi*R, S=pi*R2.

В качестве значения использовать 3.14.

* Из задачника М. Э. Абрамян

Задание Python 1_4: Даны три точки A, B, C на числовой оси. Найти длины отрезков AC и BC и их сумму.
* Из задачника М. Э. Абрамян

Пример: Дано двузначное число. Найти сумму и произведение его цифр.
* Из задачника М. Э. Абрамян

Решение:

import math
print('Введите двузначное число: ')
A = int(input())
Res = (A // 10) + math.fmod(A, 10)
print('Сумма его цифр равна: ', int(Res))
Res = (A // 10) * math.fmod(A, 10)
print('Произведение его цифр равно: ', int(Res))

Задание Python 1_5: Дано двухзначное целое число. Вывести сначала его правую цифру, а затем левую.

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

* Из задачника М. Э. Абрамян

Вложенные циклы

Итак, мы с вами
рассмотрели два оператора циклов: while и for. Все эти циклы
можно комбинировать друг с другом. То есть, создавать вложенные циклы (цикл
внутри цикла).

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

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

Тогда мы делаем первый цикл от 1 до N и вложенный от
1 до M

A =  1,2,3, 4,5,6 
N=2; M=3
for i in range(N):
    for j in range(M):
       print(Aij)
    print()

Или для подсчета
вот такой двойной суммы ряда

Программа будет выглядеть так:

S=; M=10; N=5
for i in range(1,N+1):
    for j in range(1,M+1):
        S += i*j
print(S)

Мы здесь сначала
пробегаем все значения j от 1 до M при
фиксированном i=1, затем,
значение i увеличивается
на 1, становится 2 и при этом i снова пробегаются значения j от 1 до M. И так пока i не превысит
значение N. То есть,
второй цикл вложен вот в этот первый. И таких вложений можно делать сколько
угодно.

Вот так работают
операторы циклов в Python и теперь вы знаете как их можно
применять на практике.

Видео по теме

Python 3 #1: установка и запуск интерпретатора языка

Python 3 #2: переменные, оператор присваивания, типы данных

Python 3 #3: функции input и print ввода/вывода

Python 3 #4: арифметические операторы: сложение, вычитание, умножение, деление, степень

Python 3 #5: условный оператор if, составные условия с and, or, not

Python 3 #6: операторы циклов while и for, операторы break и continue

Python 3 #7: строки — сравнения, срезы строк, базовые функции str, len, ord, in

Python 3 #8: методы строк — upper, split, join, find, strip, isalpha, isdigit и другие

Python 3 #9: списки list и функции len, min, max, sum, sorted

Python 3 #10: списки — срезы и методы: append, insert, pop, sort, index, count, reverse, clear

Python 3 #11: списки — инструмент list comprehensions, сортировка методом выбора

Python 3 #12: словарь, методы словарей: len, clear, get, setdefault, pop

Python 3 #13: кортежи (tuple) и операции с ними: len, del, count, index

Python 3 #14: функции (def) — объявление и вызов

Python 3 #15: делаем «Сапер», проектирование программ «сверху-вниз»

Python 3 #16: рекурсивные и лямбда-функции, функции с произвольным числом аргументов

Python 3 #17: алгоритм Евклида, принцип тестирования программ

Python 3 #18: области видимости переменных — global, nonlocal

Python 3 #19: множества (set) и операции над ними: вычитание, пересечение, объединение, сравнение

Python 3 #20: итераторы, выражения-генераторы, функции-генераторы, оператор yield

Python 3 #21: функции map, filter, zip

Python 3 #22: сортировка sort() и sorted(), сортировка по ключам

Python 3 #23: обработка исключений: try, except, finally, else

Python 3 #24: файлы — чтение и запись: open, read, write, seek, readline, dump, load, pickle

Python 3 #25: форматирование строк: метод format и F-строки

Python 3 #26: создание и импорт модулей — import, from, as, dir, reload

Python 3 #27: пакеты (package) — создание, импорт, установка (менеджер pip)

Python 3 #28: декораторы функций и замыкания

Python 3 #29: установка и порядок работы в PyCharm

Python 3 #30: функция enumerate, примеры использования

Ввод и вывод данных

Вывод данных осуществляется при помощи оператора print:

a = 1
b = 2
print(a)
print(a + b)
print('сумма = ', a + b)

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

1
2
3

a = 1; b = 2; print(a)
print(a + b)
print('сумма = ', a + b)

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

1
2
3

x=2
y=5
print ( x, "+", y, "=", x+y, sep = " " )

Результат отобразится с пробелами между элементами: 2 + 5 = 7

Для форматированного вывода используется format:

1 2	x = 11 print ( "{:4d}".format(x) )

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

Или с несколькими аргументами:

1 2	x = 2 print ( "{:4d}{:4d}{:4d}".format (x, x+x, x*x) )

В итоге каждое из значений выводится из расчета 4 знакоместа.

Ввод данных осуществляется при помощи оператора :

1 2	a = input() print(a)

В скобках функции можно указать сообщение-комментарий к вводимым данным:

a = input ("Введите количество: ")

Функция input воспринимает входные данные, как поток символов. Поэтому, чтобы принять целочисленное значение, следует воспользоваться функцией int():

a = int (input())

Задание Python 1_1:
Используя операторы input и print, выведите значения целых переменных x=5 и y=3 в следующих форматах:
3+5=?
3 | 5 | 8
Z(5)=F(3)
x=5; y=3;
Ответ: (5;3)