Python math module

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

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

import cmath

a = 3 + 4j

print('Sine:', cmath.sin(a))
print('Cosine:', cmath.cos(a))
print('Tangent:', cmath.tan(a))

print('ArcSin:', cmath.asin(a))
print('ArcCosine:', cmath.acos(a))
print('ArcTan:', cmath.atan(a))

Вывод:

Sine: (3.853738037919377-27.016813258003936j)
Cosine: (-27.034945603074224-3.8511533348117775j)
Tangent: (-0.0001873462046294784+0.999355987381473j)
ArcSin: (0.6339838656391766+2.305509031243477j)
ArcCosine: (0.9368124611557198-2.305509031243477j)
ArcTan: (1.4483069952314644+0.15899719167999918j)

Округление

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

  • , которая отрезает все цифры после запятой;
  • для округления в меньшую сторону;
  • для округления в большую сторону.
>>> number = 5.348762
>>> math.trunc(number)
5
>>> math.floor(number)
5
>>> math.ceil(number)
6

Для округления до k-го знака после запятой используется встроенная в Python функция round, принимающее в качестве аргументов само число и количество знаков k:

>>> number = 5.348762
>>> round(number, 1)
5.3
>>> round(number, 2)
5.35
>>> round(number, 3)
5.349
>>> round(5.55, 1)
5.5
>>> round(5.5, 0)
6.0
>>> round(2.5, 0)
2.0

Обратите внимание, что число 2.5 округлилось до 2.0, а 5.5 до 6.0. Python округляет до ближайшего четного числа

Операторы Python

Оператор – это символ или функция, которая выполняет то или иное действие над данными. К примеру, символ + — это оператор сложения.

В 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 Возведение в степень

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

USB и последовательные порты

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

PyUSB. Это простой в использовании модуль для доступа к USB-устройствам. PyUSB опирается на нативную системную библиотеку для USB-доступа. Работает «из коробки» с libusb 0.1, libusb 1.0, libusbx, libusb-win32 и OpenUSB, а также с Python в любой версии, начиная с 2.4 (и включая Python 3).

PySerial. Библиотека Python для доступа к последовательным портам.

USPP. Мультиплатформенный модуль Python для доступа к последовательным портам.

Алгебраические преобразования

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

Раскрытие скобок

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

sym.expand((x + y) ** 3) 
3 * x * y ** 2 + 3 * y * x ** 2 + x ** 3 + y ** 3

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

sym.expand(x + y, complex=True)#результат re(𝑥)+re(𝑦)+𝑖im(𝑥)+𝑖im(𝑦)
sym.expand(sym.cos(x + y), trig=True)
# результат −sin(𝑥)sin(𝑦)+cos(𝑥)cos(𝑦)

Упрощение выражений

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

sym.simplify((x + x * y) / x) # результат y + 1

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

Стандартные модули

Python распространяется с библиотекой стандартных модулей. Библиотека включает в себя более 200 модулей, которые выполняют платформенно-зависимую поддержку таких задач, как: интерфейс к операционной системе, управление объектами, поиск, сеть + интернет, GUI и т.д. Полный список стандартных модулей можно посмотреть на http://docs.python.org/library/.

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

Переменная sys.path содержит список строк с именами каталогов, в которых происходит поиск модулей. Она инициализируется из значения переменной окружения PYTHONPATH и встроенного значения по умолчанию. Можно добавить путь:

>>> import sys
>>> sys.path.append(/home/my/lib/python)

Для выяснения имен, определенных в модуле, можно использовать встроенную функцию dir(). Она возвращает отсортированный список строк:

>>> dir(sys)

Сложение и вычитание

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

Например:

Также вы можете объявить переменные и указать их в функции print:

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

Числа с плавающей точкой складываются аналогичным образом:

В результате сложения чисел с плавающей точкой также получается число с плавающей точкой, потому Python выводит 8.0, а не 8.

