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

модуль числа на примерах с int и float, синтаксис функции

Встроенная функция abs(x) в Python возвращает абсолютное значение аргумента x, который может быть целым или числом с плавающей точкой, или же объектом, реализующим функцию __abs__(). Для комплексных чисел функция возвращает их величину. Абсолютное значение любого числового значения -x или +x — это всегда соответствующее положительное +x.

Пример abs() с целым числом

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

Копировать Скопировано Use a different Browser

x = 42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
# Вывод: Абсолютное значение 42 это 42

Вывод: «Абсолютное значение 42 это 42».

То же самое, но уже с отрицательным -42.

Копировать Скопировано Use a different Browser

x = -42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Вывод: Абсолютное значение -42 это 42

Пример с числом float

Вот как получить абсолютное значение 42.42 и для -42.42:

Копировать Скопировано Use a different Browser

x = 42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение 42.42 это 42.42
x = -42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение -42.42 это 42.42
 

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

Абсолютное значение комплексного числа (3+10j).

Копировать Скопировано Use a different Browser

complex_number = (3+10j)
abs_complex_number = abs(complex_number)
print(f"Абсолютное значение {complex_number} это {abs_complex_number}")
#  Абсолютное значение (3+10j) это 10.44030650891055

abs() vs fabs()

abs(x) вычисляет абсолютное значение аргумента x. По аналогии функция fabs(x) модуля math вычисляет то же значение. Разница лишь в том, что math.fabs(x) возвращает число с плавающей точкой, а abs(x) вернет целое число, если в качестве аргумента было целое число. Fabs расшифровывается как float absolute value.

Пример c fabs():

Копировать Скопировано Use a different Browser

x = 42
print(abs(x))
# 42
import math
print(math.fabs(x))
# 42.0
 

abs() vs. np.abs()

И abs() в Python, и np.abs() в NumPy вычисляют абсолютное значение числа, но есть два отличия. np.abs(x) всегда возвращает число с плавающей точкой. Также np.abs(x) принимает массив NumPy, вычисляя значение для каждого элемента коллекции.

Пример:

Копировать Скопировано Use a different Browser

x = 42
print(abs(x))
# 42
import numpy as np
print(np.fabs(x))
# 42.0
a = np.array([-1, 2, -4])
print(np. abs(a))
# [1 2 4]

abs и np.abs абсолютно идентичны. Нет разницы какой использовать. У первой преимущество лишь в том, что ее вызов короче.

Вывод

Функция abs() — это встроенная функция, возвращающая абсолютное значение числа. Она принимает целые, с плавающей точкой и комплексные числа на вход.

Если передать в abs() целое число или число с плавающей точкой, то функция вернет не-отрицательное значение n и сохранит тип. Для целого числа — целое число. Для числа с плавающей точкой — число с плавающей точкой.

Копировать Скопировано Use a different Browser

>>> abs(20)
20
>>> abs(20.0)
20.0
>>> abs(-20.0)
20.0

Комплексные числа состоят из двух частей и могут быть записаны в форме a + bj, где a и b — это или целые числа, или числа с плавающей точкой. Абсолютное значение a + bj вычисляется математически как math.sqrt(a**2 + b**2).

Копировать Скопировано Use a different Browser

>>> abs(3 + 4j)
5.0
>>> math.sqrt(3**2 + 4**2)
5.0

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

Максим

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

Python Q https://yandex.ru/q/loves/python Online

Функция abs() в Python, абсолютное значение числа.

Сообщить об ошибке.

abs(x)

• x — число, может быть целым числом, числом с плавающей запятой или комплексным числом.

• абсолютное значение числа x, переданного в качестве аргумента.

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

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

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

# Число с плавающей точкой (запятой)
>>> f = -54.26
>>> print('=>', abs(f)) 
# => 54.26
# Целое число
>>> i = -94
>>> print('=>', abs(i)) 
# => 94
 
