Модуль числа в питоне: Python. Модуль math. Теоретико-числовые функции. Функции представления. Примеры

Содержание

complex комплексные числа | Python

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

Создание комплексных чисел

Мы знаем, что любое комплексное число $z$ задается его действительной частью $a$, мнимой частью $b$ и в нем всегда присутствует символ $i$, обозначающий мнимую единицу. В Python все практически точно так же, только мнимую единицу обозначают символом j (реже J), а числа $a$ и $b$ могут быть любыми числами типа int или float. Например, комплексные числа в Python могут выглядеть следующим образом:

3 + 7j
100. 0 + 0.001j
100. + .00j
2e-10 - 2e10j

Кстати, символ мнимой единицы j не может существовать сам по себе, к нему обязательно должно быть присоединено какое-то число, т.е. мнимая единица в Python выглядит как 1j, а любое число у которого действительная часть равна $0$ можно указывать без нее, например, все вышеуказанные числа без действительной части, для интерпретатора Python считаются приемлемыми:

7j
0.001j
.00j
2e10j

Интуитивно понятно, что если в числе $a+bi$ мнимая часть $b=0$, то оно автоматически становится обычным вещественным числом, потому что $z=a+0i=a$. Но в то же время все вещественные числа, являются подмножеством комплексных, значит число $a$ это комплексное число у которого мнимая часть равна $0$. В математике это так, но в Python нет, т.е. автоматического преобразования чисел типа complex в числа типа int или float не происходит, даже если их мнимая часть равна $0$:

>>> 10 + 0j    #  это число могло бы стать числом типа int
(10+0j)
>>> 
>>> 3. 14 - 0j    #  а это могло бы стать float
(3.14+0j)

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

>>> -1/2    #  результат может быть только типа float
-0.5
>>> 
>>> (-0.5)**0.5    #  результат может быть только типа complex
(4.329780281177467e-17+0.7071067811865476j)

Именно поэтому, комплексное 3.14 - 0j не станет вещественным 3.14. Более того, даже если такие комплексные числа передать встроенным функциям int() или float(), то это приведет к ошибке:

>>> int(2 + 0j)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to int

Для нас очевидно, что раз мнимая часть равна $0$ то к типу int нужно приводить его действительную часть. Но то что очевидно для нас, не всегда очевидно для интерпретатора. Однако, мы можем работать с отдельными частями комплексного числа с помощью атрибутов real и imag. Так что наше преобразование можно записать так:

>>> int((2 + 0j).real)
2

Особо бдительные, могут заметить, что можно вообще обойтись без функции int() потому что действительная часть числа и так типа int, однако, атрибуты real и imag всегда возвращают вещественный результат (тип float).

Встроенная функция complex()

Встроенная функция complex(real[, imag]) позволяет создать комплексное число на основе значений его действительной и мнимой частей:

>>> complex(1)    #  аргумент imag не обязателен
(1+0j)
>>> 
>>> complex(1, 2e-2)
(1+0. 02j)

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

>>> complex('1+2j')
(1+2j)
>>> complex('0.1+2.0j')
(0.1+2j)
>>> complex('.1+2.j')
(0.1+2j)
>>> complex('1e3+2e-3j')
(1000+0.002j)

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

>>> complex('1e3 + 2e-3j')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

Представление на комплексной плоскости

Целые и вещественные числа в геометрическом представлении являются точками на числовом луче:

Геометрическим представлением комплексных чисел являются точки на плоскости. Данная плоскость называется комплексной и абсолютно аналогична прямоугольной системе координат, только по оси абцис (x) откладывается величина действительной части (real), а по оси ординат (y) ооткладывается величина мнимой части (imag). Например, точка $A(3, 4)$ и комплексное число $z = 3 + 4i$ будут выглядеть вот так:

Как видите, изображение комплексных чисел на плоскости довольно простой процесс, по сути это те же самые декартовы координаты, которые получаются по правилу: $x=\mathrm {Re} \,z; \quad y=\mathrm {Im} \,z$. А в Python получение тех же координат будет выглядеть аналогично:

>>> z = 3 + 4j
>>> 
>>> z.real, z.imag
(3.0, 4.0)

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

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

Сложение двух комплексных чисел $A=a+bi$ и $B=c+di$ выполняется по простой формуле:

$$A+B = \left(a+bi\right)+\left(c+di\right)=\left(a+c\right)+\left(b+d\right)i$$

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

>>> a = -5 + 3j
>>> b = 4 + 2j
>>> 
>>> a + b
(-1+5j)

На предыдущем рисунке мы видели, что комплексное число это точка на комплексной плоскости. Но если заметить что значения действительной и мнимой части отсчитываются от начала координат, то уместно задать вопрос: «А нельзя ли изображать эти числа в виде векторов?» Ответ: «Можно. » Данные числа действительно можно рассматривать как радиус-векторы:

Разность комплексных чисел задается похожим образом:

$$A-B = \left(a+bi\right)-\left(c+di\right)=\left(a-c\right)+\left(b-d\right)i$$

Умножение комплексного числа на вещественное число выполняется очень просто: $kA = k\left(a+bi\right)=ka + kbi$ и по сути просто меняет лишь длину радиус вектора комплексного числа, вдоль его направления:

>>> a = 2 + 2j
>>> 
>>> a*2
(4+4j)
>>> 
>>> a*(-1.5)
(-3-3j)

А вот умножение комплексных чисел друг на друга немного сложнее:

$$(a+bi)\cdot (c+di)=(ac-bd)+(bc+ad)i$$

Как всегда в Python мы сразу видим результат:

>>> a = 1 + 1j
>>> b = 1 + 4j
>>> 
>>> a*b
(-3+5j)

Который на комплексной плоскости выглядит вот так:

Можно было бы предположить, что это что-то вроде векторного или скалярного умножения векторов, но нет, умножение комплексных чисел, отличается от этих двух операций. {2}}}\right)i$$

Давайте посмотрим как это выглядит в Python и на комплексной плоскости:

>>> a = -5 - 1j
>>> b = -1 + 1j
>>> 
>>> a/b
(2+3j)

Математические операции

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

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

№	Операция	Результат	Замечание
1	`x ** y`	возводит x в степень y	(I)
2	`pow(x, y[, z])`	возводит x в степень y по модулю z, где z – необязательный аргумент. Если указан параметр z, то это приведет к ошибке ValueError	(I)
3	`divmod(x, y)`	возвращает кортеж с парой чисел `(x // y, x % y)`	(II)
4	`x.conjugate()`	возвращает $\bar{x}$ — число, которое комплексно сопряжено с $x$
5	`complex(re, im)`	преобразует re в комплексное число (по умолчанию `im = 0`)	(V)(VI)
6	`float(x)`	преобразует x в вещественное число (число с плавающей точкой). Если x комплексное, то будет вызвано исключение TypeError	(VI)
7	`int(x)`	переобразует x в целое число, представленное в десятичной системе счисления. Если x комплексное, то будет вызвано исключение TypeError	(VI)
8	`abs(x)`	абсолютное значение (модуль) числа x	(III)
9	`+x`	делает число x положительным
10	`-x`	делает число x отрицательным
11	`x % y`	остаток от деления x на y	(II)
12	`x // y`	результат целочисленного деления x на y	(II)
13	`x / y`	результат «истинного» деления x на y	(IV)
14	`x * y`	произведение x и y
15	`x - y`	разность x и y
16	`x + y`	сумма x и y

Важно: приоритет математических операций выше операций сравнения.

Замечания:

I. возведение $0+0i$ в степень $0+0i$ возвращает $1+0i$:

>>> c = 0 + 0j
>>> c
0j
>>> 
>>> c**c
(1+0j)

II. функция divmod() и операция %, // не работают для комплексных чисел. Для вас это может быть и очевидно, но не пользователя для которого вы пишите программу.

III. Функция abs() всегда возвращает результат типа float.

IV. деление на $0+0i$ приведет к ошибке и вызовет исключение ZeroDivisionError.

V. встроенная функция complex() пропускает числа (объекты) типа complex «как есть», не выполняя над ними, абсолютно никаких действий.

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

Операции сравнения

Для сравнения чисел имеется $8$ операций, но для комплексных чисел доступно только $4$ причем все они имеют одинаковый приоритет:

№	Операция	Результат	Замечание
1	`x < y`	True если x меньше y, иначе False	(I)
2	`x <= y`	True если x меньше или равно y, иначе False	(I)
3	`x > n`	True если x больше y, иначе False	(I)
4	`x >= n`	True если x больше или равно y, иначе False	(I)
5	`x == y`	True если x равно y, иначе False
6	`x != y`	True если x не равно y, иначе False
7	`x is y`	True если x и y это один и тот же объект, иначе False
8	`x is not y`	True если x и y это не один и тот же объект, иначе False

Важно: приоритет операций сравнения ниже математических.

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

>>> a = 3+4j
>>> 
>>> abs(a) < 6
True
>>> 
>>> a < 6
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: complex() < int()

Функция ABS — Служба поддержки Office

В этой статье описаны синтаксис формулы и использование функции ABS в Microsoft Excel.

Описание

Возвращает модуль (абсолютную величину) числа. Абсолютная величина числа — это число без знака.

Синтаксис

ABS(число)

Аргументы функции ABS описаны ниже.

Пример

Скопируйте таблицу ниже и вставьте ее в ячейку A1 в Excel. Возможно, для работы формул понадобится выбрать все ячейки с ними и нажать клавишу F2, а затем — клавишу ВВОД. Можно также расширить столбцы для более удобного просмотра листа.

Данные
-4
Формула	Описание	Результат
=ABS(2)	Абсолютное значение числа 2	2
=ABS(-2)	Абсолютное значение числа -2	2
=ABS(A2)	Абсолютное значение числа -4	4

Данные

-4

Формула

Описание

Результат

=ABS(2)

Абсолютное значение числа 2

=ABS(-2)

Абсолютное значение числа -2

=ABS(A2)

Абсолютное значение числа -4

См.

также

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

Умножение и деление чисел в Excel

Расчет процентов

Как получить случайное число в Python? Что такое генераторы? А модуль random?

Генераторы очень просты в реализации, но немного сложны для понимания.

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

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

Вот простой пример функции генератора, которая возвращает 7 случайных целых чисел:

  import random

  def lottery():
      # returns 6 numbers between 1 and 40
      for i in range(6):
          yield random.randint(1, 40)

      # returns a 7th number between 1 and 15
      yield random.randint(1,15)

  for random_number in lottery():
         print("And the next number is... %d!" %(random_number))

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

Упражнение

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

a = 1
b = 2
a, b = b, a
print(a,b)

будет одновременно переключать значения a и b.

# fill in this function def fib(): pass #this is a null statement which does nothing when executed, useful as a placeholder. # testing code import types if type(fib()) == types.GeneratorType: print("Good, The fib function is a generator.") counter = 0 for n in fib(): print(n) counter += 1 if counter == 10: break # fill in this function def fib(): a, b = 1, 1 while 1: yield a a, b = b, a + b # testing code import types if type(fib()) == types.GeneratorType: print("Good, The fib function is a generator. ") counter = 0 for n in fib(): print(n) counter += 1 if counter == 10: break test_output_contains("Good, The fib function is a generator.") success_msg('Good work!')

`Модуль math в Python, математические функции.`

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

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

`Функции теории чисел модуля math в Python.`

В этом разделе представлены функции относящиеся к теории чисел. Факториал числа, Наибольший общий делитель, Абсолютное значение числа, Остаток от деления, дробная и целая часть числа, число x со знаком числа y, Сравнение в пределах указанной точности.

`Функции округления чисел модуля math в Python.`

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

`Степенные и логарифмические функции в Python.`

В этом разделе представлены степенные и логарифмические функции модуля `math`. `x` в степени `y`, Квадратный корень числа, Логарифм числа по указанному основанию, Десятичный логарифм, Двоичный логарифм числа, Натуральный логарифм от `x + 1`, `e**x`, `e**x - 1`.

`Тригонометрические функции модуля math в Python.`

В этом разделе представлены тригонометрические функции модуля math. Синус, косинус, тангенс, арксинус, арккосинус, арктангенс, арктангенс значения y/x

