Составьте программу которая проверяет делится ли на 3 введенное целое число: Составьте программу, которая проверяет, делится ли на 3 введенные целое число, и выводит на экран соответствующее сообщение:

Создан 06 авг.

lang-bsh

Ваша конфиденциальность

Нажимая «Принять все файлы cookie», вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в ​​отношении файлов cookie.

Принимать все файлы cookie Настроить параметры

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

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

Чтобы понять этот пример, вы должны знать следующие темы программирования R:

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

Числа 2, 3, 5, 7, 11, 13 и т. Д. Являются простыми числами, поскольку у них нет других делителей.

Но, 6 не является простым (оно составное), поскольку 2 x 3 = 6 .

Пример: Проверить простое число

  # Программа для проверки, является ли введенное число простым или нет
# принять ввод от пользователя
число = как.целое число (readline (prompt = "Введите число:"))
flag = 0
# простые числа больше 1
if (num> 1) {
# проверить факторы
flag = 1
for (i in 2: (num-1)) {
if ((число %% i) == 0) {
flag = 0
перерыв
}
}
}
если (число == 2) флаг = 1
if (flag == 1) {
print (paste (num, «простое число»))
} еще {
print (paste (num, «не является простым числом»))
}
  

Выход 1

  Введите число: 25
[1] «25 - не простое число»
  

Выход 2

  Введите число: 19
[1] «19 - простое число»
  

Здесь мы берем целое число от пользователя и проверяем, простое оно или нет.Числа, меньшие или равные 1, не являются простыми числами.

Следовательно, мы продолжаем действовать только в том случае, если num больше 1. Мы проверяем, делится ли num в точности на любое число от 2 до num — 1.

Если мы найдем множитель в этом диапазоне, число не простое. В противном случае число простое.

Мы можем уменьшить диапазон чисел, в котором ищем факторы.

В приведенной выше программе наш диапазон поиска от 2 до num — 1.

Мы могли бы использовать диапазон, [2, num /2] или [2, num ** 0.5]. Более поздний диапазон основан на том факте, что составное число должно иметь множитель меньше квадратного корня из этого числа. В противном случае число простое.

Learning with Python 2nd Edition

4.1. Оператор модуля

Оператор модуля работает с целыми числами (и целочисленными выражениями) и дает остаток при делении первого операнда на второй.В Python Оператор модуля представляет собой знак процента (%). Синтаксис такой же, как и у других операторов:

 >>> частное = 7/3
>>> распечатать частное
2
>>> остаток = 7% 3
>>> напечатать остаток
1
 

Итак, 7, разделенное на 3, равно 2, и остается 1.

Оператор модуля оказался на удивление полезным. Например, вы можете проверить, делится ли одно число на другое — если x% y равно нулю, то x делится на y.

Кроме того, из числа можно извлекать самую правую цифру или цифры.Для Например, x% 10 дает крайнюю правую цифру x (по основанию 10). Аналогично x% 100 дает две последние цифры.

4.2. Логические значения и выражения

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

Есть только два логических значения : Истина и Ложь. Заглавные буквы важно, поскольку истина и ложь не являются логическими значениями.

 >>> тип (True)
<тип 'bool'>
>>> type (true)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя 'true' не определено
 

Логическое выражение — это выражение, вычисляющее логическое значение. Оператор == сравнивает два значения и выдает логическое значение:

 >>> 5 == 5
Правда
>>> 5 == 6
Ложь
 

В первом операторе два операнда равны, поэтому выражение оценивает к True; во втором утверждении 5 не равно 6, поэтому мы получаем False.

Оператор == является одним из операторов сравнения ; остальные:

 x! = Y # x не равно y
x> y # x больше y
x  = y # x больше или равно y
x <= y # x меньше или равно y
 

Хотя эти операции, вероятно, вам знакомы, символы Python отличается от математических символов. Распространенной ошибкой является использование одного знак равенства (=) вместо двойного знака равенства (==).Помните, что = - оператор присваивания, а == - оператор сравнения. Также есть нет таких вещей, как = <или =>.

4.3. Логические операторы

Есть три логических оператора : and, or, and not. В семантика (значение) этих операторов аналогична их значению в английском языке. Например, x> 0 и x <10 истинно, только если x больше 0 и . менее 10.

n% 2 == 0 или n% 3 == 0 истинно, если либо условий истинны, то есть, если число делится на 2 или 3.

Наконец, оператор not отменяет логическое выражение, поэтому not (x> y) истинно, если (x> y) ложно, то есть если x меньше или равно у.

4.4. Условное исполнение

