Сборник. Сборник упражнений

• Название: Сборник упражнений
• Дата: 18.02.2023
• Размер: 1.68 Mb.
• Имя файла: Сборник.pdf
• Тип: Сборник; #942935
• страница: 11 из 14

Глава
11
Повторения
Упражнение 66. Никаких центов
##
# Вычислить полную сумму покупки. Сумму для уплаты наличными округлить до
# ближайших пяти центов, поскольку одноцентовые монеты выведены из обращения
#
PENNIES_PER_NICKEL = 5
NICKEL = 0.05
Хотя очень маловероятно, что в будущем в пятицентовой монете может оказаться больше пяти центов, мы все равно используем в программе переменные на случай, если когда-то нужно будет адаптировать ее для использования с другими номина- лами монет.
# Собираем общую сумму total = 0.00
# Запрашиваем цену первого товара как строку line = input("Введите цену товара (пустая строка для выхода): ")
# Продолжаем запрашивать цены товаров, пока строка не будет оставлена пустой while line != "":
# Добавляем цену в общей сумме (после перевода ее в число с плавающей запятой)
total = total + float(line)
# Запрашиваем цену следующего товара line = input("Введите цену товара (пустая строка для выхода): ")
# Показываем полную сумму к оплате print("Полная сумма к оплате: %.02f" % total)
# Считаем, сколько центов осталось бы, если бы мы оплатили всю покупку 5–центовыми
# монетами rounding_indicator = total * 100 % PENNIES_PER_NICKEL
if rounding_indicator < PENNIES_PER_NICKEL / 2:

Повторения

181
# Если оставшаяся сумма центов меньше 2,5, округляем значение путем вычитания
# полученного количества центов из общей суммы cash_total = total – rounding_indicator / 100
else:
# Иначе добавляем 5 центов и затем вычитаем нужное количество центов cash_total = total + NICKEL – rounding_indicator / 100
# Выводим итоговую сумму для оплаты print("Сумма для оплаты наличными: %.02f" % cash_total)
Упражнение 67. Найти периметр многоугольника
##
# Рассчитаем периметр многоугольника, построенного на основании координат точек,
# введенных пользователем. Пустая строка завершает ввод данных
#
from math import sqrt
# Переменная для хранения периметра многоугольника perimeter = 0
# Запрашиваем координаты первой точки first_x = float(input("Введите первую координату X: "))
first_y = float(input("Введите первую координату Y: "))
# Инициализируем координаты предыдущей точки начальными значениями prev_x = first_x prev_y = first_y
# Запрашиваем остальные координаты line = input("Введите следующую координату X (Enter для окончания ввода): ")
while line != "":
# Преобразуем координату X в число и запрашиваем координату Y
x = float(line)
y = float(input("Введите следующую координату Y: "))
# Рассчитываем расстояние до предыдущей точки и добавляем к периметру dist = sqrt((prev_x – x) ** 2 + (prev_y – y) ** 2)
perimeter = perimeter + dist
# Устанавливаем значения предыдущих координат
# для следующей итерации prev_x = x prev_y = y
# Запрашиваем следующую координату X
line = input("Введите следующую координату X (Enter для окончания ввода): ")
# Рассчитываем расстояние от последней точки до первой и добавляем к периметру dist = sqrt((first_x – x) ** 2 + (first_y – y) ** 2)
Расстояние между точками на плоскости можно рассчитать по теореме Пифагора.

182 
Решения perimeter = perimeter + dist
# Отображаем результат print("Периметр многоугольника равен", perimeter)
Упражнение 69. Билеты в зоопарк
##
# Рассчитать стоимость посещения зоопарка для группы
#
# Константы для хранения цен на разные категории билетов
BABY_PRICE = 0.00
CHILD_PRICE = 14.00
ADULT_PRICE = 23.00
SENIOR_PRICE = 18.00
# Сохраним как константы возрастные ограничения
BABY_LIMIT = 2
CHILD_LIMIT = 12
ADULT_LIMIT = 64
# Переменная для хранения общей суммы посещения total = 0
# Читаем ввод пользователя до пустой строки line = input("Введите возраст посетителя (пустая строка для окончания ввода): ")
while line != "":
age = int(line)
# Добавляем цену билета к общей сумме if age <= BABY_LIMIT:
total = total + BABY_PRICE
elif age <= CHILD_LIMIT:
total = total + CHILD_PRICE
elif age <= ADULT_LIMIT:
total = total + ADULT_PRICE
else:
total = total + SENIOR_PRICE
# Считываем возраст следующего посетителя line = input("Введите возраст посетителя (пустая строка для окончания ввода): ")
# Отображаем сумму группового посещения с правильным форматированием print("Сумма посещения зоопарка для этой группы составит $%.2f" % total)
Упражнение 70. Биты четности
##
# Рассчитать значение бита четности для набора из 8 бит, введенного пользователем
С нынешними правилами первый блок if-elif-else в нашей программе можно и не писать. Но он пригодится, если власти отменят бесплатное посе- щение зоопарка для маленьких деток.

