Import math: Python | Модуль math

Python | Модуль math

Модуль math

Последнее обновление: 02.05.2017

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

• pow(num, power): возведение числа num в степень power

• sqrt(num): квадратный корень числа num

• ceil(num): округление числа до ближайшего наибольшего целого

• floor(num): округление числа до ближайшего наименьшего целого

• factorial(num): факториал числа

• degrees(rad): перевод из радиан в градусы

• radians(grad): перевод из градусов в радианы

• cos(rad): косинус угла в радианах

• sin(rad): синус угла в радианах

• tan(rad): тангенс угла в радианах

• acos(rad): арккосинус угла в радианах

• asin(rad): арксинус угла в радианах

• atan(rad): арктангенс угла в радианах

• log(n, base): логарифм числа n по основанию base

• log10(n): десятичный логарифм числа n

Пример применения некоторых функций:

import math

# возведение числа 2 в степень 3
n1 = math.pow(2, 3)
print(n1)  # 8

# ту же самую операцию можно выполнить так
n2 = 2**3
print(n2)

# возведение в квадрат
print(math.sqrt(9))  # 3

# ближайшее наибольшее целое число
print(math.ceil(4.56))  # 5

# ближайшее наименьшее целое число
print(math.floor(4.56))  # 4

# перевод из радиан в градусы
print(math.degrees(3.14159))  # 180

# перевод из градусов в радианы
print(math.radians(180))   # 3.1415.....
# косинус
print(math.cos(math.radians(60)))  # 0.5
# cинус
print(math.sin(math.radians(90)))   # 1.0
# тангенс
print(math.tan(math.radians(0)))    # 0.0

print(math.log(8,2))    # 3.0
print(math.log10(100))    # 2.0

Также модуль math предоставляет ряд встроенных констант, такие как PI и E:

import math
radius = 30
# площадь круга с радиусом 30
area = math.pi * math.pow(radius, 2)
print(area)

# натуральный логарифм числа 10
number = math.log(10, math.e)
print(number)

Библиотеки для решения математических примеров в Python

Боитесь математики? Не раз пытались решить задачки по математике с помощью технологий? Не вы одни. Сегодня в Python можно решить почти все математические задачи. В данной статье мы рассмотрим способы имплементации различных математических операций в Python.

Содержание статьи

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

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

Python библиотеки для математики

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

Библиотека Math в Python

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

Пример: Вы можете найти экспоненту от 3, используя функцию exp() библиотеки math следующим образом:

from math import exp
exp(3) # Вычисление экспоненты

Библиотека Numpy в Python

Библиотека Numpy в Python широко используется для выполнения математических операций с матрицами. Наиболее важной особенностью Numpy, которая отличает его от других библиотек, является способность выполнять вычисления на молниеносной скорости. Это возможно благодаря C-API, который позволяет пользователю быстро получать результаты.

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

import numpy as np


mat1 = np.array([[1,2],[3,4]])
mat2 = np.array([[5,6],[7,8]])
np.dot(mat1,mat2)

Результат:

array([[19, 22],
[43, 50]])

Библиотека SciPy в Python

Библиотека math предоставляется Python научные инструменты. В ней есть различные модели для математической оптимизации, линейной алгебры, Преобразования Фурье и так далее. Модуль numpy предоставляет базовую структуру данных массива библиотеке SciPy.

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

from scipy import linalg


import numpy as np
mat1 = np.array([[1,2],[3,4]]) #DataFlair
linalg.det(mat1) # Результат: -2.0

Библиотека Statsmodel в Python

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

Ниже приведен пример реализации библиотеки Statsmodel в Python.

import numpy as np
import statsmodels.api as sm
import statsmodels.formula.api as smf


input_data = sm.datasets.get_rdataset(«Guerry», «HistData»).data

res = smf.ols(‘Lottery ~ Literacy + np.log(Pop1831)’, data = input_data).fit()
print(res.summary())

Scikit-learn в Python

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

from sklearn import linear_model


regress = linear_model.LinearRegression()

regress.fit([[0,0],[1,1],[2,2]], [0,1,2])
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

print(regress.coef_) # Результат: array([0.5, 0.5])

Заключение

В данной статье мы рассмотрели важные математические библиотеки Python. Были рассмотрены NumPy, SciPy, statsmodels, а также scikit-learn. В Python есть и другие математические библиотеки, многие находятся в процессе разработки. Надеемся, что определенные моменты руководства вам пригодятся в будущем.

Автоматизация импортов в Python / Хабр

Так получилось, что аж с 2012 года я разрабатываю open source браузерку, являясь единственным программистом. На Python само собой. Браузерка — штука не самая простая, сейчас в основной части проекта больше 1000 модулей и более 120 000 строк кода на Python. В сумме же с проектами-спутниками будет раза в полтора больше.

В какой-то момент мне надоело возиться с этажами импортов в начале каждого файла и я решил разобраться с этой проблемой раз и навсегда. Так родилась библиотека smart_imports (github, pypi).

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

Например, не надо будет писать import math чтобы обратиться к math.pi — мы и так можем понять, что в данном случае math — модуль стандартной библиотеки.

Smart imports поддерживают Python >= 3.5 Библиотека полностью покрыта тестами, coverage > 95%. Сам пользуюсь уже год.

За подробностями приглашаю под кат.

Как оно работает в целом

Итак, код из заглавной картинки работает следующим образом:

1. Во время вызова smart_imports.all() библиотека строит AST модуля, из которого сделан вызов;
2. Находим неинициализированные переменные;
3. Имя каждой переменной прогоняем через последовательность правил, которые пытаются по имени найти нужный для импорта модуль (или атрибут модуля). Если правило обнаружило необходимую сущность, следующие правила не проверяются.
4. Найденные модули загружаются, инициализируются и помещаются в глобальное пространство имён (либо туда помещаются нужные атрибуты этих модулей).

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

