Деление в Python
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
Проверка простоты числа перебором делителей
Простые числа — это натуральные числа больше единицы, которые делятся нацело только на единицу и на себя. Например, число 3 простое, так как нацело делится только на 1 и 3. Число 4 сложное, так как нацело делится не только на 1 и 4, но также на число 2.
Алгоритм перебора делителей заключается в последовательном делении заданного натурального числа на все целые числа, начиная с двойки и заканчивая значением меньшим или равным квадратному корню из тестируемого числа. Таким образом, в данном алгоритме используется цикл, счетчик итераций которого последовательно принимает значения ряда натуральных чисел от 2 до корня из исследуемого числа.
Перебор делителей применяется в том числе для определения, является ли натуральное число простым, или оно является сложным, то есть составным. Касаемо данной задачи, если хотя бы один делитель делит исследуемое число без остатка, то оно является составным. Если ни одного такого делителя не находится, то число признается простым.
from math import sqrt n = int(input()) prime = True i = 2 while i sqrt(n): if n % i == 0: prime = False break i += 1 if prime: print("Простое число") else: print("Составное число")
В программе мы сначала предполагаем, что введенное число n является простым, и поэтому присваиваем переменной prime значение True . Далее в цикле перебираются делители (переменная i ) от 2-х до квадратного корня из числа n . Как только встречается первый делитель, на который n делится без остатка, меняем значение prime на False и прерываем работу цикла, так как дальнейшее тестирование числа на простоту смысла не имеет.
Если после выполнения цикла prime осталась истиной, сработает ветка if условного оператора. В случае False , поток выполнения заходит в ветку else .
Если знать о такой особенности циклов в Python как возможность иметь ветку else , то код можно упростить, избавившись от переменной prime и ее проверки условным оператором после завершения работы цикла.
from math import sqrt n = int(input()) i = 2 while i sqrt(n): if n % i == 0: print("Составное число") break i += 1 else: print("Простое число")
Ветка else при циклах (как while , так и for ) срабатывает, если в основном теле цикла не происходило прерывания с помощью break . Если break сработал, то тело else выполняться не будет. При использовании таких конструкций также следует помнить, что если условие в заголовке цикла сразу возвращает ложь (то есть тело цикла не должно выполняться ни разу), код тела else все-равно будет выполнен.
Программы выше будут определять числа 0 и 1 как простые. Это неправильно. Данные числа не являются ни простыми, ни сложными. Для проверки ввода пользователя, можно воспользоваться условным оператором или зациклить запрос числа, пока не будет введено корректное значение:
n = 0 while n 2: n = int(input())
Рассмотрим функцию, которая определяет, является ли число простым:
from math import sqrt def is_prime(n): i = 2 while i sqrt(n): if n % i == 0: return False i += 1 if n > 1: return True a = int(input()) if is_prime(a): print("Простое число") else: print("Число НЕ является простым")
Здесь нет необходимости в прерывании работы цикла с помощью break , так как оператор return выполняет выход из тела всей функции.
Если цикл полностью отработал, выполнится выражение return True , находящееся ниже цикла. Оно помещено в тело условного оператора, чтобы исключить возврат «истины», когда в функцию передаются числа 0 или 1. В этом случае функция вернет объект None .
Программа не защищена от ввода отрицательного числа. При этом будет генерироваться ошибка на этапе извлечения квадратного корня.
Нарисуем блок-схему тестирования числа на простоту (без дополнительных проверок и оператора break ):
from math import sqrt n = int(input()) prime = True i = 2 while i sqrt(n) and prime is True: if n % i == 0: prime = False i += 1 if prime: print("Простое число") else: print("Составное число")
—>
X Скрыть Наверх
Решение задач на Python
Python задачи. Проверка делимости одного числа на другое
1) Если первое число нацело делится на второе, то вывести сообщение об этом.
2) Иначе вывести сообщение о том, что первое число не делится на второе, найти остаток от деления и также вывести его.
3) В конце программы найти частное от деления чисел и вывести его.
Код задачи на языке программирования python
a = int(input(‘Введите число 1 -‘))
b = int(input(‘Введите число 2 -‘))
. print(‘Делится без остатка’)
. print(‘Не делится,’,’ ‘,’Остаток — ‘,(a%b))
Как проверить что число делится без остатка питон
7. Деление нацело и деление по остатку
8. Функции trunc, floor, ceil
9. Деление нацело и по остатку отрицательных чисел в Python
10. Логический тип Bool. Операции сравнения
11. Cтроки и операции над ними
12. Строки: индексы и срезы
13. Строки и их методы
14. Списки и операции над ними
15. Списки: индексы и срезы
Деление нацело и деление по остатку
Давайте начнем с деления нацело. В Python данная операция обозначается знаком двойного слеша //. И допустим если вам надо нацело поделить a на b (a//b), нужно ответить на вопрос:
«Cколько раз второе число (в нашем случае b) умещается в первое?» (подробности в видео)
И попробуйте посчитать примеры ниже. Нажав на кнопку треугольника вы увидите правильные ответы
Остаток от деления в Python обозначается знаком процента %. Чтобы посчитать, вы должны ответить на вопрос:
«Сколько останется от первого числа после того, как в него максимальное количество раз уместится второе число?»(подробности в видео)
И ниже на примерах проверьте правильно ли вы определяете остаток от деления