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

Вычисления

Вы считаете, что арифме­тиче­ские операции — это просто? Пересчитайте. На самом деле, всё не так страшно, но рас­слабляться не стоит. Начнём со всем знакомой чет­вер­ки:

print ( 10 + 10 )
# 10
print ( 10 — 5 )
# 5
print ( 11 * 7 )
# 77
print ( 10 / 2 )
# 5.0

Никаких неожиданностей, правда? Не совсем, посмотрите внимательно на операцию деле­ния. Заметили? Мы разделили целое число на его делитель, но несмотря на это, результат имеет тип float. Взглянем на операцию деления чуть более пристально:

print ( 10 / 2 )
# 5.0
print ( 100 / 3 )
# 33.333333333333336
print ( 21 / 4 )
# 5.25
print ( 23 / 7 )
# 3.2857142857142856

Иногда можно увидеть такие приколы:

print ( 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 )
# 0.7999999999999999
print ( 0.1 + 0.2 )
# 0.30000000000000004
print ( 7 / 3 )
# 2.3333333333333335

Еще немного математики. Математика в каждый дом!

# Возведение в степень
print ( 10 * * 2 )
# 100
print ( 2 * * 4 )
# 16
print ( 3 * * 0.5 )
# 1.7320508075688772
print ( 3 * * -2 )
# 0.1111111111111111
# Остаток от деления
print ( 11 % 4 )
# 3
print ( 101 % 7 )
# 3
print ( 34 % 5 )
# 4
# Деление нацело
print ( 20 // 4 )
# 5
print ( 129 // 11 )
# 11
print ( 100 // 61 )
# 1

Операции сравнения в python

Операции сравнения в отличие от арифметические имеют всего два результата: True и False. Чаще всего такие операции используются в условии циклов, условных оператов, а также в некоторых функциях, например, filter.

# Операция равенства: True, если X равен Y
print ( 10 == 10 )
# True
print ( 666 == 661 )
# False
# Операция неравенства: True, если X не равен Y
print ( 666 != 661 )
# True
print ( 666 != 666 )
# False
# Операция больше: True, если X больше Y
print ( 120 > 2 )
# True
print ( 1000 > 1999 )
# False
# Операция меньше: True, если X меньше Y
print ( 121 120 )
# False
print ( 0 1 )
# True
# Операция меньше или равно: True, если X меньше или равен Y
print ( 6 6 )
# True
print ( 5 2 )
# False
# Операция больше или равно: True, если X больше или равен Y
print ( 1000 >= 10000 )
# False
print ( 9999 >= 9999 )
# False

Логические операции

Логические операции, как и операции сравнения, имеют всего два возможных результата: True и False. Используются для объединения операций сравнения в условиях циклов и условных оператов

# Оператор «and» или конъюнкция.
# True, если и выражение X, и выражение Y равны True
print ( 10 == 10 and 10 > 2 )
# True
print ( 666 == 661 and 9 > 0 )
# False
# Оператор «or» или дизъюнкция.
# True, если или выражение X, или выражение Y равны True
print ( 666 == 661 or 9 > 0 )
# True
print ( 666 == 661 or 9 0 )
# False
# Оператор » not » или инверсия меняет значение на противоположное.
# True, если выражение X равно False
print ( not 120 > 2 )
# False
print ( not 1000 999 )
# True
print ( not ( 121 121 and 10 == 2 ))
# True

Округление чисел в python

Всё дело в округлении! В python есть несколько заме­ча­тель­ных функций, которые округ­ляют число до указанного знака. Одной из таких функций является round :

pi = 3.14159265358979323846264338327
print ( round (pi, 1 ))
# 3.1
print ( round (pi, 2 ))
# 3.14
print ( round (pi, 3 ))
# 3.12
print ( round (pi, 4 ))
# 3.1416
print ( round (pi, 10 ))
# 3.1415926536
print ( round (pi, 15 ))
# 3.141592653589793

Рассмотрим любопытный пример:

print ( round ( 2.5 ))
# 2
print ( round ( 3.5 ))
# 4

Если на вашем лице застыл немой вопрос: «почему?», то я вас понимаю. В школе нас учили, что дроби 1.1, 1.2, 1.3, 1.4 округляются до единицы, а 1.5, . 1.9 до двойки. Но python думает по-другому. Есть два типа округления: арифметическое и банковское. Именно арифметическому округлению вас учили в школе. Python использует как раз-таки банковское округление, его еще называют округлением до ближайшего четного. Приведу еще несколько примеров:

print ( round ( 10.51213 ))
# 11
print ( round ( 23.5 ))
# 24
print ( round ( 22.5 ))
# 22

Примеры решения задач

Есть N оранжевых конфет и K учеников, сколько достанется каждому из них, если разделить их поровну? Сколько конфет останется после дележа?

n = int ( input ( ‘Введите количество конфет: ‘ ))
k = int ( input ( ‘Введите количество учеников: ‘ ))
a = n // k
b = n % k
print ( ‘Каждому по’ , a)
print ( ‘Осталось’ , b)

Даны стороны прямоугольника a и b. Вычислите периметр, площадь и диагональ прямоугольника.

a = int ( input ( ‘Введите a: ‘ ))
b = int ( input ( ‘Введите b: ‘ ))
s = a * b
p = 2 * (a + b)
d = (a * * 2 + b * * 2 ) * * 0.5
print ( ‘Площадь:’ , a)
print ( ‘Периметр:’ , b)
print ( ‘Диагональ:’ , c)

Дано число секунд n на секундомере. Посчитайте прошедших минут и секунд.

n = int ( input ( ‘Введите n: ‘ ))
m = n // 60
s = n % 60
print ( str (m) + ‘:’ + str (s))

Решение задач

1. Дано целое число A. Проверить истинность высказывания: «Число A является четным».

2. Дано целое число A. Проверить истинность высказывания: «Число A является нечетным».

3. Даны два целых числа: A, B. Проверить истинность высказывания: «Числа A и B имеют одинаковую четность».

4. Даны три целых числа: A, B, C. Проверить истинность высказывания: «Хотя бы одно из чисел A, B, C положительное».

5. Дано четырехзначное число. Проверить истинность высказывания: «Данное число читается одинаково слева направо и справа налево».

6. Дано число секунд n на часах. Посчитайте прошедших часов, минут и секунд.

7. Дано натуральное число. Выведите его последнюю цифру.

8. Дано положительное действительное число X. Выведите его дробную часть.

9. Дано положительное действительное число X. Выведите его первую цифру после десятичной точки.

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

11. Дано натуральное число. Найдите число десятков в его десятичной записи.

12. Дано двузначное число. Найдите сумму его цифр.

13. Дано трехзначное число. Найдите сумму его цифр.

14. Дано трехзначное число. Проверить истинность высказывания: «Все цифры данного числа различны».

15. Дано трехзначное число. Проверить истинность высказывания: «Цифры данного числа образуют возрастающую или убывающую последовательность».

16. С начала суток прошло N секунд (N — целое). Найти количество часов, минут и секунд на электронных часах.

Как определять четырехзначные числа

Пользователь вводит целое число. Проверьте является ли это число четырехзначным, если да, то вывести «Успешно», иначе «Неудача».

num = int(input(«Введите число:»))
if num//1000:
print(«Успешно»)
else:
print(«Неудача»)

Вроде бы с трехзначными пишет «Неудача», а вот с пятизначными и выше все равно пишет «Успешно»

Лучший ответ
if int(math.log10(n)) == 3.
Остальные ответы
if num > 999 && num < 10000: dkdkkp weeepУченик (99) 2 года назад
До этого я догадался, можно ли сделать так же, только через деление с остатком?

Миха Никитин Ученик (90) dkdkkp weeep, Можно, например, так: if num // 1000 != 0 && num // 10000 == 0: Проверяем, если делится на 1000, но не делится на 10000, то четырёхзначное.

if 1000 <= num <= 9999: #Можно так:
if len(str(abs(n))) == 4:
#Или так:
if 999 < abs(n) < 10000:
#Взятие модуля обязательно!. ｡◕‿◕｡

r = str(input())
if len(r) == 4: 
print('Успешно')
else: 
print('Неудача')

Сумма и произведение цифр числа в Python

Сложить или перемножить цифры числа — задача, встречающаяся почти каждому программисту. Она позволяет не только проверить умение писать код и придумывать правильные алгоритмы, но и даёт возможность оценить синтаксис и функционал используемого языка.

Сумма цифр

Реализация программы на разных языках программирования мало чем отличается. Но из-за концепций и особенностей синтаксиса решение на языке Python получается более коротким и простым, чем, например, решение на C++.

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

num = int(input("Введите целое: ")) sum = 0 while (num != 0): sum = sum + num % 10 num = num // 10 print("Сумма цифр числа равна: ", sum)

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

Во второй строке объявляется переменная, в которую будет записываться сумма. Переменная обязательна должна быть равна нулю. Иначе полученная сумма будет отличаться от реальной (некоторые люди путают сложение и произведение чисел, поэтому пишут не ноль, а единицу).

В цикле while происходит суммирование цифр. В 4 строке программа получает младший разряд числа. Например, если число равно 125, программа получает 5. Полученный младший разряд прибавляется к переменной суммы.

Строка 5: использованный младший разряд отбрасывается (делится на 10), то есть если было 125, то станет 12. Обязательно необходимо использовать целочисленное деление, то есть деление без остатка, иначе цифра не отбросится, а уйдет в дробную часть результата.

В 6 строке программа выводит результат суммирования в консоль. Пример выполнения:

Введите целое: 555 Сумма цифр числа равна: 15

В этом примере мы посчитали с помощью Python сумму цифр трёхзначного числа 555.

Произведение цифр

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

num = int(input("Введите целое: ")) mult = 1 while (num != 0): mult = mult * (num % 10) num = num // 10 print("Произведение цифр равно: ", mult)

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

Важный момент, из-за того что оператор умножения имеет более высокий приоритет выполнения, чем оператор остатка от деления, выражение «num % 10» помещается в круглые скобки. Если не сделать этого, программа сначала будет умножать переменную mult на число и только потом брать от неё остаток.

Пример работы программы:

Введите целое: 55 Произведение цифр равно: 25

Частные случаи

Рассмотренные варианты программ являются самыми простыми. Однако существует ещё много частных случаев.

Число задано строкой

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

В рассмотренных скриптах эта проблема была решена следующим образом:

num = int(input("Введите целое: "))

Оператор input помещается в функцию int, которая преобразует полученную строку к целому числу. В некоторых случаях бывает удобнее не преобразовывать число сразу, а сделать это непосредственно перед вычислением. Пример такого случая представлен ниже.

Задано дробное

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

Рассмотрим программу для вычисления произведения цифр дробного числа (аналогично с суммой):

num = input("Введите дробное: ") # разделим введённое (тип данных строка) на две части x = num.split(".") a = int(x[0]) # целая часть b = int(x[1]) # дробная часть mult = 1 while (a != 0): # перемножаем числа целой части mult = mult * (a % 10) a = a // 10 while (b != 0): # перемножаем числа дробной части mult = mult * (b % 10) b = b // 10 print("Произведение цифр равно:", mult)

Пример выполнения программы:

Введите дробное: 55.5 Произведение цифр равно: 125

Эта программа правильно вычисляет произведение цифр любого числа:

Реализация программы специально была сделана через строки, с помощью функции split введённое число делится на дробную и целую части. Дробная часть обрабатывается также, как и целая.

При приведении к действительному

Подход, описанный выше выбран потому, что из-за неточного представления десятичных дробей в двоичном виде (в котором работает компьютер), реальное представление числа отличается от ожидаемого. В итоге, если пользователь вводит число 0.55, то если привести её к действительному числу с помощью float , в переменную записывается значение 0.54999…8. В итоге, результат получается неточным, если ограничить количество итераций цикла, либо цикл является бесконечным, пример:

num = float(input("Введите дробное: ")) # Преобразуем строку в дробное a = int(num) # целая часть, например, 5 b = num - int(num) # дробная часть, например, 0.55 print("a =", a) print("b =", b) mult = 1 while (a != 0): # перемножаем числа целой части mult = mult * (a % 10) a = a // 10 while (b != 0): # b никогда не будет равно 0 mult = mult * int(b*10) # 0.55 * 10 = 5.5, int(5.5) = 5 b = b * 10 - int(b * 10) print("Произведение цифр равно:", mult)

Если бы в переменной реально было бы записано значение 5.55, то программа работала бы нормально. Однако в переменную b на самом деле помещается 0,54999… Это приводит к бесконечному выделению и отбрасыванию старшего разряда.

Вот пример вывода полученной программы:

Введите дробное: 5.55 a = 5 b = 0.5499999999999998 Произведение цифр равно: 0

Программа вывела переменную b , как 0.5499999999999998, после умножения на 10, её значение уже будет равно 5.499999999999998. Если вычесть из этого числа 5, то получим 0.4999999999999982. На конце добавилась цифра 2!

Таким образом прошло много итераций и в итоге b стало равно 0. В ходе перемножений среди цифр из которых состояло b были и нули. Поэтому результат равен 0.

Решение модуля 4.1 Добрый, добрый Python

Модуль 4.1 Условный оператор if. Конструкция if-else.

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

# Получаем 2 строку и переводим в список a = list(map(float,input().split())) # Сравниваем 2 числа из списка под индексом 0 и 1 if a[0] > a[1]: print(a[0]) else: print(a[1])

Вводится слово. Необходимо определить, является ли это слово палиндромом (одинаково читается вперед и назад, например, АННА). Регистр букв не учитывать. Если введенное слово палиндром, на экран вывести ДА, иначе — НЕТ.

# Присваиваю исходное слово word_any = input() # С помощь метода .lower() перевожу символы в нижний регистр lower_simbols = word_any.lower() # Сравниваю слова обычное и слово перевёрнутое if lower_simbols == lower_simbols[::-1]: print('ДА') # Если слова одинаковые вывожу ДА else: print("НЕТ")# Иначе вывожу НЕТ

Вводятся два целых положительных числа m и n в одну строку через пробел. Если число m делится нацело на число n, то вывести на экран частное от деления (результат деления) в виде целого числа. В противном случае вывести сообщение «m на n нацело не делится» (без кавычек) и вместо m и n подставить соответствующие числа, например: «13 на 2 нацело не делится».

# Множественное присваивание m, n = map(int, input().split()) # Проверяем делится ли число на цело if m % n == 0: print(int(m/n)) # Выводим в консоль частное от деления else: print(f" на нацело не делится") # Иначе.

Вводятся три целых положительных числа в одну строку через пробел. Убедиться, что первые два числа — это катеты прямоугольного треугольника, а третье — его гипотенуза. (Подсказка: проверка делается по теореме Пифагора

). Если проверка проходит (истинна), то вывести на экран ДА, иначе — НЕТ.

# Множественное присваивание a, b, c = map(int, input().split()) # Проверяем выполнения условия задания # проверяем равна ли сумма квадратов стороны a и b, квадрату стороны c if c**2 == a**2 + b**2: print("ДА") # Если условие выполняет выводим ДА else: print("НЕТ")# Иначе выводим НЕТ

Вводится четырехзначное число. Проверить, что оно оканчивается на цифру 7. Вывести на экран ДА, если это так и НЕТ — в противном случае.

# Присваиваю данные в переменную list_num = list(input()) # Проверить, что оно оканчивается на цифру 7 # Преобразую из строкового значения в int обращаюсь к последнему элементу и сравниваю if int(list_num[-1]) == 7: print("ДА") # Если условие выполняется выводим ДА else: print("НЕТ") # Иначе выводим НЕТ

Вводится слово. Проверить, что в этом слове присутствуют все три буквы: t, h и o (в произвольном порядке). Реализовать программу с помощью одного условного оператора. Если проверка проходит, вывести ДА, иначе — НЕТ.

# Присваиваю данные в переменную list_symbol = list(input()) # Сохраняю кортеж с буквами tup = ('t', 'h', 'o') # Проверяю что в этом слове присутствуют все три буквы: t, h и o if 't' in list_symbol and 'h' in list_symbol and 'o' in list_symbol: print("ДА") # Если условие выполняется выводим ДА else: print("НЕТ") # Иначе выводим НЕТ

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

# Присваиваю данные в переменную list_word = list(input().split()) # Если в этом списке присутствует город Москва if 'Москва' in list_word: # то удаляю его с помощью метода .remove('Москва') list_word.remove('Москва') print(*list_word) # Вывожу результат в консоль else: print(*list_word) # Вывожу результат в консоль

Вводятся четыре целых числа a, b, c, d в одну строку через пробел. Определить, войдет ли в конверт с внутренними размерами a и b мм прямоугольная открытка с размерами с и d мм. Для размещения открытки в конверте необходим зазор в 1 мм с каждой стороны. Открытку можно поворачивать на 90 градусов. Вывести ДА, если входит и НЕТ — если не входит.

# Множественное присваивание с помощью функции map a, b, c, d = map(int, input().split()) # Определяю войдет ли открытка в конверт # Сравниваем стороны открытки чтобы соответствовали сторонам конверта # -1 мм, сравниваем по обоим сторонам if ((a-1) > c and (b-1) > d) or ((a-1) > d and (b-1) > c): print('ДА') # Вывожу результат в консоль else: print('НЕТ') # Вывожу результат в консоль

Вводится шестизначное число. Определить, является ли оно счастливым. (Счастливым называют такое шестизначное число, в котором сумма его первых трех цифр равна сумме его последних трех цифр.). Вывести ДА, если счастливое и НЕТ — в противном случае.

# Сохраняю данные в переменную в виде списка num_0 = list(input()) num_1 = list(map(int, num_0[:3])) # Сохраняю в первую переменную первые три цифра в списке num_2 = list(map(int, num_0[3:])) # Сохраняю во вторую переменную последние три цифры в списке # Проверяю равна сумма первых трех цифр, сумме его последних трех цифр if sum(num_1) == sum(num_2): print('ДА') # Если равна вывожу ДА else: print('НЕТ') # Если неравна вывожу НЕТ

Работа светофора для пешеходов запрограммирована следующим образом: в начале каждого часа в течение трех минут горит зеленый сигнал, затем в течение двух минут – красный, в течение трех минут – опять зеленый и т. д. Дано вещественное число t, означающее время в минутах, прошедшее с начала очередного часа. Определить, сигнал какого цвета горит для пешеходов в этот момент. На экран вывести сообщение (без кавычек) «green» — для зеленого и «red» — для красного.

# Сохраняю данные в переменную в виде списка time_signal = float(input()) # Проверяю Если таймер больше 0 и меньше 3 или остаток от деления введенного времени больше 0 и меньше 3 тогда светится зеленый if (time_signal > 0 and time_signal < 3) or (time_signal % 5 >0 and time_signal % 5 < 3): print('green') else: print('red') # Логика с первым все понятно если так как первые три минуты гори зеленый то это подпадает под условия задания. # Дальше Если при делении на 5 остаток о деления будет больше 0 но меньше трех, мы получаем значит светится зеленый сигнал светофора # 4 % 5 = 4

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