Осваиваем python: математические операции

Абсолютная величина

Встроенная функция abs() возвращает абсолютную величину указанного числа. В математике абсолютная величина, или модуль числа – это неотрицательное число, выражающее расстояние от этого числа до нуля. Например, абсолютная величина 15 – это 15, а -75 – число 75. Абсолютная величина 0 равна 0.

Абсолютная величина – важный аспект вычислений и анализа.

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

Без функции abs() в результате получится -35, отрицательное число. Функция abs() возвращает положительное число, так как абсолютная величина всегда представлена положительным числом или нулём.

Например:

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

Расширенные операторы присваивания

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

>>> a = 10
>>> b = 20
>>> c = a * 5 + b
>>> c
70

Фактически, выражение справа от присваивания может включать ссылки на переменную, которая присваивается:

>>> a = 10
>>> a = a + 5
>>> a
15
>>> b = 20
>>> b = b * 3
>>> b
60

Первый пример интерпретируется как « назначается текущее значение плюс », эффективно увеличивая значение на . Вторая гласит: « присваивается текущее значение раз , что эффективно увеличивает значение тройные.

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

>>> z = z / 12
Traceback(most recent call last):
  File "<pyshell#11>", line 1, in <module>
    z = z / 12
NameError: name 'z' is not defined

Python поддерживает сокращенное обозначение присваиваемых назначений для арифметических и битовых операторов:

Арифметические
Битовые

Для этих операторов эквивалентно следующее:

x <op>= y
x = x <op> y

Посмотрите на эти примеры:

ДополненнаяНазначение

СтандартнаяНазначение

эквивалентно

эквивалентно

эквивалентно

Интерактивное программирование[править]

Особенно удобная возможность, предоставляемая Python — это возможность быстро проверить как работают инструкции или выражения в интерактивном режиме. Такие интерактивные оболочки называются shell. Мы уже пользовались ей как частью IDLE. Остановимся сейчас на ней поподробнее.

Interactive Shellправить

Программа, с которой мы работали в первом уроке, может быть напечатана строчка за строчкой с тем же конечным результатом:

>>> v0 = 5
>>> g = 9.81
>>> t = 0.6
>>> y = v0 * t - 0.5 * g * t ** 2
>>> print (y)
1.2342

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

>>> v0 = 6
>>> v0
6
>>> print (v0)
6

Следующий шаг — обновить выражения, в которых еще содержится старое значение, то есть нашу формулу для y. В таком редакторе как IPython можно найти предыдущее выражение, с помощью кнопок со стрелками. О возможностях этого редактора мы еще поговорим. А пока:

>>> y = v0 * t - 0.5 * g * t ** 2
>>> y
1.8341999999999996
>>> print (y)
1.8342

Причина, по которой мы получили сейчас два разных результата, в том, что, если вы просто пишите y, то вы увидите все знаки после точки, находящиеся в памяти компьютера (16), в то время как инструкция print ограничивает число знаков и, таким образом, дает ответ с достаточной точностью. Впрочем, в некоторых версиях Python автоматически округляет значение переменной.

Преобразование типаправить

Если вы ранее работали с другими языками программирования, то могли заметить, что мы пишем программы не заботясь о задании типов переменных (вернее даже типов объектов, на которые ссылаются переменные). Однако в этом уроке мы встретились с вопросом типов объектов, когда изучали ошибку целочисленного деления, которая научила нас более внимательно относиться к типам объектов. Следующий пример иллюстрирует функцию type( ) и то, как мы можем изменять тип объекта. Для начала, создадим объект типа int, на который будет ссылаться имя С:

>>> C = 21
>>> type(C)
<type 'int'>

Теперь мы преобразуем наш объект С типа int к соответствующему объекту типа float:

>>> C = float(C)     #  type  conversion
>>> type(C)
<type 'float'>
>>> C
21.0

В инструкции C = float(C) мы создали новый объект из оригинального объекта с тем же именем. Теперь имя С ссылается на новый объект. Изначальный объект типа int со значением 21 теперь недоступен, поскольку у него больше нет имени и автоматически удаляется из памяти.

Мы также можем сделать и обратное, то есть конвертировать объект типа float к объекту типа int:

>>> C = 20.9
>>> type(C)
<type 'float'>
>>> D = int(C) #  type  conversion
>>> type(D)
<type 'int'>
>>> D
20  # decimals  are  truncated  :-/

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

>>> round(20.9)
21.0
>>> int(round(20.9))
21

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