Автоматическое импортирование включается только для тех компонентов проекта, которые явно вызывают smart_imoprts.all(). Кроме того, использование smart imports не запрещает использовать обычные импорты. Это позволяет внедрять библиотеку постепенно, равно как и разрешать сложные циклические зависимости.

Дотошливый читатель заметит, что AST модуля конструируется два раза:

• первый раз его строит CPython во время импорта модуля;
• второй раз его строит smart_imports во время вызова smart_imports.all().

AST действительно можно строить только один раз (для этого надо встроиться в процесс импорта модулей с помощью import hooks реализованных в PEP-0302, но такое решение замедляет импорт.Как думаете, почему?Сравнивая производительность двух реализаций (с хуками и без), я пришёл к выводу, что при импорте модуля CPython строит AST в своих внутренних (C-шных) структурах данных. Конвертация их в структуры данных Python выходит дороже, чем построение дерева по исходникам с помощью модуля ast.

Само собой, AST каждого модуля строится и анализируется только раз за запуск.

Правила импорта по-умолчанию

Библиотеку можно использовать без дополнительной конфигурации. По-умолчанию она импортирует модули по следующим правилам:

1. По точному совпадению имени ищет модуль рядом с текущим (в том же каталоге).
2. Проверяет модули стандартной библиотеки:
   • по точному совпадению имени для пакетов верхнего уровня;
   • для вложенных пакетов и модулей проверяет составные имена с заменой точки на подчёркивание. Например os.path будет импортирован при наличии переменной os_path.

3. По точному совпадению имени ищет установленные сторонние пакеты. Например общеизвестный пакет requests.

Производительность

Работа smart imports не сказывается на показателях работы программы, но увеличивает время её запуска.

Из-за повторного построения AST время первого запуска увеличивается примерно в 1.5-2 раза. Для малых проектов это несущественно. В больших проектах же время запуска страдает скорее от структуры зависимостей между модулями, чем от времени импорта конкретного модуля.

Когда если smart imports станут популярными, перепишу работу с AST на C — это должно заметно снизить издержки при запуске.

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

На время запуска влияет как перечень правил поиска модулей, так и их последовательность. Так как некоторые правила используют стандартную функциональность Python для поиска модулей. Исключить эти расходы можно явно указав соответствие имён и модулей с помощью правила «Кастомизированные имена» (см. далее).

Конфигурация

Дефолтная конфигурация была описана ранее. Её должно хватать для работы со стандартной библиотекой в небольших проектах.Дефолтный конфиг

{
    "cache_dir": null,
    "rules": [{"type": "rule_local_modules"},
              {"type": "rule_stdlib"},
              {"type": "rule_predefined_names"},
              {"type": "rule_global_modules"}]
}

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

Пример сложного конфига (из браузерки).

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

Можно использовать несколько разных конфигов (разместив их в разных каталогах).

Параметров конфигурации сейчас не так много:

{
    // Каталог для хранения кэша AST.
    // Если не указан или null — кэш не используется.
    "cache_dir": null|"string",

    // Список конфигов правил в порядке их применения.
    "rules": []
}

Правила импорта

Порядок указания правил в конфиге определяет порядок их применения. Первое сработавшее правило останавливает дальнейший поиск импортов.

В примерах конфигов далее будет часто фигурировать правило rule_predefined_names, оно необходимо чтобы корректно распознавались встроенные функции (например, print).

Правило 1: Предопределённые имена

Правило позволяет игнорировать предопределённые имена вроде __file__ и встроенные функции, например print.Пример

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"}]
# }

import smart_imports

smart_imports.all()

# мы не будем искать модуль с именем __file__
# хотя в коде эта переменная не проинициализирована
print(__file__)

Правило 2: Локальные модули

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

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"},
#              {"type": "rule_local_modules"}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- a.py
# |-- b.py

# b.py
import smart_imports

smart_imports.all()

# Будет импортирован модуль "a.py"
print(a)

Правило 3: Глобальные модули

Пробует импортировать модуль непосредственно по имени. Например, модуль requests.Пример

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"},
#              {"type": "rule_global_modules"}]
# }
#
# ставим дополнительный пакет
#
# pip install requests

import smart_imports

smart_imports.all()

# Будет импортирован модуль requests
print(requests.get('http://example.com'))

Правило 4: Кастомизированные имена

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

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"},
#              {"type": "rule_custom",
#               "variables": {"my_import_module": {"module": "os.path"},
#                             "my_import_attribute": {"module": "random", "attribute": "seed"}}}]
# }

import smart_imports

smart_imports.all()

# В примере исплользованы модули стандартной библиотеки
# Но аналогично можно импортировать любой другой модуль
print(my_import_module)
print(my_import_attribute)

Правило 5: Стандартные модули

Проверяет, не является ли имя модулем стандартной библиотеки. Например math или os.path который трансформируется в os_path.

Работает быстрее чем правило импорта глобальных модулей, так как проверяет наличие модуля по закэшированному списку. Списки для каждой версии Python берутся отсюда: github.com/jackmaney/python-stdlib-list

Пример

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"},
#              {"type": "rule_stdlib"}]
# }

import smart_imports

smart_imports.all()

print(math.pi)

Правило 6: Импорт по префиксу

Импортирует модуль по имени, из пакета, ассоциированного с его префиксом. Удобно использовать, когда у вас есть несколько пакетов использующихся во всём коде. Например к модулям пакета utils можно обращаться с префиксом utils_.Пример

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"},
#              {"type": "rule_prefix",
#               "prefixes": [{"prefix": "utils_", "module": "my_package.utils"}]}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- utils
# |-- |-- __init__
# |-- |-- a.py
# |-- |-- b.py
# |-- subpackage
# |-- |-- __init__
# |-- |-- c.py

# c.py

import smart_imports

smart_imports.all()

print(utils_a)
print(utils_b)

Правило 7: Модуль из родительского пакета

Если у вас есть одноимённые субпакеты в разных частях проекта (например, tests или migrations), для них можно разрешить искать модули для импорта по имени в родительских пакетах.Пример

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"},
#              {"type": "rule_local_modules_from_parent",
#               "suffixes": [".tests"]}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- a.py
# |-- tests
# |-- |-- __init__
# |-- |-- b.py

# b.py

import smart_imports

smart_imports.all()

print(a)

Правило 8: Привязка к другому пакету

Для модулей из конкретного пакета разрешает поиск импортов по имени в других пакетах (указанных в конфиге). В моём случае это правило оказалось полезным для случаев, когда не хотелось распространять работу предыдущего правила (Модуль из родительского пакета) на весь проект.Пример

# конфиг:
# {
#    "rules": [{"type": "rule_predefined_names"},
#              {"type": "rule_local_modules_from_namespace",
#               "map": {"my_package.subpackage_1": ["my_package.subpackage_2"]}}]
# }
#
# код на файловой системе:
#
# my_package
# |-- __init__.py
# |-- subpackage_1
# |-- |-- __init__
# |-- |-- a.py
# |-- subpackage_2
# |-- |-- __init__
# |-- |-- b.py

# a.py

import smart_imports

smart_imports.all()

print(b)

Добавление собственных правил

Добавить собственное правило довольно просто:

1. Наследуемся от класса smart_imports.rules.BaseRule.
2. Реализуем нужную логику.
3. Регистрируем правило с помощью метода smart_imports.rules.register
4. Добавляем правило в конфиг.
5. ???
6. Профит.

Пример можно найти в реализации текущий правил

Профит

Пропали многострочные списки импортов в начале каждого исходника.

Cократилось количество строк. До перехода браузерки на smart imports в ней было 6688 строк отвечающих за импорт. После перехода осталось 2084 (по две строки smart_imports на каждый файл + 130 импортов, вызываемых явно из функций и подобных мест).

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

Планы развития

Идея определять свойства кода по именам переменных мне нравится, поэтому буду пробовать развивать её как в рамках smart imports, так и в рамках других проектов.

Касательно smart imports, планирую:

1. Добавлять поддержку новых версий Python.
2. Исследовать возможность опереться на текущие наработки сообщества по аннотации кода типами.
3. Исследовать возможность сделать ленивые импорты.
4. Реализовать утилиты для автоматической генерации конфига по исходникам и рефакторингу исходников на использование smart_imports.
5. Переписать часть кода на C, чтобы ускорить работу с AST.
6. Развивать интеграцию с линтерами и IDE, если у тех будут возникать проблемы с анализом кода без явных импортов.

Кроме того, мне интересно ваше мнение по поводу дефолтного поведения библиотеки и правил импорта.

Спасибо что осилили эту простыню текста 😀

Математические библиотеки Python

Математические библиотеки Python

Сегодня в Python можно решить почти все математические задачи. В данной статье мы рассмотрим способы имплементации различных математических операций в Python.

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

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

Python библиотеки для математики

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

Библиотека Math в Python

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

Пример: Вы можете найти экспоненту от 3, используя функцию exp() библиотеки math следующим образом:

from math import exp
exp(3) # Вычисление экспоненты

Математические библиотеки Python

Библиотека Numpy в Python

Библиотека Numpy в Python широко используется для выполнения математических операций с матрицами. Наиболее важной особенностью Numpy, которая отличает его от других библиотек, является способность выполнять вычисления на молниеносной скорости. Это возможно благодаря C-API, который позволяет пользователю быстро получать результаты.

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

import numpy as np


mat1 = np.array([[1,2],[3,4]])
mat2 = np.array([[5,6],[7,8]])
np.dot(mat1,mat2)

Результат:

array([[19, 22],
[43, 50]])

Библиотека SciPy в Python

Библиотека math предоставляется Python научные инструменты. В ней есть различные модели для математической оптимизации, линейной алгебры, Преобразования Фурье и так далее. Модуль numpy предоставляет базовую структуру данных массива библиотеке SciPy.

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

from scipy import linalg


import numpy as np
mat1 = np.array([[1,2],[3,4]]) #DataFlair
linalg.det(mat1) # Результат: -2.0

Библиотека Statsmodel в Python

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

Ниже приведен пример реализации библиотеки Statsmodel в Python.

import numpy as np
import statsmodels.api as sm
import statsmodels.formula.api as smf


input_data = sm.datasets.get_rdataset(«Guerry», «HistData»).data

res = smf.ols(‘Lottery ~ Literacy + np.log(Pop1831)’, data = input_data).fit()
print(res.summary())

Scikit-learn в Python

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

from sklearn import linear_model


regress = linear_model.LinearRegression()

regress.fit([[0,0],[1,1],[2,2]], [0,1,2])
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

print(regress.coef_) # Результат: array([0.5, 0.5])

Заключение

В данной статье мы рассмотрели важные математические библиотеки Python. Были рассмотрены NumPy, SciPy, statsmodels, а также scikit-learn. В Python есть и другие математические библиотеки, многие находятся в процессе разработки. Надеемся, что определенные моменты руководства вам пригодятся в будущем.

источник

Модули. Урок 15 курса «Python. Введение в программирование»

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

Чтобы разрешить проблему доступа к дополнительным возможностям языка, в программировании стало общепринятой практикой использовать так называемые модули, пакеты и библиотеки. Каждый модуль содержит коллекцию функций и классов, предназначенных для решения задач из определенной области. Так в модуле math языка Python содержатся математические функции, модуль random позволяет генерировать псевдослучайные числа, в модуле datetime содержатся классы для работы с датами и временем, модуль sys предоставляет доступ к системным переменным и т. д.

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

Для доступа к функционалу модуля, его надо импортировать в программу. После импорта интерпретатор «знает» о существовании дополнительных классов и функций и позволяет ими пользоваться.

В Питоне импорт осуществляется командой import. При этом существует несколько способов импорта. Рассмотрим работу с модулем на примере math. Итак,

>>> import math

Ничего не произошло. Однако в глобальной области видимости появилось имя math. Если до импорта вы упомянули бы имя math, то возникла бы ошибка NameError. Теперь же

>>> math
<module 'math' (built-in)>

В программе завелся объект math, относящийся к классу module.

Чтобы увидеть перечень функций, входящих в этот модуль, воспользуемся встроенной в Python функцией dir(), передав ей в качестве аргумента имя модуля:

>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh',
'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh',
'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor',
'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite',
'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf',
'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

Проигнорируем имена с двойными подчеркиваниями. Все остальное – имена функций и констант (переменных, которые не меняют своих значений), включенных в модуль math. Чтобы вызвать функцию из модуля, надо впереди написать имя модуля, поставить точку, далее указать имя функции, после чего в скобках передать аргументы, если они требуются. Например, чтобы вызвать функцию pow из math, надо написать так:

>>> math.pow(2, 2)
4.0

Обратите внимание, эта другая функция pow(), не та, что встроена в сам язык. «Обычная» функция pow() возвращает целое, если аргументы целые числа:

>>> pow(2, 2)
4

Для обращения к константе скобки не нужны:

>>> math.pi
3.141592653589793

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

>>> help(math.gcd)
Help on built-in function gcd in module math:

gcd(...)
    gcd(x, y) -> int
    greatest common divisor of x and y

Для выхода из интерактивной справки надо нажать клавишу q. В данном случае сообщается, что функция возвращает целое число, и это наибольший общий делитель для чисел x и y. Описание модулей и их содержания также можно посмотреть в официальной документации на сайте python.org.

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

>>> from math import gcd, sqrt, hypot

Перевести можно как «из модуля math импортировать функции gcd, sqrt и hypot».

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

>>> gcd(100, 150)
50
>>> sqrt(16)
4.0
>>> hypot(3, 4)
5.0

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

>>> from math import *

Импорт через from не лишен недостатка. В программе уже может быть идентификатор с таким же именем, как имя одной из импортируемых функций или констант. Ошибки не будет, но одно из них окажется «затерто»:

>>> pi = 3.14
>>> from math import pi
>>> pi
3.141592653589793

Здесь исчезает значение 3.14, присвоенное переменной pi. Это имя теперь указывает на число из модуля math. Если импорт сделать раньше, чем присвоение значения pi, то будет все наоборот:

>>> from math import pi
>>> pi = 3.14
>>> pi
3.14

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

Однако можно изменить имя идентификатора из модуля на какое угодно:

>>> from math import pi as P
>>> P
3.141592653589793
>>> pi
3.14

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

>>> import calendar
>>> calendar.weekheader(2)
'Mo Tu We Th Fr Sa Su'

и

>>> from calendar import weekheader as week
>>> week(3)
'Mon Tue Wed Thu Fri Sat Sun'

Во всех остальных случаях лучше оставлять идентификаторы содержимого модуля в пространстве имен самого модуля и получать доступ к ним через имя модуля, т. е. выполнять импорт командой import имя_модуля, а вызывать, например, функции через имя_модуля.имя_функции().

Практическая работа. Создание собственного модуля

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

from math import pi, pow

def rectangle(a, b):
    return round(a * b, 2)

def triangle(a, h):
    return round(0.5 * a * h, 2)

def circle(r):
    return round(pi * pow(r, 2), 2) 

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

Поместите данный код в отдельный файл square.py. Однако куда поместить сам файл?

Когда интерпретатор Питона встречает команду импорта, то просматривает на наличие файла-модуля определенные каталоги. Их перечень можно увидеть по содержимому sys.path:

>>> import sys
>>> sys.path
['', '/usr/lib/python35.zip', '/usr/lib/python3.5', 
'/usr/lib/python3.5/plat-x86_64-linux-gnu',
'/usr/lib/python3.5/lib-dynload', 
'/home/pl/.local/lib/python3.5/site-packages',
'/usr/local/lib/python3.5/dist-packages', 
'/usr/lib/python3/dist-packages']

Это список адресов в Linux. В Windows он будет несколько другим. Первый элемент – пустая строка, что обозначает текущий каталог, то есть то место, где сохранена сама программа, импортирующая модуль. Если вы сохраните файл-модуль и файл-программу в одном каталоге, то интерпретатор без труда найдет модуль.

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

Можно добавить в sys.path свой каталог. Однако в этом случае либо код программы должен содержать команды изменения значения sys.path, либо надо править конфигурационный файл операционной системы. В большинстве случаев лучше так не делать.

Поместите файл square.py в тот же каталог, где будет исполняемая программа. Ее код должен включать инструкцию импорта модуля square (при импорте расширение файла не указывается) и вызов той функции и с теми параметрами, которые ввел пользователь. Т. е. у пользователя надо спросить, площадь какой фигуры он хочет вычислить. Далее запросить у него аргументы для соответствующей функции. Передать их в функцию из модуля square, а полученный оттуда результат вывести на экран.

Примечание. Исполнение модуля как самостоятельного скрипта, а также создание строк документации, которые отображает встроенная в Python функция help(), будут рассмотрены в курсе объектно-ориентированного программирования.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Математический модуль Python

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

math — Математические функции — Python Module of the Week

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

Специальные константы

Многие математические операции зависят от специальных констант. математика
включает значения для π (pi) и e.

 импорт математики

напечатать 'π:% .30f'% math.pi
напечатайте 'e:% .30f'% math.e
 

Оба значения ограничены по точности только плавающим
Библиотека point C.

 $ питон math_constants.py

π: 3,141592653589793115997963468544
e: 2.718281828459045090795598298428
 

Испытания на исключительные значения

Вычисления с плавающей запятой могут приводить к двум типам исключительных
ценности.6} ‘. Format (‘ ‘,’ ‘,’ ‘,’ ‘)

