Лекция: числа. модули, графики

Функция преобразования углов

У внимательного читателя мог на предыдущем этапе появиться вопрос: а что, если я не знаю, сколько радиан в угле? Я знаю только количество градусов. Ничего страшного, ведь библиотека math поддерживает возможность конвертации радиан в градусы и наоборот. 

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

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

Запомнить очень просто. То, что мы хотим получить, так и называется функция.

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

Функция sqrt() — квадратный корень

Функция sqrt() вычисляет и возвращает значение квадратного корня из переданного десятичного числа.

Синтаксис:

decimal.Decimal(decimal-number).sqrt()

Пример:

import decimal as d

d.getcontext().prec = 3

val = d.Decimal(122.20)
sqrt = val.sqrt()
print("Decimal Number: ",val)
print("Square root of the decimal number: ",sqrt)

Выход:

Decimal Number:  122.2000000000000028421709430404007434844970703125
Square root of the decimal number:  11.1

Снова обратите внимание, как объявленное значение содержит полное десятичное число, в то время как вычисленное значение соответствует нашему набору точности из 3 цифр

Тригонометрические функции

В Python есть следующие тригонометрические функции.

Функция	Значение
	принимает радиан и возвращает его синус
	принимает радиан и возвращает его косинус
	принимает радиан и возвращает его тангенс
	принимает один параметр и возвращает арксинус (обратный синус)
	принимает один параметр и возвращает арккосинус (обратный косинус)
	принимает один параметр и возвращает арктангенс (обратный тангенс)
	принимает один параметр и возвращает гиперболический синус
	принимает один параметр и возвращает гиперболический косинус
	принимает один параметр и возвращает гиперболический тангенс
	принимает один параметр и возвращает обратный гиперболический синус
	принимает один параметр и возвращает обратный гиперболический косинус
	принимает один параметр и возвращает обратный гиперболический тангенс

Пример:

Вывод:

Функции представления чисел

ceil() и floor() — целая часть числа

и — функции общего назначения. Функция ceil округляет число до ближайшего целого в большую сторону. Функция floor убирает цифры десятичных знаков. Обе принимают десятичное число в качестве аргумента и возвращают целое число.

Пример:

Вывод:

Функция fabs() — абсолютное значение

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

Пример:

Вывод:

factorial() — функция факториала

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

Пример:

Вывод:

Примечание: при попытке использовать отрицательное число, возвращается ошибка значения ().

Пример:

Вывод:

Функция fmod() — остаток от деления

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

Пример:

Вывод:

Функция frexp()

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

Пример:

Вывод:

Функция fsum() — точная сумма float

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

Пример:

Вывод:

Функции возведения в степень и логарифма

Эта функция принимает один параметр в виде дробного числа и возвращает .

Пример:

Вывод:

Эта функция работает так же, как и , но возвращает . Здесь, значит , то есть, .

Пример:

Вывод:

Функция log() — логарифм числа

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

Пример:

Вывод:

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

Пример:

Вывод:

Вычисляет логарифм по основанию 10.

Пример:

Вывод:

Функция pow() — степень числа

Используется для нахождение степени числа. Синтаксис функции . Она принимает два аргумента: основание и степень.

Пример:

Вывод:

Функция sqrt() — квадратный корень числа

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

Пример:

Вывод:

Функция exp() — вычисление экспоненты

Функция вычисляет значение экспоненты, то есть e ^ x конкретного числа переданной десятичной точки.

Синтаксис:

decimal.Decimal(decimal-number).exp()

Пример:

import decimal as d

d.getcontext().prec = 5

#Intializing with an addition operation
val = d.Decimal(12.201) + d.Decimal(12.20)

#Calculating exponential of the decimal value
exp = val.exp()

#variable with no calculations
no_math = d.Decimal(1.131231)

print("Sum: ",val)
print("Exponential: ", exp)
print(no_math)

Выход:

Decimal Number:  24.401                                                                                                       
3.9557E+10                                                                                                                    
1.131231000000000097571728474576957523822784423828125   

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

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

