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

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

Инструкции

Инструкции, которые может выполнять интерпретатор Python, называются операторами. Например, a = 1 — это оператор присваивания. Оператор if, оператор for, оператор while и т. д. — это другие типы операторов, которые мы обсудим позже.

Многострочные инструкции

В Python для окончания инструкции используют символ новой строки. Но можно разбить инструкцию на несколько строк символом продолжения строки (\). Например:

a = 1 + 2 + 3 + \
    4 + 5 + 6 + \
    7 + 8 + 9

Это явное продолжение строки. В Python продолжение строки выполняется внутри круглых ( ), квадратных [ ] и фигурных скобок { }. Например, так мы можем реализовать показанную выше многострочность:

a = (1 + 2 + 3 +
    4 + 5 + 6 +
    7 + 8 + 9)

Здесь круглые скобки ( ) неявно продолжают строку. То же самое с [ ] и { }. Например:

colors = ['красный',
          'голубой',
          'зеленый']

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

a = 1; b = 2; c = 3

Отступы

Большинство языков программирования, таких как C, C ++ и Java, используют фигурные скобки { } для определения блока кода. Однако Python использует отступы.

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

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

for i in range(1,11):
    print(i)
    if i == 5:
        break

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

Сравните:

if True:
    print('Привет')
    a = 5

if True: print('Привет'); a = 5

Оба варианта допустимы и сделают одно и то же, но первый вариант — читабельнее.

Неправильный отступ приведет к ошибке IndentationError.

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

"""Это тоже
пример прекрасного
многострочного комментария"""

Строки документации (docstrings) в Python

Docstring — это сокращение от documentation string (строка документации).

Строки документации в Python — это строковые литералы, которые появляются сразу после определения функции, метода, класса или модуля.

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

def double(num):
    """Функция, которая удваивает значение"""
    return 2*num

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

Строка документации связана с объектом как его атрибут __doc__.

Так что мы можем получить доступ к строкам документации функции с помощью следующих строк кода:

def double(num):
    """Функция, которая удваивает значение"""
    return 2*num
print(double.__doc__)

Вывод:

Функция, которая удваивает значение

Источник

Синтаксис языка программирования

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

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

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

Лексемы и литералы в Python

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

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

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

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

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

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

Код
Результат
pythonCodes

# Импортируем необходимые модули стандартной библиотеки.
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

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

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

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

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

Код
pythonCodes

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

# Стиль CapWords (используется для классов и констант 
# как внутри Python, так и в большинстве библиотек).
GoToStr = True

# Собственные константы я пишу заглавными буквами.
STR_LEN = 20

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

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

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

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

Отступы и точка с запятой в Python

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

Код
Результат
pythonCodes

# Имеем 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). Так это могут быть символы табуляции или несколько подряд идущих пробелов, но что-то одно в пределах
одного блока инструкций.

Код
Результат
pythonCodes

# Для отступов вложенных инструкций мы 
# использовали по одному символу табуляции 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 не приветствуется!

Код
Результат
pythonCodes

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

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

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

0.7115384615384616

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

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

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

Код
Результат
pythonCodes

# Обычные короткие инструкции.
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='\n\n')
print('Русские буквы в нижнем регистре: ', li, end='\n\n')
print('Словарь с цифровыми ключами: ', dict, end='\n\n')

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

Значение выражения: 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

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

Код
pythonCodes

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

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

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

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

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

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

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

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

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

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

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

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

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

Форматирование python-кода

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

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

Код
pythonCodes

# Многие операторы рекомендуется отделять пробелами.
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 все-таки стоит. Не нужно перенимать вредные привычки,
ведь потом от них будет очень трудно избавиться.

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

1. Что такое синтаксис языка программирования?
Показать решение.

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

2. Какие из представленных фрагментов кода являются литералами:
«a==5», d = 0.5, [0.5, ‘cat’],
{‘color’: ‘green’}, import math,
‘Синий иней’.
Показать решение.

Ответ.
«a==5» – литерал строки в двойных кавычках, [0.5, ‘cat’] – литерал списка,
{‘color’: ‘green’} – литерал словаря, ‘Синий иней’ – литерал строки в
одинарных кавычках.

