Python проверка на целое число: Остаток от деления в Python 3 и целая часть при делении

Содержание

Остаток от деления в Python 3 и целая часть при делении

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

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

Оператор деления

Деление в Python обозначается косой чертой «/». Примечательно, что результат в консоле всегда приводится к типу «float», даже если оба операнда были целочисленного типа, об этом свидетельствует появление «.0» у полученного значения.

Это появилось в 3-ей версии Python, ранее результатом деления целых чисел было только целое число, чтобы получить дробный результат, программисты явно указывали одному из операндов тип «float», в противном случае дробная часть просто отбрасывалась.

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

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

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

Примеры:

print(int(1) / int(2))
print(5 / 5)
print(1 / 3)

0.5
1.0
0.3333333333333333

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

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

Деление без остатка

Чтобы выполнить деление на цело в Python, можно воспользоваться целочисленным делением. В этом случае результатом будет целое число, без остатка. Целочисленное деление в Python обозначается двумя косыми чертами «//».

В отличие от других языков программирования Python позволяет результату целочисленного деления быть как целым (int), так и дробным (float) числом. В обоих случаях дробная часть отбрасывается и получается число с окончанием «.0».

Примеры нахождения целой части от деления:

print(5 // 2)
print(0 // 2)
print(1234 // 5.0)

2
0
246.0

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

Остаток

Для получения остатка от деления в Python 3 используется операция, обозначающаяся символом процента «%». Остаток — это оставшаяся после целочисленного деления часть числа. Операция взятия остатка используется для решения различных видов задач.

Примеры:

print(10 % 3)
print(5 % 10)
print(5 % 0.25)

1
5
0.0

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

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

example_list = [3, 7, 2, 8, 1, 12]
for value in example_list:
    if value % 2 == 0:
        print(value)

2
8
12

Проблемы чисел с плавающей точкой

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

Из-за этого при делении и других операциях с дробями часто возникают проблемы. Например, 1/10 в двоичном представлении является неправильной бесконечной дробью. Её нельзя написать полностью, поэтому приходится округлять, а выбор значения при округлении ограничен нулем и единицей.

Что говорить о делении, если ошибки возникают и при операции сложения. Если сложить число «0.1» с самим собой четырнадцать раз, то получиться 1.400…01. Откуда взялась эта единица? Она появилась при переводе числа из двоичного вида в десятичный.

a = 0.1
for i in range(13):
    a += 0.1
print(a)

1.4000000000000001

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

Деление комплексных чисел

Комплексные числа — это числа вида «a + b·i». Они занимают наивысшую ступень в иерархии чисел, арифметические операции над ними существенно отличаются от операций над обычными числами.

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

Пример:

print((5 + 8j) / 2)

(2.5+4j)

Сокращенные операции деления

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

Полная форма Краткая форма
Деление a = a / b a /= b
Целая часть a = a // b a //=b
Остаток a = a % b a %= b

Приведём пример:

a = 245
a %= 17
print(a)

7

Деление на ноль

Если попробовать в Python выполнить деление на 0, то мы получим исключение ZeroDivisionError.

Исключение следует обрабатывать, это можно сделать так:

try:
    print(24 / 0)
except Exception as e:
    print(e)

division by zero

Но в этом случае мы обрабатываем все исключения. Зачастую так делать не совсем корректно. Мы знаем, что в нашем коде возможно деление на 0 и, чтобы отловить именно эту ошибку, следует заменить except Exception as e: на except ZeroDivisionError as e:.
Но можно и проверять перед выполнением операции, что делитель не равен 0. Например так:

a = 14
b = None
if a == 0:
    print('делитель равен нулю!')
else:
    b = 345/a
    print('Операция выполнена, результат = ' + str(b))

Операция выполнена, результат = 24.642857142857142

Числа: целые, вещественные, комплексные | Python 3 для начинающих и чайников

Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.

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

Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:

x + yСложение
x - yВычитание
x * yУмножение
x / yДеление
x // yПолучение целой части от деления
x % yОстаток от деления
-xСмена знака числа
abs(x)Модуль числа
divmod(x, y)Пара (x // y, x % y)
x ** yВозведение в степень
pow(x, y[, z])xy по модулю (если модуль задан)

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

>>> 255 + 34
289
>>> 5 * 2
10
>>> 20 / 3
6.666666666666667
>>> 20 // 3
6
>>> 20 % 3
2
>>> 3 ** 4
81
>>> pow(3, 4)
81
>>> pow(3, 4, 27)
0
>>> 3 ** 150
369988485035126972924700782451696644186473100389722973815184405301748249

Битовые операции

Над целыми числами также можно производить битовые операции

x | yПобитовое или
x ^ yПобитовое исключающее или
x & yПобитовое и
x << nБитовый сдвиг влево
x >> yБитовый сдвиг вправо
~xИнверсия битов

Дополнительные методы

int. bit_length() - количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

int.to_bytes(length, byteorder, *, signed=False) - возвращает строку байтов, представляющих это число.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
b'\xe8\x03'

classmethod int.from_bytes(bytes, byteorder, *, signed=False) - возвращает число из данной строки байтов.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int. from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Системы счисления

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

  • int([object], [основание системы счисления]) - преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
  • bin(x) - преобразование целого числа в двоичную строку.
  • hex(х) - преобразование целого числа в шестнадцатеричную строку.
  • oct(х) - преобразование целого числа в восьмеричную строку.

Примеры:

>>> a = int('19') # Переводим строку в число
>>> b = int('19. 5')  # Строка не является целым числом
Traceback (most recent call last):
  File "", line 1, in
ValueError: invalid literal for int() with base 10: '19.5'
>>> c = int(19.5)  # Применённая к числу с плавающей точкой, отсекает дробную часть
>>> print(a, c)
19 19
>>> bin(19)
'0b10011'
>>> oct(19)
'0o23'
>>> hex(19)
'0x13'
>>> 0b10011  # Так тоже можно записывать числовые константы
19
>>> int('10011', 2)
19
>>> int('0b10011', 2)
19

Вещественные числа (float)

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

>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.9999999999999999

Для высокой точности используют другие объекты (например Decimal и Fraction)).

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

>>> a = 3 ** 1000
>>> a + 0. 1
Traceback (most recent call last):
  File "", line 1, in
OverflowError: int too large to convert to float

Простенькие примеры работы с числами:

>>> c = 150
>>> d = 12.9
>>> c + d
162.9
>>> p = abs(d - c)  # Модуль числа
>>> print(p)
137.1
>>> round(p)  # Округление
137

Дополнительные методы

float.as_integer_ratio() - пара целых чисел, чьё отношение равно этому числу.

float.is_integer() - является ли значение целым числом.

float.hex() - переводит float в hex (шестнадцатеричную систему счисления).

classmethod float.fromhex(s) - float из шестнадцатеричной строки.

>>> (10.5).hex()
'0x1.5000000000000p+3'
>>> float.fromhex('0x1.5000000000000p+3')
10.5

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

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

>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(85)
9.219544457292887

Модуль random реализует генератор случайных чисел и функции случайного выбора.

>>> import random
>>> random.random()
0.15651968855132303

Комплексные числа (complex)

В Python встроены также и комплексные числа:

>>> x = complex(1, 2)
>>> print(x)
(1+2j)
>>> y = complex(3, 4)
>>> print(y)
(3+4j)
>>> z = x + y
>>> print(x)
(1+2j)
>>> print(z)
(4+6j)
>>> z = x * y
>>> print(z)
(-5+10j)
>>> z = x / y
>>> print(z)
(0.44+0.08j)
>>> print(x.conjugate())  # Сопряжённое число
(1-2j)
>>> print(x.imag)  # Мнимая часть
2.0
>>> print(x.real)  # Действительная часть
1.0
>>> print(x > y)  # Комплексные числа нельзя сравнить
Traceback (most recent call last):
  File "", line 1, in
TypeError: unorderable types: complex() > complex()
>>> print(x == y)  # Но можно проверить на равенство
False
>>> abs(3 + 4j)  # Модуль комплексного числа
5. 0
>>> pow(3 + 4j, 2)  # Возведение в степень
(-7+24j)

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

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

Функция all() в Python, все элементы True.

Проверяет, что все элементы в последовательности True.

Синтаксис:
Параметры:
Возвращаемое значение:
Описание:

Функция all() возвращает значение True , если все элементы в итерируемом объекте - истинны, в противном случае она возвращает значение False.

Если передаваемая последовательность пуста, то функция all() также возвращает True.

Функция all() применяется для проверки на True ВСЕХ значений в последовательности и эквивалентна следующему коду:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

Так же смотрите встроенную функцию any()

В основном функция all() применяется в сочетании с оператором ветвления программы if ... else. Работу функции all() можно сравнить с оператором and в Python, только all() работает с последовательностями:

>>> True and True and True
# True
>>> True and False and True
# False

>>> all([True, True, True])
# True
>>> all([True, False, True])
# False

Но между and и all() в Python есть два основных различия:

  • Синтаксис.
  • Возвращаемое значение.

Функция all() всегда возвращает False или True (значение bool)

>>> all([3, 1, 2, 6])
# True
>>> all([3, 0, 2, []])
# False

Если в выражении все значения True, то оператор and возвращает ПЕРВОЕ истинное значение, а если все значения False, то последнее ложное значение. А если в выражении присутствует значение False, то ПЕРВОЕ ложное значение. Что бы добиться поведения как у функции all(), необходимо выражение с оператором and обернуть в функцию bool().

>>> 3 and 1 and 2 and 6
# 6
>>> 3 and 0 and 3 and []
# 0

>>> bool(3 and 1 and 2 and 6)
# True
>>> bool(3 and 0 and 3 and [])
# False

Из всего сказанного можно сделать вывод, что для успешного использования функции all() необходимо в нее передавать последовательность, полученную в результате каких то вычислений/сравнений, элементы которого будут оцениваться как True или False. Это можно достичь применяя функцию map() или выражения-генераторы списков, используя в них встроенные функции или методы, возвращающие bool значения, операции сравнения, оператор вхождения in и оператор идентичности is.

num = [1, 2.0, 3.1, 4, 5, 6, 7.9]
# использование встроенных функций или
# методов на примере 'isdigit()'
>>> [str(x).isdigit() for x in num]
# [True, False, False, True, True, True, False]

# использование операции сравнения
>>> [x > 4 for x in num]
# [False, False, False, False, True, True, True]

# использование оператора вхождения `in`
>>> ['.' in str(x) for x in num]
# [False, True, True, False, False, False, True]

# использование оператора идентичности `is`
>>> [type(x) is int for x in num]
# [True, False, False, True, True, True, False]

# использование функции map()
>>> list(map(lambda x: x > 1, num))
[False, True, True, True, True, True, True]

Примеры проводимых проверок функцией all().

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

>>> num1 = range(1, 9)
>>> num2 = range(-1, 7)
>>> all([x > 0 for x in num1])
# True
>>> all([x > 0 for x in num2])
# False

Или проверить, что последовательность чисел содержит только ЦЕЛЫЕ числа.

>>> num1 = [1, 2, 3, 4, 5, 6, 7]
>>> num2 = [1, 2.0, 3.1, 4, 5, 6, 7.9]
>>> all([type(x) is int for x in num1])
# True
>>> all([type(x) is int for x in num2])
# False

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

>>> line1 = "1, 2, 3, 9.9, 15.1, 7"
>>> line2 = "1, 2, 3, 9.9, 15.1, 7, девять"
>>> all([x.replace('.', '').strip().isdigit() for x in line1.split(',')])
# True
>>> all([x.replace('.', '').strip().isdigit() for x in line2.split(',')])
# False

Еще пример со строкой. Допустим нам необходимо узнать, есть ли в строке наличие открытой И закрытой скобки?

>>> simbols = ['(', ')']
>>> line1 = "функция 'all()' всегда возвращает 'False' или 'True'"
>>> line2 = "функция any всегда возвращает значение bool"
>>> all([x in line1 for x in simbols])
# True
>>> all([x in line2 for x in simbols])
# False

Выбрать из строки числа. Язык Python

Дана строка, содержащая натуральные числа и слова. Необходимо сформировать список из чисел, содержащихся в этой строке. Например, задана строка "abc83 cde7 1 b 24". На выходе мы должны получить список [83, 7, 1, 24].

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

s = input()
l = len(s)
integ = []
i = 0
while i < l:
    s_int = ''
    a = s[i]
    while '0' <= a <= '9':
        s_int += a
        i += 1
        if i < l:
            a = s[i]
        else:
            break
    i += 1
    if s_int != '':
        integ.append(int(s_int))

print(integ)
5 dkfj78df 9 8 dkfj8
[5, 78, 9, 8, 8]

Обратите внимание, что данное решение извлекает именно числа, а не цифры. Иначе мы бы не получили число 78, а получили отдельно цифру 7 и цифру 8. Задача на извлечение цифр существенно проще.

Решение через цикл for:

a = input()
num_list = []

num = ''
for char in a:
    if char.isdigit():
        num = num + char
    else:
        if num != '':
            num_list.append(int(num))
            num = ''
if num != '':
    num_list.append(int(num))

print(num_list)

Если в строке числа всегда отделены от слов пробелами, задача решается проще:

s = input()
word_list = s.split()
num_list = []

for word in word_list:
    if word.isnumeric():
        num_list.append(int(word))

print(num_list)

Здесь происходит разделение строки на слова по пробелам. В цикле с помощью метода isnumeric() каждое слово проверяется, является ли оно числом. Подобную задачу можно решить в одну строку, если использовать функцию filter().

s = input()
word_list = s.split()

num_list = [int(num) for num in filter(lambda num: num.isnumeric(), word_list)]

print(num_list)

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

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

import re

s = input()

nums = re.findall(r'\d+', s)

nums = [int(i) for i in nums]

print(nums)

Для поиска вещественных чисел:

import re

s = input()

nums = re.findall(r'\d*\.\d+|\d+', s)

nums = [float(i) for i in nums]

print(nums)

Python: преобразование строки в число | Python

Одна из наиболее распространенных вопросов, связанных со строками - из преобразование в число. Как преобразовать в python строку в число мы рассмотрим в этом посте. Также сможем проверить, является ли содержимое строки числом. В стандартной библиотеке python есть великолепные функции преобразования. Но к сожалению они ограничены. Функция int() возвращает целое число, если получает на входе строку с целочисленным значением. Та же история с float() - число с плавающей точкой. Иначе обе эти функции возвращают ошибку TypeError... Ниже приведен полный код программы, в которой 5 функций:
  1. Чистка строки: удаляет из строки все символы, доведя содержимое до целочисленного или числа с плавающей точкой.
  2. Функция преобразования строки в целочисленное. На входе должна быть строка с любым числовым содержимым: "123.4" или "232"
  3. Функция проверки содержимого строки на "целочисленность".
  4. Функция преобразования строки в число с плавающей точкой. На входе должна быть строка с любым числовым содержимым: "123.4" или "232"
  5. Проверяем, является ли содержимое строки числом с плавающей точкой.
Это, на мой взгляд, наиболее распространенные задачи, которые приходится решать в области преобразования строк в числа. Далее код программы:
# ~*~ coding: utf8 ~*~

def clear_string(str, to_int = None):
    """
    Чистим строку от "мусора" - нечисловых символов.
    """
    new_str = ""
    for s in str:
        # сначала ищем точку (вдруг число с плавающей точкой)
        # при этом в новой строке не должно быть больше одной точки
        # и в условии to_int не определен
        if s == "." and "." not in new_str and not to_int:
            new_str += s
        else:
            try:
                i = int(s)
                new_str += s
            except:
                pass
    return new_str

def str_to_int(str):
    """
    Преобразование стоки в целое число
    """
    # попробуем воспользоваться самым простым методом
    try:
        return int(str)
    except:
        # если не получилось, то проверяем почему? допускаем, что было передано не целое число в строке
        if "." in str:
            str = str[0:str.find(".")]
            return str_to_int(str)
        else:
            # если уж совсем дела плохи, то возвращаем 0
            return 0

def check_int(str):
    try:
        int(str)
        return True
    except:
        return False

def str_to_float(str):
    """
    Преобразование стоки в число с плавающей точкой
    """
    # попробуем воспользоваться самым простым методом
    try:
        return float(str)
    except:
        # других вариантов не осталось. скорее всего функция приняла на входе мусор
        return 0

def check_float(str):
    try:
        float(str)
        return True
    except:
        return False

# есть у нас незатейливая строка
str = "a23d.d.5ff6"
# проверяем функцию чистки строки
print("Чищеная строка: %s" % clear_string(str))
print("Чищеная строка с to_int: %s" % clear_string(str, to_int=True))
# до преобразования строки в число следовало бы почистить ее
print("Преобразуем мусор в целое число: %s" % str_to_int(str))
print("Преобразуем чищеную строку в целое число: %s" % str_to_int(clear_string(str)))
# преобразуем строку в число с плавающей точкой
print("Преобразуем мусор в число с плавающей точкой: %s" % str_to_float(str))
print("Преобразуем чищеную строку в число с плавающей точкой: %s" % str_to_float(clear_string(str)))

print("Проверяем, является ли содержимое строки целочисленным: %s" % check_int(str))
print("Проверяем, является ли содержимое чищеной строки целочисленным: %s" % check_int(clear_string(str, to_int=True)))
print("Проверяем, является ли содержимое строки числом с плавающей точкой: %s" % check_float(str))
print("Проверяем, является ли содержимое чищеной строки числом с плавающей точкой: %s" % check_float(clear_string(str)))
Задачу по проверке содержимого строки на целочисленность можно было бы решить с помощью стандартной функции isdigit(). Но это слишком просто. Для наглядности и создали функцию check_int(), которая работает так же, как и isdigit().
# Для успокоения души слишком любознательных приведу пример
"s34".isdigit()
# False
"34".isdigit()
# True
clear_string("s43de463").isdigit()
# True
Ну и напоследок, если у вас есть комментарии или более интересные задачи из выше рассмотренной области, то прошу комментировать. Попробуем решить задачу вместе. Встроенные функции

- документация Python 3.9.1

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

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

абс. ()

delattr ()

хэш ()

memoryview ()

комплект ()

все ()

дикт ()

справка ()

мин ()

setattr ()

любой ()

директ ()

шестигранник ()

вперед ()

ломтик ()

ascii ()

divmod ()

id ()

объект ()

отсортировано ()

бункер ()

перечислить ()

вход ()

окт ()

статический метод ()

булев ()

eval ()

внутр ()

открытый ()

ул. ()

точка останова ()

exec ()

isinstance ()

ord ()

сумма ()

байтовый массив ()

фильтр ()

isubclass ()

pow ()

супер ()

байтов ()

поплавок ()

iter ()

печать ()

кортеж ()

, по телефону ()

формат ()

лин ()

недвижимость ()

тип ()

chr ()

замораживание ()

список ()

диапазон ()

vars ()

classmethod ()

getattr ()

местные жители ()

представитель ()

почтовый индекс ()

компиляция ()

глобальные ()

карта ()

обратное ()

__импорт __ ()

комплекс ()

hasattr ()

макс. ()

Как проверить, содержит ли строка Python другую строку?

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

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

В Python есть два способа добиться этого.

Первый: использование оператора in

Самый простой способ - использовать оператор in Python.

Давайте посмотрим на этот пример.

  >>> str = "Месси - лучший футболист"
>>> "футбол" на ул.
Правда
>>> "футбол" на ул.
False  

Как видите, оператор in возвращает True, если подстрока существует в строке.

В противном случае возвращается false.

Этот метод очень простой, чистый, читаемый и идиоматический.

Второй: использование метода поиска

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

В отличие от оператора in, который оценивается как логическое значение, метод find возвращает целое число.

Это целое число, по сути, является индексом начала подстроки, если подстрока существует, в противном случае возвращается -1.

Давайте посмотрим, как работает метод find.

  >>> str = "Месси - лучший футболист"
>>> str.find ("футбол")
18
>>> str.find ("Роналду")
-1
>>> str.find ("Месси")
0  

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

Например

  >>> str = "Месси - лучший футболист"
>>> str.find ("футбол", 5, 25)
18
>>> str.find ("Месси", 5, 25)
-1  

Обратите внимание, как для «Месси» был возвращен -1, потому что вы ограничиваете свой поиск строкой только между индексами 5 и 25.

Шпаргалка по Python 3 для начинающих

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

Некоторые дополнительные сведения

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

Как бы вы написали функцию для этого?

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

Для больших строк этот процесс может быть очень медленным.

Есть лучшие алгоритмы поиска по строкам.

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

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

Если вы просмотрите предыдущие статьи и изучите их, ваш следующий вопрос будет: «А какой алгоритм на самом деле использует Python?»

Вопросы подобного рода почти всегда требуют изучения исходного кода.

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

Хорошо, давайте углубимся в код.

Отлично, я рад, что разработчики прокомментировали свой код 🙂

Теперь очень ясно, что метод find использует смесь алгоритмов Бойера-Мура и Хорспула.

Заключение

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

Оператор in возвращает True, если подстрока существует в строке.В противном случае возвращается False.

Метод find возвращает индекс начала подстроки, если он найден, в противном случае возвращается -1.

Реализация Python (CPython) использует сочетание Boyer-Moore и horspool для поиска по строкам.

Изучение Python?

Загляните в раздел Курсы!

Избранные сообщения

Вы начинаете свою карьеру в области программирования?

Я предлагаю свой лучший контент для новичков в информационном бюллетене.

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

И многое другое…

Подпишитесь сейчас. Это бесплатно.

способов перебора списка в Python

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

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

  • Использование метода Python range ()
  • Понимание списка
  • Использование метода Python enumerate ()
  • С использованием цикла for
  • Использование цикла while с использованием Python y
  • модуль
  • Использование лямбда-функции

1. Перебрать список в Python с помощью метода range ()

Метод Python range () может использоваться в сочетании с циклом for для обхода и перебора списка в Python.

Метод range () в основном возвращает последовательность целых чисел , т.е. он строит / генерирует последовательность целых чисел от предоставленного начального индекса до конечного индекса, как указано в списке аргументов.

Синтаксис:

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

Функция range () генерирует последовательность целых чисел от начального значения до конечного / конечного значения, но не включает конечное значение в последовательность, т.е. не включает номер / значение остановки в результирующей последовательности .

Пример:

lst = [10, 50, 75, 83, 98, 84, 32]

для x в диапазоне (len (lst)):
печать (lst [x])

 

В приведенном выше фрагменте кода список повторяется с использованием функции range (), которая проходит через 0 (ноль) до длины определенного списка .

Выход:

10
50
75
83
98
84
32
 

2. Перебор списка в Python с помощью цикла for

Python for loop может использоваться для прямого перебора списка.

Синтаксис:

для var_name в input_list_name:
 

Пример:

lst = [10, 50, 75, 83, 98, 84, 32]


для x в lst:
печать (х)

 

Выход:

10
50
75
83
98
84
32
 

3.Понимание списка для перебора списка в Python

Python List Computing - это безразличный способ создания списка элементов, которые обладают определенным свойством или спецификацией, т.е. он может определить, является ли ввод списком, строкой, кортежем и т. Д.

Синтаксис:

[выражение / инструкция для элемента в input_list]
 

Пример:

lst = [10, 50, 75, 83, 98, 84, 32]

[print (x) вместо x в lst]

 

Выход:

10
50
75
83
98
84
32
 

4.Перебор списка в Python с циклом while

Python цикл while также может использоваться для итерации списка аналогично циклам for.

Синтаксис:

while (условие):
утверждение
        update_expression

 

Пример:

lst = [10, 50, 75, 83, 98, 84, 32]

х = 0

# Итерация с использованием цикла while
в то время как x 


 

Выход:

10
50
75
83
98
84
32
 

5.Python NumPy для перебора списка в Python

Python NumPy Arrays также можно использовать для эффективного перебора списка.

Функция Python numpy.arange () создает однородную последовательность целых чисел.

Синтаксис для функции numpy.arange ():

numpy.arange (запуск, остановка, шаг)
 
  • начало : этот параметр используется для предоставления начального значения / индекса для последовательности целых чисел, которая будет сгенерирована.
  • stop : этот параметр используется для предоставления конечного значения / индекса для последовательности целых чисел, которая будет сгенерирована.
  • шаг : Он обеспечивает разницу между каждым целым числом из последовательности, которая должна быть сгенерирована.

numpy.nditer (numpy_array) - это функция, которая предоставляет нам итератор для обхода массива NumPy.

Пример:

импортировать numpy как np

n = np.arange (16)

 
для x в np.nditer (n):
печать (х)

 

В приведенном выше фрагменте кода np.arange (16) создает последовательность целых чисел от 0 до 15.

Выход:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 

6. Метод Python enumerate () для перебора списка Python

Функция Python enumerate () может использоваться для оптимизированного перебора списка.

Функция enumerate () добавляет счетчик к списку или любому другому итерируемому объекту и возвращает его как объект перечисления функцией.

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

Синтаксис:

перечислить (итерация, начальный_индекс)
 
  • start_index : это индекс элемента, с которого должен быть записан счетчик для итеративного итеративного.

Пример:

lst = [10, 50, 75, 83, 98, 84, 32]

для x, res in enumerate (lst):
print (x, ":", res)

 

Выход:

0: 10
1: 50
2: 75
3: 83
4: 98
5: 84
6: 32
 

7.Итерация списка Python с использованием лямбда-функции

Лямбда-функции Python в основном анонимные.

Синтаксис:

лямбда-параметры: выражение
 
  • выражение : Итерация, которую нужно вычислить.

Лямбда-функцию вместе с функцией Python map () можно использовать для простого перебора списка.

Python map () метод принимает функцию в качестве параметра и возвращает список.

Функция input для метода map () вызывается с каждым элементом итерации и возвращает новый список со всеми элементами, возвращенными из функции, соответственно.

Пример:

lst = [10, 50, 75, 83, 98, 84, 32]

res = список (карта (лямбда x: x, lst))

печать (разрешение)

 

В приведенном выше фрагменте кода лямбда-функция x: x предоставляется в качестве входных данных для функции map (). Лямбда x: x примет каждый элемент итерации и вернет его .

input_list ( lst ) предоставляется как второй аргумент функции map (). Итак, функция map () передаст каждый элемент lst в функцию лямбда x: x и вернет элементы.

Выход:

[10, 50, 75, 83, 98, 84, 32]
 

Заключение

В этой статье. мы представили различные методы итерации списка Python.


Список литературы

Infinity в Python - представление бесконечного числа в Python

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

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

Бесконечность в Python

В Python нет способа или метода представления бесконечности как целого числа.Это соответствует фундаментальной характеристике многих других популярных языков программирования. Но поскольку python является динамически типизированным языком, вы можете использовать float (inf) как целое число, чтобы представить его как бесконечность.

Следовательно, в python мы не можем представить бесконечность или можем сказать, что нет способа показать бесконечность как целое число. Но мы можем использовать float (inf) как целое число.

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

  • Положительная бесконечность: бесконечность
  • Отрицательная бесконечность: -inf

Программа Python для определения положительного и отрицательного числа бесконечности

Пример

  # Определить число положительной бесконечности
ptive_inf = float ('inf')
print ('Положительная бесконечность:', ptive_inf)

# Определить отрицательное бесконечное число
ntive_inf = float ('- inf')
print ('Отрицательная бесконечность:', ntive_inf)  

Выход

  Положительная бесконечность: бесконечность
Отрицательная бесконечность: -inf  

Представление положительной и отрицательной бесконечности с помощью математического модуля

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

Примечание: Это будет работать только с python 3.5 или выше версии python.

Синтаксис:

  • Положительная бесконечность: math.inf
  • Отрицательная бесконечность: -math.inf

Пример:

  # Импортировать математический модуль
импорт математики

# Положительная бесконечность
ptive_inf = math.inf
print ('Положительная бесконечность:', ptive_inf)

# Отрицательная бесконечность
ntive_inf = -математика.инф
print ('Отрицательная бесконечность:', ntive_inf)  

Выход

  Положительная бесконечность: бесконечность
Отрицательная бесконечность: -inf  

Положительное бесконечное число - наибольшее, и отрицательное бесконечное число - наименьшее из всех чисел.

Для сравнения: положительная бесконечность всегда больше любого натурального числа.

(т.е. 0,1,2, .......... + ∞. Положительное целое число и + бесконечность.)

Для сравнения, отрицательная бесконечность меньше отрицательного числа.

(т.е. ∞ -.......- 2, -1,0, 1, .2,3 ......... - отрицательная бесконечность и -целое число.)

Пример:

  # Определить число положительной бесконечности
ptive_inf = float ('inf')

если 99999999999999999> ptive_inf:
print ('Число больше положительной бесконечности')
еще:
print ('Положительная бесконечность больше')

# Определить отрицательное бесконечное число
ntive_inf = float ('- inf')

если -99999999999999999> ptive_inf:
print ('Число меньше отрицательной бесконечности')
еще:
print ('Отрицательная бесконечность меньше')  

Выход

  Положительная бесконечность больше
Отрицательная бесконечность меньше  

Программа Python для проверки бесконечности числа

Пример:

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

# Определить положительное бесконечное число
ptive_inf = float ('inf')
print ('Переменная бесконечна:', math.isinf (ptive_inf))

# Определить отрицательное бесконечное число
ntive_inf = float ('- inf')
print ('Переменная бесконечна:', math.isinf (ntive_inf))
Щелкните и перетащите, чтобы переместить  

Выход:

  Переменная бесконечность: Истина
Переменная бесконечность: True  

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

Представление положительной и отрицательной бесконечности с помощью десятичного модуля

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

Синтаксис:

  • Положительная бесконечность: десятичная дробь (бесконечность)
  • Отрицательная бесконечность: десятичная дробь ('- бесконечность')

Пример:

  из десятичного числа Импорт Десятичный
импорт математики

# Определить положительную бесконечность
ptive_inf = десятичный ('бесконечность')
print ('Переменная бесконечна:', math.isinf (ptive_inf))

# Определить отрицательную бесконечность
ntive_inf = десятичный ('- бесконечность')
print ('Бесконечная переменная:', math.isinf (ntive_inf))
Щелкните и перетащите, чтобы переместить  

Выход:

  Переменная бесконечность: Истина
Переменная бесконечность: True  

Представьте положительную и отрицательную бесконечность с помощью библиотеки Numpy

Вы можете определить положительную и отрицательную бесконечность с помощью модуля inf библиотеки NumPy

Синтаксис:

  • Положительная бесконечность: np.inf
  • Отрицательная бесконечность: -np.инф

Пример:

  импортировать numpy как np
импорт математики

# Определить положительное число бесконечности
ptive_inf = np.inf

# Проверяем бесконечное число
print ('Положительное бесконечное число:', ptive_inf)

# Определить отрицательное число бесконечности
ntive_inf = -np.inf

# Проверяем бесконечное число
print ('Отрицательное бесконечное число:', ntive_inf)  

Выход:

  Число положительной бесконечности: inf
Число отрицательной бесконечности: -inf  

Проверить, равно ли положительное число бесконечности числу отрицательной бесконечности

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

Пример:

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

# Определить положительное бесконечное число
ptive_inf = float ('inf')

# Определить отрицательное бесконечное число
ntive_inf = float ('- inf')

print ('Положительная бесконечность равна отрицательной бесконечности:', ptive_inf == ntive_inf)  

Выход:

  Положительная бесконечность равна отрицательной бесконечности: ложь  

Арифметические операции с бесконечным числом дают бесконечное число

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

Пример:

  # Определить положительное бесконечное число
ptive_inf = float ('inf')

# Умножение положительного числа бесконечности на 5
print ('Умножение:', ptive_inf * 5)

# Добавление к положительному числу бесконечности
print ('Дополнение:', ptive_inf + 5)

# Вычитание до положительной бесконечности Number
print ('Вычитание:', ptive_inf - 5)

# Деление на положительную бесконечность Число
print ('Деление:', ptive_inf / 5)

# Определить отрицательное бесконечное число
ntive_inf = float ('- inf')

# Умножаем отрицательное число бесконечности на 5
print ('Умножение:', ntive_inf * 5)

# Дополнение к отрицательному числу бесконечности
print ('Дополнение:', ntive_inf + 5)

# Вычитание до отрицательной бесконечности Число
print ('Вычитание:', ntive_inf - 5)

# Деление на отрицательную бесконечность Число
print ('Подразделение:', ntive_inf / 5)  

Выход:

  Умножение: inf
Дополнение: inf
Вычитание: inf
Подразделение: inf
Умножение: -inf
Дополнение: -inf
Вычитание: -inf
Деление: -inf
  

Совет Python: проверка введенных пользователем чисел (целых)

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

Для этого вы можете использовать функцию input () : например,

username = input («Какое ваше имя пользователя?»)

username = input («Какое у вас имя пользователя?»)

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

age = int (input («Сколько вам лет?»))

age = int (input («Сколько вам лет?»))

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

Чтобы проверить ввод пользователя и убедиться, что это номер, можно перехватить это исключение , когда оно возникает, с помощью блока try… except… .else следующим образом:

пытаться: value = int (input ("Введите число:")) кроме ValueError: print («Это не целое число.»)

try:

value = int (input ("Введите число:"))

except ValueError:

print ("Это не целое число.")

Посмотрите, как мы можем использовать этот подход для определения нашей собственной функции (называемой inputNumber () ) для запроса числа. Затем эту новую функцию можно использовать вместо функции input () всякий раз, когда мы ожидаем, что пользователь введет целое число. Эта функция использует блок try… except… .else внутри цикла while , так что он продолжает просить пользователя ввести число, пока пользователь не поймет его правильно.

Окончательный код:

def inputNumber (сообщение): в то время как True: пытаться: userInput = int (ввод (сообщение)) кроме ValueError: print ("Не целое! Попробуйте еще раз.

Оставить комментарий

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *