A 10 print a 10 n: Решение модуля 7.5 "Поколение python: курс для начинающих" ответы

Содержание

Решение модуля 7.5 «Поколение python: курс для начинающих» ответы

Главная » Ответы на Stepik » «Поколение Python»: курс для начинающих

Опубликовано: 25.03.2021Рубрика: «Поколение Python»: курс для начинающихАвтор: admin

Полное решение модуля (урока) 7.5 Цикл while: обработка цифр числа на питоне + ответы.

Что покажет приведенный ниже фрагмент кода?
num = 12345
product = 1
while num != 0:
last_digit = num % 10
product = product * last_digit
num = num // 10
print(product)

Что покажет приведенный ниже фрагмент кода?
num = 123456789
total = 0
while num != 0:
last_digit = num % 10
if last_digit > 4:
total += 1
num = num // 10
print(total)

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

Формат входных данных
На вход программе подается одно натуральное число.
Формат выходных данных
Программа должна вывести цифры введенного числа в столбик в обратном порядке.

n = int(input())
while n:           # False = 0 , True = все что не 0
    i = n % 10     # получить последнюю цифру    
    n = n // 10    # удалить последнюю цифру из числа         
    print(i)

Обратный порядок 2
Дано натуральное число. Напишите программу, которая меняет порядок цифр числа на обратный.
Формат входных данных
На вход программе подается одно натуральное число.
Формат выходных данных
Программа должна вывести число записанное в обратном порядке.

n = int(input())     
while n != 0:         # еще один вариант проверки пока n не равен 0 цикл выполняется
    s = n % 10        # получаем последнюю цифру
    print(s, end='')  # выводим на экран послед.
  цифру с пустым параметром end что бы не было перевода строки
    n = n // 10       # удаляем последнюю цифру из числа

max и min
Дано натуральное число n, \, (n \ge 10)n,(n≥10). Напишите программу, которая определяет его максимальную и минимальную цифры.
Формат входных данных
На вход программе подается одно натуральное число.
Формат выходных данных
Программа должна вывести максимальную и минимальную цифры введенного числа (с поясняющей надписью).

n = int(input())         
maxx = 0                 # в максимум берем минимальное число
minn = 9                 # в минимум берем максимальное число
while n != 0:            # пока n не равна 0 выполняем цикл
    if n % 10 > maxx:    # получаем последнюю цифру и сравниваем с максимальным
        maxx = n % 10    # если последняя цифра больше то перезаписываем максимальное число
    if n % 10 < minn:    # получаем последнюю цифру и сравниваем с минимальным
        minn = n % 10    # если последняя цифра меньше то перезаписываем минимальное число
    n = n // 10          # убираем последнюю цифру
    
print('Максимальная цифра равна', maxx)
print('Минимальная цифра равна', minn)

Все вместе
Дано натуральное число. Напишите программу, которая вычисляет:
сумму его цифр;
количество цифр в нем;
произведение его цифр;
среднее арифметическое его цифр;
его первую цифру;
сумму его первой и последней цифры.
Формат входных данных
На вход программе подается одно натуральное число.
Формат выходных данных
Программа должна вывести значения указанных величин в указанном порядке.

inputn = int(input())   
n = inputn                        # это наше число, неизменное
total = 0                         # сумма чисел
product = 1                       # произведение чисел
count = 0                         # количество чисел
 
while inputn != 0:                # цикл пока inputn не равен 0
    total += inputn % 10          # считаем суму чисел
    product *= inputn % 10        # считаем произведение чисел
    count += 1                    # считаем количество чисел
    inputn //= 10                 # откидывает последнее число
 