На практике, используются довольно редко. Но применяются. И знать их тоже надо. 

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

Поэтому важно рассмотреть их более подробно. Бинарное И (&)

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

Бинарное И (&). Полный аналог оператора and, только который работает с битами. Точно так же, как и любой другой битовый оператор, он выполняет операции с каждой парой битов по отдельности, осуществляя с ними действия в соответствии с этой таблицей.

0 & 0 = 0

0 & 1 = 0

1 & 0 = 0

1 & 1 = 1

То есть, если первый бит в первой последовательности будет 0 и во второй последовательности битов первый бит будет 0, то после выполнения этой операции получится значение 0. 

Точно так же и с каждым последующим битом. Предположим, у нас есть две последовательности:

00100101

00111010

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

00100000

Естественно, передавать значения можно и в десятичной форме. В таком случае они будут преобразованы в двоичную и выполнены соответствующие вычисления. А потом они снова будут преобразованы в десятичную систему. 

Например, если выполнить побитовое «И» с числами 2 и 3, то получится две последовательности битов в двоичной форме:

10

11

Если сопоставить с таблицей выше, то после побитового И будет выдан следующий результат:

10.

То есть, на вывод уйдет цифра 2, поскольку после выполнения операции побитового И 1 и 1 дали 1, а 0 и 1 дали 0. В результате, получилось значение 10, что соответствует 2.

По аналогичному принципу работают и другие бинарные операторы.

Бинарное ИЛИ (|). Соответствует побитовой операции or. 

Общая таблица сопоставления битов с использованием этого оператора следующая.

0 | 0 = 0

0 | 1 = 1

1 | 0 = 1

1 | 1 = 1

То есть, если ввести такую строку кода, получится на выходе 3.

>>> 2|3

Почему? Потому что эти две десятичные цифры переводятся в следующие две последовательности.

10

11

1 на 1 дает 1, и 0 на 1 дает 1. Соответственно, получилось число 11 в двоичной форме, что соответствует 3 в десятичной. Поэтому такой вывод.

Бинарное ИЛИ НЕТ (^). С помощью этой функции выполняется исключающее между двумя операндами, переведенными в двоичную форму. Сопоставление осуществляется по таким правилам.

0 ^ 0 = 0

0 ^ 1 = 1

1 ^ 0 = 1

1 ^ 1 = 0

Таким образом, если выполнить соответствующую операцию с теми же самыми числами, то получится в результате 1. Ведь цифра 2 у нас 10, а 11 – это 3. Таким образом, если сопоставить разряды по правилам, получится в итоге 01.

>>> 2^3

10

11

––

01

Инвертирующий оператор. С его помощью пользователь может инвертировать 0 в 1 и наоборот.

Например, если применить его к 2, то получится в результате -3. Почему? Потому что в двоичном формате цифра 2 – это 00000010. Если же ее инвертировать, то получится 11111101, что соответствует двоичной -3. Таким образом, получится в итоге обычная 2. 

Естественно, работает все и абсолютно наоборот. Ведь если 11111101 заменить на противоположные значения, то получится на выходе та же цифра 3.

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

И такой принцип дальше. То есть, первый операнд – это то число, сдвиг которого надо осуществить. Второй же операнд – количество бит, на которое необходимо его выполнить.

Пример.

>>> 3>>2

>>> 3>>1

Сложные числа

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

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

Чтобы создать комплексное число в Python, вы просто пишете действительную часть, затем знак плюс, затем мнимую часть с буквой в конце:

Когда вы проверите значение , вы заметите, что Python заключает число в круглые скобки:

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

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

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

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

Для любого комплексного числа его сопряжение – это комплексное число с одинаковой действительной и мнимой частью, одинаковое по модулю, но с противоположным знаком. Итак, в этом случае комплексное сопряжение равно .

За исключением оператора floor division (), все арифметические операторы, которые работают с числами с плавающей запятой и целыми числами, также будут работать с комплексными числами. Поскольку это не углубленное изучение математики, мы не будем обсуждать механику сложной арифметики. Вместо этого вот несколько примеров использования комплексных чисел с арифметическими операторами:

Интересно, хотя и не удивительно с математической точки зрения, объекты и также имеют свойства и , а также метод :

Для чисел с плавающей запятой и целых чисел и всегда возвращают само число, а всегда возвращает 0. Однако следует отметить, что и возвращают целое число, если является целым числом и число с плавающей запятой, если – число с плавающей точкой.

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

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

Математические операторы Python 3

Оператор – это символ, которая обозначает операцию. Например, в математике знак плюса или + – это оператор сложения.