# Комплексное число
>>> c = (3 - 4j) 
>>> print('=>', abs(c))
# => 5.0

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Функция abs(), абсолютное значение числа.
• Функция all(), все элементы True.
• Функция any(), хотя бы один элемент True.
• Функция ascii(), преобразует строку в ASCII.
• Функция bin(), число в двоичную строку.
• Класс bool(), логическое значение объекта.
• Функция breakpoint(), отладчик кода.
• Класс bytearray(), преобразует в массив байтов.
• Класс bytes(), преобразует в строку байтов.
• Функция callable(), проверяет можно ли вызвать объект.
• Функция chr(), число в символ Юникода.
• Класс classmethod, делает функцию методом класса.
• Функция compile() компилирует блок кода Python.
• Класс complex(), преобразует в комплексное число.
• Функция delattr(), удаляет атрибут объекта.
• Класс dict() создает словарь.
• Функция dir(), все атрибуты объекта.
• Функция divmod(), делит числа с остатком.
• Функция enumerate(), счетчик элементов последовательности.
• Функция eval(), выполняет строку-выражение с кодом.
• Функция exec(), выполняет блок кода.
• Функция filter(), фильтрует список по условию.
• Класс float(), преобразует в вещественное число.
• Функция format(), форматирует значение переменной.
• Класс frozenset(), преобразует в неизменяемое множество.
• Функция getattr(), значение атрибута по имени.
• Функция globals(), переменные глобальной области.
• Функция hasattr(), наличие атрибута объекта.
• Функция hash(), хэш-значение объекта.
• Функция help(), справка по любому объекту.
• Функция hex(), число в шестнадцатеричную строку.
• Функция id(), идентификатор объекта.
• Функция input(), ввод данных с клавиатуры.
• Класс int(), преобразует в тип int.
• Функция isinstance(), принадлежность экземпляра к классу.
• Функция issubclass(), проверяет наследование класса.
• Функция iter(), создает итератор.
• Функция len(), количество элементов объекта.
• Класс list(), преобразовывает в список.
• Функция locals(), переменные локальной области.
• Функция map(), обработка последовательности без цикла.
• Функция max(), максимальное значение элемента.
• Класс memoryview(), ссылка на буфер обмена.
• Функция min(), минимальное значение элемента.
• Функция next(), следующий элемент итератора.
• Класс object(), возвращает безликий объект.
• Функция oct(), число в восьмеричную строку.
• Функция open(), открывает файл на чтение/запись.
• Функция ord(), число символа Unicode.
• Функция pow(), возводит число в степень.
• Функция print(), печатает объект.
• Класс property(), метод класса как свойство.
• Класс range(), генерирует арифметические последовательности.
• Функция repr(), описание объекта.
• Функция reversed(), разворачивает последовательность.
• Функция round(), округляет число.
• Класс set(), создает или преобразовывает в множество.
• Функция setattr(), создает атрибут объекта.
• Класс slice(), шаблон среза.
• Функция sorted(), выполняет сортировку.
• Декоратор staticmethod(), метод класса в статический метод.
• Класс str(), преобразует объект в строку.
• Функция sum(), сумма последовательности.
• Функция super(), доступ к унаследованным методам.
• Класс tuple(), создает или преобразует в кортеж.
• Класс type(), возвращает тип объекта.
• Функция vars(), словарь переменных объекта.
• Функция zip(), объединить элементы в список кортежей.
• Функция __import__(), находит и импортирует модуль.
• Функция aiter(), создает асинхронный итератор.
• Функция anext(), следующий элемент асинхронного итератора.

cmath — Математические функции для комплексных чисел — Документация по Python 3.11.1

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

Примечание

На платформах с аппаратной и системной поддержкой подписанных нули, функции с ветвлениями непрерывны на

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

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

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

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

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

cmath. фаза( x )

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

 >>> фаза (комплекс (-1.0, 0.0))
3.141592653589793
>>> фаза (комплекс (-1.0, -0.0))
-3,141592653589793
 