Повторения

183
#
# Запрашиваем первые 8 бит line = input("Введите 8 бит информации: ")
# Продолжаем цикл, пока пользователь не введет пустую строку while line != "":
# Убеждаемся в правильности ввода пользователя if line.count("0") + line.count("1") != 8 or len(line) != 8:
# Выводим сообщение об ошибке print("Это не 8 бит… Попробуйте еще.")
else:
# Считаем единички ones = line.count("1")
Метод count возвращает количество вхождений указанной подстроки в строке, к ко- торой применен.
# Отображаем значение бита четности if ones % 2 == 0:
print("Бит четности должен иметь значение 0.")
else:
print("Бит четности должен иметь значение 1.")
# Считываем следующий ввод пользователя line = input("Введите 8 бит информации: ")
Упражнение 73. Код Цезаря
##
# Реализовать код Цезаря, в котором используются символы, сдвинутые
# на определенное количество позиций.
# Отрицательные значения сдвига можно использовать для декодирования.
#
# Запрашиваем у пользователя сообщение и сдвиг message = input("Введите сообщение: ")
shift = int(input("Введите сдвиг: "))
# Обрабатываем каждый символ для создания зашифрованного сообщения new_message = ""
for ch in message:
if ch >= "a" and ch <= "z":
# Обрабатываем букву в нижнем регистре, определяя ее позицию
# в алфавите (0–25), вычисляя новую позицию и добавляя букву в сообщение pos = ord(ch) – ord("a")
pos = (pos + shift) % 26
new_char = chr(pos + ord("a"))
new_message = new_message + new_char

184 
Решения
Функция ord преобразует символ в целочисленную позицию в таблице ASCII. Функ- ция chr возвращает символ в таблице ASCII по позиции, переданной в качестве ар- гумента.
elif ch >= "A" and ch <= "Z":
# Обрабатываем букву в верхнем регистре, определяя ее позицию
# в алфавите (0–25), вычисляя новую позицию и добавляя букву в сообщение pos = ord(ch) – ord("A")
pos = (pos + shift) % 26
new_char = chr(pos + ord("A"))
new_message = new_message + new_char else:
# Если это не буква, просто сохраняем ее в сообщении new_message = new_message + ch
# Отображаем полученное сообщение print("Новое сообщение", new_message)
Упражнение 75. Палиндром или нет?
##
# Определить, является ли введенная пользователем строка палиндромом
#
# Запрашиваем строку у пользователя line = input("Введите строку: ")
# Предполагаем, что это палиндром, пока не доказано обратное is_palindrome = True
# Сравниваем символы, начиная с двух сторон. Продолжаем, пока не достигнем середины или
# не поймем, что это не палиндром i = 0
while i < len(line) / 2 and is_palindrome:
# Если символы не равны, сразу понимаем, что это не палиндром if line[i] != line[len(line) – i – 1]:
is_palindrome = False
# Переходим к следующему символу i = i + 1
# Вывод результата if is_palindrome:
print(line, " – это палиндром")
else:
print(line, " – это не палиндром")

Повторения

