Что такое инструкция в языках программирования

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

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

По сути, любой python-скрипт представляет собой не что иное, как некоторую последовательность инструкций, которая может состоять из десятков, сотен,
тысяч или даже сотен тысяч и миллионов инструкций (см. пример №1). Все зависит от того, сколько инструкций потребуется для того, чтобы описать все шаги,
необходимые для достижения целей программы.

# Инструкция импортирует переменную pi из модуля math.
from math import pi    

# Позиционное присваивание значений глобальным переменным.
x, y, z = [1, 2, 3]
        
# Эта инструкция объявляет функцию со значением по умолчанию.
def ex_func(z=0):

    # Будут использоваться глобальные переменные.
    global x, y
    # Комбинированные инструкции присваивания.
    # Теперь глобальная x == 10.
    x *= 10
    # Теперь глобальная y == 20.    
    y += 18
    # Глобальная z не изменилась, а локальная z == z*z.
    z **= 2    
    
    # Инструкция объявляет вложенную функцию.
    def in_func():

        # Будет использоваться переменная z из области видимости
        # объемлющей функции, т.е. ex_func.
        nonlocal z

        # Инструкция запускает цикл.
        for i in range(25):
            # Условная инструкция.
            if i<5: 
                # Инструкция перехода в начало цикла. 
                continue
            # От 5 до 9.
            elif i>=5 and i<10:
                # Увеличиваем z из обл. видимости ex_func.    
                z += i                
            # При i == 10.
            else:
                # Инструкция прерывания цикла.  
                break

        # Инструкция возврата значения функцией in_func.            
        return z

    # Инструкция возврата значения функцией ex_func.            
    return x + y + in_func()

# Инструкция будет отлавливать и обрабатывать исключения.    
try:
  
    # Инструкция присваивает переменной рез-т вычисления выражения.
    res = int(pi)*10 + ex_func(30) + int(input('Введите число: '))       
    # Инструкция выводит результат на экран.
    print(res, end='nn')
  		
# Блок выполняется, когда возбуждается исключение.
except Exception as err:
    # Выводим сообщение об ошибке.
    print(err)
# Если ошибок нет.
else:
    # Ничего не делаем (пустая инструкция-заполнитель).
    pass
# Этот блок выполняется всегда, даже при наличии исключения.
finally:
    # Запрашиваем ввод, чтобы окно не закрылось.
    input()

Введите число: число
invalid literal for int() with base 10: 'число'






























































	
	
	

Пример №1. Виды и формы инструкций в Python.

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

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

• a = b – это инструкция присваивания (например, a = 5**2 — 3 или
  b = len([1, 2, 3])). Помимо этого имеются и другие формы присваивания: комбинированные инструкции присваивания (например,
  a += 5 или b **= 7), позиционное присваивание (например, a, b = 5, 7 или
  [a, b] = ‘AB’), операция распаковывания последовательностей (например, a, *b = 1, 2, 3 или
  a, *b, c = ‘ABCDEF’), а также групповое присваивание одного значения (например, a = b = c = 5). Алгоритм присваивания
  у всех этих форм несколько отличается, но главная цель у них одна – это создание ссылок на объекты и сохранение их в переменных. При этом стоит добавить, что присваивание может
  быть и неявным, например, в вызовах функций или в заголовках циклов, но в любом случае результатом будут ссылки на объекты, сохраненные в переменных.
• def – определение функций и методов. Например,
  def my_func(a, b, c=0, *d): return a + b + c + d[0].
• return – возврат результата из функций и методов.
• yield – инструкция возврата результата из функции-генератора с сохранением состояния ее
  локальных переменных. При повторном вызове такой функции выполнение, в отличие от инструкции return, продолжается с ключевого слова
  yield, на котором ее работа была прервана ранее.
• class – определение классов. Например, class MyСlass: pass.
• pass – пустая инструкция-заполнитель.
• global – инструкция объявления используемых переменных глобальными (если переменных несколько, то они
  перечисляются через запятую).
• nonlocal – инструкция используется во вложенных функциях и объявляет переменные нелокальными. В результате
  интерпретатор будет использовать переменные с указанными именами из ближайшей области видимости (т.е. объемлющей функции), исключая глобальную.
• if/elif/else – условная инструкция.
• for/else – инструкция обхода последовательности в цикле.
• while/else – цикл общего назначения.
• break – инструкция выхода из цикла.
• continue – инструкция перехода в начало цикла.
• import – инструкция импорта всех доступных имен из указанных модулей (модули
  присваиваются по одному за одну инструкцию, хотя допускается и по несколько за раз, но тогда они перечисляются через запятую).
• from/import – инструкция импорта из модуля только указанных имен
  (имена перечисляются через запятую). Например, from math import pi as p, tau as t.
• try/except/finally – инструкция обработки исключений.
• raise – инструкция возбуждения исключений.
• assert – инструкция отладки, которая позволяет производить проверку
  истинности утверждений и выводить сообщение об ошибке. Например, assert x > y, ‘Значение x недопустимо мало!’.
• with/as – менеджер контекста.
• del – инструкция удаления ссылок на объекты (если ссылок несколько, то они перечисляются через запятую). Например,
  del a, b[0], c[‘car’] .

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

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

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

Например, инструкция присваивания res = 5 + my_func(1, 2) содержит в правой части выражение, включающее вызов функции. Однако в
результате вычислений в переменной сохранится ссылка лишь на один итоговый объект.

В отличие от выражений обычные инструкции в Python не могут использоваться там, где ожидается значение. Поэтому их нельзя использовать в качестве
аргументов функций, правой части присваиваний, в качестве операций или возвращаемых значений. Например, если в инструкции выше заменить вызов функции ее определением в виде
res = 5 + (def my_func(a, b): return a + b), интерпретатор возбудит исключение.

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

• условные инструкции, такие как if/else или
  if/elif/else, которые указывают интерпретатору Python на выполнение или пропуск других
  инструкций в зависимости от значения условного выражения;
• инструкции циклов, такие как for/in или
  while, которые указывают интерпретатору на многократное выполнение других инструкций;
• инструкции переходов, такие как break,
  continue или return, которые указывают интерпретатору на выполнение перехода в другую
  часть программы;
• инструкции обработки исключений, такие как try/except/else
  или try/except/finally, которые указывают интерпретатору на выполнение перехода в другую часть программы в случае возникновения
  ошибок.

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

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

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

# Присваивается смешанное выражение, включающее 
# генератор списка, арифметические выражения, 
# выражения сравнения и логическое выражение. 
li = [x*10 for x in (0, 1, 2, 3) if x > 0 and x != 3]
                       
# Анонимная функция и ее вызов в арифметическом выражении.
res = (lambda a, b: a + b)(li[0], li[1])**2

# Выражения с операторами идентичности и членства,
# выражения вызовов функций. 
if res in [900, 1000] and type(res) is int:
    print(res)

900









		
			

Пример №2. Использование выражений в Python.

В примере выше простые выражения литерального значения (например, 10, (0, 1, 2, 3), int),
выражения переменных (например, x или res) и выражения вызовов функций (например,
type(res) или более сложный вызов анонимной функции (lambda a, b: a + b)(li[0], li[1])) посредством операторов объединяются
в более длинные смешанные выражения. Однако все эти примеры далеко не предел, т.к. выражения могут использоваться везде, где интерпретатор ожидает получить значение. Да, порой выражения могут
выглядеть довольно длинными и сложными, но в результате вычислений на выходе интерпретатор все равно будет оперировать каким-то одним результирующим значением.

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

• Выражения литерального значения – это литералы в коде программы, например, ‘ten’ (строка),
  10 (число), [‘ten’, 10] (список) или list (объект).
• Выражения переменных – обычные инициализированные переменные, например, res в выражении
  res in [900, 1000] (здесь переменная уже инициализирована, а значит обращение к ней возвращает значение, сохраненное в памяти под данным именем).
• Арифметические выражения – используются привычные нам математические операторы, например, a + b**3.
• Условные выражения или выражения сравнения – используются операторы сравнения, например, a <= b.
• Выражения с логическими операторами – используются логические операторы, например, a > b and a < c.
• Выражения с побитовыми операторами – используются побитовые операторы, например, a&b.
• Выражения с операторами принадлежности – используются операторы принадлежности (членства) in и
  not in, например, 5 in [1, 2, 3].
• Выражения с операторами идентичности – используются операторы идентичности is и
  is not, например, 5 is not ‘5’.