для e в диапазоне (0, 201, 20):
х = 10,0 ** е
у = х * х
print ‘{: 3d} {! s: 6} {! s: 6} {! s: 6}’. format (e, x, y, math.isinf (y))

Когда показатель степени в этом примере становится достаточно большим, квадрат
x больше не помещается в двойной , и значение записывается как
бесконечно.

 $ питон math_isinf.py

 e x x ** 2 isinf
--- ------ ------ ------
  0 1.0 1.0 Ложь
 20 1e + 20 1e + 40 Ложь
 40 1e + 40 1e + 80 Ложь
 60 1e + 60 1e + 120 Ложь
 80 1e + 80 1e + 160 Ложь
100 1e + 100 1e + 200 Ложь
120 1e + 120 1e + 240 Ложь
140 1e + 140 1e + 280 Ложь
160 1e + 160 inf Истина
180 1e + 180 inf Истина
200 1e + 200 inf Истина
 

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

 х = 10,0 ** 200

напечатать 'x =', x
напечатать 'x * x =', x * x
пытаться:
    напечатать 'x ** 2 =', x ** 2
кроме OverflowError, ошибка:
    ошибка печати
 

Это несоответствие вызвано разницей в реализации
библиотека, используемая C Python.

 $ питон math_overflow.py

х = 1e + 200
х * х = инф
x ** 2 = (34, 'Результат слишком велик')
 

