Python math functions

The Math Module

Python has also a built-in module called , which extends the list of mathematical functions.

To use it, you must import the module:

import math

When you have imported the module, you
can start using methods and constants of the module.

The method for example, returns the square root of a number:

import
mathx = math.sqrt(64)print(x)

The method rounds a number upwards to
its nearest integer, and the
method rounds a number downwards to its nearest integer, and returns the result:

import
mathx = math.ceil(1.4)y = math.floor(1.4)print(x) #
returns 2print(y) # returns 1

The constant, returns the value of
PI (3.14…):

Фаза (аргумент)

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

Угол между вектором и действительной осью определяется как или комплексного числа.

Формально это определяется как:

фаза (число) = arctan (мнимая_часть / действительная_часть)

где функция arctan является обратной математической функцией tan.

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

import cmath
import math

num = 4 + 3j

# Using cmath module
p = cmath.phase(num)
print('cmath Module:', p)

# Using math module
p = math.atan(num.imag/num.real)
print('Math Module:', p)

Вывод:

cmath Module: 0.6435011087932844
Math Module: 0.6435011087932844

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

import cmath
import numpy as np

num = 4 + 3j

# Using cmath module
p = cmath.phase(num)
print('cmath Module in Radians:', p)
print('Phase in Degrees:', np.degrees(p))

Вывод:

cmath Module in Radians: 0.6435011087932844
Phase in Degrees: 36.86989764584402

Вычисления

Вычисления пределов

Для вычисления пределов в SymPy предусмотрен очень простой синтаксис, а именно . Например, если вы хотите вычислить предел функции , где , то надо написать .

sym.limit(sym.sin(x) / x, x, 0) # результат 1

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

sym.limit(x, x, sym.oo) # результат oo
sym.limit(1 / x, x, sym.oo) # результат 0
sym.limit(x ** x, x, 0) # результат 1

Дифференцирование

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

sym.diff(sym.sin(x), x) # результат cos(?)
sym.diff(sym.sin(2 * x), x) # результат 2cos(2?)
sym.diff(sym.tan(x), x)

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

sym.limit((sym.tan(x + y) - sym.tan(x)) / y, y, 0)

Результат тот же.

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

sym.diff(sym.sin(2 * x), x, 1) # результат 2cos(2?)
sym.diff(sym.sin(2 * x), x, 2) # результат −4sin(2?)
sym.diff(sym.sin(2 * x), x, 3) # результат −8cos(2?)

Разложение в ряд

Для разложения выражения в ряд Тейлора используется следующий синтаксис: .

sym.series(sym.cos(x), x)

sym.series(1/sym.cos(x), x)

Интегрирование

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

sym.integrate(sym.sin(x), x) # результат −cos(?)
sym.integrate(sym.log(x), x) # результат ?log(?)−?

Также несложно посчитать интеграл и от специальных функций. Возьмем, например, функцию Гаусса:

sym.integrate(sym.exp(-x ** 2) * sym.erf(x), x)

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

sym.integrate(x**3, (x, -1, 1)) # результат 0
sym.integrate(sym.sin(x), (x, 0, sym.pi / 2)) # результат 1
sym.integrate(sym.cos(x), (x, -sym.pi / 2, sym.pi / 2)) 
# результат 2

Также можно вычислять определенные интегралы с бесконечными пределами интегрирования (несобственные интегралы).

sym.integrate(sym.exp(-x), (x, 0, sym.oo)) # результат 1

Решение уравнений

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

sym.solveset(x ** 4 - 1, x) # результат {−1,1,−?,?}

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

sym.solveset(sym.exp(x) + 1, x) # результат {?(2??+?)|?∈ℤ}

Системы линейных уравнений

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

solution = sym.solve((x + 5 * y - 2, -3 * x + 6 * y - 15), (x, y))
solution, solution # результат (-3, 1) 

Факторизация

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

f = x ** 4 - 3 * x ** 2 + 1
sym.factor(f)

sym.factor(f, modulus=5)

Булевы уравнения

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

sym.satisfiable(x & y) # результат {x: True, y: True}

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

sym.satisfiable(x & ~x) # результат False

Веб-разработка

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

Beautiful Soup. Библиотека Python для быстрого парсинга HTML- и XML-файлов.

scrape. Модуль Python для веб-браузинга и скрапинга.

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

