Как инструкции отделяются друг от друга в python

Чтобы начать писать даже простейшие программы на языке Python (и не только на нем), необходимо изучить хотя бы
первичные основы синтаксиса языка. В противном случае компьютер просто не сможет понять и правильно выполнить нашу программу. Например, если
строку кода print(‘Привет, Мир!’) из задания предыдущего параграфа записать в виде
print (‘Привет, Мир!’), интерпретатор выдаст ошибку и не выведет это приветствие на
экран, т.к. в инструкции мы неправильно употребили пробел. Казалось бы мелочь, но его там вообще быть не должно. Таковы правила синтаксиса
языка Python.

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

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

Если синтаксис – это набор правил, которые помогают нам (программистам) правильно писать инструкции, то лексемы — это кирпичики, из которых мы эти
инструкции составляем.

Лексема – это минимальная единица кода программы, которая имеет для
интерпретатора определенный смысл и не может быть разбита на более мелкие логические части.

Все лексемы в Python делятся на пять основных групп: идентификаторы и ключевые слова
(NAME), литералы (NUMBER, STRING и т.д.), символы операций
(OP), разделители (NEWLINE, INDENT, ENDMARKER и др.) и
комментарии (COMMENT).

Узнать из каких лексем состоит тот или иной участок исходного кода Python можно при помощи модуля лексического
сканера tokenize, который можно найти в стандартной библиотеке в разделе
Python Language Services. После получения списка лексем, его можно использовать,
например, для синтаксической подсветки кода на языке Python, логического разбора кода или каких-нибудь других целей.

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

Чтобы получить наглядное представление о лексемах, давайте рассмотрим пример №1, в котором представлен код
простейшей программы, разбивающей строку с исходным python-кодом на лексемы и выводящей их на экран (для
просмотра результата работы программы не забудьте нажать кнопку «Результат»).

# Импортируем необходимые модули стандартной библиотеки.
import io, token, tokenize

# Создаем многострочную строку с кодом.
code_example = '''# Это словарь - именованная коллекция объектов.
my_dict = {'Имя': 'Python', 'Версия': "3.9.0"}

# Выводим значения на экран. 
print(my_dict['Имя'], my_dict['Версия'])'''

# Это позволит нам работать со строкой, как с файловым объектом.	
rl = io.StringIO(code_example).readline
	
# Разбиваем код на токены, т.е. лексемы с указанием 
# места их расположения в коде. 	
tkns = tokenize.generate_tokens(rl)
	
# Проходимся по всем токенам циклом.
for tkn in tkns:
    # Выводим тип, имя и саму лексему.
    print(tkn[0], ' -> ', token.tok_name[tkn[0]], ' -> ', tkn[1])

60 -> COMMENT -> # Это словарь - именованная коллекция объектов.
61 -> NL -> 

5 -> INDENT -> 	
1 -> NAME -> my_dict
54 -> OP -> =
54 -> OP -> {
3 -> STRING -> 'Имя'
54 -> OP -> :
3 -> STRING -> 'Python'
54 -> OP -> ,
3 -> STRING -> 'Версия'
54 -> OP -> :
3 -> STRING -> "3.9.0"
54 -> OP -> }
4 -> NEWLINE -> 

61 -> NL -> 

60 -> COMMENT -> #Выводим значения на экран. 
61 -> NL -> 

1 -> NAME -> print
54 -> OP -> (
1 -> NAME -> my_dict
54 -> OP -> [
3 -> STRING -> 'Имя'
54 -> OP -> ]
54 -> OP -> ,
1 -> NAME -> my_dict
54 -> OP -> [
3 -> STRING -> 'Версия'
54 -> OP -> ]
54 -> OP -> )
4 -> NEWLINE -> 
6 -> DEDENT -> 
0 -> ENDMARKER ->

Пример №1. Разложение python-кода на лексемы.

Как видим, лексический сканер выделил нам такие лексемы, как # Выводим значения на экран.
(комментарий), print (ключевое слово), my_dict (идентификатор),
{, :, ] (символы операций),
‘Версия’ (строковый литерал). Присутствуют в разборе и разделители в виде символов новой строки, которые при
отображении на экране добавили нам заметные отступы.

Что касается термина токен, то это та же самая лексема, только с указанием ее место­нахождения в исходном
коде. Дело в том, что лексические сканеры обычно выделяют не только сами лексемы, но также номера строк и столбцов, где каждая лексема начинается и
заканчивается.

Токен – это набор из лексемы и ее координат в исходном коде языка
программирования.

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

Литералы – это простые неименованные значения некоторого типа
данных, написанные непосредственно в самом коде программы.

