Математический практикум по Питону.
Вводятся базовые элементы питона (Python версии 3.xx): переменные, ввод/вывод и понятие об объекте.
Это предварительная версия! Любые замечания приветсвуются.
# Загружаем необходимую для данной заметки библиотеку numpy.
import numpy as np
Сохраненное значение
Возьмем некоторое выражение
# Корень дискрименанта уравнения x^2 - 5x + 4 = 0.
np.sqrt( 5*5 - 4*4 )
# Для начала замечу, что предыдущий результат вычисления сохраняется в сущности _.
_
Тогда им можно воспользоватся. Как в математике, в выражении вместо _ будет подставлено само значение.
# Например, так можно вычислить корни отмеченного уравнения.
0.5*(5 + _ ), 0.5*(5 - _ )
Переменные
Главная особенность понятия кодинга/программирования это наличие переменных -- сущность позволяющая сохранить значение вычисления.
# Вычисляем очередное выражение. Но главное в другом.
# Значение сохранается в переменную
a = 2. - 5 * np.cos( np.pi ) #, конкретно, a.
# Значение не будет выведено.
# Можем вывести значение переменной явно,
a # т.е. фактически значение которое туда было ранее помещено.
Таким образом, можно выполнять вычисления с переменными. В данном случае будет использоваться ранее сохраненное значение в переменной. Вместо переменной в выражение будет подставлено её значение и выражение вычислиться как обычно.
a * 2 - 10 # При вычислении используется зачение переменной a.
# Присвоение не поменяет значения _
d=-1 # Мы же ничего не вывели
# Сохраняется хначение которое было именно выведено.
_ * 2
# Точка с запятой тоже блокирует вывод вычисления.
a * 2 + 5; # Но данном случае получается, что данная строчка бессмысленна.
_ # Сохранилось значение с прошлого вывода.
Много переменных
Данное понятие можно "размножить". Можно ввести много переменных.
Переменная как коробка с именем. В неё можно положить что-то и оно там останется пока не будет положено что-то новое. Приэтом у коробки есть имя, т.е. коробок много и все со своим уникальным именем.
b = 5
b # Это строчка чтобы вывод все-ткаи увидеть значение переменной a.
b * b + a # Используем в выражении две переменные.
Если попытаться использовать не существующую переменную, то компилятор будет ругаться.
5 + n # В данном случае он укажет, что переменая n не задана.
# Переменных ествественно может быть много.
bb = a * 2 # Их имена могут быть длинными, но с некими ограничениями.
bb # Но не будем об этом.
Но, в отличие от многих других языках в Питоне переменным можно двать и русские имена.
пер = 5 # Имя переменной может быть и на русском языке.
пер # Но некоторым это может не понравится.
Обновление значения
Не менее важно и, что переменной можно, ествественно, присвоить новое значение выражения. Если переменная ранее не существовала, то она создается. Если она уже существовала, то она забывает свое прошлое значение, и получает новое.
a # Старое значение.
# Более того, переменной значение можно переприсвоить (сохранить новое значение).
a = 5*5 % 6 # Результат не выведется по причине того, что он будет сохранен в переменную.
a
a = 3 - 5 # Придает переменной a новое значение, старое забывается.
a # Чтобы вывести значение.
Многоликость
Одну и туже переменную конечно можно использовать и справа и слево от равенста. Важно понимать: сначала вычисляется зачение правой части, потом данное значение присваивается левой, где подразумевается переменная (иначе будет ошибка).
# В правой части используеться переменная a
a = a + 1 #, которой и присваиваеться значение.
a
Блок можно выполнять нескоко раз, для этого его нужно щелкнуть и заново нажать кнопку проигрывателя (или нажать shift-enter). Попробуй это сделать с блоком содержащем строчку "a = a + 1" При каждом новом выполнении значение блока будет менятся.
В левой части должна быть переменная.
# В левой части не должно быть выражения.
a + 1 = a + 2 # Ну разве что какого-то хитрого...
# Иначе будет ошибка.
Тип переменной
Переменная хранит некое значение, а значит с ней связан и тип (хранимого значения): целое, вещественное число, строчка и тому подобное.
# В питоне можно узнать какой тип у переменной так:
a, type( a ) # Оно выводится из типа выражения значение которого было присвоено.
# Совпадает с типом значения,
type( 5 ) # которое в нем хранится.
Отмечу, что в других языках сначала объявляется переменная нужного типа, а потом присваивается ей значение. Иначе не получиться. В питоне иначе. Переменная создается (если нужно) в момент присвоения ей значения.
Последнее имеет как свои преимущества, так и недостатки. Преимущество в том, что не нужно отдельно создавать переменную (это лишний код), тем более, что обычно тип переменой можно вывести из самого выражения.
Недостаток заключается в том, что система не будет следить за правильностью присвоения значения переменной, т.е. переменной, которая ранее хранила матрицу, можно присовить просто число, а то и вообще строку некого текста.
Нет мусорного значения в переменой как в некоторых других языках программирования.
Итого, в переменую сохранаяется как значение, и как следствие и её тип.
# Отмечу, что при присвоении переменная забывает не только свое значение, но и свой тип.
# Например, сейчас тип у переменной a целочисленый.
a # Это определяется отсутвием точки (запятой).
# Но можно это проверить и явно спросив это у системы:
type( a )
# Но если перейти к вычисления с действительными числами, то тип сразу изменится.
a = 25 ** 0.5 # хотя в даном случае значение будет тем же. Но это чистое совпадение.
a # Точка имеется.
# Повторим запрос типа у системы.
type( a )
Итого, в первом случае тип был целочисленым (int), а во втором вещественный (плавающая точка, float)
Важно понимать, что система как в таких простых случаях, так и в более сложных ругатся не будет. Она такое присвоение со сменой типа разрешит (во многих других языках так нельзя). Это важно, когда появяться более сложные выражения.
Хранится значение!
Подчеркну ещё раз, что в переменную записывается значение выражения, а не само выражение (как формула), которое это значение выдало. Покажу это на характерном прмере.
a = 5 # Присвоим переменной a значение,
b = a * 2 # переменной b -- значение выражения.
# Выведем значения переменных.
a, b # Сразу обе, через запятую. На самом деле это набор (tuple)
a = -3 # Зададим новое значение для переменной a.
b # Изменится ли значение перменной b? Конечно же нет!
# Одновременный вывод выражений.
5 + bb, 6 - np.sin ( np.pi/2 ) # Ну понятно.
Много присвоений
Можно в каждой строке сделать отдельное присвоение.
# Два присвоения
a = 5 # Присвоили a значение.
# Присвоили значение переменной b.
b = 7 - a # Используется новое значение a.
a, b
# Можно их неоднократно повторять.
a=1
b=a*2
a=b+10
a,b
Параллельное присвоение
Прежде чем переходить к самому главному объекту языка Python покажу как можно присваивать значения в параллель.
# Присвоение выполняется сразу для двух переменных: a и b.
a, b = 1, 2
# По аналогии чтобы вывести значения переменных пишем:
b, a # Специально в другом порядке.
# Убедись, что ты понимаешь результат.
# Более пидантно писать:
(a, b) = 3, 5
a, b
Можно тоже самое проделать и для более сложных выражений.
a, b = 5 + bb, 6 - np.sin ( np.pi/2 )
Упр. Поменяй значения у двух переменных: имеем две переменные (например, a и b), нужно сделать так, чтобы значение переменной a было рано прошлому значению переменной b, а переменная b была равна прошлому значению переменной a. Подсказка... традиционно для этого используют ещё одну переменную. Если хочешь усложнить упражнение, то реши без дополнительной переменной.
Вывод
Красивый вывод осуществляется функций print, где аргументы печатаются подряд.
# Буду напечатаны числа через пробел.
print( 5, 7, -5.5)
print это функция!
# Как обычно с функциями, можно подать на вход print выражение.
print( np.sqrt(9) + 1, 5%3 )
Печать текстовых строк.
# Строчки текста задаются в кавычках (либо одинарных либо двойных)
print( 'Это строчка', "И это тоже")
Строки
s = 'строка' # Сохраняем строку в переменную.
print( s ) # Теперь её выведем.
# Выведем тип.
type( s )
# Доступна операция умножения,
s*2 # которая размножает строку.
# Строки можно складывать.
'первая часть' + 'вторая часть' # Контакинация.
Последнее показывает, что идентичные по виду операции могут отличатся по функционалу для объектов иных типов.
'первая часть' + ' '+ 'вторая часть' # Добавим пробел между ними.
Также можно узнать длину строки, т.е. количество символов в её представлении.
len(s) # len возвращает длину строки.
# Такие свойство можно использовать, например, при создании таблиц.
s = '* *'
print( '*' * len(s)* 4 )
print( s * 4 )
print( s * 4 )
print( '*' * len(s)* 4 )
Упражнение: 1) Создай таблицу с одинарной толщиной внутри таблицы.
# Можно комбинировать вывод строчек и чисел.
print('aa = ', 5*5)
# Замечу, что у числа длины нет.
len( 5 )
'pl'-'p'
Последнее показывает, что объекты различаются по допустимому множеству функций и вообще говоря операций.
Ввод
# Ввод числа осущестлвяется так.
a = input() # При выполнении появится окошко для ввода.
b = input('Длину гипотенузы') # Можно вывести приглашение при вводе числа.
# Попробуем выполнить вычисление.
a*2 # Результат скорее всего не тот, который мы ожидали.
# Выведем тип переменной.
type( a ) # Он строковый, т.е.
Нужно выполнить явное преобразование типа. Наподобие того, что ранее было с булевским типом.
Можно и из строки сделать число.
# Преобразуем к целому типу
int(a)
float(a) # Преобразование к вещественному типу.
# Исходя из ранее написанного
a = float( a )
print('квадратный корень из', a, 'равен', np.sqrt(a))
Не всякую строку можно преобразовать к числу.
int('5aa')
Функции иногда даже для допустимого типа мгут выдать ошибку.
Строки и числа
'равно' + 5
str(5)
'равно ' + str(5)
Объект comples
Введем понятие об объекте на римере комплексных чисел. Напомню, что оно сотоит из вещественной и мнимой части.
# Вещественное отрицательное число:
a = -1. # часть языка.
# Попробуем из него извлечь корень.
b = a**0.5 # Квадратный корень.
b, type(b) # Через запятую указан тип -- комплексное число.
# При выводе j обозначает мнимую часть.
Создаем комплекскное число в явном виде. Часть языка питон.
# Как с явным преобразованием типов.
c = complex( -1 + 2j) # complex это тип.
c
Над комлексными числами имеются стандартные арифметические операции.
# Их поддерживает объект complex.
c + 1j # Сложение.
c**2 # Возведение в квадрат.
# (-1)**2 + 2**2*(-1) - 2(-1)2j
Вызовем квадратной корень библиотечной функцией из numpy.
# Numpy пытается вычислить квадратный корень.
np.sqrt( a )
# Сломалась.
Библиотека не могла предположить, что мы так поступи. Она оптимизирована под разные типы данных. Поэтому она и сломалась.
# Выполним явное преобразование типа.
np.sqrt( complex(a) ) # Теперь сработало.
Метод объекта -- функция принадлежащая объекту. Инача говоря, она вызывается для объекта.
# Вызвали метод сопряжения.
c.conjugate() # Возвращается новый объект.
c # Старый сотался как есть.
Атрибуты. Значение внутреннего представления.
c.imag # Считываем мнимую часть
c.real # и действительную.
Обычно внутреннее представление стараются сохранить.
c.imag = 5 # Получить доступ к внутренности нельзя. В этом суть объекта.
# В данном случае можно только создать новый объект.
c.real + 5j
Стандартные типы
На самом деле и для int и float можно какие то подобные фокусы делать.
a = 5
a.numerator
b = 2.2
b.as_integer_ratio()
b.is_integer()
(5.).is_integer()