`Функции преобразование меры углов модуля math в Python.`

В этом разделе представлены функции преобразование меры углов модуля `math`

`Гиперболические функции модуля math в Python.`

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

`Константы и специальные значения модуля math в Python.`

Константы модуля math - Pi, E, inf, nan. Проверки на бесконечность, на не число и на то и другое.

`Специальные функции модуля math в Python.`

В этом разделе представлены специальные функции модуля `math`.

`Модуль random - Python: Основы`

Python: Основы

`Модуль`

random

Python знаменит тем, что поставляется в комплекте с "батарейками" - так называют модули и пакеты, составляющие стандартную библиотеку. Более того, батареек в поставке Пайтона изрядное количество! Настоящий питонист (pythonista) - так мы, программисты на Python, себя называем - обязан хорошо ориентироваться в стандартной библиотеке, ведь это знание позволяет экономить время и силы. В этом уроке мы познакомимся с первой батарейкой - модулем random.

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

Любое значение в компьютере может быть представлено в виде набора чисел, поэтому получение случайных значений всегда предполагает использование Генератора Случайных Чисел, ГСЧ. ГСЧ бывают программными (специализированные программы) и аппаратными (специализированные устройства), но программист обычно работает с некоторой обобщённой "обёрткой" - модулем или пакетом, который скрывает ненужные детали.

Модуль random предоставляет множество функций, полезных в разных ситуациях, но мы пока остановимся на двух:

randint, генерация целого числа в заданном диапазоне,
choice, выбор случайного элемента из заданного набора.

`Генерация случайных чисел`

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

from random import randint

Теперь мы можем сгенерировать число от 1 до 100:

random_number = randint(1, 100)

При вызове randint с такими границами диапазона может "выпасть" и 1 и 100 - обе границы диапазона включены, и об этом следует помнить. Когда это может быть важно? Давайте рассмотрим другой пример - выбор случайного символа некоторой строки:

string = 'abcde'
random_index = randint(0, len(string) - 1)
char = string[random_index]

Строка в переменной string имеет длину 5. Но мы помним, что символы строки индексируются с нуля, поэтому если сгенерировать индекс так randint(0, 5), то в какой-то момент мы получим значение 5, и при попытке взять символ по этому индексу мы увидим ошибку IndexError: индекс последнего элемента в строке равен 4! Вот поэтому в коде выше из длины вычитается единица.

`Выбор случайного элемента`

Выше мы рассмотрели пример, в котором выбирался случайный символ строки. Эта задача возникает достаточно часто, поэтому в модуле random существует функция choice. С использованием этой функции выбор символа строки будет выглядеть так:

from random import choice

string = 'abcde'
char = choice(string)

При использовании choice не нужно думать о границах генерируемых индексов. И даже о самих индексах думать не нужно - функция сама знает, как правильно и безопасно выбирать элементы! Правда, придётся заботиться о том, чтобы строка, из который мы выбираем символы, не была пустой, иначе мы получим ошибку IndexError: Cannot choose from an empty sequence ("Нельзя просто так взять и выбрать, если выбирать не из чего").

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

`Случайна ли случайность?`

Строго говоря, генерируемые числа у компьютера получаются не полностью случайными, поэтому большинство ГСЧ представляют собой генераторы псевдослучайных чисел. И хотя для простоты приставку "псевдо-" часто опускают (как поступили и мы), о ней не стоит забывать. Дело в том, что некоторые алгоритмы требуют максимально случайной генерации чисел. Одна из областей с такими высокими требованиями к качеству случайности — криптография (шифрование). Представьте, что вы сгенерировали случайный пароль, длинный и сложный, а злоумышленник, пользуясь тем, что при определённых условиях можно воспроизвести ту же последовательность случайных чисел, получил тот же пароль! Вот поэтому существует большое количество специализированных ГСЧ, безопасных для использования в шифровании и создание таких генераторов - это важная, сложная и интересная работа.

`Ссылки`

`Остались вопросы? Задайте их в разделе «Обсуждение»`

Вам ответят команда поддержки Хекслета или другие студенты.

Ошибки, сложный материал, вопросы >

`Нашли опечатку или неточность?`

Выделите текст, нажмите ctrl + enter и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.

`Что-то не получается или материал кажется сложным?`

Загляните в раздел «Обсуждение»:

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

`Об обучении на Хекслете`

`Python и числа. | Admins.kz`

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

Почему нельзя свалить все данные в одну общую кучу и не заморачиваться с каждым типом по отдельности? Допустим, мы присвоили переменной a цифру 5: a = 5. А теперь представьте, что никакого разделения по типу данных нет. Так что находится в переменной: число или строка? Если 10 – это число, то с ним можно произвести математические действия. А если это строка, то мы имеем дело с текстом и тогда Python задействует совсем другие методы.

# объединение строк (конкатенация) d = '10' f = 'негритят' d + ' ' + f '10 негритят'

Ключевой момент: У каждого типа данных свои методы.

Цифра 100 написанная без кавычек, относится к числовому типу данных. А цифра ‘100’ в кавычках – к строковому типу. С помощью синтаксиса, мы сообщаем Python, какой у нас тип данных. Числа в Python делятся на два вида: целое число и вещественное.

`Целое число`

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

-80, -10, -4, 0, 1, 2, 20

`Вещественное число`

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

-5.2, -3.1, 7.8, 9.33

`Математические операции с числами`

Ради математических вычислений в Python и существует числовой тип данных.

`Сложение чисел`

e = 45 + 55 print(e) 100

j = 4.5 + 5 print(j) 9.5

`Вычитание чисел`

z = 15 - 4 print(z) 11

`Умножение чисел`

i = 3 * 2 print(i) 6

`Деление чисел`

У результата деления целого числа на целое, всегда будет дробная часть. Такая особенность обусловлена тем, что в большинстве случаев числа не делятся без остатка.

k = 9/3 print(k) 3.0

`Целочисленное деление`

В результате целочисленного деления, всегда будет целое число. Мы просто отбрасываем остаток. Число 15 поместится целых 2 раза.

m = 40 // 15

print(m)

2

`Остаток от деления`

Ответом будет остаток от деления. При обычном делении, ответ был бы 15.1. Но нам нужен только остаток. Убираем целое число и оставляем 1.

n = 16 % 3 print(n) 1

o = 12 % 3 print(4) 0

`Возведение числа в степень`

Число перед двумя звездочками – это объект, который нужно возвести в степень. Цифра после звездочек обозначает, в какую степень возводим: 4 возводим во вторую степень.

l = 4 ** 2 print(l) 16

В Python есть встроенные математические функции.

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

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

>>> abs(-5) 5 >>> abs(5) 5

`Наименьшее число`

Функция min() в Python возвращает самое маленькое число.

>>> min(1,8,9) 1

`Максимальное число`

Функция max() вернет самое большое число.

>>> max(25, 8, 57) 57

`Округление до целого числа`

Функция round() округляет до целого числа.

>>> round(2.33) 2 >>> round(4.5) 4

`Вывести число в Python`

Функция print() выводит числа на экран.

print(2,3,4)

2 3 4

`Ввести число в Python`

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

>>> r = input() 33 >>> r '33' # это строка

Python вывел строку, так как число стоит в кавычках.

Для ввода целого числа, следует обернуть функцию input() в другую функцию int().

>>> s = int(input()) 22 >>> s 22

Для вещественного числа, соответственно в float().

>>> s t = float(input()) 11.9 >>> t 11.9

`Как посчитать сумму введенных чисел?`

В команде input() можно передавать подсказки.

w = int(input("Введите первое число: ")) q = int(input("Введите второе число: ")) summa=w+q print(summa)

Введите первое число: 6 Введите второе число: 7 13

на Ваш сайт.

`Модуль числа, определение и свойства`

`Определение модуля числа`

Алгебра дает четкое определения модуля числа. Модуль в математике — это расстояние от начала отсчёта до точки координатной прямой, соответствующей этому числу.

Если мы возьмем некоторое число «a» и изобразим его на координатной прямой точкой «A» — расстояние от точки «A» до начала отсчёта (то есть до нуля, длина отрезка «OA») будет называться модулем числа «a».

Знак модуля: |a| = OA

Разберем на примере:

Точка «В», которая соответствует числу «−3», находится на расстоянии 3 единичных отрезков от точки 0 (то есть от начала отсчёта). То есть длина отрезка «OB» равна 3 единицам.

Число 3 (длина отрезка «OB») называют модулем числа «−3».

Обозначение модуля: |−3| = 3

Читают символы выше следующим образом: «модуль числа минус три равен трем».

Точка «С», которая соответствует числу «+4», находится на расстоянии четырех единичных отрезков от начала отсчёта, то есть длина отрезка «OС» равна четырем единицам.

Число 4 называют модулем числа «+4» и обозначают так: |+4| = 4.

Также можно опустить плюс и записать значение, как |4| = 4.

`Свойства модуля числа`

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

1. Модуль числа — это расстояние, а расстояние не может быть отрицательным. Поэтому и модуль числа не бывает отрицательным:

2. Модуль положительного числа равен самому числу.

3. Модуль отрицательного числа равен противоположному числу.

|−a| = a, если a < 0

4. Модуль нуля равен нулю.

5. Противоположные числа имеют равные модули.

6. Модуль произведения равен произведению модулей этих чисел.

|a b| = |a| |b|, когда

a·b 0

или

−(a·b), когда a·b<0

7. Модуль частного равен частному от деления модуля числа числителя на модуль числа знаменателя:

`Геометрическая интерпретация модуля`

Как мы уже знаем, модуль числа — это расстояние от нуля до данного числа. То есть расстояние от точки −5 до нуля равно 5.

Нарисуем числовую прямую и отобразим это на ней.

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

Решим уравнение: |х| = 5

Мы видим, что на числовой прямой есть две точки, расстояние от которых до нуля равно 5. Это точки 5 и −5. Значит, уравнение имеет два решения: x = 5 и x = −5.

Когда у нас есть два числа a и b, то их разность |a - b| равна расстоянию между ними на числовой прямой. Или длине отрезка АВ

Расстояние от точки a до точки b равно расстоянию от точки b до точки a, тогда |a - b| = |b - a|.

Решим уравнение: |a - 3| = 4 . Запись читаем так: расстояние от точки а до точки 3 равно 4. Отметим на числовой прямой точки, удовлетворяющие этому условию.

Уравнение имеет два решения: −1 и 7. Мы из 3 вычли 4 - и это один ответ, а также к 3 мы прибавили 4 - и это второй ответ.

Решим неравенство: |a + 7| < 4 .

Эту запись читаем так: расстояние от точки a до точки −7 меньше четырёх. Отмечаем на числовой прямой точки, удовлетворяющие этому условию:

Ответ в данном случае будет таким: (-11; -3).

Решим неравенство: |10 − x| ≥ 7.

Расстояние от точки 10 до точки x больше или равно семи. Отметим эти точки на числовой прямой.

Ответ: ( -; 3] [17, +)

`График функции`

График функции равен y = |х|.

Для x 0 имеем y = x.

Для x < 0 имеем y = −x. В результате получаем:

Этот график можно использовать при решении уравнений и неравенств.

`Корень из квадрата`

В контрольной или задаче ЕГЭ может встретиться задачка, в которой просят вычислить √a² , где a – некоторое число или выражение.

При этом, √a²= |a|.

По определению арифметического квадратного корня √a² — это такое неотрицательное число, квадрат которого равен a² .

Оно равно a, при а 0 и -а, при а < 0 , т. е. как раз |a|.

`Модуль комплексного числа`

У нас есть комплексное число, которое выглядит следующим образом: z=x+i·y, где x и y представляют собой действительную и мнимую части комплексного числа z (и являются действительными), а i — мнимая единица и равна √-1

Чему равен модуль числа в данном случае? Это арифметический квадратный корень из суммы квадратов действительной и мнимой части комплексного числа:

Свойства модуля комплексных чисел

Область определения: вся комплексная плоскость.
Область значений: [0;+∞).
Модуль как комплексная функция не дифференцируется ни в одной точке, так как условия Коши-Римана не выполнены.

`Модуль рационального числа`

Как найти модуль рационального числа — это расстояние от начала отсчёта до точки координатной прямой, которая соответствует этому числу.