Синтаксис вычитания отличается от сложения только оператором. Попробуйте отнять 32 из 75.67:

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

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

Генерация случайных чисел с помощью класса Math

Для генерации случайных чисел Java предоставляет класс Math, доступный в пакете java.util. Этот класс содержит статичный метод Math.random(), предназначенный для генерации случайных чисел типа double .

Метод random( ) возвращает положительное число большее или равное 0,0 и меньшее 1,0. При вызове данного метода создается объект генератора псевдослучайных чисел java.util.Random.

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

Пример использования Math.random():

public static double getRandomNumber(){
    double x = Math.random();
    return x;
}

Метод getRandomNumber( ) использует Math.random() для возврата положительного числа, которое больше или равно 0,0 или меньше 1,0 .

Результат выполнения кода:

Double between 0.0 and 1.0: SimpleRandomNumber = 0.21753313144345698

Случайные числа в заданном диапазоне

Для генерации случайных чисел в заданном диапазоне необходимо указать диапазон. Синтаксис:

(Math.random() * ((max - min) + 1)) + min

Разобьем это выражение на части:

  1. Сначала умножаем диапазон значений на результат, который генерирует метод random().Math.random() * (max — min)возвращает значение в диапазоне , где max не входит в заданные рамки. Например, выражение Math.random()*5 вернет значение в диапазоне , в который 5 не входит.
  2. Расширяем охват до нужного диапазона. Это делается с помощью минимального значения.
(Math.random() * ( max - min )) + min

Но выражение по-прежнему не охватывает максимальное значение.

Чтобы получить максимальное значение, прибавьте 1 к параметру диапазона (max — min). Это вернет случайное число в указанном диапазоне.

double x = (Math.random()*((max-min)+1))+min;

Существуют различные способы реализации приведенного выше выражения. Рассмотрим некоторые из них.

Случайное двойное число в заданном диапазоне

По умолчанию метод Math.random() при каждом вызове возвращает случайное число типа double . Например:

public static double getRandomDoubleBetweenRange(double min, double max){
    double x = (Math.random()*((max-min)+1))+min;
    return x;
}

Вы можете вызвать предыдущий метод из метода main, передав аргументы, подобные этому.

System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber = 
"+getRandomDoubleBetweenRange(5.0, 10.00));

Результат.

