Python целая часть: Интерактивный учебник языка Python

Интерактивный учебник языка Python

1. Целочисленная арифметика

Для целых чисел определены операции
+, -, * и **. Операция
деления / для целых чисел возвращает вещественное число (значение типа float).
Также функция возведения в степень возвращает значение типа float,
если показатель степени — отрицательное число.

Но есть и специальная операция целочисленного деления, выполняющегося с отбрасыванием
дробной части, которая обозначается // (она соответствует операции div в Паскале).
Она возвращает целое число: целую часть частного. Другая близкая ей операция − это операция взятия остатка от деления,
обозначаемая % (она соответствует операции mod в Паскале).
Например:

	
print(17 / 3)   # выведет 5.66666666667
print(17 // 3)  # выведет 5
print(17 % 3)   # выведет 2
2. Действительные числа
 
В этом разделе речь пойдет о действительных числах, имеющих тип float.
Обратите внимание, что если вы хотите считать с клавиатуры действительное
 число, то результат, возращаемый функцией input() необходимо
 преобразовывать к типу float:
1.492
x = float(input())
print(x)
Действительные (вещественные) числа представляются в виде чисел с десятичной точкой (а не запятой, как принято
 при записи десятичных дробей в русских текстах). Для записи очень больших или очень маленьких
 по модулю чисел используется так называемая запись «с плавающей точкой»
 (также называемая «научная» запись). В этом случае число представляется в виде
 некоторой десятичной дроби, называемой мантиссой, умноженной на целочисленную степень десяти
 (порядок). Например, расстояние от Земли
 до Солнца равно 1.496·1011, а масса молекулы воды 2.99·10-23.
Числа с плавающей точкой в программах на языке Питон, а также при вводе и выводе записываются так:
 сначала пишется мантисса, затем пишется буква e, затем пишется порядок. Пробелы внутри этой
 записи не ставятся. Например, указанные выше константы можно записать в виде
 1.496e11 и 2.99e-23. Перед самим числом также может стоять знак минус.
Напомним, что результатом операции деления / всегда является действительное число (float),
 в то время как результатом операции // является целое число (int).
Преобразование действительных чисел к целому производится с округлением
 в сторону нуля, то есть int(1.7) == 1, int(-1.7) == -1.
3. Библиотека math
 
Для проведения вычислений с действительными числами язык Питон содержит много
 дополнительных функций, собранных в библиотеку (модуль), которая называется math.
Для использования этих функций в начале программы необходимо подключить математическую
 библиотеку, что делается командой
import math
Например, пусть мы хотим округлять вещественные числа до ближайшего целого числа вверх.
 Соответствующая функция ceil от одного аргумента вызывается, например, так: math.ceil(x)
 (то есть явно указывается, что из модуля math используется функция ceil).
 Вместо числа x может быть любое число, переменная или выражение.
 Функция возращает значение, которое можно вывести на экран, присвоить
 другой переменной или использовать в выражении:
	
import math

x = math.ceil(4.2)
y = math.ceil(4.8)
print(x)
print(y)
Другой способ использовать функции из библиотеки math, при котором не нужно будет
 при каждом использовании функции из модуля math указывать название
 этого модуля, выглядит так:
	
from math import ceil
 
x = 7 / 2
y = ceil(x)
print(y)
или так:
	
from math import *
 
x = 7 / 2
y = ceil(x)
print(y)
Ниже приведен список основных функций модуля math. Более подробное описание
 этих функций можно найти на сайте с документацией языка Питон.
Некоторые из перечисленных функций (int, round, abs)
 являются стандартными и не требуют подключения модуля math для использования.
Функция
Описание
Округление
int(x)
Округляет число в сторону нуля. Это стандартная функция, для ее использования не нужно подключать
 модуль math.
round(x)
Округляет число до ближайшего целого. Если дробная часть числа равна 0.5, то число округл
Как выполнять математические действия с помощью операторов Python 3
В этом руководстве мы будем работать с двумя типами данных в Python – целыми числами (integer) и числами с плавающей точкой (floats):
Целые – числа без дробной части, которые могут быть положительными, отрицательными или нулём (…, -1, 0, 1, …).
С плавающей точкой – это числа, содержащие десятичную точку (например, 9.0 или -2.25).
В этой статье будут описаны операции с числовыми типами данных в Python.
Оператор – это символ, которая обозначает операцию. Например, в математике знак плюса или + – это оператор сложения.
Мы рассмотрим схожие операторы, которые перешли в Python из математики. Но другие операторы специфичны именно для программирования.
Ниже представлена таблица с кратким обзором математических операторов, доступных в Python.
Операция
Возвращаемое значение
x + y
Сумма x и y.
x — y
Разность x и y.
-x
Изменение знака x.
+x
Тождественность x.
x * y
Произведение x и y.
x / y
Частное от деления x на y.
x // y
Частное от целочисленного деления x на y.
x % y
Остаток от деления x / y.
x ** y
x в степени y.
В Python операторы суммы и разности выполняют те же операции, что и в математике. Поэтому вы можете использовать этот язык программирования как калькулятор.
Рассмотрим некоторые примеры. Начнём с целых чисел:
Вывод
Вместо передачи целых чисел напрямую в функцию print мы можем инициализировать переменные для этих значений:
a = 88
b = 103
print(a + b)
Вывод
Целые числа могут быть как положительными, так и отрицательными. Поэтому можно добавлять отрицательные числа к положительным:
c = -36
d = 25
print(c + d)
Вывод
Прибавление работает аналогично и с числами с плавающей запятой:
e = 5.5
f = 2.5
print(e + f)
Вывод
Синтаксис разности тот же, что и для прибавления, за исключением того, что вместо оператора сложения (+) необходимо использовать оператор вычитания (-):
g = 75.67
h = 32
print(g - h)
Вывод
В этом примере мы вычитаем целое число из числа с плавающей точкой. Python возвратит число с плавающей точкой, если хотя бы одно из чисел выражения является числом с плавающей точкой.
Унарное математическое выражение состоит из одного элемента. В Python знаки плюса и минуса могут быть использованы как единичный оператор, чтобы вернуть тождественное значение (+) или сменить знак числа (-).
Знак плюса означает тождественное значение. Мы можем использовать его с положительными значениями:
Вывод
 
Когда мы используем знак плюса с отрицательным значением, он также вернёт значение тождественное данному. В этом случае он вернёт отрицательное значение:
Основные типы данных в python. Рассмотрим int, float, string, boolean
Из этого руководства вы узнаете о базовых встроенных типах данных Python: числовых, строковых и логических (булевых).
Целые числа
В Python 3 фактически нет предела длины целочисленного значения. Конечно, оно ограничено объемом доступной в системе памяти (как и любые другие типы данных), но в остальном — может быть таким длинным, как нужно:
>>> print(123123123123123123123123123123123123123123123123 + 1)
123123123123123123123123123123123123123123123124
Python интерпретирует последовательность десятичных цифр без префикса как десятичное число:
>>> print(10)
10
Следующие строки могут быть добавлены к значению числа, чтобы обозначить основание отличное от 10:
Префикс
Интерпретация
Основание
0b (ноль + «b» в нижнем регистре)
0B (ноль + «b» в верхнем регистре)
Двоичное
2
0o (ноль + «o» в нижнем регистре)
0O (ноль + «O» в верхнем регистре)
Восьмеричное
8
0x (ноль + «x» в нижнем регистре)
0X (ноль + «X» в верхнем регистре)
Шестнадцатеричное
16
Например:
>>> print(0o10)
8

>>> print(0x10)
16

>>> print(0b10)
2
Чтобы больше узнать о значениях целых чисел с основанием не равным 10, обратитесь к следующим статьям в Википедии: двоичная, восьмеричная, шестнадцатеричная.
Базовый тип целого числа в Python, вне зависимости от используемого основания, называется int:
>>> type(10)
<class 'int'>
>>> type(0o10)
<class 'int'>
>>> type(0x10)
<class 'int'>
Примечание: отличный момент, чтобы напомнить, что функцию print() не нужно использовать при работе в командной строке. Просто вводите значения после >>> и нажимайте Enter для отображения:
>>> 10
10
>>> 0x10
16
>>> 0b10
2
Многие примеры будут использовать эту особенность интерпретатора.
Но это не работает с файлами скриптов. Значение в строке файла со скриптом не делает ничего само по себе.
Числа с плавающей точкой
Тип float в Python означает число с плавающей точкой. Значения float определяются с десятичной точкой. По желанию можно добавить символ e или E после целого числа, чтобы обозначить, что это экспоненциальная запись.
>>> 4.2
4.2
>>> type(4.2)
<class 'float'>
>>> 4.
4.0
>>> .2
0.2

>>> .4e7
4000000.0
>>> type(.4e7)
<class 'float'>
>>> 4.2e-4
0.00042
Подробнее: представление float
Подписывайтесь на телеграм каналы
Далее следует более подробная информация о том, как Python изнутри представляет числа с плавающей точкой. Вы без проблем можете пользоваться этим типом данных, не понимая этот уровень, так что не волнуйтесь, если описанное здесь покажется чересчур сложным. Информация представлена для особо любопытных.
Почти все платформы представляют числа с плавающей точкой Python как 64-битные значения двойной точности в соответствии со стандартом IEEE 754. В таком случае максимальное значение числа с плавающей точкой — это приблизительно 1.8 х 10308. Числа больше Python будет помечать в виде строки inf:
>>> 1.79e308
1.79e+308
>>> 1.8e308
inf
Ближайшее к нулю ненулевое значение — это приблизительно 5.0*10**-342. Все что ближе — это уже фактически ноль:
>>> 5e-324
5e-324
>>> 1e-325
0.0
Числа с плавающей точкой представлены в виде двоичных (с основанием 2) фракций. Большая часть десятичных фракций не может быть представлена в виде двоичных, поэтому в большинстве случаев внутреннее представление — это приближенное к реальному значение. На практике отличия представленного и реального значения настолько малы, что это не должно создавать проблем.
Дальнейшее чтение: для получения дополнительной информации о числах с плавающей точкой в Python и возможных проблемах, связанных с этим типом данных, читайте официальную документацию Python.
Комплексные числа
Сложные числа определяются следующим образом: <вещественное число>+<мнимая часть>j. Например:
>>> 2+3j
(2+3j)
>>> type(2+3j)
<class 'complex'>
Строки
Строки — это последовательности символов. Строковый тип данных в Python называется str.
Строковые литералы могут выделяться одинарными или двойными кавычками. Все символы между открывающей и закрывающей кавычкой являются частью строки:
>>> print("Я строка.")
Я строка.
>>> type("Я строка.")
<class 'str'>

>>> print('Я тоже.')
Я тоже.
>>> type('Я тоже.')
<class 'str'>
Строка может включать сколько угодно символов. Единственное ограничение — ресурсы памяти устройства. Строка может быть и пустой.
А что, если нужно использовать символ кавычки в строке? Первой идеей может быть нечто подобное:
>>> ''
''
Но, как видите, такой подход не работает. Строка в этом примере открывается одинарной кавычкой, поэтому Python предполагает, что следующая закрывает ее, хотя она задумывалась как часть строки. Закрывающая кавычка в конце вносит неразбериху и приводит к синтаксической ошибке.
Если нужно включить кавычки одного типа в строку, то стоит выделить ее целиком кавычками другого типа. Если строка содержит одинарную кавычку, просто используйте в начале и конце двойные или наоборот:
>>> print('Эта строка содержит одну кавычку (').')
SyntaxError: invalid syntax
Как видите, это не так хорошо работает. Строка в этом примере открывается одиночной кавычкой, поэтому Python предполагает, что следующая одинарная кавычка, та, которая в скобках является закрывающим разделителем. Окончательная одинарная кавычка тогда лишняя и вызывает показанную синтаксическую ошибку.
Если вы хотите включить любой тип символа кавычки в строку, самый простой способ — разделить строку с другим типом. Если строка должна содержать одну кавычку, разделите ее двойными кавычками и наоборот:
>>> print("Эта строка содержит одну кавычку (').")
Эта строка содержит одну кавычку (').

>>> print('Эта строка содержит одну кавычку (").')
Эта строка содержит одну кавычку (").
Управляющие последовательности (исключенные последовательности)
Иногда нужно, чтобы Python по-другому интерпретирован символ или последовательность нескольких символов в строке. Этого можно добиться двумя способами:
Можно «подавить» специальное значение конкретных символов в этой строке;
Можно создать специальную интерпретацию для символов в строке, которые обычно воспринимаются буквально;
Для этого используется обратный слэш (\). Обратный слэш в строке указывает, что один или несколько последующих символов нужно интерпретировать особым образом. (Это называется исключенной последовательностью, потому что обратный слэш заставляет последовательность символов «исключаться» из своего привычного значения).
Посмотрим, как это работает.
Подавление значения специальных символов
Вы видели, к каким проблемам приводит использовать кавычек в строке. Если она определена одиночными кавычками, просто так взять и использовать такую же кавычку как часть текста, нельзя, потому что она имеет особенное значение — завершает строку:
>>> print('Эта строка содержит одну кавычку (').')
SyntaxError: invalid syntax
Обратный слэш перед одинарной кавычкой «освобождает» ее от специального значения и заставляет Python воспринимать буквальное значение:
>>> print('Эта строка содержит символ одинарной кавычки (\').')
Эта строка содержит символ одинарной кавычки (').
То же работает и со строками, определенными двойными кавычками:
>>> print("Эта строка содержит символ одинарной кавычки (\").")
Эта строка содержит символ одинарной кавычки (").
Следующая таблица управляющих последовательностей описывает символы, которые заставляют Python воспринимать отдельные символы буквально:
Управляющий символ
Стандартная интерпретация
Исключенная интерпретация
\’
Завершает строку, открытую одинарной кавычкой
Символ одинарной кавычки
\»
Завершает строку, открытую двойными кавычками
Символ двойных кавычек
\newline
Завершает строку ввода
Новая строка игнорируется
\\
Показывает исключенную последовательность
Символ обратного слэша
Обычно символ новой строки (newline) заменяет enter. Поэтому он в середине строки заставит Python думать, что она неполная:
>>> print('a

SyntaxError: EOL while scanning string literal
Чтобы разбить строку на несколько строк кода, добавьте обратный слэш перед переходом на новую строку и newline будет игнорироваться:
>>> print('a\
... b\
... c')
abc
Для включения буквального значения обратного слэша, исключите его с помощью еще одного:
>>> print('foo\\bar')
foo\bar
Добавление специального значения символам
Предположим, что необходимо создать строку, которая будет содержать символ табуляции. Некоторые текстовые редакторы вставляют его прямо в код. Но многие программисты считают, что это не правильный подход по нескольким причинам:
Компьютер видит разницу между символом табуляции и последовательностью пробелов, но программист — нет. Человек, читающий код, не способен отличить пробелы от символа табуляции.
Некоторые текстовые редакторы настроены так, чтобы автоматически удалять символы табуляции и заменять их на соответствующее количество пробелов.
Некоторые REPL-среды Python не будут вставлять символы табуляции в код.
В Python (и большинстве других распространенных языков) символ табуляции определяется управляющей последовательностью \t:
>>> print('foo\tbar')
foo     bar
Она заставляет символ \t терять свое привычное значение и интерпретируется как символ табуляции.
Вот список экранированных последовательностей, которые заставляют Python использовать специальное значение вместе буквальной интерпретации:
Управляющая последовательность
«Исключенная» интерпретация
\a
ASCII: символ Bell (BEL)
\b
ASCII: символ возврата на одну позицию (BS)
\f
ASCII: символ разрыва страница (FF)
\n
ASCII: символ перевода строки (LF)
\N{<name>}
Символ из базы Unicode с именем <name>
\r
ASCII: символ возврата каретки (CR)
\t
ASCII: символ горизонтальной табуляции (TAB)
\uxxxx
Символ Unicode с 16-битным шестнадцатеричным значением
\Uxxxxxxxx
Символ Unicode с 32-битным шестнадцатеричным значением
\v
ASCII: символ вертикальной табуляции (VT)
\ooo
Символ с восьмеричным значением ooo
\xhh
Символ с шестнадцатеричными значением hh
Примеры:
>>> print("a\tb")
a    b
>>> print("a\141\x61")
aaa
>>> print("a\nb")
a
b
>>> print('\u2192 \N{rightwards arrow}')
→ →
Такой тип исключенной последовательности обычно используется для вставки символов, которые не легко ввести с клавиатуры или вывести.
«Сырые» строки
Литералу «сырой» строки предшествует r или R, которая подавляет экранирование, так что обратный слэш выводится как есть:
>>> print('foo\nbar')
foo
bar
>>> print(r'foo\nbar')
foo\nbar

>>> print('foo\\bar')
foo\bar
>>> print(R'foo\\bar')
foo\\bar
Строки в тройных кавычка
Есть и другой способ объявления строк в Python. Строки в тройных кавычках определяют группами из трех одинарных или двойных кавычек. Исключенные последовательности в них все еще работают, но одинарные и двойные кавычки, а также новые строки могут использоваться без управляющих символов. Это удобный способ создавать строки, включающие символы одинарных и двойных кавычек:
>>> print('''Эта строка содержит одинарные (') и двойные (") кавычки.''')
Эта строка содержит одинарные (') и двойные (") кавычки.
Таким же образом удобно создавать строки, разбитые на несколько строк кода:
>>> print("""Это cтрока, 
которая растянута
на несколько строк""")
Это cтрока, 
которая растянута
на несколько строк
Наконец, этот способ используется для создания комментариев кода Python.
Булев тип, Булев контекст и «истинность»
В Python 3 три типа Булевых данных. Объекты булевого типа принимают одно из двух значений, True или False:
>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>
Многие выражения в Python оцениваются в булевом контексте. Это значит, что они интерпретируются как истинные или ложные.
«Истинность» объекта типа Boolean самоочевидна: объекты равные True являются истинными, а те, что равны False — ложными. Но не-Булевы объекты также могут быть оценены в Булевом контексте.
Функции и методы модуля math в python ~ PythonRu
Эта статья посвящена математическим функциям в Python. Для выполнения математических операций необходим модуль math.
Что такое модуль?
В C и C++ есть заголовочные файлы, в которых хранятся функции, переменные классов и так далее. При включении заголовочных файлов в код появляется возможность не писать лишние строки и не использовать одинаковые функции по несколько раз. Аналогично в Python для этого есть модули, которые включают функции, классы, переменные и скомпилированный код. Модуль содержит группу связанных функций, классов и переменных.
Есть три типа модулей в Python:
Модули, написанные на Python (.py).
Модули, написанные на C и загружаемые динамически (.dll, .pyd, .so, .sl и так далее).
Модули, написанные на C, но связанные с интерпретатором.
import sys
print(sys.builtin_module_names)
('_ast', '_bisect', '_codecs', '_codecs_cn', '_codecs_hk', '_codecs_iso2022', 
'_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', '_csv', '_datetime', 
'_functools', '_heapq', '_imp', '_io', '_json', '_locale', '_lsprof', '_md5', 
'_multibytecodec', '_opcode', '_operator', '_pickle', '_random', '_sha1', 
'_sha256', '_sha512', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', 
'_tracemalloc', '_warnings', '_weakref', '_winapi', 'array', 'atexit', 'audioop', 
'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 
'math', 'mmap', 'msvcrt', 'nt', 'parser', 'signal', 'sys', 'time', 'winreg', 
'xxsubtype', 'zipimport', 'zlib').
Для получения списка модулей, написанных на C, но связанных с Python, можно использовать следующий код.
Как видно из списка выше, модуль math написан на C, но связан с интерпретатором. Он содержит математические функции и переменные, о которых дальше и пойдет речь.
Функции представления чисел
ceil() и floor() — целая часть числа
Сeil() и floor() — функции общего назначения. Функция ceil округляет число до ближайшего целого в большую сторону. Функция floor убирает цифры десятичных знаков. Обе принимают десятичное число в качестве аргумента и возвращают целое число.
Пример:

import math


number=8.10


print("Верхний предел 8.10 это:",math.ceil(number))


print("Нижний предел 8.10 это:",math.floor(number))
Вывод:
Верхний предел 8.10 это: 9
Нижний предел 8.10 это: 8
Функция fabs() — абсолютное значение
Подписывайтесь на телеграм каналы
Функция fabs используется для вычисления абсолютного значения числа. Если число содержит любой отрицательный знак (-), то функция убирает его и возвращает положительное дробное число.
Пример:

import math

number = -8.10

print(math.fabs(number))
Вывод:
8.1
factorial() — функция факториала
Эта функция принимает положительное целое число и выводит его факториал.
Пример:

import math    

number = 5

print("факториала числа", math.factorial(number))
Вывод:
факториала числа 120
Примечание: при попытке использовать отрицательное число, возвращается ошибка значения (Value Error).
Пример:

import math    

number = -5

print("факториала числа", math.factorial(number))
Вывод:
ValueError: factorial() not defined for negative values
Функция fmod() — остаток от деления
Функция fmod(x,y) возвращает x % y. Разница в том, что выражение x % y работает только с целыми числами, а эту функцию можно использовать и для чисел с плавающей точкой.
Пример:

import math  

print(math.fmod(5,2))  
print(math.fmod(-5,2))  
print(math.fmod(-5.2,2))  
print(math.fmod(5.2,2))  
Вывод:
1.0
-1.0
-1.2000000000000002
1.2000000000000002
Функция frexp()
Эта функция возвращает мантиссу и показатель степени в виде пары (m,n) любого числа x, решая следующее уравнение.
Пример:

import math  

print(math.frexp(24.8))
Вывод:
(0.775, 5)
Функция fsum() — точная сумма float
Вычисляет точную сумму значений с плавающей точкой в итерируемом объекте и сумму списка или диапазона данных.
Пример:

import math   
    

numbers=[.1,.2,.3,.4,.5,.6,.7,.8,8.9]    
print("сумма ", numbers, ":", math.fsum(numbers))    
    

print("сумма чисел от 1 до 10:", math.fsum(range(1,11)))   
Вывод:
сумма [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 8.9] : 12.5
сумма чисел от 1 до 10: 55.0
Функции возведения в степень и логарифма
Функция exp()
Эта функция принимает один параметр в виде дробного числа и возвращает e^x.
Пример:

import math   
    
print("e в степени 5 ", math.exp(5))
print("e в степени 2.5", math.exp(2.5))  
Вывод:
e в степени 5  148.4131591025766
e в степени 2.5 12.182493960703473
Функция expm1()
Эта функция работает так же, как и exp, но возвращает exp(x)-1. Здесь, expm1 значит exm-m-1, то есть, exp-minus-1.
Пример:

import math   
    
print(math.exp(5)-1)
print(math.expm1(5))
Вывод:
147.4131591025766
147.4131591025766
Функция log() — логарифм числа
Функция log(x[,base]) находит логарифм числа x по основанию e (по умолчанию). base— параметр опциональный. Если нужно вычислить логарифм с определенным основанием, его нужно указать.
Пример:

import math  
	  

print(math.log(2))  
	  

print(math.log(64,2)) 
Вывод:
0.6931471805599453
6.0
Функция log1p()
Эта функция похожа на функцию логарифма, но добавляет 1 к x. log1p значит log-1-p, то есть, log-1-plus.
Пример:

import math  
	  
print(math.log1p(2))
Вывод:
1.0986122886681098
Функция log10()
Вычисляет логарифм по основанию 10.
Пример:

import math  

print(math.log10(1000))
Вывод:
3.0
Функция pow() — степень числа
Используется для нахождение степени числа. Синтаксис функции pow(Base, Power). Она принимает два аргумента: основание и степень.
Пример:

import math  

print(math.pow(5,4))
Вывод:
625.0
Функция sqrt() — квадратный корень числа
Эта функция используется для нахождения квадратного корня числа. Она принимает число в качестве аргумента и находит его квадратный корень.
Пример:

import math  

print(math.sqrt(256))
Вывод:
16.0
Тригонометрические функции
В Python есть следующие тригонометрические функции.
Функция
Значение
sin
принимает радиан и возвращает его синус
cos
принимает радиан и возвращает его косинус
tan
принимает радиан и возвращает его тангенс
asin
принимает один параметр и возвращает арксинус (обратный синус)
acos
принимает один параметр и возвращает арккосинус (обратный косинус)
atan
принимает один параметр и возвращает арктангенс (обратный тангенс)
sinh
принимает один параметр и возвращает гиперболический синус
cosh
принимает один параметр и возвращает гиперболический косинус
tanh
принимает один параметр и возвращает гиперболический тангенс
asinh
принимает один параметр и возвращает обратный гиперболический синус
acosh
принимает один параметр и возвращает обратный гиперболический косинус
atanh
принимает один параметр и возвращает обратный гиперболический тангенс
Пример:

import math  
  

print("синус PI/2 :", math.sin(math.pi/2))  

print("косинус 0 :", math.cos(0))  

print("тангенс PI/4 :", math.tan(math.pi/4))  
  
print()  
  

print("арксинус 0 :", math.acos(0))  

print("арккосинус 1 :", math.acos(1))  

print("арктангенс 0.5 :", math.atan(0.5))  
  
print()  
  

print("гиперболический синус 1 :", math.sinh(1))  

print("гиперболический косинус 0 :", math.cos(0))  

print("гиперболический тангенс 1 :", math.tan(1))  
  
print()  
  

print("обратный гиперболический синус 1 :", math.acosh(1))  

print("обратный гиперболический косинус 1 :", math.acosh(1))  

print("обратный гиперболический тангенс 0.5 :", math.atanh(0.5))  
Вывод:
синус PI/2 : 1.0
косинус 0 : 1.0
тангенс PI/4 : 0.9999999999999999

арксинус 0 : 1.5707963267948966
арккосинус 1 : 0.0
арктангенс 0.5 : 0.4636476090008061

гиперболический синус 1 : 1.1752011936438014
гиперболический косинус 0 : 1.0
гиперболический тангенс 1 : 1.5574077246549023

обратный гиперболический синус 1 : 0.0
обратный гиперболический косинус 1 : 0.0
обратный гиперболический тангенс 0.5 : 0.5493061443340549
Функция преобразования углов
Эти функции преобразуют угол. В математике углы можно записывать двумя способами: угол и радиан. Есть две функции в Python, которые конвертируют градусы в радиан и обратно.
degrees(): конвертирует радиан в градусы;
radians(): конвертирует градус в радианы;
Пример:

import math  

print(math.degrees(1.57))
print(math.radians(90))
Вывод:
89.95437383553924
1.5707963267948966
Математические константы
В Python есть две математические константы: pi и e.
pi: это математическая константа со значением 3.1416..
e: это математическая константа со значением 2.7183..
Пример:

import math  


print("значение PI", math.pi)


print("значение e", math.e)
Вывод:
значение PI 3.141592653589793
значение e 2.718281828459045
Числа | Python
 Числа в языке Python представлены тремя встроенными типами: целые (int), вещественные (float) и комплексные (comlex), а так же двумя типами чисел, которые предоставляет его стандартная библиотека: десятичные дроби неограниченной точности (Decimal) и обыкновенные дроби (Float).
 Числовой тип данных устроен очень просто и интуитивно понятно. Однако, если чисел в вашей работе очень много, то узнать о них будет, по крайней мере, не лишним.
 Начнем с того, что числовые литералы не содержат знаки «+» и «-«, т.е. с точки зрения Python число \(-3.14\) не является единым отрицательным числом, а является командой, которая состоит из унарного оператора (-) и числа \(3.14\). Это говорит о том, что знаки «+» и «-» хоть и способны обозначать положительные и отрицательные числа, но на самом деле эти знаки являются операторами:
>>> -+-+--++1
1
 Помимо этого, числа встроенных типов (int, float и complex) относятся к немутирующим (неизменяемым) объектам, т.е. объектам чья структура не может быть изменена напрямую. Нельзя изменить какую-нибудь цифру существующего числа, нельзя расставить его цифры в обратном порядке. То что кажется изменением числа, на самом деле таковым не является. Например:
>>> x = 1
>>> x = x - 1
>>> x
0
 Вроде бы мы создали объект-число со значением \(1\), а затем изменили его значение на \(0\). Но если это так, то id объекта (его адрес в памяти) не должен меняться, а он меняется:
>>> x = 1
>>> id(x)
7916480
>>> 
>>> x = x - 1
>>> x
0
>>> 
>>> id(x)
7916464
 Как видим, изменения объекта не произошло, старый объект исчез и появился новый. Эту информацию трудно назвать «очень полезной», но она нужна для понимания «внутренней кухни» языка. Например того, что все в этом языке, включая числа, является объектом. Или того, что числа, действительно хранятся в памяти компьютера, и живут в этой памяти по каким-то своим правилам. Но вся эта внутренняя кухня является заботой самого Python. В основном, мы пишем код, даже не задумываясь о ее существовании, лишь иногда, очень редко вмешиваясь в ее работу.
 Ну и последнее, что я могу сказать о встроенных числовых типах, так это то, что результат всегда преобразуется к более общему типу если это необходимо. Например, если частное двух целых чисел (int) не является целым числом, то оно будет преобразовано к вещественному типу (float):
>>> 1/25
0.04
 А если результат не может быть выражен типами int и float, то он будет преобразован к типу complex. Так что если вдруг будете вычислять корни четной степени из отрицательных чисел, не ждите ошибки:
>>> (-3)**0.5
(1.0605752387249068e-16+1.7320508075688772j)
>>> 
>>> (-3.14)**0.5
(1.0850398284807605e-16+1.772004514666935j)
 Причем такое преобразование работает только в одну сторону int -> float -> complex:
>>> 0.25*8    #  результатом будет все равно "float"
2.0
>>> 
>>> 1 + 1j - 1j    # все равно "complex"
(1+0j)
 Еще мы могли бы рассмотреть как устроено хеширование чисел, или как устроены их классы. Но такие тонкости настолько редко требуются на практике, что я о них ни разу не слышал (что и не мудрено, я ведь сельский учитель 😇). А к тому моменту, когда вам вдруг это потребуется вы и сами без труда сможете со всем разобраться. Давайте рассмотрим каждый тип чисел в отдельности.
 Целые числа (int)
 
 В самом общем смысле, целые числа — это самые обыкновенные целые числа со знаком или без, например: \(-11, 126, 0\) или \(401734511064747568885490523085290650630550748445698208825344\). Последнее число в примере может показаться несовсем правдоподобным, но это \(2^{198}\), в чем очень легко убедиться:
>>> 2**198
401734511064747568885490523085290650630550748445698208825344
 Да, длинная арифметика, нам доступна, что называется «из коробки». А это, надо сказать, очень приятный бонус, например, вы можете легко убедиться в том что \(561\) — число Кармайкла, действительно проходит тест Ферма:
>>> 2**(561-1)%561 == 1
True
 Однако, если вы попытаетесь проверить это для числа \(9746347772161\), то результата придется ждать очень долго (если вообще дождемся), вероятнее всего компьютер «встанет колом» и его придется перезагружать. Но вот если воспользоваться встроенной функцией pow(), то результат будет получен моментально:
>>> pow(2, 9746347772160, 9746347772161) == 1
True
 Все дело в том, что данная функция для трех аргументов реализована, как алгоритм быстрого возведения в степень по модулю, что на порядки быстрее чем эквивалентная команда:
2 ** 9746347772160 % 9746347772161
 Поддержка длинной арифметики может показаться излишней, но на самом деле, есть целая куча подразделов математики (например, комбинаторика, теория графов, теория чисел, криптография и т.д.) где ее наличие «под рукой» может сильно облегчить вычисления и даже способствовать вашему самообразованию. Чем, по вашему, изучение отличается от заучивания? Верно, тем что вы сами все проверяете и подвергаете критике.
 Вещественные числа (float)
 
 Наверное, было бы правильнее называть эти числа числами с плавающей точкой нежели вещественными, но в принципе, с определенной натяжкой, можно сказать, что это, как бы одно и тоже. Давайте разберемся почему.
 В качестве примера возьмем число \(\sqrt{2}\), которое является вещественным потому что мы никогда не сможем выразить его с помощью обыкновенной дроби. А если мы все-таки извлечем корень из двойки, то обнаружим, что это бесконечная десятичная дробь. Но вычислив этот корень на Python:
>>> 2**(1/2)    #  равносильно 2**0.5
1.4142135623730951
 мы увидим, что никакой бесконечной дробью и не пахнет. Python вернул только начало этой дроби, а все остальное отбросил, т.е. он вернул число с плавающей точкой, которое как бы и соответствует вещественному числу, но с определенной погрешностью.
 На самом деле, работая с числами с плавающей точкой, мы очень часто подразумеваем числа вещественные, например вот такое число \(\sqrt[77]{7}\), его мы увидим в виде конечной десятичной дроби:
>>> 7**(1/77)
1.0255935932948266
 А число \(7^{-77}\) в виде мантисы \(8.461569363277291\) (опять же конечной десятичной дроби) и порядка \(-66\):
>>> 7**(-77)
8.461569363277291e-66
 Кстати, можно было бы подумать, что 8.461569363277291*10**(-66) вернет результат идентичный предыдущему, но:
>>> 8.461569363277291*10**(-66)
8.461569363277292e-66
 Отличие настолько незначительное, что для нас оно становится абсолютно неважным. Возможно, поэтому числа типа float в Python все чаще называют вещественными, а не числами с плавающей точкой. Возможно, потому что так короче, хотя и не так как кажется:
>>> F = len('число с плавающей точкой')
>>> R = len('вещественное число')
>>> F - R
6
 А может, потому что в нашей стране все меньше инженеров и прочих физиков-ядерщиков, для которых «какие-то» погрешности принципиально важны. Незнаю…
 В общем важно то, что тип float это тип чисел с погрешностью, чисел с ограниченной точностью. И этой точности нам более чем достаточно. Но существуют исключения из правил – ситуации, в которых и пятый и даже миллионный знак после запятой может оказаться очень важен. А бывают даже такие ситуации, когда мы вообще не можем пользоваться десятичными дробями (вещественными числами).
 Комплексные числа (complex)
 
 Единственная область где могут пригодиться комплексные числа – это наука, как теоретическая, так и прикладная. Причем, если понаблюдать за теоретиками, то можно заметить, что они, вполне себе, обходятся бумагой и ручкой, а вот прикладники часто, очень часто что-то считают на компьютерах. Причем, комплексные числа нет-нет да появятся, то тут то там. В принципе, раз это надо только ученым, то пусть сами и выкручиваются  – они же умные. «Хм… ну так-то я и есть ученый и как бы даже математик» подумал (наверное) создатель языка Гвидо Ван Россум и добавил в Python комплексные числа.
 Комплексное число \(z\) – это число вида \(a+bi\), где \(a\) – действительная часть, \(b\) – мнимая часть, а \(i\) – мнимая единица. В Python комплексное число представляется в схожем виде a ± bj, где a и b могут быть любыми числами типа int и float, а j обозначает мнимую единицу, например:
>>> 3 - 7j
(3-7j)
 Раз поддерживаются комплексные числа, следовательно, поддерживаются и математические операции над комплексными числами, так что если вам вдруг понадобится вычислить, значение какой нибудь комлексной функции, например такой:
 $$f(z) = \frac{z}{1+z^{2}}+\frac{z^{2}}{1-z^{3}}$$
 при \(z=1+1j\), то знайте – в этом нет ничего сложного:
>>> z = 1 + 1j
>>> 
>>> z/(1 + z**2) + z**2/(1 - z**3)
(0.29230769230769227+0.26153846153846155j)
 Десятичные дроби (Decimal)
 
 Числа данного типа позволяют производить вычисления над десятичными дробями с заданной точностью. Возможно, вы сразу задались вопросом: «А разве типом float мы обойтись не можем? Ведь это как бы и десятичные дроби, а погрешности при вычислениях с ними, настолько ничтожны, что мы можем вообще не обращать на них внимания.» Чтож, вполне обоснованное замечание, но давайте посмотрим вот на такой пример:
>>> 0.11+0.29
0.39999999999999997
 Должно получиться ровно \(0.4\) а получилось \(0.39999999999999997\). Конечно, как вы сказали: на такую погрешность можно вообще не обращать внимания, но как минимум, такой результат сложения кажется странным сам по себе. Ну в самом деле, разве это так трудно правильно сложить? Дело в том, что компьютер использует двоичную арифметику, над числами в двоичном представлении, а конечная десятичная дробь, в двоичном представлении может оказаться бесконечной, бесконечный «хвост» которой и отбрасывается при вычислениях, что в свою очередь и приводит к таким «ничтожным» погрешностям.
 Но, как говорится «Дьявол кроется в мелочах» Очень неприятным последствием таких «ничтожно-маленьких» погрешностей является то, что вы не можете точно проверить истинность равенства:
>>> 0.7 + 0.2 - 0.9 == 0
False
 Потому что с точки зрения компьютера:
>>> 0.7 + 0.2 - 0.9
-1.1102230246251565e-16
 А в финансовой и бухгалтерской среде подобные логические проверки выполняются постоянно.
 Вторым неприятным последствием становится то, что погрешности имеют свойство накопления. Расмотрим простой пример:
>>> s = 0
>>> for i in range(100000000):
...     s += 0.1
... 
>>> s
9999999.98112945
 Мы \(100000000\) раз сложили число \(0.1\) с самим собой, но вместо \(10000000\) мы получили \(9999999.98112945\), которое отличается от правильного результата на целых \(0.018870549276471138\). В принципе не так уж и сильно, отличается. Да и пример «притянут за уши». Но что-то подобное происходит при решении дифференциальных уравнений. Если с помощью таких уравнений строится траектория космического аппарата, то из-за такой мизерной погрешности он конечно полетит в сторону нужной планеты, но пролетит мимо. А если вы рассчитываете параметры химической реакции, то  на компьютере все может выглядеть более чем безобидно, но в действительности, из-за этой мизерной погрешности вполне может произойти взрыв.
 Потребность в повышенной точности, возникает очень редко, но возникает неспроста. Именно эту потребность и призваны удовлетворить числа типа Decimal. Этот тип не является встроенным, а предоставляется модулем Decimal из стандартной библиотеки Python:
>>> from decimal import *    #  импортируем модуль
>>> getcontext().prec = 10    #  устанавливаем точность
>>> 
>>> #  Вычислим частное 13/17
... Decimal(13) / Decimal(17)
Decimal('0.7647058824')
 Причем точность может быть настолько большой, насколько позволяет мощность компьютера. Допустим, мы хотим видеть результат с точностью \(80\) знаков после запятой (хотя можем увидеть и \(1000\)), вот они:
>>> getcontext().prec = 80    #  меняем точность
>>> 
>>> #  и получаем необходимый результат:
... Decimal(13) / Decimal(17)
Decimal('0.76470588235294117647058823529411764705882352941176470588235294117647058823529412')
 Хотелось бы думать, что такая точность доступна абсолютно для всех математических операций и функций, например таких как всякие синусы, косинусы или даже Γ, Β, G, K функции и прочая экзотика. Но нет, слишком хорошо – тоже не хорошо. К тому же все эти и другие функции могут быть получены с помощью базовых математических операций, которые модулем Decimal прекрасно поддерживаются, например:
>>> Decimal(3).sqrt()    #  квадратный корень из 3
Decimal('1.7320508075688772935274463415058723669428052538103806280558069794519330169088000')
>>> 
>>> Decimal(3)**Decimal(1/7)    #  корень 7-й степени
Decimal('1.1699308127586868762703324263880195497962096309602270476311059210484631095336891')
>>> 
>>> Decimal(3).ln()    #  натуральный логарифм
Decimal('1.0986122886681096913952452369225257046474905578227494517346943336374942932186090')
 Обыкновенные дроби (Fraction)
 
 Рациональные числа, они же — обыкновенные дроби предоставляются модулем fractions. Обыкновенная дробь в данном модуле представляется в виде пары двух чисел numerator – числитель и denominator – знаменатель:
>>> from fractions import Fraction
>>> 
>>> a = Fraction(21, 49)
>>> a
Fraction(3, 7)
 Честно говоря без чисел типа Fraction можно легко обойтись, но из примера видно, что данный модуль выполнил сокращение числителя и знаменателя автоматически, что довольно любопытно и наводит на вопрос «А где бы мне это могло пригодиться?». Самый очевидный ответ – числовые ряды и пределы. Для примера рассмотрим ряд Лейбница, который сходится к \(\pi/4\) (правда медленно… ооочень медленно сходится):
 $$\sum_{n = 0}^{\infty}\frac{(-1)^{n}}{2n + 1} = 1-{\frac{1}{3}}+{\frac{1}{5}}-{\frac{1}{7}}+{\frac{1}{9}}-{\frac{1}{11}}+{\frac{1}{13}}-{\frac{1}{15}}+{\frac{1}{17}}-{\frac{1}{19}}+…$$
>>> for n in range(10):
...     print(Fraction((-1)**n, 2*n + 1), end = ', ')
... 
1, -1/3, 1/5, -1/7, 1/9, -1/11, 1/13, -1/15, 1/17, -1/19, 
 Или посмотреть на поведение вот такого предела:
 $$\pi =\lim \limits _{m\rightarrow \infty }{\frac {(m!)^{4}\,{2}^{4m}}{\left[(2m)!\right]^{2}\,m}}$$
 который тоже можно выразить с помощью чисел типа fractions:
>>> for m in range(1, 20):
...     pi = Fraction(factorial(m)**4*2**(4*m), factorial(2*m)**2*m)
...     print(pi, '=', pi.numerator / pi.denominator)
... 
4 = 4.0
32/9 = 3.5555555555555554
256/75 = 3.4133333333333336
4096/1225 = 3.3436734693877552
65536/19845 = 3.3023935500125976
524288/160083 = 3.2751010413348074
4194304/1288287 = 3.255721745232235
134217728/41409225 = 3.2412518708089806
4294967296/1329696225 = 3.2300364664117174
34359738368/10667118605 = 3.221088996975674
274877906944/85530896451 = 3.2137849402931895
4398046511104/1371086188563 = 3.2077097324665482
70368744177664/21972535073125 = 3.202577396894602
562949953421312/176021737014375 = 3.198184286610796
4503599627370496/1409850293610375 = 3.1943814515494275
288230376151711744/90324408810638025 = 3.1910574333896466
18446744073709551616/5786075364399106425 = 3.18812716944714
147573952589676412928/46326420401234675625 = 3.1855246166557545
1180591620717411303424/370882277949065911875 = 3.1831977177392785
 Мы можем проделать тоже самое, полагаясь только на встроенные типы чисел, но результат будет не так приятен глазу:
>>> for m in range(1, 20):
...     pi = factorial(m)**4*2**(4*m), factorial(2*m)**2*m
...     print(pi, '=', pi[0] / pi[1])
... 
(16, 4) = 4.0
(4096, 1152) = 3.5555555555555554
(5308416, 1555200) = 3.4133333333333336
(21743271936, 6502809600) = 3.3436734693877552
(217432719360000, 65840947200000) = 3.3023935500125976
(4508684868648960000, 1376655196815360000) = 3.2751010413348074
(173205637914018447360000, 53200381195863982080000) = 3.255721745232235
(11351204686333112966184960000, 3502105093579160420352000000) = 3.2412518708089806
(1191604063152504866738232360960000, 368913501610175548260089856000000) = 3.2300364664117174
(190656650104400778678117177753600000000, 59190121813899276854174416896000000000) = 3.221088996975674
(44662464226856508810021017591847321600000000, 13897153996490508973748644663944806400000000) = 3.2137849402931895
(14817933731329545066953533132552736971161600000000, 4619474630559975323276844025835605406515200000000) = 3.2077097324665482
(6771440084808050186516157756781419530133543321600000000, 2114372034029222038591505484325171891273728000000000000) = 3.202577396894602
(4162106276767776895443275462152240202713763203881369600000000, 1301396637520996635282929653757676937593407668224000000000000) = 3.198184286610796
(3371306084181899285309053124343314564198148195143909376000000000000, 1055386194578188235620338701709841793640482425798656000000000000000) = 3.1943814515494275
(3535070648527119224992225688911415412468637441871219917848576000000000000, 1107805397526816243090659183103353338471496211051870525849600000000000000) = 3.1910574333896466
(4724042170170136396649210908217125226636689084520418540138094657536000000000000, 1481760895688907823077375232253249480657622975913436911005125836800000000000000) = 3.18812716944714
(7934576813692483813994361028816015004662609173385847306712585996311986176000000000000, 2490822633171928298736325678650274103462162368122535524612428236062720000000000000000) = 3.1855246166557545
(16544671758995490929976945978181310262762174241357072109729454714005989607079936000000000000, 5197500509250676608714096615351420660791267607547096227240108305824465551360000000000000000) = 3.1831977177392785
Вещественные и комплексные числа в Python: системы счисления и операции
Для обработки данных, связанных с количественной информацией, а также для выполнения арифметических операций в языке программирования Python используются различные виды чисел: целые, вещественные и комплексные. Стандартная библиотека Python содержит массу полезных методов, позволяющих легко взаимодействовать с численными типами данных.
Целые числа
Самой простой и наиболее часто используемой разновидностью чисел в языке Python, как и во многих других средствах программирования является целочисленный тип данных. Для его представления используются цифровые значения, которые, как правило, присваиваются определенным переменным. Ниже обозначен пример задания целых чисел в программе, где создается целая переменная под именем i, а затем выводится на экран ее значение и тип:
i = 42 # целое число
print("i = " + str(i))
print(type(i))

i = 42
<type 'int'>
Вещественные числа
Для того чтобы записать действительное число в Python есть числа с плавающей точкой. Работая в программе с подобными величинами, можно получать более точные данные при арифметических подсчетах. Чтобы инициализировать объект, который содержит вещественное число, необходимо присвоить ему значение, где целая и дробная части разделены символом точки. В данном примере показано создание переменной f:
f = 3.14 # вещественное число
print("f = " + str(f))
print(type(f))

f = 3.14
<type 'float'>
Комплексные числа
В языке программирования Python также поддерживается работа с комплексными числами. Подобная информация представлена в виде пары значений: действительной и мнимой части, которые разделяются символом операции сложения. Также в завершении мнимой составной части комплексного числа обязательно должна стоять буква j. В следующем фрагменте кода демонстрируется создание комплексной переменной c и выводится вся информация о ней:
c = 1 + 2j # комплексное число
print("c = " + str(c))
print(type(c))

c = (1+2j)
<type 'complex'>
Можно получить действительную и мнимую часть чисел отдельно. Для этого следует использовать real и image:
c = (1+2j)
print(c.real)
print(c.imag)

1.0
2.0
Системы счисления
Помимо общепринятой десятичной системы счисления, Python поддерживает приведение цифровых данных к двоичному, восьмеричному и шестнадцатеричному представлению. Чтобы начать работать с подобными числами, необходимо инициализировать переменные при помощи констант, обладающих префиксами 0b, 0o и 0x соответственно выбранному типу. В программе ниже создаются и выводятся на экран данные в различных системах:
b = 0b110101 # число в двоичной системе
o = 0o342 # число в восьмеричной системе
x = 0x1FE9 # число в шестнадцатеричной системе
print("b = " + str(b))
print("o = " + str(o))
print("x = " + str(x))

b = 53
o = 226
x = 8169
Приведение типов
Используя стандартные средства языка Python, можно достаточно легко менять типовую принадлежность практически любой переменной. Для этого существуют методы, такие как int, float, complex, bin, oct, hex. Три последние функции позволяют перевести число либо переменную в десятичную, восьмеричную и шестнадцатеричную систему соответственно. Следующий фрагмент кода демонстрирует работу всех шести вышеописанных методов:
i = int(67.23) # вещественное число усекается до целого
f = float('1304') # строка становится вещественным числом
c = complex(2, 6) # формируется комплексное число
b = bin(42) # перевод числа в двоичную систему
o = oct(993) # перевод числа в восьмеричную систему
x = hex(4152) # перевод числа в шестнадцатеричную систему
print("i = " + str(i))
print("f = " + str(f))
print("c = " + str(c))
print("b = " + str(b))
print("o = " + str(o))
print("x = " + str(x))

i = 67
f = 1304.0
c = (2+6j)
b = 0b101010
o = 01741
x = 0x1038
Операции над числами
Манипуляции над числовыми значениями в языке программирования Python выполняются благодаря множеству различных операций, символьные обозначения которых, как правило, совпадают с аналогами из традиционной математики. Таким образом, можно прибавлять, отнимать, умножать, делить, находить остаток от деления и возводить в степень числовые значения любых разновидностей. Ознакомиться с основными типами операций, которые выполняются над цифровыми значениями, можно из следующей небольшой таблицы:
Операция
Назначение
a + b
Сложение a и b
a – b
Разница между a и b
a * b
Умножение a на b
a / b
Деление a на b
a % b
Остаток от деления a на b
a // b
Целая часть от деления a и b
a ** b
Возведение a в степень b
Помимо вышеперечисленных арифметических действий, над числами можно осуществлять битовые операции, которые задействуют их двоичное представление. Перечень подобных операций представлен в следующей таблице, где можно найти назначение каждой из них:
Операция
Назначение
a & b
Побитовое И для a и b
a | b
Побитовое ИЛИ для a и b
a ^ b
Исключающее ИЛИ для a и b
~a
Инверсия битов для a
a << b
Побитовый сдвиг влево для a на b
a >> b
Побитовый сдвиг вправо для a на b
Также для более эффективной обработки числовых данных в Python были добавлены особые методы, позволяющие всего за одно действие осуществлять множество сложных операций. К наиболее популярным из них относятся методы, предназначенные для быстрого нахождения квадратного корня, модуля, а также округления числа. Чтобы воспользоваться некоторыми арифметическими функциями, необходимо подключить стандартную библиотеку math при помощи вызова import math. Список популярных методов представлен в данной таблице:
Метод
Назначение
sqrt(a)
Квадратный корень из a
log(a)
Натуральный логарифм из a
fabs(a)
Возвращает модуль a
round(a)
Округляет a до ближайшего целого
round(a, b)
Округляет a до b знаков после точки
floor(a)
Округляет a до меньшего целого значения
ceil(a)
Округляет a до большего целого значения
isfinite(a)
Проверяет, является ли a числом
modf(a)
Возвращает целую и дробную части a
sin(a)
Синус угла a, указанного в радианах
cos(a)
Косинус угла a, указанного в радианах
tan(a)
Тангенс угла a, указанного в радианах
Функция fabs модуля math вначале пытается привести аргумент к вещественному типу (float), и только потом вычисляет модуль. Для вычисления модуля числа так же есть стандартная функция abs.
Ввод числа с клавиатуры
Для того чтобы получить числовые данные от пользователя используется стандартный метод input. Его вызов позволяет получать ввод информации с клавиатуры, который выполняется во время запуска программы на компьютере. В качестве аргумента для этого метода можно использовать строку, предлагающую пользователю ввести числовые сведения. Ниже показан пример того, как ввести в Pyhon с клавиатуры число. Переменная n получает значение и отображается на экране с помощью print:
n = input("Press n: ")
print("n = " + str(n))

Press n: 10
n = 10
Максимальное значение
Получить максимальное значение целочисленной переменной, которое поддерживается в текущей версии языка Python можно с помощью переменной sys.maxsize. Как правило, на разных компьютерах это число совпадать не будет из-за разной архитектуры процессоров. На данный момент из Python были убраны любые ограничения, касающиеся размерности вводимых величин. Вывести на экран максимальное число в Python можно следующим образом:
import sys
print(sys.maxsize)

9223372036854775807
Заключение
Для обработки числовых данных в языке программирования Python используются цифровые константы трех видов: целые, вещественные и комплексные. Стандартные математические операции над числами, как правило, выполняются при помощи набора общепринятых знаков сложения, вычитания, умножения и деления. Для выполнения специфических действий над числовыми величинами используются различные методы из стандартной библиотеки Python.
int целые числа | Python
 Системы счисления
 
 Python поддерживает десятичные, двоичные, восьмеричные и шестнадцатеричные целые числа, причем не накладывается никаких ограничений на величину (длину) числа, лишь бы хватило памяти для его хранения.
 Десятичные целые числа создаются, как обычно, с помощью десятичных цифр:
0
9
123
75384748327837257111764874480574356743982183458735233
 причем, в десятичной системе счисления ни одно число, кроме нуля не может начинаться с цифры \(0\), что в общем-то и ежу понятно, но это значит что отбрасывания незначащих нулей не происходит, а их наличие приводит к ошибке:
>>> x = 000001
  File "<stdin>", line 1
    x = 000001
             ^
SyntaxError: invalid token
 Двоичные числа состоят из префикса 0b (или 0B) и двоичных цифр: \(0\) и \(1\):
>>> 0b0, 0b1, 0b10, 0b111, 0b10001010001110111011001
(0, 1, 2, 7, 4529625)
 Восьмеричные числа начинаются с префикса 0o (0O) и могут содержать только восьмиричные цифры: \(0\), \(1\), \(2\), \(3\), \(4\), \(5\), \(6\) и \(7\):
>>> 0o0, 0o1, 0o10, 0o77, 0o12345670
(0, 1, 8, 63, 2739128)
 Шестнадцатеричные числа начинаются с префикса 0x (0X) и могут содержать как все десятичные цифры, так и символы латинского алфавита: a, b, c, d, e, f (или A, B, C, D, E, F), которые в данном случае выступают в роли цифр:
>>> 0x0, 0x1, 0x10, 0xabcdf, 0x10f0a5d34a
(0, 1, 16, 703711, 72756876106)
 В языках со строгой типизацией необходимо указывать как тип числа, так и то, что создаваемый объект сам является числом. Но в Python такой необходимости нет, интерпретатор сам, на основе анализа литералов целых чисел, способен понять что перед ним: число или нет, целое или вещественное, восьмеричное или двоичное.
 Кстати, благодаря встроенной функции int() мы можем перевести в десятичную систему счисления, любое число представленное в другой системе счисления с основанием меньшим \(37\). Интересующее число указывается в виде строки в первом аргументе, а система счисления в котором оно представлено в виде целого числа во втором аргументе:
>>> int('111', 2)
7
>>> int('111', 3)
13
>>> int('111', 8)
73
>>> int('111', 16)
273
>>> int('1az', 36)
1691
 Арифметические операции
 
 Целые числа поддерживают следующие математические операции, которые отсортированы по убыванию приоритета:
№
Операция
Результат
Замечание
1
x ** y
возводит x в степень y
(I)
2
pow(x, y[, z])
возводит x в степень y по модулю z, где z – необязательный аргумент
(I)
3
divmod(x, y)
возвращает кортеж с парой чисел (x // y, x % y)
(II)
4
x.conjugate()
возвращает \(\bar{x}\) — число, которое комплексно сопряжено с \(x\)
5
complex(re, im)
преобразует re в комплексное число (по умолчанию im = 0)
(VI)
6
float(x)
преобразует x в вещественное число (число с плавающей точкой)
(VI)
7
int(x)
переобразует x в целое число, представленное в десятичной системе счисления
(V)(VI)
8
abs(x)
абсолютное значение (модуль) числа x
9
+x
делает число x положительным
10
-x
делает число x отрицательным
11
x % y
остаток от деления x на y
(II)
12
x // y
результат целочисленного деления x на y
(III) (II)
13
x / y
результат «истинного» деления x на y
(IV)
14
x * y
произведение x и y
15
x - y
разность x и y
16
x + y
сумма x и y
 Важно: приоритет математических операций выше побитовых логических операций и операций сравнения.
 Замечания:
 I. возведение \(0\) в степень \(0\) возвращает \(1\):
>>> 0**0, pow(0, 0)
(1, 1)
 Извлечение корней четной степени из отрицательных чисел не вызывает ошибки, а возвращает комплексное число:
>>> (-1)**0.5
(6.123233995736766e-17+1j)
>>> 
>>> pow(-25, 1/4)
(1.5811388300841898+1.5811388300841895j)
 II.  функция divmod() и операция %, // не работают для комплексных чисел. Для вас это может быть и очевидно, но не пользователя для которого вы пишите программу.
 III. если оба числа типа int то и результат будет типа int. Данная операция всегда возвращает целое число, т.е. если число x можно представить в виде d*y + r, то x//y = d (r – остаток от деления). Так же следует иметь ввиду, что результат данной операции всегда округляется в сторону минус бесконечности:
>>> 1//2, (-1)//2, 1//(-2), (-1)//(-2)
(0, -1, -1, 0)
 Это немного сбивает с толку, но проверив результат по формуле x = d*y + r, вы убедитесь что все верно.
 IV. даже если оба числа типа int, то результат все равно будет преобразован к типу float.
 V. встроенная функция int() пропускает числа (объекты) типа int «как есть», не выполняя над ними, абсолютно никаких действий.
 VI. строго говоря эти функции не являются математическими, но они могут учавствовать в математических выражениях Python и поэтому должны обладать приоритетом.
 Логические побитовые операции
 
 Фактически, если число можно перевести в двоичную систему счисления, значит его можно рассматривать как двоичные данные. Учитывая, что такие данные состоят из нулей и единиц, которые интерпретируются как логические значения True и False, мы можем выполнять над ними логические операции. Логические операции выполняются по отдельным битам соответствующих разрядов. Если в операции учавствуют числа с разным количеством разрядов, то недостающие разряды дополняются нулями слева.
 Данные операции могут быть выполнены, только над целыми числами. Если в выражении или в результате операции имеются отрицательные числа, то они представляются в виде дополнительного кода. Например, мы знаем, что результатом логического оператора ~ (побитовое НЕ) примененного, скажем, к числу 0b111 должно быть число 0b000, но вместо этого мы видим число дополнительный код которого соответствует данной операции:
>>> bin(7)
'0b111'
>>> ~7
-8
>>> bin(-8)
'-0b1000'
 В таблице перечислены все побитовые операции в порядке убывания их приоритета:
№
Операция
Результат
Замечание
1
~x
инвертирование битов x
(I)
2
x >> n
сдвиг битов числа x вправо на n разрядов
(II)(III)
3
x << n
сдвиг битов числа x влево на n разрядов
(II)(IV)
4
x & y
побитовое И чисел x и y
5
x ^ y
побитовое исключающее ИЛИ чисел x и y
6
x | y
побитовое ИЛИ чисел x и y
 Важно: приоритет побитовых операций ниже математически, но выше операций сравнения.
 Замечания:
 I. унарные операции ~, + и - имеют одинаковый приоритет.
 II. отрицательное значение в выражеиях x << n и x >> n приведет к ошибке и вызовет исключение ValueError.
 III. операция x << n эквивалентна команде x*pow(2, n), но проверка переполнения в этой команде не выполняется:
>>> 7 << 3, 7*pow(2, 3)
(56, 56)
 IV. операция x >> n эквивалентна команде x // pow(2, n), но проверка переполнения в этой команде не выполняется:
>>> 63 >> 3, 63//pow(2, 3)
(7, 7)
Операции сравнения
 
 Для сравнения чисел, доступно \(8\) операций сравнения, причем все они имеют одинаковый приоритет:
№
Операция
Результат
Замечание
1
x < y
True если x меньше y, иначе False
2
x <= y
True если x меньше или равно y, иначе False
3
x > n
True если x больше y, иначе False
4
x >= n
True если x больше или равно y, иначе False
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
 Важно: приоритет операций сравнения ниже математических и побитовых операций.
 Наряду с оператором сравнения значений чисел == и !=, в Python имеются операторы is и is not, которые позволяют выяснить, являются сравниваемые значения одним и тем же объектом или нет. Например:
>>> a = 1001
>>> b = 1000 + 1
>>> 
>>> a == b
True
>>> 
>>> a is b, a is not b
(False, True)
 Не смотря на то, что значения a и b равны, в памяти компьютера они хранятся как разные объекты:
>>> id(a), id(b)
(3071801680, 3071801728)
 Однако, придумать для данного оператора сколь-нибудь полезное практическое применение, относительно математических операций я не могу.
 В Python сравнение x > y and y > z является эквивалентным x > y > z т.е. сравнения связаные оператором and в произвольные цепочки могут быть записаны в более компактной форме. Выполнение таких выражений начинается слева направо и останавливается как только будет получено первое значение False. Это означает, что если в выражении x > y > z сравнение x > y вернет False то сравнение y > z выполняться не будет.
Методы целых чисел
 
 Целые числа – это объекты, которые обладают следующими методами:
int.bit_length()¶
возвращает количество бит, которое необходимо для представления числа в памяти, без учета знака и незначащих нулей:
>>> x = 204
>>> bin(x)
'0b11001100'
>>> 
>>> x.bit_length()
8
>>> 
>>> (-0b000000000000001).bit_length()
1
int.to_bytes(length, byteorder, *, signed=False)¶
возвращает массив байтов, который соответствует данному числу:
 Параметр length задает необходимое количество байтов, а byteorder определяет в каком порядке возвращать байты: значение 'big' – от старшего к младшему, 'little' – от младшего к старшему. Оба параметра являются обязательными:
>>> (129).to_bytes(2, byteorder = 'big')
b'\x00\x81'
>>> 
>>> (129).to_bytes(5, 'big')
b'\x00\x00\x00\x00\x81'
>>> 
>>> (129).to_bytes(5, 'little')
b'\x81\x00\x00\x00\x00
 Если указанных байтов недостаточно для представления числа, то будет вызвано исключение OverflowError. А что бы узнать и (или) использовать порядок байтов который использует машина, выполняющая код используйте sys.byteorder.
 Параметр signed позволяет установить использование дополнительного кода для отрицательных целых чисел:
>>> (127).to_bytes(2, 'big', signed = True)
b'\x00\x7f'
>>> 
>>> (-127).to_bytes(2, 'big', signed = True)
b'\xff\x81'
 Если signed = False, а число является отрицательным, то будет вызвано исключение OverflowError.
classmethod int.from_bytes(bytes, byteorder, *, signed=False)¶
возвращает целое число, которое соответствует указанному массиву байтов.
 Параметры bytes и byteorder являются обязательными. bytes — должен быть байто-подобным объектом (строки байтов, массивы байтов, array.array и т.д.). Описание параметров byteorder и signed смотрите в int.to_bytes():
>>> int.from_bytes(b'\x00\x7f', byteorder = 'big')
127
>>> 
>>> int.from_bytes(b'\x00\x7f', byteorder = 'little')
32512
>>> 
>>> int.from_bytes(b'\xff\x81', 'big', signed = True)
-127
>>> 
>>> 
>>> int.from_bytes([1, 0], 'big')    #  можно указать "массив" байтов
256
>>> int.from_bytes([255, 255], 'big')
65535
 Как округлить значения Python до целых чисел?
 · Kodify 
 Когда наша программа Python работает с числовыми значениями, время от времени нам приходится преобразовывать значения с дробной составляющей в целые (целые) числа. Но как это сделать? А какие варианты есть у Python? Давайте узнаем вместе.
 # Округление числовых значений вверх и вниз в Python 
 При округлении значений мы переходим от числового значения с десятичными знаками к целому числу. При этом мы теряем некоторую точность, но округленное значение часто намного легче читать и интерпретировать.
 Python имеет три способа превратить значение с плавающей запятой в целое (целое) число:
 Встроенная функция  round ()  округляет значения вверх и вниз.
 Функция  math.floor ()  округляет  вниз  до следующего полного целого числа.
 Функция  math.ceil ()  округляет  до  до следующего полного целого числа.
 Если вам просто нужна строка или вывод скрипта с целым числом, то эту задачу может выполнить и строка формата Python.Таким образом, вы также не потеряете точность исходного значения.
 Давайте посмотрим, как работают эти три подхода.
 # Округление значений вверх и вниз: функция Python  round ()  
 Для округления значений с плавающей запятой вверх и вниз мы используем функцию Python  round ()  (Lutz, 2013; Python Docs, n.d. a). Есть два способа использовать эту функцию. Первый вариант — округлить значения до определенного числа десятичных знаков. Другой вариант превращает значение с плавающей запятой в целое число.
 Для этого мы вызываем  round ()  с одним аргументом: значение, которое нужно преобразовать в целое число. Например:
  круглый (5,4598)
# Возвращает: 5
  
 Функция  round ()  округляет значения ,5  до четного целого числа (Python Docs, n.d. a). Итак,  .5  округляется для положительных значений и в меньшую сторону для отрицательных значений.
 Например,  раунд (0,5)  и  раунд (-0,5)  возвращают  0 , а  раунд (1.5)  дает  2  и  круглые (-1,5)  дает -2 . Это поведение Python немного отличается от того, как обычно происходит округление.
 Когда мы передаем  round ()  целое число, функция просто возвращает это целое число. В этом случае ошибки нет, поэтому нам не нужно проверять, имеет ли аргумент функции дробное значение. Однако это должно быть число; строковые значения не допускаются в  round () .
 # Пример: округление чисел Python до ближайшего полного целого числа 
 Чтобы увидеть, как на практике работает функция  round () , давайте рассмотрим следующую мини-программу:
  # Некоторые числа для округления
значениеA = 3.14159265359
значениеB = 1845.7409947
значениеC = -100,95
значениеD = 9,5432
значениеE = 34,49953

# Округлить значения до целых чисел
roundA = круглый (значениеA)
roundB = круглый (значениеB)
roundC = круглый (значениеC)
roundD = круглый (значениеD)
roundE = круглый (значениеE)

# Вывод округленных значений
print ("Значение:". ljust (15), "Округленное:")

print (str (значениеA) .ljust (15), roundA)
print (str (значениеB) .ljust (15), roundB)
print (str (значениеC) .ljust (15), roundC)
print (str (значениеD) .ljust (15), roundD)
print (str (значениеE) .ljust (15), roundE)
  
 Здесь мы сначала создаем пять переменных со значениями с плавающей запятой.В одних много десятичных знаков, в других — всего несколько.
 Затем делаем округление. Для этого мы вызываем функцию  round ()  и указываем один аргумент: значение для округления. Мы храним округленные целые числа в переменных с  roundA  по  roundE .
 Затем мы выводим результаты с помощью функции  print () . Для каждой переменной мы отображаем исходное значение (например,  valueA ) и его округленный результат ( roundA ). С помощью строкового метода  ljust ()  мы выравниваем это первое значение слева.Это выравнивает значения для более красивого результата.
 Вот как выглядят округленные значения:
  Значение: Округленное:
3,14159265359 3
1845.7409947 1846
-100,95 -101
9,55432 10
34,49953 34
  
 # Округлить до следующего целого числа: функция Python  math.floor ()  
 Функция  math.floor ()  возвращает значение пола   своего аргумента, которое является ближайшим целым числом, меньшим или равным к значению этого аргумента (Python Docs, n.d. б).
 Звучит абстрактно, но это просто еще один способ сказать, что  math.floor ()  округляется до следующего целого числа. Таким образом,  7,8  становится  7 , а  5,4  превращается в  5 . А поскольку функция округляет  вниз  до меньшего значения,  -8,2  становится -9 .
 Вот быстрый пример функции  math.floor () :
  import math

math.floor (12,75)
# Возвращает: 12
  
  математ.floor ()  принимает только один аргумент: значение для округления в меньшую сторону. С помощью небольшой настраиваемой функции мы также можем округлить до нескольких десятичных знаков. Для получения дополнительной информации см. Округление до определенного десятичного числа.
 # Пример: округление значений до следующего полного целого числа 
 Чтобы изучить, как на практике работает функция  math.floor () , давайте рассмотрим следующую программу Python:
  import math

# Некоторые случайные значения
значениеA = 11,2829850
значениеB = 19,2545879
значениеC = 0.50000001
значениеD = 34,6403001
значениеE = -9,9121138

# Округлить значения до ближайшего полного целого числа
roundA = math.floor (значениеA)
roundB = math.floor (значениеB)
roundC = math.floor (значениеC)
roundD = math.floor (значениеD)
roundE = math.floor (значениеE)

# Распечатать результаты
print (valueA, "rounded =", roundA)
print (значениеB, "округлено =", roundB)
print (valueC, "rounded =", roundC)
  
.
 Основы Python — Часть 1 
 Об этом курсе 
 Этот курс является первым из серии из 2 курсов, которые подготовят вас к сертификационным экзаменам  PCEP — Certified Python Programmer  и  PCAP: Certified Associate in Python Programming .
 Основная цель курса — вывести вас из состояния полной неграмотности в программировании на уровень знаний в области программирования, который позволит вам  проектировать ,  писать ,  отлаживать  и  запускать программы , закодированные на языке Python , а также понять основные концепции технологии разработки программного обеспечения.
 Курс подготовит вас к работе и карьере, связанной с широко понимаемой разработкой программного обеспечения  , которая включает в себя не только создание самого кода в качестве младшего разработчика, но также разработку компьютерных систем   и тестирование программного обеспечения  .
 Сертификация 
  PCEP — Сертифицированный программист Python начального уровня Сертификация  — это профессиональная квалификация, которая измеряет вашу способность выполнять задачи кодирования, связанные с основами программирования на языке Python.Кандидат на тестирование должен продемонстрировать достаточные знания универсальных концепций компьютерного программирования, синтаксиса и семантики языка Python, а также навыки решения типичных проблем реализации с помощью стандартной библиотеки Python.
  PCEP — Сертифицированный программист Python начального уровня Сертификация  показывает, что человек знаком с универсальными концепциями компьютерного программирования, такими как типы данных, контейнеры, функции, условия, циклы, а также синтаксис, семантика и среда выполнения языка программирования Python.
 Получение сертификата PCEP гарантирует, что человек ознакомится с наиболее важными средствами, предоставляемыми Python 3, чтобы позволить ему / ей начать собственное обучение на среднем уровне и продолжить свое профессиональное развитие.
  Сертификация PCEP — Certified Python Programmer начального уровня Сертификация  — это промежуточный этап к сертификации PCAP — Certified Associate in Python Programming и отправная точка для начала карьеры в разработке программного обеспечения, программировании на Python и связанных технологиях.Получение сертификата PCEP поможет вам выделиться среди других кандидатов и встать на ноги.
 Дополнительная информация: PCEP — Сертифицированный программист Python начального уровня
 .
 9.7. itertools — Функции, создающие итераторы для эффективного цикла — документация Python 2.7.18 
  chain () 
 п, кв,…
 p0, p1,… пласт, q0, q1,…
  цепь ('ABC', 'DEF') -> A B C D E F 
  компресс () 
 данные, селекторы
 (d [0], если s [0]), (d [1], если s [1]),…
  compress ('ABCDEF', [1,0,1,0,1,1]) -> A C E F 
  падение () 
 pred, seq
 seq [n], seq [n + 1], запускается при сбое пред.
  drop while (лямбда x: x <5, [1,4,6,4,1]) -> 6 4 1 
  groupby () 
 итерация [, keyfunc]
 подитераторов, сгруппированных по значению keyfunc (v)
  ifilter () 
 pred, seq
 элементов seq, где pred (elem) истинно
  ifilter (лямбда x: x% 2, диапазон (10)) -> 1 3 5 7 9 
  ifilterfalse () 
 pred, seq
 элементов seq, где pred (elem) ложно
  ifilterfalse (лямбда x: x% 2, диапазон (10)) -> 0 2 4 6 8 
  islice () 
 seq, [start,] stop [, step]
 элементов из последовательности [начало: стоп: шаг]
  islice ('ABCDEFG', 2, Нет) -> C D E F G 
  imap () 
 func, p, q,…
 func (p0, q0), func (p1, q1),…
  imap (pow, (2,3,10), (5,2,3)) -> 32 9 1000 
  starmap () 
 func, seq
 func (* seq [0]), func (* seq [1]),…
  карта звездного неба (pow, [(2,5), (3,2), (10,3)]) -> 32 9 1000 
  тройник () 
 ит, н
 it1, it2,… itn разбивает один итератор на n
  взять пока () 
 pred, seq
 seq [0], seq [1], до тех пор, пока предварительный не завершится
  takewhile (лямбда x: x <5, [1,4,6,4,1]) -> 1 4 
  izip () 
 п, кв,…
 (p [0], q [0]), (p [1], q [1]),…
  izip ('ABCD', 'xy') -> Топор По 
  izip_longest () 
 p, q,…
 (p [0], q [0]), (p [1], q [1]),…
  izip_longest ('ABCD', 'xy', fillvalue = '-') -> Axe By C- D- 
.
 re — Операции с регулярными выражениями — документация Python 3.8.6 
  Исходный код:  Lib / re.py
 Этот модуль обеспечивает операции сопоставления регулярных выражений, аналогичные
 те, что есть в Perl.
 И шаблоны, и строки для поиска могут быть строками Unicode ( str )
 а также 8-битные строки ( байт ).
 Однако строки Unicode и 8-битные строки нельзя смешивать:
 то есть вы не можете сопоставить строку Unicode с байтовым шаблоном или
 наоборот; аналогично, при запросе замены, замена
 строка должна быть того же типа, что и шаблон, и строка поиска.
 В регулярных выражениях используется обратная косая черта ( '\' ) для обозначения
 специальные формы или разрешить использование специальных символов без вызова
 их особое значение. Это противоречит использованию Python того же
 символ того же назначения в строковых литералах; например, чтобы соответствовать
 буквальная обратная косая черта, возможно, придется написать  '\\\\'  в качестве шаблона
 строка, потому что регулярное выражение должно быть  \ , а каждое
 обратная косая черта должна быть выражена как  \  внутри обычной строки Python
 буквальный.Также обратите внимание, что любые недопустимые escape-последовательности в Python
 использование обратной косой черты в строковых литералах теперь генерирует  DeprecationWarning 
 и в будущем это станет  SyntaxError . Это поведение
 произойдет, даже если это допустимая escape-последовательность для регулярного выражения.
 Решение состоит в том, чтобы использовать нотацию исходной строки Python для регулярного выражения.
 узоры; обратная косая черта не обрабатывается каким-либо особым образом в строковом литерале
 с префиксом  'r' .Итак,  r "\ n"  — это двухсимвольная строка, содержащая
  '\'  и  'n' , а  "\ n"  — это односимвольная строка, содержащая
 новая линия. Обычно шаблоны выражаются в коде Python с использованием этого необработанного
 строковое обозначение.
 Важно отметить, что большинство операций с регулярными выражениями доступны как
 функции и методы на уровне модуля на
 скомпилированные регулярные выражения. Функции — это ярлыки
 которые не требуют предварительной компиляции объекта регулярного выражения, но пропускают некоторые
 параметры тонкой настройки.
 См. Также
 Сторонний модуль регулярных выражений,
 который имеет API, совместимый со стандартной библиотекой  re  module,
 но предлагает дополнительные функции и более полную поддержку Unicode.
 Синтаксис регулярных выражений 
 Регулярное выражение (или RE) определяет набор строк, которые ему соответствуют; то
 функции в этом модуле позволяют проверить, соответствует ли конкретная строка заданному
 регулярное выражение (или если данное регулярное выражение соответствует определенному
 строка, что сводится к тому же самому).
 Регулярные выражения могут быть объединены в новые регулярные выражения; если  A 
 и  B  являются регулярными выражениями, тогда  AB  также являются регулярными выражениями.
 В общем, если строка  p  соответствует  A , а другая строка  q  соответствует  B ,
 строка  pq  будет соответствовать AB. Это справедливо, если только  A  или  B  не содержат низкий приоритет.
 операции; граничные условия между  A  и  B ; или иметь пронумерованную группу
 Ссылки.Таким образом, сложные выражения можно легко построить из более простых
 примитивные выражения, подобные описанным здесь. Подробности теории
 и реализации регулярных выражений, обратитесь к книге Фридла [Frie09],
 или почти любой учебник по построению компиляторов.
 Далее следует краткое объяснение формата регулярных выражений. Для дальнейшего
 информацию и более мягкое изложение, обратитесь к Regular Expression HOWTO.
 Регулярные выражения могут содержать как специальные, так и обычные символы.Наиболее
 обычные символы, такие как  'A' ,  'a'  или  '0' , являются простейшими обычными
 выражения; они просто соответствуют себе. Вы можете объединить обычные
 символов, поэтому  последний  соответствует строке  'последний' . (В остальном
 В разделе  мы будем писать RE в этом специальном стиле , обычно без кавычек, и
 строки для сопоставления  'в одинарных кавычках' .)
 Некоторые символы, например  '|'  или  '(' , особенные.Специальный
 персонажи либо обозначают классы обычных персонажей, либо влияют на
 как интерпретируются окружающие их регулярные выражения.
 Квалификаторы повторения ( * ,  + , ? ,  {m, n}  и т. Д.) Не могут быть
 непосредственно вложенные. Это позволяет избежать двусмысленности с суффиксом модификатора non-greedy
 ?  и с другими модификаторами в других реализациях. Чтобы применить второй
 от повторения к внутреннему повторению можно использовать круглые скобки. Например,
 выражение  (?: a {6}) *  соответствует любому кратному шести  'a'  символам.
 (Caret.) Соответствует началу строки, а также в режиме  MULTILINE 
 соответствует сразу после каждой новой строки.
  $ 
 Соответствует концу строки или непосредственно перед новой строкой в ​​конце
 строка, а в режиме  MULTILINE  также соответствует перед новой строкой.  foo 
 соответствует как «foo», так и «foobar», а регулярное выражение  foo $  соответствует
 только «фу». Что еще интереснее, поиск  foo. долларов в  'foo1 \ nfoo2 \ n' 
 обычно совпадает с «foo2», но с «foo1» в режиме  MULTILINE ; поиск
 один  $  в  'foo \ n'  найдет два (пустых) совпадения: одно непосредственно перед
 перевод строки и один в конце строки.
  * 
 Заставляет результирующий RE соответствовать 0 или более повторениям предыдущего RE, как
 как можно больше повторений.  ab *  будет соответствовать «a», «ab» или «a», за которыми следует
 на любое количество знаков «б».
  + 
 Заставляет результирующий RE соответствовать одному или нескольким повторениям предыдущего RE.
  ab +  будет соответствовать «a», за которым следует любое ненулевое число «b»; он не будет
 совпадать просто «а».
 ? 
 Заставляет результирующий RE соответствовать 0 или 1 повторениям предыдущего RE.
  ab?  будет соответствовать либо «a», либо «ab».
  *? ,  +? ,  ?? 
 Значения  '*' ,  '+'  и  '?' Квалификаторы  все  жадные ; они совпадают
 как можно больше текста.Иногда такое поведение нежелательно; если там
  <. *>  сопоставляется с  ' b ' , он будет соответствовать всему
 строка, а не только  '' . Добавление ?  после того, как квалификатор делает это
 выполнить сопоставление в  нежадном  или  минимальном моде ; как  несколько 
 символы будут сопоставлены по мере возможности. Использование RE  <. *?>  будет соответствовать
 только  '' .
  {m} 
 Указывает, что должно быть сопоставлено ровно  м  копий предыдущего RE; меньше
 совпадения приводят к тому, что весь RE не совпадает.Например,  {6}  будет соответствовать
 ровно шесть  'a'  символов, но не пять.
  {m, n} 
 Приводит к совпадению результирующего RE от  m  до  n  повторений предыдущего
 RE, пытаясь сопоставить как можно больше повторений. Например,
  a {3,5}  будет соответствовать от 3 до 5  'a'  символов. Опуская  м  указывает
 нижняя граница равна нулю, а отсутствие  n  задает бесконечную верхнюю границу.Как
 Например,  a {4,} b  будет соответствовать  'aaaab'  или тысяче  'a'  символов
 за которым следует  'b' , но не  'aaab' . Запятая не может быть опущена или
 модификатор можно спутать с ранее описанной формой.
  {м, п}? 
 Приводит к совпадению результирующего RE от  m  до  n  повторений предыдущего
 RE, пытаясь сопоставить как можно более  несколько  повторений.Это
 нежадная версия предыдущего квалификатора. Например, на
 Строка из 6 символов
.
No related posts.