185
Упражнение 77. Таблица умножения
##
# Вывести таблицу умножения от 1 до 10
#
MIN = 1
MAX = 10
# Строка заголовков print(" ", end = "")
for i in range(MIN, MAX + 1):
print("%4d" % i, end = "")
print()
# Выводим таблицу for i in range(MIN, MAX + 1):
print("%4d" % i, end = "")
for j in range(MIN, MAX + 1):
print("%4d" % (i * j), end = "")
print()
Упражнение 79. Наибольший общий делитель
##
# Рассчитаем наибольший общий делитель для двух целых чисел с использованием цикла
#
# Запрашиваем у пользователя два целых числа n = int(input("Введите первое целое число: "))
m = int(input("Введите второе целое число: "))
# Присваиваем d наименьшее из n и m d = min(n, m)
# В цикле находим наибольший общий делитель для двух чисел while n % d != 0 or m % d != 0:
d = d – 1
# Выводим результат print("Наибольший общий делитель для", n, "и", m, "равен", d)
Упражнение 82. Десятичное число в двоичное
##
# Перевести десятичное число в двоичное
#
NEW_BASE = 2
# Запрашиваем число для перевода у пользователя num = int(input("Введите неотрицательное целое число: "))
Указание в качестве последнего аргумента функ- ции print выражения end = “” позволяет избе- жать принудительного перевода строки.

186 
Решения
# Будем сохранять результат в переменной result result = ""
q = num
Алгоритм, предложенный здесь, выражен при помощи цикла repeat-until (повторяй- пока), но за неимением в Python такого типа циклов нам пришлось адаптировать алгоритм для работы с циклом while. Как пример, этого можно достигнуть путем дублирования тела цикла и размещения его непосредственно перед циклом.
# Пишем копию тела цикла вне самого цикла r = q % NEW_BASE
result = str(r) + result q = q // NEW_BASE
# Выполняем цикл, пока q не станет равен нулю while q > 0:
r = q % NEW_BASE
result = str(r) + result q = q // NEW_BASE
# Отображаем результат print(num, "в десятичной системе равно", result, "в двоичной.")
Упражнение 83. Максимальное число
в последовательности
##
# Находим максимумы в случайном ряду из 100 целых чисел
# и считаем количество обновлений максимального значения
#
from random import randrange
NUM_ITEMS = 100
# Генерируем и выводим первое число mx_value = randrange(1, NUM_ITEMS + 1)
print(mx_value)
# В этой переменной будем накапливать количество обновлений максимума num_updates = 0
# Проходим по числам for i in range(1, NUM_ITEMS):
# Генерируем новое случайное число current = randrange(1, NUM_ITEMS + 1)
# Если оно превышает текущий максимум...

Повторения

187
if current > mx_value:
# Обновляем максимум и увеличиваем счетчик на единицу mx_value = current num_updates = num_updates + 1
# Отображаем значение с пометкой print(current, "<== Обновление")
else:
# Отображаем значение print(current)
# Отображаем результаты print("Максимальное значение в ряду:", mx_value)
print("Количество смен максимального значения:", num_updates)

Глава
12
Функции
Упражнение 88. Медиана трех значений
##
# Рассчитываем и выводим на экран медиану трех чисел, введенных пользователем
# В этой программе реализованы две техники вычисления медианы для демонстрации
# разных подходов к решению одной и той же задачи
#
## Рассчитываем медиану трех чисел при помощи блока if
# @param a – первое значение
# @param b – второе значение
# @param c – третье значение
# @return медиана чисел a, b и c
#
def median(a, b, c):
if a < b and b < c or a > b and b > c:
return b if b < a and a < c or b > a and a > c:
return a if c < a and b < c or c > a and b > c:
return c
## Рассчитываем медиану трех чисел при помощи функций min и max и капельки арифметики
# @param a – первое значение
# @param b – второе значение
# @param c – третье значение
# @return медиана чисел a, b и c
#
def alternateMedian(a, b, c):
return a + b + c – min(a, b, c) – max(a, b, c)
# Выводим медиану чисел, введенных пользователем def main():
x = float(input("Введите первое число: "))
y = float(input("Введите второе число: "))
Каждая функция, которую вы пишете, должна начинаться с комментария.
Строки, начинающиеся с конструкции
@param, используются для описания параметров. Строка, начинающаяся с @return, описывает возвращаемое значение.
Медиана трех чисел равна их сумме за вычетом минимального и макси- мального значений.

Функции

