Python как изменить знак числа

Числа¶

Числа в Python 3 — целые, вещественные, комплексные. Работа с числами и операции над ними.

Целые числа (int)¶

Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:

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

>>> 255 + 34
289
>>> 5 * 2
10
>>> 20 / 3
6.666666666666667
>>> 20 // 3
6
>>> 20 % 3
2
>>> 3 ** 4
81
>>> pow(3, 4)
81
>>> pow(3, 4, 27)
0
>>> 3 ** 150
369988485035126972924700782451696644186473100389722973815184405301748249

Битовые операции¶

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

Дополнительные методы¶

int.bit_length()

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

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

int.to_bytes(length, byteorder, *, signed=False)

возвращает строку байтов, представляющих это число.

>>> (1024).to_bytes(2, byteorder='big')
b'x04x00'
>>> (1024).to_bytes(10, byteorder='big')
b'x00x00x00x00x00x00x00x00x04x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'xffxffxffxffxffxffxffxffxfcx00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
b'xe8x03'

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

возвращает число из данной строки байтов.

>>> int.from_bytes(b'x00x10', byteorder='big')
16
>>> int.from_bytes(b'x00x10', byteorder='little')
4096
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Системы счисления¶

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

int([object], [основание системы счисления])

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

bin(x)

преобразование целого числа в двоичную строку.

hex(х)

преобразование целого числа в шестнадцатеричную строку.

oct(х)

преобразование целого числа в восьмеричную строку.

Примеры:

>>> a = int('19') # Переводим строку в число
>>> b = int('19.5')  # Строка не является целым числом
Traceback (most recent call last):
  File "", line 1, in
ValueError: invalid literal for int() with base 10: '19.5'
>>> c = int(19.5)  # Применённая к числу с плавающей точкой,
                   # отсекает дробную часть
>>> print(a, c)
19 19
>>> bin(19)
'0b10011'
>>> oct(19)
'0o23'
>>> hex(19)
'0x13'
>>> 0b10011  # Так тоже можно записывать числовые константы
19
>>> int('10011', 2)
19
>>> int('0b10011', 2)
19

Вещественные числа (float)¶

Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:

>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.9999999999999999

Для высокой точности используют другие объекты (например Decimal и Fraction)).

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

>>> a = 3 ** 1000
>>> a + 0.1
Traceback (most recent call last):
  File "", line 1, in
OverflowError: int too large to convert to float

Простенькие примеры работы с числами:

>>> c = 150
>>> d = 12.9
>>> c + d
162.9
>>> p = abs(d - c)  # Модуль числа
>>> print(p)
137.1
>>> round(p)  # Округление
137

Дополнительные методы¶

float.as_integer_ratio()

пара целых чисел, чьё отношение равно этому числу.

float.is_integer()

является ли значение целым числом.

float.hex()

переводит float в hex (шестнадцатеричную систему счисления).

classmethod float.fromhex(s)

float из шестнадцатеричной строки.

>>> (10.5).hex()
'0x1.5000000000000p+3'
>>> float.fromhex('0x1.5000000000000p+3')
10.5

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

Модуль math предоставляет более сложные математические функции.

>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(85)
9.219544457292887

Модуль random реализует генератор случайных чисел и функции случайного выбора.

>>> import random
>>> random.random()
0.15651968855132303

Комплексные числа (complex)¶

В Python встроены также и комплексные числа:

>>> x = complex(1, 2)
>>> print(x)
(1+2j)
>>> y = complex(3, 4)
>>> print(y)
(3+4j)
>>> z = x + y
>>> print(x)
(1+2j)
>>> print(z)
(4+6j)
>>> z = x * y
>>> print(z)
(-5+10j)
>>> z = x / y
>>> print(z)
(0.44+0.08j)
>>> print(x.conjugate())  # Сопряжённое число
(1-2j)
>>> print(x.imag)  # Мнимая часть
2.0
>>> print(x.real)  # Действительная часть
1.0
>>> print(x > y)  # Комплексные числа нельзя сравнить
Traceback (most recent call last):
  File "", line 1, in
TypeError: unorderable types: complex() > complex()
>>> print(x == y)  # Но можно проверить на равенство
False
>>> abs(3 + 4j)  # Модуль комплексного числа
5.0
>>> pow(3 + 4j, 2)  # Возведение в степень
(-7+24j)

Для работы с комплексными числами используется также модуль cmath.

Лекция 2. Ключевые слова. Комментарии. Управляющие структуры и блоки кода.

Значки, используемые в тексте