Мы рассмотрим схожие операторы, которые перешли в Python из математики. Но другие операторы специфичны именно для программирования.

Ниже представлена таблица с кратким обзором математических операторов, доступных в Python.

Операция	Возвращаемое значение
x + y	Сумма x и y.
x — y	Разность x и y.
-x	Изменение знака x.
+x	Тождественность x.
x * y	Произведение x и y.
x / y	Частное от деления x на y.
x // y	Частное от целочисленного деления x на y.
x % y	Остаток от деления x / y.
x ** y	x в степени y.

Умножение и деление в питоне

Оператор, которые мы будем использовать в Python для умножения «*», а для деления «/». Пример умножения двух чисел с плавающей точкой в Python:

k = 100.1
l = 10.1
print(k * l)

Вывод

1011.0099999999999

Когда вы выполняете деление в Python 3, частное всегда будет числом с плавающей точкой, даже если вы используете два целых числа:

m = 80
n = 5
print(m / n)

Вывод

16.0

Это одно из наиболее существенных отличий Python 2 от Python 3. В Python 3 результатом будет дробное число. Поэтому, когда вы используете оператора «/» для деления 11 на 2, возвращено будет 5.5. В Python 2 возвращаемое значение деления 11 / 2 было 5.

В Python 2 оператор «/» выполняет целочисленное деление, где частное x, а возвращаемое число – это наибольшее целое число, меньшее или равное x. Если вы выполните пример, приведённый выше, в Python 2, то получите 16 без десятичной точки.

Целочисленное деление python 3 использует оператор «//». Выражение 100 // 40 вернёт значение 2.

Деление (/)

Сложение, вычитание и умножение тривиальны, а вот с делением не всё так просто. В Python существует три вида деления и столько же разных операторов. Начнём с истинного деления, за которое отвечает оператор «». Его главным отличием является то, что, вне зависимости от типов операндов, будет возвращен вещественный результат ().

Этот вид деления наиболее близок к обычному и знакомому нам математическому. И здесь тоже нельзя делить на ноль:

Немного истории. В старых версиях Питон оператор «/» выполнял операцию классического деления: т.е. он делил целочисленно и усекал дробную часть в том случае, когда делимое и делитель были целыми. Если же операнды принадлежали к множеству вещественных чисел, то проводилось деление с сохранением дробной части, и результат был float.

Разработчики отказались от классического деления в Python 3.0 и вместо него добавили истинное деление. Архитекторы языка пошли на такой шаг по той причине, что в предыдущей модели классического деления результаты напрямую зависели от типов операндов. Из-за этого возникали трудности с их предварительной идентификацией и оценкой, что было особенно критично для Питона, как для языка с динамической типизацией.

Кавычки

Одинарные кавычки

Строку можно указать, используя одинарные кавычки, как например, ‘Это строка’.  Любой одиночный символ в кавычках, например,  ‘ю’  — это строка. Пустая строка » — это тоже строка. То есть строкой мы считаем всё, что находится внутри кавычек.

Двойные кавычки

Запись строки в одинарных кавычках  это не единственный способ. Можно использовать и двойные кавычки, как например, »Это строка».  Для интерпретатора разницы между записями строки в одинарных и двойных кавычках нет.  

ВниманиеЕсли  строка началась с двойной кавычки — значит и закончиться должна на двойной кавычке. Если внутри строки мы хотим использовать двойные кавычки, то саму строку надо делать в одинарных кавычках. 

Театр »Современник»print(‘Театр »Современник»’)

Тройные кавычки

Строка, занимающая несколько строк,  должна быть обрамлена тройными кавычками (» » »  или »’).  Например:

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

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

Меньше. Соответствует математическому знаку «меньше». С его помощью программа сравнивает два значения. Если первое оказывается меньше второго, то выдает логическое значение True.

>>> 4<3

False

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

>>> 4>3

True

Меньше или равно. Проверяет два условия:

1. Левая часть меньше правой, или нет?
2. Являются ли левая и правая части одинаковыми.

Если да, она возвращает True. То есть, должно соблюдаться или первое условие или второе.

>>> 7<=7

True

В этом примере мы видим, что число 7 равняется числу 7. Соответственно, программа выводит результат «истина». Ничего удивительного!

Больше или равно. Противоположный предыдущему оператор, возвращающий значение «истина» при соблюдении одного из этих условий:

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

Синтаксис такой же самый, только вместо знака < используется знак >. Приведем пример для наглядности.