189
z = float(input("Введите третье число: "))
print("Медиана равна:", median(x, y, z))
print("С помощью альтернативного метода:", \
alternateMedian(x, y, z))
# Вызываем основную функцию main()
Упражнение 90. Двенадцать дней Рождества
##
# Отображаем полный текст песни The Twelve Days of Christmas.
#
from int_ordinal import intToOrdinal
Функция intToOrdinal, написанная вами для упражнения 89, импортируется здесь, чтобы не нужно было ее дублировать.
## Отображаем один куплет песни The Twelve Days of Christmas
# @param n – куплет для отображения
# @return (None)
def displayVerse(n):
print("On the", intToOrdinal(n), "day of Christmas")
print("my true love sent to me:")
if n >= 12:
print("Twelve drummers drumming,")
if n >= 11:
print("Eleven pipers piping,")
if n >= 10:
print("Ten lords a–leaping,")
if n >= 9:
print("Nine ladies dancing,")
if n >= 8:
print("Eight maids a–milking,")
if n >= 7:
print("Seven swans a–swimming,")
if n >= 6:
print("Six geese a–laying,")
if n >= 5:
print("Five golden rings,")
if n >= 4:
print("Four calling birds,")
if n >= 3:
print("Three French hens,")
if n >= 2:

190 
Решения print("Two turtle doves,")
if n == 1:
print("A", end=" ")
else:
print("And a", end=" ")
print("partridge in a pear tree.")
print()
# Отображаем все 12 куплетов песни def main():
for verse in range(1, 13):
displayVerse(verse)
# Вызываем основную функцию main()
Упражнение 93. Центрируем строку
##
# Центрируем строку в рамках заданного окна
#
WIDTH = 80
## Создаем новую строку, которая будет центрирована в окне заданной ширины
# @param s – строка для центрирования
# @param width – ширина окна, в котором будет центрирована строка
# @return копия строки s с ведущими пробелами для центрирования def center(s, width):
# Если строка слишком длинная, возвращаем оригинал if width < len(s):
return s
# Вычисляем количество пробелов, необходимое для центрирования строки spaces = (width – len(s)) // 2
result = " " * spaces + s
Оператор // используется, чтобы округлить результат деления до целого числа. Опе- ратор / не может быть использован, поскольку возвращает число с плавающей точ- кой, а символ пробела можно поставить только целое количество раз.
return result
# Демонстрируем центрирование строки def main():
print(center("Известная история", WIDTH))
print(center("от:", WIDTH))

Функции

191
print(center("Кого–то известного", WIDTH))
print()
print("Жили–были...")
# Call the main function main()
Упражнение 95. Озаглавим буквы
##
# Заглавные буквы в строке
#
## Озаглавливаем нужные буквы в строке
# @param s – исходная строка для обработки
# @return новая строка def capitalize(s):
# Создаем копию исходной строки, в которой будем собирать итоговую строку result = s
# Делаем заглавной первый непробельный символ в строке pos = 0
while pos < len(s) and result[pos] == ' ':
pos = pos + 1
if pos < len(s):
# Заменяем символ на заглавный, не затрагивая остальные символы в строке result = result[0 : pos] + result[pos].upper() + \
result[pos + 1 : len(result)]
Использование двоеточия внутри квадратных скобок позволяет обратиться к под- строке, которая начинается с индекса, соответствующего числу до двоеточия, и за- канчивается индексом, равным числу справа от двоеточия, не включая его.
# Делаем заглавной первую букву, которая следует за точкой и
# восклицательным или вопросительным знаком pos = 0
while pos < len(s):
if result[pos] == "." or result[pos] == "!" or \
result[pos] == "?":
# Переходим за знак ''.'', ''!'' or ''?''
pos = pos + 1
# Пропускаем пробелы while pos < len(s) and result[pos] == " ":
pos = pos + 1