Для того, чтобы писать полезные программы, нам почти всегда нужна возможность проверять условия и соответствующим образом измените поведение программы. Условный утверждения дают нам эту возможность. Самая простая форма - ** if выписка **:

, если x> 0:
    напечатайте "x положительно"
 

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

Синтаксис оператора if выглядит следующим образом:

, если БУЛЕВОЕ ВЫРАЖЕНИЕ:
    ЗАЯВЛЕНИЯ
 

То же, что и определение функции из предыдущей главы, и другое составное операторов, оператор if состоит из заголовка и тела. Заголовок начинается с ключевого слова, если за ним следует логическое выражение и заканчивается на двоеточие (:).

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

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

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

 if True: # Это всегда верно
    pass # так что это всегда выполняется, но ничего не делает
 

4,5. Альтернативное исполнение

Вторая форма оператора if - альтернативное выполнение, в котором есть две возможности, и условие определяет, какая из них будет выполнена. В синтаксис выглядит так:

, если x% 2 == 0:
    напечатайте x, "даже"
еще:
    напечатайте x, "нечетно"
 

Если остаток от деления x на 2 равен 0, то мы знаем, что x равен даже, и программа отображает сообщение об этом.Если условие false, выполняется второй набор операторов. Поскольку условие должно быть true или false, будет выполнена ровно одна из альтернатив. В альтернативы называются ответвлениями , потому что они являются ответвлениями в потоке исполнение.

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

 def print_parity (x):
    если x% 2 == 0:
        напечатайте x, "даже"
    еще:
        напечатайте x, "нечетно"
 

Для любого значения x print_parity отображает соответствующее сообщение.При его вызове в качестве аргумента можно указать любое целочисленное выражение.

 >>> print_parity (17)
17 странно.
>>> y = 41
>>> print_parity (y + 1)
42 чётно.
 

4.6. Связанные условные выражения

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

, если x  у:
    напечатайте x, "больше, чем", y
еще:
    напечатайте x, "и", y, "равны"
 

elif - это сокращение от else if.Опять же, ровно одна ветка будет выполнен. Нет ограничений на количество операторов elif, а есть только разрешен одиночный (и необязательный) оператор else, и он должен быть последним ветка в выписке:

, если choice == 'a':
    function_a ()
elif choice == 'b':
    function_b ()
elif choice == 'c':
    function_c ()
еще:
    print «Неверный выбор».
 

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

4,7. Вложенные условные выражения

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

, если x == y:
    напечатайте x, "и", y, "равны"
еще:
    если x 
 Внешнее условие содержит две ветви. Первая ветка содержит простой
оператор вывода.Вторая ветвь содержит еще один оператор if, который
имеет две собственные ветви. Эти две ветки являются операторами вывода,
хотя они тоже могли быть условными утверждениями.
 Хотя отступ операторов делает структуру очевидной, вложенные
условные выражения становятся трудными для чтения очень быстро. В целом хорошо
идея избегать их, когда это возможно.
 Логические операторы часто позволяют упростить вложенные условные
заявления. Например, мы можем переписать следующий код, используя один
условно:
, если 0 
 Оператор печати выполняется, только если мы проходим оба
условные, поэтому мы можем использовать оператор and:
, если 0 
 Такие условия являются обычными, поэтому Python предоставляет альтернативный синтаксис.
что похоже на математическое обозначение:
, если 0 
 Это условие семантически совпадает с составным логическим выражением и
вложенное условие.
 4.8. Заявление о возврате 
 Оператор return позволяет завершить выполнение функции.
прежде, чем вы дойдете до конца. Одна из причин его использования - обнаружение ошибки.
состояние:
 def print_square_root (x):
    если x <= 0:
        print "Только положительные числа, пожалуйста."
        возвращаться

    результат = x ** 0,5
    print "Квадратный корень из", x, "равно", результат
 
 Функция print_square_root имеет параметр с именем x. Первая вещь
он проверяет, меньше ли x или равно 0, и в этом случае он
отображает сообщение об ошибке, а затем использует return для выхода из функции.В
поток выполнения немедленно возвращается к вызывающему, а оставшиеся строки
функция не выполняется.
 4.9. Ввод с клавиатуры 
 В  Input  мы познакомились со встроенными функциями Python, которые позволяют
ввод с клавиатуры: raw_input и input. Теперь давайте посмотрим на эти
снова более подробно.
 При вызове любой из этих функций программа останавливается и ожидает
пользователь что-то напечатал. Когда пользователь нажимает клавишу Return или Enter,
программа возобновляет работу, и raw_input возвращает то, что пользователь ввел в виде строки:
 >>> my_input = raw_input ()