• 🕑 — отмечает, что высказывание не совсем верно, но будет уточнено позднее.
• ⭐ — выделяет определение нового понятия.
• ❗ — привлекает внимание к высказыванию.
• ☝️ — указывает на небольшое отступление от темы или уточнение.
• 💡 — индикатор традиций и договорённостей.
• ⚠️ — требуется осторожность: возможно, сложное высказывание.

Повторение терминов из первой лекции

• Литерал — непосредственное значение, например, целое или дробное число;
• Переменная — некий идентификатор, имеющий, но скрывающий своё непосредственное значение;
• Оператор — элемент, указывающий на проведение определённой операции (сложения, умножения и т.п.) над операндами;
• Выражение — последовательность литералов и/или переменных и/или операций над ними. Выражение вычисляется
  интерпретатором и возвращает результат. Выражение может также содержать операции над выражениями;
• Утверждение — законченная команда компьютеру, например вычисление выражения для вывода результата в консоль или для присваивания
  его переменной. Обычно заканчивается переводом строки (ВВОД, ENTER в интерпретаторе). В отличие от выражения, не имеет результата.
• Исключение — ошибка, возникающая при некорректном выражении или некорректных значениях выражения.

Оператор изменения знака числа: -.

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

Таким же образом мы можем присвоить переменной y значение со знаком, противоположным значению (объявленной ранее) переменной x:

>>> x = 2
>>> y = -x
>>> y
-2

что выведет -2.

Ключевые слова. Утверждение «напечатать» (print-statement)

До сих пор мы работали в интерактивном интерпретаторе. Пришло время создать нашу первую программу.

Что такое Python-программа? В общем случае программа — это набор команд для компьютера.
В нашем курсе мы будем считать программой набор утверждений на Python, записанный в файл.
Наличие файла с текстом программы (как говорят программисты, «кодом«) является ключевым свойством программы.
Оно отражается на поведении интерпретатора python:

❗ При выполнении программы из файла интерпретатор уже не выводит значения после каждого перевода строки.

Для вывода значения выражения в программе нужно использовать так называемый
print-statement (утверждение «напечатать» или «напечатай»). Оно выглядит как анлийское слово print, за которым через пробел следует
требуемое выражение: например, print 2 или print 2 + 2.

💡 Количество пробелов (один или несколько) после ключевого слова print для интерпретатора не важно,
но по соглашению принято использовать один пробел.

Утверждение print можно использовать и в интерактивном интерпретаторе:

Однако именно в программах его использование просто не имеет альтернативы (NB 1).

Давайте создадим файл с программой на Python (В PyCharm: File -> New -> Python file;
либо можно использовать текстовый редактор типа Блокнот, но не какой-либо Office)
с названием, например, program1.
(☝️ Файл должен иметь расширение .py. В PyCharm оно будет добавлено автоматически.)

Напишем в нём одну строку (☝️ при использовании текстового редактора необходимо сохранить файл!):

Теперь можно ☝️ запустить эту программу (В PyCharm: Run -> Run… -> <Ввод>; в командной строке — python program1.py)
и в её выводе мы увидим 2.

Слово print в составе данного утверждения — так называемое ключевое слово.

⭐ Ключевые слова являются идентификаторами,
которые встроены в язык Python и не требуют объявления (в отличие от переменных), при этом объявляемые переменные не могут
носить имя, совпадающее с ключевыми словами.

💡 Ключевые слова в Python по традиции записываются в строчном регистре и являются тем или иным английским словом.

☝️ Фактически, вычисление выражения справа от знаков >>> в интерактивном режиме

эквивалентно выполнению программы с содержанием

— эта программа также выведет 4.

Содержание программы. Комментарии

Как мы уже сказали, программа — это набор утверждений на Python.
Утверждения в программе записываются по одному в строке (NB 2) и выполняются в общем случае последовательно
в порядке записи 🕑 .

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

❗ Строки текста программы, в которых нет ни одного утверждения, никак 🕑 не влияют на её результат.

Таковыми считаются:

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

⭐ Комментарий — это часть программы, которая
никак не влияет на её выполнение, то есть игнорируется интерпретатором, но при этом (обычно) несёт смысл для человека.

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

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

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

# Так может выглядеть простейшая программа на Python. 
# Это общий комментарий к программе.

# ниже следует print-утверждение.
print 2 + 2  # оно выведет 4

❗ В программах на Python 2 есть такая вещь, как необходимый специальный комментарий. Для того, чтобы Python 2
корректно работал с русским языком в тексте программы, первой строкой должен идти комментарий с указанием кодировки,
который выглядит так, как в примере ниже. Первую строку из этого примера нужно вставлять в каждую программу для Python 2.
(☝️ В PyCharm можно вписать её в шаблон файла, и она будет добавляться автоматически.)