В качестве примеров приведем литералы, которые являются значениями различных типов данных: вещественное число 3.4,
целое число 5, комплексное число 5+3j, строка в двойных кавычках
«яблоко», строка в одинарных кавычках ‘две груши’, логические значения
True и False, словарь {1: 1, ‘два’: 2},
список [1, 2, 3] и т.д. При этом, если, например, литерал числа 28840.0303178
является одновременно и лексемой (пусть и выглядит она подозрительно большой), то литерал списка [1, 2] состоит
сразу из пяти лексем.

Итак, лексемы – это логически неделимые фрагменты кода, а литералы – обычные значения.

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

Примерами идентификаторов могут служить: b (латинская буква), ж (русская буква),
_b (начинается со знака подчеркивания), py_2 (включает цифру),
_Чаво (начинается со знака подчеркивания и включает русские буквы, одна из которых заглавная),
G123 (начинается с заглавной буквы), set_name
(имя в «змеиной» нотации), setName (имя в
«верблюжей» нотации), ClassName (стиль CupWords) и т.д.

В то же время комбинации символов 15var_1, $Var2 или
var 3 не могут использоваться в качестве идентификаторов, т.к. они начинаются либо содержат недопустимые
символы (третье имя содержит пробел). Также следует помнить про регистр используемых символов, поскольку, например, идентификаторы
var_1, Var_1 и VAR_1 обозначают имена совершенно
разных переменных или функций, т.к. регистр символов у них не совпадает.

Для лучшего восприятия кода следует давать именам понятные и по возможности краткие названия, которые бы соответствовали, например, хранящимся
в переменных данным или же выполняемым функциями действиям. Кроме того, идентификаторы могут состоять как из одной буквы, так и сразу из нескольких
слов. Для таких случаев в программировании существуют два распространенных устоявшихся стиля записи идентификаторов, которые называются
camelCase («верблюжьяНотация») и snake_case («змеиная_нотация»). Если идентификатор
состоит из одного слова, то в обоих случаях он пишется строчными буквами. При наличии двух и более слов, в верблюжей
нотации первое слово идентификатора пишется строчными буквами, а каждое последующее слово начинается с заглавной буквы. В змеиной
нотации все слова пишутся строчными буквами, но каждое последующее слово идентификатора отделяется от предыдущего знаком подчеркивания
(см. пример №2).

# Одинаково в любой нотации.
cars = 5
автобусы = 10
	
# Змеиная нотация (для переменных и функций).
go_to_str = True
	
# Верблюжья нотация.
goToStr = True

# Смешивать нотации можно, но не рекомендуется.
goTo_str = False

# Стиль CupWords (для классов).
GoToStr = True

Пример №2. Стили записи идентификаторов.

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

Что касается соглашений по именам в Python, то они подробно описаны в руководстве по написанию кода
PEP8 на официальном сайте.

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

# Имеем 4 инструкции по одной на каждой строке.
# Точку с запятой нигде не ставим.

a = 3.7

b = 5.2

c = a + b

# Выведет 8.9
print(c)

# -------------------------

# Конечно, точки с запятой ошибок не вызовут, 
# но в Python так поступать не принято!!!

a = 3.7;

b = 5.2;

c = a + b;

# Опять же выведет 8.9
print(c);

8.9
8.9





















			
			

Пример №3. Примеры разделения инструкций в Python.

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

Основная инструкция:
	Вложенный блок инструкций

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

# Для отступов вложенных инструкций мы 
# использовали по одному символу табуляции Tab.
		
a = 3.7

b = 5.2

# Если делитель больше нуля, то
if a > 0:
    # делим числа
    c = a/b
    # и выводим результат на экран.
    print(c)
# Иначе, если	
elif a < 0:
    # перемножаем числа
    c = a*b
    # и выводим результат на экран.
    print(c)
# Иначе	
else:
    # выводим предупреждение.
    print('На ноль делить нельзя!')

0.7115384615384616




















			
			

Пример №4. Порядок использования отступов в Python.

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

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

 if <Условие №1>:
    <Блок инструкций №1>
 elif <Условие №2>:
    <Блок инструкций №2>
 ...
 else:
    <Запасной блок инструкций>

Если первое условие истинно (результатом вычислений будет True), то выполняется первый блок инструкций. Если первое условие ложно
(результатом вычислений будет False), то проверяются по-очереди все условия необязательных блоков elif и, если найдется
истинное условие, то выполняется соответствующий условию блок инструкций. Если все дополнительные условия окажутся ложными, выполнится запасной блок инструкций
else. Обязательным является только блок инструкций if, остальные блоки могут быть опущены. При этом разрешается
использовать любое количество блоков elif, но только один блок else (еще раз посмотрите на пример выше).

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