• Вызовы функций и методов – это тоже выражения, т.к. они явно или неявно возвращают результат, например, f(3, 5).
• Генераторы – генераторы выражений, списков, словарей, множеств. Например,
  {simb for simb in ‘123’}.
• lambda-выражения или анонимные функции – это специальные конструкции, которые позволяют встраивать определения функций в программный код
  выражений. Например, 5**2 + (lambda x, y: x — y)(5, 2).
• Выражения присваивания – используется моржовый оператор
  :=, который позволяет присваивать значения непосредственно в выражении. Например, x = 5 + (y:=5).
• Трехместные выражения if/else – эти конструкции позволяют использовать в выражениях
  условную инструкцию if/else в ее простейшей форме. Например, x = True if y > 0 else False.

Да, разделение по категориям получилось несколько условным, но вполне наглядным для того, чтобы отличать в коде выражения от инструкций. Это внешне. Логически выражения также несколько
отличаются по своему использованию и смысловому содержанию. Ведь выражения – это все, что состоит из объектов (ну, или ссылок на них) и операторов и может быть вычислено интерпретатором
для получения значения, а инструкции – это указания на выполнение программой каких-либо действий (необязательно вычислений). Да, выражения вполне обоснованно можно считать особым видом
инструкций, результатом исполнения которых являются значения. Но при этом не стоит забывать, что на практике выражения практически всегда входят в состав каких-либо инструкций и других более
сложных смешанных выражений, а вот использование инструкций в выражениях недопустимо (например, инструкция d = 5 + (def my_func(): return 3) однозначно вызовет
сбой скрипта).

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

Операции (от
англ. operations) – это те действия, которые мы выполняем над переменными и объектами.

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

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

Примерами выражений с использованием операторов могут служить
a + b, a != b, -b,
a > b, (b + 7)/(5 — 3**2) и др. Здесь символы и комбинации символов
+, !=, **, —,
/, > и есть операторы. Кстати, выражения или значения, расположенные по сторонам операторов,
называют операндами.

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

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

# Теперь a==19, т.к. приоритет оператора * выше, чем у +.
a = 5 + 7*2     
print('5 + 7*2 ->', a)

# Теперь b==24, т.к. порядок был указан при помощи скобок.
b = (5 + 7)*2   
print('(5 + 7)*2 ->', b, end='nn')

c = 2
# Вернет True, т.к. согласно принятому порядку 
# это тоже самое, что и a < b and b > c. 
print(a < b > c)   
# Вернет False, т.к. скобки явно указывают порядок выполнения.
print('a < (b > c) ->', a < (b > c), end='nn')  
        
# Согласно принятому порядку это тоже самое, что и c = (a = b).
# А вот использование инструкции c = a += b вызовет ошибку.
c = a = b     
 
# Теперь d == -8, т.к. операторы - и - имеют равный приоритет и 
# левую ассоциативность, поэтому 5 - 6 - 7 == (5 - 6) - 7. 
d = 5 - 6 - 7     
print('5 - 6 - 7 ->', d, end='nn')
 
# Теперь d == 1, т.к. (0 and 0 or 1) == (0 and 0) or 1. 
d = 0 and 0 or 1     
print('0 and 0 or 1 ->', d)         
  
# Теперь d == 0, т.к. операция в скобках выполняется первой. 
d = 0 and (0 or 1)     
print('0 and (0 or 1) ->', d)

5 + 7*2 -> 19
(5 + 7)*2 -> 24

True
a < (b > c) -> False

5 - 6 - 7 -> -8

0 and 0 or 1 -> 1
0 and (1 or 0) -> 0



















		
			

Пример №3. Использование операторов в Python.

Для большей наглядности мы перечислили основные операторы языка Python, использующиеся в выражениях, в порядке убывания их приоритетов
в таблице №4. Чем ниже приоритет, тем ниже находится строка с соответствующими операторами. Если операторы имеют одинаковый приоритет,
они перечисляются в одной и той же строке таблицы.

Таблица №4. Основные операторы языка Python.

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

Большинство операторов, приведенных в таблице, являются бинарными, т.е. используются с двумя операндами (например,
+, —, !=). Есть также операторы, которые
работают только с одним операндом, их называют унарными. Примером может служить —
(оператор отрицания или унарный минус), который применяется для смены знака числа на противоположный.