>>> 0>=0

True

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

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

Давайте приведем несколько примеров, чтобы было более понятно, как этот оператор работает с различными операндами. Сначала пишется строка кода, а сразу вслед за ней – вывод.

>>> 3==3.0

True

>>> 1==True

True

>>> 7==True

False

>>> 0==False

True

>>> 0.5==True

False

Не равно. Этот арифметический символ также не выглядит, как зачеркнутый знак равно, как в математике. Этот оператор состоит из двух частей – восклицательного знака и математического знака «равно». То есть, он выглядит, как !=. 

Полностью противоположный оператору «равно» символ. Если этот оператор обнаруживает, что операнды одинаковые, он возвращает значение «ложь», а не «истина», как в случае с оператором равенства.

>>> 1!=1.0

False

Раньше была еще одна версия этого оператора – <>. Но сейчас она не используется, поскольку была убрана в Python третьей версии.

Дополнительные методы и операции в Python

В эти операции входят:
• int.bit_length() — количество бит, которое необходимо, чтобы представить число в двоичном виде без учёта лидирующих нулей и знака;
• int.to_bytes(length, byteorder, *, signed=False) — метод возвращает строку байтов, которые представляют это число;
• classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращение числа из заданной строки байтов.

Пример работы последнего метода:

>>>
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes(, byteorder='big')
16711680

Поезд / тестовый сплит

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

Мы можем легко разделить набор данных следующим образом:

Вот,Yпросто цель (ядовитая или съедобная). Затем,Иксэто просто все особенности набора данных. Наконец, мы используемtrain_test_splitфункция.test_sizeПараметр соответствует части набора данных, которая будет использоваться для тестирования. Обычно мы используем 20%. Затемrandom_stateПараметр используется для воспроизводимости. Он может быть установлен на любое число, но он гарантирует, что при каждом запуске кода набор данных будет разделен одинаково. Если нетrandom_stateпри условии, что поезд и набор тестов будут различаться, так как функция разбивает их случайным образом.

Хорошо, мы официально готовы начать моделирование и делать прогнозы!

Таблица «Функции и методы строк»

Функция или метод	Назначение
S = ‘str’; S = «str»; S = »’str»’; S = «»»str»»»	Литералы строк
S = «s\np\ta\nbbb»	Экранированные последовательности
S = r»C:\temp\new»	Неформатированные строки (подавляют экранирование)
S = b»byte»	Строка байтов
S1 + S2	Конкатенация (сложение строк)
S1 * 3	Повторение строки
S	Обращение по индексу
S	Извлечение среза
len(S)	Длина строки
S.find(str, ,)	Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.rfind(str, ,)	Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.index(str, ,)	Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.rindex(str, ,)	Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.replace(шаблон, замена)	Замена шаблона на замену. maxcount ограничивает количество замен
S.split(символ)	Разбиение строки по разделителю
S.isdigit()	Состоит ли строка из цифр
S.isalpha()	Состоит ли строка из букв
S.isalnum()	Состоит ли строка из цифр или букв
S.islower()	Состоит ли строка из символов в нижнем регистре
S.isupper()	Состоит ли строка из символов в верхнем регистре
S.isspace()	Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы (‘\f’), «новая строка» (‘\n’), «перевод каретки» (‘\r’), «горизонтальная табуляция» (‘\t’) и «вертикальная табуляция» (‘\v’))
S.istitle()	Начинаются ли слова в строке с заглавной буквы
S.upper()	Преобразование строки к верхнему регистру
S.lower()	Преобразование строки к нижнему регистру
S.startswith(str)	Начинается ли строка S с шаблона str
S.endswith(str)	Заканчивается ли строка S шаблоном str
S.join(список)	Сборка строки из списка с разделителем S
ord(символ)	Символ в его код ASCII
chr(число)	Код ASCII в символ
S.capitalize()	Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.center(width, )	Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.count(str, ,)	Возвращает количество непересекающихся вхождений подстроки в диапазоне (0 и длина строки по умолчанию)
S.expandtabs()	Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.lstrip()	Удаление пробельных символов в начале строки
S.rstrip()	Удаление пробельных символов в конце строки
S.strip()	Удаление пробельных символов в начале и в конце строки
S.partition(шаблон)	Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.rpartition(sep)	Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.swapcase()	Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.title()	Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.zfill(width)	Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.ljust(width, fillchar=» «)	Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
S.rjust(width, fillchar=» «)	Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
S.format(*args, **kwargs)	Форматирование строки

Идентификационные операторы