192 
Решения
# Если не достигли конца строки, меняем текущий символ на заглавную букву if pos < len(s):
result = result[0 : pos] + \
result[pos].upper() + \
result[pos + 1 : len(result)]
# Идем к следующему символу pos = pos + 1
# Делаем заглавными буквы i, когда им предшествует пробел, а следом идет пробел,
# точка, восклицательный или вопросительный знак либо апостроф pos = 1
while pos < len(s) – 1:
if result[pos – 1] == " " and result[pos] == "i" and \
(result[pos + 1] == " " or result[pos + 1] == "." or \
result[pos + 1] == "!" or result[pos + 1] == "?" or \
result[pos + 1] == "'"):
# Заменяем i на I, не затрагивая другие символы result = result[0 : pos] + "I" + \
result[pos + 1 : len(result)]
pos = pos + 1
return result
# Демонстрируем работу функции def main():
s = input("Введите текст: ")
capitalized = capitalize(s)
print("Новая версия:", capitalized)
# Вызываем основную функцию main()
Упражнение 96. Является ли строка целым числом?
##
# Определяем, представляет ли строка, введенная пользователем, целое число
#
## Посмотрим, включает ли строка целочисленное значение
# @param s – строка для проверки
# @return True, если это целое число. Иначе False.
#
def isInteger(s):
# Удаляем пробелы в начале и конце строки s = s.strip()
# Определяем, являются ли оставшиеся символы целыми числами if (s[0] == "+" or s[0] == "–") and s[1:].isdigit():

Функции

193
return True if s.isdigit():
return True return False
# Демонстрируем работу функции isInteger def main():
s = input("Введите строку: ")
if isInteger(s):
print("Строка является целым числом.")
else:
print("Строка не является целым числом.")
# Вызываем основную функцию, только если файл не импортирован if __name__ == "__main__":
main()
Переменной __name__ автоматически присваивается значение при запуске програм- мы на языке Python. При этом если файл запущен напрямую из Python, значение этой переменной будет равняться строке “__main__”, а если импортирован в другую программу – имени модуля.
Упражнение 98. Простое число?
## Определяем, является ли число простым
# @param n – целое число для проверки
# @return True, если число простое, иначе False def isPrime(n):
if n <= 1:
return False
# Проверяем все числа от двух до n, не включая его, на деление n на них без остатка for i in range(2, n):
if n % i == 0:
return False return True
# Определяем, является ли простым введенное пользователем число def main():
value = int(input("Введите целое число: "))
if isPrime(value):
print(value, "– простое число.")
else:
print(value, "не является простым числом.")
# Вызываем основную функцию, только если файл не импортирован
Метод isdigit возвращает True, если строка состоит как ми- нимум из одного символа и все символы в ней являются цифрами.
Если n % i == 0, значит, n без остатка делится на i, а следовательно, оно не простое.

194 
Решения if __name__ == "__main__":
main()
Упражнение 100. Случайный пароль
##
# Генерируем и отображаем случайный пароль, содержащий от 7 до 10 символов
#
from random import randint
SHORTEST = 7
LONGEST = 10
MIN_ASCII = 33
MAX_ASCII = 126
## Генерируем случайный пароль
# @return строка, содержащая случайный пароль def randomPassword():
# Выбираем случайную длину пароля randomLength = randint(SHORTEST, LONGEST)
# Генерируем соответствующее количество случайных символов, добавляя их к результату result = ""
for i in range(randomLength):
randomChar = chr(randint(MIN_ASCII, MAX_ASCII))
result = result + randomChar
Функция chr принимает код ASCII в качестве единственного параметра и возвраща- ет символ, соответствующий этому коду.
# Возвращаем случайный пароль return result
# Генерируем и отображаем случайный пароль def main():
print("Ваш случайный пароль:", randomPassword())
# Вызываем основную функцию, только если файл не импортирован if __name__ == "__main__":
main()
Упражнение 102. Проверка пароля на надежность
##
# Проверка пароля на надежность
#

Функции

195
## Проверяем, является ли пароль надежным. Надежным будем считать пароль, в котором
# как минимум 8 символов, есть большие и маленькие буквы, а также цифры
# @param password – пароль для проверки
# @return True, если пароль надежен, иначе False def checkPassword(password):
has_upper = False has_lower = False has_num = False
# Проверяем каждый символ в пароле for ch in password:
if ch >= "A" and ch <= "Z":
has_upper = True elif ch >= "a" and ch <= "z":
has_lower = True elif ch >= "0" and ch <= "9":
has_num = True
# Если пароль отвечает всем четырем требованиям if len(password) >= 8 and has_upper and has_lower and has_num:
return True
# Если как минимум одно требование не соблюдено return False
# Демонстрируем работу функции def main():
p=input("Введите пароль: ")
if checkPassword(p):
print("Это надежный пароль.")
else:
print("Это ненадежный пароль.")
# Вызываем основную функцию, только если файл не импортирован if __name__ == "__main__":
main()
Упражнение 105. Произвольные системы счисления
##
# Переводим значение из одной системы счисления в другую. Диапазон систем – от 2 до 16
#
from hex_digit import *
Модуль hex_digit содержит функции hex2int и int2hex, которые мы написали, решая упражнение 104. Инструкция import * позволит загрузить все функции из модуля.