Модуль рационального числа, примеры:

|-3,5| = 3,5

|0| = 0

`Модуль вещественных чисел`

Область определения: (−∞;+∞).
Область значений: [0;+∞).
Функция чётная.
Функция дифференцируется везде, кроме нуля. В точке x=0 функция претерпевает излом.

`Модуль противоположного числа, нуля, отрицательного и положительного чисел`

Исходя из свойств модуля, которые мы рассмотрели выше, получаем:

Противоположные числа имеют равные модули, то есть |- а| = |а| = a. Если посмотреть это относительно координатной прямой, то две точки, у которых координаты - это противоположные числа, располагаются на одном расстоянии от начала отсчета. То есть модули противоположных чисел одинаковы.
Модуль нуля равен нулю. |0| = 0, если a = 0
Для положительного числа модуль равен самомý числу, а для отрицательного – противоположному числу. |а| = - а |−a| = a

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

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

`cmath - Математические функции для комплексных чисел - документация Python 3.9.5`

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

Примечание

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

`Преобразование в полярные координаты и обратно`

Комплексное число Python z хранится внутри с использованием прямоугольника или декартовых координат .Это полностью определяется его реальными часть z.real и ее мнимая часть z.imag . В другом слов:

Полярные координаты дают альтернативный способ представления комплекса номер. В полярных координатах комплексное число z определяется как модуль r и фазовый угол phi . Модуль r - это расстояние от z до начала координат, а фаза phi - против часовой стрелки угол, измеряемый в радианах, от положительной оси x до линии сегмент, соединяющий начало координат с z .

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

смат. фаза ( x )

Вернуть фазу x (также известную как аргумент x ) как плавать. phase (x) эквивалентно math.atan2 (x.imag, x.real) . Результат лежит в диапазоне [- π , π ], и ветвь разрез для этой операции лежит по отрицательной действительной оси, непрерывный сверху.В системах с поддержкой нулей со знаком (который включает в себя большинство используемых в настоящее время систем), это означает, что знак результата такой же, как знак x.imag , даже если x.imag равно нулю:

 >>> фаза (комплекс (-1,0; 0,0))
3,1415589793
>>> фаза (комплекс (-1,0, -0,0))
-3.1415589793

Примечание

Модуль (абсолютное значение) комплексного числа x может быть вычисляется с помощью встроенной функции abs () .Здесь нет отдельная функция модуля cmath для этой операции.

смат. полярный ( x ): Вернуть представление x в полярных координатах. Возвращает пара (r, phi) , где r - это модуль x , а phi - это фаза х . полярный (x) эквивалентен (абс (x), фаза (x)) .

смат. прямоугольник ( r , phi ): Вернуть комплексное число x с полярными координатами r и phi . Эквивалентно r * (math.cos (phi) + math.sin (phi) * 1j) .

`Степенные и логарифмические функции`

смат. эксп. ( x ): Возврат e в степени x , где e - основание естественного логарифмы.

смат. журнал ( x [, основание ]): Возвращает логарифм x к заданному основанию . Если base нет указано, возвращает натуральный логарифм x . Есть один срез ветки, от 0 вдоль отрицательной действительной оси до -∞, непрерывно сверху.

смат. лог10 ( x ): Вернуть десятичный логарифм x .У него такая же ветка, что и у журнал () .

смат. кв. ( x ): Вернуть квадратный корень из x . У него такое же сечение ветки, как у log () .

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

смат. acos ( x ): Вернуть арккосинус x . Есть два разреза ветки: один идет прямо от 1 вдоль вещественной оси до ∞, непрерывный снизу.Другой простирается слева от От -1 по действительной оси до -∞, непрерывно сверху.

смат. asin ( x ): Вернуть арксинус x . Он имеет те же сечения ветвей, что и acos () .

смат. атан ( x ): Вернуть арктангенс x . Есть два отрезка ответвления: один идет от 1j вдоль мнимой оси до ∞j , непрерывно справа.В другой простирается от -1j вдоль мнимой оси до -∞j , непрерывно слева.

смат. cos ( x ): Вернуть косинус x .

смат. sin ( x ): Вернуть синус x .

смат. желто-коричневый ( x ): Вернуть тангенс x .

`Гиперболические функции`

смат. acosh ( x ): Вернуть обратный гиперболический косинус x . Есть один срез ветки, продолжающаяся слева от 1 вдоль вещественной оси до -∞, непрерывная сверху.

смат. асинь ( x ): Вернуть обратный гиперболический синус x . Есть два отреза ветки: Один простирается от 1j вдоль мнимой оси до ∞j , непрерывный справа.Другой простирается от -1j вдоль мнимая ось до -∞j , непрерывная слева.

смат. атанх ( x ): Вернуть арктангенс гиперболического значения x . Есть два отрезка ветки: один. простирается от 1 вдоль действительной оси до ∞ , непрерывно снизу. В другой простирается от -1 вдоль действительной оси до -∞ , непрерывно от выше.

смат. цвет ( x ): Вернуть гиперболический косинус x .

смат. sinh ( x ): Вернуть гиперболический синус x .

смат. танх ( x ): Вернуть гиперболический тангенс x .

`Классификационные функции`

смат. исфинит ( x ): Вернуть Истинно , если действительная и мнимая части x конечны, и Неверно иначе.

смат. isinf ( x ): Вернуть Истинно , если действительная или мнимая часть x является бесконечность и Ложь в противном случае.

смат. иснан ( x ): Вернуть Истинно , если действительная или мнимая часть x является NaN, и Неверно в противном случае.

смат. isclose ( a , b , * , rel_tol = 1e-09 , abs_tol = 0,0 )

Вернуть Истина , если значения a и b близки друг к другу и Неверно иначе.

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

rel_tol - относительный допуск - это максимально допустимая разница. между a и b относительно большего абсолютного значения a или b .Например, чтобы установить допуск 5%, передайте rel_tol = 0,05 . По умолчанию допуск 1e-09 , что гарантирует, что два значения совпадают с точностью до 9 десятичных цифр. rel_tol должно быть больше нуля.

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

Если ошибок не происходит, результатом будет: абс (a-b) <= max (rel_tol * max (abs (a), abs (b)), abs_tol) .

Специальные значения IEEE 754: NaN , inf и -inf будут обрабатывается в соответствии с правилами IEEE. В частности, NaN не считается близко к любому другому значению, включая NaN . inf и -inf только считается близким к себе.

См. Также

PEP 485 - Функция проверки примерного равенства

`Константы`

смат. пи: Математическая константа π в виде числа с плавающей запятой.

смат. e: Математическая константа e в виде числа с плавающей запятой.

смат. тау: Математическая константа τ , в виде числа с плавающей запятой.

смат. инф: Положительная бесконечность с плавающей точкой.Эквивалент с плавающей запятой ('inf') .

смат. инфдж: Комплексное число с нулевой действительной частью и мнимой положительной бесконечностью часть. Эквивалент комплексному (0,0, float ('inf')) .

смат. нан: Значение с плавающей запятой, «не число» (NaN). Эквивалентно с плавающей запятой ('nan') .

смат. нанж: Комплексное число с нулевой действительной частью и мнимой частью NaN. Эквивалентно комплекс (0,0, число с плавающей запятой ('nan')) .

Обратите внимание, что набор функций аналогичен, но не идентичен тому, что в модуль математика . Причина наличия двух модулей в том, что некоторые пользователи не интересуются комплексными числами и, возможно, даже не знают, что это такое. Они предпочел бы math.sqrt (-1) вызывать исключение, чем возвращать сложный номер.Также обратите внимание, что функции, определенные в cmath , всегда возвращают комплексное число, даже если ответ может быть выражен действительным числом (в котором случай комплексного числа имеет мнимую часть нуля).

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

См. Также

Кахан, W: Отрезки ветвей для сложных элементарных функций; или, много шума о ничего не значащий бит. В: Изерлес, А., и Пауэлл, М. (ред.), Современное состояние в численном анализе. Clarendon Press (1987), стр. 165–211.

`6. Модули - документация Python 3.9.5`

 >>> import builtins
>>> dir (встроенные)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
 BlockingIOError, BrokenPipeError, BufferError, BytesWarning,
 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
 ConnectionRefusedError, ConnectionResetError, DeprecationWarning,
 EOFError, Ellipsis, EnvironmentError, Exception, False,
 FileExistsError, FileNotFoundError, FloatingPointError,
 FutureWarning, GeneratorExit, IOError, ImportError,
 ImportWarning, IndentationError, IndexError, InterruptedError,
 IsADirectoryError, KeyError, KeyboardInterrupt, LookupError,
 MemoryError, NameError, None, NotADirectoryError, NotImplemented,
 NotImplementedError, OSError, OverflowError,
 PendingDeprecationWarning, PermissionError, ProcessLookupError,
 ReferenceError, ResourceWarning, RuntimeError, RuntimeWarning,
 StopIteration, SyntaxError, SyntaxWarning, SystemError,
 SystemExit, TabError, TimeoutError, True, TypeError,
 UnboundLocalError, UnicodeDecodeError, UnicodeEncodeError,
 UnicodeError, UnicodeTranslateError, UnicodeWarning, UserWarning,
 'ValueError', 'Предупреждение', 'ZeroDivisionError', '_', '__build_class__',
 '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',
 all, any, ascii, bin, bool, bytearray, bytes, callable,
 chr, classmethod, compile, complex, copyright, credits,
 delattr, dict, dir, divmod, enumerate, eval, exec, exit,
 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'фильтр', 'с плавающей точкой', 'формат', 'frozenset', 'getattr', 'globals', 'hasattr',
 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'хэш', 'справка', 'шестнадцатеричный', 'id', 'input', 'int', 'isinstance', 'issubclass',
 iter, len, лицензия, list, locals, map, max, memoryview,
 min, next, object, oct, open, ord, pow, print, property,
 'quit', 'range', 'repr', 'reverse', 'round', 'set', 'setattr', 'срез',
 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'отсортированный', 'статический метод', 'str', 'sum', 'super', 'tuple', 'type', 'vars',
 'zip']

`Модули Python`

`Что такое модуль?`

Считайте модуль тем же, что и библиотека кода.

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

`Создать модуль`

Чтобы создать модуль, просто сохраните нужный код в файле с расширением .py :

`Пример`

Сохраните этот код в файле с именем mymodule.py

def приветствие (имя): print ("Привет," + имя)

`Используйте модуль`

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

`Пример`

Импортируйте модуль с именем mymodule и вызовите функцию приветствия:

import mymodule

mymodule.приветствие («Джонатан»)

Пример запуска »

Примечание: При использовании функции из модуля используйте синтаксис: имя_модуля.имя_функции .

`Переменные в модуле`

Модуль может содержать уже описанные функции, а также переменные все типы (массивы, словари, объекты и т. д.):

`Пример`

Сохраните этот код в файле mymodule.py

person1 = { "name": "Джон", "age": 36, "страна": "Норвегия" }

`Пример`

Импортируйте модуль с именем mymodule и получите доступ к словарю person1:

import mymodule

a = mymodule.person1 ["возраст"] print (a)

Пример запуска »

`Именование модуля`

Вы можете назвать файл модуля как хотите, но он должен иметь расширение файла .py

`Переименование модуля`

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

`Пример`

Создайте псевдоним для mymodule с именем mx :

импортировать mymodule как mx

a = mx.person1 ["возраст"] print (a)

Пример запуска »

`Встроенные модули`

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

`Пример`

Импорт и использование платформы Модуль:

платформа импорта

x = platform.system () print (x)

Попробуй сам "

`Использование функции dir ()`

Имеется встроенная функция для вывода списка всех имен функций (или переменных имена) в модуле.Функция dir () :

`Пример`

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

платформа импорта

x = dir (платформа) print (x)

Попробуй сам "

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

`Импорт из модуля`

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

`Пример`

Модуль с именем mymodule имеет одну функцию и один словарь:

def приветствие (имя): print ("Привет," + имя)

person1 = { "name": "Джон", "возраст": 36, "страна": «Норвегия» }

`Пример`

Импортировать из модуля только словарь person1:

from mymodule import person1

print (person1 ["возраст"])