Python provides two operators, and , that determine whether the given operands have the same identity—that is, refer to the same object. This is not the same thing as equality, which means the two operands refer to objects that contain the same data but are not necessarily the same object.
Here is an example of two object that are equal but not identical:

>>> x = 1001
>>> y = 1000 + 1
>>> print(x, y)
1001 1001
>>> x == y
True
>>> x is y
False

Here, and both refer to objects whose value is . They are equal. But they do not reference the same object, as you can verify:

>>> id(x)
60307920
>>> id(y)
60307936

and do not have the same identity, and returns .
You saw previously that when you make an assignment like , Python merely creates a second reference to the same object, and that you could confirm that fact with the function. You can also confirm it using the operator:

>>> a = 'I am a string'
>>> b = a
>>> id(a)
55993992
>>> id(b)
55993992
>>> a is b
True
>>> a == b
True

In this case, since and reference the same object, it stands to reason that and would be equal as well.
Unsurprisingly, the opposite of is :

>>> x = 10
>>> y = 20
>>> x is not y
True

Логистическая регрессия

Сначала мы будем использовать логистическую регрессию. На следующих этапах мы будем использовать область под кривой ROC и матрицу путаницы в качестве метрик ошибок.

Давайте сначала импортируем все, что нам нужно:

Затем мы делаем примерЛогистическая регрессияОбъект и пример модели для учебного набора:

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

Также вам нужно напомнить, что логистическая регрессия возвращает вероятность. А пока давайте установим порог на 0,5. Таким образом, если вероятность больше 0,5, гриб будет классифицирован как ядовитый. Конечно, если вероятность меньше порога, гриб классифицируется как съедобный.

Это именно то, что происходит в ячейке кода ниже:

Обратите внимание, что мы рассчитали вероятности на тестовом наборе. Теперь давайте посмотримМатрица путаницы.Это покажет нам истинно положительные, истинно отрицательные, ложноположительные и ложно отрицательные показатели

Теперь давайте посмотримМатрица путаницы.Это покажет нам истинно положительные, истинно отрицательные, ложноположительные и ложно отрицательные показатели.

Пример путаницы

Мы выводим нашу матрицу путаницы следующим образом:

И вы должны получить:

Удивительно! Наш классификатор идеален! Из приведенной выше матрицы путаницы вы видите, что наши ложноположительные и ложноотрицательные показатели равны 0, что означает, что все грибы были правильно классифицированы как ядовитые или съедобные!

Давайте напечатаем область под кривой ROC. Как известно, для идеального классификатора он должен быть равен 1.

Действительно, кодовый блок выше выводит 1! Мы можем сделать нашу собственную функцию для визуализации кривой ROC:

И вы должны увидеть:

Кривая ROC

Поздравляем! Вы создали идеальный классификатор с базовой моделью логистической регрессии.

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

Логические операторы

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

Оператор	Значение
and	Оператор «и»: выражение истинно, если оба его компонента истинны.
or	Оператор «или»: выражение истинно, если хотя бы один из его компонентов истинен.
not	Оператор «не»: изменяет логическое значение компонента на противоположное.

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

• сдал ли студент экзамен
• и зарегистрирован ли он.

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

Другой пример: программа с логическими операторами может проверять активность пользователя в онлайн-магазине:

• использовал ли он кредит магазина
• или заказывал ли он товары в течение последних 6 месяцев.

Для примера попробуйте сравнить три выражения:

В первом случае оба выражения истинны, потому оператор and возвращает True.

Во втором случае истинно только значение 8 == 8. Поскольку хотя бы одно из предложенных условий истинно, оператор or возвращает True. Оператор and в таком случае выдал бы False.

В третьем случае выражение 3 <= 1 ложно. Оператор not изменяет полученное логическое значение на противоположное: not False = True.

Теперь попробуйте сравнить числа с плавающей точкой.

• Поскольку в первом примере одно из выражений ложно, and вернёт False. Оператор and оценивает выражение как истинное только тогда, когда оба компонента истинны.
• Поскольку оба выражения ложны, оператор or выдаст False.
• Поскольку выражение истинно, оператор not вернёт False (not True = False).

Примечание: Если вы не понимаете, как это работает, вам помогут разобраться таблицы истинности. Эту тему мы рассмотрим далее в этом руководстве.

Логические операторы можно объединять в составные выражения:

Выражение (0.8 < 3.1) or (0.1 == 0.1) истинно, поскольку оба математических выражения, из которых оно состоит, истинны. Оператор or вернёт True.