В конце параграфа хотелось бы еще раз отметить, что фрагменты кода с присваиванием значений переменным в Python принято
считать инструкциями присваивания. Это связано с тем, что такие фрагменты внутри обычных выражений не разрешены, а в документации все операторы присваивания
объединены в одну группу и перечислены в отдельном пункте 2.6 «Delimiters» вместе
с другими разделителями (хотя и с оговоркой, что они могут выступать в роли операторов). Например, фрагменты кода d = 5,
s += 7**2 или li[0] += 3 — f мы будем называть инструкциями присваивания. Тем не
менее одна форма выражения присваивания в языке все таки имеется. Формируется она при помощи недавно введенного моржового оператора
:=, который может использоваться не только в инструкциях, но и внутри обычных выражений. Например, инструкция присваивания
li = [a := 1, b := 2] включает также и два выражения присваивания.

• Инструкции – это команды на языке Python, которые сообщают интерпретатору последовательность
  действий, необходимых для достижения поставленных целей. По умолчанию интерпретатор выполняет инструкции последовательно одна за другой в порядке их следования
  в коде. Если нужно изменить выполнение хода программы по умолчанию, используются управляющие конструкции: условные инструкции, циклы, инструкции переходов или
  инструкции обработки исключений.
• Выражение – это любая единица исходного кода Python, которая может быть вычислена
  интерпретатором для получения значения. Сложные выражения составляются из более простых при помощи различных операторов, которые позволяют выполнять над объектами
  такие операции как сложение, вычитание, сравнение и т.д. Но каким бы сложным не было выражение, в результате последовательных вычислений на выходе интерпретатор
  все равно будет оперировать каким-то одним результирующим значением.
• Важно помнить, что на практике выражения практически всегда входят в состав каких-либо инструкций, а вот использование последних в выражениях недопустимо
  (например, попытка выполнения инструкции d = if 3>k: k=3 приведет к ошибке).
• Операторы представляют собой символьные обозначения команд, с помощью которых мы выполняем операции над объектами. Выражения или значения, расположенные по сторонам
  операторов, называют операндами. Если оператор используется с двумя операндами, его называют бинарным. Если же оператор работает только с одним операндом, его
  называют унарным. Так в выражении -3 + (2 — 5)*7 операторы + и *
  представляют собой бинарные операторы, а вот оператор — используется и как бинарный оператор вычитания, и как унарный минус.
• Большинство операторов обрабатывают свои операнды в определенном направлении. Это свойство принято называть ассоциативностью. Одни операторы выполняют обработку
  своих операндов слева направо, обладая левой ассоциативностью, другие обладают правой ассоциативностью, выполняя обработку в обратном направлении, т.е. справа налево.
  Кроме того, существуют операторы не имеющие ассоциативности. Так левой ассоциативностью, в основном обладают бинарные операторы, правая ассоциативность
  присуща унарным операторам, а операторы сравнения вообще не обладают ассоциативностью.
• Важным является и приоритет операторов, т.к. операторы с большим приоритетом обрабатываются первыми. Например, значением выражения
  2*7 + 4 будет 18, а не 22, т.к. приоритет оператора умножения
  выше приоритета оператора сложения.
• Если приоритет операторов одинаков, они группируются и обрабатываются либо согласно их ассоциативности, либо в соответствии с установленным для них порядком (это
  касается операторов, у которых ассоциативность отсутствует). В любом случае лучше всегда использовать скобки, непосредственно определяя порядок группировки и не
  полагаясь на приоритет или ассоциативность операторов.

# Приоритет оператора умножения выше. 
# 5 + 10*5 == 5 + (10*5).
a = 5+10*5
# Выведет 55.        
print('5 + 10*5 =', a, end='nn')

# Приоритет одинаков, ассоциативность левая.
# 5/10*5 == (5/10)*5.
b = 5/10*5
# Выведет 2.5.        
print('5/10*5 =', b, end='nn')        
        
# Приоритет оператора is выше.
# True in [True] is True == True in ([True] is True).        
res = True in [True] is True      
# Выведет False.
print('True in [True] is True ->', res)

5 + 10*5 = 55

5/10*5 = 2.5

True in [True] is True -> False