libgmail. Обеспечивает доступ к гугловскому сервису Gmail.

Google Maps. Благодаря этому модулю можно использовать веб-сервисы платформы Google Maps в своем приложении на Python.

Requests позволяет невероятно легко отсылать HTTP/1.1-запросы.

Selenium. При помощи этого модуля разработчики могут программными методами открывать веб-страницы, заполнять поля, кликать по кнопкам и отсылать формы.

pyquery позволяет делать jQuery-запросы в XML-документах. API этой библиотеки максимально приближен к jQuery. Для быстрой манипуляции с XML и HTML pyquery использует LXML.

Логические операции с десятичным модулем

Decimal содержит набор встроенных функций для выполнения логических операций с десятичными числами, таких как AND, OR, XOR и т. Д.

• Функция logical_and(): выполняет операцию логического И над двумя десятичными числами и возвращает результат.
• Функция logical_or(): выполняет операцию логического ИЛИ над двумя десятичными числами и возвращает результат.
• Функция logical_xor(): выполняет логическую операцию XOR над двумя десятичными числами и возвращает результат.

#Syntax for logical_and() function-
decimal1.logical_and(decimal2)

#Syntax for logical_or() function-
decimal1.logical_or(decimal2)

#Syntax for logical_xor() function-
decimal1.logical_xor(decimal2)

Пример:

import decimal as d

valx = d.Decimal(1001)
valy = d.Decimal(1111)

print("Value 1: ",valx)
print("Value 2: ",valy)

AND = valx.logical_and(valy)
print("The logical AND value of the two decimals: ",AND)

OR = valx.logical_or(valy)
print("The logical OR value of the two decimals: ",OR)

XOR = valx.logical_xor(valy)
print("The logical XOR value of the two decimals: ",XOR)

Выход:

Value 1:  1001
Value 2:  1111
The logical AND value of the two decimals:  1001
The logical OR value of the two decimals:  1111
The logical XOR value of the two decimals:  110

cmath vs math

A complex number is a combination of a real number and an imaginary number. It has the formula of a + bi, where a is the real number and bi is the imaginary number. Real and imaginary numbers can be explained as follows:

• A real number is literally any number you can think of.
• An imaginary number is a number that gives a negative result when squared.

A real number can be any number. For example, 12, 4.3, -19.0 are all real numbers. Imaginary numbers are shown as i. The following image shows an example of a complex number:

In the example above, 7 is the real number and 3i is the imaginary number. Complex numbers are mostly used in geometry, calculus, scientific calculations, and especially in electronics.

The functions of the Python module aren’t equipped to handle complex numbers. However, Python provides a different module that can specifically deal with complex numbers, the module. The Python module is complemented by the module, which implements many of the same functions but for complex numbers.

You can import the module as follows:

>>>

Since the module is also packaged with Python, you can import it the same way you imported the module. Before you work with the module, you have to know how to define a complex number. You can define a complex number as follows:

>>>

As you can see, you can determine that a number is indeed complex by using .

Note: In mathematics, the imaginary unit is usually denoted i. In some fields, it’s more customary to use j for the same thing. In Python, you use to denote imaginary numbers.

Python also provides a special built-in function called that lets you create complex numbers. You can use as follows:

>>>

You can use either method to create complex numbers. You can also use the module to calculate mathematical functions for complex numbers as follows:

>>>

Импорт модуля

Если запустить в каталоге, в котором лежит данный модуль (например, my_module.py), интерпретатор:

>>> python

и потом сделать импорт модуля:

>>> import my_module

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

>>> my_module.func1()
>>> my_module.func2()
...

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

>>> f1 = my_module.func1

Второй вариант импорта — взятие непосредственно имени без имени модуля:

>>> from my_module import func1, func2
>>> func1()

Третий вариант импорта — включение всех имен, определенных в модуле:

>>> from my_module import *
>>> func1()

Для предотвращения конфликта имен можно использовать создание алиаса:

>>> from my_module import open as my_open

Пример. Импорт на основе from обладает такой особенностью, что он делает импортируемые атрибуты read-only:

>>> from small import x, y
>>> x = 42

В данном случае x — это локальная переменная, в то время как переменные x, y в самом модуле small не меняются:

>>> import small
>>> small.x = 42

здесь x — глобальная переменная.

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

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

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