Чего ты ждешь?
>>> распечатать my_input
Чего ты ждешь?
 
 Перед вызовом raw_input рекомендуется распечатать сообщение, сообщающее
пользователь, что вводить.Это сообщение называется подсказкой  . Мы можем поставить
приглашение в качестве аргумента raw_input:
 >>> name = raw_input ("Как ... вас зовут?")
Как тебя зовут? Артур, король бриттов!
>>> напечатать имя
Артур, король бриттов!
 
 Обратите внимание на то, что приглашение является строкой, поэтому оно должно быть заключено в кавычки.
 Если мы ожидаем, что ответ будет целым числом, мы можем использовать функцию ввода
который оценивает ответ как выражение Python:
 prompt = "Что...это скорость полета порожней ласточки? \ n "
скорость = ввод (подсказка)
 
 Если пользователь вводит строку цифр, она преобразуется в целое число и
назначен на скорость. К сожалению, если пользователь вводит символы, которые не
составить допустимое выражение Python, программа выйдет из строя:
 >>> скорость = ввод (подсказка)
Какая ... скорость полета порожней ласточки?
Что значит африканская ласточка или европейская?
...
SyntaxError: недопустимый синтаксис
 
 В последнем примере, если пользователь сделал ответ действительным Python
выражение, заключив его в кавычки, это не дало бы ошибки:
 >>> скорость = ввод (подсказка)
Какие...это скорость полета порожней ласточки?
"Что вы имеете в виду, африканскую или европейскую ласточку?"
>>> скорость
- Что значит африканская или европейская ласточка?
>>>
 
 Чтобы избежать такого рода ошибок, рекомендуется использовать raw_input для получения
строка, а затем используйте команды преобразования, чтобы преобразовать ее в другие типы.
 4.10. Преобразование типа 
 Каждый тип Python имеет встроенную команду, которая пытается преобразовать значения.
другого типа в этот тип.Команда int (ARGUMENT), например,
принимает любое значение и по возможности преобразует его в целое число или жалуется
в противном случае:
 >>> int ("32")
32
>>> int ("Привет")
ValueError: недопустимый литерал для int () с базой 10: 'Hello'
 
 int также может преобразовывать значения с плавающей запятой в целые числа, но помните
что он усекает дробную часть:
 >>> интервал (-2,3)
-2
>>> int (3.99999)
3
>>> int ("42")
42
>>> интервал (1.0)
1
 
 Команда с плавающей запятой (АРГУМЕНТ) преобразует целые числа и строки в числа с плавающей запятой.
номера:
 >>> поплавок (32)
32.0
>>> float ("3,14159")
3,14159
>>> поплавок (1)
1.0
 
 Может показаться странным, что Python отличает целочисленное значение 1 от
значение с плавающей запятой 1.0. Они могут представлять одно и то же число, но они
относятся к разным типам. Причина в том, что они представлены по-разному.
внутри компьютера.
 Команда str (ARGUMENT) преобразует любой переданный ей аргумент в тип
строка:
 >>> str (32)
'32'
>>> str (3.14149)
"3.14149"
>>> str (Верно)
'Правда'
>>> str (правда)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя 'true' не определено
 
 str (АРГУМЕНТ) будет работать с любым значением и преобразовывать его в строку.В виде
упоминалось ранее, True - логическое значение; правда нет.
 Для логических значений ситуация особенно интересна:
 >>> булев (1)
Правда
>>> булево (0)
Ложь
>>> bool ("Ни!")
Правда
>>> bool ("")
Ложь
>>> булево (3.14159)
Правда
>>> bool (0.0)
Ложь
 
 Python присваивает логические значения значениям других типов. Для числовых типов
как целые числа и числа с плавающей запятой, нулевые значения являются ложными и ненулевыми.
верны. Для строк пустые строки являются ложными, а непустые - истинными.
 4.11. ГАСП 
 GASP ( G  raphics  A  PI для  S  учеников  P  ython) позволит
нам писать программы, связанные с графикой. Прежде чем вы сможете использовать GASP, необходимо
для установки на вашем компьютере. Если вы используете Ubuntu GNU / Linux, см.  GASP  в Приложении А. Текущие инструкции
для установки GASP на другие платформы можно найти на
http://dev.laptop.org/pub/gasp/downloads.
 После установки gasp попробуйте следующий скрипт python:
 от импорта газа *

begin_graphics ()

Круг ((200, 200), 60)
Линия ((100, 400), (580, 200))
Коробка ((400, 350), 120, 100)