3. Опишите правила составления имен (идентификаторов) в Python.
Показать решение.

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

4. Перечислите правильно составленные идентификаторы, сопровождая свой выбор пояснениями:
f, f2, d5,
3d, abc, ABC,
$h, h$2, _h___2,
h_2_, 2_h,
ruEn, d3.f3, d3_f3,
d3 f3, эй_Hey, свободный_дом2,
ухТы!!!, 3дом_слева, F15,
gggggggggg, d’25’, s_8.
Показать решение.

Ответ.
Правильно составленными являются идентификаторы (см. правила составления имен):
f, f2, d5,
abc, ABC, _h___2,
h_2_, ruEn, d3_f3,
эй_Hey, свободный_дом2,
F15, gggggggggg, s_8.

5. Составьте имя переменной в верблюжей и змеиной нотациях, используя фразу
show must go on. Как будет выглядеть имя, если использовать данную фразу для названия класса?
Показать решение.

Ответ.
Имя переменной в верблюжей нотации будет иметь вид showMustGoOn (обычно используется для переменных и
функций сторонних библиотек), при использовании змеиной нотации – show_must_go_on
(используется для переменных и функций внутри Python и ее стандартной библиотеки). Для имен классов обычно
используется нотация CupWords, поэтому имя будет иметь вид ShowMustGoOn.

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

Условие
pythonCodes

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

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

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

Условие
Решение
pythonCodes

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

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

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

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

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

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

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

Условие
pythonCodes

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

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

Условие
Решение
pythonCodes

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

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

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

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

8. Создайте скрипт, в котором переменным num и
s, присвойте значения 500 и ‘ рублей’.
Затем выведите значения переменных на экран при помощи функции print, использовав в качестве разделителя
пустую строку и завершив вывод двумя символами перевода строки. В конце скрипта напишите комментарий «Символ = в
программировании означает присвоить, а не равно!».
Показать решение.

Решение
Результат
pythonCodes

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

print(num, s, sep='', end='\n\n')

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

500 рублей.

Быстрый переход к другим страницам

Источник

# Глава 2. Синтаксические правила
> Код, который так же понятен, как обычный английский.
Одна из целей создания питона, озвученная автором языка Гвидо ван Россумом

Рассмотрим структуру программы и основные синтаксические правила. Также вы узнаете, для чего нужны и чем различаются оператор `pass` и объект-синглтон «многоточие».

## Структура программы
В Java, go, C++ и многих других языках точкой входа в приложение является метод `main()`. Такие языки объединяет нерушимое правило: нельзя просто написать код на уровне файла и запустить его. Питон — представитель скриптовых языков, и на него это правило не распространяется: с первой же строчки скрипта может начинаться бизнес-логика, не обернутая ни в какую функцию.

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

«`python
print(«Dummy script, does nothing»)
«`

Тогда после запуска скрипта мы увидим в консоли ожидаемый вывод:

«`shell
$ python example.py
Dummy script, does nothing
«`

В этом коротком примере вся программа сводится к вызову встроенной функции `print()` для вывода текста. В ней нет подключения модулей, объявления переменных, классов. Что ж, усложним код.

Пусть в консоль печатается текущее время:

«`python {.example_for_playground}
from datetime import datetime

def print_time():
now = datetime.now()
current_time = now.strftime(«%H:%M:%S»)
print(«Current Time:», current_time)

print_time()
«`
«`
Current Time: 13:19:20
«`

На первой строке из модуля `datetime` импортируется одноименный объект в глобальное пространство имен программы. Затем объявляется функция `print_time()`. Внутри нее у объекта `datetime` вызывается метод `now()` для получения текущего времени; оно преобразовывается в удобный формат и печатается в консоль. На последней строке объявленная функция `print_time()` вызывается.

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

## Синтаксические правила
С этих правил начинают свой путь все питонисты.