print(total)                      # сумма чисел
print(count)                      # количество чисел
print(product)                    # произведение чисел
print(total/count)                # среднее арифмитическое всех чисел
print(n//10 ** (count-1))         # первое число
print(n//10 ** (count-1) + n%10)  # произведение первого и последнего чисел

Вторая цифра
Дано натуральное число n(n > 9). Напишите программу, которая определяет его вторую (с начала) цифру.
Формат входных данных
На вход программе подается одно натуральное число, состоящее как минимум из двух цифр.
Формат выходных данных
Программа должна вывести его вторую (с начала) цифру.

n = int(input())
second = 0           # переменная для последней цифры

while n > 9:         # пока n > 9 выполняем цикл
    second = n % 10  # находим и в переменную перезаписываем последнию цифру
    n = n // 10      # убираем последнюю цифру
    
print(second)

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

Формат входных данных
На вход программе подается одно натуральное число.
Формат выходных данных
Программа должна вывести «YES» если число состоит из одинаковых цифр и «NO» в противном случае.

num = int(input())       # ввод числа
flag = True              # флаг считаем что все цифры равны

while num > 9:           # пока число 2значное выполняем цикл
    last = num % 10      # вычисляем последнюю цифру
    num = num // 10      # удаляем последнюю цифру и запускаем цикл сначала    
    sec = num % 10       # вычисляем предпоследнюю цифру      
    if last != sec:      # условие, если последняя и предпоследняя
        flag = False     # цифры не равны, меняем флаг    
    
if flag:                 # если флаг true
    print('YES')         # значит цифры равны
else:                
    print('NO')          # иначе различны

Упорядоченные цифры ?️
Дано натуральное число. Напишите программу, которая определяет, является ли последовательность его цифр при просмотре справа налево упорядоченной по неубыванию.
Формат входных данных
На вход программе подается одно натуральное число.
Формат выходных данных
Программа должна вывести «YES» если последовательность его цифр при просмотре справа налево является упорядоченной по неубыванию и «NO» в противном случае.

# Эту задачу решил иначе чем предыдущую что бы показать как еще можно
num = int(input())
teg = 'YES'           # используем тег и считаем что последовательность упорядочена
a = num % 10          # находим послееднюю цифру числа

while num:            # запускаем цикл
    if a > num % 10:  # условие если предыдущая цифра больше последующей
        teg = 'NO'    # то присваиваем тег NO, и уже нет смысла записывать в a последнию цифру
    else:             # иначе
        a = num % 10  # присваиваем последнюю цифру - переменной
    num //= 10        # удаляем последнюю цифру числа
print(teg)

55 94 074 просмотров

Понравилась статья? Поделиться с друзьями:

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

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

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

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

Например, сумма цифр числа 253 равна 10-ти, так как 2 + 5 + 3 = 10. Произведение цифр числа 253 равно 30-ти, так как 2 * 5 * 3 = 30.

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

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

При этом используются операции деления нацело и нахождения остатка. Если число разделить нацело на 10, произойдет «потеря» последней цифры числа. Например, 253 ÷ 10 = 25 (остаток 3). С другой стороны, эта потерянная цифра есть остаток от деления. Получив эту цифру, мы можем добавить ее к сумме цифр и умножить на нее произведение цифр числа.

Пусть n – само число, suma – сумма его цифр, а mult – произведение. Тогда алгоритм нахождения суммы и произведения цифр можно словесно описать так:

Переменной suma присвоить ноль.
Переменной mult присвоить единицу. Присваивать 0 нельзя, так как при умножении на ноль результат будет нулевым.
Пока значение переменной n больше нуля повторять следующие действия:
1. Найти остаток от деления значения n на 10, то есть извлечь последнюю цифру числа.
2. Добавить извлеченную цифру к сумме и увеличить на эту цифру произведение.
3. Избавиться от последнего разряда числа n путем деления нацело на 10.

В языке Python операция нахождения остатка от деления обозначается знаком процента —

%. Деление нацело — двумя слэшами — //.

Код программы на языке Python

n = int(input())
 
suma = 0
mult = 1
 
while n > 0:
    digit = n % 10
    suma = suma + digit
    mult = mult * digit
    n = n // 10
 
print("Сумма:", suma)
print("Произведение:", mult)

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

253
Сумма: 10
Произведение: 30

Изменение значений переменных можно записать в сокращенном виде:

...
while n > 0:
    digit = n % 10
    suma += digit
    mult *= digit
    n //= 10
...

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

Если число отрицательное, это не влияет на сумму его цифр. В таком случае достаточно будет использовать встроенную в Python функции abc, которая возвращает абсолютное значение переданного ей аргумента. Она превратит отрицательное число в положительное, и цикл while с его условием n > 0 будет работать как и прежде.

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

Программа, обрабатывающая все целые числа, может начинаться так:

n = abs(int(input()))
 
suma = 0
mult = 1
if n == 0:
    mult = 0
...

Заметим, если в самом числе встречается цифра 0 (например, 503), то произведение всех цифр будет равно нулю. Усложним задачу:

Вводится натуральное число. Найти сумму и произведение цифр, из которых состоит это число. При этом если в числе встречается цифра 0, то ее не надо учитывать при нахождении произведения.

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

n = int(input())
 
suma = 0
mult = 1
 
while n > 0:
    digit = n % 10
    if digit != 0:  
        suma += digit
        mult *= digit
    n = n // 10
 
print("Сумма:", suma)
print("Произведение:", mult)

Обратим внимание, что заголовок условного оператора if digit != 0: в Python можно сократить до просто if digit:. Потому что 0 — это False. Все остальные числа считаются истиной.

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

a = input()
 
suma = 0
mult = 1
 
for digit in a:
    suma += int(digit)
    mult *= int(digit)
 
print("Сумма:", suma)
print("Произведение:", mult)

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

n = input()
 
suma = 0
mult = 1
 
for digit in n:
    if digit.isdigit():
        suma += int(digit)
        mult *= int(digit)
 
print("Сумма:", suma)
print("Произведение:", mult)

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

это3 чи3с9ло!
Сумма: 15
Произведение: 81

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

Глубокое знание языка Python позволяет решить задачу более экзотическими способами:

import functools
 
n = input()
n = [int(digit) for digit in n]
 
suma = sum(n)
mult = functools.reduce(lambda x, y: x*y, n)
 
print("Сумма:", suma)
print("Произведение:", mult)

Выражение [int(digit) for digit in n] представляет собой генератор списка. Если была введена строка "234", будет получен список чисел: [2, 3, 4].

Встроенная функция sum считает сумму элементов переданного ей аргумента.

Функция reduce модуля functools принимает два аргумента — лямбда-выражение и в данном случае список. Здесь в переменной x происходит накопление произведения, а y принимает каждое следующее значение списка.

Больше задач в PDF

Функция Python range() — GeeksforGeeks

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

Синтаксис функции Python range()

Синтаксис: range(start, stop, step)
Параметр:
start : [ необязательный ] начальное значение последовательности
стоп: следующее значение после конечного значения последовательности
шаг: [ необязательный ] целочисленное значение, обозначающее разницу между любыми двумя числами в последовательности.
Возврат: Возвращает объект типа диапазона.

Пример функции Python range()

Python3

для i в диапазоне

 9 0048  (   5   ): 
         печать   (i, конец   =   " "   ) 
  печать  9004 7 ()

Выход:

 0 1 2 3 4

В чем польза функции диапазона в Python

Проще говоря, range() позволяет пользователю генерировать серию чисел в заданном диапазоне. В зависимости от того, сколько аргументов пользователь передает функции, пользователь может решить, где будет начинаться и заканчиваться этот ряд чисел, а также насколько велика будет разница между одним числом и следующим. Функция Python range() может быть инициализирована тремя способами.

диапазон (стоп) принимает один аргумент.
диапазон (старт, стоп) принимает два аргумента.
диапазон (старт, стоп, шаг) принимает три аргумента.

Диапазон Python (стоп)

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

Визуализация диапазона Python

Пример: Демонстрация диапазона Python (стоп)

Python3

для i в диапазоне ( 6 ):

печать (i, конец = " " )

печать ()

Вывод:

9009 0 0 1 2 3 4 5

Диапазон Python (старт, стоп)

Когда пользователь вызывает range() с двумя аргументами пользователь может решить не только, где заканчивается последовательность чисел, но и где она начинается, поэтому пользователю не нужно все время начинать с 0. Пользователи могут использовать range() для генерации последовательности чисел от X до Y, используя range(X, Y).

Визуализация диапазона Python

Пример: Демонстрация диапазона Python (запуск, остановка)

Python3

для i 90 047 в диапазоне ( 5 , 20 ):

печать 9004 7 (i, конец = " " )

Выход:

 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Диапазон Python (начало, стоп, шаг)

числа будут начинаться и останавливаться, но также и насколько велика будет разница между одним числом и следующим. Если пользователь не указывает шаг, то range() будет автоматически вести себя так, как будто шаг равен 1. В этом примере мы печатаем четные числа от 0 до 10, поэтому мы выбираем начальную точку от 0 (начало = 0 ) и остановите серию на 10 (стоп = 10). Для печати четного числа разница между одним числом и следующим должна быть 2 (шаг = 2), после указания шага мы получаем следующий вывод (0, 2, 4, 8).

Визуализация диапазона Python

Пример: Демонстрация диапазона Python (начало, остановка, шаг)

Python3

для 900 47 i в диапазоне ( 0 , 10 , 2 ):

печать

 (i, конец 9004 8  =   " "   ) 
  печать   ()

Вывод:

 0 2 4 6 8

Диапазон Python() с примерами

9011 0 Пример 1. Увеличение диапазона с использованием положительного шага

Если пользователь хочет увеличить, тогда пользователю нужно, чтобы шаги были положительным числом.

Python3

для i в диапазоне ( 0 , 30 , 4 ):

печать (i, конец = "" )

печать ()

Вывод:

 0 4 8 12 16 20 24 28

хочет уменьшить, то пользователю нужно, чтобы шаги были отрицательными число.
Python3
для i в диапазоне ( 2 5 , 2 , - 2 ):
     печать (i, конец = " " )
печать ()
Вывод:
25 23 21 1917 15 13 11 9 7 5 3
Пример 3: Python range() с float
Функция Python range() не поддерживает числа с плавающей запятой. то есть пользователь не может использовать числа с плавающей запятой или нецелые числа в любом из своих аргументов. Пользователи могут использовать только целые числа.
Python3
для i в диапазоне ( 3.3 ):
     печать (i)
Вывод:
для i в диапазоне (3.3): TypeError: объект 'float' не может быть интерпретирован как целое число
Пример 4. Конкатенация двух функций range() с использованием метода itertools chain()
Результат двух функций range() можно объединить с помощью метода chain() модуля itertools. Метод chain() используется для печати всех значений в итерируемых целях одно за другим, упомянутых в его аргументах.
Python3
из itertools импорт цепочка

900 46 print ( "Объединение результата" )
рез = цепочка ( диапазон ( 5 ), диапазон ( 10 , 20 , 2 ))

для i в рез:
     печать (i, конец = " " )
Вывод:
Объединение результата 0 1 2 3 4 10 12 14 16 18
Пример 5.
Доступ к range() со значением индекса
Последовательность чисел возвращается функцией range() в качестве объекта, к которому можно получить доступ по значению индекса. Его объект поддерживает как положительное, так и отрицательное индексирование.
Python3
ele = диапазон ( 10 9004 7 )[ 0 ]
печать ( "Первый элемент:" , ele)

ele = диапазон ( 10 )[ 9 0047 — 1 ]
печать ( "\nПоследний элемент:" , ele)

ele = диапазон ( 10 )[ 4 ]
печать ( "\nПятый элемент:" , ele)
Вывод:
Первый элемент: 0 Последний элемент: 9 Пятый элемент: 4
Некоторые важные моменты, которые следует помнить о функции Python range():

Функция range() работает только с целыми числами, т. е. целыми числами.
Все аргументы должны быть целыми числами. Пользователи не могут передавать строку или число с плавающей запятой или любой другой тип в аргументе start , stop и step диапазона().
Все три аргумента могут быть положительными или отрицательными.

Значение шага не должно быть нулевым. Если шаг равен нулю, python вызывает исключение ValueError.
range() — это тип в Python 9.0021
Пользователи могут обращаться к элементам в диапазоне() по индексу, так же как пользователи делают это со списком:

Документация Learning with Python 2nd Edition
4.1. Оператор модуля
Оператор модуля работает с целыми числами (и целочисленными выражениями) и дает остаток при делении первого операнда на второй. В Питоне оператор модуля представляет собой знак процента (%). Синтаксис такой же, как и для других операторы:
>>> частное = 7 / 3 >>> вывести частное 2 >>> остаток = 7 % 3 >>> напечатать остаток 1
Таким образом, 7 разделить на 3 будет 2 с 1 остатком.
Оператор модуля оказывается на удивление полезным. Например, вы можете проверить, делится ли одно число на другое — если x % y равно нулю, то х делится на у.
Кроме того, вы можете извлечь крайнюю правую цифру или цифры из числа. Для например, x % 10 дает самую правую цифру x (в базе 10). Точно так же x % 100 дает две последние цифры.
4.2. Логические значения и выражения
Тип Python для хранения истинных и ложных значений называется bool, названным в честь английского математика Джорджа Буля. Джордж Буль создал логическое значение алгебра , которая является основой всей современной компьютерной арифметики.
Существует только два логических значения : True и False. Капитализация важно, поскольку true и false не являются логическими значениями.
>>> тип (правда) <тип 'bool'> >>> тип(правда) Traceback (последний последний вызов): Файл "", строка 1, в NameError: имя «истина» не определено
Логическое выражение — это выражение, результатом которого является логическое значение. Оператор == сравнивает два значения и выдает логическое значение:
>>> 5 == 5 Истинный >>> 5 == 6 ЛОЖЬ
В первом операторе два операнда равны, поэтому выражение оценивает на Истина; во втором утверждении 5 не равно 6, поэтому получаем False.
Оператор == является одним из операторов сравнения ; остальные:
x != y # x не равно y x > y # x больше, чем y x < y # x меньше y x >= y # x больше или равно y x <= y # x меньше или равно y
Хотя эти операции, вероятно, вам знакомы, символы Python отличается от математических символов. Распространенной ошибкой является использование одного знак равенства (=) вместо двойного знака равенства (==). Помните, что = — оператор присваивания, а == — оператор сравнения. Кроме того, есть нет такой вещи, как =< или =>.
4.3. Логические операторы
Существует три логических оператора : и, или, и не. семантика (значение) этих операторов аналогична их значению в английском языке. Например, 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 BOOLEAN EXPRESSION: ЗАЯВЛЕНИЯ
Аналогично определению функции из предыдущей главы и другим составным операторы, оператор if состоит из заголовка и тела. Заголовок начинается с ключевого слова, если за ним следует цифра логическое выражение и заканчивается на двоеточие (:).
Следующие операторы с отступом называются блоком . Первый оператор без отступа отмечает конец блока. Блок операторов внутри составного оператора называется телом оператора.
Каждый оператор внутри тела выполняется в том порядке, в котором выражение оценивается как True. Весь блок пропускается, если логическое значение выражение оценивается как False.
Количество операторов, которые могут появляться в теле сообщения, не ограничено. if, но должен быть хотя бы один. Иногда полезно иметь тело без операторов (обычно в качестве места хранения для кода, который вы еще не писал). В этом случае вы можете использовать оператор pass, который ничего не делает.
если True: # Это всегда верно pass # так что это всегда выполняется, но ничего не делает
4.5. Альтернативное выполнение
Второй формой оператора if является альтернативное выполнение, в котором две возможности, и условие определяет, какая из них будет выполнена. синтаксис выглядит так:
если x % 2 == 0: выведите x, "четно" еще: выведите x, "нечетно"
Если остаток от деления x на 2 равен 0, то мы знаем, что x равно даже, и программа выводит сообщение об этом. Если условие false, выполняется второй набор операторов. Так как условие должно быть true или false, будет выполнена ровно одна из альтернатив. альтернативы называются ответвления , потому что это ответвления в потоке исполнение.
Кроме того, если вам нужно проверить четность (четность или нечетность) чисел часто вы можете обернуть этот код в функцию :
def print_parity(x): если х% 2 == 0: выведите x, "четно" еще: выведите x, "нечетно"
Для любого значения x функция print_parity отображает соответствующее сообщение. Когда вы вызываете его, вы можете указать любое целочисленное выражение в качестве аргумента.
>>> print_parity(17) 17 странно. >>> у = 41 >>> print_parity(y+1) 42 четно.
4.6. Связанные условные операторы
Иногда существует более двух возможностей, и нам нужно более двух ветви. Один из способов выразить такое вычисление — это цепочка . условное :
если x < y: вывести x, "меньше", y Элиф х > у: вывести x, "больше", y еще: выведите x, "и", y, "равны"
elif — это сокращение от else if. Опять же, ровно одна ветвь будет казнен. Количество операторов elif не ограничено, а только допускается один (и необязательный) оператор else, и он должен быть последним ветка в заявлении:
если выбор == 'a': функция_а() Элиф выбор == 'б': функция_b() Элиф выбор == 'с': function_c() еще: напечатать «Неверный выбор».
Каждое условие проверяется по порядку. Если первое ложно, проверяется следующее, и так далее. Если одно из них истинно, выполняется соответствующая ветвь, и заявление заканчивается. Даже если верно несколько условий, верно только первое филиал выполняет.
4.7. Вложенные условные операторы
Один условный оператор также может быть вложил в другой. Мы могли бы написать пример трихотомии выглядит следующим образом:
, если x == y: выведите x, "и", y, "равны" еще: если х < у: вывести x, "меньше", y еще: вывести x, "больше", y
Внешнее условное предложение содержит две ветви. Первая ветвь содержит простой выходное заявление. Вторая ветвь содержит еще один оператор if, который имеет две собственные ветви. Эти две ветви являются выходными операторами, хотя они могли быть и условными операторами.
Хотя отступ операторов делает структуру очевидной, вложенные условные выражения становятся трудными для чтения очень быстро. В общем, это хорошо Идея избегать их, когда вы можете.
Логические операторы часто позволяют упростить вложенные условные операторы. заявления. Например, мы можем переписать следующий код, используя один условно:
, если 0 < x: если х < 10: выведите «x — положительная цифра».
Оператор печати выполняется только в том случае, если мы проходим оба условные выражения, поэтому мы можем использовать оператор and:
, если 0 < x и x < 10: выведите «x — положительная цифра».
Такие условия являются общими, поэтому Python предоставляет альтернативный синтаксис что похоже на математическую запись:
, если 0 < x < 10: выведите «x — положительная цифра».
Это условие семантически такое же, как составное логическое выражение и вложенное условное выражение.
4.9. Ввод с клавиатуры
В Input мы познакомились со встроенными функциями Python, которые получают ввод с клавиатуры: raw_input и ввод. Теперь давайте посмотрим на эти снова более глубоко.
При вызове любой из этих функций программа останавливается и ожидает пользователю ввести что-либо. Когда пользователь нажимает клавишу Return или Enter, программа возобновляется, и raw_input возвращает то, что пользователь ввел в виде строки:
>>> my_input = raw_input() Чего же ты ждешь? >>> напечатать my_input Чего же ты ждешь?
Перед вызовом raw_input рекомендуется распечатать сообщение, сообщающее пользователь, что вводить. Это сообщение называется приглашение . Мы можем поставить подсказка в качестве аргумента для raw_input:
>>> name = raw_input("Как... вас зовут?") Как вас зовут? Артур, король бриттов! >>> печатать имя Артур, король бриттов!
Обратите внимание, что подсказка представляет собой строку, поэтому она должна быть заключена в кавычки.
Если мы ожидаем, что ответ будет целым числом, мы можем использовать функцию ввода который оценивает ответ как выражение Python:
prompt = "Какова... скорость полета порожней ласточки?\n" скорость = ввод (подсказка)
Если пользователь вводит строку цифр, она преобразуется в целое число и назначается скорость. К сожалению, если пользователь вводит символы, которые не составить допустимое выражение Python, программа вылетает:
>>> speed = input(prompt) Какова... скорость полета порожней ласточки? Что вы имеете в виду, африканская или европейская ласточка? ... SyntaxError: неверный синтаксис
В последнем примере, если пользователь сделал ответ действительным Python выражение, заключив его в кавычки, оно не выдало бы ошибки:
>>> скорость = ввод (подсказка) Какова. .. скорость полета порожней ласточки? "Что ты имеешь в виду, африканская или европейская ласточка?" >>> скорость — Что ты имеешь в виду, африканская или европейская ласточка? >>>
Во избежание ошибок такого рода рекомендуется использовать raw_input для получения строку, а затем используйте команды преобразования, чтобы преобразовать ее в другие типы.
4.10. Преобразование типов
Каждый тип Python поставляется со встроенной командой, которая пытается преобразовать значения другого типа в этот тип. Команда int(ARGUMENT), например, принимает любое значение и преобразует его в целое число, если это возможно, или жалуется иначе:
>>> целое ("32") 32 >>> int("Привет") ValueError: недопустимый литерал для int() с основанием 10: «Привет»
int также может преобразовывать значения с плавающей запятой в целые числа, но помните что он усекает дробную часть:
>>> int(-2.3) -2 >>> целое(3.99999) 3 >>> интервал("42") 42 >>> целое (1.0) 1
Команда float(ARGUMENT) преобразует целые числа и строки в числа с плавающей запятой числа:
>>> float(32) 32,0 >>> с плавающей запятой("3. 14159") 3.14159 >>> с плавающей запятой(1) 1,0
Может показаться странным, что Python различает целочисленное значение 1 от значение с плавающей запятой 1.0. Они могут представлять одно и то же число, но они относятся к разным типам. Причина в том, что они представлены по-разному. внутри компьютера.
Команда str(ARGUMENT) преобразует любой переданный ей аргумент в тип строка:
>>> ул(32) '32' >>> ул(3.14149) «3.14149» >>> ул(правда) 'Истинный' >>> ул(правда) Traceback (последний последний вызов): Файл "", строка 1, в NameError: имя «истина» не определено
str(ARGUMENT) будет работать с любым значением и преобразовывать его в строку. Как упоминалось ранее, True — это логическое значение; правда нет.
Для логических значений ситуация особенно интересна:
>>> bool(1) Истинный >>> логический (0) ЛОЖЬ >>> bool("Ни!") Истинный >>> буль ("") ЛОЖЬ >>> логическое значение (3.14159) Истинный >>> логический (0.0) ЛОЖЬ
Python присваивает логические значения значениям других типов. Для числовых типов подобно целым числам и числам с плавающей запятой, нулевые значения являются ложными и ненулевыми значениями. верны. Для строк пустые строки являются ложными, а непустые строки — истинными.
4.11. GASP
GASP ( G графика A PI для S студентов P ython) позволит нам писать программы, использующие графику. Прежде чем вы сможете использовать GASP, необходимо для установки на вашу машину. Если вы используете Ubuntu GNU/Linux, см. GASP в Приложении A. Текущие инструкции для установки 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('key_pressed') end_graphics()
Предпоследняя команда делает паузу и ждет, пока не будет нажата клавиша. Без него экран мигал бы так быстро, что вы бы его не увидели.
Запустив этот скрипт, вы должны увидеть графическое окно, которое выглядит следующим образом:
С этого момента мы будем использовать вздох для иллюстрации (каламбур) концепции программирования и добавить к нашему веселью во время обучения. Вы можете узнать подробнее о модуле GASP, прочитав Приложение B.
4.12. Глоссарий
блок
Группа последовательных операторов с одинаковым отступом.
корпус
Блок операторов в составном операторе, следующий за заголовок.
логическое выражение
Выражение, которое либо истинно, либо ложно.
логическое значение
Имеется ровно два логических значения: True и False. логический значения получаются, когда логическое выражение оценивается 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, "меньше", y Элиф х > у: вывести 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, затем запустите его из командной строки и дайте это: p или q, когда запрашивается логическое выражение. Вы должны получить следующий вывод:
p q p или q ====================== Правда Правда Правда Верно Ложно Верно Ложь Верно Верно Ложь Ложь Ложь
Теперь, когда мы видим, как это работает, давайте добавим его в функцию, чтобы сделать его проще в использовании:
по определению true_table (выражение): напечатать "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 * >>> true_table("p или q") p q p или q ====================== Правда Правда Правда Верно Ложно Верно Ложь Верно Верно Ложь Ложь Ложь >>>
Используйте функции таблицы истинности со следующими логическими выражениями, запись таблицы истинности производится каждый раз:
нет(p или q)
р и кв
не(p и q)
нет(р) или нет(q)
не(р) и не(к)
Какие из них логически эквивалентны?
Введите следующие выражения в оболочку Python:
Правда или Ложь Правда и ложь не (ложь) и правда Правда или 7 Ложь или 7 Истина и 0 Ложь или 8 "счастливый" и "грустный" "счастливый" или "грустный" "" и "грустно" "счастлив и ""
Проанализируйте эти результаты. Какие наблюдения вы можете сделать о значениях разные типы и логические операторы? Можете ли вы записать эти наблюдения в в виде простых правил о и и или выражений?
, если выбор == 'a': функция_а() Элиф выбор == 'б': функция_b() Элиф выбор == 'с': function_c() еще: напечатать «Неверный выбор».
Поместите этот код в функцию с именем dispatch(choice). Затем определите function_a, function_b и function_c, чтобы они выводили сообщение о том, что им звонили. Например:
определение function_a(): print "Функция_a была вызвана..."
Поместите четыре функции (dispatch, function_a, function_b и function_c в скрипт с именем ch04e05.py. В нижней части этого скрипт добавляет вызов диспетчера ('b'). Ваш вывод должен быть:
функция_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
Какой результат будет следующим?
если "Ни!": print 'Мы Рыцари, говорящие "Ни!"' еще: print "Хватит! Хватит этого!" если 0: print "А теперь совсем о другом..." еще: print "Что же это такое?"
Объясните, что произошло и почему.
Следующий скрипт gasp в файле с именем house.py рисует простой дом на задыхающемся холсте:

from gasp import * # импортировать все из библиотеки gasp begin_graphics() # открыть графический холст Box((20, 20), 100, 100) # дом Box((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() # закрываем холст (что может произойти # в любом случае, так как скрипт здесь заканчивается, но он # лучше указать явно).