Как вводить нецелые числа в питоне

Python поддерживает все распространенные арифметические операции:

print(6 + 2) # 8

print(6 - 2) # 4

print(6 * 2) # 12

print(6 / 2) # 3.0

print(7 / 2) # 3.5 print(7 // 2) # 3

print(6 ** 2) # Возводим число 6 в степень 2. Результат - 36

print(7 % 2) # Получение остатка от деления числа 7 на 2. Результат - 1

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

Пусть у нас выполняется следующее выражение:

number = 3 + 4 * 5 ** 2 + 7 print(number) # 110

Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).

Чтобы переопределить порядок операций, можно использовать скобки:

number = (3 + 4) * (5 ** 2 + 7) print(number) # 224

Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.

Арифметические операции с присвоением

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

+= Присвоение результата сложения
-= Присвоение результата вычитания
*= Присвоение результата умножения
/= Присвоение результата от деления
//= Присвоение результата целочисленного деления
**= Присвоение степени числа
%= Присвоение остатка от деления

number = 10 number += 5 print(number) # 15 number -= 3 print(number) # 12 number *= 4 print(number) # 48

Округление и функция round

При операциях с числами типа float надо учитывать, что результат операций с ними может быть не совсем точным. Например:

first_number = 2.0001 second_number = 5 third_number = first_number / second_number print(third_number) # 0.40002000000000004

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

print(2.0001 + 0.1) # 2.1001000000000003

В случае выше для округления результата мы можем использовать встроенную функцию round() :

first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number)) # 2

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

Функция round() также может принимать второе число, которое указывает, сколько знаков после запятой должно содержать получаемое число:

first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number, 4)) # 2.1001

В данном случае число third_number округляется до 4 знаков после запятой.

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

# округление до целого числа print(round(2.49)) # 2 - округление до ближайшего целого 2 print(round(2.51)) # 3

Однако если округляемая часть равна одинаково удалена от двух целых чисел, то округление идет к ближайшему четному:

print(round(2.5)) # 2 - ближайшее четное print(round(3.5)) # 4 - ближайшее четное

Округление производится до ближайшего кратного 10 в степени минус округляемая часть:

# округление до двух знаков после запятой print(round(2.554, 2)) # 2.55 print(round(2.5551, 2)) # 2.56 print(round(2.554999, 2)) # 2.55 print(round(2.499, 2)) # 2.5

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

# округление до двух знаков после запятой print(round(2.545, 2)) # 2.54 print(round(2.555, 2)) # 2.56 - округление до четного print(round(2.565, 2)) # 2.56 print(round(2.575, 2)) # 2.58 print(round(2.655, 2)) # 2.65 - округление не до четного print(round(2.665, 2)) # 2.67 print(round(2.675, 2)) # 2.67

Подобно о проблеме можно почитать к документации.

Вопросы для самопроверки
Упражнения для самопроверки

Как написать программу, которая выводит ошибку при вводе не целочисленного числа? Python

Введите строку, попытайтесь преобразовать в целое, если не вышло впишите в переменную None — признак неудачи:

s = input() try: i = int(s) except ValueError: i = None if isinstance(i, int): print('YES') else: print('NO')

Отслеживать
ответ дан 30 авг 2022 в 17:39
Stanislav Volodarskiy Stanislav Volodarskiy
32.7k 3 3 золотых знака 20 20 серебряных знаков 56 56 бронзовых знаков
Благодарю. Не успел познакомиться с некоторыми свойствами.
31 авг 2022 в 6:46

Если вы хотите принимать любые числа, то можно поступить так:

a = input() try: int(a) except ValueError: a = None if a is None: print('NO') else: print('YES')

Если же вы хотите принимать только положительные числа можно сделать код легче:

a = input() if a.isdigit(): print('YES') else: print('NO')

Если же хотите числа с плавающей точкой использовать тоже, то в третьей строчке первого фрагмента кода int(a) замените на float(a) .

Числа в Python и методы работы с ними

В Python, как и во всех популярных языках программирования, имеются целые числа (int) и числа с плавающей точкой (float). Но у Python есть и отличительная особенность – комплексные числа (complex).

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

str1 = '1' str2 = '2' num1 = 1 num2 = 2 print(str1+str2) # Выведет '12' print(num1+num2) # Выведет 3

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

В Python, как и в привычной нам математике, целыми числами являются все числа, которые лишены дробной части, то есть не имеют плавающей точки. Рассмотрим на примере:

num1 = 1 num2 = 2 # Присваиваем переменным целые числа print(num1, num2) # Выведет 1 2

Для упрощения создания больших чисел в Python используется нижнее подчеркивание, а не запятая. Пример:

num = 999_999_999 print(num) # Выведет 999999999 num = 999,999,999 print(num) # Выдаст ошибку

Комьюнити теперь в Телеграм
Подпишитесь и будьте в курсе последних IT-новостей

Числа с плавающей точкой (float)

Для отделения целой части числа в Python используется точка. Рассмотрим создание float-числа на примере:

num1 = 0.1 num2 = 0.22 # Присваиваем переменным целые числа print(num1, num2) # Выведет 0.1 0.22

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

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

