Оператор -- это один из способов указания действий при выполнении программы
В языке Python определены следующие операторы: оператор присваивания =
, оператор выбора if
, операторы цикла while
и for
, break
, continue
, оператор-заполнитель pass
, оператор удаления переменной del
, оператор определения функции def
, операторы выхода из функции return
, yield
, и yield from
, операторы объявления global
иnonlocal
, оператор импортирования модуля import
, оператор определения класса class
, операторы для обработки исключений assert
, raise
, try
, with
.
Операторы в Python делятся на несоставные и составные операторы. Составной оператор — это оператор, в который вложены другие операторы и выражения.
Несоставные операторы обычно располагают по одному в строке кода. Конец строки автоматически завершает несоставной оператор/выражение, находящийся в этой строке. Символ точка с запятой ;
в конце несоставного оператора/выражения НЕ обязателен.
Несколько несоставных операторов и/или выражений можно помещать в одну строку кода, разделяя их символом точка с запятой ;
a = 1; print(a); b = [1]
1
Для читабельности кода рекомендовано размещать по одному несоставному оператору в строке
Код, содержащий круглые (), квадратные [] или фигурные {} скобки, может занимать несколько строк. Многострочный оператор/выражение со скобками не закончится до тех пор, пока не достигнет закрывающей скобки из пары. Отступы в строках продолжения роли не играют, хотя строки рекомендовано выравнивать ради читабельности
a = [(1,
2),
{3,
4}]; a
[(1, 2), {3, 4}]
Примеры из PEP 8 (руководство по стандартам стиля кодирования на Python https://www.python.org/dev/peps/pep-0008/) корректного выравнивания многострочного кода при определении и вызове функции:
foo = long_function_name(var_one, var_two,
var_three, var_four)
def long_function_name(
var_one, var_two, var_three,
var_four):
print(var_one)
foo = long_function_name(
var_one, var_two,
var_three, var_four)
При написании многострочного кода следует использовать круглые скобки ()
b = (a
+ [5]
+ 2*a); b
[(1, 2), {3, 4}, 5, (1, 2), {3, 4}, (1, 2), {3, 4}]
Альтернативным синтаксисом для написания многострочного кода является использование символа обратной косой черты \
в конце каждой строки кода
b = a + [5] +\
2*a; b
[(1, 2), {3, 4}, 5, (1, 2), {3, 4}, (1, 2), {3, 4}]
На текущий момент такой синтаксис использовать не рекомендуется, так как он подвержен ошибкам. Символ обратной косой черты \
можно не заметить, его можно забыть написать
Составной оператор — это оператор, в который вложены другие операторы и выражения.
Составной оператор имеет следующий вид:
Строка заголовка:
Тело оператора в виде вложенного блока операторов и выражений
if 'KM2':
print('KM2')
KM2
Строка заголовка составного оператора должна заканчиваться символом двоеточие :
. Отсутствие символа двоеточие :
в конце строки заголовка составного оператора является наиболее распространенной ошибкой в Python.
Тело составного оператора записывается с отступом относительно строки заголовка оператора. Отступ — это пробельные символы (пустое пространство) слева от кода. Операторы и выражения вложенного блока должны быть смещены на одинаковое расстояние вправо
if 'KM2':
print('KM2')
print('Body ends here')
KM2 Body ends here
Фигурные скобки {}
вокруг вложенного блока НЕ нужны
Для отступа можно использовать либо пробелы, либо табуляции. В отдельном блоке используйте либо пробелы, либо табуляции, но не то и другое одновременно. Общепринято использовать отступ в 4 пробела или 1 табуляцию.
Делайте бОльший отступ вправо для следующего вложенного блока и меньший отступ для закрытия предыдущего блока. На основании отступов будет автоматически определяться начало и конец вложенного блока
if 'KM2':
print('if-operator outside')
if False:
print('if-operator inside')
print('Body ends here')
if-operator outside Body ends here
Выравнивание кода в соответствии с его структурой с применением отступов является частью синтаксиса языка Python и является особенностью языка Python. Совокупный эффект заключается в том, что код на Python становится более согласованным и читабельным.
Старайтесь выравнивать код в ЛЮБОМ блочно-структурированном языке программирования для отражения логической структуры кода в целях читабельности кода
Пробельные символы внутри операторов и выражений почти всегда игнорируются. Исключением являются ситуации, когда пробелы находятся внутри строковых литералов и когда пробелы применяются для отступа в составных операторах
a=1+2; a = 1 + 2; '1+2', '1 + 2'
('1+2', '1 + 2')
Если тело составного оператора состоит только из выражений или несоставных операторов, то тело составного оператора может быть записано в строке заголовка оператора после символа двоеточие
if True: print(True + 2)
3
PEP 8 — руководство по стандартам стиля кодирования на Python, см. https://www.python.org/dev/peps/pep-0008/ (2001, изменения в 2013)
Перевод PEP 8, см. например, https://pythonworld.ru/osnovy/pep-8-rukovodstvo-po-napisaniyu-koda-na-python.html#section-2
Оператор pass
не выполняет действий и называется оператором-заполнителем. Он часто применяется для создания пустого вложенного блока составного оператора
if True: pass
Оператор pass
может использоваться для обозначения места в коде, подлежащего заполнению в будущем
def f():
pass
В Python З.Х в любом месте кода, где может находиться оператор/выражение/объект, разрешено указывать символ многоточие ...
. Многоточие синтаксически заменяет оператор-заполнитель pass
и объект-заполнитель None
def f():
x = ...
...
return x
Явное присваивание в Python выполняется с помощью оператора присваивания =
. Слева от оператора присваивания указываются переменные (имена), справа — выражения. В процессе выполнения явного присваивания вычисляются значения выражений, и полученные объекты связываются с указанными переменными.
После выполнения оператора присваивания переменная хранит ссылку на объект: переменная (имя) -> объект (значение выражения)
В Python существует пять синтаксических форм явных присваиваний:
Базовое присваивание связывает одну переменную, стоящую слева от оператора присваивания =
, с одним объектом, представляющим результат вычисления выражения, стоящего справа от оператора присваивания
variable = 'object'
variable
'object'
Оператор присваивания последовательностей имеет вид:
список или кортеж переменных (имен) = последовательность
и связывает переменные, указанные в его левой части, с элементами последовательности, которая указана в правой части.
Оператор присваивания последовательностей является позиционным оператором. У последовательностей, стоящих в левой и правой частях, связываются элементы, стоящие на одинаковых позициях. В результате для каждого i
-го элемента последовательности определена ссылка на объект:
переменная(имя)i -> объект(значение выражения)i
.
Следует отметить, что количество элементов последовательностей левой и правой частей должно совпадать.
a, b = 1, 2
a, b
(1, 2)
Обратите внимание, что присваивание переменных осуществляется последовательно слева направо. Это приводит к влиянию переменных, стоящих левее текущего присваивания в последовательности, на результаты присваиваний для переменных, стоящих правее текущего присваивания
x = list(range(3))
i = 0
x[i], i, x[i] = 'first', 2, 'last'
x
['first', 1, 'last']
Распространенный кодовый трюк в Python для обмена значениями двух переменных без использования дополнительной переменной на основе присваивания последовательностей
print(a, b)
a, b = b, a
a, b
1 2
(2, 1)
Слева от оператора присваивания может стоять кортеж или список
var1, var2, ..., varN = obj1, obj2, ..., objN
[var1, var2, ..., varN] = obj1, obj2, ..., objN
В правой части оператора присваивания может стоять любой итерируемый объект
a, b = "rt"; [c,d] = range(2)
a, b, c, d
('r', 't', 0, 1)
Слева от оператора присваивания можно использовать одиночную переменную, отмеченную звездочкой, *var
для указания расширенного присваивания последовательностей. В этом случае переменной var
, отмеченной звездочкой, присваивается список, в котором собраны все элементы последовательности, не присвоенные остальным переменным
a, *b = 'object'
a, b
('o', ['b', 'j', 'e', 'c', 't'])
Если нет объектов, которые можно было бы сопоставить с переменной, отмеченной звездочкой, тогда ей присваивается пустой список
a, *b = "a"
a, b
('a', [])
Кодовый трюк в Python на основе расширенного присваивания последовательностей для получения первого и остальных объектов последовательности или начальных и последнего объектов последовательности
first, *rest = 'object'
*most, last = 'object'
first, rest, most, last
('o', ['b', 'j', 'e', 'c', 't'], ['o', 'b', 'j', 'e', 'c'], 't')
При групповом присваивании var1 = var2 = ... = varN = obj
переменные var1
, var2
, ..., varN
ссылаются на один и тот же объект obj
a = b = [1]
id(a), id(b)
(2157491502656, 2157491502656)
При присваивании последовательностей переменные ссылаются на разные объекты
a, b = [1], [1]
id(a), id(b)
(2157491496768, 2157491512640)
Оператор дополненного присваивания имеет вид:
a operation= b
и указывает следующую последовательность действий: cначала вычисляется выражение a operation b
, затем полученный объект(значение выражения) связывается с переменной a
, т.е. а -> a operation b
. Всего существует 12 операторов дополненного присваивания
a = b = 1
a += 1; b /= 3
a, b
(2, 0.3333333333333333)
При неявном присваивании переменная создается автоматически не при выполнении оператора присваивания =
, а в процессе выполнения других действий.
Виды неявных присваиваний:
for
присваивание переменной цикла значения из последовательности (оператор for
, Тема 3)def
, Тема 4)import
, Тема 7)class
, Тема 8)В Python важным является место в программе, где переменной присваивается значение.
Местоположение присваивания переменной ее значения, например, x = value
, ассоциирует или связывает переменную x
с пространством имен, в котором переменная будет находиться.
Пространство имен объекта содержит ВСЕ атрибуты объекта.
При присваивании вида obj.x = value
создается или изменяется переменная x
в пространстве имен объекта obj
.
Переменная, которой выполнено присваивание внутри функции (внутри оператора def
), ассоциируется или связывается с пространством имен данной функции.
Переменная, которой выполнено присваивание внутри класса (внутри оператора class
), ассоциируется или связывается с пространством имен данного класса.
Переменная, которой выполнено присваивание в модуле (не внутри функции или класса), ассоциируется с пространством имен модуля.
Даже если при присваивании переменные задаются одинаковыми именами, присваивание значений в разных местах программы (внутри модуля, внутри функции, внутри класса, внутри метода класса) делает все переменные уникальными
x = 1 # пространство имен модуля
def f():
x = 10 # пространство имен функции
print(x)
return None
f()
x
10
1
Вызов встроенной функции dir()
без аргументов позволяет просмотреть пространство имен, соответствующее местоположению вызова функции dir()
x = 1 # пространство имен модуля
print(dir())
def f():
x = 10 # пространство имен функции
print(dir())
return None
f()
['In', 'Out', '_', '_13', '_14', '_15', '_16', '_17', '_18', '_19', '_2', '_20', '_21', '_22', '_23', '_24', '_3', '_4', '_8', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '_dh', '_i', '_i1', '_i10', '_i11', '_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20', '_i21', '_i22', '_i23', '_i24', '_i25', '_i3', '_i4', '_i5', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'a', 'b', 'c', 'd', 'exit', 'f', 'first', 'get_ipython', 'i', 'last', 'most', 'quit', 'rest', 'variable', 'x'] ['x']
Оператор del
удаляет переменную, созданную ранее явным или неявным присваиванием. Удаление переменной означает как удаление имени переменной, так и удаление ссылки на объект, с которым переменная была связана.
a = 1; del a; a
--------------------------------------------------------------------------- NameError Traceback (most recent call last) ~\AppData\Local\Temp/ipykernel_27208/764565214.py in <module> ----> 1 a = 1; del a; a NameError: name 'a' is not defined
list1 = list(range(10))
del list1[0], list1[:4]
list1
[5, 6, 7, 8, 9]
При удалении переменной объект, на который ссылается переменная, не удаляется. Объект удаляется только в том случае, если при удалении переменной удаляется последняя ссылка на объект. Это приводит к автоматической очистке области памяти, где располагается этот объект, так как ни одна переменная в коде на него больше не ссылается.
Оператор if
используется для выбора варианта кода на основе результатов проверки условий.
Синтаксический шаблон составного оператора if
:
if
условие 1:
Вложенный блок 1
elif
условие 2: $\color{green}{\text{# (необязательная конструкция; может быть несколько)}}$
Вложенный блок 2
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 3
Конструкции elif
и else
являются частью оператора if
. Конструкции elif
и else
имеют собственные строками заголовков, а также собственные вложенные блоки кода.
test = 5
if test<5:
print("Less than 5")
elif test==5:
print("Equals 5")
else:
print("More than 5")
Equals 5
Строки заголовков оператора if
и конструкций elif
и else
связываются друг с другом выравниванием с одинаковыми отступами.
if-else
¶test = 40
answer = "Less than 5" if test<5 else "More or equal than 5"
answer
'More or equal than 5'
answer = 100 + (test if test<10 else 0)
answer
100
Для построения условных выражений можно использовать булевые операции and
, or
, not
1<3 and 3<5, 1<3<5, True or False, not 1<3
(True, True, True, False)
При выполнении операции and
вычисляются слева направо булевые значения операндов и возвращается первый ложный объект, если он найден, или последний операнд в противном случае. Выполнение операции останавливается на первом найденном ложном объекте. Это называют укороченной оценкой, так как вычисления для оставшегося выражения прекращается, как только результат становится известным.
[] and {}, bool([]), bool({})
([], False, False)
1 and 3, bool(1), bool(3)
(3, True, True)
При выполнении операции or
вычисляются слева направо булевые значения операндов и возвращается первый истинный объект, если он найден, или последний операнд в противном случае. Выполнение операции останавливается на первом найденном истинном объекте. Это называют укороченной оценкой.
[] or {}, bool([]), bool({})
({}, False, False)
1 or 3, bool(1), bool(3)
(1, True, True)
Оператор сопоставлений match
появился в версии Python 3.10. Оператор match
используется для выбора варианта кода на основе сопоставления объекта с шаблонами.
match
obj:
case pattern 1:
Вложенный блок 1
...
case pattern N:
Вложенный блок N
case _:
Вложенный блок N+1
Объект obj
последовательно сравнивается с шаблонами pattern 1
, pattern 2
до pattern N
. При соответствии объекта obj
шаблону pattern i
выполняется соответствующий Вложенный блок i и действие оператора match
завершается. Шаблону _
соответствует ЛЮБОЙ объект.
Ознакомьтесь с результатами выполнения следующих примеров в версии Python 3.10 и выше
language = 'english'
match language:
case 'russian':
print('Привет')
case 'american english' | 'british english' | 'english': # альтернативные шаблоны
print('Hello')
case 'german':
print('Hallo')
case _:
print('Undefined')
File "C:\Users\Olga\AppData\Local\Temp/ipykernel_27208/1899217848.py", line 2 match language: ^ SyntaxError: invalid syntax
match language:
case 'russian':
print('Привет')
case name:
print(f'Hello in {name}')
В случае, если значение language
не совпадает с 'russian'
, тогда происходит неявное присваивание name=language
и выполняется соответствующий вложенный блок print(f'Hello in {name}')
.
location = (1, 3, 2, "a", "b", "c")
match location:
case x, :
print(f"1D location found: ({x})")
case x, y:
print(f"2D location found: ({x}, {y})")
case x, y, z, *names:
print((f"3D location found: ({x}, {y}, {z})"))
print(f"Also, there was some extra data: {names}")
data = [2,3]
match data:
case [_]:
...
case [_,_]:
...
В Python определены два оператора цикла: for
и while
Цикл на основе оператора for
является простым и эффективным способом прохода по элементам последовательности (итерируемого объекта) и выполнения блока кода для каждого элемента по очереди.
Цикл на основе оператора while
представляет собой наиболее универсальный инструмент для организации циклов; он не ограничивается проходом по последовательности, но в целом требует написания большего объема кода и выполняется медленнее, чем цикл for
В Python существуют также неявные концепции организации циклов:
in
проверки принадлежностиmap
, filter
, reduce
Включения выполняются со скоростью кода на языке С внутри интерпретатора, которая гораздо выше, чем скорость выполнения байт-кода циклов for
и while
внутри PVM
while
¶Синтаксический шаблон составного оператора while
:
while
условие:
Вложенный блок 1
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 2
while
условие:
Вложенный блок 1
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 2
Вложенный блок 1 может содержать операторы break
и continue
. Оператор break
завершает выполнение всей структуры повторения и осуществляет переход за пределы заключающего оператора цикла. Оператор continue
прерывает выполнение текущей итерации цикла и осуществляет переход на выполнение следующей итерации этого цикла. Операторы break
и continue
используются только в циклах.
while
условие:
Вложенный блок 1
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 2
Вложенный блок 2 выполняется один раз и только в том случае, если выход из цикла произошел нормально, то есть Вложенный блок 1 НЕ закончился выполнением оператора break
Совместное использование while
и break
пропускает Вложенный блок 2 конструкции else
, что предлагает структурированный способ обработки ситуации с неудавшимся поиском в цикле
i = range(10)
control = 12
while i:
first, *rest = i
if first==control:
print(control, "is found")
break
i = rest
else:
print(control, "is not found")
12 is not found
Конструкция else
цикла while
является особенностью Python и не поддерживается в других языках программирования
for
¶Синтаксический шаблон составного оператора for
:
for
element in
sequence:
Вложенный блок 1
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 2
for
element in
sequence:
Вложенный блок 1
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 2
Переменной цикла element
последовательно неявно присваиваются объекты из последовательности sequence
слева направо, пока не будет достигнут конец последовательности
for
element in
sequence:
Вложенный блок 1
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 2
Вложенный блок 1 может содержать операторы break
и continue
. Оператор break
завершает выполнение всей структуры повторения и осуществляет переход за пределы заключающего оператора цикла. Оператор continue
прерывает выполнение текущей итерации цикла и осуществляет переход на выполнение следующей итерации этого цикла. Операторы break
и continue
используются только в циклах.
for
element in
sequence:
Вложенный блок 1
else
: $\color{green}{\text{# (необязательная конструкция)}}$
Вложенный блок 2
Вложенный блок 2 выполняется один раз и только в том случае, если выход из цикла произошел нормально, то есть Вложенный блок 1 НЕ закончился выполнением оператора break
Совместное использование for
и break
пропускает Вложенный блок 2 конструкции else
, что предлагает структурированный способ обработки ситуации с неудавшимся поиском в цикле
control = 1
for i in range(10):
if i==control:
print(control, "is found")
break
else:
print(control, "is not found")
1 is found
Конструкция else
цикла for
является особенностью Python и не поддерживается в других языках программирования
Проход по КЛЮЧАМ словаря с помощью цикла for
можно осуществить двумя способами, когда последовательностью для прохода в цикле является словарь либо результат вызова словарного метода keys
dict1 = dict(zip('abcdefg', range(7)))
for i in dict1:
print(i,end=' ')
for i in dict1.keys():
print(i,end=' ')
a b c d e f g a b c d e f g
Для прохода по ЗНАЧЕНИЯМ словаря с помощью цикла for
необходимо в качестве последовательности для прохода в цикле использовать результат вызова словарного метода values
print(dict1)
for i in dict1.values():
print(i,end=' ')
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6} 0 1 2 3 4 5 6
Для одновременного прохода по КЛЮЧАМ и ЗНАЧЕНИЯМ словаря с помощью цикла for
необходимо в качестве последовательности для прохода в цикле использовать результат вызова словарного метода items
for (key, elem) in dict1.items():
print(key, '=>', elem, end=', ')
a => 0, b => 1, c => 2, d => 3, e => 4, f => 5, g => 6,
Python предоставляет возможность прохода по строкам файла в цикле for
для файлового объекта, не вызывая метод построкового чтения readline
file1 = open("tmp.txt",'r')
for x in file1:
print(x, end='')
the first line the second line the last line100 200 300
Запомните, что проход в цикле по файловому объекту можно сделать только один раз.
Совет: всякий раз, когда это возможно, применяйте цикл for
вместо цикла while
Замечание: не используйте оператор присваивания =
в заголовке циклов while
Совет: не используйте вызовы range
в циклах for
кроме крайних случаев
print
в Python З.Х является встроенной функцией, в более ранних версиях print
был оператором.
Функция print
обычно вызывается в отдельной строке, так как она возвращает None
.
print({1})
1, print({2})
{1} {2}
(1, None)
В общем случае функции, которые возвращают None
, рассматриваются как разновидности операторов.
print
¶print(obj1, obj2, ...[, sep=' '] [, end='\n'][, file=sys.stdout][, flush=False])
Функция print
выводит в поток данных file
строковые представления одного или большего числа объектов obj1
, obj2
, ..., которые при выводе разделяются строкой sep
. За строковыми представлениями объектов obj1
, obj2
, ... следует строка end
. Буферизированный вывод сбрасывается или нет согласно значению аргумента flush
.
print(1, [1], {1: 1}, sep="\t", end=" end")
1 [1] {1: 1} end
print(obj1, obj2, ...[, sep=' '] [, end='\n'][, file=sys.stdout][, flush=False])
По умолчанию функция print
записывает произвольные объекты в стандартный поток вывода sys.stdout
, автоматически добавляя к объектам некоторое форматирование, разделяя объекты символом пробела и добавляя в конце строки вывода управляющий символ перехода на новую строку. При вызове функции print
преобразовывать объекты в строки не требуется в отличие от методов записи файловых объектов write
и writelines
. При вызове функции print
без аргументов в поток стандартного вывода записывается символ новой строки \n
.
print(1, {1}, {1:1})
print()
1 {1} {1: 1}
print(obj1, obj2, ...[, sep=' '] [, end='\n'][, file=sys.stdout][, flush=False])
В Python З.Х указание аргумента file
при вызове функции print
отправляет строковые представления объектов методу write
файлового объекта, указанного в качестве значения аргумента file
.
file = open("tmp.txt",'a')
print(1, [1], file=file)
Последующие вызовы функции print
продолжают выводить объекты в стандартный поток вывода
print("The lecture is finished")
The lecture is finished