update_when ('нажатие_ключа')
end_graphics ()
 
 Команда, выполняющая предпоследнюю паузу, ожидает нажатия клавиши.Без него экран будет мигать так быстро, что вы его не увидите.
 Запустив этот сценарий, вы должны увидеть графическое окно, которое выглядит следующим образом:
 С этого момента мы будем использовать дыхание, чтобы проиллюстрировать (каламбур) компьютер.
концепции программирования и добавить к нашему удовольствию во время обучения. Вы можете узнать
подробнее о модуле GASP см. в Приложении B.
 4.12. Глоссарий 
 блок
 Группа последовательных операторов с одинаковым отступом.
 кузов
 Блок операторов в составном операторе, следующий за
заголовок.
 логическое выражение
 Выражение, которое может быть истинным или ложным.
 логическое значение
 Имеется ровно два логических значения: Истина и Ложь. Логический
значения результат, когда логическое выражение оценивается Python
Интерпретатор. У них есть тип bool.
 филиал
 Один из возможных путей потока исполнения, определяемый
условное исполнение.
 связанное условное
 Условный переход с более чем двумя возможными потоками выполнения. В
Связанные условные выражения Python записываются с if ... elif ... else
заявления.
 оператор сравнения
 Один из операторов, сравнивающих два значения: ==,! =,>, <,> = и <=.
 состояние
 Логическое выражение в условном операторе, определяющее, какой
филиал выполнен.
 условный оператор
 Оператор, управляющий потоком выполнения в зависимости от некоторых
условие.В Python ключевые слова if, elif и else
используется для условных операторов.
 логический оператор
 Один из операторов, объединяющих логические выражения: и,
или, и нет.
 оператор модуля
 Оператор, обозначенный знаком процента (%), работающий на
целые числа и дает остаток от деления одного числа на
Другой.
 гнездование
 Одна структура программы внутри другой, например условный оператор
внутри ветви другого условного оператора.
 подсказка
 Визуальная подсказка, которая говорит пользователю ввести данные.
 Преобразование типа
 Явный оператор, который принимает значение одного типа и вычисляет
соответствующее значение другого типа.
 обертывание кода в функцию
 Процесс добавления заголовка функции и параметров в последовательность
операторов программы часто называют «заключением кода в
функция". Этот процесс очень полезен, когда программа
Рассматриваемые утверждения будут использоваться несколько раз.
 4,13. Упражнения 
 Попробуйте вычислить в уме следующие числовые выражения, затем используйте
интерпретатор Python для проверки ваших результатов:
 >>> 5% 2
 >>> 9% 5
 >>> 15% 12
 >>> 12% 15
 >>> 6% 6
 >>> 0% 7
 >>> 7% 0
 Что случилось с последним примером? Почему? Если бы ты умел правильно
предвидеть реакцию компьютера во всех случаях, кроме последнего, пора
двигаться дальше.Если нет, найдите время и придумайте собственные примеры. Исследовать
модуля, пока вы не будете уверены, что понимаете, как он работает.
, если x  у:
    напечатайте x, "больше, чем", y
еще:
    напечатайте x, "и", y, "равны"
 
  Оберните  этот код в функцию с именем compare (x, y). Звоните сравнить
три раза: по одному, если первый аргумент меньше, больше
чем, и равно второму аргументу.
 Чтобы лучше понимать логические выражения, полезно построить истину.
таблицы. Два логических выражения  логически эквивалентны  тогда и только тогда, когда
у них одна и та же таблица истинности.
 Следующий скрипт Python распечатывает таблицу истинности для любого логического
выражение с двумя переменными: p и q:
 expression = raw_input ("Введите логическое выражение с двумя переменными, p и q:")

напечатать "p q% s"% выражение
length = len ("p q% s"% выражение)
длина печати * "="

для p в True, False:
    для q в True, False:
        print "% -7s% -7s% -7s"% (p, q, eval (выражение))
 
 Вы узнаете, как работает этот сценарий, в следующих главах.А пока ты
будет использовать его, чтобы узнать о логических выражениях. Скопируйте эту программу в
файл с именем p_and_q.py, затем запустите его из командной строки и дайте
it: p или q при запросе логического выражения. Ты должен получить
следующий вывод:
 p q p или q
=====================
Правда правда правда
Верно Неверно Верно
Ложь правда правда
Ложь Ложь Ложь
 
 Теперь, когда мы увидели, как это работает, давайте обернем его функцией, чтобы