Операции деления с использованием бесконечных значений не определены.Результат
деления числа на бесконечность — NaN («не число»).

 импорт математики

х = (10,0 ** 200) * (10,0 ** 200)
у = х / х

напечатать 'x =', x
печать 'isnan (x) =', math.isnan (x)
напечатать 'y = x / x =', x / x
print 'y == nan =', y == float ('nan')
print 'isnan (y) =', math.isnan (y)
 

NaN не сравнивается как равное какому-либо значению, даже самому себе, поэтому
проверьте NaN, вы должны использовать isnan ().

 $ питон math_isnan.py

x = inf
isnan (x) = Ложь
у = х / х = нан
y == nan = ложь
isnan (y) = Истина
 

Преобразование в целые числа

Математический модуль включает три функции для преобразования
значения с плавающей запятой в целые числа.5} ‘. Format (‘ ‘,’ ‘,’ ‘,’ ‘,’ ‘)

fmt = » .join ([‘{: 5.1f}’] * 5)

для i в [-1,5, -0,8, -0,5, -0,2, 0, 0,2, 0,5, 0,8, 1]:
напечатать fmt.format (i, int (i), math.trunc (i), math.floor (i), math.ceil (i))

trunc () эквивалентно прямому преобразованию в int.

 $ питон math_integers.py

  я в багажнике потолок