Модули могут импортировать другие модули. Обычно инструкцию import располагают в начале модуля или программы.

Перебор последовательности с помощью itertools.cycle()

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

Рассмотрим два состояния лампочки: «включено» и «выключено».

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

import itertools

# Initially, bulb is switched off, so off is the first element in the list
bulb_states = itertools.cycle()

for _ in range(5):
    # Use next(iterator) to get the current state
    curr_state = next(bulb_states)
    print(f"Bulb state currently {curr_state}")

Выход

Bulb state currently off
Bulb state currently on
Bulb state currently off
Bulb state currently on
Bulb state currently off

Состояние лампочки постоянно меняется между двумя значениями «включено» и «выключено».

Разработка игр

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

Pygame. Набор модулей для написания видеоигр. Pygame расширяет функционал прекрасной библиотеки SDL. Благодаря ему на Python можно создавать полнофункциональные игры и мультимедиа-программы.

Pyglet. Мощная, но при этом простая в использовании библиотека Python для разработки игр и других приложений с большим количеством визуальных эффектов для Windows, Mac OS X и Linux.

pyOpenGL. Этот модуль чаще других используется для обеспечения работы с библиотекой OpenGL и связанными с нею API в программах на Python.

cmath[править]

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

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

Переход к полярным координатам и обратноправить

Комплексное число z может быть представлено в Декартовой системе координат в представлении, что действительная z.real часть откладывается по оси x, а мнимая z.imag — по оси y. Само число z записывается:

z = z.real + z.imag*1j

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

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

• cmath.phase

  Возвращает фазовый угол φ для числа x, phase(x) эквивалентно math.atan2(x.imag, x.real). Результат лежит в интервале .

  (x)

• cmath.polar

  Возвращает представление x в полярных координатах, то есть возвращает пару (r, phi).

  (x)

• cmath.rect(r, phi)

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

  (x)

Другие функцииправить

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

Константыправить

• cmath.pi
• cmath.e

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

Multiplication and Division

Like addition and subtraction, multiplication and division will look very similar to how they do in mathematics. The sign we’ll use in Python for multiplication is and the sign we’ll use for division is .

Here’s an example of doing multiplication in Python with two float values:

When you divide in Python 3, your quotient will always be returned as a float, even if you use two integers:

This is one of the . Python 3’s approach provides a fractional answer so that when you use to divide by the quotient of will be returned. In Python 2 the quotient returned for the expression is .

Python 2’s operator performs floor division, where for the quotient the number returned is the largest integer less than or equal to . If you run the above example of with Python 2 instead of Python 3, you’ll receive as the output without the decimal place.

In Python 3, you can use to perform floor division. The expression will return the value of . Floor division is useful when you need a quotient to be in whole numbers.

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

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

from math import pi, pow

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

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

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

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

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

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

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

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

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

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

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

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

Addition and Subtraction

In Python, addition and subtraction operators perform just as they do in mathematics. In fact, you can use the Python programming language as a calculator.

Let’s look at some examples, starting with integers:

Instead of passing integers directly into the statement, we can initialize variables to stand for integer values:

Because integers can be both positive and negative numbers (and 0 too), we can add a negative number with a positive number:

Addition will behave similarly with floats:

Because we added two floats together, Python returned a float value with a decimal place.

The syntax for subtraction is the same as for addition, except you’ll change your operator from the plus sign () to the minus sign ():

Here, we subtracted an integer from a float. Python will return a float if at least one of the numbers involved in an equation is a float.

Экспоненциальные и логарифмические функции

import cmath
a = 3 + 4j
print('e^c =', cmath.exp(a))
print('log2(c) =', cmath.log(a, 2))
print('log10(c) =', cmath.log10(a))
print('sqrt(c) =', cmath.sqrt(a))

Вывод:

e^c = (-13.128783081462158-15.200784463067954j)
log2(c) = (2.321928094887362+1.3378042124509761j)
log10(c) = (0.6989700043360187+0.4027191962733731j)
sqrt(c) = (2+1j)

Другие

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

>>> print(cmath.isfinite(2 + 2j))
True

>>> print(cmath.isfinite(cmath.inf + 2j))
False

>>> print(cmath.isinf(2 + 2j))
False

>>> print(cmath.isinf(cmath.inf + 2j))
True

>>> print(cmath.isinf(cmath.nan + 2j))
False

