Математический практикум по Питону.
Вводятся базовые элементы питона (Python версии 3.xx): арифметические и логические выражения, понятие о типе (int, float, bool, str, type) и о его явном/неявном преобразование. Рассматривается и функция печати print. Понятие объекта (на примере, complex), операции над ним и его методы. Также вводится тернарная оператор. Вводится понятие модуля на примере библиотеки math.
Это предварительная версия! Любые замечания приветствуются.
Работа с консолью.
Мы таким способом общаемся с компьютером. Все началось с консоли файловой системы, потом всякие мат программы: Maple, ...
Программа предствляется в виде блоков, содержащиш некий код с пояснениями. Предполягается постепенное построение программы, т.е. не сразу все пишется, а за несколько этапов. Промежуточный результат выводится и на основании его пишется новый блок.
Так в целом проще чем срузе писать код, который учитывает все возможные случаи.
Далее идет пример блока (с коментарием).
# Замечания, пояснения в коде начинаются с символа решетка и идут до конца строки. Как, например, эта строка.
# Код может быть разбит на блоки. Это например новый блок кода. При выполнеии они нумеруются.
# Пустные строки ни на что не влияют.
# Можно и с отсутпом писать комментарии.
В питоне можно выполнять вычисления как на калькуляторе.
# Для этого необходимое выражение записывается в блоке
# и наживается клавиша воспроизведения (или shift-enter).
-5 + 9
# Отмечу, что последнее значение блока выводится в качестве результата блока.
4
Над числами доступны стандартные арифметические операции: +, -, * и /.
4 - 9 # Вычитание.
-5
3 * 7 # Умножение.
21
Обычное деление:
5/2 # truediv
# Дробная часть задается точкой (а не запятой) в десятичной записи.
2.5
Также доступны вычисления над целыми числами, так называемые целочисленные вычисления.
# Целочисленное деление задается как //:
5//2 # floordiv
# Отбросили дробную часть у 2.5
2
Действует правило округление "вниз" (как и для положительных чисел) -- берется нижняя граница.
(-11)//2 # При обычном деление -5.5 => Внизу -6
-6
11//2 # При обычном делении 5.5 => Внизу 5.
5
Важной особенностью питона в том, что можно несколько выражений одновременно вычислять. В других языках есть схожая вещь, но это другое...
(-5)/2, (-5)//2 # Выражения записываем через запятую.
# -2.5 => -3.
(-2.5, -3)
# Скорее даже это не округление, а наибольшее целое число меньшее отношения.
5/3, 5//3, 5/-3, 5//-3
(1.6666666666666667, 1, -1.6666666666666667, -2)
Возведение в степень
Один из немногих языков, где операция возведения в степень является встроенной (в сам язык).
# Возведение в степень задается двойной звездочкой, т.е. 3 в степени 2 записывается как:
3 ** 2
9
# Степень конечно может быть и дробной:
32 ** (1/5) # т.е. корень пятой степени из 32.
2.0
# Проверим:
2.0 ** 5
32.0
Сложные выражения
# Можно использовать и сложные выражения.
2 + 3*5
17
# В частости, использовать скобки.
2.0 + 3.5 * ( 5 - 3.)
9.0
Упр. Найди корни квадратного уравнения для заданных коэффициентов. Например, для уравнения x^2 - 5x + 4=0. Подставь их в выражение задающее квадратное уравнение (должен получиться 0).
Деление с остатком
Важно для программирования как такового. Например, для взятия каждого второго элемента из множества.
"Парной" операцией к целочисленному делению (//) является вычисление остатока от деления:
5%2 # Ищем остаток от деления 5 на 2.
1
Пусть $a, b \in \mathbb{Z}$(множество целых чисел). При этом пока считается, что $b > 0$.
Напомню, что если $r \in \mathbb{Z}$ остаток от деления $a$ на $b$, то имеет место представление: \begin{equation*} a=r + k*b, \end{equation*} где $k \in \mathbb{Z}$. Также должно быть выполнено: \begin{equation*} 0 \leq r < b. \end{equation*} В согласии с данным:
7 % 5 # Это должно быть понятно.
# 7 = 2 + 1 * 5
2
(-7) % 5 # Но и это: остаток всегда будет положительным.
# -7 = 3 + (-2) * 5
3
(-5) % (-3) # Ну только, если сам делитель положительный. Иначе справедливо следующее.
# -5 = -2 + 1 * (-3).
-2
В случае отрицательного делителя ($b < 0$), остаток, считается, тоже должен быть отрицательным, т.е. \begin{equation*} b < r \leq 0. \end{equation*} Последнее связано с тем, что делитель определяет класс эквивалентности между целыми числами. Операция остаток отображает произвольное число на его класс.
5 % (-3) # Поэтому в данном случае остаток будет также как раз отрицательным.
# 5 = -1 + (-2) * (-3).
-1
Деление с остатком традиционно вводят для целых чисел. Но ничто не мешает её определить аналогичным образом и для вещественных.
# Можно даже так.
2.5 % 2.1 # 2.5 = 0.4 + 1.2.1.
# Компьютер испытывает проблемы с представлением дробных чисел...
0.3999999999999999
С каждым выражением связан его тип. В зависимости от него могут вариьероваться поведение других частей программы.
# Тип выражения с целым числом.
type( 5 ) # У числа нет точки.
int
# Тип выражения с вещественным числом.
type( 5.1 ) # Число с робной частью.
float
# Число с точкой (хоть без фактической дробной части).
type( 5. ) # Нужно быть предельно аккуратным.
float
Фактически сначала вычисляется зачение выражение, что и определяет его тип.
# Входные два числа имеют целый тип.
type( 5/2 )
# Результат вычисления же имеет вещественный тип.
float
# Целочисленное деление.
type( 5//2 ) # Поэтому целый тип.
int
# У сложного выражения тоже есть тип.
type( 5 + 3*2 ) # По аналогии.
# Значение будет целым.
int
Так, сначала вычисляется значение
5 + 3*2
11
Потом тип данного числа
type(int)
type
Тип типа...
# У выражения определяющий тип
type(type(int)) # тоже есть тип.
type
Он называется type
Можно принудительно (явно) изменить тип выражения.
Неявное преобразование типа
Обычно выполняется неявное преобразование типа.
# Входные числа целые, выходное вещественное.
5/3, type(5), type(5/3)
(1.6666666666666667, int, float)
В этом смысле нужно быть предельно аккуратным при написании выражений. Может произойти нежелательное преобразование типа.
Явное преобразование типа
Можно выполнить явное преобразование типа.
# Целое число
5
5
5, type( 5 )
(5, int)
и оно же в вещественном представлении.
# Необходимый тип пишем до скобок.
float(5) # Тип берется от числа.
# Появилась точка и дробная часть равная 0!
# Замечу точку, она обозначает вещественный тип.
5.0
type( float( 5 ) )
float
На будущее... это фактически вызов конструктора нового объекта.
Можно наоброт. Из вещественного получить целое.
# Фактически отбросили дробную часть.
int(5.0), int(5.1), int(5.9), int(-4.9), int(-4.1)
(5, 5, 5, -4, -4)
Замечу, что:
# Здесь идет речь об округлении вниз.
51//10, 59//10, (-49)//10, (-41//10)
(5, 5, -5, -5)
Для выражений ествественно тоже можно сделать преобразование типа. Фактически сначала будет вычислено значение выражения, а потом оно будет преобразовано.
5/2 # Тип вещественный.
2.5
# Фактически тип берется от выражения.
int(5/2)
2
# Отбрасываем дробную часть.
int(-11/2) # -11/2=-5.5 => -5
-5
# Целочисленное деление.
-11//2
-6
int(51/10), int(59/10), int((-49)//10), int( (-41)//10 )
(5, 5, -5, -5)
Вприципе этого должно быть достаточно. И любое вычисление можно сделать. Например, для вычисления синуса вспоимнить нужный ряд и вычислить. Последнее не очень продуктивно. Зачем так поступать? Ведь скорее всего код для вычисления синуса уже кем-то написан. Лучше воспользоватся чем-то готовым.
Для расширения возможностей естественно необходимо применять сторонний код, а именно библиотеки. В следующем блоке показано как это делается (вызываются библиотечные функции) на примере библиотеки math: это библиотека для работы с векторами, матрицами. Она же применяется для вычисления стандартных функций: тригонометрических, экспонента, логарифм, степень и др.
Библиотека Math
Math относится к стандартным библиотекам идущим вместе с питоном.
# Для использования готовых библиотек достаточно их загрузить в среду питона:
import math # Загрузили библиотеку math.
# Теперь можно вычислить например:
math.sin( 1.1 )
0.8912073600614354
Ну раз так, то можно и так
2.2 * math.sin( 1.1 )
1.9606561921351582
Следует отметить, то как функция называется: не сама по себе (sin), а с префиксом "math.". Последнее связано с тем, что функция sin из библиотеки math. Последнее сделано, чтобы функции из разных библиотек не перепутались: не перекрыли друг друга при одинаковом названии.
В языках программирования, в частности, в питоне применение функции называется вызовом.
Имеется множество библиотечных функций.
# Арксинус.
2*math.asin( -1 ) # Ответ похож на значение числа -пи.
-3.141592653589793
Но, название math длинное. Есть расширение данной команды для загрузки библиотеки и присвоение ей сокращенного имени.
# Данная строчка загружает библиотеку math и дает ей сокращенное название mt.
import math as mt
Теперь можно использовать сокращенное название mt вместо полного math.
2.2 * mt.sin( 1.1 ) # Применили функцию синус (np.sin).
1.9606561921351582
Используется префикс np так как она была загружена в систему с сокращенным названием mt. Поэтому такое обозначение.
Итого, в math существуют тригонометрические функции: sin, cos, tan, и их обратные: asin, acos, atan. Полный список можно посмотреть в документации.
# Ествественно в качестве аргумента функции можно исользовать не только число, но и целое выражение
mt.sqrt( 4**2 + 3**2 )
5.0
При вызове функции сначала вычисляются значения всех её аргументов, а потом эти значения подаются вызываемой функции. Отсуюда термин "вызов по значению". Подчеркну, что сами выражения не доступны вызываемой функции. Доступно только значение.
Если вдруг не понятно, на всякий случай упомину и случай функция от фукнции:
mt.asin( mt.sin(0.4+0.1) )
0.5
# Доступны и константы
mt.pi # Например, число пи.
3.141592653589793
mt.e # e, натуральное
2.718281828459045
mt.sin( mt.pi*3.5 )
-1.0
Упр. Реши уравнение sin(ax+b)=c при заданных значений a, b и c. Например, при c=1, b=pi/2, a=2
К вычислимым выражениям относятся не только арифметические, но и логичекие.
Неравенства и булевский тип
Например, можно сложить два числа, а можно вычислить истинность утверждения, что первое число больше второго.
# Сложим два числа. Оба целые.
10 + 5 # Результат тоже целый.
15
Проверяем истинность того, что первое число больше второго.
# Входные числа имеют целый тип, а результат булевый (истина ли ложь).
10 > 5 # True -- истина.
True
# Данное утверждение ложное.
10 > 15 # False -- ложь.
False
# Выводим тип результирующего выражения.
type( 10 > 5 ) # Видим что тип bool, булевский.
bool
type( True ) # Можно сразу взять одно из значений истинности.
bool
Помимо строгих неравенств имеются и нестрогие.
# Соответственно меньше равно и больше равно.
3 <= 3, 5 >= -1
(True, True)
Проверка на не/равенство
Ну у конечно проверка на равенство
3 == 3
True
25 == 5**2
True
Проверяется по сути.
25 == 25.0
True
Но
25 == 25.00001
False
Проверка на неравенство:
5 != 3
True
4 != 4
False
Практика
Четное ли число
5%2 == 0, 6%2 == 0
(False, True)
Над логическими значениями доступны свои операции. Они менее известны, поэтому дадим некоторое пояснение. Следующие операции дву-арные (т.е. имеют два аргумента)
type(True)
bool
# Можно явно использовать значения типа bool.
True and True # Ясно что будет Истина.
True
# Раз один из аргументов ложь то,
True and False # итог ложный.
False
# Проверяем операцию И в разных комбинациях:
True and True, False and True, False and False
(True, False, False)
# По аналогии проверяем операцию ИЛИ.
True or True, False or True, False or False
(True, True, False)
Для вычисления над логическими выражениями существует и унарная операция:
not True, not False
(False, True)
Практика
Проверка на нечетность
not 5%2 == 0
True
С арифметическими выражениями
Итого, можно применить их с арифметическими выражениями.
5 < 11 and 12 < 20
True
# Соответственно доступно следующее выражение.
(10 > 5) and ( 111 < 200 ) # True and True
True
# и такие
(10 < 5) or (3 < 5), (10 < 5) or (3 > 5)
(True, False)
not (5 < 3) # Отрицание от ложного неравенства.
True
Практика
Более практичные примеры связаны с проверкой принадлежности числа интервалу
5 < 7 and 7 < 10 # Проверка принадлежности числа 7 интервалу [5,10].
True
Аналогично.
5 < 4 and 4 < 10 # Проверка принадлежности числа 4 интервалу [5,10]
False
Внимание!!
В отличие от многих языков программировния питон поддерживает сложные логические неравенства.
5 < 6 > 5.9 # Подразумевается операция И между всеми неравенствами.
True
# Последнее эквивалентно.
5 < 6 and 6 > 5.9
True
# В соответствие с этим, принадлежность интвервалу записывается как
5 < 7 < 10 # Проверка принадлежности числа 7 интервалу [5,10].
True
5 < 4 < 10, 5 < 6 < 10,
(False, True)
Приоритет операций
У арифметических операций (+,-,*,/) тоже есть приоритет. Но он проходится в школе.
# Так в выражении
2 + 3 * 5 # Сначала *, а потом +.
17
# Можно явно применить скобки.
2 + (3 * 5) # Тогда слова про приеритет теряют смысл.
17
# А не наоборот.
(2 + 3) * 5 # Это не правильное понимание приоритета.
25
Как и всегда для логических выражений между операциями существуют приоритеты (У И выше приоритет чем у ИЛИ). Но лучше всегда ставить скобки.
6 < 5 and (8 < 10 or 5 < 7)
False
Другая расстановка скобок.
(6 < 5 and 8 < 10) or 5 < 7
True
6 < 5 and 8 < 10 or 5 < 7
True
Из bool в число
Можно и из булевского получить целое. Есть соглашение на данный счет.
int(True) # Истина преобразуется в 1.
1
int(False)
0
int(5 < 3) # а ложь в ноль.
0
Благодаря этому например можно такие вычисления делать
# Количество чисел из набора больше 5:
int( 5 < 4 ) + int( 5 < 5 ) + int( 5 < 6 ) + int ( 5 < 7 )
2
Из числа в bool
Но и число можно превратить в булевское значение.
# Считается, что нулевое значение это ложь, остальные истина.
bool(0), bool(0.1), bool(-0.5), bool(10)
(False, True, True, True)
bool( 5%2 )
# Число нечетное
True
bool( 6%2 )
False
Упражнения. Вычислить абсолютное значение числа использую смесь логических и арифметических выражений.
Позволяет в зависимости от истинности выражения вернуть разные зачения.
Например, если число отрицательное, то вернуть -1, иначе 0.
-1 if -5<0 else 0
-1
-1 if 1<0 else 0
0
Без else нельзя. Оператор единая сущность включающая как if, так и else.
-1 if 1<0
File "<ipython-input-100-b2df582666ae>", line 1 -1 if 1<0 ^ SyntaxError: invalid syntax
Можно строить и цепочки.
-1 if 1<0 else 1 if 1==1 else 0
1
-1 if 0<0 else 1 if 0==1 else 0
0
Возвращать можно конечно и другие типы данных. Например, текстовые строки.
Строчки текста задаются в кавычках (либо одинарных либо двойных)
'текстовая строка' # Одинарные кавычки.
'текстовая строка'
"можно и в двойных кавычках" # Теперь кавычки двойные.
# Но результат содержит одинарные.
'можно и в двойных кавычках'
type("строка"), type('ещё одна') # Тип в любом случае будет строка -- str.
(str, str)
# Текст в одинарных парных кавычках.
'Это строчка'
'Это строчка'
# Можно и в двойных парных кавычках.
"И это тоже"
'И это тоже'
type('строка'), type("строка")
(str, str)
Применение
Тогда можно такую условную конструкцию написать.
"меньше" if 5<6 else "больше"
'меньше'
"меньше" if 5<6 else "больше"
'меньше'
Проверка того является ли -1 корнем.
"корень" if mt.fabs( (-1)**2 + 2 *(-1) + 1 ) < 0.0001 else "не корень"
'корень'
"корень" if mt.fabs( (-2)**2 + 2 *(-2) + 1 ) < 0.0001 else "не корень"
'не корень'
Проверка рабочего времени.
"работа" if 9 < 15 < 18 else "отдых"
'работа'
"работа" if 9 < 20 < 18 else "отдых"
'отдых'
В задачах на проверку на четность.
"нечетное" if 5%2 else "четное"
'нечетное'
"нечетное" if (-8)%2 else "четное"
'четное'
Вычисление длины строки
Длина строки, т.е. количество символом в её представлении.
len("строка")
6
Для чисел не срабатывает
len(5)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-118-91fed648bb37> in <module> ----> 1 len(5) TypeError: object of type 'int' has no len()
Арифметические операции над строками
Строки можно складывать.
'первая часть' + 'вторая часть' # Контакинация.
'первая частьвторая часть'
Последнее показывает, что идентичные по виду операции могут отличатся по функционалу для объектов иных типов.
'первая часть' + ' '+ 'вторая часть' # Добавим пробел между ними.
'первая часть вторая часть'
Умножать нельзя.
'строка' * 'умножить'
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-121-5a68665afacb> in <module> ----> 1 'строка' * 'умножить' TypeError: can't multiply sequence by non-int of type 'str'
как и вычитать.
'pl' - 'p'
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-122-2cc6ce5d8bf8> in <module> ----> 1 'pl' - 'p' TypeError: unsupported operand type(s) for -: 'str' and 'str'
Доступна операция умножения, но...
'строка' * 2 # которая размножает строку.
'строкастрока'
# Но
'строка' * 2.1
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-124-908aa0d5f69c> in <module> 1 # Но ----> 2 'строка' * 2.1 TypeError: can't multiply sequence by non-int of type 'float'
# Даже
'строка' * 2.
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-125-8173c873191a> in <module> 1 # Даже ----> 2 'строка' * 2. TypeError: can't multiply sequence by non-int of type 'float'
Функция print
577 , 888
(577, 888)
Красивый вывод осуществляется функций print, где аргументы печатаются подряд.
# Буду напечатаны числа через пробел.
print( 5, 7, -5.5)
5 7 -5.5
print это функция!
# Как обычно с функциями, можно подать на вход print выражение.
print( mt.sqrt(9) + 1, 5%3 )
4.0 2
Использование другого разделителя вместо пробела.
print( 5, 7, -5.5, sep = ', ')
5, 7, -5.5
Подмена символа конца строки
print( 5, 7, -5.5, sep = ', ', end = '.')
5, 7, -5.5.
Но так не сработает...
print( 5, 7, -5.5, sep = ', ', end = '.')
print( 1, 2, 3, sep = ', ', end = '.')
# Все слилось в одну строку
5, 7, -5.5.1, 2, 3.
Печать текстовых строк.
print( "Это печать текстовой строки")
Это печать текстовой строки
print("Площадь круга радиуса 5 равна", mt.pi*5**2)
Площадь круга радиуса 5 равна 78.53981633974483
print("Площадь круга радиуса 5 равна", mt.pi*5**2)
print("Периметр круга радиуса 5 равна", mt.pi*5*2)
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
print("Площадь круга радиуса 5 равна", (len("Периметр") - len("Площадь"))*" ", mt.pi*5**2)
print("Периметр круга радиуса 5 равна", mt.pi*5*2)
# Прблема из за того, что после каждой запятой выводится пробел.
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
print("Площадь круга радиуса 5 равна", (len("Периметр") - len("Площадь"))*" ", mt.pi*5**2)
print("Периметр круга радиуса 5 равна", "", mt.pi*5*2)# Нужно вывести пустую строку
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
Могли бы и сделав разделяющий символ между элементами равным пустой строке.
print("Площадь круга радиуса 5 равна ", (len("Периметр") - len("Площадь"))*" ", mt.pi*5**2, sep = "") # Разделяющий символ сделан равным пустой строке
print("Периметр круга радиуса 5 равна ", mt.pi*5*2, sep = "")# Но добавлен прбел к строке чтобы не слиплось.
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
Специальные символы
'\n' -- Новая строка
'\t' -- Табуляция
'строка 1\nстрока 2\n\tстрока 3'
'строка 1\nстрока 2\n\tстрока 3'
print('строка 1\nстрока 2\n\tстрока 3')
строка 1 строка 2 строка 3
print('начало\n' + 'тело\n'*3 + 'конец')
начало тело тело тело конец
print('начало\n' + '\tтело\n'*3 + 'конец')
# Внимание на отступ
начало тело тело тело конец
Переделаем вывод с табуляцией.
print("Площадь круга радиуса 5 равна\t", mt.pi*5**2)
print("Периметр круга радиуса 5 равна\t", mt.pi*5*2)
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
В одну строчку
print( "Площадь круга радиуса 5 равна\t", mt.pi*5**2, "\n", "Периметр круга радиуса 5 равна\t", mt.pi*5*2)
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
print( "", "Площадь круга радиуса 5 равна\t", mt.pi*5**2, "\n", "Периметр круга радиуса 5 равна\t", mt.pi*5*2)
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
print( "Площадь круга радиуса 5 равна\t", mt.pi*5**2, "\n", "Периметр круга радиуса 5 равна\t", mt.pi*5*2, sep = "")
# Опять же сделав разделяющий символ пустым.
Площадь круга радиуса 5 равна 78.53981633974483 Периметр круга радиуса 5 равна 31.41592653589793
Можно и наоборот сделать так что отдельные printы печатали в одной строке. Для этого символ в конце строки нужно заменить. По умолчанию это \n, т.е. переход на новую.
print("Какой-то текст, ", end = "")
print("Его продолжение")
Какой-то текст, Его продолжение
А так по умолчанию.
print("Какой-то текст, ", end = "\n")
print("Его продолжение")
Какой-то текст, Его продолжение
problem
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-148-526ab3a89ffc> in <module> ----> 1 problem NameError: name 'problem' is not defined
Упражнение Написать программу рисующую табличку:
# !!!!
------------------- | | | | | | | | ------------------- | | | | | | | | -------------------
'aaa' + 'bbbb' # Ещё наз напомню.
'aaabbbb'
Вместо операции + можно применить и другие. Например, операцию меньше, больше. Строчки можно сравнивать посредством логических операций в алфавитном порядке.
# Возвращает истину если первое слово ижет раньше второго алфавитном порядке.
'Максим' < 'Дима' # Знак < вместо знака +.
False
'Максим' < 'Федор'
True
# Это можно рассматривать как единое целое,
'Максим' == 'Федор' # т.е. что операция == и < обе логические.
False
'Максим' <= 'Федор'
True
Проверка на равенство по сути, т.е. как строчки в обычном поимании.
# По сути они равны.
'строка' == "строка"
True
# А эти строки нет.
'строка 1' == "строка 2" # Строки не совпадают.
False
("раньше" if "Катя"<"Маша" else "позже") + " в списке"
'раньше в списке'
("раньше" if "Яна"<"Маша" else "позже") + " в списке"
'позже в списке'
Возьмем некоторое выражение
# Корень дискрименанта уравнения x^2 - 5x + 4 = 0.
mt.sqrt( 5*5 - 4*4 )
3.0
Замечу, что предыдущий результат вычисления сохраняется в сущности _.
# Выведем
_
3.0
Тогда им можно воспользоватся. Как в математике, в выражении вместо _ будет подставлено само значение.
Например, так можно вычислить корни отмеченного уравнения.
0.5*(5 + _ ), 0.5 *(5 - _ )
(4.0, 1.0)
Объект comples
Введем понятие об объекте на примере комплексных чисел. Напомню, что оно сотоит из вещественной и мнимой части.
# Вещественное отрицательное число:
a = -1. # часть языка.
# Попробуем из него извлечь корень.
b = a**0.5 # Квадратный корень.
b, type(b) # Через запятую указан тип -- комплексное число.
# При выводе j обозначает мнимую часть.
((6.123233995736766e-17+1j), complex)
Создаем комплекскное число в явном виде. Часть языка питон.
# Как с явным преобразованием типов.
c = complex( -1 + 1j + 1j) # complex это тип.
c
(-1+2j)
Над комлексными числами имеются стандартные арифметические операции.
-1+2j
(-1+2j)
# Их поддерживает объект complex.
c + 1j # Сложение.
(-1+3j)
c**2 # Возведение в квадрат.
# (-1)**2 + 2**2*(-1) - 2(-1)2j
(-3-4j)
Вызовем квадратной корень библиотечной функцией из math.
a, type(a)
(-1.0, float)
# Math пытается вычислить квадратный корень.
mt.sqrt( a )
# Сломалась.
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-167-b568a790b229> in <module> 1 # Math пытается вычислить квадратный корень. ----> 2 mt.sqrt( a ) 3 # Сломалась. ValueError: math domain error
Библиотека честно пишет про область определения, что мол отрицательные числа не входят.
complex(a)
(-1+0j)
# Выполним явное преобразование типа.
mt.sqrt( complex(a) ) # Теперь сработало.
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-169-306ab6437b4a> in <module> 1 # Выполним явное преобразование типа. ----> 2 mt.sqrt( complex(a) ) # Теперь сработало. TypeError: can't convert complex to float
А с комплексными числами она не умеет работать.