Примечание

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

cmath.polar( x )

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

cmath.rect( r , фи )

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

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

cmath.exp( x )

Возврат e в степени x , где e основание натурального числа логарифмы.

cmath.log( x [ база ])

Возвращает логарифм x по заданному основанию . Если база не указанный, возвращает натуральный логарифм x . Срезана одна ветка, от 0 вдоль отрицательной вещественной оси до -∞, непрерывно сверху.

cmath. log10( x )

Возвращает логарифм по основанию 10 числа x . У него такая же ветвь срезана, как лог() .

cmath.sqrt( x )

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

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

cmath.acos( x )

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

cmath.asin( x )

Возвращает арксинус x . У него те же ветвления, что и у acos() .

cmath.atan( x )

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

cmath.cos( x )

Возвращает косинус x .

cmath.sin( x )

Возврат синуса x .

cmath.tan( x )

Возврат касательной x .

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

cmath.acosh( x )

Возвращает гиперболический арккосинус x . Там одна ветка срезана, идущий влево от 1 вдоль действительной оси до -∞, непрерывный сверху.

cmath.asinh( x )

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

cmath.atanh( x )

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

cmath.cosh( x )

Возвращает гиперболический косинус x .

cmath.sinh( x )

Вернуть гиперболический синус x .

cmath.tanh( x )

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

Функции классификации

cmath.isfinite( x )

Возврат Истинно , если и действительная, и мнимая части x конечны, и False иначе.

Новое в версии 3.2.

cmath. isinf( x )

Возврат True , если действительная или мнимая часть x является бесконечность и False в противном случае.

cmath.isnan( х )

Возврат True , если действительная или мнимая часть x является NaN, и False в противном случае.

cmath.isclose( a , b , * , rel_tol=1e-09 , abs_tol=0.0 )

Вернуть True , если значения a и b близки друг к другу и False иначе.

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

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

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

Если ошибок нет, результат будет таким: абс(а-б) <= макс(отн_допуск * макс(абс(а), абс(б)), абс_доп) .

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

Новое в версии 3.5.

См. также

PEP 485 — Функция проверки приблизительного равенства

Константы

cmath.pi

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

cmath.e

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

cmath.tau

Математическая константа τ , как поплавок.

Новое в версии 3.6.

cmath.inf

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

Новое в версии 3.6.

cmath.infj

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

Новое в версии 3.6.

cmath.нан

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

Новое в версии 3.6.

cmath.nanj

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

Новое в версии 3.6.

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

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

См. также

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

Python Numbers — неофициальная документация по разработке Python (заметки Виктора)

Номерная башня

Модуль чисел определяется PEP 3141 — Иерархия типов для чисел.

• номера.Номер: базовый класс
• чисел. Комплекс: добавьте реальных , изображений , сопряженных ()
• номеров. Real: подкласс Complex; добавить много операций с плавающей запятой.
• номеров. Rational: подкласс Real; добавить числитель и знаменатель атрибуты
• номеров. Интеграл: подкласс Rational

Подклассы:

• числа.Числа: целочисленные, с плавающей запятой, комплексные, десятичные.Десятичные, дробные.Дробь
• чисел.Комплекс: целое, число с плавающей запятой, комплекс, дроби.Дробь
• чисел.Вещественное число: целое число, число с плавающей запятой, дроби.Дробь
• чисел. Рациональное: целое, дроби. Дробь
• номеров. Интеграл: int

int, float, сложные методы и атрибуты:

• conjugate()
• изображение
• настоящий

Атрибуты целого числа и дроби:

• знаменатель
• числитель

Преобразования в Python

int(obj) и float(obj) accept:

• int
• поплавок
• десятичный. Десятичный
• дроби. Дробь
• байта
• ул

int(obj) округлений до нуля (ROUND_DOWN, например: int(0.9) == 0 и int(-0.9) == 0 ).

Но int(obj) и float(obj) отклонить:

• сложный