# coding: utf-8

# Так может выглядеть простейшая программа на Python. 
# Это общий комментарий к программе.

# ниже следует print-утверждение.
print 2 + 2  # оно выведет 4

К сожалению, это определённое нарушение Дзена Python, и оно уже устранено в Python 3. Если вы увидели при попытке выполнения
вашей программы ошибку вида

SyntaxError: Non-ASCII character 'xd0' in file a.py on line 1, but no encoding declared

это верный признак того, что вы забыли указать кодировку в начале программы.

Управляющие структуры

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

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

ЕСЛИ х МЕНЬШЕ НУЛЯ: выведем значение x с противоположным знаком 
ИНАЧЕ: выведем значение x

В Python, это будет выглядеть почти так же, только на «английском».

☝️ Напомним только, что для использования переменной в программе нам необходимо её вначале объявить.

x = -1  # чтобы объявить переменную х, присвоим ей значение, для примера -1
if x < 0: print -x  # первое print-утверждение
else: print x  # второе print-утверждение

В выводе программы мы увидим число 1. В данном случае выполнилось первое print-утверждение, выведя значение выражения -x.
Второе же не было выполнено.

Если в утверждении присваивания x мы поставим 1 вместо -1, то мы также увидим 1.
На этот раз выполнилось второе print-утверждение с выражением x.

Что есть что в этой записи?

Ключевые слова if, else. Условные утверждения

if, else — это ключевые слова в Python. Каждое из этих слов вводит соответствующие утверждения.

Во второй строке примера находится if-утверждение, которое содержит в себе первое print-утверждение.
За ним следует else-утверждение, которое также содержит в себе второе print-утверждение.

Как же так, ведь выше мы упомянули, что утверждения записываются по одному в строке? Да, это совершенно верно по отношению к простым
утверждениям. Сложные утверждения могут допускать и несколько утверждений в строке,
а могут растягиваться на многие строки. Сложное утверждение можно отличить по наличию знака :.

Вид утверждения if такой:

Утверждение else может идти только после if-утверждения и имеет вид

В нашем примере блок кода 1 — это первое print-утверждение, блок кода 2 — второе.

💡 Количество пробелов вокруг : не имеет значения, но в общепринятом стиле знак : непосредственно (без пробела)
следует за ключевым словом либо выражением в утверждении, а за ним
следует ровно один пробел.

Утверждения if и else в паре 🕑 образуют условное утверждение, являющееся также логической управляющей структурой.

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

В случае условного утверждения, это значит, что
если выполняется условие, указанное в if-утверждении, то будет выполнен блок кода, включённый в него, но
блок кода в else-утверждении будет пропущен.
Если же это условие НЕ выполняется, то первый блок кода не выполнится,
а управление получит второй блок кода — в else-утверждении.

Условия: Операторы сравнения

Мы использовали в if-утверждении оператор «меньше», это один из операторов сравнения. Всего их шесть:

• меньше: <
• больше: >
• меньше или равно: <=
• больше или равно: >=
• равно: ==
• не равно: !=

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

💡 Как обычно, записывают эти операторы, отделяя операнды пробелами (по одному).

Блоки кода

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

⚠️ Блок кода состоит из одного или нескольких утверждений и сам является частью соответствующего утверждения. Блоки кода
могут быть вложенными.

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

☝️ В ЯП¹ типа С, С++, Java и подобных обычно блоки кода находятся внутри фигурных скобок, в Pascal — между ключевыми словами begin/end.

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

• все утверждения, принадлежащие одному блоку кода, находились на одном уровне отступов, и
• величина отступа соответствовала уровню вложенности блоков.

❗ В случае, если последовательные утверждения в программе (или введённом коде в интерактивном режиме)
имеют отступы с разным числом пробелов/табуляции, это является синтаксической ошибкой вида

IndentationError: unexpected indent 

💡 Уровень отступа в Python обычно состоит из одного или нескольких единичных отступов, в количестве, равном уровню вложенности блока.
Общепринятого соглашения по величине единичного отступа, увы, нет. Наиболее популярен его размер в 4 пробела. В PyCharm,
а также в других средах разработки и большинстве продвинутых текстовых редакторов это можно настроить и устанавливать отступы клавишей tab.

☝️ Небольшое отступление для читателей, знакомых с другими ЯП¹:

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

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

💡 Если блок кода в составе утверждений if/else состоит из одного утверждения, его вполне корректно записать и на той же строке,
что и ключевое слово — сразу после двоеточия, как сделано в приведённом примере. Однако принято записывать даже одиночные вложенные утверждения на отдельной строке,
выделяя её отступами, это делается для читаемости. После улучшения наш пример примет вид:

x = -1  # чтобы объявить переменную х, присвоим ей значение, для примера -1
if x < 0: 
    print -x  # первое print-утверждение
else: 
    print x  # второе print-утверждение

Далее мы будем придерживаться этого стиля и в примерах, и в псевдокоде.

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

ЕСЛИ х меньше нуля: 
    напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
    напечатаем значение -x
ИНАЧЕ: 
    напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
    напечатаем значение x

Уже из текста (такой текст-аналог кода часто называют ⭐ псевдокодом) видно, что нам будет необходимо по два print-утверждения
в каждом блоке кода (в if-утверждении и в else-утверждении).

Реализуем это в коде (учтя необходимость объявить переменную перед использованием):

x = -1
if x < 0:
    print x 
    print -x 
else:
    print x 
    print x 

Для случая с x = -1 мы увидим выведенные значения -1, 1 . Для случая с x = 1 мы увидим два раза единицу.

Ну и никто не мешает нам вместо print-утверждения использовать и вложенную управляющую структуру if—else — например,
при обработке случая с x = 0 мы решили не выводить 0. Запишем в псевдокоде :

ЕСЛИ х меньше нуля: 
    напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
    напечатаем значение -x
ИНАЧЕ: 
    ЕСЛИ х равен нулю:
        не выводим значение
    ИНАЧЕ:
        напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
        напечатаем значение x

Как видно из псевдокода, у нас появляется вложенная логическая структура if—else во втором блоке кода (else-утверждении).
Но интересно и другое: не выводим значение — а что же делаем вместо этого?

Утверждение pass

Ответ на этот вопрос нам даёт pass-утверждение, или утверждение «пропустить».

⭐ pass-утверждение — это утверждение об отсутствии необходимости вычислений.

Оно состоит из ровно одного ключевого слова pass и не содержит вычисляемого выражения.

Запишем наш пример на Python:

x = -1
if x < 0:
    print x 
    print -x 
else:
    if x == 0:  # используем описанный выше оператор сравнения по равенству
        pass
    else:
        print x 
        print x 

Для чего может быть полезно такое «пустое» утверждение? Например, для того, чтобы в будущем внести на его место что-то внятное.
Но часто его применяют и для улучшения читаемости кода. Поясним на следующем примере.

На самом деле, мы можем изменить наш второй if—else блок так, чтобы, наборот,
выводить х в случае если x не равен 0, так как это логически эквивалентно:

ЕСЛИ х меньше нуля: 
    напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
    напечатаем значение -x
ИНАЧЕ: 
    ЕСЛИ х НЕ РАВЕН нулю:
        напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
        напечатаем значение x
    ИНАЧЕ:
        не выводим значение

Пришло время сказать, что ❗ в управляющих структурах Python else-утверждение необязательно. И если у нас нет необходимости
выполнять действия в блоке ИНАЧЕ, то мы можем его просто опустить, ограничившись одним if-утверждением:

ЕСЛИ х меньше нуля: 
    напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
    напечатаем значение -x
ИНАЧЕ: 
    ЕСЛИ х НЕ РАВЕН нулю:
        напечатаем значение x  (чтобы убедиться, что выполнился именно этот блок кода) 
        напечатаем значение x

На Python это будет выглядеть так:

x = -1
if x < 0:
    print x 
    print -x 
else:
    if x != 0:  # используем описанный выше оператор сравнения по неравенству
        print x 
        print x 

Но часто нам важно подчеркнуть, что в случае с x = 0 мы намеренно не предпринимаем ничего, и в целях читаемости и наглядности
мы и используем вариант с pass.

Более сложные управляющие структуры

Помните принцип из Дзена Python «плоское лучше, чем вложенное»? Проиллюстрируем это на последнем примере, где
условие x != 0 непосредственно следует за ключевым словом else — «ИНАЧЕ»: в русском языке мы бы записали это через запятую:

... иначе, если `x != 0` ...

Чтобы избежать излишней вложенности в управляющих структурах, для подобных случаев существует «плоская» форма if—else—if структуры,
с ключевым словом elif — сокращённое else if.

x = -1
if x < 0:
    print x 
    print -x 
elif x != 0:
    print x 
    print x 

Количество блоков elif в структуре не ограничено. В структуре может также содержаться и блок else, который
является так же, как и в простом if—else утверждении, необязательным,
но при наличии, он должен быть последним блоком в структуре:

x = -1
if x < 0:
    print x 
    print -x 
elif x != 0:
    print x 
    print x 
else:
    pass  # или что-то другое

