The python math module: everything you need to know

Встроенные функции

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

round

– округляет число (number) до ndigits знаков после запятой. Это стандартная функция, которая для выполнения не требует подключения модуля math.

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

Чтобы получить целый показатель, результат преобразовывают в .

Синтаксически функция вызывается двумя способами.

1. – это округление числа до целого, которое расположено ближе всего. Если дробная часть равна 0,5, то округляют до ближайшего четного значения.
2. – данные округляют до знаков после точки. Если округление проходит до сотых, то равен «2», если до тысячных – «3» и т.д.

int

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

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

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

1. Если число положительное, добавить к нему 0,5.
2. Если число отрицательное, добавить -0,5.

Синтаксически преобразование оформляется так:

Комбинации элементов между собой

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

import itertools

values = 

com = itertools.combinations_with_replacement(values, 2)

for val in com:
	print(*val)

Выход:

1 1
1 2
1 3
1 4
2 2
2 3
2 4
3 3
3 4
4 4

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

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

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

Input : string = 'XYZ'
Output : XYZ
         XZY 
         YXZ
         YZX
         ZXY       
         ZYX

Алгоритм

Step 1: given string.
Step 2: Get all permutations of string.
Step 3: print all permutations.

Пример кода

from itertools import permutations 
def allPermutations(str1): 
   # Get all permutations of string 'ABC' 
   per = permutations(str1) 
   # print all permutations
   print("Permutation Of this String ::>")
   for i in list(per): 
      print (''.join(i)) 
# Driver program 
if __name__ == "__main__": 
   str1 = input("Enter the string ::>")
   allPermutations(str1) 

Вывод

Enter the string ::> abc
Permutation Of this String ::>
abc
acb
bac
bca
cab
cba

Python Tutorial

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

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

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

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

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

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

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

Функции из библиотеки Math

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

math.ceil

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

Любая дробь находится между двумя целыми числами. Например, 2.3 лежит между 2 и 3. Функция ceil() определяет большую сторону и возводит к нему результат преобразования. Например:

Алгоритм определяет большую границу интервала с учетом знака:

math.floor

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

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

math.trunc

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

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

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

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

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

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

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

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

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

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.

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

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

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

Python

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

1 2	frommathimportexp exp(3)# Вычисление экспоненты

Компиляция файлов

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

Некоторые полезные опции компиляции:

1. — эта опция заставляет интерпретатор компилировать так называемый оптимизированный байт-код и сохранять его в файле с расширением ‘.pyo’. При этом из кода удаляются ассерты, игнорируется условный дебаг, ‘.pyc’-файлы игнорируются.
2. — эта опция делает то же, что и предыдущая опция, плюс удаляет комменты.
3. Файл, запускаемый непосредственно из командной строки, никогда не компилируется. Для оптимизации его запуска необходимо большую часть кода убрать в модули.
4. Модуль может загружаться из файлов с расширением ‘.pyс’ или ‘.pyo’, даже если нет файла с расширением ‘.py’. Это может пригодиться в тех случаях, когда вы не хотите распространять исходный код.
5. Кроме того, интерпретатор может загружать бинарники, собранные с помощью языка си — файлы с расширением ‘.so’ в линуксе либо ‘.dll’ в Windows.
6. Модуль можно «зазипповать» в архив с расширением ‘.zip’ и импортировать из архива.
7. Может быть загружен Java-класс, собранный с помощью Jython.

Вычисления

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

Для вычисления пределов в 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

Data Science и математика

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

SciPy. SciPy (произносится как «сай пай») это экосистема программного обеспечения с открытым кодом для математики, науки и инженерии.

Matplotlib. Библиотека Python для создания 2D-графиков. Генерирует пригодные для печати изображения в разных форматах. Matplotlib может использоваться в скриптах, интерпретаторе Python, в Jupyter Notebook, на серверах веб-приложений и в GUI-инструментарии.

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

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

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

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

import cmath

a = 3 + 4j

print('Hyperbolic Sine:', cmath.sinh(a))
print('Hyperbolic Cosine:', cmath.cosh(a))
print('Hyperbolic Tangent:', cmath.tanh(a))

print('Inverse Hyperbolic Sine:', cmath.asinh(a))
print('Inverse Hyperbolic Cosine:', cmath.acosh(a))
print('Inverse Hyperbolic Tangent:', cmath.atanh(a))

Вывод:

Hyperbolic Sine: (-6.5481200409110025-7.61923172032141j)
Hyperbolic Cosine: (-6.580663040551157-7.581552742746545j)
Hyperbolic Tangent: (1.000709536067233+0.00490825806749606j)
Inverse Hyperbolic Sine: (2.2999140408792695+0.9176168533514787j)
Inverse Hyperbolic Cosine: (2.305509031243477+0.9368124611557198j)
Inverse Hyperbolic Tangent: (0.11750090731143388+1.4099210495965755j)

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

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

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

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