----- ----- ----- ----- -----
 -1,5 -1,0 -1,0 -2,0 -1,0
 -0,8 0,0 0,0 -1,0 -0,0
 -0,5 0,0 0,0 -1,0 -0,0
 -0,2 0,0 0.0 -1,0 -0,0
  0,0 0,0 0,0 0,0 0,0
  0,2 0,0 0,0 0,0 1,0
  0,5 0,0 0,0 0,0 1,0
  0,8 0,0 0,0 0,0 1,0
  1,0 1,0 1,0 1,0 1,0
 

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

modf () принимает одно число с плавающей запятой и возвращает кортеж
содержащий дробную и целую части входного значения.

 импорт математики

для i в диапазоне (6):
    print '{} / 2 = {}'. format (i, math.modf (i / 2.0))
 

Оба числа в возвращаемом значении являются числами с плавающей запятой.7} ‘. Format (‘ ‘,’ ‘,’ ‘)

для m, e в [(0,8, -3),
(0,5, 0),
(0,5, 3),
]:
х = math.ldexp (m, e)
print ‘{: 7.2f} {: 7d} {: 7.2f}’. format (m, e, x)

Используя ту же формулу, что и frexp (), ldexp () принимает
значения мантиссы и экспоненты в качестве аргументов и возвращает значение с плавающей запятой
количество.

 $ питон math_ldexp.py

   м е х
------- ------- -------
   0,80 -3 0,10
   0,50 0 0,50
   0,50 3 4.00
 

Положительные и отрицательные признаки

Абсолютным значением числа является его значение без знака. Использовать
fabs () для вычисления абсолютного значения с плавающей запятой
количество.

 импорт математики

напечатать math.fabs (-1.1)
напечатать math.fabs (-0.0)
напечатать math.fabs (0.0)
напечатать math.fabs (1.1)
 

На практике абсолютная величина поплавка равна
представлен как положительное значение.

 $ питон math_fabs.py

1.1
0,0
0,0
1.1
 

Чтобы определить знак значения, либо чтобы задать набор значений
тот же знак или просто для сравнения используйте copysign (), чтобы установить
знак заведомо хорошей ценности.5} ‘. Format (‘ ‘,’ ‘,’ ‘,’ ‘,’ ‘)

для f в [-1.0,
0,0,
1.0,
float (‘- inf’),
поплавок (‘инф’),
поплавок (‘- нан’),
поплавок (‘нан’),
]:
s = int (math.copysign (1, f))
print ‘{: 5.1f} {: 5d} {! s: 5} {! s: 5} {! s: 5}’. format (f, s, f <0, f> 0, f == 0)