комплекс(объект) принимает:

• инт
• поплавок
• комплекс
• десятичный. Десятичный
• дроби. Дробь
• ул

Но комплекс(объект) отклоняет:

• байт

decimal.Decimal(obj) принимает:

• целый
• поплавок
• десятичный. Десятичный
• ул

Но десятичный. Десятичный (объект) отклоняет:

• сложный
• дроби. Дробь
• байта

дроби. Фракция (объект) принимает:

• целое число
• поплавок
• десятичный.Десятичный
• дроби. Дробь
• стр. (например: "1" или "1/2" )

Но дроби. Фракция(объект) брак:

• сложный
• байта

тип int

Примеры:

 >>> (123).bit_length()
7
>>> sys.int_info
sys.int_info (bits_per_digit = 30,
             размер_цифры=4)
 

Сериализация в байтах:

 >>> (123).to_bytes(4, 'мало')
б'{\х00\х00\х00'
>>> int.from_bytes(b'{\x00\x00\x00', 'маленький')
123
 

Округление:

• int(float) вызывает float. __trunc__() , поэтому округление до нуля (ОКРУГЛ_ВНИЗ)

тип с плавающей запятой

Примеры:

 >>> sys.float_info
sys.float_info (макс. = 1,7976931348623157e+308,
               макс_эксп = 1024,
               max_10_exp=308,
               мин=2,2250738585072014e-308,
               мин_эксп = -1021,
               min_10_exp=-307,
               копать=15,
               мант_коп = 53,
               эпсилон=2,220446049250313э-16,
               основание = 2,
               раунды=1)
>>> sys.float_repr_style
'короткий'
>>> (1.2).as_integer_ratio()
(5404319552844595, 4503599627370496)
 

Форматирование как шестнадцатеричное (основание 16):

 >>> (1.1).hex()
'0x1.199999999999ap+0'
>>> float.fromhex('0x1.199999999999ap+0')
1.1
 

Округление:

• float.__trunc__(): Округление до нуля (ROUND_DOWN)
• float.__round__(): Округлить до ближайшего, а ничьи — до ближайшего четного целого числа (ROUND_HALF_EVEN).
• float.__int__() — это псевдоним для float.__trunc__() (ROUND_DOWN)

Дробь

 >>> дроби. Дробь (5, 10) # int / int
Фракция (1, 2)
>>> Fraction.Fraction(1.2) # число с плавающей запятой
Дробь(5404319552844595, 4503599627370496)
 

C API

Преобразование объекта Python в целое число. Методы типа:

• __int__() : слот type->tp_as_number->nb_int
• __index__() : слот тип->tp_as_number->nb_index
• __trunc__() (без слота)

PyNumber_Long(obj) :

• Вызов obj.__trunc__() (Округление до нуля, ROUND_DOWN)
• или: если тип obj — bytes или str, анализировать строку в десятичном виде (с основанием 10)
• или: ошибка!

PyNumber_Index(x) вызывает метод __index__() : вызывает исключение, если тип не имеет __index__() метод или если метод не возвращает точно тип int (*).

_PyLong_FromNbInt(x) :

• Вызов type(x).__int__(x) : тип результата должен быть именно типом int (*)
• или: ошибка!

_pylong_fromnbindexornbint (x) : __index __ () или __int __ () :