Пример запуска »

Примечание: При импорте с использованием из ключевое слово, не используйте имя модуля при обращении к элементам в модуле.Пример: человек1 ["возраст"] , не mymodule.person1 ["возраст"]

`12. Модули - Как думать как компьютерный ученый: обучение с Python 3`

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

Мы также показали вам, как получить доступ к справке. Справочная система содержит список всех стандартных модулей, доступных с Python. Играйте с помощью!

`12.1. Случайные числа`

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

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

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

 импорт случайный

# Создать объект черного ящика, который генерирует случайные числа
rng = random.Random ()

dice_throw = rng.randrange (1,7) # Возвращает int, одно из 1,2,3,4,5,6
delay_in_seconds = rng.random () * 5,0

Вызов метода randrange генерирует целое число между нижним и верхним аргумент, используя ту же семантику, что и диапазон - поэтому нижняя граница включена, но верхняя граница исключена.Все значения имеют равную вероятность появления (т.е. результаты равны равномерно и распределены). Как и диапазон, рандрейндж может также укажите необязательный аргумент step. Предположим, нам нужно на случайное нечетное число меньше чем 100, можно сказать:

 r_odd = rng.randrange (1, 100, 2)

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

Случайный метод возвращает число с плавающей запятой в интервале [0.0, 1.0) - значение квадратная скобка означает «закрытый интервал слева», а круглая скобка означает «Открытый интервал справа». Другими словами, 0,0 возможен, но все возвращается числа будут строго меньше 1.0. Обычно по шкале результаты после вызывая этот метод, чтобы перевести их в интервал, подходящий для вашего приложения. в в случае, показанном здесь, мы преобразовали результат вызова метода в число в интервал [0.0, 5,0). Опять же, это равномерно распределенные числа - числа числа, близкие к 0, с такой же вероятностью встречаются, как числа, близкие к 0,5, или числа, близкие к 1,0.

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

 cards = list (range (52)) # Сгенерировать целые числа [0 .. 51]
                         # представляет колоду карт.rng.shuffle (cards) # Перемешать колоду

`12.1.1. Повторяемость и тестирование`

Генераторы случайных чисел основаны на детерминированном алгоритме - повторяемом и предсказуемом. Поэтому их называют псевдослучайными генераторами - они не являются действительно случайными. Они начинаются со значения seed . Каждый раз, когда вы запрашиваете другое случайное число, вы получаете один, основанный на текущем атрибуте семени, и состояние семени (которое является одним атрибутов генератора) будут обновлены.

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

 drng = случайный.Random (123) # Создать генератор с известным начальным состоянием

Этот альтернативный способ создания генератора случайных чисел дает явное начальное число значение к объекту. Без этого аргумента система, вероятно, использует что-то основанное во время. Так что если взять несколько случайных чисел из drng сегодня, вы получите точно такая же случайная последовательность, как и завтра!

`12.1.2. Собирать шары из мешков, бросать кости, тасовать колоду карт`

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

 случайный импорт

def make_random_ints (число, нижняя_ граница, верхняя_ граница):
   "" "
     Сгенерируйте список, содержащий число случайных чисел в интервале между lower_bound
     и upper_bound.upper_bound - это открытая граница.
   "" "
   rng = random.Random () # Создать генератор случайных чисел
   результат = []
   для i в диапазоне (число):
      result.append (rng.randrange (нижняя_ граница, верхняя_ привязка))
   вернуть результат

 >>> make_random_ints (5, 1, 13) # Выбрать 5 случайных номеров месяцев
[8, 1, 8, 5, 6]

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

Но что, если вам не нужны дубликаты? Если бы вы хотели 5 разных месяцев, тогда этот алгоритм неверен.В этом случае хороший алгоритм - создать список возможностей, перемешайте его и вырежьте нужное количество элементов:

 xs = list (range (1,13)) # Сделать список 1..12 (нет дубликатов)
rng = random.Random () # Создать генератор случайных чисел
rng.shuffle (xs) # Перемешать список
result = xs [: 5] # Берем первые пять элементов

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

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

 импорт случайный

def make_random_ints_no_dups (число, нижняя_ граница, верхняя_ граница):
   "" "
     Создайте список, содержащий число случайных чисел между
     lower_bound и upper_bound.upper_bound - это открытая граница.
     Список результатов не может содержать дубликатов.
   "" "
   результат = []
   rng = random.Random ()
   для i в диапазоне (число):
        в то время как True:
            кандидат = rng.randrange (нижняя_ граница, верхняя_ привязка)
            если кандидат не в результате:
                перерыв
        result.append (кандидат)
   вернуть результат

xs = make_random_ints_no_dups (5, 1, 10000000)
печать (хз)

Это дает 5 случайных чисел без дубликатов:

 [3344629, 1735163, 9433892, 1081511, 40]

Даже у этой функции есть свои подводные камни.Можете ли вы заметить, что произойдет в этот случай?

 xs = make_random_ints_no_dups (10, 1, 6)

`12.2. Модуль времени`

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

Его можно использовать, чтобы вызвать часы и присвоить результат переменной, скажем t0, непосредственно перед тем, как вы начнете выполнять код, который хотите измерить. Затем после выполнения вызовите снова часы (на этот раз мы сохраним результат в переменной t1). Различия t1-t0 - это время, прошедшее с начала, и показатель того, насколько быстро выполняется ваша программа.

Давайте попробуем небольшой пример.Python имеет встроенную функцию суммы, которая может суммировать элементы в списке. Мы также можем написать свои собственные. Как мы думаем, они будут сравнивать на скорость? Мы попытаемся суммировать список [0, 1, 2 ...] в обоих случаях, и сравните результаты:

 время импорта

def do_my_sum (хз):
    сумма = 0
    для v в xs:
        сумма + = v
    сумма возврата

sz = 10000000 # Пусть в списке будет 10 миллионов элементов
testdata = диапазон (sz)

t0 = время.Часы()
my_result = do_my_sum (тестовые данные)
t1 = time.clock ()
print ("my_result = {0} (затраченное время = {1: .4f} секунд)"
        .format (my_result, t1-t0))

t2 = time.clock ()
их_результат = сумма (тестовые данные)
t3 = time.clock ()
print ("their_result = {0} (затраченное время = {1: .4f} секунд)"
        .format (их_результат, t3-t2))

На достаточно скромном ноутбуке получаем следующие результаты:

 my_sum = 49999995000000 (затраченное время = 1,5567 секунды)
их_сумма = 49999995000000 (затраченное время = 0.9897 секунд)

Итак, наша функция работает примерно на 57% медленнее, чем встроенная. Генерация и суммирование десяти миллионов элементов менее чем за секунду - это не так уж и плохо!

`12,3. Математический модуль`

Математический модуль содержит математические функции, которые вы обычно калькулятор (sin, cos, sqrt, asin, log, log10) и некоторые математические константы как пи и е:

 >>> импорт математики
>>> math.pi # Постоянное число пи
3.1415589793
>>> math.e # Постоянная основа натурального логарифма
2,718281828459045
>>> math.sqrt (2.0) # Функция извлечения квадратного корня
1,4142135623730951
>>> math.radians (90) # Преобразовать 90 градусов в радианы
1,5707963267948966
>>> math.sin (math.radians (90)) # Найти грех 90 градусов
1.0
>>> math.asin (1.0) * 2 # Удвойте arcsin 1.0, чтобы получить число пи
3,1415589793

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

Обратите внимание на еще одно различие между этим модулем и нашим использованием random и turtle: в random и turtle мы создаем объекты и вызываем методы объекта. Это поскольку объекты имеют состояние - черепаха имеет цвет, положение, заголовок и т. д., и каждый генератор случайных чисел имеет начальное значение, которое определяет его следующий результат.

Математические функции являются «чистыми» и не имеют состояния - вычисление квадратного корня из 2.0 не зависит от какого-либо состояния или истории того, что происходило в прошлом. Итак, функции не являются методами объекта - это просто функции, которые сгруппированы в модуль под названием math.

`12,4. Создание собственных модулей`

Все, что нам нужно сделать для создания наших собственных модулей, - это сохранить наш скрипт как файл с расширением .py. Предположим, например, что этот скрипт сохранен как файл с именем seqtools.py:

 def remove_at (pos, seq):
    return seq [: pos] + seq [pos + 1:]

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

 >>> импортировать инструменты seqtools
>>> s = "Строка!"
>>> seqtools.remove_at (4, с)
'Жало!'

Мы не включаем расширение файла .py, когда импорт. Python ожидает, что имена файлов модулей Python заканчиваются на .py, поэтому расширение файла не включается в оператор импорта .

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

`12,5. Пространства имен`

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

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

 # Module1.ру

question = "В чем смысл жизни, Вселенной и всего остального?"
answer = 42

 # Module2.py

question = "Каков ваш квест?"
answer = "Искать Святой Грааль."

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

 импортный модуль1
import module2

печать (module1.question)
печать (module2.question)
печать (module1.отвечать)
печать (module2.answer)

выведет следующее:

 В чем смысл жизни, Вселенной и всего остального?
Какой у вас квест?
42
Искать Святой Грааль.

Функции также имеют свои собственные пространства имен:

 def f ():
    п = 7
    print ("печать n внутри f:", n)

def g ():
    n = 42
    print ("печать n внутри g:", n)

п = 11
print ("печать n перед вызовом f:", n)
f ()
print ("печать n после вызова f:", n)
грамм()
print ("печать n после вызова g:", n)

Запуск этой программы дает следующий результат:

 печатает n перед вызовом f: 11
печать n внутри f: 7
печать n после вызова f: 11
печать n внутри g: 42
печать n после вызова g: 11

Три "n" здесь не сталкиваются, поскольку каждый из них находится в разных пространство имен - это три имени для трех разных переменных, как и может быть три разных человека, и все они называются «Брюс».

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

`12,6. Правила области действия и поиска`

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

В Python есть три важных области:

Локальная область видимости относится к идентификаторам, объявленным внутри функции. Эти идентификаторы сохраняются в пространстве имен, которое принадлежит функции, и каждая функция имеет собственное пространство имен.
Глобальная область относится ко всем идентификаторам, объявленным в текущем модуле или файле.
Встроенная область видимости относится ко всем идентификаторам, встроенным в Python, таким как диапазон и min, которые можно использовать без необходимости импорта, и которые (почти) всегда доступны.

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

 диапазон определения (n):
    вернуть 123 * n

печать (диапазон (10))

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

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

Теперь немного более сложный пример:

 n = 10
м = 3
def f (n):
   м = 7
   вернуть 2 * n + m

print (f (5), n, m)

Это напечатает 17 10 3.Причина в том, что две переменные m и n в строках 1 и 2 находятся вне функции в глобальном пространстве имен. Внутри функции новые переменные вызываемые n и m создаются только на время выполнения f . Эти создается в локальном пространстве имен функции f. В теле f правила поиска в области видимости определите, что мы используем локальные переменные m и n. Напротив, после того, как мы вернулись из f, аргументы n и m функции печати относятся к исходным переменным в строках 1 и 2, и они никоим образом не были изменены при выполнении функции f.

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

Каков объем переменной n в строке 1? Его масштабы - регион, в котором он находится. видимый - это строки 1, 2, 6, 7. Он скрыт от просмотра в строках 3, 4, 5 из-за локальная переменная n.

`12,7. Атрибуты и оператор точки`

Переменные, определенные внутри модуля, называются атрибутами модуля. Мы видели, что у объектов тоже есть атрибуты: например, у большинства объектов есть атрибут __doc__, некоторые функции имеют атрибут __annotations__.Доступ к атрибутам осуществляется с помощью оператора точка (.). Атрибут вопроса доступа к module1 и module2 можно получить с помощью module1.question и module2.question.

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

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

`12,8. Три варианта заявления об импорте`

Вот три различных способа импортировать имена в текущее пространство имен и использовать их:

 математика импорта
х = math.sqrt (10)

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

Вот другое расположение:

 из math import cos, sin, sqrt
х = sqrt (10)

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

Тогда у нас есть удобное сокращение:

 from math import * # Импортировать все идентификаторы из math,
                     # добавляем их в текущее пространство имен.