Эти операторы присваивают значение правого операнда левому. Только один-единственный оператор просто присваивает значение — это знак «=» (равно). Все остальные предварительно выполняют какое-либо арифметическое действие между двумя операндами, и получившийся результат записывается в левый операнд.

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

Копировать

Значение переменной b складывается со значением переменной a, после чего результат записывается в a:

Копировать

Значение переменной b вычитается из значения переменной a, после чего результат записывается в a:

Копировать

Значение переменной a делится на значение переменной b, после чего результат записывается в a:

Копировать

Значение переменной a умножается на значение переменной b, после чего результат записывается в a:

Копировать

Значение переменной a делится на значение переменной b, после чего остаток от деления записывается в a:

Копировать

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

Значение переменной a возводится в степень, равную значению переменной b, после чего результат записывается в a:

Копировать

Деление с остатком и присваивание

Значение переменной a делится на значение переменной b, после чего целая часть результата деления записывается в a:

Копировать

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

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

Сложение. Соответствует математическому знаку +. Выполняет стандартную арифметическую операцию сложения. Синтаксис функции такой же, как и в математике: операнд 1 + операнд 2.

Например.

>>> 4+4

Вывод: 8.

Вычитание. Выполняет стандартную арифметическую операцию вычитания. Первый операнд – это первое число, а второй – это второе число соответственно. Сам оператор выглядит точно так же, как и математический знак минуса.

>>> 3-4

-1

Умножение. Умножает первое число на такое количество раз, которое указано во втором числе. 

Также в качестве операнд, как и во всех остальных случаях, могут использоваться переменные. В этом случае осуществляется умножение переменной 1 на переменную 2. 

>>> 5*5

25

Деление. Последовательность действий такая же самая, как и с умножением: сначала идет операнд 1, потом знак деления (/), а потом – операнд 2.

>>> 3/4

0.75 

Возведение в степень. Берет число 1 и возводит в степень числа 2.

>>> 3**4

81

Деление без остатка. Все мы знаем, что после деления может оставаться остаток, если не получается разделить число на другое число непосредственно. С помощью этого оператора мы можем получить целое число, если разделить напрямую не получается. Например.

>>> 4//3

1

>>> 10//3

3

Деление по модулю. Выполняет похожую операцию на предыдущий пример, только возвращает как раз остаток. Этот оператор – знак процента, который находится между операндами. Например:

>>> 3%4

3

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

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

x + y	Сложение
x — y	Вычитание
x * y	Умножение
x / y	Деление
x // y	Получение целой части от деления
x % y	Остаток от деления
-x	Смена знака числа
abs(x)	Модуль числа
divmod(x, y)	Пара (x // y, x % y)
x ** y	Возведение в степень
pow(x, y)	xy по модулю (если модуль задан)

Также нужно отметить, что целые числа в 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)
>>> 3 ** 150
369988485035126972924700782451696644186473100389722973815184405301748249

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

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

x | y	Побитовое или
x ^ y	Побитовое исключающее или
x & y	Побитовое и
x << n	Битовый сдвиг влево
x >> y	Битовый сдвиг вправо
~x	Инверсия битов

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

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'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
b'\xe8\x03'

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

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

Побитовые python операторы работают только с целыми числами, причём особым образом: значения операндов переводятся в двоичную систему, после чего операция выполняется последовательно для каждого бита. После окончания операции значение переводится обратно в десятичную систему и может быть возвращено в качестве результата операции.

Всего в питон 6 побитовых операторов:

• & — бинарное «и»
• | — бинарное «или»
• ^ — бинарное «или нет» (исключающее ИЛИ, или XOR)
• ~ — инвертирующий оператор (отрицание, для него требуется только один операнд)
• << — бинарный сдвиг влево
• >> — бинарный сдвиг вправо

Мне нравится1Не нравится

Целые числа и числа с плавающей запятой

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

Целые числа

Целое число – это целое число без десятичных знаков. Например, 1 – целое число, а 1.0 – нет. Имя для целочисленного типа данных – , которое вы можете увидеть с помощью :

Вы можете создать целое число, набрав желаемое число. Например, следующее присваивает переменной целое число 25:

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