>>> print(cmath.isnan(2 + 2j))
False

>>> print(cmath.isnan(cmath.inf + 2j))
False

>>> print(cmath.isnan(cmath.nan + 2j))
True

>>> print(cmath.isclose(2+2j, 2.01+1.9j, rel_tol=0.05))
True

>>> print(cmath.isclose(2+2j, 2.01+1.9j, abs_tol=0.005))
False

Линейная алгебра

Матрицы

Матрицы в создаются как экземпляры класса :

sym.Matrix(, ])

В отличие от , мы можем использовать в матрицах символьные переменные:

x, y = sym.symbols('x, y')
A = sym.Matrix(, ])
A

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

A**2

Дифференциальные уравнения

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

f, g = sym.symbols('f g', cls=sym.Function)

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

f(x) # результат ?(?)
f(x).diff(x, x) + f(x)

Теперь решим следующее дифференциальное уравнение:

sym.dsolve(f(x).diff(x, x) + f(x), f(x))
# результат ?(?)=?1sin(?)+?2cos(?)

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

sym.dsolve(sym.sin(x) * sym.cos(f(x)) + sym.cos(x) * sym.sin(f(x)) * f(x).diff(x), f(x), hint='separable') 
# результат [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), 
#            acos(C1/cos(x)))]

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

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

import cmath

a = 3 + 4j

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

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

Вывод:

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

Getting to Know the Python math Module

The Python module is an important feature designed to deal with mathematical operations. It comes packaged with the standard Python release and has been there from the beginning. Most of the module’s functions are thin wrappers around the C platform’s mathematical functions. Since its underlying functions are written in CPython, the module is efficient and conforms to the C standard.

The Python module offers you the ability to perform common and useful mathematical calculations within your application. Here are a few practical uses for the module:

• Calculating combinations and permutations using factorials
• Calculating the height of a pole using trigonometric functions
• Calculating radioactive decay using the exponential function
• Calculating the curve of a suspension bridge using hyperbolic functions
• Solving quadratic equations
• Simulating periodic functions, such as sound and light waves, using trigonometric functions

Since the module comes packaged with the Python release, you don’t have to install it separately. Using it is just a matter of importing the module:

>>>

NumPy vs math

Several notable Python libraries can be used for mathematical calculations. One of the most prominent libraries is Numerical Python, or NumPy. It is mainly used in scientific computing and in data science fields. Unlike the module, which is part of the standard Python release, you have to install NumPy in order to work with it.

The heart of NumPy is the high-performance N-dimensional (multidimensional) array data structure. This array allows you to perform mathematical operations on an entire array without looping over the elements. All of the functions in the library are optimized to work with the N-dimensional array objects.

Both the module and the NumPy library can be used for mathematical calculations. NumPy has several similarities with the module. NumPy has a subset of functions, similar to module functions, that deal with mathematical calculations. Both NumPy and provide functions that deal with , , , and calculations.

There are also several fundamental differences between and NumPy. The Python module is geared more towards working with scalar values, whereas NumPy is better suited for working with arrays, vectors, and even matrices.

Для повторения значения

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

Например, если вы хотите построить последовательность вида , где i находится в диапазоне от 0 до 10, вы можете использовать эту функцию.

import itertools

data = list(zip(range(10), itertools.repeat(5)))
print(data)

Выход

Действительно, нам удалось легко сделать эту последовательность.

Другой пример, в котором эта функция полезна, — если вы пытаетесь построить квадраты с помощью map() в Python.

squares = list(map(pow, range(10), itertools.repeat(2)))
print(squares)

Выход

Видите, как легко мы смогли построить его с помощью .

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

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

Синтаксис:

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

Пример:

import decimal as d

d.getcontext().prec = 5

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

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

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

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

Выход:

Decimal Number:  24.401                                                                                                       
3.9557E+10                                                                                                                    
1.131231000000000097571728474576957523822784423828125   

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

Заключение

Сегодня мы узнали основы модульной системы питона и импорта компонентов. Импорт модулей — это основа программной архитектуры в питоне. Большие программы состоят из большого количества файлов, и объединяет их линковка во время исполнения на основе импорта. Модули структурируют программу, разбивая логику на отдельные компоненты. Код внутри одного модуля изолирован от остальных модулей, что минимизирует коллизию имен внутри программы.

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

<< Предыдущая статья. Следующая статья >>