196 
Решения
## Переводим число из десятичной системы в произвольную
# @param num – число в десятичной системе для преобразования
# @param new_base – основание для выходного результата
# @return строка в новой системе счисления def dec2n(num, new_base):
# Формируем представление числа в новой системе счисления, сохраняя в result result = ""
q = num
# Первый запуск тела будущего цикла r = q % new_base result = int2hex(r) + result q=q // new_base
# Продолжаем цикл, пока q не станет равен нулю while q > 0:
r = q % new_base result = int2hex(r) + result q = q // new_base
# Возвращаем результат return result
## Переводим число из произвольной системы
# в десятичную
# @param num – число в системе по основанию b,
# сохраненное в виде строки
# @param b – основание преобразуемого числа
# @return число в десятичной системе счисления def n2dec(num, b):
decimal = 0
# Обрабатываем каждую цифру по основанию b for i in range(len(num)):
decimal = decimal * b decimal = decimal + hex2int(num[i])
# Возвращаем результат return decimal
# Преобразуем число между произвольными системами счисления def main():
# Запрашиваем у пользователя исходную систему счисления и число from_base = int(input("Исходная система счисления (2–16): "))
if from_base < 2 or from_base > 16:
print("Допустимый диапазон систем счисления: от 2 до 16.")
print("Выходим...")
quit()
from_num = input("Введите число по этому основанию: ")
Значение по основанию b должно быть представлено в виде строки, поскольку оно может содержать буквы, если основание счисления превышает 10.

Функции

197
# Преобразуем в десятичное число и отображаем результат dec = n2dec(from_num, from_base)
print("Результат: %d по основанию 10." % dec)
# Преобразуем в число с новым основанием и отображаем результат to_base = int(input("Введите требуемую систему счисления (2–16): "))
if to_base < 2 or to_base > 16:
print("Допустимый диапазон систем счисления: от 2 до 16.")
print("Выходим...")
quit()
to_num = dec2n(dec, to_base)
print("Результат: %s по основанию %d." % (to_num, to_base))
# Вызов основной функции main()
Упражнение 107. Максимальное сокращение дробей
##
# Максимальное сокращение дробей
#
## Вычислить наибольший общий делитель для двух целых чисел
# @param n – первое число (должно быть ненулевым)
# @param m – второе число (должно быть ненулевым)
# @return наибольший общий делитель двух целых чисел def gcd(n, m):
# Инициализируем d как меньшее значение из n и m d = min(n, m)
# Используем цикл while для поиска наибольшего общего делителя n и m while n % d != 0 or m % d != 0:
d = d – 1
return d
Для достижения цели функция gcd использует цикл. Также существует простой и эле- гантный способ определения наибольшего общего делителя двух чисел при помощи рекурсии. Эта концепция будет описана в упражнении 174.
## Сокращаем дробь до предела
# @param num – числитель дроби
# @param den – знаменатель дроби (должен быть ненулевым)
# @return числитель и знаменатель сокращенной дроби def reduce(num, den):
# Если числитель равен нулю, сокращенная дробь будет равна 0/1
if num == 0:

198 
Решения return (0, 1)
# Находим наибольший общий делитель числителя и знаменателя g = gcd(num, den)
# Делим числитель и знаменатель на НОД и возвращаем результат return (num // g, den // g)
В функции reduce мы использовали оператор //, чтобы вернуть целочисленные зна- чения числителя и знаменателя.
# Запрашиваем дробь у пользователя и отображаем ее максимально сокращенный вариант def main():
# Запрашиваем числитель и знаменатель у пользователя num = int(input("Введите числитель дроби: "))
den = int(input("Введите знаменатель дроби: "))
# Вычисляем сокращенную дробь
(n, d) = reduce(num, den)
# Выводим результат print("Дробь %d/%d может быть сокращена до %d/%d." % (num, den, n, d))
# Вызов основной функции main()
Упражнение 108. Переводим меры
##
# Преобразуем меры объема ингредиентов в рецептах с целью их более лаконичного
# выражения
# Например, 59 чайных ложек можно сократить до 1 стакана, 3 столовых ложек
# и 2 чайных ложек.
#
TSP_PER_TBSP = 3
TSP_PER_CUP = 48
##
# Преобразуем меры объема ингредиентов в рецептах с целью их более лаконичного
# выражения
# @param num – количество единиц объема для преобразования
# @param unit – единица измерения (''cup'', ''tablespoon'' или ''teaspoon'')
# @return строка, представляющая меры в сокращенной форме def reduceMeasure(num, unit):
# Приводим единицу измерения к нижнему регистру unit = unit.lower()