Возможно, вы уже знакомы с тем, как преобразовать строку, содержащую целое число, в число с помощью . Например, следующее преобразует строку «25» в целое число 25:

не является целочисленным литералом, потому что целое значение создается из строки.

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

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

Нет предела тому, насколько большим может быть целое число, что может быть удивительно, учитывая, что компьютеры имеют конечный объем памяти. Попробуйте ввести наибольшее число, которое вы можете придумать, в интерактивном окне IDLE. Python справится с этим без проблем!

Числа с плавающей запятой

Число с плавающей запятой(floating-point number) или сокращенно с плавающей запятой(float) – это число с десятичной запятой. 1.0 – это число с плавающей запятой, как и -2.75. Имя типа данных с плавающей запятой – float:

Как и целые числа, числа с плавающей запятой можно создавать из литералов с плавающей запятой(floating-point literals) или путем преобразования строки в число с плавающей запятой с помощью функции :

Есть три способа представить литерал с плавающей запятой. Каждое из следующих действий создает литерал с плавающей запятой со значением один миллион:

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

Чтобы написать литерал с плавающей запятой в нотации E, введите число, за которым следует буква e, а затем другое число. Python берет число слева от e и умножает его на 10, возведенное в степень числа после e. Итак, эквивалентно 1 × 10⁶.

Python также использует нотацию E для отображения больших чисел с плавающей запятой:

Число с плавающей запятой 200000000000000000.0 отображается как . Знак указывает, что показатель степени является положительным числом. Вы также можете использовать отрицательные числа в качестве показателя степени:

Литерал интерпретируется как в степени , что составляет 1/10000 или 0,0001.

В отличие от целых чисел, числа с плавающей запятой имеют максимальный размер. Максимальное число с плавающей запятой зависит от вашей системы, но что-то вроде должно выходить за рамки возможностей большинства машин. составляет 2 × 10⁴⁰⁰, что намного больше, чем общее количество атомов во Вселенной!

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

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

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

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

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

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

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

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

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

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

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

float.is_integer() — является ли значение целым числом.

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

classmethod float.fromhex(s) — float из шестнадцатеричной строки.

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

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

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

Преимущества

Есть различные преимущества генераторов. Некоторые из них приведены ниже:

Легко реализовать

Генераторы проще реализовать по сравнению с итератором. В итераторе мы должны реализовать функцию __iter __() и __next __().

Эффективная память

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

Генератор бесконечной последовательности – отличный пример оптимизации памяти. Давайте обсудим это в приведенном ниже примере, используя функцию sys.getsizeof().

 
import sys 
# List comprehension 
nums_squared_list =  
print(sys.getsizeof("Memory in Bytes:"nums_squared_list)) 
# Generator Expression 
nums_squared_gc =(i ** 2 for i in range(1000)) 
print(sys.getsizeof("Memory in Bytes:", nums_squared_gc)) 

Выход:

Memory in Bytes: 4508 
Memory in Bytes: 56 

Из вышеприведенного вывода видно, что для  list comprehension используется 4508 байт памяти, тогда как generator expression использует 56 байт памяти. Это означает, что объекты-генераторы намного эффективнее, чем сжатие списков.

 Конвейерная обработка с помощью генератора

Data Pipeline предоставляет возможность обрабатывать большие наборы данных или поток данных без использования дополнительной памяти компьютера.

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

 
with open('sells.log') as file: 
burger_col =(line for line in file)  per_hour =(int(x) for x in burger_col if x != 'N/A') 
print("Total burgers sold = ",sum(per_hour)) 

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

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

 
def infinite_sequence(): 
    num = 0 
    while True: 
        yield num 
            num += 1 
 
for i in infinite_sequence(): 
    print(i) 

Выход:

0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 
......... 
.......... 
315 
316 
317 
Traceback(most recent call last): 
  File "C:\Users\DEVANSH SHARMA\Desktop\generator.py", line 33, in <module>
    print(i) 
KeyboardInterrupt 

В этом руководстве мы узнали о генераторах Python.

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Синтаксис функции квадратного корня Python