Дополнительная функция, такая как copysign (), необходима, потому что сравнение
NaN и -NaN напрямую с другими значениями не работают.

 $ питон math_copysign.py


  f s <0> 0 = 0
----- ----- ----- ----- -----
 -1.0-1 Истина Ложь Ложь
  0,0 1 ложно ложно верно
  1.0 1 Ложь Истина Ложь
 -inf -1 Истина Ложь Ложь
  inf 1 Ложь Истина Ложь
  nan -1 Ложь Ложь Ложь
  nan 1 Ложь Ложь Ложь
 

Обычно используемые расчеты

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

 импорт математики

значения = [0,1] * 10

print 'Входные значения:', значения

print 'sum (): {: .20f}'. format (sum (значения))

s = 0,0
для i в значениях:
    s + = я
print 'for-loop: {: .20f}'. формат (ы)
    
напечатать 'math.fsum (): {: .20f}'. формат (math.fsum (значения))
 

Учитывая последовательность из десяти значений, каждое из которых равно 0,1, ожидаемое
значение суммы последовательности равно 1.0. Поскольку 0.1 не может быть
представлены точно как значение с плавающей запятой, однако ошибки
вводится в сумму, если она не вычисляется с помощью fsum ().

 $ питон math_fsum.py

Входные значения: [0,1, 0,1, 0,1, 0,1, 0,1, 0,1, 0,1, 0,1, 0,1, 0,1]
сумма (): 0.99999999999999988898
для цикла: 0,99999999999999988898
math.fsum (): 1.00000000000000000000
 

factorial () обычно используется для вычисления количества
перестановки и комбинации ряда объектов. Факториал
положительного целого числа n , выраженного n !, определяется рекурсивно как
(п-1)! * n и останавливается на 0! == 1.

 импорт математики

для i в [0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.1]:
    пытаться:
        print '{: 2.0f} {: 6.0f}'. format (i, math.factorial (i))
    кроме ValueError, ошибка:
        print 'Ошибка вычисления факториала (% s):'% i, err
 

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

 $ питон math_factorial.py

 0 1
 1 1
 2 2
 3 6
 4 24
 5 120
Ошибка вычисления факториала (6.1): factorial () принимает только целые значения
 

gamma () похожа на factorial (), но работает с реальными
числа и значение сдвигается на единицу вниз (гамма равна (n —
1)!).

 импорт математики

для i в [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6]:
    пытаться:
        print '{: 2.1f} {: 6.2f}'. format (i, math.gamma (i))
    кроме ValueError, ошибка:
        print 'Ошибка вычисления гаммы (% s):'% i, err
 

Поскольку ноль приводит к отрицательному начальному значению, это недопустимо.

 $ питон math_gamma.ру

Ошибка вычисления гаммы (0): ошибка математической области
1,1 0,95
2,2 1,10
3,3 2,68
4,4 10,14
5,5 52,34
6,6 344,70
 

lgamma () возвращает натуральный логарифм абсолютного значения
Гамма для входного значения.

 импорт математики

для i в [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6]:
    пытаться:
        print '{: 2.1f} {: .20f} {: .20f}'. format (i, math.lgamma (i), math.log (math.gamma (i)))
    кроме ValueError, ошибка:
        print 'Ошибка вычисления lgamma (% s):'% i, err
 

Использование lgamma () сохраняет большую точность, чем вычисление
логарифм отдельно, используя результаты gamma ().

 $ питон math_lgamma.py

Ошибка вычисления lgamma (0): ошибка математической области
1,1 -0,04987244125984036103 -0,04987244125983997245
2,2 0,09694746679063825923 0,09694746679063866168
3,3 0,98709857789473387513 0,98709857789473409717
4,4 2,31610349142485727469 2,31610349142485727469
5.5 3.95781396761871651080 3.95781396761871606671
6,6 5,84268005527463252236 5,84268005527463252236
 

Оператор по модулю (%) вычисляет остаток от деления
выражение (т.е. 5% 2 = 1).5} ‘. Format (‘ x ‘,’ y ‘,’% ‘,’ fmod ‘).
Распечатать ‘—- —- —— ——‘

для x, y в [(5, 2),
(5, -2),
(-5, 2),
]:
print ‘{: 4.1f} {: 4.1f} {: 5.2f} {: 5.2f}’. format (x, y, x% y, math.fmod (x, y))

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

 $ питон math_fmod.py

 x y% fmod
---- ---- ----- -----
 5.0 2,0 1,00 1,00
 5,0 -2,0 -1,00 1,00
-5,0 2,0 1,00 -1,00
 

Показатели и логарифмы

Кривые экспоненциального роста появляются в экономике, физике и др.
науки. Python имеет встроенный оператор возведения в степень («**»),
но pow () может быть полезно, когда вам нужно передать вызываемый
функция в качестве аргумента.

 импорт математики

для x, y в [
    # Типичное использование
    (2, 3),
    (2.1, 3.2),

    # Всегда 1
    (1.0, 5),
    (2.0, 0),

    # Не-число
    (2, float ('nan')),

    # Корнеплоды
    (9.0, 0,5),
    (27,0, 1,0 / 3),
    ]:
    print '{: 5.1f} ** {: 5.3f} = {: 6.3f}'. format (x, y, math.pow (x, y))
 

Повышение 1 до любой степени всегда возвращает 1.0, как и повышение любого
значение в степени 0,0. Большинство операций с не-номером
значение nan return nan. Если показатель меньше 1,
pow () вычисляет корень.

 $ питон math_pow.py

  2,0 ** 3,000 = 8,000
  2,1 ** 3.200 = 10,742
  1.0 ** 5.000 = 1.000
  2,0 ** 0,000 = 1,000
  2,0 ** нан = нан
  9,0 ** 0,500 = 3,000
 27.0 ** 0,333 = 3,000
 