Далее. Бывают ситуации, когда в коде короткие инструкции идут одна за другой. Тогда некоторые программисты записывают их на одной
строке, разделяя точкой с запятой. Кроме того, на одной строке с основной инструкцией разрешается записывать и односторочные вложенные инструкции
(см. пример №5). Однако все это пусть и допускается, но в Python не приветствуется!

# Пишем 2 инструкции на одной строке.
# Вот здесь-то как раз и нужна точка с запятой.
a = 3.7; b = 5.2

# А здесь мы записали на одной строке и основную инструкцию, и вложенные, 
# не забыв разделить 2 вложенные инструкции точкой с запятой. 
if a > 0: c = a/b; print(c)
else: print('На ноль делить нельзя!')

# Согласитесь, что читаемость кода упала. Поэтому старайтесь поступать 
# так как можно реже! А еще лучше, вообще никогда так не делайте!

0.7115384615384616








			
			

Пример №5. Запись нескольких инструкций на одной строке.

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

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

# Обычные короткие инструкции.
import math

a = 3
d = 56.33
s = 1.041

# Чтобы расположить длинную инструкцию на нескольких строках, 
# нужно просто заключить ее в круглые скобки.
n = (
    143.77 + 34*(math.sqrt(439.25)) - 
    23/(math.pi - a*d) + abs(-36*s)
    )

# Т.к. синтаксис литерала списка предусматривает квадратные
# скобки, круглые писать не нужно.
li = [
     'а', 'б', 'в', 'г', 'д', 'е', 'ё', 'ж', 'з', 'и', 'й', 'к', 
     'л', 'м', 'н', 'о', 'п', 'р', 'с', 'т', 'у', 'ф', 'х', 'ц', 
     'ч', 'ш', 'щ', 'ъ', 'ы', 'ь', 'э', 'ю', 'я'
     ]

# А вот синтаксис литерала словаря требует наличие фигурных скобок.
dict = {
       1: 'а', 2: 'б', 3: 'в', 4: 'г', 5: 'д', 6: 'е', 7: 'ё', 
       8: 'ж', 9: 'з', 10: 'и', 11: 'й', 12: 'к', 13: 'л', 
       14: 'м', 15: 'н', 16: 'о', 17: 'п', 18: 'р', 19: 'с', 
       20: 'т', 21: 'у', 22: 'ф', 23: 'х', 24: 'ц', 25: 'ч', 
       26: 'ш', 27: 'щ', 28: 'ъ', 29: 'ы', 30: 'ь', 31: 'э', 
       32: 'ю', 33: 'я'
       }

# Выведем все на экран.
print('Значение выражения: ', n, end='nn')
print('Русские буквы в нижнем регистре: ', li, end='nn')
print('Словарь с цифровыми ключами: ', dict, end='nn')

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

Значение выражения: 893.9666059760239

Русские буквы в нижнем регистре: ['а', 'б', 'в', 'г', 'д', 'е', 'ё', 
'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о', 'п', 'р', 'с', 'т', 'у', 
'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ы', 'ь', 'э', 'ю', 'я']

Словарь с цифровыми ключами: {1: 'а', 2: 'б', 3: 'в', 4: 'г', 5: 'д', 
6: 'е', 7: 'ё', 8: 'ж', 9: 'з', 10: 'и', 11: 'й', 12: 'к', 13: 'л', 
14: 'м', 15: 'н', 16: 'о', 17: 'п', 18: 'р', 19: 'с', 20: 'т', 21: 'у', 
22: 'ф', 23: 'х', 24: 'ц', 25: 'ч', 26: 'ш', 27: 'щ', 28: 'ъ', 29: 'ы', 
30: 'ь', 31: 'э', 32: 'ю', 33: 'я'}

Пример №6. Запись одной инструкции на нескольких строках.

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

Как вы уже поняли, для вывода информации на экран используется встроенная функция print(), которой через запятую
следует передавать выводимые на экран значения. Отметим, что все значения сначала автоматически преобразуются в строки и только потом выводятся.
При этом в качестве дополнительных аргументов функции можно передавать именованные строковые аргументы sep и
end. Первый задает вид разделителя между выводимыми значениями (по умолчанию это обычный пробел, т.е.
sep=’ ‘), а второй – символы в конце вывода (по умолчанию это символ перевода строки, т.е.
end=’n’). В итоге инструкция вывода, например, двух значений может иметь такой вид:
print(‘один’, ‘два’, sep=’ ‘, end=’n’).

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

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

# a = 3.7 - эта инструкция не сработает, т.к. считается комментарием.

# Многострочные комментарии синтаксисом не предусмотрены, но!!!
# Для этого вполне подойдут строки в тройных кавычках.