x = sqrt (10) # Используйте их без квалификации.

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

 >>> импортировать математику как m
>>> m.pi
3,1415589793

Но послушайте, с хорошими редакторами с автозаполнением и быстрыми пальцами, это небольшая цена!

Наконец, обратите внимание на этот случай:

 область определения (радиус):
    импортная математика
    вернуть math.pi * radius * radius

х = математика.sqrt (10) # Выдает ошибку

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

`12.9. Превратите тестер вашего устройства в модуль`

Ближе к концу главы 6 (Плодотворные функции) мы представили модульное тестирование и наш собственный тест. функции, и вам пришлось скопировать ее в каждый модуль, для которого вы написал тесты.Теперь мы можем поместить это определение в модуль его собственный, скажем unit_tester.py, и просто используйте вместо этого одну строку в каждом новом скрипте:

 из теста импорта unit_tester

`12.10. Глоссарий`

атрибут

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

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

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

полное имя

 Имя, начинающееся с некоторого идентификатора пространства имен и оператора точки, или
 с помощью объекта-экземпляра, например math.sqrt или tess.forward (10).

импортная ведомость

Оператор, который делает объекты, содержащиеся в модуле, доступными для использовать в другом модуле. Есть две формы для импорта утверждение.Использование гипотетических модулей с именами mymod1 и mymod2 каждый содержит функции f1 и f2, а также переменные v1 и v2, примеры из этих двух форм включают:

 импорт mymod1
из mymod2 импортировать f1, f2, v1, v2

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

метод

Функциональный атрибут объекта. Методы вызываются (вызываются) на объект, использующий оператор точки. Например:

 >>> s = "это строка."
>>> s.upper ()
«ЭТО СТРОКА».
>>>

Мы говорим, что метод upper вызывается для строки s. s - неявно первый аргумент для upper.

модуль

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

пространство имен

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

коллизия имен

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

вместо

предотвращает конфликты имен.

ndard библиотека Библиотека - это набор программного обеспечения, используемого в качестве инструментов при разработке. другого программного обеспечения. Стандартная библиотека языка программирования: набор таких инструментов, которые распространяются вместе с ядром программирования язык. Python поставляется с обширной стандартной библиотекой.

`12.11. Упражнения`

Открыть справку для модуля календаря.
1. Попробуйте следующее:
  календарь импорта cal = календарь.TextCalendar () # Создаем экземпляр cal.pryear (2012) # Что здесь происходит?
2. Обратите внимание, что неделя начинается в понедельник. Отважный студент CompSci считает, что лучше начать свою неделю с начала недели. Четверг, потому что тогда до выходных всего два рабочих дня, и каждую неделю есть перерыв посередине. Прочтите документацию для TextCalendar, и узнайте, как вы можете помочь ему напечатать календарь, который соответствует его потребностям.
3. Найдите функцию для печати только того месяца, в котором в этом году выпадает ваш день рождения.
4. Попробуйте это:
  d = calendar.LocaleTextCalendar (6, «ИСПАНСКИЙ») d.pryear (2012)
  Попробуйте несколько других языков, включая тот, который не работает, и посмотрите, что произойдет.
5. Поэкспериментируйте с calendar.isleap. Чего он ожидает как аргумент? Что он возвращает в результате? Что это за функция?
Сделайте подробные записи о том, что вы узнали из этих упражнений.
Открыть справку по математическому модулю.
1. Сколько функций в математическом модуле?
2. Что делает math.ceil? А как насчет math.floor? (Подсказка : оба floor и ceil ожидают аргументов с плавающей запятой.)
3. Опишите, как мы вычисляли то же значение, что и math.sqrt. без использования математического модуля.
4. Какие две константы данных в математическом модуле?
Запишите подробные записи вашего расследования в этом упражнении.
Осмотрите модуль копирования. Что делает deepcopy делать? В каких упражнениях из предыдущей главы можно было бы использовать deepcopy удобно?
Создайте модуль с именем mymodule1.py. Добавить атрибуты myage, установленные в ваш текущий возраст и год, установленный на текущий год. Создать еще один модуль с именем mymodule2.py. Добавьте атрибуты myage, равные 0, и Год установлен на год вашего рождения. Теперь создайте файл с именем namespace_test.py. Импортируйте оба модуля выше и напишите следующая выписка:
печать ((mymodule2.myage - mymodule1.myage) == (mymodule2.year - mymodule1.year))
Когда вы запустите namespace_test.py, вы увидите либо True, либо Ложь в качестве вывода в зависимости от того, были ли у вас уже день рождения в этом году.
Этот пример показывает, что разные модули могут иметь атрибуты с именами myage и год. Поскольку они находятся в разных пространствах имен, они не конфликтуют друг с другом. Когда мы пишем namespace_test.py, мы полностью определить, какой именно переменный год или мой возраст мы имеем в виду.
Добавьте следующий оператор в mymodule1.py, mymodule2.py и namespace_test.py из предыдущего упражнения:
print («Меня зовут», __name__)
Запустите namespace_test.py. Что происходит? Почему? Теперь добавьте в внизу mymodule1.py:
если __name__ == "__main__": print ("Это не будет работать, если я импортирован.")
Запустите mymodule1.py и снова namespace_test.py. В каком случае ты увидеть новый оператор печати?
В оболочке Python / интерактивном интерпретаторе попробуйте следующее:
Что Тим Петерс говорит о пространствах имен?

Дайте ответ интерпретатора Python на каждое из следующих из непрерывная сессия переводчика:

 >>> s = "Если бы мы вынули кости, они не были бы хрустящими, не так ли?"
>>> с.расколоть()
>>> тип (s.split ())
>>> s.split ("о")
>>> s.split ("i")
>>> "0" .join (s.split ("o"))

Убедитесь, что вы понимаете, почему вы получаете каждый результат. Затем примените то, что у вас есть научился заполнять тело функции ниже, используя разделение и методы соединения объектов str:

 def myreplace (старый, новый, s):
    "" "Заменить все вхождения старого на новое в s." ""
    ...


test (myreplace (",", ";", "то, то и другое") ==
                         "это; то; и еще кое-что")
test (myreplace ("", "**",
                 "Слова теперь будут разделены звездами.") ==
                 «Слова ** теперь ** будут ** разделяться ** ** звездочками»)

Ваше решение должно пройти тесты.

Создайте модуль с именем wordtools.py с нашими тестовыми каркасами на месте.

Теперь добавьте функции к этим тестам:

 тест (чистое слово ("что?") == "что")
test (cleanword ("'сейчас!'") == "сейчас")
test (cleanword ("? + = 'w-o-r-d!, @ $ ()'") == "word")

test (has_dashdash ("расстояние - но"))
тест (не has_dashdash ("несколько"))
тест (has_dashdash ("говорил--"))
test (has_dashdash ("расстояние - но"))
тест (не has_dashdash ("- йо-йо-"))

test (extract_words ("Сейчас время! 'Сейчас', время? Да, сейчас.") ==
      ['сейчас', 'есть', 'то', 'время', 'сейчас', 'есть', 'то', 'время', 'да', 'сейчас'])
test (extract_words ("она пыталась сделать реверанс, пока говорила - причудливо") ==
      ['она', 'пыталась', 'к', 'реверанс', 'как', 'она', 'говорила', 'причудливо'])

test (wordcount («сейчас», [«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) == 2)
test (wordcount ("is", ["now", "is", "time", "is", "now", "the", "is"]) == 3)
test (wordcount («время», [«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) == 1)
test (wordcount («лягушка», [«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) == 0)

test (wordset ([«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) ==
      [«есть», «сейчас», «время»])
test (wordset (["Я", "a", "a", "is", "a", "is", "I", "am"]) ==
      [«Я», «а», «есть», «есть»])
test (wordset (["or", "a", "am", "is", "are", "be", "but", "am"]) ==
      [«а», «я», «есть», «быть», «но», «есть», «или»])

тест (длинное слово (["а", "яблоко", "груша", "виноград"]) == 5)
test (longestword (["a", "am", "I", "be"]) == 2)
test (longestword (["это", "supercalifragilisticexpialidocious"]) == 34)
тест (длинное слово ([]) == 0)

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

`Все, что вам нужно знать - настоящий Python`

В этой статье вы узнаете все о модуле Python math . Математические вычисления - неотъемлемая часть большинства разработок Python. Независимо от того, работаете ли вы над научным проектом, над финансовым приложением или над любым другим видом программирования, вам просто не избежать математики.

Для простых математических вычислений в Python вы можете использовать встроенные математические операторы , такие как сложение ( + ), вычитание (–), деление (/) и умножение ( * ). .Но более сложные операции, такие как экспоненциальные, логарифмические, тригонометрические или степенные функции, не встроены. Означает ли это, что вам нужно реализовать все эти функции с нуля?

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

К концу этой статьи вы узнаете:

Что такое модуль Python math
Как использовать функции модуля math для решения реальных задач
Какие константы модуля math , включая пи, тау и число Эйлера
В чем разница между встроенными функциями и функциями math
В чем разница между math , cmath и NumPy:

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

Итак, приступим!

`Знакомство с Python`

math Модуль

Модуль Python math - важная функция, предназначенная для работы с математическими операциями. Он поставляется в стандартной версии Python и был там с самого начала. Большинство функций модуля math представляют собой тонкие оболочки математических функций платформы C.Поскольку его основные функции написаны на CPython, модуль math эффективен и соответствует стандарту C.

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

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

Поскольку модуль math входит в состав версии Python, вам не нужно устанавливать его отдельно.Использование - это просто импорт модуля:

Вы можете импортировать модуль Python math , используя указанную выше команду. После импорта вы можете сразу использовать его.

`Константы модуля`

math

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

Пи
Тау
Число Эйлера
бесконечность
Не число (NaN)

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

`Пи`

Пи (π) - это отношение длины окружности ( c ) к ее диаметру ( d ):

π = с / д

Это соотношение всегда одинаково для любого круга.

Пи - это иррациональное число , что означает, что его нельзя выразить простой дробью. Следовательно, у пи бесконечное количество десятичных знаков, но оно может быть приблизительно равно 22/7 или 3,141.

Интересный факт: Пи - самая признанная и известная математическая константа в мире. У него есть своя собственная дата празднования, называемая Днем Пи, которая приходится на 14 марта (3/14).

Вы можете получить доступ к pi следующим образом:

>>>

  >>> математ.Пи
3,1415589793

Как видите, число пи в Python дается с точностью до пятнадцати десятичных знаков. Количество предоставленных цифр зависит от базового компилятора C. По умолчанию Python печатает первые пятнадцать цифр, а math.pi всегда возвращает значение с плавающей запятой.

Итак, каковы некоторые из способов, которыми пи может быть вам полезен? Вы можете рассчитать длину окружности, используя 2π r , где r - радиус окружности:

>>>

  >>> r = 3
>>> окружность = 2 * математика.пи * р
>>> f "Окружность круга = 2 * {math.pi: .4} * {r} = {окружность: .4}"
'Окружность круга = 2 * 3,142 * 3 = 18,85'

Вы можете использовать math.pi для вычисления длины окружности. Вы также можете рассчитать площадь круга по формуле π r ² следующим образом:

>>>

  >>> r = 5
>>> площадь = math.pi * r * r
>>> f "Площадь круга = {math.pi: .4} * {r} * {r} = {area: .4}"
'Площадь круга = 3.142 * 5 * 5 = 78,54 '

Вы можете использовать math.pi для вычисления площади и длины окружности. Когда вы выполняете математические вычисления с помощью Python и сталкиваетесь с формулой, в которой используется π, рекомендуется использовать значение пи, заданное модулем math , вместо жесткого кодирования значения.

`Тау`

Тау (τ) - отношение длины окружности к ее радиусу. Эта константа равна 2π, или примерно 6,28. Как и пи, тау - иррациональное число, потому что оно просто пи умноженное на два.

Во многих математических выражениях используется 2π, и использование тау вместо этого может помочь упростить ваши уравнения. Например, вместо вычисления длины окружности с 2π r мы можем подставить tau и использовать более простое уравнение τ r .

Однако использование тау в качестве постоянной окружности все еще обсуждается. Вы можете свободно использовать 2π или τ по мере необходимости.

Вы можете использовать тау, как показано ниже:

>>>

  >>> математ.тау
6,283185307179586

Как и math.pi , math.tau возвращает пятнадцать цифр и является значением с плавающей запятой. Вы можете использовать тау для вычисления длины окружности с τ r , где r - радиус, следующим образом:

>>>

  >>> r = 3
>>> окружность = math.tau * r
>>> f "Окружность круга = {math.tau: .4} * {r} = {окружность: .4}"
'Окружность круга = 6,283 * 3 = 18,85'

Вы можете использовать math.tau вместо 2 * math.pi , чтобы привести в порядок уравнения, содержащие выражение 2π.

`Число Эйлера`

Число Эйлера ( e ) - это константа, являющаяся основанием натурального логарифма , математической функции, которая обычно используется для расчета скорости роста или спада. Как и в случае с пи и тау, число Эйлера - иррациональное число с бесконечным числом десятичных знаков. Значение e часто приблизительно равно 2,718.

Число Эйлера

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

>>>

  >>> math.e
2,718281828459045

Как и math.pi и math.tau , значение math.e дается с точностью до пятнадцати десятичных знаков и возвращается как значение с плавающей запятой.

`Бесконечность`

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

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

>>>

  >>> f "Положительная бесконечность = {math.inf}"
'Положительная бесконечность = бесконечность'
>>> f "Отрицательная бесконечность = {-math.inf}"
'Отрицательная бесконечность = -inf'

Бесконечность не является числовым значением.Вместо этого он определяется как math.inf . Python представил эту константу в версии 3.5 как эквивалент float ("inf") :

. >>>

  >>> float ("inf") == math.inf
Правда

И float ("inf") , и math.inf представляют концепцию бесконечности, что делает math.inf больше любого числового значения:

>>>

  >>> x = 1e308
>>> math.inf> x
Правда

В приведенном выше коде math.inf больше, чем значение x , 10 ³⁰⁸ (максимальный размер числа с плавающей запятой), которое является числом с двойной точностью.

Точно так же -math.inf меньше любого значения:

>>>

  >>> y = -1e308
>>> y> -math.inf
Правда

Отрицательная бесконечность меньше значения y , что составляет -10 ³⁰⁸. Никакое число не может быть больше или меньше отрицательной бесконечности.Вот почему математические операции с math.inf не изменяют значение бесконечности:

>>>

  >>> math.inf + 1e308
инф
>>> math.inf / 1e308
инф

Как видите, ни сложение, ни деление не изменяют значение math.inf .

`Не число (NaN)`

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

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

Вы можете увидеть значение math.nan ниже:

NaN не является числовым значением. Как видите, значение math.nan - это nan , то же значение, что и float ("nan") .

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

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

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

факториалы числа
Наибольший общий делитель двух чисел
Сумма итераций

`Найдите факториалы с помощью Python`

factorial ()

Возможно, вы встречали математические выражения вроде 7! или 4! перед.Восклицательные знаки не означают, что числа взволнованы. Скорее, "!" - это факториал , символ . Факториалы используются при поиске перестановок или комбинаций. Вы можете определить факториал числа, умножив все целые числа от выбранного числа до 1.

В следующей таблице показаны значения факториала для 4, 6 и 7:

Символ	Словами	Выражение	Результат
4!	Четыре факториала	4 х 3 х 2 х 1	24
6!	Шесть факториалов	6 х 5 х 4 х 3 х 2 х 1	720
7!	Семь факториал	7 х 6 х 5 х 4 х 3 х 2 х 1	5040

Из таблицы видно, что 4 !, или четырехфакториал, дает значение 24 путем умножения диапазона целых чисел от 4 до 1.Аналогично 6! и 7! дают значения 720 и 5040 соответственно.

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

для петель
Рекурсивные функции
math.factorial ()

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

  def fact_loop (число):
    если число <0:
        возврат 0
    если num == 0:
        возврат 1

    факториал = 1
    для i в диапазоне (1, num + 1):
        факториал = факториал * я
    возврат факториала

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

  def fact_recursion (число):
    если число <0:
        возврат 0
    если num == 0:
        возврат 1

    return num * fact_recursion (число - 1)

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

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

>>>

  >>> fact_loop (7)
5040

>>> fact_recursion (7)
5040

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

Однако реализация собственных функций только для получения факториала числа занимает много времени и неэффективно. Лучше использовать math.factorial () . Вот как можно найти факториал числа с помощью math.factorial () :

. >>>

  >>> math.factorial (7)
5040

Этот подход возвращает желаемый результат с минимальным объемом кода.

factorial () принимает только положительные целые числа.Если вы попытаетесь ввести отрицательное значение, вы получите ValueError :

>>>

  >>> math.factorial (-5)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ValueError: factorial () не определен для отрицательных значений

Ввод отрицательного значения приведет к ошибке ValueError при чтении factorial (), не определенного для отрицательных значений .

factorial () также не принимает десятичные числа.Это даст вам ValueError :

>>>

  >>> math.factorial (4.3)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ValueError: factorial () принимает только целые значения

Ввод десятичного значения приводит к ошибке ValueError при чтении factorial () принимает только целые значения .

Вы можете сравнить время выполнения для каждого из методов факториала, используя timeit () :

>>>

  >>> импортное время
>>> timeit.timeit ("fact_loop (10)", globals = globals ())
1,063997201999996

>>> timeit.timeit ("fact_recursion (10)", globals = globals ())
1,815312818999928

>>> timeit.timeit ("math.factorial (10)", setup = "import math")
0,10671788000001925

Пример выше иллюстрирует результаты timeit () для каждого из трех факторных методов.

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

Тип	Срок исполнения
С петлями	1.0640 с
С рекурсией	1,8153 с
С факториалом `()`	0,1067 с

Как видно из времени выполнения, factorial () быстрее, чем другие методы. Это из-за его базовой реализации C. Метод, основанный на рекурсии, самый медленный из трех. Хотя вы можете получить разные тайминги в зависимости от вашего CPU , порядок функций должен быть одинаковым.

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

`Найдите максимальное значение с помощью`

ceil ()

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

Например, вход 5,43 вернет значение 6, а вход -12,43 вернет значение -12. math.ceil () может принимать положительные или отрицательные действительные числа в качестве входных значений и всегда будет возвращать целочисленное значение.

Когда вы вводите целочисленное значение в ceil () , оно вернет то же число:

>>>

  >>> math.ceil (6)
6
>>> math.ceil (-11)
-11

math.ceil () всегда возвращает одно и то же значение, если на входе задано целое число. Чтобы увидеть истинную природу ceil () , вы должны ввести десятичные значения:

>>>

  >>> math.ceil (4.23)
5
>>> math.ceil (-11,453)
-11

Если значение положительное (4.23), функция возвращает следующее целое число, большее значения (5). Если значение отрицательное (-11,453), функция также возвращает следующее целое число, большее значения (-11).

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

>>>

  >>> math.ceil ("x")
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: должно быть действительное число, а не str

Вы должны ввести число в функцию.Если вы попытаетесь ввести любое другое значение, вы получите TypeError .

`Найдите минимальную стоимость с`

этажом ()

floor () вернет ближайшее целочисленное значение, которое меньше или равно заданному числу. Эта функция ведет себя противоположно ceil () . Например, ввод 8,72 вернет 8, а ввод -12,34 вернет -13. floor () может принимать как положительные, так и отрицательные числа в качестве входных данных и возвращает целочисленное значение.

Если ввести целочисленное значение, функция вернет то же значение:

>>>

  >>> math.floor (4)
4
>>> math.floor (-17)
-17

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

>>>

  >>> math.floor (5.532)
5
>>> math.floor (-6.432)
-7

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

Если вы попытаетесь ввести значение, не являющееся числом, функция вернет TypeError :

>>>

  >>> math.floor ("x")
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: должно быть действительное число, а не str

Вы не можете вводить нечисловые значения в качестве входных данных для ceil () .Это приведет к ошибке TypeError .

`Усечь числа с усечением`

()

Когда вы получаете число с десятичной точкой, вы можете оставить только целую часть и исключить десятичную часть. В модуле math есть функция trunc () , которая позволяет вам делать именно это.

Удаление десятичного значения - это тип округления. При использовании trunc () отрицательные числа всегда округляются в большую сторону до нуля, а положительные числа всегда округляются в меньшую сторону до нуля.

Вот как функция trunc () округляет положительные или отрицательные числа:

>>>

  >>> math.trunc (12.32)
12
>>> math.trunc (-43,24)
-43

Как видите, 12,32 округляется вниз до 0, что дает результат 12. Таким же образом -43,24 округляется вверх до 0, что дает значение -43. trunc () всегда округляется до нуля независимо от того, положительное или отрицательное число.

При работе с положительными числами trunc () ведет себя так же, как floor () :

>>>

  >>> математ.trunc (12.32) == math.floor (12.32)
Правда

trunc () ведет себя так же, как floor () для положительных чисел. Как видите, возвращаемое значение обеих функций одинаково.

При работе с отрицательными числами trunc () ведет себя так же, как ceil () :

>>>

  >>> math.trunc (-43.24) == math.ceil (-43.24)
Правда

Если число отрицательное, floor () ведет себя так же, как ceil () .Возвращаемые значения обеих функций одинаковы.

`Найдите близость чисел с помощью Python`

isclose ()

В определенных ситуациях - особенно в области науки о данных - вам может потребоваться определить, близки ли два числа друг к другу. Но для этого сначала нужно ответить на важный вопрос: как близко равно близко ? Другими словами, каково определение слова «закрыть»?

Что ж, Мерриам-Вебстер скажет вам, что близость означает «близость во времени, пространстве, эффекте или градусе».«Не очень-то полезно, правда?

Например, возьмите следующий набор чисел: 2.32, 2.33 и 2.331. Когда вы измеряете близость по двум десятичным знакам, 2,32 и 2,33 близки. Но на самом деле 2.33 и 2.331 ближе. Таким образом, близость - понятие относительное. Невозможно определить близость без какого-то порога.

К счастью, модуль math предоставляет функцию с именем isclose () , которая позволяет вам установить свой собственный порог, или допуск для близости.Он возвращает True , если два числа находятся в пределах установленного вами допуска близости, и в противном случае возвращает False .

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

Относительный допуск или rel_tol - это максимальная разница, которая считается «близкой» по отношению к величине входных значений. Это процент толерантности. Значение по умолчанию - 1e-09 или 0,000000001.
Абсолютный допуск или abs_tol - это максимальная разница, которая считается «близкой», независимо от величины входных значений.Значение по умолчанию - 0,0.

isclose () вернет True , если выполняется следующее условие:

абс (a-b) <= max (rel_tol * max (abs (a), abs (b)), abs_tol).

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

В следующем случае 6 и 7 не близки к :

>>>

  >>> математ.isclose (6, 7)
Ложь

Цифры 6 и 7 не считаются близкими, поскольку относительный допуск установлен для девяти десятичных знаков. Но если вы введете 6.999999999 и 7 с одинаковым допуском, тогда они будут считаться близкими:

>>>

  >>> math.isclose (6.999999999, 7)
Правда

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

Вы можете отрегулировать относительный допуск, как хотите, в зависимости от ваших потребностей. Если установить для rel_tol значение 0,2, то 6 и 7 считаются близкими:

>>>

  >>> math.isclose (6, 7, rel_tol = 0.2)
Правда

Вы можете заметить, что 6 и 7 уже близки. Это потому, что они находятся в пределах 20% друг от друга.

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

>>>

  >>> math.isclose (6, 7, abs_tol = 1.0)
Правда
>>> math.isclose (6, 7, abs_tol = 0,2)
Ложь

Когда вы устанавливаете абсолютный допуск на 1, числа 6 и 7 близки, потому что разница между ними равна абсолютному допуску. Однако во втором случае разница между 6 и 7 не меньше или равна установленному абсолютному допуску 0,2.

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

>>>

  >>> математ.isclose (1, 1.0000001, abs_tol = 1e-08)
Ложь
>>> math.isclose (1, 1.00000001, abs_tol = 1e-08)
Правда

Как видите, вы можете определить близость очень маленьких чисел с помощью isclose . Несколько особых случаев, касающихся близости, можно проиллюстрировать с использованием значений nan и inf :

>>>

  >>> math.isclose (math.nan, 1e308)
Ложь
>>> math.isclose (math.nan, math.nan)
Ложь

>>> math.isclose (math.inf, 1e308)
Ложь
>>> math.isclose (math.inf, math.inf)
Правда

Из приведенных выше примеров видно, что nan не близко ни к какому значению, даже самому себе. С другой стороны, inf не близок ни к каким числовым значениям, даже к очень большим, а близко к себе .

`Функции питания`

Функция мощности принимает любое число x в качестве входных данных, увеличивает x до некоторой степени n и возвращает x ⁿ в качестве выходных данных.Модуль Python math предоставляет несколько функций, связанных с питанием. В этом разделе вы узнаете о степенных функциях, экспоненциальных функциях и функциях извлечения квадратного корня.

`Вычислить степень числа с помощью`

pow ()

Степенные функции имеют следующую формулу, где переменная x - это основание , переменная n - это степень , а a может быть любой константой :

Степенная функция

В приведенной выше формуле значение основания x возведено в степень n .

Вы можете использовать math.pow () , чтобы получить степень числа. Имеется встроенная функция pow () , которая отличается от math.pow () . Вы узнаете разницу позже в этом разделе.

math.pow () принимает два следующих параметра:

>>>

  >>> math.pow (2, 5)
32,0
>>> math.pow (5, 2.4)
47,546789696

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

Когда основание 1 возводится в степень любого числа n, это дает результат 1.0:

>>>

  >>> math.pow (1.0, 3)
1.0

Когда вы увеличиваете базовое значение 1 до любого значения мощности, вы всегда получите 1,0 в результате. Аналогично, любое базовое число, возведенное в степень 0, дает результат 1.0:

>>>

  >>> math.pow (4, 0.0)
1.0
>>> math.pow (-4, 0,0)
1.0

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

>>>

  >>> math.pow (math.nan, 0,0)
1.0

Возведение нуля в степень любого положительного числа даст в результате 0,0:

>>>

  >>> math.pow (0.0, 2)
0,0
>>> math.pow (0,0, 2,3)
0,0

Но если вы попытаетесь возвести 0,0 в отрицательную степень, результатом будет ValueError :

>>>

  >>> math.pow (0,0, -2)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ValueError: ошибка математического домена

ValueError возникает только тогда, когда основание равно 0. Если основание - любое другое число, кроме 0, тогда функция вернет допустимое значение мощности.

Помимо math.pow () , в Python есть два встроенных способа определения степени числа:

х ** у
pow ()

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

>>>

  >>> 3 ** 2
9
>>> 2 ** 3,3
9,8406759329

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

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

База номер
Мощность номер
Модуль упругости номер

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

>>>

  >>> pow (3, 2)
9
>>> pow (2, 3.3)
9,8406759329

Встроенная функция pow () имеет два обязательных аргумента, которые работают так же, как base и power в синтаксисе x ** y . pow () также имеет третий параметр, который является необязательным: модуль . Этот параметр часто используется в криптографии. Встроенный pow () с дополнительным параметром модуля эквивалентен уравнению (x ** y)% z . Синтаксис Python выглядит так:

>>>

  >>> pow (32, 6, 5)
4
>>> (32 ** 6)% 5 == pow (32, 6, 5)
Правда

pow () возводит основание (32) в степень (6), а затем результат делится по модулю на число модуля (5).В этом случае результат равен 4. Вы можете подставить свои собственные значения и увидеть, что и pow () , и данное уравнение дают одинаковые результаты.

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

>>>

  >>> timeit.timeit ("10 ** 308")
1,0078728999942541

>>> timeit.timeit ("pow (10, 308)")
1.047615700008464

>>> timeit.timeit ("math.pow (10, 308)", setup = "import math")
0,1837239999877056

В следующей таблице сравнивается время выполнения трех методов, измеренное с помощью timeit () :

.

Тип	Срок исполнения
`x ** y`	1.0079 с
`pow (x, y)`	1.0476 с
`math.pow (x, y)`	0.1837 с

Из таблицы видно, что math.pow () быстрее, чем другие методы, а встроенный pow () - самый медленный.

Причина эффективности math.pow () заключается в способе его реализации. Он полагается на базовый язык C. С другой стороны, pow () и x ** y используют собственную реализацию объекта ввода оператора ** . Однако math.pow () не может обрабатывать комплексные числа (что будет объяснено в следующем разделе), тогда как pow () и ** могут.

`Найдите натуральную экспоненту с помощью`

exp ()

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

Общая экспоненциальная функция

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

Так что же такого особенного в экспоненциальных функциях? Значение функции быстро растет по мере увеличения значения x .Если основание больше 1, то значение функции непрерывно увеличивается по мере увеличения x . Особое свойство экспоненциальных функций состоит в том, что наклон функции также непрерывно увеличивается по мере увеличения x .

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

Естественная экспоненциальная функция

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

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

>>>

  >>> math.exp (21)
1318815734,4832146
>>> математика.ехр (-1,2)
0,301194211214

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

. >>>

  >>> math.exp ("x")
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: должно быть действительное число, а не str

Как видите, если ввод является строковым значением, тогда функция возвращает TypeError , чтение должно быть действительным числом, а не str .

Вы также можете вычислить показатель степени, используя выражение math.e ** x или используя pow (math.e, x) . Время выполнения этих трех методов следующее:

>>>

  >>> timeit.timeit ("math.e ** 308", setup = "import math")
0,17853009998701513

>>> timeit.timeit ("pow (math.e, 308)", setup = "import math")
0,21040189999621361

>>> timeit.timeit ("math.exp (308)", setup = "import math")
0,125878200007719

В следующей таблице сравнивается время выполнения вышеуказанных методов, измеренное с помощью timeit () :

.

Тип	Срок исполнения
`e ** x`	0.1785 с
`pow (e, x)`	0,2104 с
`math.exp (x)`	0,1259 с

Вы можете видеть, что math.exp () быстрее, чем другие методы, а pow (e, x) - самый медленный. Это ожидаемое поведение из-за базовой реализации C модуля math .

Также стоит отметить, что e ** x и pow (e, x) возвращают одинаковые значения, но exp () возвращает немного другое значение.Это связано с различиями в реализации. В документации Python отмечается, что exp () более точен, чем два других метода.

`Практический пример с`

exp ()

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

Уравнение радиоактивного распада

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

N (0) - начальное количество вещества.
N (т) - это количество, которое еще остается и еще не разложилось по прошествии некоторого времени ( т ).
T - период полураспада распадающегося количества.
e - число Эйлера.

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

Радиоизотоп стронций-90 имеет период полураспада 38,1 года. В пробе содержится 100 мг Sr-90. Вы можете рассчитать оставшиеся миллиграммы Sr-90 через 100 лет:

>>>

  >>> half_life = 38,1
>>> начальный = 100
>>> время = 100
>>> оставшийся = начальный * math.exp (-0,693 * время / период полураспада)
>>> f "Оставшееся количество Sr-90: {осталось}"
«Оставшееся количество Sr-90: 16.22044604811303 '

Как видите, период полураспада установлен на 38,1, а продолжительность установлена на 100 лет. Вы можете использовать math.exp , чтобы упростить уравнение. Подставляя значения в уравнение, вы можете обнаружить, что через 100 лет остается 16,22 мг Sr-90.

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

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

Общая логарифмическая функция

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

`Python Natural Log с`

журналом ()

Натуральный логарифм числа - это его логарифм по основанию математической константы e , или числа Эйлера:

Натуральная логарифмическая функция

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

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

log () имеет два аргумента. Первый является обязательным, а второй - необязательным. С одним аргументом вы можете получить натуральный логарифм (с основанием e ) входного числа:

>>>

  >>> math.log (4)
1,3862943611198906
>>> математика.журнал (3.4)
1,2237754316221157

Однако функция возвращает ValueError , если вы вводите неположительное число:

>>>

  >>> math.log (-3)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ValueError: ошибка математического домена

Как видите, в log () нельзя ввести отрицательное значение. Это связано с тем, что значения журнала не определены для отрицательных чисел и нуля.

С двумя аргументами вы можете вычислить логарифм первого аргумента по основанию второго аргумента:

>>>

  >>> математ.журнал (math.pi, 2)
1.651496129472319
>>> math.log (math.pi, 5)
0,711260668712669

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

`Общие сведения о`

log2 () и log10 ()

Модуль Python math также предоставляет две отдельные функции, которые позволяют вычислять значения журнала с основанием 2 и 10:

.

log2 () используется для вычисления значения журнала по основанию 2.
log10 () используется для вычисления значения журнала по основанию 10.

С помощью log2 () вы можете получить значение журнала с основанием 2:

>>>

  >>> math.log2 (math.pi)
1.6514961294723187
>>> math.log (math.pi, 2)
1.651496129472319

Обе функции преследуют одну и ту же цель, но в документации Python отмечается, что log2 () более точен, чем использование log (x, 2) .

Вы можете вычислить логарифмическое значение числа по основанию 10 с помощью log10 () :

>>>

  >>> математ.log10 (math.pi)
0,4971498726941338
>>> math.log (math.pi, 10)
0,4971498726941338

В документации Python также упоминается, что log10 () более точен, чем log (x, 10) , хотя обе функции преследуют одну и ту же цель.

`Практический пример с натуральным бревном`

В предыдущем разделе вы видели, как использовать math.exp () для вычисления оставшегося количества радиоактивного элемента через определенный период времени. С математ.log () , вы можете определить период полураспада неизвестного радиоактивного элемента, измерив массу через определенный интервал. Следующее уравнение можно использовать для расчета периода полураспада радиоактивного элемента:

Уравнение радиоактивного распада

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

T - период полураспада распадающегося количества.
N (0) - исходное количество вещества.
N (т) - это количество, которое остается и еще не разложилось по прошествии определенного периода времени ( т ).
ln - натуральное бревно.

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

Например, представьте, что вы изучаете образец неопознанного радиоактивного элемента.Когда это было обнаружено 100 лет назад, размер образца составлял 100 мг. После 100 лет распада осталось всего 16,22 мг. Используя формулу выше, вы можете рассчитать период полураспада этого неизвестного элемента:

>>>

  >>> начальное = 100
>>> Осталось = 16,22
>>> время = 100
>>> half_life = (-0,693 * время) / math.log (оставшееся / начальное)
>>> f "Период полураспада неизвестного элемента: {half_life}"
'Период полураспада неизвестного элемента: 38.09942398335152'

Как видите, неизвестный элемент имеет период полураспада примерно 38.1 год. Основываясь на этой информации, вы можете идентифицировать неизвестный элемент как стронций-90.

`Прочие важные`

math Функции модуля

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

`Вычислить наибольший общий делитель`

Наибольший общий делитель (НОД) двух положительных чисел - это наибольшее положительное целое число, которое делит оба числа без остатка.

Например, НОД 15 и 25 равно 5. Вы можете разделить 15 и 25 на 5 без остатка. Нет большего числа, делающего то же самое. Если взять 15 и 30, то НОД будет 15, потому что и 15, и 30 можно разделить на 15 без остатка.

Для расчета GCD не нужно реализовывать собственные функции. Модуль Python math предоставляет функцию под названием math.gcd () , которая позволяет вычислить НОД двух чисел.В качестве входных данных можно указать положительные или отрицательные числа, и он вернет соответствующее значение НОД. Однако вы не можете ввести десятичное число.

`Вычислить сумму итераций`

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

`Вычислить квадратный корень`

Квадратный корень числа - это значение, которое при умножении на себя дает число. Вы можете использовать math.sqrt () , чтобы найти квадратный корень из любого положительного действительного числа (целого или десятичного). Возвращаемое значение всегда является значением с плавающей запятой. Функция выдаст ValueError , если вы попытаетесь ввести отрицательное число.

`Преобразование значений углов`

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

Если вы хотите преобразовать градусы в радианы, вы можете использовать math.radians () . Он возвращает значение введенного градуса в радианах. Аналогичным образом, если вы хотите преобразовать радианы в градусы, вы можете использовать math.degrees () .

`Расчет тригонометрических значений`

Тригонометрия - это изучение треугольников.Он касается отношения между углами и сторонами треугольника. Тригонометрия в основном интересует прямоугольные треугольники (в которых один внутренний угол равен 90 градусам), но ее также можно применить к другим типам треугольников. Модуль Python math предоставляет очень полезные функции, позволяющие выполнять тригонометрические вычисления.

Вы можете рассчитать значение синуса угла с помощью math.sin () , значение косинуса с помощью math.cos () и значение тангенса с помощью math.загар () . Модуль math также предоставляет функции для вычисления арксинуса с math.asin () , арккосинуса с math.acos () и арктангенса с math.atan () . Наконец, вы можете вычислить гипотенузу треугольника, используя math.hypot () .

`Новые дополнения к модулю`

math в Python 3.8

С выпуском Python версии 3.8 в модуль math было внесено несколько новых дополнений и изменений.Новые дополнения и изменения заключаются в следующем:

comb (n, k) возвращает количество способов выбора k элементов из n элементов без повторения и без определенного порядка .
perm (n, k) возвращает количество способов выбора k элементов из n элементов без повторения и с заказом .
isqrt () возвращает целочисленный квадратный корень неотрицательного целого числа.
prod () вычисляет произведение всех элементов во входной итерации. Как и fsum () , этот метод может принимать итерации, такие как массивы, списки или кортежи.
dist () возвращает евклидово расстояние между двумя точками p и q , каждая из которых задана как последовательность (или итерация) координат. Две точки должны иметь одинаковый размер.
hypot () теперь обрабатывает более двух измерений.Ранее он поддерживал максимум два измерения.

cmath и math

Комплексное число - это комбинация действительного и мнимого числа. Он имеет формулу a + bi , где a - действительное число, а bi - мнимое число. Действительные и мнимые числа можно объяснить следующим образом:

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

Действительным числом может быть любое число. Например, 12, 4,3, -19,0 - все действительные числа. Мнимые числа отображаются как i . На следующем изображении показан пример комплексного числа:

. Комплексное число

В приведенном выше примере 7 - действительное число, а 3i - мнимое число. Комплексные числа в основном используются в геометрии, исчислении, научных расчетах и особенно в электронике.

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

Вы можете импортировать модуль cmath следующим образом:

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

>>>

  >>> c = 2 + 3j
>>> c
(2 + 3j)

>>> тип (c)
<класс 'сложный'>

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

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

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

>>>

  >>> c = комплекс (2, 3)
>>> c
(2 + 3j)

>>> тип (c)
<класс 'сложный'>

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

>>>

  >>> cmath.sqrt (с)
(1.8581072140693775 + 0.6727275964137814j)

>>> cmath.log (c)
(1,3622897515267103 + 0,6947382761967031j)

>>> cmath.exp (c)
(-16.0670844 + 12.02063434789931j)

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

`NumPy против`

math

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

Сердце NumPy - это высокопроизводительная структура данных N -мерного (многомерного) массива. Этот массив позволяет выполнять математические операции со всем массивом без циклического перебора элементов.Все функции библиотеки оптимизированы для работы с объектами N-мерного массива.

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

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

При работе со скалярными значениями функции модуля math могут быть быстрее, чем их аналоги в NumPy. Это связано с тем, что функции NumPy преобразуют значения в массивы под капотом, чтобы выполнять над ними вычисления.NumPy работает намного быстрее при работе с размерными массивами N из-за оптимизации для них. За исключением fsum () и prod () , функции модуля math не могут обрабатывать массивы.

`Заключение`

Из этой статьи вы узнали о модуле Python math . Модуль предоставляет полезные функции для выполнения математических вычислений, которые имеют множество практических приложений.

Из этой статьи вы узнали:

Что такое модуль Python math
Как использовать math функций с практическими примерами
Какие константы модуля math , включая пи, тау и число Эйлера, равны
В чем разница между встроенными функциями и функциями math
В чем разница между math , cmath и NumPy:

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

`Встроенные модули Python`

Интерактивная оболочка Python имеет ряд встроенных функций. Они загружаются автоматически при запуске оболочки и всегда доступны, например print () и input () для ввода-вывода, функции преобразования чисел int (), float (), complex (), список преобразований типов данных (), кортеж (), set () и т. д.

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

Встроенные модули написаны на C и интегрированы с оболочкой Python. Каждый встроенный модуль содержит ресурсы для определенных системных функций, таких как управление ОС, дисковый ввод-вывод и т. Д.Стандартная библиотека также содержит множество скриптов Python (с расширением .py), содержащих полезные утилиты.

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

  >>> help ('модули')

Секреты IPython _weakrefset heapq
__future__ _winapi hmac выберите
_abc abc html-селекторы
_ast aifc http setuptools
_asyncio antigravity idlelib полка
_bisect argparse imaplib shlex
_blake2 массив imghdr shutil
_bootlocale ast imp signal
_bz2 asynchat importlib simplegeneric
_codecs asyncio ind сайт
_codecs_cn asyncore проверить шесть
_codecs_hk atexit io smtpd
_codecs_iso2022 audioop ipaddress smtplib
_codecs_jp автозагрузка ipython_genutils sndhdr
_codecs_kr backcall сокет itertools
_codecs_tw base64 jedi socketserver
_collections bdb json sqlite3
_collections_abc ключевое слово binascii sre_compile
_compat_pickle binhex lib2to3 sre_constants
_compression bisect linecache sre_parse
_contextvars встроенная локаль ssl
_csv bz2 logging stat
_ctypes cProfile статистика lzma
_ctypes_test календарь macpath storemagic
_datetime строка почтового ящика cgi
_decimal cgitb mailcap stringprep
_distutils_findvs структура маршалинга фрагментов
_dummy_thread cmath математический подпроцесс
_elementtree cmd mimetypes sunau
_functools код символ mmap
_hashlib codecs modulefinder sympyprinting
_heapq codeop msilib symtable
_imp коллекции msvcrt sys
_io colorama multiprocessing sysconfig
_json colorsys netrc tabnanny
_locale compileall nntplib tarfile
_lsprof одновременный NT telnetlib
_lzma configparser временный файл ntpath
_markupbase contextlib тест nturl2path
_md5 contextvars числа тесты
_msi copy opcode textwrap
_multibytecodec copyreg оператор это
_multiprocessing crypt optparse threading
_opcode csv os время
_operator ctypes синтаксический анализатор timeit
_osx_support curses parso tkinter
_overlapped cythonmagic pathlib token
_pickle dataclasses pdb tokenize
_py_abc datetime трассировка рассола
_pydecimal dbm pickleshare traceback
_pyio decimal инструменты для маринования tracemalloc
_queue декоратор pip traitlets
_random difflib pipe tty
_sha1 dis pkg_resources черепаха
_sha256 distutils pkgutil turtledemo
_sha3 doctest типы платформ
_sha512 dummy_threading plistlib typing
_signal easy_install poplib unicodedata
_sitebuiltin электронная почта posixpath unittest
_socket кодировки pprint urllib
_sqlite3 surepip profile uu
_sre enum prompt_toolkit uuid
_ssl errno pstats venv
_stat faulthandler pty предупреждения
_string filecmp py_compile wave
_strptime fileinput pyclbr wcwidth
_struct fnmatch pydoc weakref
_symtable formatter pydoc_data webbrowser
_testbuffer фракции pyexpat winreg
_testcapi ftplib pygments winsound
_testconsole functools queue wsgiref
_testimportmultiple gc quopri xdrlib
_testmultiphase genericpath random xml
_thread getopt re xmlrpc
_threading_local getpass reprlib xxsubtype
_tkinter gettext rlcompleter zipapp
_tracemalloc glob rmagic zip-файл
_warnings gzip runpy zipimport
_weakref hashlib sched zlib

Введите любое имя модуля, чтобы получить дополнительную помощь.Или введите "модули спама" для поиска
для модулей, в названии или резюме которых содержится строка «спам».

Узнайте о некоторых из часто используемых встроенных модулей в следующих нескольких главах.

`Научитесь создавать и импортировать специальные и встроенные модули`

`Что такое модули в Python?`

Модули

относятся к файлу, содержащему операторы и определения Python.

Файл, содержащий код Python, например: example.py , называется модулем, и его имя модуля будет , например .

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

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

Создадим модуль. Введите следующее и сохраните его как example.py .

  # Пример модуля Python

def add (a, b):
   "" "Эта программа добавляет два
   числа и вернуть результат "" "

   результат = a + b
   вернуть результат

Здесь мы определили функцию add () внутри модуля с именем example .Функция принимает два числа и возвращает их сумму.

`Как импортировать модули в Python?`

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

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

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

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

Используя имя модуля, мы можем получить доступ к функции, используя точку . оператор. Например:

  >>> example.add (4,5.5)
9,5

Python имеет множество стандартных модулей. Вы можете ознакомиться с полным списком стандартных модулей Python и вариантов их использования. Эти файлы находятся в каталоге Lib внутри того места, где вы установили Python.

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

можно импортировать так же, как мы импортируем наши пользовательские модули.

Есть разные способы импорта модулей. Они перечислены ниже ..

`Оператор импорта Python`

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

  # пример инструкции импорта
# для импорта математики стандартного модуля

импортная математика
print («Значение числа пи», math.pi)

При запуске программы вывод будет:

  Число Пи равно 3.1415589793

`Импорт с переименованием`

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

  # импортировать модуль, переименовав его

импортировать математику как m
print («Значение числа пи», m.pi)

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

Обратите внимание, что имя math не распознается в нашей области. Следовательно, math.pi недействителен, а m.pi - правильная реализация.

`Python from ... оператор импорта`

Мы можем импортировать определенные имена из модуля, не импортируя модуль в целом. Вот пример.

  # импортировать только пи из математического модуля

из математического импорта Пи
print («Значение числа Пи равно», Пи)

Здесь мы импортировали только атрибут pi из модуля math .

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

  >>> из математического импорта pi, e
>>> пи
3.1415589793
>>> е
2,718281828459045

`Импортировать все имена`

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

  # импортировать все имена из стандартного модуля math

из математического импорта *
print («Значение числа Пи равно», Пи)

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

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

`Путь поиска модуля Python`

При импорте модуля Python просматривает несколько мест. Интерпретатор сначала ищет встроенный модуль. Затем (если встроенный модуль не найден) Python просматривает список каталогов, определенных в sys.path . Поиск ведется в таком порядке.

Текущий каталог.
PYTHONPATH (переменная среды со списком каталогов).
Зависящий от установки каталог по умолчанию.

>>> import sys
>>> sys.path
['',
'C: \ Python33 \ Lib \ idlelib',
'C: \ Windows \ system32 \ python33.zip',
'C: \ Python33 \ DLLs',
'C: \ Python33 \ lib',
'C: \\ Python33',
'C: \\ Python33 \\ lib \\ site-packages']

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

`Перезарядка модуля`

Интерпретатор Python импортирует модуль только один раз за сеанс. Это делает вещи более эффективными. Вот пример, показывающий, как это работает.

Предположим, у нас есть следующий код в модуле с именем my_module .

  # Этот модуль показывает эффект
# множественный импорт и перезагрузка

print («Этот код был выполнен»)

Теперь мы видим эффект от множественного импорта.

  >>> импортировать my_module
Этот код был выполнен
>>> импортировать my_module
>>> import my_module

Мы видим, что наш код был выполнен только один раз.Это означает, что наш модуль был импортирован только один раз.

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

Python предоставляет более эффективный способ сделать это. Мы можем использовать функцию reload () внутри модуля imp для перезагрузки модуля. Сделать это можно следующими способами:

  >>> импортный имп
>>> импортировать my_module
Этот код был выполнен
>>> импортировать my_module
>>> имп.перезагрузить (my_module)
Этот код был выполнен
<модуль 'my_module' из '. \\ my_module.py'>

`Встроенная функция dir ()`

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

Например, мы определили функцию add () в модуле example , который у нас был в начале.

Мы можем использовать dir в модуле , пример следующим образом:

  >>> dir (пример)
['__builtins__',
'__cached__',
'__doc__',
'__файл__',
'__initializing__',
'__loader__',
'__название__',
'__упаковка__',
'добавить']

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