System.out.println("Double between 5.0 and 10.00: RandomDoubleNumber = 
"+getRandomDoubleBetweenRange(5.0, 10.00));

Случайное целое число в заданном диапазоне

Пример генерации случайного целочисленного значения в указанном диапазоне:

public static double getRandomIntegerBetweenRange(double min, double max){
    double x = (int)(Math.random()*((max-min)+1))+min;
    return x;
}

Метод getRandomIntegerBetweenRange() создает случайное целое число в указанном диапазоне. Так как Math.random() генерирует случайные числа с плавающей запятой, то нужно привести полученное значение к типу int. Этот метод можно вызвать из метода main, передав ему аргументы следующим образом:

System.out.println("Integer between 2 and 6: RandomIntegerNumber 
= "+getRandomIntegerBetweenRange(2,6));

Результат.

Integer between 2 and 6: RandomIntegerNumber = 5

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

Примеры

Пример 1: известен заранее

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

Пример: файлу в проекте нужно импортировать функцию из .

Решение: (или любой другой эквивалентный синтаксис импорта).

Пример 2: мог измениться

Зачастую нам требуется как запускать скрипт напрямую из командной строки, так и импортировать его как модуль в другом скрипте. Как вы увидите далее, здесь могут возникнуть проблемы, особенно в Python 3.

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

Звучит просто, не так ли? Нам всего лишь нужно выполнить два импорта: один в и другой в .

Проблема: это один из тех случаев, когда меняется. Когда мы выполняем , содержит , а при выполнении содержит .

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

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

Вместо этого мы могли бы попробовать . Это решает проблему при запуске напрямую, однако теперь создаёт проблему при запуске . В Python 3 это приведёт к ошибке, потому что не находится в (в Python 2 это не вызовет проблемы из-за поддержки неявных относительных импортов).

Обобщим информацию:

Запускаем
Нет проблем В Py2 нет проблем, в Py3 ошибка ( не в )
Ошибка ( не в ) Нет проблем

Использование относительного импорта будет иметь тот же эффект, что и .

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

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

  1. В консоли смените директорию на  .
  2. Запустите .

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

Примечание Обычно этот метод работает, однако в некоторых случаях переменная может быть неправильной. В таком случае нужно использовать встроенный пакет . Подробнее в этом ответе на StackOverflow.

3. Использовать только Python 2 и неявные относительные импорты (последняя колонка в таблице).

4. Использовать абсолютные импорты относительно директории и добавить её в переменную среды . Это решение не переносимо, поэтому лучше не использовать его. О том, как добавить директорию в , читайте в этом ответе.

Пример 3: мог измениться (вариант 2)

А вот ещё одна проблема посложнее. Допустим, модуль никогда не надо запускать напрямую, но он импортируется и , которые запускаются напрямую.

В этом случае первое решение из примера выше не сработает. Тем не менее, всё ещё можно использовать остальные решения.

Пример 4: импорт из родительской директории

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

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

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

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

Генерация букв

Стандартная библиотека Питона позволяет сгенерировать не только цифры, но и буквы. Следующий вариант предлагает ознакомиться с инициализацией трех различных переменных случайными символами латиницы. Чтобы выполнить эти действия необходимо импортировать модуль string, а после этого использовать список letter1s. Именно в него входят все буквы английского алфавита.

import randomimport stringa = random.choice(string.letters)b = random.choice(string.letters)c = random.choice(string.letters)print(a)print(b)print(c)

JiL

Рандом в Питоне позволяет произвести замену отображаемой буквы в разном регистре. Преобразование к общему виду происходит при помощи вызова стандартного строкового метода upper или lower.

Унарные арифметические операции

Унарное математическое выражение состоит из одного элемента. В Python знаки плюса и минуса могут быть использованы как единичный оператор, чтобы вернуть тождественное значение (+) или сменить знак числа (-).

Знак плюса означает тождественное значение. Мы можем использовать его с положительными значениями:

i = 3.3
print(+i)

Вывод

3.3

Когда мы используем знак плюса с отрицательным значением, он также вернёт значение тождественное данному. В этом случае он вернёт отрицательное значение:

j = -19
print(+j)

Вывод

-19

При использовании с отрицательным значением знак плюса возвращает то же отрицательное значение.

Минус (в отличие от знака плюса) изменяет знак числа. Поэтому при передаче положительного числа мы получим отрицательное значение:

i = 3.3
print(-i)

Вывод

-3.3

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

j = -19
print(-j)

Вывод

19

Унарные арифметические операторы возвращают тождественное значение в случае с +i, или противоположное по знаку число в случае с -i.

Функция логарифма log() в Python

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

Python

import math

print(«math.log(10.43):», math.log(10.43))
print(«math.log(20):», math.log(20))
print(«math.log(math.pi):», math.log(math.pi))

1
2
3
4
5

importmath

print(«math.log(10.43):»,math.log(10.43))

print(«math.log(20):»,math.log(20))

print(«math.log(math.pi):»,math.log(math.pi))

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

Shell

math.log(10.43): 2.344686269012681
math.log(20): 2.995732273553991
math.log(math.pi): 1.1447298858494002

1
2
3

math.log(10.43)2.344686269012681

math.log(20)2.995732273553991

math.log(math.pi)1.1447298858494002

Python NumPy

NumPy IntroNumPy Getting StartedNumPy Creating ArraysNumPy Array IndexingNumPy Array SlicingNumPy Data TypesNumPy Copy vs ViewNumPy Array ShapeNumPy Array ReshapeNumPy Array IteratingNumPy Array JoinNumPy Array SplitNumPy Array SearchNumPy Array SortNumPy Array FilterNumPy Random
Random Intro
Data Distribution
Random Permutation
Seaborn Module
Normal Distribution
Binomial Distribution
Poisson Distribution
Uniform Distribution
Logistic Distribution
Multinomial Distribution
Exponential Distribution
Chi Square Distribution
Rayleigh Distribution
Pareto Distribution
Zipf Distribution

NumPy ufunc
ufunc Intro
ufunc Create Function
ufunc Simple Arithmetic
ufunc Rounding Decimals
ufunc Logs
ufunc Summations
ufunc Products
ufunc Differences
ufunc Finding LCM
ufunc Finding GCD
ufunc Trigonometric
ufunc Hyperbolic
ufunc Set Operations

Комплексное

Комплексное число состоит из двух частей — действительной и мнимой. Мнимая часть пишется с суффиксом «j».

Мы также можем использовать функцию complex() для создания комплексного числа. Мы можем передать два аргумента типа int или float в функцию complex(). Первый аргумент — действительная часть, а второй аргумент — сложная часть.

x = 1 + 2j
print(x)
print(type(x))

x = -1 - 4j
print(x)
print(type(x))

x = complex(1, 2)
print(x)
print(type(x))

x = complex(1)
print(x)
print(type(x))

x = complex(-1, -2.5)
print(x)
print(type(x))

Вывод:

(1+2j)
<class 'complex'>
(-1-4j)
<class 'complex'>
(1+2j)
<class 'complex'>
(1+0j)
<class 'complex'>
(-1-2.5j)
<class 'complex'>

Мы также можем получить представление комплексного числа объекта, определив метод __complex __(). Этот метод должен возвращать комплексное число.

class Data:

    def __init__(self, r, i):
        self.real = r
        self.imaginary = i

    def __complex__(self):
        return complex(self.real, self.imaginary)


d = Data(10, 20)
c = complex(d)
print(c)
print(type(c))

Выход:

Мы также можем преобразовать строку в комплексное число. Между реальной и мнимой частью не должно быть пробелов.

c = complex("1+2j")  # works fine

c = complex("1 + 2j") # ValueError: complex() arg is a malformed string

Мы можем получить действительную часть комплексного числа, используя свойство «real». Мы можем получить мнимую часть комплексного числа, используя свойство «imag».

c = 10 + 20j
print(c.real)  # real part
print(c.imag)  # imaginary part

Некоторые другие методы комплексных чисел:

  • conugate(): возвращает комплексное сопряженное число. Знак мнимой части меняется на противоположный.
  • abs(): возвращает величину комплексного числа.
c = 1 + 2j

print(c.conjugate())  # (1-2j)
print(abs(c))  # 2.23606797749979

Тригонометрия

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

>>> pi = math.pi
>>> math.degrees(pi) 1
80.0
>>> math.degrees(pi/2)
90.0
>>> math.degrees(pi/4)
45.0
>>> math.degrees(pi/3)
59.99999999999999
>>> math.degrees(pi/6)
29.999999999999996

В двух последних случаях счетчик не дошел до 60.0 и 30.0 градусов, соответственно. Для этого можно воспользоваться округлением, рассмотренным выше.

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

>>> math.radians(180)
3.141592653589793
>>> math.radians(60)
1.0471975511965976

Тригонометрические функции принимают в качестве аргументов значение в радианах:

>>> math.cos(pi)
-1.0
>>> math.sin(pi/2)
1.0
>>> math.sin(pi)
1.2246467991473532e-16
>>> math.tan(pi/4)
0.9999999999999999

Полный список тригонометрических функций можно посмотреть в официальной документации Python [].

Модуль random

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

  • random () – может вернуть число в промежуток значений от 0 до 1;
  • seed (a) – производит настройку генератора на новую последовательность а;
  • randint (a,b) – возвращает значение в диапазон данных от а до b;
  • randrange (a, b, c) – выполняет те же функции, что и предыдущая, только с шагом с;
  • uniform (a, b) – производит возврат вещественного числа в диапазон от а до b;
  • shuffle (a) – миксует значения, находящиеся в перечне а;
  • choice (a) – восстанавливает обратно случайный элемент из перечня а;
  • sample (a, b) – возвращает на исходную позицию последовательность длиной b из перечня а;
  • getstate () – обновляет внутреннее состояние генератора;
  • setstate (a) – производит восстановление внутреннего состояния генератора а;
  • getrandbits (a) – восстанавливает а при выполнении случайного генерирования бит;
  • triangular (a, b, c) – показывает изначальное значение числа от а до b с шагом с.

Если вам необходимо применить для задания инициализирующееся число псевдо случайной последовательности, то не обойтись без функции seed. После ее вызова без применения параметра, используется значение системного таймера. Эта опция доступна в конструкторе класса Random.

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

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

Модуль оснащен одноименной функцией random. Она более активно используется в Питоне, чем остальные. Эта функция позволяет произвести возврат числа в промежуток значений от 0 до 1. Вот пример трех основных переменных:

import randoma = random.random()b = random.random()print(a)print(b)

0.5479332865190.456436031781

Целые числа

Чтобы в программе появились случайные числа из четко заданного диапазона, применяется функция randit. Она обладает двумя аргументами: максимальным и минимальным значением. Она отображает значения, указанные ниже в генерации трех разных чисел от 0 до 9.

import randoma = random.randint(0, 9)b = random.randint(0, 9)print(a)print(b)

47

Диапазон целых чисел

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

  • минимальное значение;
  • максимальное;
  • длина шага.

При вызове функции с одним требованием, граница будет установлена на значении 0, а промежуток будет установлен на 1. Для двух аргументов длина шага уже высчитывается автоматически. Вот пример работы этой опции на основе трех разных наборов.

import randoma = random.randrange(10)b = random.randrange(2, 10)c = random.randrange(2, 10, 2)print(a)print(b)print(c)

952

Диапазон вещественных чисел

Генерация вещественных чисел происходит при использовании функции под названием uniform. Она регулируется всего двумя параметрами: минимальным и максимальным значением. Пример создания демонстрации с переменными a, b и c.

import randoma = random.uniform(0, 10)b = random.uniform(0, 10)print(a)print(b)

4.856873750913.66695202551

Арифметические функции в Python

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

  • : округление определенного числа вверх;
  • : возвращает модуль (абсолютное значение) указанного числа;
  • : округление определенного числа вниз;
  • : получение наибольшего общего делителя чисел и ;
  • : возвращает сумму всех элементов итерируемого объекта;
  • : возвращает (e^x)-1;
  • : когда значение слишком мало, вычисление может привести к значительной потери в точности. может вернуть вывод с полной точностью.

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

Python

import math

num = -4.28
a = 14
b = 8

num_list =
x = 1e-4 # Малое значение x

print(‘Число:’, num)
print(‘Округление числа вниз:’, math.floor(num))
print(‘Округление числа вверх:’, math.ceil(num))
print(‘Модуль числа:’, math.fabs(num))
print(‘Наибольший общий делитель a и b: ‘ + str(math.gcd(a, b)))
print(‘Сумма элементов списка: ‘ + str(math.fsum(num_list)))
print(‘e^x (при использовании функции exp()) равно:’, math.exp(x)-1)
print(‘e^x (при использовании функции expml()) равно:’, math.expm1(x))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

importmath

num=-4.28

a=14

b=8

num_list=10,8.25,75,7.04,-86.23,-6.43,8.4

x=1e-4# Малое значение x

print(‘Число:’,num)

print(‘Округление числа вниз:’,math.floor(num))

print(‘Округление числа вверх:’,math.ceil(num))

print(‘Модуль числа:’,math.fabs(num))

print(‘Наибольший общий делитель a и b: ‘+str(math.gcd(a,b)))

print(‘Сумма элементов списка: ‘+str(math.fsum(num_list)))

print(‘e^x (при использовании функции exp()) равно:’,math.exp(x)-1)

print(‘e^x (при использовании функции expml()) равно:’,math.expm1(x))

Вывод

Python

Число: -4.28
Округление числа вниз: -5
Округление числа вверх: -4
Модуль числа: 4.28
Наибольший общий делитель a и b: 2
Сумма элементов списка: 16.029999999999998
e^x (при использовании функции exp()) равно: 0.0001000050001667141
e^x (при использовании функции expml()) равно: 0.00010000500016667084

1
2
3
4
5
6
7
8

Число-4.28

Округлениечиславниз-5

Округлениечиславверх-4

Модульчисла4.28

Наибольшийобщийделительaиb2

Суммаэлементовсписка16.029999999999998

e^x(прииспользованиифункцииexp())равно0.0001000050001667141

e^x(прииспользованиифункцииexpml())равно0.00010000500016667084

К числу других математических функций относятся:

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

Примеры данных методов представлены ниже:

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

Python

math.pow(3, 4)

1 math.pow(3,4)

Вывод

Shell

81.0

1 81.0

Квадратный корень

Python

math.sqrt(81)

1 math.sqrt(81)

Вывод

Shell

9.0

1 9.0

Абсолютный и относительный импорт

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

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

  1. При явном импорте используется формат , где символы точки показывают, на сколько директорий «вверх» нужно подняться. Одна точка показывает текущую директорию, две точки — на одну директорию выше и т. д.
  2. Неявный относительный импорт пишется так, как если бы текущая директория была частью . Такой тип импортов поддерживается только в Python 2.

В документации Python об относительных импортах в Python 3 написано следующее:

В качестве примера допустим, что мы запускаем , который импортирует , который импортирует , и . Тогда импорты в будут выглядеть следующим образом:

Абсолютные импорты:

Явные относительные импорты:

Неявные относительные импорты (не поддерживаются в Python 3):

Учтите, что в относительных импортах с помощью точек можно дойти только до директории, содержащей запущенный из командной строки скрипт (не включительно). Таким образом, не сработает в . В результате мы получим ошибку .

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

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

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

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

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

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

Например:

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

Дополнительные примеры, упрощающие жизнь Data Scientist’а

Рассмотрим еще три примера, которые пригодятся каждому разработчику, а не только математикам.

1-й пример. Согласно тригонометрии cos(pi/4) должен равняться sin(pi/4). Так ли это в Python?

>>> pi= math.pi
>>> math.sin(pi/4) == math.cos(pi/4)
False

Как видим, что нет. В вычислениях с плавающей точкой такое происходит часто. Но нам не всегда важна точность до 120-го знака после запятой. Поэтому можно воспользоваться функцией , возвращающее True в случае если два числа близки друг к другу. По умолчанию рассматриваются только 9 знаков после запятой, но это значение всегда можно изменить по желанию.

>>> sin = math.sin(pi/4)
>>> cos = math.cos(pi/4)
>>> math.isclose(sin, cos)
True

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

>>> abs(-5)
5 >>>
abs(8 - 16)
8

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

>>>  * 5

В данном случае оператор “*” служит не умножением, а повторением элементов в списке.

В следующей статье мы поговорим об использовании Python для статистиков. А практические нюансы по математическим вычислениям в Data Science и не только вы узнаете на наших практических курсах по Python в лицензированном учебном центре обучения и повышения квалификации ИТ-специалистов в Москве.

Смотреть расписание
Записаться на курс

Источники

Оцените статью
Рейтинг автора
5
Материал подготовил
Илья Коршунов
Наш эксперт
Написано статей
134
Добавить комментарий