# создание и сложение двух комплексных чисел num1 = 1 + 2j num2 = 2 + 4j summa = num1 + num2 print(summa) # Выведет (3+6j)

Проверка типа данных переменной

Для проверки типа данных переменной в Python используется встроенная функция type(). Рассмотрим на примере:

str = ‘1’ int = 1 float = 1.1 com1 = 1 + 2j com2 = 2 + 4j complex = com1 + com2 print(type(str)) # Выведет print(type(int)) # Выведет print(type(float)) # Выведет print(type(complex)) # Выведет

Арифметические действия в Python

Сложение делается с помощью оператора “+”. Пример:

a = 1 + 1 print(a) # Выведет 2

С помощью сложения можно преобразовать целое число в число с плавающей точкой. Рассмотрим на примере:

a = 1 + 1.0 print(a) # Выведет 2.0

Вычитание выполняется с помощью оператора “—”. Пример:

a = 1 - 1 print(a) # Выведет 0

Умножение делается с помощью оператора “*”:

a = 2 * 2 print(a) # Выведет 4

Возведение в степень выполняется с помощью оператора “**”. Пример:

a = 2**3 print(a) # Выведет 8

Также возведение в степень можно производить с помощью функции pow():

num1 = 2 num2 = 3 print(pow(num1, num2)) # Выведет 8

Деление выполняется с помощью оператора “/”. Пример:

a = 4 / 2 print(a) # Выведет 2

Для получения остатка от деления используется оператор “%”. Пример:

a = 5 % 2 print(a) # Выведет 1

Целочисленное деление выполняется с помощью оператора “//”. Пример:

a = 5 // 2 print(a) # Выведет 2

Округление чисел с плавающей точкой

Для округления float-чисел до ближайшего целого числа используется функция round(). Рассмотрим на примере:

num1 = 1.4 num2 = 1.6 print(round(num1)) # Выведет 1 print(round(num2)) # Выведет 2

Получение модуля числа

Для получения модуля любого числа мы можем использовать функцию abs(). Рассмотрим на примере:

num1 = -2 num2 = 3 print(abs(num1)) # Выведет 2 print(abs(num2)) # Выведет 3

Вывод

Мы разобрали функции для работы с числами в Python и научились ими пользоваться. Надеюсь, эта статья оказалась для вас полезной. Удачи в ваших начинаниях!

ТИПЫ ДАННЫХ В PYTHON

Кроме того, к базовым типам также относятся логический тип и тип NoneType.

Числа

Тип данных Числа имеет в Python три вида:

Целые числа

Примеры записи целых десятичных чисел:

5 20 856 57557253

Двоичные числа записывают с префиксом 0b.

Примеры записи целых двоичных чисел:

0b101 0b10100

Восьмиричные числа записывают с префиксом 0o.

Примеры записи целых восьмиричных чисел:

Шестнадцатиричные числа записывают с префиксом 0x.

Примеры записи целых шестнадцатиричных чисел:

0x5 0x14 0x4fd

Дробные числа

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

Примеры записи дробных чисел:

0.5 3.14 65.728

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

Мнимая часть комплексного числа записывается с помощью постфикса j.

Примеры записи комплексных чисел:

2 + 3j 3.7 + 0.5j 45 + 0j

Строки

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

Каждый символ в строке имеет свой индекс (номер). Нумерация начинается с нуля.

Примеры записи строк:

«Hello»
‘я люблю Python’

Списки

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

Элементы списка не обязательно должны быть одного типа. Элементом списка может быть даже другой список.

Списки в Python записываются в квадратных скобках. Каждый элемент в списке имеет свой индекс (номер). Нумерация начинается с нуля.

[2, 5, 3, 7]
[5, 3.2, ‘apple’, ‘orange’]
[7, 3, [4, 2], 9]

Кортежи

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

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

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

(5, 8, 2, 3)
(7, 9.3, ‘gold’, ‘silver’)
(7, 3, [4, 5], 9)

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

Множества

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

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

Множества удобны тем, что с ними можно выполнять операции объединения, пересечения, вычитания, сравнения (находить элементы множества, отсутствующие в другом множестве, или находить элементы множества, присутствующие в другом множестве).

Множества в Python записываются в фигурных скобках.

Элементами множества могут быть числа, строки, кортежи, но не могут быть списки, множества или словари.

Словари

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

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

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

Словари в Python записываются в фигурных скобках.

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

x = print(x)

Логический тип

Логический тип (boolean) имеет два значения: истина (True) и ложь (False).

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

True
False

Тип NoneType

Тип NoneType в Python принимает значение None, которое идентично значению Null в других языках программирования.

Проверка типа

Узнать тип объекта можно с помощью функции type().

Создадим строковый объект и напечатаем его тип.

a = 'wire' print(type(a))

Проверить тип объекта можно с помощью функции isinstance(). Функция принимает два аргумента: имя объекта и название типа. Если тип объекта и название типа совпадают, то функция возвратит логическое значение True, если не совпадают, то возвратит False.

Создадим целочисленный объект и напечатаем результат, возвращаемый функцией isinstance().

a = 5 print(isinstance(a, int))

True

Попробуем еще.

a = [5, 10, 20] print(isinstance(a, list))

Как вводить нецелые числа в питоне