Общий синтаксис, используемый для вызова sqrt()функции:

В приведённом выше фрагменте кода «x» — это число, квадратный корень которого вы хотите вычислить. Число, которое вы передаёте в качестве параметра функции извлечения квадратного корня, может быть больше или равно 0

Обратите внимание, что вы можете передать только одно число

Но к чему относится «математическая» часть синтаксиса выше? Математический модуль — это библиотека Python, которая содержит множество полезных математических функций, одна из которых является sqrt()функцией. Для использования sqrt()вам нужно будет импортировать математический модуль, поскольку именно там хранится код для выполнения функции. Приставляя «math» к префиксу sqrt(), компилятор знает, что вы используете функцию sqrt(), принадлежащую библиотеке «math».

Способ импорта математического модуля состоит в том, чтобы написать ключевое слово «импорт» вместе с именем модуля — в данном случае «математика». Оператор импорта — это простая строка, которую вы пишете перед кодом, содержащим sqrt()функцию:

Результатом функции извлечения квадратного корня является число с плавающей запятой (float). Например, результатом использования sqrt()81 будет 9,0, что является числом с плавающей запятой.

Включите математический оператор импорта в начало любого сеанса файла или терминала / консоли, который содержит код, который использует sqrt().

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

В Python любое число, состоящее из десятичных цифр без префикса, интерпретируется как десятичное число типа .

Целые числа в Python представлены только одним типом — PyLongObject, реализация которого лежит в longobject.c, а сама структура выглядит так:

Любое целое число состоит из массива цифр переменной длины, поэтому в Python 3 в переменную типа может быть записано число неограниченной длины. Единственное ограничение длины — это размер оперативной памяти.

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

• 0b (0B) – для двоичного представления;
• 0o (0O) – для восьмеричного представления;
• 0x (0X) – для шестнадцатеричного представления.

7.6. Прочие математические разделы

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

7.6.1. Множества

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

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

Функция unique() так же позволяет получить индексы входного массива с первым вхождением уникальных элементов, а так же индексы уникального массива которые восстанавливают исходный массив:

Так же имеется ряд других полезных функций:

7.6.2. Логические операции

Логические функции NumPy, условно, можно разделить на два множества: первое — позволяет определять специфику элементов массива и самого массива; второе — обычные логические операции которые действуют над массивами поэлементно.

Иногда, возникает потребность определить тип элементов:

Привычные нам логические операции выполняются над массивами булевых значений (массивы из значений True и False ):

Помимо всего прочего, NumPy позволяет производить различные сравнения:

7.6.3. Многочлены

Многочлены, довольно часто, встречаются в самых разных областях: физика, инженерное дело, теория приближений, криптография, теория вероятностей, комбинаторика и т.д. Многочлены определенного вида выделяются в особые классы, каждый из которых имеет свою нишу применения. В NumPy представлены функции для работы с классами многочленов Чебышёва, Лежандра, Лагерра и Эрмита. Помимо прочего, NumPy предоставляет широкий набор функций для работы с полиномами в общем виде, т.е. полиномы любого вида (Бернулли, Гегенбауэра, Шапиро, Якоби, Роджерса в том числе) могут быть легко сконструированы пользователем самостоятельно.

Рассмотрим базовые функции для работы с полиномами:

Иногда бывает крайне удобно создавать полиномы не указывая их коэфициенты, а указывая их корни:

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

9432 просмотра

1 ответ

83 Репутация автора

Я пытаюсь построить сложную матрицу в Python и столкнулся с некоторыми проблемами. Я использую scipy.linalg.expm функцию, и у меня появляется довольно странное сообщение об ошибке при попытке следующего кода:

Ошибка при запуске второго эксперимента:

Это кажется действительно странным, поскольку все, что я изменил, — это диапазон, который t я использовал. Это потому, что гамильтониан диагональн? В общем, гамильтонианов не будет, но я также хочу, чтобы он работал для диагональных. Я на самом деле не знаю механику expm , поэтому любая помощь будет принята с благодарностью.

Ответы (1)

3 плюса

48935 Репутация автора

Это интересно. Одно могу сказать, что проблема специфична для np.matrix подкласса. Например, следующее прекрасно работает:

Если углубиться в трассировку, то возникает исключение, _fragment_2_1 в scipy.sparse.linalg.matfuncs.py частности эти строки :

Сообщение об ошибке

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

Установка точки останова и проверка формы этих переменных подтверждает это:

3 Логарифмические функции

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

• decimal.ln();
• decimal.log10().

Функция возвращает значение натурального десятичного числа, как показано ниже.

decimal.Decimal(decimal-number).ln()

Функция decimal.log10() используется для вычисления значения журнала по основанию 10 переданного ей десятичного числа.

decimal.Decimal(decimal-number).log10()

Пример:

import decimal as d

d.getcontext().prec = 2

val = d.Decimal(122.20)

log = val.ln()
print("Natural log value of the decimal number: ",log)

log_10 = val.log10()
print("Log value with base 10 of the decimal number: ",log_10)

Выход:

Natural log value of the decimal number:  4.8
Log value with base 10 of the decimal number:  2.1

Работа с отрицательными числами с помощью abs ()

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

abs()Функция возвращает абсолютное значение заданного числа. Абсолютное значение −9 будет 9. Аналогично, абсолютное значение 9 равно 9. Поскольку sqrt()оно предназначено для работы с положительными числами, отрицательное число вызовет исключение ValueError.

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

Или, альтернативно:

abs()Функция будет принимать в своём значении и перевести его к абсолютному значению (81 в данном случае). Затем в sqrt()функцию будет передано неотрицательное абсолютное значение, что нам и нужно, чтобы не получить надоедливых ошибок!

Прямой метод

Самый прямой метод вычисления модульной экспоненты — это вычислить b e напрямую, а затем взять это число по модулю m . Рассмотрим попытку вычислить c , учитывая b = 4 , e = 13 и m = 497 :

c ≡ 4 13 (мод. 497)

Можно использовать калькулятор для вычисления 4 13 ; получается 67 108 864 человека. Взяв это значение по модулю 497, ответ c определяется как 445.

Обратите внимание, что длина b составляет только одну цифру, а длина e — всего две цифры, но значение b e составляет 8 цифр.

В сильной криптографии b часто составляет не менее 1024 бит . Рассмотрим b = 5 × 10 76 и e = 17 , оба из которых являются вполне разумными значениями. В этом примере длина b составляет 77 цифр, а длина e — 2 цифры, но значение b e имеет длину 1304 десятичных цифры. Такие вычисления возможны на современных компьютерах, но сама величина таких чисел приводит к значительному снижению скорости вычислений. По мере того, как b и e увеличиваются еще больше, чтобы обеспечить лучшую безопасность, значение b e становится громоздким.

Время, необходимое для выполнения возведения в степень, зависит от операционной среды и процессора. Описанный выше метод требует для завершения O ( e ) умножений.

Вывод

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

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

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

Целые и вещественные числа. Математические операции и вывод результата

Если мы рассматриваем математические операции над целыми и дробными числами, то это операторы +, -, *, /, **, //,%. С первыми тремя все понятно. Они обозначают соответственно сложение, вычитание, умножение. Оператор ** указывает на необходимость возведения в степень.

Одиночное (/) и двойное (//) деление различаются. Если первое дает действительное число в решении, второе необходимо, чтобы найти целую часть деления. Например, 9 // 4 = 2. Этот оператор соответствует функции div в Turbo Pascal. Но закономерность есть. Знак «/» напечатает целое число в результате, если и делитель, и делимое являются целыми числами. Чтобы найти остаток от деления в Python, вам нужно использовать оператор «%». По аналогии с тем же «Турбо Паскалем» «%» сравним с функцией мода. Например, 9% 2 = 1, то есть в Python остаток от деления в данном случае равен 1. Рассмотрим еще несколько примеров.

Для деления без остатка Python предлагает использовать функцию divmod (x, y). В этом случае x — делимое, y — делитель. Для divmod (9,3) программа выдает следующий результат (3,0). Это означает, что все деление равно 3, а остаток равен 0.

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