• return x , если тип (x) == int ( pylng_checact hipexact (x) == int ( pylng_checact.
• вызов type(x).__index__(x) , если он определен: тип результата должен быть точно тип int (*)
• вызов type(x).__int__(x) (вызов _PyLong_FromNbInt() ): тип результата должен быть точно типом int (*)
Ошибка
• , если это не подкласс int и тип не определен __index__() ни __int__() метод
• Новое в Python 3.8

PyLong_AsLong() преобразует Python int в C длинный :

• вызов _PyLong_FromNbIndexOrNbInt()
• поднять OverflowError, если результат не помещается в C long
• Python 3. 7 и старше вызывают только __int__() , а не __index__() .

PyLong_AsUnsignedLongMask() преобразует объект Python в беззнаковый C long :

• вызов _PyLong_FromNbIndexOrNbInt(x) и затем _PyLong_AsUnsignedLongMask() на результат
Ошибка
• , если объект не может быть преобразован в int с помощью _PyLong_FromNbIndexOrNbInt(x)
• целочисленное переполнение маски
• Python 3.7 и старше вызывают только __int__() , а не __index__() .

(*) Особый случай: __int__() или __index__() возвращает подкласс int. Этот функция устарела, начиная с Python 3.3 (см. коммит 6a44f6ee). Эта функция может быть удалена из Python 3.9.: см. bpo-17576.

PyArg_ParseTuple и Py_BuildValue

Справочная документация: разбор аргументов и построение значений.

• PyArg_ParseTuple реализован в Python/getargs.c , основная функция: convertsimple() .

• Py_BuildValue реализован в Python/modsupport.c , основная функция: do_mkvalue() .

• Функции ведут себя иначе, если PY_SSIZE_T_CLEAN определяется:

  Для всех вариантов форматов # ( s# , y# и т.д.) тип файла Аргумент длины (int или Py_ssize_t ) управляется определением макрос PY_SSIZE_T_CLEAN до включения Python.h .

Форматы PyArg_ParseTuple:

• "i" (C int ): __index__() или __int__() ; вызов PyLong_AsLong(объект) , но явно отклоняет float, используя PyFloat_Check(аргумент) .
• "l" (C long ): __index__() или __int__() ; вызов PyLong_AsLong() , но явно отклоняет float, используя PyFloat_Check(arg)
• "n" (C ssize_t ): __index__() ; вызов PyNumber_Index() и затем PyLong_AsSsize_t() . Исключение при переполнении.
• "к" : вызовите PyLong_AsUnsignedLongMask() , если это подкласс int или int, ошибка иначе. Целочисленное переполнение маски .

Примечание. В Python 3.7 и старше PyLong_AsLong() вызывает только __int__() , не __index__() .

Скрипт для обновления этой страницы

number_tower.py:

 из __future__ import print_function
импортировать номера
предупреждения об импорте
импортные фракции
импортировать десятичный
warnings.simplefilter("ошибка", DeprecationWarning)
ЗНАЧЕНИЯ = (
 ("целое", 123),
 ("с плавающей запятой", 1,5),
 («сложный», сложный (0, 1,5)),
 ("десятичный.Десятичный", десятичный.Десятичный("1.1")),
 ("дроби.Дробь", дроби.Дробь(1, 7)),
 ("байты", б"123"),
 ("ул", "123"),
)
ТИПЫ = (
 ("целое", целое),
 ("плавать", плавать),
 ("сложный", сложный),
 ("десятичный.Десятичный", десятичный. Десятичный),
 ("дроби.Дробь", дроби.Дробь),
)
для type_descr, num_type в TYPES:
 принято = []
 отклонено = []
 для value_descr, значение в VALUES:
 пытаться:
 num_type(значение)
 кроме TypeError:
 отклонено.append(value_descr)
 еще:
 принято .append (value_descr)
 если принято:
 print("``%s(obj)`` accept:" % type_descr)
 Распечатать()
 для имени принято:
 print("* ``%s``" % имя)
 Распечатать()
 если отклонено:
 print("``%s(obj)`` отклонить:" % type_descr)
 Распечатать()
 для имени в отклоненном:
 print("* ``%s``" % имя)
 Распечатать()
Распечатать()
для имя_башни, тип_башни в (
 ("Число", цифры.Число),
 ("Комплекс", номера.Комплекс),
 ("Настоящий", цифры.Настоящий),
 («Рациональное», числа.Рациональное),
 ("Интеграл", числа.Интеграл),
):
 подклассы = []
 для type_descr, num_type в TYPES:
 если issubclass (num_type, tower_type):
 подклассы.