Поскольку квадратные корни (показатель степени 1/2) используются так часто,
это отдельная функция для их вычисления.

 импорт математики

напечатать math.sqrt (9.0)
напечатать math.sqrt (3)
пытаться:
    напечатать math.sqrt (-1)
кроме ValueError, ошибка:
    print 'Невозможно вычислить sqrt (-1):', err
    
 

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

 $ питон math_sqrt.py

3.0
1,73205080757
Невозможно вычислить sqrt (-1): ошибка математического домена
 

Функция логарифма находит y , где x = b ** y. По умолчанию,
log () вычисляет натуральный логарифм (основание: e ). Если
предоставляется второй аргумент, это значение используется в качестве основы.

 импорт математики

напечатать math.log (8)
напечатать math.log (8, 2)
напечатать math.log (0,5, 2)
 

Логарифмы

, где x меньше единицы, дают отрицательный результат.5} ‘. Формат (i, x, точное, неточное, совпадение)

Строки в выводе с завершающим * выделяют неточные
ценности.

 $ питон math_log10.py

i x точное неточное несоответствие
- ------------ -------------------- ---------------- ---- --------
 0 1.0 0.000000000000000000 0.000000000000000000
 1 10.0 1.000000000000000000 1.000000000000000000
 2 100,0 2.000000000000000000 2.000000000000000000
 3 1000.0 3.000000000000000000 2.999999999999999556 *
 4 10000.0 4.000000000000000000 4.000000000000000000
 5 100000.0 5.000000000000000000 5.000000000000000000
 6 1000000.0 6.000000000000000000 5.999999999999999112 *
 7 10000000.0 7.000000000000000000 7.000000000000000000
 8 100000000.0 8.000000000000000000 8.000000000000000000
 9 1000000000.0 9.000000000000000000 8.999999999999998224 *
 

log1p () вычисляет ряд Ньютона-Меркатора (естественный
логарифм 1 + x).

 импорт математики

х = 0,0000000000000000000000001
напечатайте 'x:', x
напечатайте '1 + x:', 1 + x
напечатать 'журнал (1 + x):', math.log (1 + x)
напечатать 'log1p (x):', math.log1p (x)
 

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

 $ питон math_log1p.py

х: 1e-25
1 + х: 1.0
журнал (1 + x): 0,0
log1p (x): 1e-25
 

exp () вычисляет экспоненциальную функцию (e ** x).

 импорт математики

х = 2

fmt = '% .20f'
напечатать fmt% (math.e ** 2)
напечатать fmt% math.pow (math.e, 2)
напечатать fmt% math.exp (2)
 

Как и в случае с другими функциями особого случая, он использует алгоритм, который
дает более точные результаты, чем эквивалент общего назначения
math.pow (math.e, x).

 $ питон math_exp.py

7.38905609893064951876
7.38905609893064951876
7,38905609893065040694
 

expm1 () является обратным к log1p () и вычисляет e ** x —
1.

 импорт математики

х = 0.0000000000000000000000001

напечатать x
напечатать math.exp (x) - 1
напечатать math.expm1 (x)
 

Как и в случае с log1p (), небольшие значения x теряют точность, когда
вычитание выполняется отдельно.

 $ питон math_expm1.py

1e-25
0,0
1e-25
 

Уголки

Хотя степени чаще используются в повседневных обсуждениях
углы, радианы являются стандартной единицей измерения углов в науке.
и математика. Радиан — это угол, образованный двумя линиями, пересекающимися в
центр круга, их концы на окружности
окружность, разнесенная на один радиус.7} ‘. Format (‘ ‘,’ ‘,’ ‘)

для deg, ожидаемого в [(0, 0),
(30, math.pi / 6),
(45, math.pi / 4),
(60, math.pi / 3),
(90, math.pi / 2),
(180, math.pi),
(270, 3 / 2,0 * math.pi),
(360, 2 * math.pi),
]:
print ‘{: 7d} {: 7.2f} {: 7.2f}’. format (deg, math.radians (deg), ожидается)

Формула преобразования: рад = град * π / 180.8} ‘. Format (‘ ‘,’ ‘,’ ‘)
для рад, ожидаемого в [(0, 0),
(math.pi / 6, 30),
(math.pi / 4, 45),
(math.pi / 3, 60),
(math.pi / 2, 90),
(math.pi, 180),
(3 * math.pi / 2, 270),
(2 * math.pi, 360),
]:
print ‘{: 8.2f} {: 8.2f} {: 8.2f}’. format (рад, math.degrees (rad), ожидается)

Формула: град = рад * 180 / π.

 $ питон math_degrees.py

Ожидаемые градусы в радианах
-------- -------- --------
    0,00 0,00 0,00
    0,52 30,00 30,00
    0,79 45,00 45,00
    1,05 60,00 60,00
    1,57 90,00 90,00
    3,14 180,00 180,00
    4,71 270,00 270,00
    6,28 360,00 360,00
 

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

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

Примечание

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

Учитывая угол в прямоугольном треугольнике, синус — это отношение
длина стороны, противоположной углу гипотенузы (sin A =
напротив / гипотенуза). Косинус — это отношение длины
сторона, прилегающая к гипотенузе (cos A = прилегающая / гипотенуза).
А касательная — это отношение противоположной стороны к соседней
сторона (загар A = противоположный / смежный).

 импорт математики

print 'Градусы радианы, синус, косинус, касательный'
Распечатать '-------  -------  -------  --------  -------'

fmt = '' .join (['% 7.2f'] * 5)

для градусов в диапазоне (0, 361, 30):
    рад = математические радианы (градусы)
    если deg в (90, 270):
        t = float ('бесконечность')
    еще:
        t = math.tan (рад)
    напечатать fmt% (deg, rad, math.sin (rad), math.cos (rad), t)
 