❗ Из всей структуры if—elif—else может выполниться только один блок кода,
который первым соответствует указанному в нём условию (для if и elif),
даже если после этого есть другие подходящие блоки, либо блок else (или просто ничего, если блок else отсутствует),
в случае если ни одно условие не верно.

Например:

x = 3
if x > 1:
    print 1  # выведет 1 
elif x > 2:
    print 2  # не выполнится
else:
    print 3  # не выполнится

Чтобы выполнился именно блок с условием x > 2, необходимо поменять местами блоки с условиями x > 1 и x > 2:

x = 3
if x > 2:
    print 2  # выведет 2 
elif x > 1:
    print 1  # не выполнится
else:
    print 3  # не выполнится

При x = 2 в последнем примере выполнится только блок с условием x > 1, при x = 1 — только блок else.

☝️ Небольшое отступление для читателей, знакомых с другими ЯП¹:

Во многих ЯП используются также условные структуры case или switch. В Python такой структуры нет, так как структура
if—elif—else является практически полноценной заменой, однако может возникнуть резонный вопрос: ведь выражения в утверждениях if—elif
вычисляются каждый раз заново, в то время как в switch только один раз. Но это не совсем так: операции сравнения в блоках case
оператора switch выполняются также каждый раз, а более сложное выражение гораздо удобнее (помните принцип «читаемость имеет значение»?)
вычислить заранее единожды, присвоить его
значение переменной и сравнивать эту переменную сколько понадобится. Впрочем, в Python есть ещё более продвинутые техники, которые позволяют
выполнять однократное сравнение, но об этом позже.

Резюме

В этой лекции мы узнали о главном отличии программы от калькулятора — наличии управляющих структур,
написали первую программу в файле и получили из неё вывод результата. Мы также повстречались с новыми операторами — сравнения,
ключевыми словами print и pass, познакомились с псевдокодом.

Задания

Небольшая рекомендация:
сохраняйте все написанные вами программы в папки с названиями по номеру лекции, в файлы с
названиями, содержащими номер задания, например lect_2/program1.py. Они вам ещё пригодятся.

1. Поменять знак в значении переменной, не меняя её имени (да, такое возможно!). Если в утверждении присваивания
   присвоить уже объявленной переменной значение выражения, содержащего ту же переменную, то после вычисления этого выражения
   она получит новое значение.
   Сделать это двумя способами — с помощью унарного оператора минус и арифметическим способом: умножив на -1.
   Результат вывести в утверждении print.

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

   при этом учесть следующее:

   • значение x может быть как вещественным, так и целым, в последнем случае результат деления может не совпадать
     с ожидаемым. Чтобы этого избежать, рекомендуется использовать литерал 2.0 вместо 2;
   • для значения x, при котором может возникнуть ошибка ZeroDivisionError, не выводить ничего,
     указав в комментариях, почему требуется именно такое условие.

   Проверка: результата выполнения программы:

   • при x = 1 программа выведет число -3.0;
   • при x = 2 программа не выведет ничего;
   • при x = 3 программа выведет число 5.0;

   и т.п.

3. Написать программу, аналогичную предыдущему заданию, но с двумя переменными: x и y, и формулой

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

   или умножение на вещественное число 1:

   В этом случае, как мы помним из первой лекции, значение x гарантированно будет вещественным числом.

4. Написать программу нахождения максимума: в её начале задаются 5 переменных a1, a2, a3, a4, a5
   (можно назвать их константами),
   далее задаётся переменная maximum. Написать условную конструкцию (точнее несколько),
   которая по очереди проходит по заданным
   константам и обновляет maximum каждый раз, когда константа больше текущего значения максимума.
   Значения для констант можно выдумать любые и поэкспериментировать с разными комбинациями.

5. Написать программу-счётчик: в её начале задаются 5 переменных-констант a1, a2, a3, a4, a5,
   далее задаётся переменная-счётчик counter. Написать условную конструкцию, которая проходит по заданным
   константам и увеличивает счётчик на единицу каждый раз, когда абсолютная величина константы больше 5 (10, 100).

Примечания

1: ЯП — сокращение для «Языки программирования»

NB 1: Альтернативы, конечно же, есть, но они более специфичны для конкретных случаев и менее очевидны.
Здесь работает принцип Дзена Python: Должен быть один, и желательно, только один очевидный способ сделать это.

NB 2: В Python допускается запись и больше чем одного утверждения в строке, разделяя их символом ;.
Это не практикуется в программах в целях читаемости. Однако в некоторых случаях такая функциональнось бывает удобной и
встречается. Один из принципов Дзена Python как раз гласит «практичность важнее безупречности»)

Следующая лекция Оглавление Предыдущая лекция