Полученное значение True становится компонентом следующего выражения: (-0.2 > 1.4) and (True). Оператор and выдаст False, потому что выражение -0.2 > 1.4 ложно. (False) and (True) = False.

Далее оператор not заменит полученное значение False на обратное ему логическое значение: not(False) = True. Значит, результат будет таким:

Комплексные числа в Python (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)

Кроме того, для работы с complex может применяться модуль cmath.

На этом пока что всё. Следите за новостями и не забывайте оставлять свои комментарии!

Операторы принадлежности

С помощью этих операторов можно определить, входят ли значения в определенную последовательность. Она может быть любой – строкой, списком или кортежем. К этой категории относится всего два оператора – in и not in.

In. С английского переводится, как «В». Соответственно, с помощью этого оператора осуществляется проверка, является ли определенное значение частью последовательности списка, кортежа или строки. 

Хотя принцип прост, покажем пример для наглядности. 

>>> pets=

>>> ‘fox’ in pets

Попробуйте определить, какое значение будет возвращено в этой ситуации. Правильный ответ – «False». Почему? Да, fox – это действительно лиса, и она является животным. Но она не входит в список домашних питомцев, куда относятся только собаки, коты и хорьки. Поэтому возвращается значение «ложь».

Если же написать такую строку, то будет возвращено «истина».

>>> ‘cat’ in pets

Почему? Потому что кот есть в списке питомцев. 

Теперь приведем пример проверки вхождения фразы в строку.

>>> ‘me’ in ‘disappointment’

Какой вывод будет у этой фразы? Правильно, «истина», потому что слог «me» в этом слове есть.

Not in. Этот оператор выполняет противоположное действие. Оно возвращает значение «истина» исключительно в случае, если не входит в состав последовательности та конструкция, которая находится в первом операнде.

Если бы мы в примерах выше использовали этот оператор, то были бы выданы такие результаты:

1. Если бы мы проверяли вхождение лисы в перечень домашних питомцев, то было бы выдано значение True, потому что она не входит. 
2. Если бы мы проверяли вхождение кота в этот список, было бы возвращено значение false, поскольку он также не входит. 
3. Если бы мы проверяли факт вхождения слога «me» в слово «disappointment», то был бы выдан ответ false. 

То есть, эти операторы работают полностью противоположным друг другу образом. 

Арифметические Операторы

В следующей таблице перечислены арифметические операторы, поддерживаемые Python:

Оператор
Пример
Смысл
Результат

 (unary)

Положительное значение

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

 (binary)

Сложение
Сумма и

 (unary)

Отрицательное значение
Значение равно с обратным знаком

 (binary)

Вычитание

вычитается из

Умножение
Перемножение и

Деление
Частное от деления на . Результат всегда относится к типу .

Модуль
Остаток от деления на

Округляющее деление(также называется Целочисленное деление)
Частное от деления на , округлённое до ближайшего минимального целого

Степень
Возведение в степень

 
Вот несколько примеров использования этих операторов:

>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64

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

>>> 10 / 5
2.0
>>> type(10 / 5)
<class 'float'>

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

>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2

Кстати, заметьте, что в сеансе REPL можно увидеть результат вычисления выражения просто набрав его после подсказки не испольуя оператор , точно так же можно увидеть знчение переменной:

>>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106

Оператор деления

Деление в Python обозначается косой чертой «/». Примечательно, что результат в консоле всегда приводится к типу «float», даже если оба операнда были целочисленного типа, об этом свидетельствует появление «.0» у полученного значения.

Это появилось в 3-ей версии Python, ранее результатом деления целых чисел было только целое число, чтобы получить дробный результат, программисты явно указывали одному из операндов тип «float», в противном случае дробная часть просто отбрасывалась.

Важно понимать, что деление в Python, как и другие операции, работает медленнее, чем в более низкоуровневых языках программирования. Это связано с высоким уровнем автоматизации и абстракции, из-за динамической типизации интерпретатор вынужден приводить числа к дробному типу «float», который требует большего количества памяти

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

Примеры:

print(int(1) / int(2))
print(5 / 5)
print(1 / 3)

0.5
1.0
0.3333333333333333

Из примера видно, что не смотря на то, что во всех случаях операция была между целыми числами, результатом деления в Python 3 является вещественное число. В первом случае мы даже специально использовали приведение к типу int.

Дополнительно хотелось бы отметить, что если точности типа данных float не достаточно, можно воспользоваться библиотекой decimal. В частности мы её использовали при написании программы «калькулятор» в отдельной статье.