Тангенс также можно определить как отношение синуса угла
к его косинусу, и поскольку косинус равен 0 для π / 2 и 3π / 2 радиан,
касательная бесконечна.

 $ питон math_trig.py

Градусы Радианы Синус Косинус Тангенс
------- ------- ------- -------- -------
   0,00 0,00 0,00 1,00 0,00
  30,00 0,52 0,50 0,87 0,58
  60,00 1,05 0,87 0,50 1,73
  90,00 1,57 1,00 0,00 инф.
 120,00 2,09 0,87 -0,50 -1,73
 150,00 2,62 0,50 -0,87 -0,58
 180,00 3,14 0,00 -1,00 -0,00
 210,00 3,67 -0,50 -0,87 0,58
 240,00 4,19 -0.10} '. Format (' ',' ',' ')

для x, y в [# простых точек
              (1, 1),
              (-1, -1),
              (math.sqrt (2), math.sqrt (2)),
              (3, 4), треугольник # 3-4-5
              # по кругу
              (math.sqrt (2) / 2, math.sqrt (2) / 2), # pi / 4 рад
              (0.5, math.sqrt (3) / 2), # pi / 3 rads
              ]:
    h = math.hypot (x, y)
    print '{: 7.2f} {: 7.2f} {: 7.2f}'. format (x, y, h)
 

Точки на окружности всегда имеют гипотенузу == 1.

 $ питон math_hypot.8} '. Format (' ',' ',' ',' ',' ')


для (x1, y1), (x2, y2) в [((5, 5), (6, 6)),
                            ((-6, -6), (-5, -5)),
                            ((0, 0), (3, 4)), треугольник # 3-4-5
                            ((-1, -1), (2, 3)), треугольник # 3-4-5
                            ]:
    х = х1 - х2
    у = у1 - у2
    h = math.hypot (x, y)
    print '{: 8.2f} {: 8.2f} {: 8.2f} {: 8.2f} {: 8.2f}'. формат (x1, y1, x2, y2, h)
 

Используйте разницу в значениях x и y , чтобы переместить одну конечную точку в
происхождение, а затем передайте результаты в hypot ().

 $ питон math_distance_2_points.py

   X1 Y1 X2 Y2 Расстояние
-------- -------- -------- -------- --------
    5,00 5,00 6,00 6,00 1,41
   -6,00 -6,00 -5,00 -5,00 1,41
    0,00 0,00 3,00 4,00 5,00
   -1,00 -1,00 2,00 3,00 5,00
 

Математика

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

 импорт математики

для r в [0, 0,5, 1]:
    print 'arcsine (%. 1f) =% 5.2f'% (r, math.asin (r))
    напечатайте 'arccosine (%. 1f) =% 5.2f'% (r, math.acos (r))
    print 'арктангенс (%. 1f) =% 5.2f'% (r, math.atan (r))
    Распечатать
 

1,57 примерно равно π / 2, или 90 градусов, угол при
что синус равен 1, а косинус равен 0.

 $ питон math_inverse_trig.py

арксинус (0,0) = 0,00
арккозин (0,0) = 1,57
арктангенс (0,0) = 0,00

арксинус (0,5) = 0,52
арккозин (0,5) = 1,05
арктангенс (0,5) = 0,46

арксинус (1,0) = 1,57
арккозин (1,0) = 0,00
арктангенс (1.0) = 0.6} '. Format (' ',' ',' ',' ')

fmt = '' .join (['{: 6.4f}'] * 4)

для i в диапазоне (0, 11, 2):
    х = 1 / 10,0
    напечатать fmt.format (x, math.sinh (x), math.cosh (x), math.tanh (x))
    
 

В то время как функции косинуса и синуса описывают круг,
гиперболический косинус и гиперболический синус образуют половину гиперболы.

 $ питон math_hyperbolic.py

  X sinh cosh tanh
------ ------ ------ ------
0,0000 0,0000 1,0000 0,0000
0,2000 0,2013 1,0201 0,1974
0,4000 0,4108 1,0811 0.7} '. Format (' ',' ')

для x в [-3, -2, -1, -0,5, -0,25, 0, 0,25, 0,5, 1, 2, 3]:
    print '{: 5.2f} {: 7.4f}'. format (x, math.erf (x))
    
 

Обратите внимание, что erf (-x) == -erf (x).

 $ питон math_erf.py

  x erf (x)
----- -------
-3,00 -1,0000
-2,00 -0,9953
-1,00 -0,8427
-0,50 -0,5205
-0,25 -0,2763
 0,00 0,0000
 0,25 0,2763
 0,50 0,5205
 1,00 0,8427
 2,00 0,9953
 3,00 1,0000
 

Дополнительная функция ошибок — 1 — erf (x).

 импорт математики

напечатайте '{: ^ 5} {: 7}'.7} '. Format (' ',' ')

для x в [-3, -2, -1, -0,5, -0,25, 0, 0,25, 0,5, 1, 2, 3]:
    print '{: 5.2f} {: 7.4f}'. format (x, math.erfc (x))
    
 

 $ python math_erfc.py

  х erfc (х)
----- -------
-3,00 2,0000
-2,00 1,9953
-1,00 1,8427
-0,50 1,5205
-0,25 1,2763
 0,00 1,0000
 0,25 0,7237
 0,50 0,4795
 1,00 0,1573
 2,00 0,0047
 3,00 0,0000
 

См. Также

математика

Стандартная библиотека документации для этого модуля.

Арифметика с плавающей запятой IEEE в Python

Сообщение в блоге Джона Кука о том, как возникают и возникают особые ценности
разобрались при выполнении математики в Python.

SciPy

Библиотеки с открытым исходным кодом для научных и математических
расчеты на Python.

.