**Вложенные блоки кода** отделяются отступами, а не фигурными скобками. Мы будем придерживаться [рекомендации из PEP8:](https://peps.python.org/pep-0008/#indentation) 1 отступ = 4 пробела.
Вложенному блоку предшествует инструкция, заканчивающаяся двоеточием. Перед телом цикла — это условие цикла. Перед телом `if` — условие `if`. И так далее.

Пример условия:

«`python
if user_is_active:
get_next_command()
else:
close_session()
«`

Пример цикла:

«`python
for item in items:
process(item)
«`

Пример функции:

«`python
def is_long(s):
if len(s) > 79:
return «string is too long»
return «string has normal length»
«`

Конец строки — это конец инструкции. Точка с запятой в конце не ставится.

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

«`python
check_db_is_online()
start_transaction()
«`

Инициализируйте две переменные:{.task_text}
— `a`, равную 8, на одной строке.
— `b`, равную 10, на другой.

«`python {.task_source #python_chapter_0020_task_0010}
«`
Синтаксис: переменная = значение {.task_hint}
«`python {.task_answer}
a = 8
b = 10
«`

Исправьте синтаксические ошибки в коде. {.task_text}

В данном коде используется функция `range(a, b)`, позволяющая получить последовательность от целого числа `a` до целого числа `b` не включительно. {.task_text}

«`python {.task_source #python_chapter_0020_task_0020}
for i in range(1, 10); print(i);
«`
Нужно заменить точку с запятой в конце цикла на двоеточие. Удалить точку с запятой после `print()` и перенести вызов `print()` на новую строку с отступом. {.task_hint}
«`python {.task_answer}
for i in range(1, 10):
print(i)
«`

Если инструкция не влезает в строку (например, становится длиннее рекомендованных PEP8 79 символов), ее можно разбить на несколько строк с использованием круглых скобок.

Первая строка в этом примере занимает 92 символа:

«`python
while retries_count < max_retries and service_is_up and not cancelled and request_is_ready:
send_request()
«`

Приведем ее в соответствие с PEP8:

«`python
while (
retries_count < max_retries
and service_is_up
and not cancelled
and request_is_ready
):
send_request()
«`

Разбейте условие `if` на две строки или более. {.task_text}

«`python {.task_source #python_chapter_0020_task_0030}
MAX_SESSIONS = 5
MAX_QUEUE_LEN = 100

sessions_count = 9
queue_tasks = [«task1», «task2»] # Here we create list of strings
error_in_request = True

if sessions_count > MAX_SESSIONS or len(queue_tasks) > MAX_QUEUE_LEN or error_in_request:
print(«Error handling request»)
«`
Для разбиения условия на несколько строк возьмите его в круглые скобки. {.task_hint}
«`python {.task_answer}
MAX_SESSIONS = 5
MAX_QUEUE_LEN = 100

sessions_count = 9
queue_tasks = [«task1», «task2»] # Here we create list of strings
error_in_request = True

if (
sessions_count > MAX_SESSIONS
or len(queue_tasks) > MAX_QUEUE_LEN
or error_in_request
):
print(«Error handling request»)
«`

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

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

«`python
x = x_offset(); y = y_offset(); print(x, y)
«`

Сделайте этот код более читабельным. Одна строка — одна инструкция. {.task_text}

«`python {.task_source #python_chapter_0020_task_0040}
x = 5; y = 8; print(x, y)
«`
Должно получиться 3 строки: 2 для инициализации переменных и 1 на вызов функции. {.task_hint}
«`python {.task_answer}
x = 5
y = 8
print(x, y)
«`

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

«`python
while is_active: send_request()
«`

Перепишите этот код, чтобы вложенный блок `while` шел на отдельной строке. {.task_text}

В коде заводится функция `send_request()`, которая затем вызывается в цикле `while`. {.task_text}

«`python {.task_source #python_chapter_0020_task_0050}
def send_request():
# some business logic
return False

is_active = True

while is_active: is_active = send_request()
«`
Тело цикла должно идти на отдельной строке с отступом. {.task_hint}
«`python {.task_answer}
def send_request():
# some business logic
return False

is_active = True

while is_active:
is_active = send_request()
«`

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

«`python
try:
send_request(data)
except Exception:
# Do nothing
«`

Но пустой вложенный блок — это синтаксическая ошибка:

«`
SyntaxError: unexpected EOF while parsing
«`

Чтобы ее избежать, был придуман оператор `pass`. Это [ассемблеровский NOP](https://en.wikipedia.org/wiki/NOP_(code)) в мире питона. Так сказать оператор «отсутствие оператора».

Теперь синтаксической ошибки не будет:

«`python
try:
send_request(data)
except Exception:
pass
«`

Добавьте `pass` в цикл, чтобы устранить ошибку интерпретатора. {.task_text}

«`python {.task_source #python_chapter_0020_task_0060}
n = 101

while n < 100:
«`
Перед оператором `pass` не забудьте сделать отступ. {.task_hint}
«`python {.task_answer}
n = 101

while n < 100:
pass
«`

## Многоточие
В питоне существует объект-синглтон «многоточие», привязанный к константе с именем `Ellipsis` и литералу `…`:

«`python {.example_for_playground}
print(Ellipsis)
print(…)
«`
«`
Ellipsis
Ellipsis
«`

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

«`python
def handle_request(req):
…
«`

При этом многоточие не является семантической заменой `pass`: `pass` принято проставлять в качестве индикатора намеренного отсутствия кода, а многоточие — как напоминание TBD (to be defined) при активной разработке. Например, если соответствующий блок кода планируется добавить в следующем реквесте.

## Комментарии
Однострочные комментарии начинаются с символа `#`:

«`python
# TODO: refactor coords calculation
x = x_offset() # get x offset
«`

Многострочные комментарии обрамляются тремя подряд идущими кавычками: двойными `»` либо одинарными `’`.

«`python
«»»
TODO:
refactor before release!
«»»
«`

«`python
»’
TODO:
refactor before release!
»’
«`

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

Если многострочный комментарий следует сразу за объявлением модуля, функции, класса или метода, то он называется **docstring.** Большинство современных IDE умеют делать подсказки на основе docstring.

Пример docstring для функции:

«`python
def get_coords():
«»»Here we calculate x, y and transform
these coordinates to lat, lon»»»
pass
«`

## Резюмируем
— Блоки кода определяются двоеточием и отступами.
— Для обозначения отсутствия операции во вложенном блоке предусмотрен оператор `pass`.
— Объект-синглтон `Ellipsis` и соответствующий ему литерал `…` имеют несколько вариантов использования. Самый частый — проставление многоточия `…` вместо `pass` для маркировки мест, где кода еще нет, но планируется его дописать.
— Однострочные комментарии начинаются с символа `#`, многострочные — заключаются в тройные кавычки.

Источник

Здравствуйте, ученики! Давайте разберем структуру программы на Python и ответим на вопросы.

**Структура программы на Python:**

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

* **Заголовки:** Импорт необходимых модулей (например, `import math`).
* **Определения функций:** Блоки кода, которые выполняют определенные задачи (например, `def my_function():`).
* **Основной блок кода:** Инструкции, которые выполняются при запуске программы.

**Ответы на вопросы:**

1. **Как отдельные инструкции в программе отделяются друг от друга?**
В Python отдельные инструкции обычно отделяются друг от друга символом новой строки. Каждая строка, как правило, содержит одну инструкцию. Однако, если инструкция слишком длинная, её можно разбить на несколько строк, используя обратный слеш `\` в конце каждой строки, кроме последней. Другой способ — заключить инструкцию в круглые, квадратные или фигурные скобки. Например:

«`python
x = 1 + 2 + 3 + \
4 + 5

y = (1 + 2 +
3 + 4)
«`

2. **Для чего в тексте программы используются отступы?**
В Python отступы (обычно 4 пробела или символ табуляции) имеют критическое значение, так как они определяют структуру блоков кода, таких как тела функций, циклов, условных операторов и т.д. Отступы показывают, какие инструкции принадлежат к определенному блоку кода. Неправильные отступы могут привести к ошибкам в программе.

«`python
def my_function():
# Этот код принадлежит функции my_function
print(«Hello»)
if True:
# Этот код принадлежит условному оператору if
print(«World»)
«`

3. **Каким образом в тексте программы оформляются комментарии?**
В Python комментарии оформляются двумя способами:
* Однострочные комментарии начинаются с символа `#`. Всё, что следует за `#` до конца строки, игнорируется интерпретатором.
* Многострочные комментарии заключаются в тройные кавычки (`»’` или `»»»`). Они используются для документирования функций, классов и больших фрагментов кода.

«`python
# Это однострочный комментарий
»’
Это многострочный комментарий.
Он может занимать несколько строк.
»’
def my_function():
«»»
Эта функция делает что-то полезное.
«»»
pass
«`

4. **Приведите примеры присваивания переменным значений целого, вещественного, строкового и логического типов.**
«`python
# Целый тип (integer)
age = 25

# Вещественный тип (float)
price = 99.99

# Строковый тип (string)
name = «Alice»

# Логический тип (boolean)
is_student = True
«`

**Развёрнутый ответ для школьника:**

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

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

Надеюсь, теперь тебе понятнее, как устроена программа на Python!

Источник

Что такое инструкция в Python: Путеводитель по основам программирования 🐍

✋🏻Комментарии✌️🏼

Давайте разберемся, что же такое инструкция в Python! Представьте себе повара, готовящего сложное блюдо. У него есть рецепт — пошаговая инструкция, указывающая, что и когда делать. Код на Python — это тот же рецепт, только для компьютера. Каждая строчка кода — отдельная команда, инструкция, которую компьютер должен выполнить. 👨‍🍳

Python — это интерпретируемый язык. Это значит, что специальная программа, интерпретатор, читает наш код построчно и выполняет каждую инструкцию последовательно, словно шеф-повар следует рецепту шаг за шагом. Без инструкций программа не сможет работать — это как рецепт без указания ингредиентов и процесса приготовления. Именно инструкции задают логику работы программы. Каждая инструкция — это фундаментальный блок, из которого строится вся программа. Без них нет программы!

Нажмите на ссылку, чтобы открыть нужный раздел:

💎 Что такое инструкция Python: Разложим по полочкам

💎 В чем разница между выражением и инструкцией: Язык Python — это не только действия, но и значения

💎 Что такое инструкция `if` в Python: Управление потоком выполнения

💎 Для чего используется инструкция `continue` в Python: Пропуск итераций цикла

💎 Python

💎 Что означают скобки в Python: Работа со списками и другими структурами данных

💎 Что такое отступ в Python: Важность форматирования

💎 Выводы и заключение

💎 FAQ

💎 Q: Что произойдет, если я не буду использовать отступы в Python?

💎 Q: Можно ли использовать табуляцию вместо пробелов для отступов?

💎 Q: В чем разница между `if` и `elif`?

💎 Q: Что делает инструкция `return`?

💎 Q: Можно ли использовать `continue` в блоке `else`?

🤞🏼 Комментировать

Что такое инструкция Python: Разложим по полочкам

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

Ключевые моменты:

Инструкции — это базовые элементы кода.
Интерпретатор выполняет инструкции последовательно.
Без инструкций нет программы.
Разнообразие инструкций позволяет создавать сложные программы.

В чем разница между выражением и инструкцией: Язык Python — это не только действия, но и значения

Давайте разберем важную разницу между инструкцией и выражением. Инструкция — это команда, которая *делает* что-то. Например, `x = 5` — это инструкция, которая присваивает переменной `x` значение 5. А выражение — это фрагмент кода, который *вычисляет* значение. Например, `2 + 2` — это выражение, которое вычисляет значение 4. Выражения всегда имеют значение, инструкции — нет. Инструкции управляют потоком выполнения программы, а выражения — это данные, с которыми работают инструкции. Инструкции — это глаголы, а выражения — это существительные.

Основные отличия:

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

Что такое инструкция `if` в Python: Управление потоком выполнения

Инструкция `if` — это мощный инструмент для управления потоком выполнения программы. Она позволяет выполнять разные участки кода в зависимости от условий. Представьте себе дорожное разветвление: `if` проверяет условие, и в зависимости от результата выбирает, по какой дороге ехать дальше 🚗. Если условие истинно, выполняется блок кода после `if`. Если ложно, то выполняется блок кода после `else` (если он есть). `elif` позволяет добавить еще несколько условий для проверки. Это как несколько дорожных развязок, каждая с собственным условием.

Пример:

python

x = 10

if x > 5:

print(«x больше 5»)

elif x == 5:

print(«x равно 5»)

else:

print(«x меньше 5»)

Для чего используется инструкция `continue` в Python: Пропуск итераций цикла

Инструкция `continue` используется внутри циклов (например, `for` или `while`). Она позволяет пропустить оставшуюся часть текущей итерации цикла и перейти к следующей. Представьте, что вы перебираете список, и на каком-то элементе хотите пропустить дальнейшую обработку и перейти к следующему. `continue` — это ваш инструмент для этого! ⏩

Пример:

Python

for i in range(1, 6):

if i == 3:

continue # Пропускаем итерацию, когда i равно 3

print(i)

Что означают скобки в Python: Работа со списками и другими структурами данных

В Python скобки используются для обозначения различных структур данных. Квадратные скобки `[]` используются для создания и доступа к элементам списков. Список — это упорядоченная коллекция элементов. Python отображает элементы списка в квадратных скобках, отделяя их запятыми, для ясного представления структуры данных. Это как аккуратный список покупок 📝.

Пример:

python

my_list = [1, 2, 3, 4, 5]

print(my_list) # Вывод: [1, 2, 3, 4, 5]

Что такое отступ в Python: Важность форматирования

Отступы в Python — это не просто вопрос стиля, а неотъемлемая часть синтаксиса. В отличие от многих других языков программирования, где блоки кода обозначаются фигурными скобками `{}`, в Python используются отступы для определения блоков кода. Это делает код более читаемым и понятным, но требует строгого соблюдения правил форматирования. Отступы — это визуальное разделение блоков кода, которые связаны логически. Неправильные отступы приведут к ошибке. Это как правильное построение дома из кирпичей 🧱 — каждый блок на своем месте.

Важно:

Отступы определяют блоки кода.
Обычно используется 4 пробела для одного отступа.
Неправильные отступы вызывают ошибки.

Выводы и заключение

В этой статье мы разобрали основные понятия инструкций в Python. Инструкции — это фундаментальные блоки любого кода Python. Они определяют действия, которые выполняет компьютер. Понимание разницы между инструкциями и выражениями, а также умелое использование инструкций `if` и `continue` — залог написания эффективного и читаемого кода. Не забывайте о важности отступов! Они — неотъемлемая часть синтаксиса Python. Мастерство программирования приходит с практикой, поэтому не бойтесь экспериментировать и писать свой код! 🎉

FAQ

Q: Что произойдет, если я не буду использовать отступы в Python?

A: Программа не скомпилируется и выдаст ошибку синтаксиса.

Q: Можно ли использовать табуляцию вместо пробелов для отступов?

A: Технически можно, но это не рекомендуется. Лучше использовать 4 пробела для обеспечения согласованности.

Q: В чем разница между `if` и `elif`?

A: `if` проверяет первое условие. `elif` проверяет последующие условия только если предыдущие были ложными.

Q: Что делает инструкция `return`?

A: Инструкция `return` завершает выполнение функции и возвращает значение.

Q: Можно ли использовать `continue` в блоке `else`?

A: Нет, `continue` можно использовать только внутри циклов.

Вопросы и ответы

👉 Что такое инструкция в Python 👈

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

👉 Какой язык программирования учить в 2024 году 👈

C, C++, C# — классика в программировании:

Высокая производительность C, возможности объектно-ориентированного программирования C++ и акцент на разработке под платформу Microsoft в C# подтверждают их востребованность и в 2024 году.

👉 Как должен начинаться код на Python 👈

Изучение нового языка программирования традиционно начинается с ‘Hello, World!’.

👉 Где определены базовые правила написания Python 👈

PEP8 содержит перечень принципов написания красивого и лаконичного программного кода на языке Python.

👉 Что такое синтаксис в Python 👈

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

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

Код на Python — это набор инструкций, которые, как правило, отделяются друг от друга переводом строки.

👉 Что входит в основу программирования 👈

Программирование основывается на использовании языков программирования и средств программирования. В основном языки программирования основаны на текстовом представлении программ, но иногда программировать можно, используя, например, визуальное программирование или «zero-code» программирование.

⚠️ Какие есть моментальные лотереи

⚠️ В каких лотереях больше всего выигрывают

⚠️ Что за лотерея Белбет

⚠️ Какие есть белорусские лотереи

Источник