проще в использовании:
 def таблица_правды (выражение):
    напечатать "p q% s"% выражение
    length = len ("p q% s"% выражение)
    длина печати * "="

    для p в True, False:
        для q в True, False:
            print "% -7s% -7s% -7s"% (p, q, eval (выражение))
 
 Мы можем импортировать его в оболочку Python и вызвать true_table со строкой
содержащее наше логическое выражение в p и q в качестве аргумента:
 >>> из импорта p_and_q *
>>> таблица_правды ("р или д")
p q p или q
=====================
Правда правда правда
Верно Неверно Верно
Ложь правда правда
Ложь Ложь Ложь
>>>
 
 Используйте функции true_table со следующими логическими выражениями,
запись таблицы истинности, производимой каждый раз:
 нет (p или q)
 п и д
 нет (п и д)
 нет (p) или нет (q)
 не (p) и не (q)
 Какие из них логически эквивалентны?
 Введите следующие выражения в оболочку Python:
 Верно или неверно
Правда и ложь
not (False) и True
Верно или 7
Ложь или 7
Верно и 0
Ложь или 8
"счастливый" и "грустный"
"счастливый" или "грустный"
"" и "грустный"
"счастлив и ""
 
 Проанализируйте эти результаты.Какие наблюдения вы можете сделать о ценностях
разные типы и логические операторы? Вы можете записать эти наблюдения в
форма простых  правил  об а и или выражениях?
 при выборе == 'a':
    function_a ()
elif choice == 'b':
    function_b ()
elif choice == 'c':
    function_c ()
еще:
    print «Неверный выбор».
 
 Оберните этот код в функцию под названием dispatch (choice). Затем определите
function_a, function_b и function_c, чтобы они распечатали
сообщение о том, что они были вызваны.Например:
 def function_a ():
    print "function_a была вызвана ..."
 
 Поместите четыре функции (dispatch, function_a, function_b и
function_c в скрипт с именем ch04e05.py. Внизу этого
скрипт добавляет вызов к отправке ('b'). Ваш вывод должен быть:
 Наконец, измените сценарий, чтобы пользователь мог вводить «a», «b» или «c». Попробуй это
путем импорта вашего скрипта в оболочку Python.
 Напишите функцию с именем is_divisible_by_3, которая принимает одно целое число как
аргумент и печатает: «Это число делится на три.«Если аргумент
делится без остатка на 3 и «Это число не делится на три».
иначе.
 Теперь напишите аналогичную функцию с именем is_divisible_by_5.
 Обобщите функции, которые вы написали в предыдущем упражнении, в функцию
с именем is_divisible_by_n (x, n), который принимает два целочисленных аргумента и
выводит, делится ли первое на второе. Сохраните это в
файл с именем ch04e07.py. Импортируйте его в оболочку и попробуйте. Образец
сессия может выглядеть так:
 >>> из ch04e07 импорт *
>>> is_divisible_by_n (20, 4)
Да, 20 делится на 4
>>> is_divisible_by_n (21, 8)
Нет, 21 не делится на 8
 
 Каким будет результат?
 если «Ni!»:
    print 'Мы рыцари, которые говорят: «Ни!»'
еще:
    print "Прекрати! Больше этого не надо!"

если 0:
    print "А теперь о другом... "
еще:
    print "Что все это значит?"
 
 Объясните, что произошло и почему это произошло.
 Следующий скрипт дыхания в файле с именем house.py рисует простой
дом на задыхающемся холсте:
 from gasp import * # импортировать все из библиотеки gasp

begin_graphics () # открываем графический холст

Коробка ((20, 20), 100, 100) # домик
Коробка ((55, 20), 30, 50) # дверь
Box ((40, 80), 20, 20) # левое окно
Box ((80, 80), 20, 20) # правое окно
Line ((20, 120), (70, 160)) # левая крыша
Line ((70, 160), (120, 120)) # правая крыша

update_when ('key_pressed') # держать холст открытым, пока не будет нажата клавиша
end_graphics () # закрываем холст (что могло бы произойти
                            # в любом случае, так как скрипт здесь заканчивается, но он
                            # лучше быть явным).
 Запустите этот сценарий и убедитесь, что вы получили окно, похожее на
это:
 Оберните код дома в функцию с именем draw_house ().
 Запустите сценарий сейчас. Вы видите дом? Почему нет?
 Добавьте вызов draw_house () в нижней части скрипта, чтобы
Дом возвращается к экрану.
  Параметризация  функции с параметрами x и y - заголовок
должен затем стать def draw_house (x, y) :, чтобы вы могли передать
расположение дома на полотне.