фаза (число) = 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

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

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

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

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

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

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

Базы данных

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

MySQLdb. Python DB API-2.0-совместимый интерфейс для доступа к базам данных MySQL.

PyGreSQL. Модуль, который служит интерфейсом для базы данных PostgreSQL. Он дает возможность работать с PostgreSQL-фичами из Python-скрипта.

Gadfly. Простая реляционная СУБД, реализованная на Python (на основе SQL).

SQLAlchemy. Библиотека Python для работы с базами данных с применением ORM. Позволяет разработчикам приложений использовать всю мощь и гибкость SQL.

KinterbasDB. Расширение Python, реализующее поддержку совместимости Python Database API 2.0 для опенсорсной реляционной базы данных Firebird и некоторых версий ее проприетарной кузины — Borland Interbase.

Функция 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.

a = 1 + 2j
b = 2 + 4j
print('Addition =', a + b)
print('Subtraction =', a - b)
print('Multiplication =', a * b)
print('Division =', a / b)

Выход:

Addition = (3+6j)
Subtraction = (-1-2j)
Multiplication = (-6+8j)
Division = (2+0j)

ПРИМЕЧАНИЕ. В отличие от действительных чисел, мы не можем сравнивать два комплексных числа. Мы можем сравнивать только их действительную и мнимую части по отдельности, поскольку это действительные числа. Приведенный ниже фрагмент доказывает это.

>>> a
(4+3j)
>>> b
(4+6j)
>>> a < b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'complex' and 'complex'

Создать комбинации с помощью combinations()

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

iterator = itertools.combinations(*sequence, r)

Вот простой пример:

import itertools
words = 
results = itertools.combinations(words, 2)
for item in results:
    print(item)

Выход

('hello', 'from')
('hello', 'AskPython')
('hello', 'how')
('from', 'AskPython')
('from', 'how')
('AskPython', 'how')

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

results = itertools.combinations_with_replacement(words, 3)

for item in results:
    print(item)

Выход

('hello', 'hello', 'hello')
('hello', 'hello', 'from')
('hello', 'hello', 'AskPython')
('hello', 'hello', 'how')
('hello', 'from', 'from')
('hello', 'from', 'AskPython')
('hello', 'from', 'how')
('hello', 'AskPython', 'AskPython')
('hello', 'AskPython', 'how')
('hello', 'how', 'how')
('from', 'from', 'from')
('from', 'from', 'AskPython')
('from', 'from', 'how')
('from', 'AskPython', 'AskPython')
('from', 'AskPython', 'how')
('from', 'how', 'how')
('AskPython', 'AskPython', 'AskPython')
('AskPython', 'AskPython', 'how')
('AskPython', 'how', 'how')
('how', 'how', 'how')

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

Перебор последовательности с помощью 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

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

Operator Precedence

In Python, as in mathematics, we need to keep in mind that operators will be evaluated in order of precedence, not from left to right or right to left.

If we look at the following expression:

We may read it left to right, but remember that multiplication will be done first, so if we call , we will receive the following value:

This is because evaluates to , and then we add to return as the final result.

If instead we would like to add the value to , then multiply that sum by , we can use parentheses just like we would in math:

One way to remember the order of operation is through the acronym PEMDAS:

Order	Letter	Stands for
1	P	Parentheses
2	E	Exponent
3	M	Multiplication
4	D	Division
5	A	Addition
6	S	Subtraction

You may be familiar with another acronym for the order of operations, such as BEDMAS or BODMAS. Whatever acronym works best for you, try to keep it in mind when performing math operations in Python so that the results that you expect are returned.

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:

>>>

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

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.

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

Пакеты

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

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

Например, есть пакет, который лежит в корневой папке TCP. В нем лежат два подкаталога — Server и Client:

TCP/
   _init_.py
   main.py
   
   Server/
         _init_.py
         tcp.py
         server.py
         lib.py
   Client/
         _init_.py
         tcp.py
         client.py
         lib.py

Файл _init_.py необходим для того, чтобы интерпретатор распознал каталог, как содержащий пакет. Обычно это пустой файл. Тогда импорт индивидуальных модулей пакета может быть таким:

>>> import TCP.Server.lib
>>> import TCP.Client.lib

Ссылка на функцию должна быть полной:

>>> import TCP.Server.lib.connect()

Можно сделать альтернативную загрузку:

>>> from TCP.Server import lib as server_lib 
>>> from TCP.Client import lib as client_lib 
>>> server_lib.connect()
>>> client_lib.connect()

Здесь вместо lib может быть подставлен модуль, подпакет или имя, определенное в TCP.Server — т.е. это может быть функция, класс или переменная.

Что касается варианта с импортом:

>>> from TCP import *

то в корневом __init__.py может быть определен список __all__ , в котором перечисляются модули, которые импортируются в этом случае. Например:

    __all__ = 

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