# Удобный многострочный комментарий.
'''b = 5.2 

# Комментарии принято писать на отдельной строке.
c = a + b   

print(c) # А вот так комментарии не принято писать.
'''

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

Пример №7. Комментарии в Python.

Многострочные комментарии синтаксисом Python не предусмотрены. Вместо них используются подряд идущие
однострочные комментарии. Однако многие программисты, как показано в примере, используют для создания многострочных комментариев строки в тройных
кавычках. В результате такого хака многострочные комментарии представляют собой любой текст, расположенный между комбинациями символов
»’ и »’ или же «»» и
«»». Такие много­строчные комментарии поглощают однострочные, могут содержать несколько строк, но при этом
не могут быть вложенными друг в друга.

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

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

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

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

Если вы еще не посетили официальную страницу руководства PEP8 по написанию кода на
Python, сделайте это сейчас хотя бы для ознакомления. Здесь же мы еще раз кратко пройдемся по основным
принципам форматирования python-кода, заполнив при этом некоторые пробелы. Итак.

• На каждой строке следует писать по одной инструкции, не вставляя в конце точку с запятой.
• После основной инструкции должно присутствовать двоеточие. При этом одинаковые блоки вложенных инструкций должны отделяться с левой стороны
  идентичными отступами. В идеале для этого нужно использовать по четыре пробела на каждый уровень вложенности.
• Строки кода по возможности должны полностью помещаться в видимой области экрана монитора. В идеале они не должны превышать длины в
  79 символов. Для переноса длинных инструкций на новую строку в зависимости от ситуации следует использовать
  круглые, квадратные или фигурные скобки.
• В большинстве случаев интерпретатор игнорирует подряд идущие пробелы и символы табуляции (отступы сюда не относятся!!!). Поэтому для визуального
  разделения некоторых лексем и повышения читабельности кода можно смело использовать пробелы (см. пример №8).
  Однако при этом желательно придерживаться устоявшихся стандартов и, например, не ставить подряд несколько пробелов, а также не использовать для
  таких целей символы табуляции.
• Комментарии в исходном коде следует писать на отдельной строке, а не вместе с инструкцией на одной строке. При этом принято отделять символ
  решетки от текста комментария пробелом, а предложения начинать с заглавной буквы и завершать точкой.

# Многие операторы рекомендуется отделять пробелами.
a = 3
a += 5

# Перед символами ,, :, ;, . пробел ставить не принято. 
c, d = 5, 3

# Как и в вызовах функций вокруг символа =,  
def my_func(s=5, b=0.5):
    # и в выражениях вокруг знаков умножения и деления. 
    return (s*d + s/d) * (s%d + 0.1)/5.05	

# Также не нужно ставить пробелы сразу после 
# открывающей скобки или перед закрывающей. 
dict = {'color': 'red'}

Пример №8. Примеры использования пробелов в коде Python.

Пугаться такого количества рекомендаций не стоит. Большинство из них в скором времени станут для вас естественным способом оформления кода. А
некоторые рекомендации вы и вовсе будете игнорировать, где-то умышленно, а где-то и рефлекторно. Я, например, не люблю ставить пробел в начале
комментариев, часто забываю завершать их точкой. Также я привык не отделять пробелами операторы присваивания, ставить их после запятых и т.д.
Но придерживаться рекомендаций по оформлению кода в Python все-таки стоит. Не нужно перенимать вредные привычки,
ведь потом от них будет очень трудно избавиться.

6. Какой символ используется в Python для обозначения комментариев?
Определите в коде строки комментариев и закомментируйте их.
Показать решение.

Присваиваем переменной значение.
a = 3

Увеличиваем значение на единицу.
b += 1

Выводим его на экран.
print(b)	

Присваиваем переменной значение.
a = 3

Увеличиваем значение на единицу.
b += 1

Выводим его на экран.
print(b)	

# Присваиваем переменной значение. 
a = 3

# Увеличиваем значение на единицу.
b += 1

# Выводим его на экран.
print(b)	

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

li=['red','green' , 'blue' ]; #Формируем список

#Циклом выводим значения списка на экран.
for val in li : print ( val )		

li=['red','green' , 'blue' ]; #Формируем список

#Циклом выводим значения списка на экран.
for val in li : print ( val )		

# Формируем список. 
li = ['red', 'green', 'blue']

# Циклом выводим значения списка на экран.
for val in li: 
    print(val)	
	
'''
Уберите лишние пробелы, точку с запятой после списка,
правильно оформите комментарии.
'''		

num = 500
s = ' рублей.'

print(num, s, sep='', end='nn')

# Знак = в программировании означает присвоить, а не равно! 

500 рублей.