Функции

199
Единицы измерения приводятся к нижнему регистру путем вызова метода lower и сохранения результата в ту же переменную. Это позволит пользователю вводить меру в любом регистре.
# Вычислим объем в чайных ложках if unit == "teaspoon" or unit == "teaspoons":
teaspoons = num elif unit == "tablespoon" or unit == "tablespoons":
teaspoons = num * TSP_PER_TBSP
elif unit == "cup" or unit == "cups":
teaspoons = num * TSP_PER_CUP
# Преобразуем объем в чайных ложках в другие единицы измерения cups = teaspoons // TSP_PER_CUP
teaspoons = teaspoons – cups * TSP_PER_CUP
tablespoons = teaspoons // TSP_PER_TBSP
teaspoons = teaspoons – tablespoons * TSP_PER_TBSP
# Создаем строковую переменную для хранения результата result = ""
# Добавляем количество стаканов к результату (если надо)
if cups > 0:
result = result + str(cups) + " cup"
# Множественное число if cups > 1:
result = result + "s"
# Добавляем количество столовых ложек к результату (если надо)
if tablespoons > 0:
# Добавляем запятую, если нужно if result != "":
result = result + ", "
result = result + str(tablespoons) + " tablespoon"
# Множественное число if tablespoons > 1:
result = result + "s"
# Добавляем количество чайных ложек к результату (если надо)
if teaspoons > 0:
# Добавляем запятую, если нужно if result != "":
result = result + ", "
result = result + str(teaspoons) + " teaspoon"
# Множественное число if teaspoons > 1:

200 
Решения result = result + "s"
# Обрабатываем ноль if result == "":
result = "0 teaspoons"
return result
В эту программу мы включили сразу несколько вызовов функции для охвата боль- шого числа разнообразных мер.
# Демонстрируем работу функции reduceMeasure путем нескольких обращений def main():
print("59 teaspoons is %s." % reduceMeasure(59, "teaspoons"))
print("59 tablespoons is %s." % \
reduceMeasure(59, "tablespoons"))
print("1 teaspoon is %s." % reduceMeasure(1, "teaspoon"))
print("1 tablespoon is %s." % reduceMeasure(1, "tablespoon"))
print("1 cup is %s." % reduceMeasure(1, "cup"))
print("4 cups is %s." % reduceMeasure(4, "cups"))
print("3 teaspoons is %s." % reduceMeasure(3, "teaspoons"))
print("6 teaspoons is %s." % reduceMeasure(6, "teaspoons"))
print("95 teaspoons is %s." % reduceMeasure(95, "teaspoons"))
print("96 teaspoons is %s." % reduceMeasure(96, "teaspoons"))
print("97 teaspoons is %s." % reduceMeasure(97, "teaspoons"))
print("98 teaspoons is %s." % reduceMeasure(98, "teaspoons"))
print("99 teaspoons is %s." % reduceMeasure(99, "teaspoons"))
# Вызов основной функции main()
Упражнение 109. Магические даты
##
# Определяем все магические даты в XX веке
#
from days_in_month import daysInMonth
## Определяем, является ли дата магической
# @param day – день в дате
# @param month – месяц в дате
# @param year – год в дате
# @return True, если дата является магической, иначе False def isMagicDate(day, month, year):
if day * month == year % 100:
return True
Выражение year % 100 позволяет перейти к представлению года из двух цифр.

Функции

201
return False
# Находим и отображаем все магические даты XX века def main():
for year in range(1900, 2000):
for month in range(1, 13):
for day in range(1, daysInMonth(month, year) + 1):
if isMagicDate(day, month, year):
print("%02d/%02d/%04d – магическая дата." % (day, month, year))
# Вызов основной функции main()