Сборник упражнений и задач
по основам Python
Наш задачник по языку программирования Python содержит как стандартные, так и более продвинутые упражнения и задачи на закрепление теоретических основ излагаемых в учебнике. На данный момент в задачнике представлено более 240 задач и упражнений по Питону с готовыми решениями и ответами. Однако не забывайте, что нужно стараться получать результат самостоятельно. Если же вы не смогли одолеть какое-то задание и посмотрели ответ, закройте его и наберите код вручную, ведь нашей конечной целью является не чтение задач, а практика и успешное их решение.
- Чтобы посмотреть результат выполнения исходного кода решений, используйте кнопку «Результат».
- Чтобы окно консоли после выполнения скрипта сразу не закрывалось, дописывайте в конец скрипта инструкцию input().
- Числа и математические выражения
- Текстовые строки
- Списки
- Кортежи
- Словари
- Множества
- Линейные алгоритмы
- Логические выражения
- Условная инструкция if/elif/else
- Циклы for и while
- Итерации и генераторы
- Функции
- ООП: классы и объекты
- Импорт, модули и пакеты
- Файлы и каталоги
- Обработка исключений
- Утилита pip и виртуальные окружения
- Дата и время
- Олимпиадные задачи
- Первые утилиты, скрипты и программы
- Приложения с GUI
Задачи на числа и математические выражения
Теоретический материал по числам, математическим операциям и модулю math можно почитать в нашем учебнике здесь.
1.1. Выведите на экран строковые представления числа 53 в двоичной, восьмеричной и шестнадцатеричной системах счисления. Показать решение.
# Переводим число в требуемые СС.
print('53 в 2-й СС:', bin(53))
print('53 в 8-й СС:', oct(53))
print('53 в 16-й СС:', hex(53))
53 в 2-й СС: 0b110101 53 в 8-й СС: 0o65 53 в 16-й СС: 0x35
1.2. Даны строковые представления чисел: '011011101' (двоичная СС), '357' (восьмеричная СС) и 'AF23D' (шестнадцатеричная СС). Выведите на экран строковые представления этих чисел в десятичной системе счисления. Показать решение.
# Представление числа в 2-й СС.
num_bin = '011011101'
# Выведет 221 (10-я СС).
print(int(num_bin, base=2))
# Представление числа в 8-й СС.
num_oct = '357'
# Выведет 239 (10-я СС).
print(int(num_oct, base=8))
# Представление числа в 16-й СС.
num_hex = 'AF23D'
# Выведет 717373 (10-я СС).
print(int(num_hex, base=16))
221 239 717373
1.3. Зная, что 1372 является числом в восьмеричной системе счисления, выведите на экран значение этого числа в десятичной системе счисления. Показать решение.
# Сохраним число в переменной.
num_oct = str(1372)
# Выведет 762 (10-я СС).
print(int(num_oct, base=8))
762
1.4. Представьте вещественные числа 275.4, 0.0032 и 3.45 в коде Python в стандартном виде. Напомним, что в математике число в такой форме имеет вид a*10n, где 1 ≤ a < 10, а n – целое число. Например, для числа 0.123 получим 1.23*10-1. Показать решение.
# 275.4.
num_1 = 2.754e2
print(num_1)
# 0.0032.
num_2 = 3.2e-3
print(num_2)
# 3.45.
num_3 = 3.45E0
print(num_3)
275.4 0.0032 3.45
1.5. Найдите наименьшую обыкновенную дробь, равную вещественному числу 14.375, и выведите ее на экран в формате '14.375 = числитель/знаменатель'. Показать решение.
# Получаем числ. и знам., т.е. кортеж (115, 8).
num = 14.375.as_integer_ratio()
# Составляем и выводим строку.
print('14.375 = ', num[0], '/', num[1], sep='')
14.375 = 115/8
1.6. Дано комплексное число 7.5+1.35j. Выведите на экран его действительную и мнимую части, а также число, сопряженное к данному. Показать решение.
# Сохраним число в переменной.
c = 7.5+1.35j
print('Комплексное число', c)
# Выведет 7.5.
print('Действительная часть числа:', c.real)
# Выведет 1.35.
print('Мнимая часть числа:', c.imag)
# Выведет 7.5-1.35j.
print('Сопряженное к 7.5+1.35j:', c.conjugate())
Комплексное число (7.5+1.35j) Действительная часть числа: 7.5 Мнимая часть числа: 1.35 Сопряженное к 7.5+1.35j: (7.5-1.35j)
1.7. Даны два действительных числа a и b. Вычислите их сумму, разность, произведение и частное при a=3.79 и b=84.93. Округлите результаты до сотых и выведите их на экран. Показать решение.
# Присваиваем значения переменным.
a = 3.79
b = 84.93
# Выведет 88.72.
print('a + b =', round(a + b, 2))
# Выведет -81.14.
print('a - b =', round(a - b, 2))
# Выведет 321.88.
print('a*b =', round(a*b, 2))
# Выведет 0.04.
print('a/b =', round(a/b, 2))
a + b = 88.72
a - b = -81.14
a*b = 321.88
a/b = 0.04
1.8. Вычислите значение выражения (10/2.3 - 34)*0.7 + 90.5, округлив результат до трех знаков после десятичной точки и найдя его модуль. Показать решение.
# Найдем результат выражения.
res = (10/2.3 - 3**4)*0.7 + 9**0.5
# Округлим и найдем модуль.
res = abs(round(res, 3))
# Выведем результат на экран.
print('Ответ:', res)
Ответ: 50.657
1.9. Найдите значение выражения в десятичной системе счисления: (1EA16 + 010111012 - 2378 - 68110)*21023. Выведите результат на экран. Показать решение.
''' 1-й вариант '''
# Переводим числа в 10-ю СС.
n_1 = int('1EA', base=16)
n_2 = int('01011101', base=2)
n_3 = int('237', base=8)
n_4 = 681
n_5 = int('2102', base=3)
# Вычисляем и выводим.
res = (n_1 + n_2 - n_3 - n_4)*n_5
# Выведет -16705.
print(res)
''' 2-й вариант '''
# Используем префиксы требуемой СС.
n_1 = 0x1EA
n_2 = 0b01011101
n_3 = 0o237
n_4 = 681
n_5 = int('2102', base=3)
# Вычисляем и выводим.
res = (n_1 + n_2 - n_3 - n_4)*n_5
# Выведет -16705.
print(res)
-16705
-16705
1.10. Извлеките квадратный корень из 196 тремя способами. Показать решение.
# Нам понадобится модуль math.
import math
# Выведем результаты на экран.
print('196**0.5 =', 196**0.5)
print('pow(196, 0.5) =', pow(196, 0.5))
print('math.sqrt(196) =', math.sqrt(196))
196**0.5 = 14.0 pow(196, 0.5) = 14.0 math.sqrt(196) = 14.0
1.11. Выведите на экран результат вычисления sin(π/6) и cos(45°) округлив результат до двух знаков после десятичной точки. Показать решение.
print('sin(π/6) =', round(math.sin(math.pi/6), 2))
print('cos(45°) =', round(math.cos(math.radians(45)), 2))
sin(π/6) = 0.5 cos(45°) = 0.71
1.12. Вычислите значение арифметического выражения при заданных значениях переменных и выведите полученный результат на экран: 5.2a3 + 3b5 - 7.3 при a=3, b=2.5. Показать решение.
# Присваиваем значения переменным.
a = 3
b = 2.5
# Вычисляем выражение.
res = 5.2*pow(a, 3) + 3*b**5 - 7.3
print(res)
426.06874999999997
1.13. Вычислите значение арифметического выражения при заданных значениях переменных и выведите полученный результат на экран: x(3.3 + 2y) - |64:(x + y)| при x=-4.1, y=2. Показать решение.
# Присваиваем значения переменным.
x = -4.1
y = 2
# Вычисляем выражение.
res = x*(3.3 + 2*y) - abs(64/(x + y))
print(res)
-60.406190476190474
1.14. Вычислите значение арифметического выражения при заданных значениях переменных и выведите полученный результат на экран: |m(2m-1) - 35.5|:(3n + 0.8m)2 при m=2, n=5. Показать решение.
# Присваиваем значения переменным.
m = 2
n = 5
# Вычисляем выражение.
res = abs(m**(2*m - 1) - 35.5)/pow((3*n + 0.8*m), 2)
print(res)
0.09979677747133109
1.15. Вычислите значение арифметического выражения при заданных значениях переменных и выведите полученный результат на экран: ln|a2 - 1.5a:b| + e3 при a=5.73, b=1.7. Показать решение.
# Импортируем модуль math.
import math
# Присваиваем значения переменным.
a = 5.73
b = 1.7
# Вычисляем выражение.
res = math.log(abs(pow(a, 2) - 1.5*a/b)) + math.e**3
print(res)
23.40974589863339
1.16. Вычислите значение арифметического выражения при заданных значениях переменных и выведите полученный результат на экран: log4(7x - 3y) + √(lg|10xy|) при x=4, y=-3. Показать решение.
# Импортируем модуль math.
import math
# Присваиваем значения переменным.
x = 4
y = -3
# Вычисляем выражение.
res = math.log((7*x - 3*y), 4) + math.sqrt(math.log(abs(10*x*y), 10))
print(res)
4.046663313200022
1.17. Вычислите значение арифметического выражения при заданных значениях переменных и выведите полученный результат на экран: √(log2(mn+2 - 3e)):(ln(2m) + lg(4n)) при m=5, n=2. Показать решение.
# Импортируем модуль math.
import math
# Присваиваем значения переменным.
m = 5
n = 2
# Вычисляем выражение.
res = math.sqrt(math.log(pow(m, n + 2) - 3*math.e, 2))/(math.log(2*m) + math.log(4*n, 10))
print(res)
0.9497109039993775
1.18. Запишите арифметическое выражение на языке Python в виде строки, а затем выведите полученный результат на экран: cos2(3a - 1) - sin(5a - b)3. Показать решение.
# Импортируем модуль math.
#import math
# Записываем выражение в виде строки.
res = 'pow(math.cos(3*a - 1), 2) - math.sin(pow(5*a - b, 3))'
# Выводим его на экран.
print(res)
pow(math.cos(3*a - 1), 2) - math.sin(pow((5*a - b), 3))
1.19. Запишите арифметическое выражение на языке Python в виде строки, а затем выведите полученный результат на экран: 3tg|√(x + y2) - π| - arctg3(√x + y2). Показать решение.
# Импортируем модуль math.
#import math
# Записываем выражение в виде строки.
res = '3*math.tan(abs(math.sqrt(x + y**2) - math.pi)) - pow(math.atan(math.sqrt(x) + y**2), 3)'
# Выводим его на экран.
print(res)
3*math.tan(abs(math.sqrt(x + y**2) - math.pi)) - pow(math.atan(math.sqrt(x) + y**2), 3)
1.20. Запишите арифметическое выражение на языке Python в виде строки, а затем выведите полученный результат на экран: √(arccos3x - arcsin2y)/arctg|x2 - y2| + 5√π. Показать решение.
# Импортируем модуль math.
#import math
# Записываем выражение в виде строки.
res = 'math.sqrt(math.acos(3*x) - math.asin(2*y))/math.atan(abs(x**2 - y**2)) + pow(math.pi, 1/5)'
# Выводим его на экран.
print(res)
math.sqrt(math.acos(3*x) - math.asin(2*y))/math.atan(abs(x**2 - y**2)) + pow(math.pi, 1/5)
1.21. Вычислите значение арифметического выражения |3√π4 - 8eπ|/ln9.7. Округлите результат до сотых и выведите его на экран. Показать решение.
# Импортируем модуль math.
import math
# Записываем выражение в виде строки.
res = round(abs(pow(math.pi, 4/3) - 8*math.e*math.pi)/math.log(9.7), 2)
# Выводим его на экран.
print(res)
28.04
Задачи на строки
Теоретический материал по строкам можно почитать в нашем учебнике здесь.
Не забываем, что строки относятся к неизменяемому типу данных, поэтому изменить их непосредственно не получится. Но всегда можно получить измененную копию строки и заменить ею хранящуюся в переменной исходную строку.
2.1. Составьте и выведите на экран пользователя строку, в которой через запятую перечислите целое, вещественное и комплексное числа в формате «'int', 'float', 'complex'». Реализуйте вывод двумя способами, использовав в качестве внешних двойные и одинарные кавычки. Показать решение.
'''1-й вариант'''
# Экранировать ничего не нужно.
print("'71', '2.37', '-0.2+3j'")
'''2-й вариант'''
# Экранируем символы кавычек.
print('\'71\', \'2.37\', \'-0.2+3j\'')
'71', '2.37', '-0.2+3j'
'71', '2.37', '-0.2+3j'
2.2. Составьте и выведите на экран пользователя строку-матрешку с содержимым «'4 + "3 + '2 + "1 + '0' " ' " '». Реализуйте вывод четырьмя способами, использовав в качестве внешних все виды кавычек, разрешенных для строк. Показать решение.
'''1-й вариант'''
# Экранируем символы соответствующих кавычек.
матрешка = "'4 + \"3 + '2 + \"1 + '0' \" ' \" '"
print(матрешка)
'''2-й вариант'''
# Экранируем символы соответствующих кавычек.
матрешка = '\'4 + "3 + \'2 + "1 + \'0\' " \' " \''
print(матрешка)
'''3-й вариант'''
# Используем многострочные комментарии.
матрешка = """'4 + "3 + '2 + "1 + '0' " ' " '"""
print(матрешка)
'''4-й вариант'''
# Используем многострочные комментарии.
матрешка = ''''4 + "3 + '2 + "1 + '0' " ' " \''''
print(матрешка)
'4 + "3 + '2 + "1 + '0' " ' " '
'4 + "3 + '2 + "1 + '0' " ' " '
'4 + "3 + '2 + "1 + '0' " ' " '
'4 + "3 + '2 + "1 + '0' " ' " '
2.3. Необходимо вывести на экран пользователя строку с адресом '..\new_dir\tables.py'. Реализуйте вывод двумя способами. Показать решение.
'''1-й вариант'''
# Используем сырую строку.
str_1 = r'..\new_dir\tables.py'
print(str_1, end='\n\n')
'''2-й вариант'''
# А здесь экранируем сами слеши.
str_2 = '..\\new_dir\\tables.py'
print(str_2)
..\new_dir\tables.py
..\new_dir\tables.py
2.4. Дана строка '123456789'. Используя операции индексирования и среза выведите на экран третий и пятый символы, а также подстроку '567'. Реализуйте вывод двумя способами: используя только положительные индексы и только отрицательные. Показать решение.
Ответ. Не забываем, что индексация символов строки начинается с 0, а при использовании отрицательных индексов – с -1. Кроме того, при взятии среза нужно помнить, что символ с индексом равным последнему пределу среза в результат не попадает.
# Сохраним строку в переменной.
str_1 = '123456789'
# Выводим на экран 3-й символ.
print('str_1[2] ->', str_1[2])
print('str_1[-7] ->', str_1[-7], end='\n\n')
# Выводим на экран 5-й символ.
print('str_1[4] ->', str_1[4])
print('str_1[-5] ->', str_1[-5], end='\n\n')
# Теперь выведем подстроку.
print('str_1[4:7] ->', str_1[4:7])
print('str_1[-5:-2] ->', str_1[-5:-2])
str_1[2] -> 3
str_1[-7] -> 3
str_1[4] -> 5
str_1[-5] -> 5
str_1[4:7] -> 567
str_1[-5:-2] -> 567
2.5. Дана строка 'AaBbCcDd'. Используя срезы с шагом получите две строки: только с заглавными и только со строчными буквами. Выведите их на экран. Показать решение.
# Сохраним строку в переменной.
str_1 = 'AaBbCcDd'
# Выводим на экран требуемые строки.
print('str_1[::2] ->', str_1[::2], end='\n\n')
# Смещаем вывод на единицу.
print('str_1[1::2]->', str_1[1::2])
str_1[::2] -> ABCD
str_1[1::2] -> abcd
2.6. Измените строку 'кот', записав ее символы в обратном порядке. Выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'кот'
# Получаем строку-перевертыш.
s = s[::-1]
# Выводим ее на экран.
print(s)
ток
2.7. Дана строка '0123456789'. Удалите из нее первый, пятый и последний символы. Выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = '0123456789'
# Формируем новую строку.
s = s[1:4] + s[5:-1]
# Выводим ее на экран.
print(s)
1235678
2.8. При помощи строк '.', '!' и ' ' (один пробел) сформируйте новую строку '..... ! ! ! .....' и выведите ее на экран. Разрешается использовать только операторы + и . Показать решение.
# Формируем строку.
str_1 = '.'*5 + ' ' + ('!' + ' ')*3 + '.'*5
# Выводим ее на экран.
print(str_1)
..... ! ! ! .....
2.9. Дана строка 'Вот и пришла осень золотая!'. Возьмите ее в кавычки «» и выведите результат на экран. Шестнадцатиричные коды кавычек в Юникоде: 00AB и 00BB. Показать решение.
# Сохраняем строку в переменной.
s = 'Вот и пришла осень золотая!'
# Сохраняем результат.
s = '\u00AB' + s + '\u00BB'
# Выводим результат на экран.
print(s)
«Вот и пришла осень золотая!»
2.10. Подсчитайте количество символов в строке '1a\u0398\t\u03B43s'. Сделайте это сперва устно, а затем проверьте себя программно. Показать решение.
# Получаем количество символов строки.
n = len('1a\u0398\t\u03B43s')
# Выведет 7.
print('В строке "1a\\u0398\\t\\u03B43s" ', n, ' символов.', sep='')
В строке "1a\u0398\t\u03B43s" 7 символов.
2.11. Удалите в строке ' a b c d e f ' все пробелы и выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = ' a b c d e f '
# Удаляем пробелы и заменяем исх. строку.
s = s.replace(' ', '')
# Выводим результат на экран.
print(s)
abcdef
2.12. Дана строка "..-.--..-.--". После каждой точки допишите еще по одной точке и выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = '..-.--..-.--'
# Заменяем каждую точку на две.
s = s.replace('.', '..')
# Выводим измененную копию на экран.
print(s)
....-..--....-..--
2.13. Дана строка '131231442145'. Подсчитайте в ней количество символов '1' и выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = '131231442145'
# Считаем и выводим рез-т на экран.
print('Кол-во единиц:', s.count('1'))
Кол-во единиц: 4
2.14. Посчитайте устно, а затем проверьте себя, выведя на экран сумму индексов символа 'а' в строках 'повар' и 'Пайтон'. Показать решение.
# Находим индексы символа в строках.
ind_1 = 'повар'.index('а')
ind_2 = 'Пайтон'.index('а')
# Выводим рез-т на экран.
print('Сумма индексов:', ind_1 + ind_2)
Сумма индексов: 4
2.15. Даны две переменные: a = 73 и b = 95. Используя метод форматирования строк, выведите на экран их сумму и произведение в форматах 'a + b = c' и 'a*b = c'. Повторите тоже самое, но использовав для этого F-строки. Показать решение.
# Заданные переменные.
a = 73; b = 95
# Форматируем и выводим рез-ты на экран.
print('{} + {} = {}'.format(a, b, a+b))
print('{0}*{1} = {2}'.format(a, b, a*b))
# Используем f-строки.
print(f'\n{a} + {b} = {a+b}')
print(f"{a}*{b} = {a*b}")
73 + 95 = 168
73*95 = 6935
73 + 95 = 168
73*95 = 6935
2.16. Дана строка 'ABCDEF'. Поменяйте в ней первый и последний символы местами и выведите итоговую строку на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'ABCDEF'
# Заменяем строку измененной копией.
s = s[-1] + s[1:-1] + s[0]
# Выводим ее на экран.
print(s)
FBCDEA
2.17. Допишите в конец строки 'автопрогон' ее длину и выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'автопрогон'
# Формируем новую строку.
s += str(len(s))
# Выводим итог на экран.
print(s)
автопрогон10
2.18. Дана строка 'в Ереване'. Подсчитайте в ней количество русских символов 'е' в любом регистре и выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'в Ереване'
# Считаем и выводим рез-т на экран.
print((s.lower()).count('е'))
3
2.19. Подсчитайте количество слов в строке 'Вот и пришла осень золотая!'. Разделителем слов считайте пробел. Выведите результат подсчета на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'Вот и пришла осень золотая!'
# Разбиваем на слова и считаем.
res = len(s.split(' '))
# Выводим результат на экран.
print('Количество слов:', res)
Количество слов: 5
2.20. Найдите количество вхождений подстроки 'ab' в строку 'ab bc ab bd ab be' и поменяйте в каждом случае символы 'a' и 'b' местами. Выведите результаты на экран. Показать решение.
# Сохраним исходную строку в переменной.
s = 'ab bc ab bd ab be'
# Выводим количество вхождений "ab" на экран.
print('Кол-во вхождений "ab": ', s.count('ab'))
# Меняем символы подстрок 'ab' местами.
s = s.replace('ab', 'ba')
# Выводим измененную копию строки на экран.
print(s)
Количество вхождений "ab": 3
ba bc ba bd ba be
2.21. Определите совпадает ли количество круглых открывающихся и круглых закрывающихся скобок в строке 'abs(math.sin(pow((5*a - b), 3)))'. Выведите результат проверки на экран в виде сообщения. Показать решение.
# Сохраняем строку в переменной.
s = 'abs(math.sin(pow((5*a - b), 3)))'
# Вычисляем разность количества скобок.
res = s.count('(') - s.count(')')
# Выводим сообщение в зависимости от рез-та.
if res>0:
print('Открывающих скобок больше.')
elif res<0:
print('Закрывающих скобок больше.')
else:
print('Количество скобок обоих видов равно.')
Количество скобок обоих видов равно.
2.22. Определите есть ли в строке 'Земля-2022' хотя бы один символ арабской цифры от нуля до девяти и выведите результат проверки на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'Земля-2022'
# Предварительный результат.
res = False
''' 1-й вариант. '''
# Запускаем цикл по символам строки.
for simb in s:
# Осуществляем проверку.
if simb.isdigit():
# Сохраняем результат.
res = True
# Прерываем цикл.
break
# Выводим результат на экран.
print(res)
''' 2-й вариант. '''
# Строка цифр для проверки.
nums = '0123456789'
# Запускаем цикл по символам строки.
for simb in s:
# Осуществляем проверку.
if simb in nums:
# Сохраняем результат.
res = True
# Прерываем цикл.
break
# Выводим результат на экран.
print(res)
''' 3-й вариант. '''
# Генератор списка из проверок на цифру.
res = any([simb.isdigit() for simb in s])
# Выводим результат на экран.
print(res)
''' 4-й вариант. '''
# Строка цифр для проверки.
nums = '0123456789'
# Находим пересечение множеств.
res = 1 if set(s)&set(nums) else 0
# Выводим результат на экран.
print(res)
True
True
True
1
2.23. Подсчитайте общее количество алфавитных символов Юникода в строке 'a1, b2, c3, e4, d5, f6.' и выведите результат на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'a1, b2, c3, e4, d5, f6.'
''' 1-й вариант '''
# Инициализируем счетчик букв.
res = 0
# Запускаем цикл по символам строки.
for simb in s:
# Осуществляем проверку.
if simb.isalpha():
# Обновляем счетчик.
res += 1
# Выводим итог на экран.
print('Количество букв:', res)
''' 2-й вариант '''
# Используем генератор списков.
res = len([simb for simb in s if simb.isalpha()])
# Выводим итог на экран.
print('Количество букв:', res)
''' 3-й вариант '''
# Используем встроенную функцию.
res = len(list(filter(lambda simb: simb.isalpha(), s)))
# Выводим итог на экран.
print('Количество букв:', res)
Количество букв: 6
Количество букв: 6
Количество букв: 6
2.24. Подсчитайте количество цифр 7 дробной части десятичного числа 377.37177785772707. Показать решение.
# Преобразуем число в строку.
s = str(377.37177785772707)
# Получаем дробную часть числа.
n = s[s.find('.') + 1:]
# Выводим кол-во цифр 7 в ней.
print(n.count('7'))
8
2.25. Составьте строку, состоящую из заглавных букв латинского алфавита, и выведите ее на экран. В таблице символов Юникода заглавные буквы латинского алфавита занимают диапазон номеров с 65 по 90. Показать решение.
''' 1-й вариант '''
# Инициализируем пустую строку.
s = ''
# Запускаем цикл по символам строки.
for n in range(65, 91):
# Обновляем счетчик.
s += chr(n)
# Выводим итог на экран.
print(s)
''' 2-й вариант '''
# Метод строк + встр-ная ф-ция + lambda.
s = ''.join(map(lambda n: chr(n), range(65, 91)))
# Выводим итог на экран.
print(s)
''' 3-й вариант '''
# Метод строк + генератор списков.
s = ''.join([chr(n) for n in range(65, 91)])
# Выводим итог на экран.
print(s)
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
2.26. Выведите на экран сумму числовых кодов символов строки 'два пижона'. Показать решение.
# Сохраняем строку в переменной.
s = 'два пижона'
''' 1-й вариант '''
# Стартовое значение суммы.
sm = 0
# Организуем цикл по символам строки.
for simb in s:
# Обновляем значение суммы.
sm += ord(simb)
# Выводим сумму на экран.
print(sm)
''' 2-й вариант '''
# Встроенная ф-ция + генератор списков.
print(sum([ord(simb) for simb in s]))
''' 3-й вариант '''
# Встроенные функции + lambda.
print(sum(map(lambda simb: ord(simb), s)))
9742
9742
9742
2.27. Подсчитайте количество русских букв в строке 'Camel - это же верблюд, а не ёж!' и выведите результат на экран. В таблице символов Юникода строчные буквы русского алфавита занимают диапазон номеров с 1040 по 1103, а также 1025 и 1105 для букв Ё и ё. Показать решение.
# Сохраним исходную строку в переменной.
s = 'Camel - это же верблюд, а не ёж!'
''' 1-й вариант '''
# Инициализируем счетчик букв.
res = 0
# Организуем цикл по символам строки.
for simb in s:
# Осуществляем проверку.
if ord(simb) in range(1040, 1104):
# Обновляем счетчик.
res += 1
# Приплюсуем количество русских букв Ё и ё.
res += s.count('Ё') + s.count('ё')
# Выводим количество русских букв на экран.
print('Кол-во русских букв в слове:', res)
''' 2-й вариант '''
# Все русские символы строки добавляются в список после
# проверки их кода на попадание в нужный диапазон Юникода.
res = len([x for x in s if ord(x) in range(1040, 1104)])
# Приплюсуем количество русских букв Ё и ё.
res += s.count('Ё') + s.count('ё')
# Выводим количество русских букв на экран.
print('Кол-во русских букв в слове:', res)
''' 3-й вариант '''
# Встроенные функции + lambda.
res = len(list(filter(lambda x: x if ord(x) in range(1040, 1104) else False, s)))
# Приплюсуем количество русских букв Ё и ё.
res += s.count('Ё') + s.count('ё')
# Выводим количество русских букв на экран.
print('Кол-во русских букв в слове:', res)
Кол-во русских букв в слове: 17
Кол-во русских букв в слове: 17
Кол-во русских букв в слове: 17
2.28. Дана строка '_*..*..*_'. Замените в ней все символы '*' числами, которые соответствуют их номеру вхождения в строку (первая слева имеет номер вхождения один и т.д.). Выведите измененную строку на экран. Показать решение.
# Сохраним исходную строку в переменной.
s = '_*..*..*_'
''' 1-й вариант '''
# Запускаем цикл по кол-ву символа в строке.
for i in range(1, s.count('*')+1):
# Делаем одну замену '*' за раз.
s = s.replace('*', str(i), 1)
# Выводим изм-ную строку.
print(s)
''' 2-й вариант '''
# Восстанавливаем исходную строку.
s = '_*..*..*_'
# Счетчик символов.
k = 0
# Формируемая строка.
s_1 = ''
# Цикл по символам исходной строки.
for simb in s:
# Если звездочку не встретили.
if simb != '*':
# Добавляем символ в строку.
s_1 += simb
else:
# Наращиваем счетчик.
k += 1
# Добавляем номер в строку.
s_1 += str(k)
# Обновляем переменную и выводим изм-ную строку.
print(s := s_1)
_1..2..3_
_1..2..3_
2.29. Подсчитайте, сколько видов букв присутствует в строке 'синхрофазотрон', и выведите результаты на экран. Показать решение.
# Сохраним строку в переменной.
s = 'синхрофазотрон'
''' 1-й вариант '''
# Архив отработанных символов.
simbls = ''
# Цикл по символам целевой строки.
for simb in s:
# Если символ еще не считался.
if simb not in simbls:
# Обновляем архив.
simbls += simb
# Выводим результат на экран.
print('Кол-во видов букв :', len(simbls))
''' 2-й вариант '''
# Множество включает неповторяющиеся элементы.
print('Кол-во видов букв :', len(set(s)))
Кол-во видов букв : 10
Кол-во видов букв : 10
2.30. Дана строка 'акваланг'. Замените в ней все символы 'а' числами, которые соответствуют индексу этого символа в строке. Выведите измененную строку на экран. Показать решение.
# Сохраним исходную строку в переменной.
s = 'акваланг'
''' 1-й вариант '''
# Запускаем цикл по кол-ву символа в строке.
for i in range(s.count('а')):
# Делаем одну замену 'а' на ее индекс.
s = s.replace('а', str(s.index('а')), 1)
# Выводим изм-ную строку.
print(s)
''' 2-й вариант '''
# Восстановим исходную строку.
s = 'акваланг'
# Формируемая промежут. строку.
s_1 = ''
# Нумеруем символы строки.
for tpl in enumerate(s):
# Если букву 'а' не встретили.
s_1 += tpl[1] if tpl[1] != 'а' else str(tpl[0])
# Обновляем переменную и выводим изм-ную строку.
print(s := s_1)
0кв3л5нг
0кв3л5нг
2.31. Подсчитайте количество каждого вида символов в строке 'выхухоль' и выведите результаты на экран. Показать решение.
# Сохраним строку в переменной.
s = 'выхухоль'
''' 1-й вариант '''
# Архив отработанных символов.
simbls = ''
# Цикл по символам целевой строки.
for simb in s:
# Если символ еще не считался.
if simb not in simbls:
# Выводим его кол-во на экран.
print(simb, ':', s.count(simb), end=', ')
# Обновляем архив.
simbls += simb
''' 2-й вариант '''
print()
# Цикл по символам целевой строки.
for simb in set(s):
# Выводим его кол-во на экран.
print(simb, ':', s.count(simb), end=', ')
''' 3-й вариант '''
print()
# Генератор словаря + привидение к множеству.
res = {x: s.count(x) for x in set(s)}
# Выводим словарь формата {'символ': количество, ...}.
print(res)
''' 4-й вариант '''
# Встр-ная ф-ция + lambda + привидение к множеству.
res = list(map(lambda x: (x, s.count(x)), set(s)))
# Список кортежей формата ['символ', количество, ...].
print(res)
в : 1, ы : 1, х : 2, у : 1, о : 1, л : 1, ь : 1,
х : 2, ь : 1, л : 1, в : 1, о : 1, у : 1, ы : 1,
{'х': 2, 'ь': 1, 'л': 1, 'в': 1, 'о': 1, 'у': 1, 'ы': 1}
[('х', 2), ('ь', 1), ('л', 1), ('в', 1), ('о', 1), ('у', 1), ('ы', 1)]
2.32. Измените строку 'Чья это корова там замычала?' таким образом, чтобы символы в словах были записаны в обратном порядке. Разделителем слов считайте пробел. Выведите результат на экран. Показать решение.
# Сохраним исходную строку в переменной.
s = 'Чья это корова там замычала?'
# Разбиваем на слова и переворачиваем их.
li = [w[::-1] for w in s.split(' ')]
# Собираем строку обратно.
s = ' '.join(li)
# Выводим измененную строку.
print(s)
яьЧ отэ аворок мат ?алачымаз
2.33. Дано строковое представление времени таймера '03:25:57'. Выведите на экран количество секунд, оставшихся до момента срабатывания таймера. Используйте формат сообщения «До срабатывания таймера осталось {n} сек.». Показать решение.
# Сохраним строку в переменной.
ts = '03:25:57'
''' 1-й вариант '''
# Берем срезы, приводим к целым числам
# и переводим в секунды часы и минуты.
t = int(ts[:2])*3600 + int(ts[3:5])*60 + int(ts[-2:])
print('До срабатывания таймера осталось {} сек.'.format(t))
''' 2-й вариант '''
# Получаем список строк.
li = ts.split(':')
# Приводим эл-ты списка к целым числам
# и переводим в секунды часы и минуты.
t = int(li[0])*3600 + int(li[1])*60 + int(li[2])
print('До срабатывания таймера осталось {} сек.'.format(t))
До срабатывания таймера осталось 12357 сек.
До срабатывания таймера осталось 12357 сек.
Задачи на списки
Теоретический материал по спискам можно почитать в нашем учебнике здесь.
Не забываем, что списки, в отличие от строк и кортежей, мы можем изменять непосредственно.
3.1. Используя операции индексирования и среза выведите на экран первый и третий элементы списка [1, 2, 3, 4, 5], а также срез списка из первых трех элементов. Реализуйте вывод двумя способами: используя только положительные и только отрицательные индексы. Показать решение.
Ответ. Не забываем, что индексация символов строк, списков и кортежей начинается с 0, а при использовании отрицательных индексов – с -1. Кроме того, при взятии среза нужно помнить, что символ с индексом равным последнему пределу среза в результат не попадает.
# Сохраним список в переменной.
li = [1, 2, 3, 4, 5]
# Выводим на экран 1-й элемент.
print('li[0] ->', li[0])
print('li[-5] ->', li[-5], end='\n\n')
# Выводим на экран 3-й элемент.
print('li[2] ->', li[2])
print('li[-3] ->', li[-3], end='\n\n')
# Теперь выведем срез.
print('li[:3] ->', li[:3])
print('li[0:-2] ->', li[0:-2])
li[0] -> 1
li[-5] -> 1
li[2] -> 3
li[-3] -> 3
li[:3] -> [1, 2, 3]
li[0:-2] -> [1, 2, 3]
3.2. Дан список [[1, 2, ['Ok!', 3]], ['list', 4], 5]. Выведите на экран строку 'Ok!', использовав синтаксис доступа к элементу списка по его индексу. Показать решение.
# Сохраняем список в переменной.
li = [[1, 2, ['Ok!', 3]], ['list', 4], 5]
# Используем цепочку доступа по индексу.
print(li[0][2][0])
Ok!
3.3. Создайте список-матрешку, в который поместите два элемента: целое число и вложенный список, в который поместите еще два элемента: вещественное число и вложенный список, в который поместите еще два элемента: комплексное число и вложенный список, в который поместите еще два элемента: строку и пустой список. Выведите на экран конечную строку. Показать решение.
# Создаем наш список-матрешку.
li = [1, [0.2, [0.3+4j, ['5р.', []]]]]
# Выводим на экран нужное значение.
print(li[1][1][1][0])
5р.
3.4. Дан список ['Санкт', '+', 'Петербург']. Исправьте плюс на дефис и выведите название города на экран использовав доступ к элементам списка по индексам. Показать решение.
# Сохраним список в переменной.
li = ['Санкт', '+', 'Петербург']
# Меняем знак на верный.
li[1] = '-'
# Выводим название на экран.
print(li[0], li[1], li[2], sep='', end='\n\n')
Санкт-Петербург
3.5. Дан список ['a', '1', 'b', '2', 'c', '3']. Разбейте его на два списка: только с буквами и только с числами. Сам список затем удалите, а новые списки выведите на экран, каждый на отдельной строке. Показать решение.
# Сохраним список в переменной.
li = ['a', '1', 'b', '2', 'c', '3']
# Получаем требуемые срезы.
li_1 = li[0::2]
li_2 = li[1::2]
# Сам список удаляем.
del li
# Выводим полученные списки на экран.
print(li_1, li_2, sep='\n\n')
['a', 'b', 'c']
['1', '2', '3']
3.6. Замените в списке [1, 2, 3, 4, 5] первые три элемента их суммой. Затем добавьте в конец списка число 7. Переместите первый элемент конечного списка в предпоследнюю позицию списка. Выведите список на экран. Используйте в решении только доступ по индексу и срезы. Показать решение.
# Сохраним список в переменной.
li = [1, 2, 3, 4, 5]
# Получаем сумму первых 3-х эл-тов.
sum = li[0] + li[1] + li[2]
# Производим замену среза полученной суммой.
li[0:3] = [sum]
# Добавляем в конец списка новый эл-т.
li[len(li):len(li)] = [7]
# Вставляем в предпоследнюю позицию 1-й эл-т.
li[-1:-1] = [li[0]]
# Сам 1-й элемент удаляем (или через del).
li[0:1] = []
# Выводим полученный список на экран.
print(li)
[4, 5, 6, 7]
3.7. Дан список [3, 4, 1, 1, 5, 1]. Выведите на экран: количество всех элементов в списке, количество единиц в списке, индекс первого вхождения единицы в список. Показать решение.
# Сохраним список в переменной.
li = [3, 4, 1, 1, 5, 1]
# Выводим кол-во элементов списка.
print('Количество эл-тов в списке:', len(li))
# Выводим кол-во единиц.
print('Количество единиц:', li.count(1))
# Выводим индекс первого вхождения.
print('Индекс первой единицы:', li.index(1))
Количество эл-тов в списке: 6
Количество единиц: 3
Индекс первой единицы: 2
3.8. Дан пустой список []. Используя методы списков: добавьте в него строку 'a', в конец списка еще и строку 'b', расширьте список за счет списка ['c', 'e'], вставьте в список перед 'e' строку 'd'. Выведите конечный результат на экран. Показать решение.
# Сохраним список в переменной.
li = []
# Добавляем первые два эл-та.
li.append('a')
li.append('b')
# Расширяем за счет списка.
li.extend(['c', 'e'])
# Вставляем перед последним эл-том.
li.insert(li.index('e'), 'd')
# Выводим результат на экран.
print(li)
['a', 'b', 'c', 'd', 'e']
3.9. В предыдущей задаче должен был получиться список ['a', 'b', 'c', 'd', 'e']. Используя методы списков: удалите из него последний элемент, инверсируйте список (измените порядок следования элементов на обратный), удалите элемент со значением 'c', очистите список. Показать решение.
# Сохраним список в переменной.
li = ['a', 'b', 'c', 'd', 'e']
# Удаляем последний эл-т списка.
li.pop()
# Инверсируем список.
li.reverse()
# Удаляем из списка строку 'c'.
li.remove('c')
# Очищаем список.
li.clear()
# Выводим результат на экран.
print(li)
[]
3.10. Дан список неповторяющихся целых чисел [3, -54, 25, 8, 0]. Выведите на экран: сумму его элементов, разность максимального и минимального значений. Показать решение.
# Сохраняем список в переменной.
li = [3, -54, 25, 8, 0]
# Выводим сумму эл-тов.
print('sum(li) =', sum(li))
# Выводим max - min.
print('max(li) - min(li) =', max(li) - min(li))
sum(li) = -18
max(li) - min(li) = 79
3.11. Дан список чисел [7, 7, -4, 2.5, -.9, 0]. Выведите на экран количество отрицательных элементов. Показать решение.
# Сохраняем список в переменной.
li = [7, 7, -4, 2.5, -.9, 0]
''' 1-й вариант '''
# Размер списка с отриц. эл-тами.
n = len([x for x in li if x < 0])
# Выводим рез-т на экран.
print('Кол-во отриц. эл-тов:', n)
''' 2-й вариант '''
# Счетчик отрицательных чисел.
n = 0
# Цикл по элементам списка.
for elem in li:
# Если текущий эл-т меньше нуля.
if elem < 0:
# Увеличиваем счетчик на 1.
n += 1
# Выводим рез-т на экран.
print('Кол-во отриц. эл-тов:', n)
Кол-во отриц. эл-тов: 2
Кол-во отриц. эл-тов: 2
3.12. Дан список неповторяющихся вещественных чисел [0.3, -2.4, 4.5, 0.0, -3.1]. Выведите на экран индекс минимального элемента. Показать решение.
# Сохраняем список в переменной.
li = [0.3, -2.4, 4.5, 0.0, -3.1]
# Получаем индекс мин. эл-та.
i = li.index(min(li))
# Выводим рез-т на экран.
print('Индекс мин. эл-та:', i)
Индекс мин. эл-та: 4
3.13. Дан список целых чисел [9, -3, 5, 0, -3]. Выведите на экран сумму абсолютных значений его элементов. Показать решение.
# Сохраняем список в переменной.
li = [9, -3, 5, 0, -3]
''' 1-й вариант '''
# Встр. ф-ция + генератор списков.
s = sum([abs(x) for x in li])
# Выводим рез-т на экран.
print('Сумма абс. значений эл-тов:', s)
''' 2-й вариант '''
# Счетчик суммы эл-тов.
s = 0
# Цикл по элементам списка.
for elem in li:
# Наращиваем сумму.
s += abs(elem)
# Выводим рез-т на экран.
print('Сумма абс. значений эл-тов:', s)
''' 3-й вариант '''
# Встр. ф-ция + lambda.
s = sum(map(lambda x: abs(x), li))
# Выводим рез-т на экран.
print('Сумма абс. значений эл-тов:', s)
Сумма абс. значений эл-тов: 20
Сумма абс. значений эл-тов: 20
Сумма абс. значений эл-тов: 20
3.14. Дан список неповторяющихся целых чисел [9, -210, 0, 500, -37]. Поменяйте местами максимальный и минимальный элементы списка. Выведите измененный список на экран. Показать решение.
# Сохраняем список в переменной.
li = [9, -210, 0, 500, -37]
# Получаем индекс мин. эл-та.
i_min = li.index(min(li))
# Получаем индекс макс. эл-та.
i_max = li.index(max(li))
# Меняем элементы местами.
li[i_min], li[i_max] = li[i_max], li[i_min]
# Выводим список на экран.
print(li)
[9, 500, 0, -210, -3.7]
3.15. Дан список целых чисел [3, 2, 3, 2, 1, 4]. Расположите числа в порядке убывания их значений, а затем добавьте в конец списка его длину. Выведите измененный список на экран. Показать решение.
# Сохраняем список в переменной.
li = [3, 2, 3, 2, 1, 4]
# Сортируем эл-ты списка.
li.sort(reverse=True)
# Добавляем в конец списка его длинну.
li.append(len(li))
# Выводим список на экран.
print(li)
[4, 3, 3, 2, 2, 1, 6]
3.16. Дан список [True, 5, 'go', 3+0.1j]. Циклически сдвиньте все его элементы на одну позицию вправо так, чтобы li[0] перешел на место li[1], li[1] — на место li[2], ..., а последний элемент перешел на место li[0]. Выведите измененный список на экран. Показать решение.
# Сохраняем список в переменной.
li = [True, 5, 'go', 3+0.1j]
# Удаляем последний эл-т и вставляем в начало.
li.insert(0, li.pop())
# Выводим список на экран.
print(li)
[(3+0.1j), True, 5, 'go']
3.17. Дан список натуральных чисел [13, 5, 5, 8, 16, 4]. Удалите из него первое четное число, имеющее нечетный индекс. Выведите измененный список на экран. Показать решение.
# Сохраняем список в переменной.
li = [13, 5, 5, 8, 16, 4]
# Запускаем цикл по нечет. индексам.
for i in range(1, len(li), 2):
# Проверяем на четность.
if li[i]%2 == 0:
# Удаляем эл-т.
del li[i]
# Цикл сразу прерываем.
break
# Выводим список на экран.
print(li)
[13, 5, 5, 16, 4]
3.18. Дан список строк ['уж', 'змея', '', 'питон']. Удалите из него все строки с длиной менее пяти символов и выведите результат на экран. Показать решение.
''' 1-й вариант '''
# Создаем список для манипуляций.
li = ['уж', 'змея', '', 'питон']
# Выведем для наглядности.
print('Стартовый список:', li)
# Стартовое значение индекса.
i = 0
# Длина списка.
ln = len(li)
# Запускаем цикл по индексам списка.
while i < ln:
# Если в строке менее 5 символов.
if len(li[i]) < 5:
# Удаляем элемент.
del li[i]
# Не забываем уменьшить длину списка,
# иначе индекс может выйти за его пределы.
ln -= 1
else:
# Если элемент удален не был,
# наращиваем индекс.
i += 1
# Получим ['питон'].
print('Конечный результат: ', li, end='\n\n')
''' 2-й вариант '''
# Восстанавливаем список.
li = ['уж', 'змея', '', 'питон']
# Выведем для наглядности.
print('Стартовый список:', li)
# Можно и через генератор списков.
li = [x for x in li if len(x) > 4]
# Получим ['питон'].
print('Конечный результат: ', li, end='\n\n')
''' 3-й вариант '''
# Восстанавливаем список.
li = ['уж', 'змея', '', 'питон']
# Выведем для наглядности.
print('Стартовый список:', li)
# Используем фильтрацию эл-тов.
li = list(filter(lambda x: len(x) > 4, li))
# Получим ['питон'].
print('Конечный результат: ', li)
Стартовый список: ['уж', 'змея', '', 'питон']
Конечный результат: ['питон']
Стартовый список: ['уж', 'змея', '', 'питон']
Конечный результат: ['питон']
Стартовый список: ['уж', 'змея', '', 'питон']
Конечный результат: ['питон']
3.19. Дан список ['три', [2, 5], 0.7, 'home']. Создайте список типов элементов данного списка и выведите результат на экран. Показать решение.
# Сохраняем список в переменной.
li = ['три', [2, 5], 0.7, 'home']
''' 1-й вариант '''
# Приемник найденных типов.
types = []
# Цикл по эл-там целевого списка.
for elem in li:
# Получаем тип элемента.
elem_type = type(elem)
# Если тип еще не попадался.
if elem_type not in types:
# Добавляем тип в приемник.
types.append(elem_type)
# Выводим список типов на экран.
print(types)
''' 2-й вариант '''
# Приемник найденных типов.
types = []
# Можно и через генератор списков.
[types.append(el_tp) for x in li if (el_tp := type(x)) not in types]
# Выводим список типов на экран.
print(types)
[<class 'str'>, <class 'list'>, <class 'float'>]
[<class 'str'>, <class 'list'>, <class 'float'>]
3.20. Дан список [1.0, 'ok', True, 'ok', 7, 1]. Удалите из него повторяющиеся элементы (в списке не должно остаться дублей). Выведите измененный список на экран. Будьте внимательны! Значения 1.0, True и 1 – это не дубли! Показать решение.
# Сохраняем список в переменной.
li = [1.0, 'ok', True, 'ok', 7, 1]
# Приемник отработанных эл-тов.
els = []
# Цикл по эл-там целевого списка.
for e in li:
# Если эл-т еще не попадался.
if e in els:
# Еще проверим на идентичность по типу.
if e is not els[els.index(e)]:
# Добавляем эл-т в приемник.
els.append(e)
else:
# Добавляем эл-т в приемник.
els.append(e)
# Выводим список на экран.
print(li := els)
[1.0, 'ok', True, 7, 1]
3.21. Даны два списка строк ['1', 'True', 'ok'] и ['no', 'True', 'no']. Сформируйте новый список, который будет состоять из строк, которые присутствуют хотя бы в одном из списков. Выведите полученный список на экран. Показать решение.
# Сохраняем списки в переменных.
li_1 = ['1', 'True', 'ok']
li_2 = ['no', 'True', 'no']
''' 1-й вариант '''
# Новый список.
li = []
# Цикл по эл-там 1-го списка.
for s in li_1 + li_2:
# Если строка еще не попадалась.
if s not in li:
# Добавляем ее в список.
li.append(s)
# Выводим список на экран.
print(li)
''' 2-й вариант '''
# Новый список.
li = []
# Используем генератор списков.
[li.append(s) for s in li_1+li_2 if s not in li]
# Выводим список на экран.
print(li)
''' 3-й вариант '''
# Используем объединение множеств.
li = list(set(li_1)|set(li_2))
# Выводим список на экран.
print(li)
['1', 'True', 'ok', 'no']
['1', 'True', 'ok', 'no']
['1', 'ok', 'no', 'True']
3.22. Дан список [1, None, 3.0, [1, 2], 'b']. Поменяйте в нем соседние элементы местами. Т.к. число элементов в списке нечетное, последний элемент оставьте на своем месте. Выведите измененный список на экран. Показать решение.
# Сохраняем список в переменной.
li = [1, None, 3.0, [1, 2], 'b']
# Цикл по индексам списка.
for i in range(0, len(li)-1, 2):
# Меняем соседние эл-ты местами.
li[i], li[i+1] = li[i+1], li[i]
# Выводим список на экран.
print(li)
[None, 1, [1, 2], 3.0, 'b']
Задачи на кортежи
Теоретический материал по кортежам можно почитать в нашем учебнике здесь.
Не забываем, что кортежи относятся к неизменяемому типу данных, поэтому изменить их непосредственно не получится. Но всегда можно получить измененную копию кортежа и заменить ею хранящийся в переменной исходный кортеж. Следует заметить, что практически все задачи для списков можно адресовать и кортежам, т.к. они легко конвертируемы в списки и обратно при помощи конструкторов list(tpl) и tuple(li). Однако кортежи в основном предназначены для хранения неизменяемых данных, поэтому для них первостепенными следует считать задачи по извлечению значений и получению индексов элементов.
4.1. Создайте кортеж, в качестве элементов которого используйте целое, вещественное и комплексное числа, кортеж с одним элементом в виде строки, пустой кортеж и пустой список. Выведите на экран строку вложенного кортежа. Показать решение.
Ответ. Не забываем, что при создании кортежа с одним элементом нужно завершать его запятой, иначе интерпретатор не отличит кортеж от простого выражения.
# Создаем кортеж.
tpl = (1, 0.2, 0.3+4j, ('5',), (), [])
# Выводим строку вложенного кортежа на экран.
print(tpl[3][0])
5
4.2. Создайте кортеж-матрешку, в который поместите два элемента: целое число и вложенный кортеж, в который поместите еще два элемента: вещественное число и вложенный кортеж, в который поместите еще два элемента: комплексное число и вложенный кортеж, в который поместите еще два элемента: строку и пустой кортеж. Выведите на экран конечную строку. Обратите внимание на схожесть решения с задачей 3.3. Показать решение.
# Создаем наш кортеж-матрешку.
tpl = (1, (0.2, (0.3+4j, ('5р.', ()))))
# Выводим на экран нужное значение.
print(tpl[1][1][1][0])
5р.
4.3. Используя операции индексирования и среза выведите на экран первый и третий элементы кортежа (1, 2, 3, 4, 5), а также срез кортежа из первых трех элементов. Реализуйте вывод двумя способами: используя только положительные и только отрицательные индексы. Обратите внимание на схожесть решения и результатов с задачей 3.1. Показать решение.
Ответ. Не забываем, что индексация символов строк, списков и кортежей начинается с 0, а при использовании отрицательных индексов – с -1. Кроме того, при взятии среза нужно помнить, что символ с индексом равным последнему пределу среза в результат не попадает.
# Сохраним кортеж в переменной.
tpl = (1, 2, 3, 4, 5)
# Выводим на экран 1-й элемент.
print('tpl[0] ->', tpl[0])
print('tpl[-5] ->', tpl[-5], end='\n\n')
# Выводим на экран 3-й элемент.
print('tpl[2] ->', tpl[2])
print('tpl[-3] ->', tpl[-3], end='\n\n')
# Теперь выведем срез.
print('tpl[:3] ->', tpl[:3])
print('tpl[0:-2] ->', tpl[0:-2])
tpl[0] -> 1
tpl[-5] -> 1
tpl[2] -> 3
tpl[-3] -> 3
tpl[:3] -> (1, 2, 3)
tpl[0:-2] -> (1, 2, 3)
4.4. Дан кортеж ((1, 2, ('Ok!', 3)), ('tuple', 4), 5). Выведите на экран строку 'Ok!', использовав синтаксис доступа к элементу кортежа по его индексу. Обратите внимание на схожесть решения и результатов с задачей 3.2. Показать решение.
# Сохраняем кортеж в переменной.
tpl = ((1, 2, ('Ok!', 3)), ('tuple', 4), 5)
# Используем цепочку доступа по индексу.
print(tpl[0][2][0])
Ok!
4.5. Дан кортеж (3, 's', 1, 5, 's'). Выведите на экран: количество всех элементов кортежа, количество строк 's', индекс первого вхождения 's' в кортеж. Показать решение.
# Сохраним кортеж в переменной.
tpl = (3, 's', 1, 5, 's')
# Выводим кол-во элементов кортежа.
print("Количество эл-тов в кортеже:", len(tpl))
# Выводим кол-во строк 's'.
print("Количество строк 's':", tpl.count('s'))
# Выводим индекс первого вхождения.
print("Индекс первой 's':", tpl.index('s'))
Количество эл-тов в кортеже: 5
Количество строк 's': 2
Индекс первой 's': 1
4.6. Дан кортеж (['кит', 1, 3], 5). Замените в списке 'кит' на 'кот', удалите единицу, а также измените значение последнего элемента списка, возведя тройку в квадрат. Выведите кортеж на экран. Попробуйте изменить второй элемент кортежа, умножив его на два. Объясните результат. Показать решение.
Ответ. Мы не можем изменять сами кортежи, т.е. удалять, добавлять или перемещать его элементы, которые представляют собой объекты произвольного типа. Однако изменять значения элементов кортежа, которые являются объектами изменяемых типов мы можем.
# Сохраним кортеж в переменной.
tpl = (['кит', 1, 3], 5)
# Изменяем первый эл-т вложенного списка.
tpl[0][0] = 'кот'
# Удаляем 2-й эл-т вложенного списка.
del tpl[0][1]
# Изменяем 2-й эл-т (ранее он был 3-м).
tpl[0][1] *= 3
# Выводим кортеж на экран.
print(tpl)
# Пробуем изменить 2-й эл-т кортежа.
tpl[1] *= 2
# Получаем ошибку.
(['кот', 9], 5)
'tuple' object does not support item assignment
Задачи на словари
Теоретический материал по словарям можно почитать в нашем учебнике здесь.
5.1. Создайте словарь d = {'1': 0, 2: 0, '3': 0} тремя способами. Выведите полученный словарь на экран. Показать решение.
''' 1-й вариант '''
# Создаем при помощи фигурных скобок.
d_1 = {'1': 0, 2: 0, '3': 0}
# Выводим словарь на экран.
print(d_1, end='\n\n')
''' 2-й вариант '''
# Используем конструктор и список пар.
d_2 = dict([('1', 0), (2, 0), ('3', 0)])
# Выводим словарь на экран.
print(d_2, end='\n\n')
''' 3-й вариант '''
# Создаем при помощи метода класса.
d_3 = {}.fromkeys(['1', 2, '3'], 0)
# Выводим словарь на экран.
print(d_3)
{'1': 0, 2: 0, '3': 0}
{'1': 0, 2: 0, '3': 0}
{'1': 0, 2: 0, '3': 0}
5.2. Создайте словарь содержащий данные о человеке. В качестве ключей используйте строки 'имя', 'возраст' и 'пол'. Значения придумайте самостоятельно. Выведите полученный словарь на экран. Показать решение.
''' 1-й вариант '''
# Пары «ключ: значение» перечисляем через запятую.
person = {'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}
print(person)
''' 2-й вариант '''
# Используем пары «идентификатор = значение».
person = dict(имя = 'Олег', пол = 'муж.', возраст = 25)
print(person)
''' 3-й вариант '''
# Используем список с кортежами пар.
person = dict([('имя', 'Олег'), ('пол', 'муж.'), ('возраст', 25)])
print(person)
{'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}
{'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}
{'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}
5.3. Дан словарь d = {'1': 1.29, '2': 0.43}. Используя доступ к элементам словаря по ключу, найдите произведение 1.29*0.43, после чего добавьте результат в словарь, а затем выведите значение нового элемента на экран. Показать решение.
# Сохраняем словарь в переменной.
d = {'1': 1.29, '2': 0.43}
# Вычисляем произведение и заносим в словарь.
d['3'] = d['1']*d['2']
# Выведет 0.5547.
print("1.29*0.43 =", d['3'])
1.29*0.43 = 0.5547
5.4. Найдите представления ключей, значений и элементов словаря d = {1: 1, '2': 2, '3': 3, 4: 4}. Выведите их на экран в виде списков. Показать решение.
# Сохраняем словарь в переменной.
d = {1: 1, '2': 2, '3': 3, 4: 4}
# Сохраняем представления в переменных.
k = d.keys()
v = d.values()
i = d.items()
# Выводим их все на экран.
print('Ключи:', list(k))
print('Значения:', list(v))
print('Эл-ты:', list(i))
Ключи: [1, '2', '3', 4]
Значения: [1, 2, 3, 4]
Эл-ты: [(1, 1), ('2', 2), ('3', 3), (4, 4)]
5.5. Сколько элементов будет содержать словарь d_1 = {'1': 1, '2': 2} после добавления к нему элементов словаря d_2 = {'2': 'two', '3': 3}? Каковы будут значения элементов итогового словаря? Проверьте свой ответ программно. Показать решение.
Ответ. В ходе выполнения инструкции d_1.update(d_2) элементы второго словаря добавляются в первый, замещая собой в случае необходимости элементы первого словаря с идентичными ключами. Следовательно, итоговый словарь будет состоять из трех элементов и иметь вид {'1': 1, '2': 'two', '3': 3}.
# Сохраняем словари в переменных.
d_1 = {'1': 1, '2': 2}
d_2 = {'2': 'two', '3': 3}
# Обновляем 1-й словарь за счет 2-го.
d_1.update(d_2)
# Выводим итоговый словарь на экран.
print("d_1.update(d_2) ->", d_1, end='\n\n')
# Выводим кол-во эл-тов словаря.
print("len(d_1) ->", len(d_1))
d_1.update(d_2) -> {'1': 1, '2': 'two', '3': 3}
len(d_1) -> 3
5.6. Удалите из словаря d = {'a': 1, 'b': 2, 'c': 3} элементы d['a'] и d['c'], использовав для второго элемента оператор удаления, а для первого имеющийся у словарей метод. Выведите результат на экран, после чего очистите словарь. Показать решение.
# Сохраняем словарь в переменной.
d = {'a': 1, 'b': 2, 'c': 3}
# Удаляем d['a'].
d.pop('a')
# Удаляем d['c'].
del d['c']
# Выводим словарь на экран.
print(d)
# Очищаем его.
d.clear()
{'b': 2}
5.7. Требуется создать словарь colors для хранения информации о представлениях цветов HTML в виде специальных названий, а также в цветовой модели RGB в десятичном и шестнадцатеричном форматах. Сохраните в словаре информацию для черного, серого и белого цветов. В HTML эти цвета могут задаваться, соответственно:
- по названиям: black, grey и white;
- в 10-м формате: rgb(0, 0, 0), rgb(128, 128, 128) и rgb(255, 255, 255);
- в 16-м формате: #000000, #808080 и #FFFFFF.
# Используем вложенные словари.
colors = {
'черный': {'name': 'black', 'rgb10': 'rgb(0, 0, 0)', 'rgb16': '#000000'},
'серый': {'name': 'grey', 'rgb10': 'rgb(128, 128, 128)', 'rgb16': '#808080'},
'белый': {'name': 'white', 'rgb10': 'rgb(255, 255, 255)', 'rgb16': '#000000'},
}
# Получаем представления целевого цвета.
c_name = colors['серый']['name']
c_10 = colors['серый']['rgb10']
c_16 = colors['серый']['rgb16']
# Выводим их на экран.
print('color: {};'.format(c_name))
print('color: {};'.format(c_10))
print('color: {};'.format(c_16))
color: grey;
color: rgb(128, 128, 128);
color: #808080;
5.8. Создайте словарь-матрешку, в который поместите элемент со строковым ключом в формате целого числа и значением в виде вложенного словаря, в который поместите элемент со строковым ключом в формате вещественного числа и значением в виде вложенного словаря, в который поместите элемент со строковым ключом в формате комплексного числа и значением в виде вложенного словаря, в который поместите элемент со строковым ключом в формате пустого списка и значением в виде вложенного словаря, в который поместите элемент со строковым ключом в формате кортежа с одним элементом и значением в виде строки 'Ok!'. Выведите на экран конечную строку. Показать решение.
# Создаем наш словарь-матрешку.
d = {'1': {'0.2': {'0.3+4j': {'[]': {'(5,)': 'Ok!'}}}}}
# Выводим на экран нужное значение.
print(d['1']['0.2']['0.3+4j']['[]']['(5,)'])
Ok!
5.9. Дан список ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс']. Создайте словарь с ключами 'd1', 'd2', ..., соответствующими индексам элементов списка. Выведите на экран элемент словаря, который соответствует среде, в формате ключ: значение. Показать решение.
# Сохраним список в переменной.
li = ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс']
''' 1-й вариант '''
# Используем генератор словарей.
days = {'d' + str(li.index(e)): e for e in li}
print('d3:', days['d3'])
''' 2-й вариант '''
# Создаем пустой словарь.
days = {}
# Организуем цикл по эл-там списка.
for e in li:
# Добавляем эл-т в словарь.
days['d' + str(li.index(e))] = e
print('d3:', days['d3'])
d3: Чт
d3: Чт
5.10. Дан словарь с натуральными ключами {1: 'Один', 2: 'Два', 3: 'Три', 100: 'сто'}. Выведите на экран сумму ключей, максимальное и минимальное значения ключей, а также их количество. Показать решение.
# Сохраним словарь в переменной.
d = {1: 'Один', 2: 'Два', 3: 'Три', 100: 'сто'}
# Получим представление ключей словаря.
ks = d.keys()
# Стартовое значение суммы ключей.
s_for = 0
# Суммируем ключи циклом.
for k in ks: s_for += k
# Выводим сумму на экран.
print('s_for:', s_for)
# Или еще проще.
print('s_sum:', sum(ks))
# Выводим остальные рез-ты на экран.
print('max_val:', max(ks))
print('min_val:', min(ks))
print('Кол-во ключей:', len(ks))
s_for: 106
s_sum: 106
max_val: 100
min_val: 1
Кол-во ключей: 4
5.11. Дан словарь со значениями констант {'pi': 3.14, 'e': 2.71, 'fi': 1.62}. Выведите на экран значения констант, которые превышают число 2.5. Показать решение.
# Сохраним словарь в переменной.
d = {'pi': 3.14, 'e': 2.71, 'fi': 1.62}
# Получим представление значений словаря.
vs = d.values()
# Выводим целевые значения циклом.
for v in vs:
# Проверяем условие вывода.
if v > 2.5: print(v)
3.14
2.71
5.12. Поменяйте в словаре d = {1: '1', 2: '2', 3: '3', 4: '4'} ключи и значения местами. Выведите итоговый словарь на экран. Показать решение.
# Сохраним словарь в переменной.
d = {1: '1', 2: '2', 3: '3', 4: '4'}
# Выводим исходный словарь на экран.
print(d, end='\n\n')
''' 1-й вариант '''
# Меняем местами ключи и значения словаря.
d = {v: k for k, v in d.items()}
# Выводим измененный словарь на экран.
print(d)
''' 2-й вариант '''
# Восстанавливаем исходный словарь.
d = {1: '1', 2: '2', 3: '3', 4: '4'}
# Промежуточный словарь.
vk = {}
# Меняем местами ключи и значения словаря.
for k, v in d.items(): vk[v] = k
# Делаем замену исходного словаря на новый.
d = vk
# Выводим измененный словарь на экран.
print(d)
''' 3-й вариант '''
# Восстанавливаем исходный словарь.
d = {1: '1', 2: '2', 3: '3', 4: '4'}
# Меняем местами ключи и значения словаря.
d = dict(zip(d.values(), d.keys()))
# Выводим измененный словарь на экран.
print(d)
{1: '1', 2: '2', 3: '3', 4: '4'}
{'1': 1, '2': 2, '3': 3, '4': 4}
{'1': 1, '2': 2, '3': 3, '4': 4}
{'1': 1, '2': 2, '3': 3, '4': 4}
5.13. Удалите из словаря d = {1: 1, '2': 2, '3': 3, 4: 4} все элементы со строковыми ключами. Помните, что изменение размеров словаря во время итерации может привести к ошибке, поэтому для работы используйте копию словаря. Выведите итоговый словарь на экран. Показать решение.
# Сохраняем словарь в переменной.
d = {1: 1, '2': 2, '3': 3, 4: 4}
# Выводим словарь на экран.
print('Стартовый словарь:', d)
# Представление ключей словаря d.
k = d.keys()
# Но работать будем с копией.
d_copy = d.copy()
# Обходим все ключи представления.
for key in k:
# Если ключ является строкой,
if isinstance(key, str):
# удаляем его.
del d_copy[key]
# Заносим в переменную измененную копию.
d = d_copy
# Выводим измененный словарь на экран.
print('Измененный словарь:', d)
Стартовый словарь: {1: 1, '2': 2, '3': 3, 4: 4}
Измененный словарь: {1: 1, 4: 4}
5.14. Дан словарь с товарами. Выведите на экран все товары, цена которых не превышает 100 рублей, а текущий остаток не менее 10 кг. Показать решение.
goods = {
"apple": {"name": "Яблоки", "cost": 25, "kg": 30},
"pear": {"name": "Груши", "cost": 50, "kg": 5},
"plum": {"name": "Сливы", "cost": 55, "kg": 25},
"cherry": {"name": "Вишни", "cost": 110, "kg": 15}
}
# Словарь товаров.
goods = {
"apple": {"name": "Яблоки", "cost": 25, "kg": 30},
"pear": {"name": "Груши", "cost": 50, "kg": 5},
"plum": {"name": "Сливы", "cost": 55, "kg": 25},
"cherry": {"name": "Вишни", "cost": 110, "kg": 15}
}
# Цикл по ключам словаря.
for k in goods:
# Проверяем условие для товара.
if goods[k]['cost'] <= 100 and goods[k]['kg'] >= 10:
# Выводим название товара на экран.
print(goods[k]['name'])
Яблоки
Сливы
Задачи на множества
Теоретический материал по множествам можно почитать в нашем учебнике здесь.
6.1. Создайте множество, в качестве элементов которого используйте целое, вещественное и комплексное числа, а также строки в формате кортежа, списка и словаря, содержащих по одному элементу. Выведите полученное множество на экран. Показать решение.
Ответ. Не забываем, что при создании множества следует использовать только неизменяемые элементы.
# Создаем множество.
st = {1, 0.2, 0.3+4j, '(5,)', '[6]', '{7: 8}'}
# Выводим его на экран.
print(st)
{0.2, 1, '[6]', '{7: 8}', '(5,)', (0.3+4j)}
6.2. Дано множество {'a', 'b', 'c'}. Удалите из него строку 'c', а затем добавьте элемент 'd'. Выведите итоговое множество на экран. Показать решение.
# Сохраняем множество в переменной.
s = {'a', 'b', 'c'}
# Удаляем указанный эл-т.
s.remove('c')
# Добавляем эл-т.
s.add('d')
# Выводим итог на экран.
print(s)
{'a', 'b', 'd'}
6.3. Даны множества {'a', 'b'} и {'b', 'c'}. Множества простые, поэтому сперва назовите результат их объединения, пересечения, разности и симметричной разницы устно, а затем проверьте себя, выведя результаты на экран. Показать решение.
# Сохраняем множества в переменных.
s_1 = {'a', 'b'}
s_2 = {'b', 'c'}
# Объединение: {'b', 'c', 'a'}.
print('s_1 | s_2 ->', s_1 | s_2)
# Пересечение: {'b'}.
print('s_1 & s_2 ->', s_1 & s_2)
# Разность: {'a'}.
print('s_1 - s_2 ->', s_1 - s_2)
# Сим. разность: {'c', 'a'}.
print('s_1 ^ s_2 ->', s_1 ^ s_2)
s_1 | s_2 -> {'b', 'c', 'a'}
s_1 & s_2 -> {'b'}
s_1 - s_2 -> {'a'}
s_1 ^ s_2 -> {'c', 'a'}
6.4. Решите предыдущую задачу, использовав для получения результатов соответствующие методы класса set. Показать решение.
# Сохраняем множества в переменных.
s_1 = {'a', 'b'}
s_2 = {'b', 'c'}
# Объединение: {'b', 'c', 'a'}.
res = set.union(s_1, s_2)
print('set.union(s_1, s_2) ->', res)
# Пересечение: {'b'}.
res = set.intersection(s_1, s_2)
print('set.intersection(s_1, s_2) ->', res)
# Разность: {'a'}.
res = set.difference(s_1, s_2)
print('set.difference(s_1, s_2) ->', res)
# Сим. разность: {'c', 'a'}.
res = set.symmetric_difference(s_1, s_2)
print('set.symmetric_difference(s_1, s_2) ->', res)
set.union(s_1, s_2) -> {'c', 'a', 'b'}
set.intersection(s_1, s_2) -> {'b'}
set.difference(s_1, s_2) -> {'a'}
set.symmetric_difference(s_1, s_2) -> {'c', 'a'}
6.5. Дано множество целых чисел {-3, 8, 15, -5, 0, 7}. Выведите на экран произведение максимального и минимального элементов, сумму элементов не превышающих 7. Показать решение.
# Сохраним множество в переменной.
st = {-3, 8, 15, -5, 0, 7}
# Выводим произведение макс. и мин. эл-тов.
print('max(st)*min(st) =', max(st)*min(st))
''' 1-й вариант '''
# Стартовое значение суммы.
sm = 0
# Суммируем эл-ты циклом.
for el in st:
# Но сперва проверяем условие.
if el <= 7: sm += el
# Выводим сумму на экран.
print('Сумма эл-тов не превыш-х 7:', sm)
''' 2-й вариант '''
# Встр-ная ф-ция + генератор множеств.
res = sum({x for x in st if x <= 7})
# Выводим сумму на экран.
print('Сумма эл-тов не превыш-х 7:', res)
max(st)*min(st) = -75
Сумма эл-тов не превыш-х 7: -1
Сумма эл-тов не превыш-х 7: -1
6.6. Определите есть ли в строке 'Купить, нельзя оставить!' хотя бы одна точка или запятая. Выведите результат проверки на экран. Показать решение.
# Приведем строку к множеству.
s_1 = set('Купить, нельзя оставить!')
# Создадим множество с запятой и точкой.
s_2 = set('.,')
# Находим пересечение мн-в и выводим ре-т.
print(True if set(s_1)&set(s_2) else False)
True
6.7. Даны три слова 'аквариум', 'мармелад' и 'рама'. Выведите на экран сперва все виды букв, которые присутствуют во всех словах сразу, а затем все виды букв, которые присутствуют в любом из них. Показать решение.
# Преобразуем строки в множества символов.
s_1 = set('аквариум')
s_2 = set('мармелад')
s_3 = set('рама')
# Находим пересечение множеств.
res_1 = s_1&s_2&s_3
print('Общие виды букв', res_1)
# Находим объединение множеств.
res_2 = s_1|s_2|s_3
print('Все имеющиеся виды букв:', res_2)
Общие виды букв {'а', 'м', 'р'}
Все имеющиеся виды букв: {'и', 'а', 'д', 'е', 'в', 'к', 'у', 'р', 'л', 'м'}
6.8. Даны три числа: 30, 5 и 25. Выведите на экран наименьшее из них, использовав для этого программную проверку. Показать решение.
# Сохраняем числа в переменных.
a = 30
b = 5
c = 25
''' 1-вариант '''
# Добавляем все числа в множество.
st = {a}
st.add(b)
st.add(c)
# Выводим сообщение на экран.
print('Наименьшее число - это', min(st))
''' 2-вариант '''
# Строка для вывода.
s = 'Наименьшее число - это'
# Если a наименьшее.
if a < b and a < c:
# Выводим сообщение на экран.
print(s, a)
# Если b наименьшее.
elif b < a and b < c:
# Выводим сообщение на экран.
print(s, b)
# Иначе остается число c.
else:
# Выводим сообщение на экран.
print(s, c)
Наименьшее число - это 5
Наименьшее число - это 5
6.9. Даны два списка ников ['ivan2022', 'sveta', 'ivan', 'kot23', 'sveta', 'ivan'] и ['koly', 'enot37', 'luzer', 'kot23', 'sveta']. Сколько уникальных ников представлено в обоих списках? В каком списке уникальных ников содержится больше? Выведите результаты на экран. Показать решение.
# Преобразуем списки в множества ников.
s_1 = set(['ivan2022', 'sveta', 'ivan', 'kot23', 'sveta', 'ivan'])
s_2 = set(['koly', 'enot37', 'luzer', 'kot23', 'sveta'])
# Выводим общее количество уникальных ников.
print('Общее кол-во ун. ников:', len(s_1|s_2))
# Находим разницу кол-ва ун. ников в списках.
n = len(s_1) - len(s_2)
# Выводим ответ.
if n > 0:
print('В 1-ом списке ун. ников больше.')
elif n < 0:
print('Во 2-ом списке ун. ников больше.')
else:
print('Списки имеют равное кол-во ун. ников.')
Общее кол-во ун. ников: 7
Во 2-ом списке ун. ников больше.
6.10. Сформируйте и выведите на экран множество из всех подходящих для этого элементов списка [True, 0, 1, False, 2+3.4j, 5, '5', (6, 7), [8, 9], {'10': 10}]. Объясните конечный результат. Используйте для решения задачи генератор множеств и класс Hashable модуля collections.abc для проверки хешируемости элементов списка. Показать решение.
Ответ. Т.к. в ходе проверки на равенство интерпретатор считает значения 0 и False, а также 1 и True равными, то в результирующее множество попадет только то значение, которое идет в заданном списке первым. В тоже время значения 5 и '5' не равны, поэтому оба будут присутствовать в итоговом множестве. Также в итоговое множество не попадут изменяемые значения, т.е. список [8, 9] и словарь {'10': 10}.
# Импортируем класс Hashable.
from collections.abc import Hashable
# Сохраним список в переменной.
li = [True, 0, 1, False, 2+3.4j, 5, '5', (6, 7), [8, 9], {'10': 10}]
# Формируем мн-во и выводим его на экран.
st = {e for e in li if isinstance(e, Hashable)}
print(st)
{0, True, 5, '5', (2+3.4j), (6, 7)}
Задачи на линейные алгоритмы
Линейный алгоритм – это алгоритм, в котором все действия выполняются последовательно одно за другим.
7.1. Перевести граммы в килограммы и вывести результат на экран. Значение граммов ввести с клавиатуры. Показать решение.
# Вводим значение граммов для расчетов.
grams = float(input('Введите вес в граммах: '))
# Переводим в килограммы.
kg = grams*1e-3
print('Получаем: {} кг.'.format(kg))
Введите вес в граммах: 550
Получаем: 0.55 кг.
7.2. Даны две переменные x = 10 и y = 55. Поменяйте их значения местами. Выведите значения переменных на экран до и после замены. Показать решение.
# Исходные значения переменных.
x = 10
y = 55
# Выводим их на экран.
print('x = {}, y = {}.'.format(x, y))
# Меняем значения местами.
y, x = x, y
# Выводим их на экран.
print('x = {}, y = {}.'.format(x, y))
x = 10, y = 55.
x = 55, y = 10.
7.3. С клавиатуры вводится расстояние L в метрах. Необходимо найти и вывести на экран количество полных километров в нем. Показать решение.
# Вводим расстояние в метрах.
L = float(input('Введите расстояние в метрах: '))
# Находим число полных километров.
km = L//1000
print('Полных км.:', km)
Введите расстояние в метрах: 5035
Полных км.: 5.0
7.4. Вычислить и вывести на экран длину окружности и площадь круга одного и того же заданного радиуса R, который необходимо ввести с клавиатуры в сантиметрах. Результаты должны округляться до сотых. Показать решение.
# Импортируем число Пи.
from math import pi
# Вводим значение радиуса для расчетов.
R = float(input('Введите радиус R в см: '))
# Вычисляем и выводим длину окружности.
L = round(2*pi*R, 3)
print('Длина окружности: {} см.'.format(L))
# Вычисляем и выводим площадь круга.
S = round(pi*R**2, 2)
print('Площадь круга: {} см. кв.'.format(S))
Введите радиус R в см: 5
Длина окружности: 31.42 см.
Площадь круга: 78.54 см. кв.
7.5. С клавиатуры вводится некоторое число байт. Определите количество байт, которое нужно к нему добавить, чтобы получить целое число килобайт и мегабайт. Выведите результаты на экран. Показать решение.
# Вводим значение байтов для расчетов.
bs = int(input('Введите кол-во байт: '))
# Коэффициент перевода (1 килобайт).
k = 1024
# Коэффициент перевода (1 мегабайт).
m = k**2
# Кортеж с полным кол-вом килобайтов и остатком байтов.
kbs = divmod(bs, k)
# Кортеж с полным кол-вом мегабайтов и остатком байтов.
mbs = divmod(bs, m)
# Выводим результаты на экран.
print('\nВведено байт: {}.'.format(bs))
# Для оптимизации сохраним строку в переменной.
s = 'Кол-во {}байт: {}, до целого не хватает байт: {}.'
print(s.format('кило', kbs[0], k - kbs[1]))
print(s.format('мега', mbs[0], m - mbs[1]))
Введите кол-во байт:
Введено байт: 9588888.
Кол-во килобайт: 9364, до целого не хватает байт: 872.
Кол-во мегабайт: 9, до целого не хватает байт: 896872.
7.6. Вычислить и вывести на экран период колебания маятника длиной L с точностью до сотых. Для рассчетов использовать формулу T = 2π√(L/g), где g – ускорение свободного падения (9.81 м/c2). Значение длины маятника в метрах необходимо ввести с клавиатуры. Показать решение.
# Импортируем число Пи.
from math import pi
# Вводим длину маятника в метрах.
L = float(input('Введите длину маятника в метрах: '))
# Находим период колебания.
T = round(2*pi*pow(L/9.81, 1/2), 2)
print('Период колебаний маятника: {} c.'.format(T))
Введите длину маятника в метрах: 3.5
Период колебаний маятника: 3.75 c.
7.7. Вычислить и вывести на экран сумму цифр трехзначного натурального числа вводимого с клавиатуры. Показать решение.
# Вводим число (получим строку).
n = input('Введите трехзначное нат-ное число: ')
''' 1-й вариант '''
# Цифры получаем используя срезы.
s = int(n[0]) + int(n[1]) + int(n[2])
# Выводим рез-т на экран.
print('Сумма цифр числа:', s)
''' 2-й вариант '''
# Приводим строку к числу.
n = int(n)
# Например, 537%10 = 7.
n_3 = n%10
# Например, 537//10 = 53.
n = n//10
# Например, 53%10 = 3.
n_2 = n%10
# Например, 53//10 = 5.
n_1 = n//10
# Выводим рез-т на экран.
print('Сумма цифр числа:', n_1 + n_2 + n_3)
Введите трехзначное нат-ное число: 537
Сумма цифр числа: 15
Сумма цифр числа: 15
7.8. Найдите количество секунд, прошедших с начала суток, если на вход сценария время поступило в виде строки '07:45:33'. Выведите результат на экран в виде сообщения «С начала суток прошло n сек.». Показать решение.
# Сохраним строку в переменной.
ts = '07:45:33'
''' 1-й вариант '''
# Берем срезы, приводим к целым числам
# и переводим в секунды часы и минуты.
t = int(ts[:2])*3600 + int(ts[3:5])*60 + int(ts[-2:])
print('С начала суток прошло {} сек.'.format(t))
''' 2-й вариант '''
# Получаем список строк.
li = ts.split(':')
# Приводим эл-ты списка к целым числам
# и переводим в секунды часы и минуты.
t = int(li[0])*3600 + int(li[1])*60 + int(li[2])
print('С начала суток прошло {} сек.'.format(t))
С начала суток прошло 27933 сек.
С начала суток прошло 27933 сек.
7.9. С клавиатуры вводится целое число. Необходимо вывести число, обратное введенному по порядку составляющих его цифр. Например, если было введено число 12345, программа должна вывести пользователю на экран число 54321. Показать решение.
# Запрашиваем число и сохраняем его.
n = input('Введите целое число: ')
# Приводим строку к списку.
li = list(n)
# Переворачиваем список.
li.reverse()
# Собираем строку обратно.
n = "".join(li)
# Выводим перевернутое число на экран.
print('Число обратное введенному:', n)
Введите целое число: 75476
Число обратное введенному: 67457
7.10. Получите и преобразуйте текущую системную дату, возвращаемую методом date.today() модуля стандартной библиотеки datetime, из формата «год-месяц-день» в формат «день.месяц.год». Выведите оба формата даты на экран. Показать решение.
# Импортируем модуль даты.
from datetime import date
# Получаем системную дату.
sys_date = str(date.today())
# Выводим ее на экран.
print('Сист. дата:', sys_date)
# Разбиваем в список и переворачиваем.
li = sys_date.split('-')
li.reverse()
# Собираем строку обратно.
new_format = '.'.join(li)
# Выводим ее на экран.
print('Целевой формат:', new_format)
Сист. дата: 2022-06-13
Целевой формат: 13.06.2022
Задачи на логические выражения
Теоретический материал по логическому типу данных можно почитать в нашем учебнике здесь.
Не забываем, что в отличие от некоторых других языков программирования в Python логические константы True и False являются регистрозависимыми. Кроме того, к логическому типу автоматически приводятся результаты выражений в заголовках инструкций if и while. В результате мы можем использовать более короткие схемы вместо полноценных логических выражений. Например, заголовок «while len(li) > 0:» можно заменить на «while li:», т.к. после опустошения списка, он автоматически преобразуется в False и цикл прерывается.
8.1. Записать и вывести на экран условие, которое является истинным, когда положительное целое n кратно двум или трем. Показать решение.
# Составляем условие.
s = 'n%2 == 0 or n%3 == 0'
print(s)
# Небольшая проверка в инструкции.
n = 5
if n%2 == 0 or n%3 == 0:
print(True)
else:
print(False)
n%2 == 0 or n%3 == 0
False
8.2. Записать и вывести на экран условие, которое является истинным, когда целое n не кратно трем и оканчивается нулем. Показать решение.
# Составляем условие.
s = 'n%3 != 0 and n%10 == 0'
print(s)
# Небольшая проверка в инструкции.
n = 50
if n%3 != 0 and n%10 == 0:
print(True)
else:
print(False)
n%3 != 0 and n%10 == 0
True
8.3. Записать и вывести на экран условие, которое является истинным, когда список li имеет хотя бы один элемент. Показать решение.
# Составляем условие.
res = "li"
print(res)
# Небольшая проверка в инструкции.
li = [0]
if li:
print(True)
else:
print(False)
li
True
8.4. Записать и вывести на экран условие, которое является истинным, когда хотя бы одно из чисел x, y и z больше 80. Показать решение.
# Составляем условие.
s = 'x > 80 or y > 80 or z > 80'
print(s)
# Небольшая проверка в инструкции.
x = 90; y = 50; z = 70;
if x > 80 or y > 80 or z > 80:
print(True)
else:
print(False)
x > 80 or y > 80 or z > 80
True
8.5. Записать и вывести на экран условие, которое является истинным, когда оба числа a и b одновременно положительны или отрицательны. Показать решение.
# Составляем условие.
s = '(a > 0 and b > 0) or (a < 0 and b < 0)'
print(s)
# Небольшая проверка в инструкции.
a = -5; b = -50
if (a > 0 and b > 0) or (a < 0 and b < 0):
print(True)
else:
print(False)
(a > 0 and b > 0) or (a < 0 and b < 0)
True
8.6. Записать и вывести на экран условие, которое является истинным для пустого словаря d. Показать решение.
# Составляем условие.
res = "not d"
print(res)
# Небольшая проверка в инструкции.
d = {}
if not d:
print(True)
else:
print(False)
not d
True
8.7. Записать и вывести на экран условие, которое является истинным, когда строка s является ключом словаря D, но отсутствует в списке строк L. Показать решение.
# Составляем условие.
res = 's in D.keys() and s not in L'
print(res)
# Небольшая проверка в инструкции.
s = 'a'; D = {'a': 1}; L = ['d', 'v']
if (s in D.keys() and s not in L):
print(True)
else:
print(False)
s in D.keys() and s not in L
True
8.8. Записать и вывести на экран логическое выражение, описывающее область определения функции у = √a + 1/(a - 7) + 1/(b + 5) + 1/(b - 2). Показать решение.
# Составляем условие.
s = 'a >= 0 and a != 7 and b != -5 and b != 2'
print(s)
# Небольшая проверка в инструкции.
a = 7; b = 10
if a >= 0 and a != 7 and b != -5 and b != 2:
print(True)
else:
print(False)
a >= 0 and a != 7 and b != -5 and b != 2
False
8.9. Записать и вывести на экран условие, которое является истинным, только когда одно из чисел x, y и z меньше нуля. Показать решение.
'''1-й вариант'''
# Составляем условие.
s = '(x < 0) + (y < 0) + (z < 0) == 1'
print(s)
# Небольшая проверка в инструкции.
x = 90; y = -50; z = 70;
# Не забываем, что True и False в ариф-ских
# выражениях выступают в роли 1 и 0.
if (x < 0) + (y < 0) + (z < 0) == 1:
print(True)
else:
print(False)
'''2-й вариант'''
# Составляем условие.
s = '(x < 0, y < 0, z < 0).count(True) == 1'
print(s)
# Небольшая проверка в инструкции.
x = 90; y = -50; z = 70;
# Если кол-во значений True будет равно 1.
if (x < 0, y < 0, z < 0).count(True) == 1:
print(True)
else:
print(False)
(x < 0) + (y < 0) + (z < 0) == 1
True
(x < 0, y < 0, z < 0).count(True) == 1
True
8.10. Записать и вывести на экран условие, которое является истинным, когда переменная принадлежит к классу целых или вещественных чисел. Показать решение.
'''1-й вариант'''
# Составляем условие.
res = 'isinstance(a, int) or isinstance(a, float)'
print(res)
# Небольшая проверка в инструкции.
a = 7.5
if isinstance(a, int) or isinstance(a, float):
print(True)
else:
print(False)
'''2-й вариант'''
# Составляем условие.
res = 'type(a) is int or type(a) is float'
print(res)
# Небольшая проверка в инструкции.
a = '7.5'
if type(a) is int or type(a) is float:
print(True)
else:
print(False)
isinstance(a, int) or isinstance(a, float)
True
type(a) is int or type(a) is float
False
8.11. Известно, что обрабатываемая строка может содержать только целые числа, например, '-32', '59'. Запишите и выведите на экран условие, которое является истинным только для строк, содержащих двузначное число. Показать решение.
'''1-й вариант'''
# Составляем условие.
res = "len(s.lstrip('-')) == 2"
print(res)
# Небольшая проверка в инструкции.
s = '-59'
if len(s.lstrip('-')) == 2:
print(True)
else:
print(False)
'''2-й вариант'''
# n = abs(int(s)), затем используем n в условии.
res = "abs(int(s)) > 9 and abs(int(s)) < 100"
print(res)
# Небольшая проверка в инструкции.
s = '-591'
# Убираем избыточность кода.
n = abs(int(s))
if n > 9 and n < 100:
print(True)
else:
print(False)
len(s.lstrip('-')) == 2
True
abs(int(s)) > 9 and abs(int(s)) < 100
False
8.12. Запишите и выведите на экран условие, которое является истинным только для положительных целых чисел, которые делятся сразу и на два, и на четыре. При этом используйте не прямое деление, которое для больших чисел даст значительный отрицательный эффект по производительности, а следующие правила математики:
- целое положительное число делится на два, если оно четное;
- целое положительное число делится на четыре, если число, образованное последними двумя цифрами этого числа делится на четыре.
# Составляем условие.
res = "(int(str(n)[-2:])%4 == 0) and (int(str(n)[-1:])%2 == 0)"
print(res)
# Небольшая проверка в инструкции.
n = 253424
if (int(str(n)[-2:])%4 == 0) and (int(str(n)[-1:])%2 == 0):
print(True)
else:
print(False)
(int(str(n)[-2:])%4 == 0) and (int(str(n)[-1:])%2 == 0)
True
Задачи на if/else
Теоретический материал по условной инструкции if/elif/else можно почитать в нашем учебнике здесь.
9.1. Определите, не является ли введенная пользователем с клавиатуры строка пустой. Результат проверки в виде True или False выведите на экран. Показать решение.
# Выводим сообщение и призыв к вводу.
s = input('Введите строку: ')
''' 1-й вариант '''
# Осуществляем проверку и вывод результатов.
# Можно и проще if s: ...
if len(s) > 0:
print(True)
else:
print(False)
''' 2-й вариант '''
# Используем трехместное выр-е if/else.
print(True) if len(s) > 0 else print(False)
Введите строку: sdsd
True
True
9.2. Написать программу, которая будет делить введенные пользователем два вещественных числа и выводить результат на экран, сообщая об ошибке в случае деления на ноль. Показать решение.
# Выводим сообщение и призыв к вводу.
x = float(input('Введите 1-е число: '))
y = float(input('Введите 2-е число: '))
# Осуществляем проверку и вывод результатов.
if y != 0:
print('x/y =', x/y)
else:
print('На ноль делить нельзя!')
Введите 1-е число: 4
Введите 2-е число: 5
x/y = 0.8
9.3. Определить, является ли введенное с клавиатуры натуральное число кратным трем. Вывести результат на экран. Показать решение.
# Просим ввести число для проверки.
n = int(input('Введите нат. число для проверки: '))
# Проверяем кратность трем.
if n%3 == 0:
# Выводим результат на экран.
print('Число', n, 'кратно трем.')
else:
# Выводим результат на экран.
print('Число', n, 'на 3 не делится.')
Введите нат. число для проверки: 81
Число 81 кратно трем.
9.4. Рассчитать стоимость покупки с учетом скидки в 35%, которая предоставляется покупателю, если сумма покупки превышает 20 у.е. Сумму покупки ввести с клавиатуры, а результаты округлить до сотых (копейки, центы и т.д.). Вывести на экран итоговую стоимость и размер предоставленной скидки. Показать решение.
# Вводим сумму покупки.
cost = float(input('Введите сумму покупки (у.е.): '))
# Начальный размер скидки в у.е.
sale = 0
# Вычисляем скидку при условии cost > 20 у.е.
if cost > 20:
# Рассчитываем и округляем скидку в у.е.
sale = round(cost*0.35, 2)
# Рассчитываем итоговую стоимость.
cost = cost - sale
# Выводим на экран результаты.
print('Стоимость покупки:', cost, 'у.е.')
print('Предоставленная скидка:', sale, 'у.е.')
Введите сумму покупки (у.е.): 27.8
Стоимость покупки: 18.07 у.е.
Предоставленная скидка: 9.73 у.е.
9.5. Напишите программу, которая будет проверять, является ли введенное пользователем значение цифрой десятичной системы счисления. Результат проверки должен выводиться пользователю на экран в виде сообщения. Показать решение.
# Выводим сообщение и призыв к вводу.
s = input('Введите число от 0 до 9: ')
# Составляем и проверяем условное выражение.
if len(s) == 1 and int(s) in range(10):
# Выводим сообщение.
print(s, ' - это цифра 10-ной СС.', sep='')
# Если условие ложно.
else:
# Выводим сообщение.
print('«{}» - это не цифра 10-ной СС!'.format(s))
Введите число от 0 до 9: ывввы
«ывввы» - это не цифра 10-ной СС!
9.6. Напишите программу, которая будет проверять, является ли введенное пользователем значение цифрой десятичной системы счисления. В случае положительного результата, на экран пользователя должно выводиться название цифры, например, «3 - это три». В противном случае должно выводиться предупреждение «Введите цифру 10-й СС». Показать решение.
# Выводим сообщение и призыв к вводу.
d = int(input('Введите целое число от 0 до 9: '))
# Используем словарь.
nums = {0: 'ноль', 1: 'один', 2: 'два',
3: 'три', 4: 'четыре',
5: 'пять', 6: 'шесть', 7: 'семь',
8: 'восемь', 9: 'девять'}
# Проверяем истинность условного выражения.
if d in nums.keys():
# Выводим сообщение.
print('{} - это {}'.format(d, nums[d]))
# Если условие ложно.
else:
# Выводим сообщение.
print('Введите цифру 10-й СС')
Введите целое число от 0 до 9: 5
5 - это пять
9.7. Напишите скрипт, который будет проверять пользователя на умение перемножать однозначное натуральное число на двузначное, запрашивая ввод ответа с клавиатуры. Результат проверки ответа пользователя должен выводиться на экран в виде соответствующего сообщения. В случае неправильного ответа, программа должна выводить сообщение об ошибке, дополнительно сообщая пользователю верный результат. Для получения случайных целых чисел из диапазона 2 - 99 импортируйте из модуля random стандартной библиотеки метод randrange. Показать решение.
Введите ответ: 2*65 = 120 Вы ошиблись, т.к. 2*65 = 130 ---------------------- Введите ответ: 2*47 = 94 Верно! 2*47 = 94
# Импортируем метод randrange из модуля random.
from random import randrange
# Получаем случайные числа от 2 до 99.
a = randrange(2, 10)
b = randrange(10, 100)
# Вычисляем результат.
res = a*b
# Выводим пример на экран.
inp = 'Введите ответ: {}*{} = '.format(a, b)
ans = int(input(inp))
# Проверяем ответ.
if ans == res:
# Поздравляем пользователя.
mes = 'Верно!'
else:
# Сообщаем об ошибке.
mes = 'Вы ошиблись, т.к.'
# Выводим сообщение на экран.
print(mes, '{}*{} = {}'.format(a, b, res))
Введите ответ: 2*65 = 120
Вы ошиблись, т.к. 2*65 = 130
9.8. Известна денежная сумма. Необходимо разменять её купюрами по 100, 10 и монетой 2 руб., если это возможно. Сумма должна вводиться с клавиатуры, а результат расчета выводиться на экран в формате «Размен: 100xa, 10xb, 2xc» или «Извините, но размен невозможен!». Показать решение.
Введите сумму в рублях: 156 Размен: 100x1, 10x5, 2x3 ---------------------- Введите сумму в рублях: 35 Извините, но размен невозможен!
# Просим ввести число.
s = int(input('Введите сумму в рублях: '))
# Разменять получится только четную сумму.
if s%2 == 0 and s > 0:
# Получаем кол-во купюр по 100 и остаток.
m_100, r_100 = divmod(s, 100)
# Получаем кол-во купюр по 10 и остаток.
m_10, r_10 = divmod(r_100, 10)
# Получаем кол-во купюр по 2.
m_2 = r_10//2
# Формируем и выводим ответ.
print('Размен: 100x{0}, 10x{1}, 2x{2}'.format(m_100, m_10, m_2))
# Для нечетной и неверной суммы.
else:
# Выводим сообщение об ошибке.
print('Извините, но размен невозможен!')
Введите сумму в рублях: 156
Размен: 100x1, 10x5, 2x3
9.9. Даны три числа: 130, 25 и 70. Выведите на экран наименьшее из них, использовав для этого программную проверку. Показать решение.
# Сохраняем числа в переменных.
a = 130
b = 25
c = 70
''' 1-вариант '''
# Строка для вывода.
s = 'Наименьшее число - это'
# Если a наименьшее.
if a < b and a < c:
# Выводим сообщение на экран.
print(s, a)
# Если b наименьшее.
elif b < a and b < c:
# Выводим сообщение на экран.
print(s, b)
# Иначе остается число c.
else:
# Выводим сообщение на экран.
print(s, c)
''' 2-вариант '''
# Формируем из чисел множество.
st = {a}
st.add(b)
st.add(c)
# Выводим сообщение на экран.
print('Наименьшее число - это', min(st))
Наименьшее число - это 25
Наименьшее число - это 25
9.10. Определите четверть координатной плоскости, которой принадлежит точка A(x, y). Координаты точки должны вводиться с клавиатуры. Показать решение.
# Запрашиваем координаты точки.
x = int(input('x = '))
y = int(input('y = '))
# Общая строка для вывода.
s = 'Точка A({}, {}) принадлежит {} четверти.'
# В 1-й четверти коорд. полож.
if x > 0 and y > 0:
print(s.format(x, y, 'I'))
elif x < 0 and y > 0:
print(s.format(x, y, 'II'))
elif x < 0 and y < 0:
print(s.format(x, y, 'III'))
elif x > 0 and y < 0:
print(s.format(x, y, 'IV'))
x = -5
y = 10
Точка A(-5, 10) принадлежит II четверти.
9.11. По длинам трех отрезков, вводимых пользователем с клавиатуры, определить возможность существования треугольника, составленного из этих отрезков. Если такой треугольник существует, то определить, является ли он разносторонним, равнобедренным или равносторонним. Показать решение.
# Просим ввести длины сторон.
a = int(input('a = '))
b = int(input('b = '))
c = int(input('c = '))
''' 1-й вариант '''
# Существует?
if a + b <= c or a + c <= b or b + c <= a:
print('Треугольник не существует')
# Разносторонний?
elif a != b and a != c and b != c:
print('Разносторонний.')
# Равносторонний?
elif a == b == c:
print('Равносторонний.')
# Значит равнобедренный.
else:
print('Равнобедренный.')
''' 2-й вариант '''
# Существует?
if a + b <= c or a + c <= b or b + c <= a:
print('Треугольник не существует')
# Если же существует.
else:
# Разносторонний?
if a != b and a != c and b != c:
print('Разносторонний.')
# Равносторонний?
elif a == b == c:
print('Равносторонний.')
# Значит равнобедренный.
else:
print('Равнобедренный.')
a = 5
b = 5
c = 7
Равнобедренный.
Равнобедренный.
9.12. Напишите скрипт, который по введенному пользователем числу от 1 до 12, будет выводить на экран сообщение в виде названия месяца и времени года. Если пользователь введет недопустимое число, программа должна выдавать сообщение об ошибке. Показать решение.
# Сохраним названия месяцев в словаре.
m = {1: 'Январь', 2: 'Февраль', 3: 'Март', 4: 'Апрель',
5: 'Май', 6: 'Июнь', 7: 'Июль', 8: 'Август',
9: 'Сентябрь', 10: 'Октябрь', 11: 'Ноябрь', 12: 'Декабрь'}
# Сохраним названия пор года в списке.
s = ['зима', 'весна', 'лето', 'осень']
# Просим ввести число.
n = int(input('Введите номер месяца: '))
# Проверяем диапазон для месяцев.
if n >= 1 and n <= 12:
# Проверяем диапазон для поры года.
if n in range(3, 6):
# Выводим результат на экран.
print('{}, {}.'.format(m[n], s[1]))
# Проверяем диапазон для поры года.
elif n in range(6, 9):
# Выводим результат на экран.
print('{}, {}.'.format(m[n], s[2]))
# Проверяем диапазон для поры года.
elif n in range(9, 12):
# Выводим результат на экран.
print('{}, {}.'.format(m[n], s[3]))
# Иначе.
else:
# Выводим результат на экран.
print('{}, {}.'.format(m[n], s[0]))
else:
# Выводим сообщение об ошибке.
print('Неверный номер месяца!')
Введите номер месяца: 11
Ноябрь, осень.
9.13. Напишите скрипт, который будет тестировать пользователя на знание синтаксиса условной инструкции if. На экран пользователю должны выводиться два случайных формата записи из списка ['if/elseif/else', 'if/elif/else', 'A = Y if X else Z'] и запрос на ввод верного варианта в виде «Введите 0, 1 или 2: ». После чего программа должна оценить ответ и в случае ошибки написать правильный. Для получения случайных вариантов из списка импортируйте из модуля random стандартной библиотеки метод randint. Показать решение.
Какой из двух форматов подходит для инструкции if: if/elseif/else или if/elif/else? Укажите номер верного формата или введите ноль, если оба варианта не верны. Введите 0, 1 или 2: 1 Ошибка! Верный вариант: if/elif/else. ---------------------- Какой из двух форматов подходит для инструкции if: if/elseif/else или A = Y if X else Z? Укажите номер верного формата или введите ноль, если оба варианта не верны. Введите 0, 1 или 2: 0 Верно! ---------------------- Какой из двух форматов подходит для инструкции if: if/elif/else или A = Y if X else Z? Укажите номер верного формата или введите ноль, если оба варианта не верны. Введите 0, 1 или 2: 1 Верно!
# Импортируем метод randint из модуля random.
from random import randint
# Сохраняем список в переменной.
li = ['if/elseif/else', 'if/elif/else', 'A = Y if X else Z']
# Сохраняем в переменной верный вариант.
ans = li[1]
# Удалим из списка один случайный элемент.
del li[randint(0, 2)]
# Сообщение для верного ответа.
mes_1 = 'Верно!'
# Сообщение для ошибки.
mes_2 = 'Ошибка! Верный вариант: {}.'.format(ans)
# Выводим призыв к вводу.
print('Какой из двух форматов подходит для инструкции if: {} или {}?'.format(li[0], li[1]))
print('Укажите номер верного формата или введите ноль, если оба варианта не верны.')
d = int(input('Введите 0, 1 или 2: '))
# Проверяем диапазон номера.
if d == 0:
# Проверяем ответ.
if ans not in li:
# Выводим сообщение.
print(mes_1)
# Если верный вариант присутствует.
else:
# Сообщаем об ошибке и выводим верный ответ.
print(mes_2)
# Проверяем диапазон номера.
elif d in [1, 2]:
# Проверяем выбранный вариант.
if li[d-1] == ans:
# Выводим сообщение.
print(mes_1)
# Если введен неверный вариант.
else:
# Сообщаем об ошибке и выводим верный ответ.
print(mes_2)
# Если введен недопустимый номер.
else:
# Выводим сообщение.
print('Введите 0, 1 или 2!')
Какой из двух форматов подходит для инструкции if: if/elseif/else или if/elif/else?
Укажите номер верного формата или введите ноль, если оба варианта не верны.
Введите 0, 1 или 2: 1
Ошибка! Верный вариант: if/elif/else.
9.14. Сформируйте список li из 10-ти случайных натуральных чисел не превышающих 100. Для этого используйте инструкции from random import randint и for k in range(1, 11): li.append(randint(1, 100)). Далее, используя для обхода элементов списка цикл for, выведите на экран: максимальное значение четных чисел, если их меньше, чем нечетных; максимальное значение нечетных чисел, если их меньше, чем четных; максимальное значение из двух, если в списке содержится равное количество четных и нечетных чисел. Использовать для решения задачи другие встроенные функции запрещается! Показать решение.
li: [5, 20, 41, 63, 24, 21, 10, 62, 91, 19] Четных чисел меньше. Макс. четное: 62 ---------------------- li: [28, 58, 94, 59, 27, 30, 80, 18, 4, 53] Нечетных чисел меньше. Макс. нечетное: 59 ---------------------- li: [88, 32, 50, 99, 17, 12, 78, 95, 55, 47] Чисел одинаковое кол-во. Макс. из них нечетное: 99
# Импортируем ф-цию randint
from random import randint
# Сохраняем список в переменной.
li = []
# Заполняем его 10-ю случайными числами.
for k in range(1, 11):
# Добавляем случайное n <= 100.
li.append(randint(1, 100))
# Выводим список на экран.
print('li:', li)
# Стартовые максимальные значения.
max_2k = 0; max_2k_1 = 0
# Счетчики четных и нечетных элементов.
len_2k = 0; len_2k_1 = 0
# Обрабатываем каждый эл-т списка.
for elem in li:
# Если число четное.
if elem%2 == 0:
# Увеличиваем счетчик четных чисел.
len_2k += 1
# Если оно больше сохраненного ранее.
if elem > max_2k:
# Сохраняем его.
max_2k = elem
# Если число нечетное.
else:
# Увеличиваем счетчик нечетных чисел.
len_2k_1 += 1
# Если оно больше сохраненного ранее.
if elem > max_2k_1:
# Сохраняем его.
max_2k_1 = elem
# Если четных чисел меньше.
if len_2k > 0 and len_2k < len_2k_1:
# Выводим наибольшее четное.
print('Четных чисел меньше.')
print('Макс. четное:', max_2k)
# Если нечетных чисел меньше.
elif len_2k_1 > 0 and len_2k_1 < len_2k:
# Выводим наибольшее из них.
print('Нечетных чисел меньше.')
print('Макс. нечетное:', max_2k_1)
# Если количество равное.
else:
print('Чисел одинаковое кол-во.')
# Выводим наибольшее из двух.
if max_2k > max_2k_1:
print('Макс. из них четное:', max_2k)
else:
print('Макс. из них нечетное:', max_2k_1)
li: [5, 20, 41, 63, 24, 21, 10, 62, 91, 19]
Четных чисел меньше.
Макс. четное: 62
Задачи на циклы for и while
Теоретический материал по циклам for и while можно почитать в нашем учебнике здесь.
Все задачи должны решаться как с использованием цикла for, так и цикла while. Дополнительно разрешается использовать и другие инструменты для обхода наборов элементов.
10.1. Посчитайте количество символов в строке 'Python - это Питон!', использовав счетчики на основе циклов for и while. Показать решение.
# Сохраним строку символов в переменной.
str_1 = 'Python - это Питон!'
''' 1-й вариант '''
# Создаем счетчик символов.
k = 0
# Организуем цикл по всем символам строки str_1.
for simb in str_1:
# Просто увеличиваем счетчик на единицу.
k += 1
# Выводим k на экран.
print('В строке', k, 'символов.')
''' 2-й вариант '''
# Создаем новый счетчик символов.
n = 0
# Организуем цикл по всем символам строки str_1.
while str_1:
# Сокращаем строку на один символ.
str_1 = str_1[1:]
# Просто увеличиваем счетчик на единицу.
n += 1
# Выводим n на экран.
print('В строке', n, 'символов.')
В строке 19 символов.
В строке 19 символов.
10.2. Сколько кортежей содержится в списке [(1, 2), (3), (4,), (5+6), (7+8,)]? Проверьте свой ответ программно, используя циклы. Выведите кортежи на экран в одну строку. Показать решение.
Ответ. Список содержит три кортежа, т.к. (3) - это просто число в скобках, а (5+6) - сумма чисел.
# Сохраняем список в переменной.
li = [(1, 2), (3), (4,), (5+6), (7+8,)]
''' 1-й вариант '''
# Запускаем цикл по эл-там списка.
for elem in li:
# Если эл-т является кортежем.
if isinstance(elem, tuple):
# Выводим его на экран через пробел.
print(elem, end=' ')
# Сделаем отступ для цикла while.
print()
''' 2-й вариант '''
# Цикл прервется при опустошении списка.
while li:
# Берем 1-й эл-т списка.
elem = li[0]
# Сам список укорачиваем.
li = li[1:]
# Если эл-т является кортежем.
if isinstance(elem, tuple):
# Выводим его на экран через пробел.
print(elem, end=' ')
(1, 2) (4,) (15,)
(1, 2) (4,) (15,)
10.3. Найдите сумму всех элементов списка [1, '2', 3, 4, '5'], предварительно приводя строки к целым числам. Показать решение.
# Сохраним список в переменной.
li = [1, '2', 3, 4, '5']
''' 1-й вариант '''
# Задаем стартовое значение суммы
sum = 0
# Циклом проходимся по эл-там списка.
for elem in li:
# Проверяем тип текущего элемента списка.
if type(elem) is str:
# Перед сложением приводим к целочисленному типу.
sum += int(elem)
# Если не строка.
else:
# Просто наращиваем сумму.
sum += elem
# Выводим сумму на экран.
print('Цикл for:', sum)
''' 2-й вариант '''
# Обнуляем сумму.
sum = 0
# Счетчик и размер списка.
n = 0; li_len = len(li)
# Организуем цикл по всем эл-там списка.
while n < li_len:
# Получаем текущий элемент списка.
elem = li[n]
# Проверяем тип текущего элемента списка.
if type(elem) is str:
# Перед сложением приводим к целочисленному типу.
sum += int(elem)
# Если не строка.
else:
# Просто наращиваем сумму.
sum += elem
# Увеличиваем счетчик на единицу.
n += 1
# Выводим сумму на экран.
print('Цикл while:', sum)
Цикл for: 15
Цикл while: 15
10.4. Дано множество целых чисел {12, 33, 24, 7, 19}. Выведите на экран только четные числа. Показать решение.
''' 1-й вариант '''
# Сохраним множество в переменной.
s = {12, 33, 24, 7, 19}
# Обходим эл-ты в цикле.
for elem in s:
# Проверяем на четность.
if elem%2 != 0:
# Выводим число.
print(elem, end=' ')
else:
# Пропускаем число
continue
# Сделаем отступ для цикла while.
print()
''' 2-й вариант '''
# Получим копию множества, чтобы не изменить оригинал.
s_1 = s.copy()
# Организуем цикл по всем эл-там мн-ва.
while s_1:
# Удаляем и получаем эл-т множества.
elem = s_1.pop()
# Проверяем на четность.
if elem%2 != 0:
# Выводим число.
print(elem, end=' ')
else:
# Пропускаем число
continue
33 19 7
33 19 7
10.5. Используя циклы, проверьте при помощи оператора in наличие символов строки 'abcde123' в строке 'bad_cat_23', выводя результаты проверки на экран в виде «Символ "a" есть в "bad_cat_23".» или «Символа "n" нет в "bad_cat_23".». Показать решение.
# Сохраним строку символов в переменной.
str_1 = 'abcde123'
# Сохраним целевую строку в переменной.
str_2 = 'bad_cat_23'
''' 1-й вариант '''
# Организуем цикл по всем символам строки str_1.
for simb in str_1:
# Проверяем наличие очередного символа в строке str_2.
if simb in str_2:
# Выводим подтверждение на экран.
print('Символ ', simb, ' есть в "', str_2, '".', sep='')
else:
# Выводим отрицание на экран.
print('Символа ', simb, ' нет в "', str_2, '".', sep='')
# Сделаем отступ для цикла while.
print()
''' 2-й вариант '''
# Получим счетчик для итераций.
k = len(str_1)
# Организуем цикл по всем символам строки str_1.
while k:
# Счетчик эффективнее уменьшить сразу.
k -= 1
# Получаем символ str_1, начиная с конца строки.
simb = str_1[k]
# Проверяем наличие очередного символа в строке str_2.
if simb in str_2:
# Выводим подтверждение на экран.
print('Символ ', simb, ' есть в "', str_2, '".', sep='')
else:
# Выводим отрицание на экран.
print('Символа ', simb, ' нет в "', str_2, '".', sep='')
''' Самостоятельно организуйте цикл, начиная с 1-го символа. '''
Символ a есть в "bad_cat_23".
Символ b есть в "bad_cat_23".
Символ c есть в "bad_cat_23".
Символ d есть в "bad_cat_23".
Символа e нет в "bad_cat_23".
Символа 1 нет в "bad_cat_23".
Символ 2 есть в "bad_cat_23".
Символ 3 есть в "bad_cat_23".
Символ 3 есть в "bad_cat_23".
Символ 2 есть в "bad_cat_23".
Символа 1 нет в "bad_cat_23".
Символа e нет в "bad_cat_23".
Символ d есть в "bad_cat_23".
Символ c есть в "bad_cat_23".
Символ b есть в "bad_cat_23".
Символ a есть в "bad_cat_23".
10.6. Вычислить и вывести на экран сумму кубов натуральных чисел от 1 до n включительно. Верхний предел должен вводиться с клавиатуры и не должен превышать числа 100. Показать решение.
# Запрашиваем число и сохраняем его.
n = int(input('Введите нат. число <= 100: '))
# Проверяем верхний предел.
if n > 0 and n <= 100:
''' 1-й вариант '''
# Счетчик суммы.
s = 0
# Организуем цикл по числам от 1 до n.
for i in range(1, n+1): s += i**3
# Выводим сумму на экран.
print('Сумма кубов чисел от 1 до {}: {}'.format(n, s))
''' 2-й вариант '''
# Счетчики суммы и чисел.
s = 0; i = 1
# Организуем цикл по числам от 1 до n.
while i <= n: s += i**3; i += 1
# Выводим сумму на экран.
print('Сумма кубов чисел от 1 до {}: {}'.format(n, s))
''' 3-й вариант '''
# Используем встроенные функции и lambda.
s = sum(map(lambda i: i**3, range(1, n+1)))
# Выводим сумму на экран.
print('Сумма кубов чисел от 1 до {}: {}'.format(n, s))
# Если предел введен неверно.
else:
print('Введите нат. число <= 100!!!')
Введите нат. число от 2 до 100: 30
Сумма кубов чисел от 1 до 30: 216225
Сумма кубов чисел от 1 до 30: 216225
Сумма кубов чисел от 1 до 30: 216225
10.7. Вычислить факториал заданного натурального числа. Факториал числа n вычисляется по формуле: n! = 1*2*3*...*n. Число n должно вводиться с клавиатуры и не должно превышать числа 30. Показать решение.
# Запрашиваем число и сохраняем его.
n = int(input('Введите нат. число <= 30: '))
# Проверяем верхний предел.
if n > 0 and n <= 30:
''' 1-й вариант '''
# Счетчик произведения.
f = 1
# Организуем цикл по числам от 2 до n.
for i in range(2, n+1): f *= i
# Выводим факториал на экран.
print('{}! = {}'.format(n, f))
''' 2-й вариант '''
# Счетчики произведения и чисел.
f = 1; i = 2
# Организуем цикл по числам от 2 до n.
while i <= n: f *= i; i += 1
# Выводим факториал на экран.
print('{}! = {}'.format(n, f))
# Если предел введен неверно.
else:
print('Введите нат. число <= 30!!!')
Введите нат. число <= 30: 15
15! = 1307674368000
15! = 1307674368000
10.8. Подсчитайте количество арабских цифр и алфавитных символов Юникода в строке 'Станция «Альфа-2015»' и выведите результаты на экран. Показать решение.
# Сохраняем строку в переменной.
s = 'Станция «Альфа-2015»'
''' 1-й вариант '''
# Инициализируем счетчики цифр и букв.
n = b = 0
# Запускаем цикл по символам строки.
for simb in s:
# Осуществляем проверку.
if simb.isalpha():
# Обновляем счетчик букв.
b += 1
elif simb.isdigit():
# Обновляем счетчик букв.
n += 1
# Выводим рез-ты на экран.
print('Количество цифр:', n)
print('Количество букв:', b)
''' 2-й вариант '''
# Инициализируем счетчики цифр и букв.
n = b = 0
# Запускаем цикл по символам строки.
while s:
# Осуществляем проверку.
if s[0].isalpha():
# Обновляем счетчик букв.
b += 1
elif s[0].isdigit():
# Обновляем счетчик букв.
n += 1
# Обрезаем строку.
s = s[1:]
# Выводим рез-ты на экран.
print('Количество цифр:', n)
print('Количество букв:', b)
Количество цифр: 4
Количество букв: 12
Количество цифр: 4
Количество букв: 12
10.9. Даны два списка строк ['1', 'True', 'ok'] и ['no', 'True', 'no']. Сформируйте новый список, который будет состоять из строк, которые присутствуют хотя бы в одном из списков. Выведите полученный список на экран. Показать решение.
# Сохраняем списки в переменных.
li_1 = ['1', 'True', 'ok']
li_2 = ['no', 'True', 'no']
''' 1-й вариант '''
# Новый список.
li = []
# Цикл по эл-там списка.
for s in li_1 + li_2:
# Если строка еще не попадалась.
if s not in li:
# Добавляем ее в список.
li.append(s)
# Выводим список на экран.
print(li)
''' 2-й вариант '''
# Объединим списки.
li_12 = li_1 + li_2
# Новый список.
li = []
# Цикл по эл-там списка.
while li_12 != []:
# Удаляем и получаем последний эл-т.
s = li_12.pop(0)
# Если строка еще не попадалась.
if s not in li:
# Добавляем ее в список.
li.append(s)
# Выводим список на экран.
print(li)
''' 3-й вариант '''
# Новый список.
li = []
# Используем генератор списков.
[li.append(s) for s in li_1+li_2 if s not in li]
# Выводим список на экран.
print(li)
''' 4-й вариант '''
# Используем объединение множеств.
li = list(set(li_1)|set(li_2))
# Выводим список на экран.
print(li)
['1', 'True', 'ok', 'no']
['1', 'True', 'ok', 'no']
['1', 'True', 'ok', 'no']
['ok', 'no', '1', 'True']
10.10. Выведите на экран через пробел все символы строки 'abcdefABCDEF', которые находятся в нижнем регистре, не используя при этом срез строки. Показать решение.
# Сохраняем строку в переменной.
s = 'abcdefABCDEF'
''' 1-й вариант '''
# Организуем цикл по символам строки.
for simb in s:
# Если символ является 'A'.
if simb == 'A': break
# Выводим очередной символ на экран.
print(simb, end=' ')
# Сделаем отступ для цикла while.
print()
''' 2-й вариант '''
# Инициализируем счетчик для цикла.
k = 0
# Организуем цикл по символам строки.
while k < len(s):
# Если символ является 'A'.
if s[k] == 'A': break
# Выводим очередной символ на экран.
print(s[k], end=' ')
# Наращиваем значение счетчика.
k += 1
a b c d e f
a b c d e f
10.11. Cгенерируйте и выведите на экран мозаичное изображение гексагональной сетки, напоминающее мелкоячеистую проволочную сетку. Показать решение.
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
''' 1-й вариант '''
# Задаем константы.
# Количество ячеек по горизонтали.
X_REPEAT = 19
# Количество ячеек по вертикали.
Y_REPEAT = 12
# Каждая итерация распечатывает одну полосу ячеек.
for y in range(Y_REPEAT):
# Выводим строку с верхними половинами 6-ков:
for x in range(X_REPEAT):
print(r'/ \_', end='')
print()
# Выводим строку с нижними половинами 6-ков:
for x in range(X_REPEAT):
print(r'\_/ ', end='')
print()
# Выводим разрыв между вариантами.
print()
''' 2-й вариант '''
# Счетчик внешнего цикла.
y = 0
# Каждая итерация распечатывает одну полосу ячеек.
while y < Y_REPEAT:
# Счетчик внутренних циклов.
x = 0
# Выводим строку с верхними половинами 6-ков:
while x < X_REPEAT:
print(r'/ \_', end='')
# Наращиваем счетчик.
x += 1
print()
# Счетчик внутренних циклов обнуляем.
x = 0
# Выводим строку с нижними половинами 6-ков:
while x < X_REPEAT:
print(r'\_/ ', end='')
# Наращиваем счетчик.
x += 1
print()
# Наращиваем счетчик внешнего цикла.
y += 1
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
10.12. Выведите на экран в порядке возрастания и через пробел все цифры вложенных списков конструкции [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]]. Не забываем делать это при помощи циклов for и while (должны получиться тройные матрешки из вложенных циклов). Показать решение.
# Структура вложенных списков для обхода.
li = [[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
[[19, 20, 21], [22, 23, 24], [25, 26, 27]]
]
# 3 вложенных списка внешнего списка.
for elem_1 in li:
# 3 вложенных списка 2 уровня.
for elem_2 in elem_1:
# Числа вложенных списков 2 уровня.
for elem_3 in elem_2:
# Выводим их на экран.
print(elem_3, end=' ')
# Сделаем отступ для цикла while.
print('\n')
# Счетчик индексов.
k = 0
# 3 вложенных списка внешнего списка.
while k < 3:
# Счетчик индексов.
m = 0
# 3 вложенных списка 2 уровня.
while m < 3:
# Счетчик индексов.
n = 0
# Числа вложенных списков 2 уровня.
while n < 3:
# Выводим их на экран.
print(li[k][m][n], end=' ')
# Увеличиваем счетчик.
n += 1
# Увеличиваем счетчик.
m += 1
# Увеличиваем счетчик.
k += 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
10.13. Выведите на экран цифры вводимого с клавиатуры натурального числа, пропуская цифры 2 и 5. Показать решение.
# Запрашиваем число и сохраняем его.
s = input('Введите нат. число: ')
''' 1-й вариант '''
# Организуем цикл по символам строки.
for simb in s:
# Пропускаем цифры 2 и 5.
if simb == '2' or simb == '5': continue
# Выводим очередную цифру на экран.
print(simb, end='')
# Сделаем отступ для цикла while.
print()
''' 2-й вариант '''
# Инициализируем счетчик для цикла.
k = 0
# Организуем цикл по символам строки.
while k < len(s):
# Пропускаем цифры 2 и 5.
if s[k] == '2' or s[k] == '5': k += 1; continue
# Выводим очередную цифру на экран.
print(s[k], end='')
# Наращиваем значение счетчика.
k += 1
Введите нат. число: 123456789
1346789
1346789
10.14. Дан словарь {1: [1, 2, 3, 4], 2: [5, 6, 7, 8]}. Удалите из вложенных списков все четные значения элементов. Выведите измененный словарь на экран. Показать решение.
# Сохраняем словарь в переменной.
d = {1: [1, 2, 3, 4], 2: [5, 6, 7, 8]}
''' 1-й вариант '''
# Организуем внешний цикл по ключам словаря.
for key in d:
# Задаем счетчик для внутреннего цикла.
k = 0
# Внутренний цикл по эл-там списка.
for num in d[key]:
# Проверяем число на четность.
if num%2 == 0:
# Удаляем его.
del d[key][k]
# Наращиваем счетчик.
k += 1
# Выводим на экран измененный словарь.
print(d)
''' 2-й вариант '''
# Получаем список ключей и значений словаря.
d_items = list(d.items())
# Организуем внешний цикл по ключам словаря.
while d_items != []:
# Получаем очередной ключ и соотв. значение.
key = d_items[0][0]
val = d_items[0][1]
# Задаем счетчик для внутреннего цикла.
k = 0
# Внутр. цикл по эл-там вложенного списка.
while k < len(val):
# Проверяем число на четность.
if val[k]%2 == 0:
# Удаляем его из словаря.
del d[key][k]
# Наращиваем внутренний счетчик.
k += 1
# Удаляем отработанный ключ из списка.
del d_items[0]
# Выводим на экран измененный словарь.
print(d)
{1: [1, 3], 2: [5, 7]}
{1: [1, 3], 2: [5, 7]}
10.15. Выведите на экран таблицу умножения чисел от одного до девяти. Показать решение.
----+------------------------------------- | х | 1 2 3 4 5 6 7 8 9 | ----+------------------------------------- | 1 | 1 2 3 4 5 6 7 8 9 | | 2 | 2 4 6 8 10 12 14 16 18 | | 3 | 3 6 9 12 15 18 21 24 27 | | 4 | 4 8 12 16 20 24 28 32 36 | | 5 | 5 10 15 20 25 30 35 40 45 | | 6 | 6 12 18 24 30 36 42 48 54 | | 7 | 7 14 21 28 35 42 49 56 63 | | 8 | 8 16 24 32 40 48 56 64 72 | | 9 | 9 18 27 36 45 54 63 72 81 | ----+-------------------------------------
''' 1-й вариант '''
# Выводим шапку таблицы.
print()
print(' ----+-------------------------------------')
print(' | х | 1 2 3 4 5 6 7 8 9 |')
print(' ----+-------------------------------------')
# Выводим произведения построчно.
for x in range(1, 10):
# Выводим левую метку текущей строки таблицы.
print(' |' + str(x).rjust(2) + ' |', end='')
# Организуем внутренний цикл.
for y in range(1, 10):
# Выводим произведение и пробел.
print(str(x*y).rjust(3), end=' ')
# Выводим символ для правой рамки и разрыв.
print('|')
# Выводим нижнюю рамку таблицы.
print(' ----+-------------------------------------')
# Выводим разрыв между таблицами.
print('\n')
''' 2-й вариант '''
# Выводим шапку таблицы.
print()
print(' ----+-------------------------------------')
print(' | х | 1 2 3 4 5 6 7 8 9 |')
print(' ----+-------------------------------------')
# Задаем счетчик для внешнего цикла.
x = 1
# Выводим произведения построчно.
while x < 10:
# Выводим левую метку текущей строки таблицы.
print(' |' + str(x).rjust(2) + ' |', end='')
# Задаем счетчик для внутреннего цикла.
y = 1
# Организуем внутренний цикл.
while y < 10:
# Выводим произведение и пробел.
print(str(x*y).rjust(3), end=' ')
# Наращиваем счетчик внутреннего цикла.
y += 1
# Наращиваем счетчик внешнего цикла.
x += 1
# Выводим символ для правой рамки и разрыв.
print('|')
# Выводим нижнюю рамку таблицы.
print(' ----+-------------------------------------')
----+------------------------------------- | х | 1 2 3 4 5 6 7 8 9 | ----+------------------------------------- | 1 | 1 2 3 4 5 6 7 8 9 | | 2 | 2 4 6 8 10 12 14 16 18 | | 3 | 3 6 9 12 15 18 21 24 27 | | 4 | 4 8 12 16 20 24 28 32 36 | | 5 | 5 10 15 20 25 30 35 40 45 | | 6 | 6 12 18 24 30 36 42 48 54 | | 7 | 7 14 21 28 35 42 49 56 63 | | 8 | 8 16 24 32 40 48 56 64 72 | | 9 | 9 18 27 36 45 54 63 72 81 | ----+------------------------------------- ----+------------------------------------- | х | 1 2 3 4 5 6 7 8 9 | ----+------------------------------------- | 1 | 1 2 3 4 5 6 7 8 9 | | 2 | 2 4 6 8 10 12 14 16 18 | | 3 | 3 6 9 12 15 18 21 24 27 | | 4 | 4 8 12 16 20 24 28 32 36 | | 5 | 5 10 15 20 25 30 35 40 45 | | 6 | 6 12 18 24 30 36 42 48 54 | | 7 | 7 14 21 28 35 42 49 56 63 | | 8 | 8 16 24 32 40 48 56 64 72 | | 9 | 9 18 27 36 45 54 63 72 81 | ----+-------------------------------------
10.16. Напишите программу вывода на экран всех простых чисел, не превосходящих заданного натурального числа n. Простым называется натуральное число большее единицы, которое делится только на единицу и само себя. Если у натурального числа есть делители большие единицы, то все они не превышают корня квадратного из этого числа. Показать решение.
# Запрашиваем число и сохраняем его.
n = int(input('Введите нат. число: '))
# Флаг простоты числа.
f = True
''' 1-й вариант '''
# Цикл по всем числам от 2 до n.
for p in range(2, n+1):
# Цикл по возможным делителям d числа p.
for d in range(2, int(p**0.5) + 1):
# Если p делится на d без остатка.
if p%d == 0:
# Число составное.
f = False
# Остальные делители не проверяем.
break
# Условие вывода числа.
if f == True:
# Выводим простое число на экран.
print(p, end=' ')
else:
# Сбрасываем флаг простоты числа.
f = True
# Выводим разрыв между вариантами.
print()
''' 2-й вариант '''
# Задаем счетчик для внешнего цикла.
p = 2
# Цикл по всем числам от 2 до n.
while p <= n:
# Задаем счетчик для внутреннего цикла.
d = 2
# Цикл по возможным делителям d числа p.
while d < int(p**0.5) + 1:
# Если p делится на d без остатка.
if p%d == 0:
# Число составное.
f = False
# Наращиваем счетчик внутреннего цикла.
d += 1
# Остальные делители не проверяем.
break
# Наращиваем счетчик внутреннего цикла.
d += 1
# Условие вывода числа.
if f == True:
# Выводим простое число на экран.
print(p, end=' ')
else:
# Сбрасываем флаг простоты числа.
f = True
# Наращиваем счетчик внешнего цикла.
p += 1
Введите нат. число: 30
2 3 5 7 11 13 17 19 23 29
2 3 5 7 11 13 17 19 23 29
Задачи на протокол итераций и генераторы
Теоретический материал по итерациям и генераторам можно почитать в нашем учебнике здесь.
11.1. Имеется список вещественных чисел [1.3, 2.5, 3.1]. Создайте множество квадратов этих чисел, использовав для этого генератор множеств. Выведите полученное множество на экран. Показать решение.
# Используем генератор множеств.
st = {x**2 for x in [1.5, 2.5, 3.5]}
# Выведет {2.25, 12.25, 6.25}.
print('Квадраты чисел:', st)
Квадраты чисел: {2.25, 12.25, 6.25}
11.2. Создайте список нечетных чисел, принадлежащих отрезку [10; 20], использовав для этого генератор списков. Выведите полученный список на экран. Показать решение.
# Используем генератор списков.
li = [x for x in range(10, 21) if x%2 != 0]
# Выводим список на экран.
print(li)
[11, 13, 15, 17, 19]
11.3. Преобразуйте кортеж чисел (3.27, 5.755, 7.321) в словарь, в качестве ключей которого будут использованы числа кортежа, а значениями будут их округленные до десятых значения. Используйте для решения задачи генератор словарей. Выведите полученный словарь на экран. Показать решение.
# Используем генератор словарей.
d = {x: round(x, 1) for x in (3.27, 5.755, 7.321)}
# Выводим словарь на экран.
print(d)
{3.27: 3.3, 5.755: 5.8, 7.321: 7.3}
11.4. Выведите на экран элементы списка [1, 2, 3], использовав для этого функцию next(). Показать решение.
# Получаем итератор списка.
i_li = iter([1, 2, 3])
# Выводим элементы на экран.
print(next(i_li))
print(next(i_li))
print(next(i_li))
1
2
3
11.5. С помощью генератора-выражений получите итератор для последовательности четных чисел из диапазона от 1 до 20 включительно. В ручном режиме выведите первые три числа последовательности, использовав метод __next__ итератора. Показать решение.
Ответ. Решим двумя способами: с использованием шага в функции range и с использованием условия в генераторе-выражений.
'''1-й вариант'''
# Создаем источник чисел.
r = range(2, 21, 2)
# Получаем целевой генератор чисел.
obj_1 = (x for x in r)
# Выводим первые 3 числа последовательности.
print(obj_1.__next__(), end=' ')
print(obj_1.__next__(), end=' ')
print(obj_1.__next__())
'''2-й вариант'''
# Создаем источник чисел.
r = range(1, 21)
# Получаем целевой генератор чисел.
obj_2 = (x for x in r if x%2 == 0)
# Выводим первые 3 числа последовательности.
print(obj_2.__next__(), end=' ')
print(obj_2.__next__(), end=' ')
print(obj_2.__next__())
2 4 6
2 4 6
11.6. Напишите функцию-генератор gen_func(n), которая при вызове будет возвращать итератор для последовательности четных чисел из диапазона от 1 до n включительно. Вызовите функцию, передав аргументу значение 20, и в ручном режиме выведите первые три числа сгенерированной последовательности, использовав метод __next__ итератора. Показать решение.
# Определяем функцию-генератор.
def gen_func(n):
# Запускаем цикл.
for i in range(2, n+1, 2):
# Возвращаем значение и приостанавливаем
# выполнение ф-ции до следующего вызова.
yield i
# Получаем объект-генератор (итератор).
gen_obj = gen_func(20)
# Выводим первые 3 числа последовательности.
print(gen_obj.__next__(), end=' ')
print(gen_obj.__next__(), end=' ')
print(gen_obj.__next__())
2 4 6
11.7. Выведите на экран сумму числовых кодов символов строки 'генераторы', использовав в решении генератор списков. Показать решение.
# Сохраняем строку в переменной.
s = 'генераторы'
# Встроенная ф-ция + генератор списков.
print(sum([ord(simb) for simb in s]))
10837
11.8. Дан список [(1, 2), (3+4), (5,), (6+7, 8), (9+10,)]. Оставьте в нем только элементы, которые являются кортежами и содержат более одного элемента. Используйте для решения задачи генератор списков. Выведите итоговый и результирующий списки на экран. Показать решение.
# Сохраняем список в переменной.
li = [(1, 2), (3+4), (5,), (6+7, 8), (9+10,)]
# Выведем начальный список на экран.
print(li)
# Удаляем лишние элементы и сохраняем список.
li = [e for e in li if isinstance(e, tuple) and len(e) > 1]
# Выведем итоговый список на экран.
print(li)
[(1, 2), 7, (5,), (13, 8), (19,)]
[(1, 2), (13, 8)]
11.9. Сформируйте множество из всех подходящих для этого элементов списка [3, 'ok', [1, 2], (True, False), {'flag': 1}] и выведите его на экран. Используйте для решения задачи генератор множеств и класс Hashable модуля collections.abc для проверки хешируемости элементов списка. Показать решение.
# Импортируем класс Hashable.
from collections.abc import Hashable
# Сохраним список в переменной.
li = [3, 'ok', [1, 2], (True, False), {'flag': 1}]
# Формируем мн-во и выводим его на экран.
st = {e for e in li if isinstance(e, Hashable)}
print(st)
{(True, False), 3, 'ok'}
11.10. Сформируйте словарь, в котором ключами будут строковые значения чисел из диапазона целых чисел от 20 до 30 кратные трем, но не кратные пяти, а значениями квадраты этих чисел. Используйте для решения задачи генератор словарей. Показать решение.
# Формируем множество и выводим его на экран.
d = {str(n): n**2 for n in range(20, 31) if n%3 == 0 and n%5 != 0}
print(d)
{'21': 441, '24': 576, '27': 729}
11.11. Напишите скрипт, который будет находить сумму цифр вводимого пользователем целого числа. Проверьте его на числах -9720, 0 и +3531. Используйте для решения задачи генератор выражения. Показать решение.
# Запрашиваем число и сохраняем его.
num_str = input('Введите целое число: ')
# Удаляем - или +.
num_str = num_str.lstrip('-+')
# Начальное значение суммы.
digit_sum = 0
# Суммируем элементы генератора выражения.
digit_sum = sum((int(d) for d in num_str))
# Выводим результат на экран.
print('Сумма цифр числа равна:', digit_sum)
Введите целое число: -9720
Сумма цифр числа равна: 18
...
Введите целое число: 0
Сумма цифр числа равна: 0
...
Введите целое число: +3531
Сумма цифр числа равна: 12
11.12. Напишите функцию-генератор gen_fib(n: 'int>0') для генерирования последовательности из n чисел Фибоначчи. Вместо проверки аргумента просто укажите аннотацию, сообщающую о том, что аргумент должен быть целым неотрицательным числом. Используя созданный генератор, выведите на экран 10-е число Фибоначчи, а также сумму первых 10-ти чисел последовательности.
Числа Фибоначчи представляют собой ряд чисел, в котором первое число равно нулю, второе единице, а каждое последующее число равно сумме двух предыдущих, т.е. 0 1 1 2 3 5 8 и т.д. Показать решение.
# Определяем функцию-генератор.
def gen_fib(n: 'int>0'):
# Для получения двух и более чисел.
if n > 1:
# Два последовательных числа послед-ти.
fib_1 = 0; fib_2 = 1
# Выдаем 1-ое число послед-ти.
# Приостанавливаем выполнение фун-ции.
yield fib_1
# Выдаем 2-ое число послед-ти.
# Приостанавливаем выполнение фун-ции.
yield fib_2
# Для чисел послед-ти, начиная с 3-го.
# Кол-во итераций на 2 меньше.
n = n - 2
while n > 0:
# Получаем следующую пару чисел.
fib_1, fib_2 = fib_2, fib_1 + fib_2
# Выдаем очередное число Фибоначчи.
yield fib_2
# Уменьшаем значение счетчика.
n -= 1
# Если нужно только одно число.
elif n == 1:
# Выдаем 1-ое число послед-ти.
# Приостанавливаем выполнение фун-ции.
yield 0
# Если аргументу передано недопустимое значение.
else: return None
# Вычисляем сумму первых 10 чисел Фибоначчи.
fib_sum = 0
for fib in gen_fib(10):
# Наращиваем сумму.
fib_sum += fib
# Выводим 10-е число Фибоначчи (fib из цикла).
print('10-е число Фибоначчи:', fib)
# Выводим сумму первых 10 чисел Фибоначчи.
print('Сумма 10-ти чисел Фибоначчи:', fib_sum)
# Сумму можно вычислить еще проще.
fib_sum = sum(gen_fib(10))
print('Сумма 10-ти чисел Фибоначчи:', fib_sum)
10-е число Фибоначчи: 34
Сумма 10-ти чисел Фибоначчи: 88
Сумма 10-ти чисел Фибоначчи: 88
Задачи на функции
Теоретический материал по функциям можно почитать в нашем учебнике здесь.
12.1. Создайте простейшую в мире функцию simple_pass, а затем выведите на экран ее тип. Показать решение.
# Простейшая в мире функция.
def simple_pass(): pass
# Выводим тип объекта.
print(type(simple_pass))
<class 'function'>
12.2. Напишите функцию hello_friend, принимающую в качестве аргументов имя и фамилию пользователя и возвращающую строку в формате «Привет, {name} {surname}!». Вызовите функцию и выведите результат вызова на экран. Показать решение.
# Определяем ф-цию с двумя позиционными аргументами.
def hello_friend(name, surname):
# Формируем приветствие.
s = 'Привет, {} {}!'.format(name, surname)
# Возвращаем результат.
return s
# Вызываем ф-цию и выводим приветствие на экран.
print(hello_friend('Иван', 'Иванов'))
Привет, Иван Иванов!
12.3. Создайте еще одну версию функции hello_friend из предыдущего задания, также принимающую в качестве аргументов имя и фамилию пользователя и возвращающую строку в формате «Привет, {name} {surname}!». Но на этот раз функция должна принимать только именованные аргументы со значениями по умолчанию. Вызовите функцию без аргументов и с аргументами, попутно выводя результаты вызовов на экран. Показать решение.
# Определяем ф-цию с двумя именованными аргументами.
def hello_friend(*, name='Иван', surname='Иванов'):
# Формируем приветствие.
s = 'Привет, {} {}!'.format(name, surname)
# Возвращаем результат.
return s
# Вызываем ф-цию без передачи аргументов.
print(hello_friend())
# Вызываем ф-цию с аргументами.
print(hello_friend(name='Петр', surname='Романовский'))
Привет, Иван Иванов!
Привет, Петр Романовский!
12.4. Создайте пользовательскую функцию print_args, принимающую произвольное количество аргументов и выводящую их затем на экран. Вызовите функцию, одновременно передав ей в качестве значений целое число, вещественное число, строку и пустой список. Показать решение.
# Ф-ция с произвольным числом аргументов.
def print_args(*args):
# Заголовок цикла.
for elem in args:
# Выводим элемент на экран.
print(elem)
# Вызываем ф-цию.
print_args(5, 0.73, 'str', [])
5
0.73
str
[]
12.5. Создайте пользовательскую функцию print_named_args, принимающую произвольное количество именованных аргументов и выводящую их затем на экран в формате «key -> value». Вызовите функцию, передав ей в качестве значений комплексное число, кортеж с логическими значениями и пустое множество. Показать решение.
# Ф-ция с произв-ным числом именованных арг-тов.
def print_args(**dict_args):
# Заголовок цикла.
for item in dict_args.items():
# Выводим пару key -> value на экран.
print(item[0], '->', item[1])
# Вызываем ф-цию.
print_args(c=5+3j, b=(True, False), st=set())
c -> (5+3j)
b -> (True, False)
st -> set()
12.6. Создайте и вызовите пользовательскую функцию-матрешку my_func_1, состоящую из четырех вложенных друг в друга определений аналогичных функций. Каждая функция должна выводить сообщение в формате 'In my_func_{номер функции}.', а также содержать определение и вызов следующей вложенной функции (в последней функции эта часть будет отсутствовать). Показать решение.
In my_func_1. In my_func_2. In my_func_3. In my_func_4. In my_func_5.
# Создаем нашу функцию-матрешку.
def my_func_1():
# Выводим сообщение.
print('In my_func_1.')
# Определяем вложенную функцию.
def my_func_2():
print('In my_func_2.')
def my_func_3():
print('In my_func_3.')
def my_func_4():
print('In my_func_4.')
def my_func_5():
print('In my_func_5.')
# Вызываем вложенную функцию.
my_func_5()
my_func_4()
my_func_3()
my_func_2()
# Вызываем функцию.
my_func_1()
In my_func_1.
In my_func_2.
In my_func_3.
In my_func_4.
In my_func_5.
12.7. Создайте функцию, принимающую в качестве аргументов два числа x и y=1 и возвращающую частное d этих чисел в виде строки 'x/y = d'. Снабдите функцию аннотациями: float для x, 'y != 0' для y и 'x/y' для возвращаемого функцией результата. Добавьте в функцию строку документирования «Возвращает строку вида 'x/y = d'.». Выведите на экран результаты вызовов func(5, 0) и func(5, 10), документацию функции через соответствующий атрибут, а также все аннотации, использовав для этого цикл for. Показать решение.
# Объявляем функцию с аннотациями.
def func(x: float, y: 'y != 0' = 1) -> 'x/y':
"""Ф-ция возвращает строку вида 'x/y = d'"""
# Получаем частное.
d = str(x/y) if y != 0 else 'None'
# Получаем строку для возврата.
# res = str(x) + '/' + str(y) + '= ' + d или
res = '{0}/{1} = {2}'.format(x, y, d)
# Возвращаем результат.
return res
# Вызываем функцию.
print(func(5, 0))
print(func(5, 10), end='\n\n')
# Выводим описание функции.
print(func.__doc__, end='\n\n')
# Получаем словарь с аннотациями.
ann_dict = func.__annotations__
# Выводим все аннотации.
for key in ann_dict:
print(key, ': ', ann_dict[key], sep='')
5/0 = None
5/10 = 0.5
Ф-ция возвращает строку вида 'x/y = d'
x: <class 'float'>
y: y != 0
return: x/y
12.8. Напишите рекурсивную функцию recursive_func(text), которая будет выводить символы передаваемой ей строки на экран через пробел. Показать решение.
# Объявляем нашу рекурсивную функцию.
def recursive_func(text):
# Если text == ''.
if not text:
# Завершаем рекурсии.
return None
# Иначе
else:
# выводим первый символ
print(text[0], end=' ')
# и вызываем функцию опять, урезав
# текст на один символ.
return recursive_func(text[1:])
# Вызываем функцию.
recursive_func('Python 3.12')
P y t h o n 3 . 1 2
12.9. Напишите рекурсивную функцию, которая будет вычислять сумму цифр натурального числа. Используя полученную функцию, выведите на экран суммы цифр чисел 7 и 39574. Показать решение.
# Рек-вная ф-ция для вычисления суммы цифр нат. числа.
def sum_digits(n):
# Базовый случай для числа меньше 10.
if n < 10:
# Просто возвращаем само число.
return n
# Рекурсивный случай для чисел больше 10.
else:
# Возвращаем последнюю цифру числа (остаток от
# деления на 10) плюс сумму цифр оставшейся
# части (частное от деления числа на 10).
return n%10 + sum_digits(n//10)
# Выводим суммы цифр заданных чисел на экран.
mes = 'Сумма цифр числа {} равна {}.'
print(mes.format(7, sum_digits(7)))
print(mes.format(39574, sum_digits(39574)))
Сумма цифр числа 7 равна 7.
Сумма цифр числа 39574 равна 28.
12.10. Напишите собственный аналог встроенной функции abs для нахождения модуля числа. Проверьте ее на числах -5, 0 и 10. Показать решение.
# Определяем нашу функцию.
def my_abs(x):
# Если x < 0,
if x < 0:
# меняем знак и возвращаем.
return -x
# Если x >= 0,
else:
# возвращаем x без изменений.
return x
# Проверяем функцию на числах.
print(my_abs(-5))
print(abs(-5))
print(my_abs(0))
print(abs(0))
print(my_abs(10))
print(abs(10))
5
5
0
0
10
10
12.11. Напишите функцию, рассчитывающую стоимость поездки на такси в зависимости от расстояния. В качестве аргументов функция должна принимать именованные параметры: км – расстояние поездки в километрах, мин_цена – базовый тариф, включающий подачу такси и первые три километра пути, цена_за_км – цена за каждый километр, начиная с четвертого. Рассчитайте и выведите на экран стоимость поездки за 17.5 км, если по умолчанию базовый тариф составляет 2 у.е., а цена за километр сверх минимума – 0.3 у.е. Показать решение.
# Заголовок функции.
def func(*, км, мин_цена=2, цена_за_км=0.3):
# Задаем стартовое значение стоимости поездки.
стоимость = мин_цена
# Проверяем километраж.
if км > 3:
# Увеличиваем итоговую стоимость.
стоимость += (км - 3)*цена_за_км
# Возвращаем результат в точку вызова.
return стоимость
# Вызываем функцию и выводим результат.
print('Стоимость поездки:', func(км=17.5), 'y.e.')
Стоимость поездки: 6.35 y.e.
12.12. Напишите функцию, которая будет генерировать случайный пароль. В пароле должно быть от 8 до 15 символов Юникода из диапазонов 48-57 (цифры), 65-90 (буквы латинского алфавита в верхнем регистре) и 97-122 (буквы латинского алфавита в нижнем регистре). Сгенерируйте и выведите на экран три пароля. Показать решение.
# Импортируем метод choice.
from random import choice
# Заголовок функции.
def func():
# Генерируем список указанных кодов.
li = [i for i in range(48, 58)]
li += [i for i in range(65, 91)]
li += [i for i in range(97, 123)]
# Случайная длина пароля от 8 до 15 символов.
k = choice(range(8, 16))
# Строка для пароля.
p = ''
# Генерируем пароль.
while k != 0:
# Выбираем случайный код и получаем символ.
p += chr(choice(li))
# Уменьшаем счетчик цикла.
k -= 1
# Возвращаем сгенерированный пароль в точку вызова.
return p
# Вызываем функцию и выводим результат.
print('Ваш случайный пароль:', func())
print('Ваш случайный пароль:', func())
print('Ваш случайный пароль:', func())
Ваш случайный пароль: dZTuhFvDR4ENyTj
Ваш случайный пароль: aJ0lrFYKWRs10
Ваш случайный пароль: 8YXl3lRNc2dr
12.13. Напишите простейшую функцию-калькулятор, которая будет выполнять с двумя переданными ей числами следующие действия: сложение, вычитание, умножение и деление с указанной точностью. Соответственно, функция должна принимать два позиционных числовых аргумента для чисел, один именованный строковый аргумент op (по умолчанию функция должна выполнять операцию сложения) и один именованный числовой аргумент prec для требуемой точности результата (по умолчанию три знака после запятой). В случае деления на ноль функция должна возвращать NaN, а при попытке выполнения непредусмотренной операции – сообщение об ошибке «Неподдерживаемый тип операции!». Выведите на экран результаты вызовов функции с точностью до сотых для числовых выражений: -13.756 + 59.291, 599 - 783, -7/55, 7/0 и 57.75*33.2. Показать решение.
# Заголовок функции.
def func(x, y, *, op='+', prec=3):
# Определяем требуемый вид операции.
if op == '+':
# Производим сложение.
res = round(x + y, prec)
elif op == '-':
# Производим вычитание.
res = round(x - y, prec)
elif op == '*':
# Производим умножение.
res = round(x*y, prec)
elif op == '/' or op == ':':
if y != 0:
# Производим деление.
res = round(x/y, prec)
else:
# Возвращаем NaN.
res = float('nan')
else:
# Возвращаем сообщение об ошибке.
res = 'Неподдерживаемый тип операции!'
# Возвращаем результат в точку вызова.
return res
# Вызываем функцию и выводим результат.
print('-13.756 + 59.291 =', func(-13.756, 59.291, prec=2))
print('599 - 783 =', func(599, 783, op='-', prec=2))
print('-7/55 =', func(-7, 55, op='/', prec=2))
print('7/0 =', func(7, 0, op='/', prec=2))
print('57.75*33.2 =', func(57.75, 33.2, op='*', prec=2))
-13.756 + 59.291 = 45.53
599 - 783 = -184
-7/55 = -0.13
7/0 = nan
57.75*33.2 = 1917.3
12.14. В григорианском календаре, который был введен в 1582 году папой римским Григорием XIII обычный год состоит из 365 дней. Но т.к. период обращения Земли вокруг Солнца составляет 365.2425 дней, для устранения накапливающейся ошибки было решено ввести в календарь дополнительные «високосные года» в 366 дней. Таковыми условились считать года кратные 4. Однако этого оказалось недостаточно, поэтому для сведения ошибки к минимуму в григорианский календарь ввели дополнительную коррекцию: каждый год, который делится без остатка на 100, является високосным только тогда, когда он делится еще и на 400. Например, високосным считается 1760 год, т.к. он делится на четыре, но год 1700 високосным не является, т.к. он делится на четыре и сто, но не делится на четыреста. Зная все эти нюансы, напишите функцию, которая будет определять, является ли переданный ей год високосным. Проверьте и выведите на экран годы 1782, 1900, 2000 и 2023. Показать решение.
# Заголовок функции.
def func(year):
# Если год делится на 4.
if year%4 == 0:
# Проверим деление на 100.
if year%100 == 0:
# Проверим деление на 400.
if year%400 == 0:
return 'високосный'
else:
return 'невисокосный'
# Иначе сразу возвращаем результат.
else:
return 'невисокосный'
# Вызываем функцию и выводим результат.
print('1782 год:', func(1782))
print('1900 год:', func(1900))
print('2000 год:', func(2000))
print('2023 год:', func(2023))
1782 год: невисокосный
1900 год: невисокосный
2000 год: високосный
2023 год: невисокосный
12.15. Напишите функцию для определения длины гипотенузы прямоугольного треугольника с помощью теоремы Пифагора. В качестве аргументов функция должна принимать длины катетов в виде двух положительных чисел. Возвращаемым значением должна быть длина гипотенузы, округленная с точностью до сотых. В случае передачи аргументов недопустимого типа или диапазона функция должна возвращать -1. Выведите на экран результаты вызовов функции для положительных и отрицательных значений аргументов. Показать решение.
# Импортируем метод sqrt.
from math import sqrt
# Заголовок функции.
def func(a, b):
# Условия проверки типов переменных.
type_a = type(a) is int or type(a) is float
type_b = type(b) is int or type(b) is float
# Проверим типы переменных.
if not (type_a and type_b):
# Возвращаем -1.
return -1
# Стороны должны быть больше нуля.
elif a > 0 and b > 0:
# Находим гипотенузу по теореме Пифагора.
c = sqrt(a**2 + b**2)
# Возвращаем значение в точку вызова.
return round(c, 2)
# Для всех остальных случаев.
else:
# Возвращаем -1.
return -1
# Вызываем функцию и выводим результаты.
print(func(5.0, 10))
print(func(-5, -10))
11.18
-1
12.16. Используя функцию import_module модуля importlib стандартной библиотеки напишите функцию imp_mods(mods), импортирующую в глобальную область видимости текущего модуля необходимые пакеты и модули. В качестве аргумента функция должна принимать кортеж или список имен пакетов и модулей для импорта. Импортируйте при помощи созданной функции модули random и math, а затем выведите на экран факториал случайного положительного целого числа не превышающего десяти. Показать решение.
# Импортируем требуемую функцию.
from importlib import import_module
# Объявляем функцию.
def imp_mods(mods):
# Получаем словарь глоб-ных переменных модуля.
glb = globals()
# Если список имен не пустой.
if mods:
# Циклом импортируем все модули.
for m in mods:
# И добавляем их в глобальное
# пространство имен модуля.
glb[m] = import_module(m)
# Импортируем требуемые модули.
imp_mods(('random', 'math'))
# Выводим факториал случайного числа.
print(math.factorial(random.randint(1, 10)))
6
12.17. Напишите функцию для нахождения НОД произвольного количества чисел. Затем найдите и выведите на экран наибольший общий делитель чисел 165, 435 и 300. Показать решение.
# Заголовок функции.
def func(*nums):
# Узнаем количество переданных чисел.
k = len(nums)
# Список пустых множеств для делителей чисел.
li = [set() for i in range(0, k)]
# Цикл по переданным числам.
for j in range(0, k):
# Получаем очередное число.
n = nums[j]
# Ищем все его делители.
for d in range(2, int(n/2)+1):
# Если n делится без остатка на d.
if n%d == 0:
# Добавляем d в мн-во делителей числа n.
li[j].add(d)
# Ищем пересечение мн-в делителей чисел (общие делители).
s = li[0]
# Делители первого числа уже добавили.
for z in range(1, k):
# Обновляем множество общих делителей.
s &= li[z]
# Возвращаем НОД.
return max(s)
# Вызываем функцию и выводим результат.
print('НОД(165, 435, 300):', func(165, 435, 300))
НОД: 15
12.18. Напишите функцию, которая будет тестировать скорость выполнения другой функции за указанное количество итераций. В качестве именованных аргументов функция должна принимать: f – объект другой функции, args=[] – список или кортеж аргументов тестируемой функции (по умолчанию без аргументов), i=1000 – количество итераций тестирования (по умолчанию тысяча итераций). На выходе функция должна возвращать список [<имя функции>, <количество проведенных итераций>, <затраченное время>]. Протестируйте скорость выполнения встроенных функций sum и min за 20000 итераций на списке целых чисел из диапазона от 1 до 10000. Выведите результаты тестирования на экран, как показано в условии. Показать решение.
Функция: sum
Кол-во итераций: 20000
Время выполнения: 1.2101598
Функция: min
Кол-во итераций: 20000
Время выполнения: 1.6920748
# Заголовок функции.
def func(*, f, args=[], i=1000):
# Импортируем в лок. обл. видимости.
from time import time
# Стартовое значение времени.
start = time()
# Задаем цикл на требуемое число итераций.
for j in range(0, i):
# Вызываем тестируемую функцию или метод.
f(*args)
# Конечное значение времени.
stop = time()
# Возвращаем имя тестируемой функции, кол-во
# итераций и время, затраченное на выполнение.
return [f.__name__, i, round(stop - start, 7)]
# Генерируем список из 10 тыс. чисел.
li = [n for n in range(1, 10001)]
# Протестируем скорость работы sum.
t_sum = func(f=sum, args=[li], i=20000)
print('Функция:', t_sum[0])
print('Кол-во итераций:', t_sum[1])
print('Время выполнения:', t_sum[2], end='\n\n')
# Протестируем скорость работы min.
t_min = func(f=min, args=[li], i=20000)
print('Функция:', t_min[0])
print('Кол-во итераций:', t_min[1])
print('Время выполнения:', t_min[2])
Функция: sum
Кол-во итераций: 20000
Время выполнения: 1.1964874
Функция: min
Кол-во итераций: 20000
Время выполнения: 1.614357
Задачи на ООП: классы и объекты
Теоретический материал по объектно-ориентированному программированию можно почитать в нашем учебнике здесь.
13.1. Создайте простейший в мире класс SimplePass. Затем создайте экземпляр класса и выведите на экран его тип. Показать решение.
# Простейший в мире класс.
class SimplePass: pass
# Создаем экземпляр класса.
simp = SimplePass()
# Выводим тип объекта.
print(type(simp))
<class '__main__.main.<locals>.SimplePass'>
13.2. Определите класс A, включающий:
- строку документирования класса '''Класс A''';
- метод set_a() для установки значения атрибута a;
- метод get_a() для получения значения этого атрибута.
# Определяем класс.
class A:
'''Класс A'''
# Метод установки значения атрибута a.
def set_a(self, a):
# Инициализируем a.
self.a = a
# Метод получения значения атрибута a.
def get_a(self):
# Возвращаем a.
return self.a
# Выводим документацию класса.
print(A.__doc__, end='\n\n')
# Создаем 1-й экземпляр класса.
obj_1 = A()
# Устанавливаем и выводим значение атрибута 1-го объекта.
obj_1.set_a(1)
print('obj_1.get_a():', obj_1.get_a())
# Создаем 2-й экземпляр класса.
obj_2 = A()
# Устанавливаем и выводим значение атрибута 2-го объекта.
obj_2.a = 2
print('obj_2.a:', obj_2.a)
Класс A
obj_1.get_a(): 1
obj_2.a: 2
13.3. Определите класс B, включающий:
- строку документирования класса '''Класс B''';
- конструктор, инициализирующий атрибут данных b создаваемых экземпляров;
- метод get_b() для получения значения этого атрибута.
# Определяем класс.
class B:
'''Класс B'''
# Конструктор класса B.
def __init__(self, b):
# Инициализируем b.
self.b = b
# Метод получения значения атрибута b.
def get_b(self):
# Возвращаем b.
return self.b
# Выводим документацию класса.
print(B.__doc__, end='\n\n')
# Создаем экземпляр класса.
obj = B('b_ok')
# Выводим значение атрибута.
print('obj.get_b():', obj.get_b())
Класс B
obj.get_b(): b_ok
13.4. Определите класс C, наследующий классы A (задача №2) и B (задача №3) и включающий:
- строку документирования класса '''Класс C = A + B''';
- конструктор, инициализирующий дополнительно атрибуты данных a и c создаваемых экземпляров;
- собственные методы set_b() и set_c() для установки значений соответствующих атрибутов;
- собственный метод get_c() для получения значения атрибута c.
# Определяем класс.
class A:
'''Класс A'''
# Метод установки значения атрибута a.
def set_a(self, a):
# Инициализируем a.
self.a = a
# Метод получения значения атрибута a.
def get_a(self):
# Возвращаем a.
return self.a
# Определяем класс.
class B:
'''Класс B'''
# Конструктор класса B.
def __init__(self, b):
# Инициализируем b.
self.b = b
# Метод получения значения атрибута b.
def get_b(self):
# Возвращаем b.
return self.b
# Наследуем оба класса.
class C(A, B):
'''Класс C = A + B'''
# Конструктор класса C.
def __init__(self, a, b, c):
# Вызываем конструктор класса B,
# инициализируя атрибут b.
B.__init__(self, b)
# Инициализируем a (унаследован).
self.set_a(a)
# Инициализируем c (определен здесь).
self.set_c(c)
# Метод установки значения атрибута b.
def set_b(self, b):
# Возвращаем b.
self.b = b
# Метод установки значения атрибута c.
def set_c(self, c):
# Инициализируем c.
self.c = c
# Метод получения значения атрибута c.
def get_c(self):
# Возвращаем c.
return self.c
# Выводим документацию класса C.
print(C.__doc__, end='\n\n')
# Создаем экземпляр класса.
obj = C('a_ok', 'b_ok', 'c_ok',)
# Выводим значения атрибутов.
print('obj.get_a():', obj.get_a())
print('obj.get_b():', obj.get_b())
print('obj.get_c():', obj.get_c())
Класс C = A + B
obj.get_a(): a_ok
obj.get_b(): b_ok
obj.get_c(): c_ok
13.5. Определите класс D, включающий:
- статический метод stat_print_dict, выводящий на экран словарь атрибутов переданного ему объекта класса;
- метод класса cls_print_dict, выводящий на экран словарь атрибутов своего класса.
Ответ. Следует помнить, что статический метод ничего не знает ни о своем классе, ни о его экземпляре. Поэтому при вызове ему нужно обязательно передавать объект класса D. А вот метод класса знает о нем, т.к. он либо вызывается через объект своего класса, либо определяет класс по его экземпляру, из которого он вызывается.
# Определяем класс D.
class D:
# Статический метод.
@staticmethod
def stat_print_dict(c):
# Выводим словарь атрибутов класса.
print(c.__dict__)
# Метод класса.
@classmethod
def cls_print_dict(cls):
# Выводим словарь атрибутов класса.
print(cls.__dict__)
# Создаем экземпляр класса.
obj = D()
# Ст. методу передаем объект класса.
obj.stat_print_dict(D)
# Метод класса знает о нем.
obj.cls_print_dict()
{'__module__': '__main__', 'stat_print_dict': ...}
{'__module__': '__main__', 'stat_print_dict': ...}
13.6. Определите класс E, наследующий класс D (задача №5) и включающий единственный атрибут данных класса e = 'Класс E'. Создайте экземпляр obj_1 класса D и, вызвав оба метода из этого экземпляра, выведите на экран словарь атрибутов класса. Затем создайте экземпляр obj_2 класса E и также, вызвав оба метода из этого экземпляра, выведите на экран словарь атрибутов этого класса. Объясните результаты. Показать решение.
Ответ. Опять же, следует помнить, что статический метод ничего не знает ни о своем классе, ни о его экземпляре. Поэтому при вызове ему нужно обязательно передавать объект класса. А вот метод класса знает о нем, т.к. он либо вызывается через объект своего класса, либо определяет класс по его экземпляру, из которого он вызывается. При этом оба вида методов наследуются точно также, как и обычные методы. Поэтому мы можем вызывать их из любых допустимых объектов классов или их экземпляров.
# Определяем класс D.
class D:
# Статический метод.
@staticmethod
def stat_print_dict(c):
# Выводим атрибуты класса.
print(c.__dict__)
# Метод класса.
@classmethod
def cls_print_dict(cls):
# Выводим атрибуты класса.
print(cls.__dict__)
# Определяем класс E.
class E(D):
# Атрибут класса.
e = 'Класс E'
# Создаем экземпляр класса.
obj_1 = D()
# Ст. методу передаем объект класса.
obj_1.stat_print_dict(D)
# Метод класса знает о нем.
obj_1.cls_print_dict()
# Создаем экземпляр класса.
obj_2 = E()
# Ст. методу передаем объект класса.
obj_2.stat_print_dict(E)
# Метод знает класс экземпляра.
obj_2.cls_print_dict()
{'__module__': '__main__', 'stat_print_dict': <staticmethod..., '__doc__': None}
{'__module__': '__main__', 'stat_print_dict': <staticmethod..., '__doc__': None}
{'__module__': '__main__', 'e': 'Класс E', '__doc__': None}
{'__module__': '__main__', 'e': 'Класс E', '__doc__': None}
13.7. Определите класс F, наследующий класс A (задача №2), включающий:
- конструктор, обновляющий строку документации создаваемых экземпляров на 'Объект класса F';
- расширенный метод set_a() для установки значения атрибута a, который должен дополнительно выводить сообщение 'Атрибут a установлен!'.
# Определяем класс.
class A:
'''Класс A'''
# Метод установки значения атрибута a.
def set_a(self, a):
# Инициализируем a.
self.a = a
# Метод получения значения атрибута a.
def get_a(self):
# Возвращаем a.
return self.a
# Определяем класс F.
class F(A):
'''Класс F(A)'''
# Конструктор класса F.
def __init__(self):
# Обновляем документацию.
self.__doc__ = 'Объект класса F'
# Расширяем метод.
def set_a(self, a):
# Вызываем метод суперкласса.
# Можно super(F, self).set_a(a)
# или A.set_a(self, a)
super().set_a(a)
# Выводим сообщение.
print('Атрибут a установлен!')
# Выводим строку документирования класса.
print(F.__doc__, end='\n\n')
# Создаем экземпляр класса.
obj = F()
# Выводим его документацию.
print(obj.__doc__)
# Устанавливаем и выводим значение атрибута a.
obj.set_a('a_ok')
print('obj.get_a():', obj.get_a())
Класс F(A)
Объект класса F
Атрибут a установлен!
obj.get_a(): a_ok
13.8. Определите класс PiNum, хранящий значение числа Пи и включающий:
- конструктор, инициализирующий текущую точность представления числа Пи создаваемым экземпляром (по умолчанию два знака после запятой);
- переопределяемый магический метод __str__, возвращающий строку с текущим значением числа Пи;
- управляемый атрибут max_pi, хранящий значение числа Пи с максимальной точностью в 13 знаков после запятой и недоступный для изменения или удаления;
- метод set_pi_prec, устанавливающий значение атрибута cur_pi экземпляра для хранения значения числа Пи с текущей точностью (по умолчанию два знака после запятой).
# Определяем класс числа Пи.
class PiNum:
# Инициализируем экземпляр.
def __init__(self, prec=2):
# Задаем текущую точность Пи.
self.set_pi_prec(prec)
# Оформляем строковое представление.
def __str__(self):
# Выводим значение Пи.
# с текущей точностью.
return str(self.cur_pi)
# Создаем управляемый атрибут.
@property
def max_pi(self):
# Неизменяемая макс-ная точность числа Пи.
return 3.1415926535897
# Запрещаем изменение и удаление атрибута.
@max_pi.setter
def max_pi(self, val): pass
@max_pi.deleter
def max_pi(self): pass
# Изменение точности представления числа Пи.
def set_pi_prec(self, prec=2):
# Задаем текущую точность.
self.cur_pi = round(self.max_pi, prec)
# Создаем экземпляр класса.
pi = PiNum(3)
# Выводим строковое представление объекта.
print(pi)
# Изменяем точность представления числа.
pi.set_pi_prec(5)
# Выводим текущее значение на экран.
print(pi.cur_pi)
# Выводим значение с макс. допустимой точностью.
print(pi.max_pi)
3.142
3.14159
3.1415926535897
13.9. Определите класс Circle, представляющий окружность и включающий:
- статический метод, переводящий метры в сантиметры или наоборот;
- конструктор, инициализирующий радиус r экземпляра и атрибут pi для хранения числа Пи с точностью в три знака после запятой (для получения требуемого значения используйте класс PiNum из предыдущей задачи);
- методы экземпляров для получения длины и площади окружности с точностью в три знака после запятой.
# Определяем класс числа Пи.
class PiNum:
# Инициализируем экземпляр.
def __init__(self, prec=2):
# Задаем текущую точность Пи.
self.set_pi_prec(prec)
# Оформляем строковое представление.
def __str__(self):
# Выводим значение Пи.
# с текущей точностью.
return str(self.cur_pi)
# Создаем управляемый атрибут.
@property
def max_pi(self):
# Неизменяемая макс-ная точность числа Пи.
return 3.1415926535897
# Запрещаем изменение и удаление атрибута.
@max_pi.setter
def max_pi(self, val): pass
@max_pi.deleter
def max_pi(self): pass
# Изменение точности представления числа Пи.
def set_pi_prec(self, prec=2):
# Задаем текущую точность.
self.cur_pi = round(self.max_pi, prec)
# Определяем класс окружности.
class Circle:
# Если понадобится перевод.
@staticmethod
def m_to_cm(n, flag=1):
# Проверка флага.
if flag == 0:
# Переводим см в метры.
return n/100
# Переводим метры в см.
return n*100
# Конструктор класса.
def __init__(self, r=1):
# Радиус окружности.
self.r = r
# Число Пи с требуемой точностью.
self.pi = PiNum(3).cur_pi
# Получаем длину окружности.
def get_len(self):
# Длина окружности.
return round(2*self.pi*self.r, 3)
# Получаем площадь окружности.
def get_s(self):
# Площадь окружности.
return round(self.pi*self.r**2, 3)
# Переводим радиус окружности из метров в см.
r = Circle.m_to_cm(2.57)
# Создаем экземпляр класса.
obj = Circle(r)
# Выводим на экран длину окружности.
print('Длина окружности: {} см.'.format(obj.get_len()))
print('Площадь окружности: {} кв.см.'.format(obj.get_s()))
Длина окружности: 1614.988 см.
Площадь окружности: 207525.958 кв.см.
13.10. Определите суперкласс Сотрудник, включающий:
- конструктор, инициализирующий имя работника, его должность (по умолчанию None) и оклад (по умолчанию 0);
- метод экземпляра для повышения оклада на какую-то часть (например, на 0.3, т.е. на 30%) с округлением результата до копеек;
- магический метод __str__ для перегрузки строкового представления объекта, который должен выводить данные о работнике в формате 'Атрибут: объект.атрибут' по одной записи на каждой строке.
- создайте экземпляр иван_менеджер созданного подкласса с начальным окладом в 1700 рублей;
- повысьте сотруднику оклад за счет стандартной надбавки в 0.335 и бонуса за должность в 0.25;
- выведите строковое представление объекта экземпляра с информацией о сотруднике на экран.
# Суперкласс.
class Сотрудник:
# Инициализируем начальные данные.
def __init__(self, имя, должность=None, оклад=0):
self.имя = имя
self.должность = должность
self.оклад = оклад
# Повышаем оклад.
def повысить_оклад(self, надбавка):
# Округляем до копеек.
self.оклад = round(self.оклад*(1 + надбавка), 2)
# Переопределяем строковое представление объекта.
def __str__(self):
# Форматируем строку вывода.
s = 'Имя: {}\nДолжность: {}\nОклад: {} руб.'
s = s.format(self.имя, self.должность, self.оклад)
# Выводим ее пользователю на экран.
return s
# Подкласс.
class Менеджер(Сотрудник):
# Переопределяем метод повышения оклада.
def повысить_оклад(self, надбавка, бонус=0.15):
Сотрудник.повысить_оклад(self, надбавка + бонус)
# Создаем экземпляр подкласса «Менеджер».
петр_менеджер = Менеджер('Петр', 'менеджер', 1700)
# Повышаем оклад.
петр_менеджер.повысить_оклад(надбавка=0.335, бонус=0.25)
# Выводим на экран строковое представление объекта.
print(петр_менеджер)
Имя: Петр
Должность: менеджер
Оклад: 2694.5 руб.
13.11. Создайте абстрактный класс геометрической фигуры Shape с конструктором, принимающим длину стороны и высоту, проведенную к этой стороне. Определите в классе абстрактный метод area(), который будет использоваться подклассами для расчета площади соответствующих им геометрических фигур. Далее создайте классы Triangle и Rectangle, наследующие суперкласс Shape и реализующие его абстрактный метод под свои нужды. Продемонстрируйте использование созданных классов для нахождения площади треугольника и прямоугольника по известным значениям длины стороны и высоты, проведенной к этой стороне. Показать решение.
# Импортируем класс и декоратор.
from abc import ABC, abstractmethod
# Определяем абстрактный суперкласс.
class Shape(ABC):
# Сразу инициализируем длину стороны и соответствующую высоту фигуры.
def __init__(self, length, height):
self.length = length
self.height = height
# Определяем абстрактный метод расчета площади треугольника.
@abstractmethod
def area(self):
pass
# Определяем подкласс треугольника.
class Triangle(Shape):
# Определяем метод расчета площади треугольника.
def area(self):
# Площадь треугольника равна половине произведения основания на высоту.
return 0.5*self.length*self.height
# Определяем подкласс прямоугольника.
class Rectangle(Shape):
# Определяем метод расчета площади прямоугольника.
def area(self):
# Площадь прямоугольника равна произведению его сторон.
return self.length*self.height
# Создаем экземпляр класса треугольника.
trian = Triangle(20, 10)
# Рассчитываем площадь.
print('S треугольника:', trian.area())
# Создаем экземпляр класса прямоугольника.
rect = Rectangle(20, 10)
# Рассчитываем площадь.
print('S прямоугольника:', rect.area())
S треугольника: 100.0
S прямоугольника: 200
13.12. Определите класс Counter, реализующий десятичный счетчик, который может увеличивать или уменьшать свое значение на единицу в заданном диапазоне, включая границы диапазона. В классе должны быть предусмотрены следующие возможности:
- конструктор для инициализации счетчика значениями по умолчанию (стартовое значение, нижняя и верхняя границы диапазона),
- метод для его инициализации произвольными значениями,
- а также методы для увеличения и уменьшения текущего значения счетчика.
# Создаем класс.
class Counter():
# Инициализируем создаваемый счетчик.
def __init__(self, *, start=0, min_v=0, max_v=5):
# Устанавливаем начальные параметры счетчика.
self.set_counter(start=start, min_v=min_v, max_v=max_v)
# Установка значения счетчика.
def set_counter(self, *, start=0, min_v=0, max_v=5):
# Проверяем выход за диапазон.
a = start >= min_v
b = start <= max_v
# Чтобы счетчик мог сработать хотя бы раз.
c = max_v > min_v
# Составляем условие.
if a and b and c:
# Начальное значение счетчика.
self.start = start
# Текущее значение счетчика.
self.current = start
# Минимальное значение счетчика.
self.min_v = min_v
# Верхняя граница счетчика.
self.max_v = max_v
# Увеличение счетчика на единицу.
def up_counter(self):
# Проверяем выход за диапазон.
if self.current in range(self.min_v, self.max_v):
self.current += 1
# Возвращаем сигнал.
return 1
else:
# Возвращаем сигнал.
return 0
# Уменьшение счетчика на единицу.
def down_counter(self):
# Проверяем выход за диапазон.
if self.current in range(self.min_v+1, self.max_v+1):
self.current -= 1
# Возвращаем сигнал.
return 1
else:
# Возвращаем сигнал.
return 0
# Создаем счетчик (используем значения по умолчанию).
cnt_1 = Counter()
# Выводим стартовые значения параметров.
print('start:', cnt_1.start)
print('current:', cnt_1.current)
print('min:', cnt_1.min_v)
print('max:', cnt_1.max_v, end='\n\n')
# Проверяем счетчик в деле по всему диапазону.
for i in range(cnt_1.min_v, 100):
# Выводим текущее значение счетчика.
print('current:', cnt_1.current)
# Проверяем выход за диапазон и, если все ок,
# увеличиваем значение счетчика на единицу.
if not cnt_1.up_counter(): break
# Переустановим счетчик.
cnt_1.set_counter(start=2, min_v=-3, max_v=10)
# Выводим стартовые значения параметров.
print('\n\nstart:', cnt_1.start)
print('current:', cnt_1.current)
print('min:', cnt_1.min_v)
print('max:', cnt_1.max_v, end='\n\n')
# Проверяем выход за диапазон.
for i in range(cnt_1.start, -100, -1):
# Выводим текущее значение счетчика.
print('current:', cnt_1.current)
# Проверяем выход за диапазон и, если все ок,
# уменьшаем значение счетчика на единицу.
if not cnt_1.down_counter(): break
start: 0
current: 0
min: 0
max: 5
current: 0
current: 1
current: 2
current: 3
current: 4
current: 5
start: 2
current: 2
min: -3
max: 10
current: 2
current: 1
current: 0
current: -1
current: -2
current: -3
Задачи на импорт, модули и пакеты
Теоретический материал по импортированию, модулям и пакетам можно почитать в нашем учебнике здесь.
14.1. Импортируйте из стандартной библиотеки модуль math. Используя необходимые атрибуты модуля выведите на экран результаты вычисления выражений: cosπ (см. косинус и число Пи), √e (см. число e) и 5! (см. факториал). Показать решение.
# Импортируем модуль math.
import math
# Вычисляем и выводим на экран.
res = math.cos(math.pi)
print(res)
res = math.sqrt(math.e)
print(res)
res = math.factorial(5)
print(res)
-1.0
1.6487212707001282
120
14.2. Выведите на экран текущее время. Для решения задачи импортируйте из модуля datetime стандартной библиотеки класс datetime. Далее используйте цепочку datetime.now().time(), которая как раз и вернет текущее время. Показать решение.
# Импортируем из модуля datetime класс datetime.
from datetime import datetime
# Выводим текущее время.
print(datetime.now().time())
14:10:32.657780
14.3. Выведите на экран текущую версию интерпретатора в формате «Python major.micro.minor.». Для выполнения задания импортируйте атрибут version_info модуля sys стандартной библиотеки. Показать решение.
# Импорт в глоб. обл. видимости.
from sys import version_info
# Выводим версию Питона на экран.
print('Python {0[0]}.{0[1]}.{0[2]}.'.format(version_info))
Python 3.11.3.
14.4. Импортируйте из модуля random стандартной библиотеки функции randint и choice, использовав для них псевдонимы rnd и chc. Создайте список li и заполните его пятью случайными целыми числами от 1 до 20. Выведите на экран сам список, а также случайный элемент списка. Показать решение.
# Импортируем требуемые функции.
from random import randint as rnd, choice as chc
# Создаем список для заполнения числами.
li = []
# Заполняем 5-ю случайными целыми числами от 1 до 20.
for n in range(1, 6):
# Добавляем очередное случайное число.
li.append(rnd(1, 20))
# Выводим получившийся список.
print('Список случайных чисел:', li)
# Выводим из списка случайное число.
print('Случайное число из списка:', chc(li))
Список случайных чисел: [17, 18, 7, 8, 7]
Случайное число из списка: 18
14.5. Выполните следующее упражнение:
- создайте вручную корневой каталог проекта project с исполняемым файлом main.py;
- в полученном каталоге создайте два пакета pkg_1 и pkg_2, добавив в них соответствующие модули mod_1.py с инструкцией x = 1 и mod_2.py с инструкцией x = 2;
- используя главный файл проекта выведите на экран сумму значений переменных модулей.
Показать решение.
Ответ. Не забываем, что для преобразования каталога в пакет необходимо создать в нем файл инициализации __init__.py.
# Импортируем модули в глоб. обл. видимости.
from pkg_1 import mod_1
from pkg_2 import mod_2
# Можно, например, и так.
# import pkg_1.mod_1 as mod_1
# import pkg_2.mod_2 as mod_2
# Выводим сумму значений переменных.
res = mod_1.x + mod_2.x
print('{} + {} = {}'.format(mod_1.x, mod_2.x, res))
1 + 2 = 3
14.6. Выполните следующее упражнение:
- создайте вручную корневой каталог проекта project с исполняемым файлом main.py;
- в полученном каталоге создайте два пакета pkg_1 и pkg_2, добавив в них соответствующие модули mod_1.py с инструкцией x = 1 и mod_2.py с инструкцией y = 2;
- в пакет pkg_2 добавьте подпакет pkg_3, содержащий модуль mod_3.py с инструкцией z_2 = z_1 = 3;
- добавьте в модуль mod_1.py инструкцию импорта переменной z_1, а в модуль mod_2.py инструкцию импорта переменной z_2;
- используя главный файл проекта выведите на экран сумму значений всех переменных модулей mod_1.py и mod_2.py.
Показать решение.
Ответ. Не забываем, что относительный импорт через корневой каталог программы запрещен. Он доступен только для подпакетов какого-нибудь пакета, но без выхода участков пути в корневой каталог.
# Импортируем все переменные модулей.
from pkg_1.mod_1 import *
from pkg_2.mod_2 import *
# Можно, например, и так.
# from pkg_1.mod_1 import x, z_1
# from pkg_2.mod_2 import y, z_2
# Выводим сумму значений переменных.
res = x + y + z_1 +z_2
print('{} + {} + {} + {} = {}'.format(x, y, z_1, z_2, res))
1 + 2 + 3 + 3 = 9
14.7. Используя функцию import_module модуля importlib стандартной библиотеки напишите функцию imp_mods(mods), импортирующую в глобальную область видимости текущего модуля необходимые пакеты и модули. В качестве аргумента функция должна принимать кортеж или список имен пакетов и модулей для импорта. Импортируйте при помощи созданной функции модули random и math, а затем выведите на экран факториал случайного положительного целого числа не превышающего десяти. Показать решение.
# Импортируем требуемую функцию.
from importlib import import_module
# Объявляем функцию.
def imp_mods(mods):
# Получаем словарь глоб-ных переменных модуля.
glb = globals()
# Если список имен не пустой.
if mods:
# Циклом импортируем все модули.
for m in mods:
# И добавляем их в глобальное
# пространство имен модуля.
glb[m] = import_module(m)
# Импортируем требуемые модули.
imp_mods(('random', 'math'))
# Выводим факториал случайного числа.
print(math.factorial(random.randint(1, 10)))
6
Задачи на файлы и каталоги
Теоретический материал по работе с файлами и каталогами можно почитать в нашем учебнике здесь.
15.1. Используя встроенную функцию open(), создайте в каталоге скрипта файл text_1.txt и запишите туда строку 'Пайтон практика: упражнения и задачи.', не забыв закрыть файл после операции. Выведите содержимое записанного файла на экран. Показать решение.
# Создаем и открываем файл на запись.
f_obj = open('text_1.txt', 'w', encoding='utf-8')
# Записываем в него строку.
f_obj.write('Пайтон практика: упражнения и задачи.')
# Закрываем файловый объект.
f_obj.close()
# Открываем файл в режиме чтения.
f_obj = open('text_1.txt', 'r', encoding='utf-8')
# Считываем все содержимое.
text = f_obj.read()
# Закрываем файловый объект.
f_obj.close()
# Выводим содержимое файла на экран.
print(text)
Пайтон практика: упражнения и задачи.
15.2. Используя соответствующую встроенную функцию, откройте в каталоге скрипта файл text_2.txt в режиме записи и чтения, запишите туда строку '0123456789', после чего считайте записанное содержимое и выведите его на экран, не забыв закрыть файл после операции. Далее, откройте файл в режиме дозаписи и чтения, допишите туда строку 'abcdef' и также выведите обновленное содержимое файла на экран. Показать решение.
# Создаем и открываем файл на запись и чтение.
f_obj = open('text_2.txt', 'w+', encoding='utf-8')
# Записываем в него строку.
f_obj.write('0123456789')
# Перемещаем указатель в начало файла.
f_obj.seek(0)
# Считываем содержимое.
text = f_obj.read()
# Выводим все на экран.
print(text)
# Закрываем файловый объект.
f_obj.close()
# Открываем файл в режиме дозаписи и чтения.
f_obj = open('text_2.txt', 'a+', encoding='utf-8')
# Дописываем в него строку.
f_obj.write('abcdef')
# Перемещаем указатель в начало файла.
f_obj.seek(0)
# Считываем содержимое и выводим на экран.
print(f_obj.read())
# Закрываем файловый объект.
f_obj.close()
0123456789
0123456789abcdef
15.3. Используя соответствующую встроенную функцию создайте в каталоге скрипта файл li.py и запишите туда строку li_1 = [1, 2]. Далее, используя менеджер контекста with/as, допишите в файл строку li_2 = ['red', 'green'] и, не выходя за область видимости менеджера, выведите на экран содержимое файла используя для чтения цикл for. Показать решение.
# Создаем и записываем файл li.py.
f = open('li.py', 'w', encoding='utf-8')
# Записываем в него первую строку.
f.write('li_1 = [1, 2]\n')
# Закрываем файловый объект.
f.close()
# Открываем файл li.py в менеджере контекста.
with open('li.py', 'a+', encoding='utf-8') as f:
# Дописываем в него еще одну строку.
f.write("li_2 = ['red', 'green']")
# Перемещаем файловый указатель в начало файла.
f.seek(0)
# Выводим строки на экран.
for s in f.readlines(): print(s, end='')
# Еще раз перемещаем указатель в начало файла.
f.seek(0)
print('\n\nИ еще раз...\n')
# Т.к. файловый объект итерируем и его эл-ми
# являются строки, можно сделать и так.
for s in f: print(s, end='')
li_1 = [1, 2]
li_2 = ['red', 'green']
И еще раз...
li_1 = [1, 2]
li_2 = ['red', 'green']
15.4. Используя менеджер контекста и соответствующую встроенную функцию, создайте в каталоге скрипта файл mod.py и запишите туда инструкцию определения функции sum_func, принимающую два числа и возвращающую их сумму. Используя вновь созданный модуль выведите на экран сумму чисел 10 и 20. Затем допишите в файл инструкцию определения функции mul_func, принимающую два числа и возвращающую их произведение. Используя обновленный модуль выведите на экран произведение чисел 10 и 20. Показать решение.
# Импортируем функцию перезагрузки модулей.
from importlib import reload
# Сохраняем числа в переменных.
x, y = 10, 20
# Сохраняем объявление функции в переменной.
s = '''def sum_func(x, y):
return x + y'''
# Создаем и открываем файл на запись.
with open('mod.py', 'w', encoding='utf-8') as f:
# Записываем в него содержимое.
f.write(s)
# Импортируем созданный модуль.
import mod
# Выводим сумму на экран.
print('x + y =', mod.sum_func(x, y))
# Формируем еще одно определение функции.
s = '''
def mul_func(a, b):
return a*b'''
# Открываем файл на дозапись.
with open('mod.py', 'a+', encoding='utf-8') as f:
# Дописываем еще одну инструкцию.
f.write(s)
# Перезагружаем модуль.
reload(mod)
# Выводим на экран произведение.
print('x*y =', mod.mul_func(x, y))
x + y = 30
x*y = 200
15.5. Используя возможности модуля pathlib cоздайте в каталоге скрипта каталог test_dir, а в нем пустой файл test_file.txt. Запишите в файл строку 'Python Ok или Ok Python.', после чего выведите содержимое файла на экран. Удалите каталог и файл. Результаты всех операций должны отображаться на экране, как показано в кодовом блоке ниже. Показать решение.
Каталог и файл созданы!
Нажмите любую клавишу...
Python Ok или Ok Python?
Файл записан и прочитан!
Нажмите любую клавишу...
Все удалено!
Нажмите любую клавишу...
# Импортируем из модуля класс.
from pathlib import Path
# Создаем каталог.
p_dir = Path('test_dir')
p_dir.mkdir(exist_ok=True)
# Создаем в каталоге пустой файл.
p_file = p_dir/'test_file.txt'
p_file.touch()
print('Каталог и файл созданы!')
input('Нажмите любую клавишу...\n')
# Открываем файл для записи.
with p_file.open(mode='w', encoding='utf-8') as f:
# Записываем текст.
f.write('Python Ok или Ok Python?')
# Открываем и читаем файл.
with p_file.open(encoding='utf-8') as f:
print(f.read(), '\n')
print('Файл записан и прочитан!')
input('Нажмите любую клавишу...\n')
# Удаляем файл.
p_file.unlink()
# Удаляем пустой каталог.
p_dir.rmdir()
print('Все удалено!')
input('Нажмите любую клавишу...')
Каталог и файл созданы!
Нажмите любую клавишу...
Python Ok или Ok Python?
Файл записан и прочитан!
Нажмите любую клавишу...
Все удалено!
Нажмите любую клавишу...
15.6. Напишите скрипт, в котором объявите три функции:
- create_db(db_name) – должна принимать строковый аргумент и создавать пустое хранилище db_name, если оно еще не существует.
- set_amount(db_name, num, money) – должна проверять, существует ли в хранилище счет num (строка), после чего либо создавать и пополнять его с выводом сообщения «Счет №{num} создан, баланс пополнен!», либо обновлять баланс существующего счета с выводом сообщения «Баланс счета №{num} обновлен!».
- get_amount(db_name, num) – должна выводить текущий баланс счета num (строка) на экран в форме «Текущий баланс счета №{num}: {money} руб.».
После объявления функций создайте хранилище my_bank. Создайте в нем банковский счет 3335, пополнив его баланс на 5000 рублей, после чего выведите баланс на экран. Проделайте тоже самое для счета 3336, положив на счет сперва 300 рублей, а потом доложив еще 700 рублей.
Для решения задачи используйте модуль shelve, а также класс Path модуля pathlib, которые импортируйте в глобальное пространство скрипта. Показать решение.
Счет N3335 создан, баланс пополнен!
Текущий баланс счета N3335: 5000 руб.
Счет N3336 создан, баланс пополнен!
Текущий баланс счета N3336: 300 руб.
Баланс счета N3336 обновлен!
Текущий баланс счета N3336: 1000 руб.
# Импортируем модуль shelve.
import shelve
# Импортируем класс для работы с путями.
from pathlib import Path
# Определяем функцию создания хранилища.
def create_db(db_name):
# Получаем объект пути.
p = Path(db_name)
# Если каталог хранилища еще не создан.
if not p.exists():
# Создаем каталог для хранилища.
p.mkdir()
# Используем менеджер контекста.
with shelve.open(p/p) as db:
# Просто создаем хранилище.
pass
# Обновить значение суммы на счете.
def set_amount(db_name, num, money):
# Получаем объект пути.
p = Path(db_name)
# Используем менеджер контекста.
with shelve.open(p/p) as db:
# Если счет еще не открыт.
if num not in db:
# Устанавливаем баланс счета.
db[num] = money
# Выводим сообщение.
s = 'Счет N' + num + ' создан, баланс пополнен!'
print(s)
else:
# Устанавливаем баланс счета.
db[num] = money
# Выводим сообщение.
print('Баланс счета N' + num + ' обновлен!')
# Получить текущий баланс счета.
def get_amount(db_name, num):
# Получаем объект пути.
p = Path(db_name)
# Используем менеджер контекста.
with shelve.open(p/p) as db:
# Выводим сумму счета на экран.
mess = 'Текущий баланс счета N'+ num +':'
print(mess, db[num], 'руб.', end='\n\n')
# Создаем базу данных для счета.
create_db('my_bank')
# Создаем счет №3335 и пополняем его баланс.
set_amount('my_bank', '3335', 5000)
# Получаем баланс счета.
get_amount('my_bank', '3335')
# Создаем счет №3336 и пополняем его баланс.
set_amount('my_bank', '3336', 300)
# Получаем баланс счета.
get_amount('my_bank', '3336')
# Обновляем баланс счета №3336.
set_amount('my_bank', '3336', 1000)
# Получаем баланс счета.
get_amount('my_bank', '3336')
Счет N3335 создан, баланс пополнен!
Текущий баланс счета N3335: 5000 руб.
Счет N3336 создан, баланс пополнен!
Текущий баланс счета N3336: 300 руб.
Баланс счета N3336 обновлен!
Текущий баланс счета N3336: 1000 руб.
15.7. Выполните следующее упражнение:
- создайте в папке скрипта корневой каталог упражнения root_dir;
- в полученном корневом каталоге создайте еще четыре каталога dir_1, dir_2, dir_3, и dir_4, добавив в них соответствующие пустые файлы f_1.txt, f_2.txt, f_3.txt и f_4.txt (не нужно создавать все вручную, используйте цикл);
- выведите сообщение 'Все каталоги и файлы созданы!' и призыв к действию 'Нажмите любую клавишу...\n';
- переместите каталог dir_2 в dir_1 и переименуйте файл f_2.txt в f_1_2.txt;
- переместите каталог dir_4 в dir_3 и переименуйте файл f_4.txt в f_3_4.txt;
- выведите сообщение 'Все перемещено и переименовано!' и призыв к действию 'Нажмите любую клавишу...\n';
- удалите каталог dir_3 и файл f_1.txt
- выведите сообщение 'dir_3 удален, f_1.txt удален!' и призыв к действию 'Нажмите любую клавишу...\n';
- поместите каталог dir_1 в одноименный архив в том же каталоге (т.е. в root_dir), а сам каталог dir_1 удалите;
- выведите сообщение 'dir_1 заархивирован, сам dir_1 удален!' и призыв к действию 'Нажмите любую клавишу...\n';
- распакуйте архив обратно в каталог root_dir, сам архив удалите (в root_dir должен остаться только распакованный каталог dir_1);
- выведите сообщение 'dir_1 разархивирован, сам архив удален!' и призыв к действию 'Нажмите любую клавишу...'.
Для выполнения задания используйте функции модуля shutil и методы класса pathlib.Path. Выполняйте упражнение поэтапно, при необходимости удаляя корневой каталог упражнения воизбежание ошибок. Показать решение.
# Импортируем модуль.
import shutil
# Импортируем класс.
from pathlib import Path
# Создаем корневой каталог упражнения.
r = Path('root_dir')
r.mkdir()
# Циклом создаем в нем каталоги и файлы.
for k in range(1, 5):
d = r/'dir_{}'.format(k)
d.mkdir()
f = d/'f_{}.txt'.format(k)
f.touch()
print('Все каталоги и файлы созданы!')
input('Нажмите любую клавишу...\n')
# Перемещаем dir_2 в dir_1.
shutil.move(r/'dir_2', r/'dir_1')
# Переименовываем f_2 в f_1_2.
p_1 = r/'dir_1/dir_2/f_2.txt'
p_2 = r/'dir_1/dir_2/f_1_2.txt'
p_1.rename(p_2)
# Перемещаем dir_4 в dir_3.
shutil.move(r/'dir_4', r/'dir_3')
# Переименовываем f_4 в f_3_4.
p_1 = r/'dir_3/dir_4/f_4.txt'
p_2 = r/'dir_3/dir_4/f_3_4.txt'
p_1.rename(p_2)
print('Все перемещено и переименовано!')
input('Нажмите любую клавишу...\n')
# Удаляем каталог dir_3.
shutil.rmtree(r/'dir_3')
# Удаляем файл f_1.txt.
(r/'dir_1/f_1.txt').unlink()
print('dir_3 удален, f_1.txt удален!')
input('Нажмите любую клавишу...\n')
# Путь к создаваемому файлу архива (без расширения).
a_name = r/'dir_1'
# Путь к каталогу отсчета.
r_dir = r
# Путь к архивируемому каталогу.
b_dir = 'dir_1'
# Архивируем root_dir/dir_1.
shutil.make_archive(a_name, 'zip', r_dir, b_dir)
# Удаляем каталог dir_1.
shutil.rmtree(r/'dir_1')
print('dir_1 заархивирован, сам dir_1 удален!')
input('Нажмите любую клавишу...\n')
# Полный путь к архиву (с расширением файла).
a_name = r/'dir_1.zip'
# Все распаковываем в root_dir.
shutil.unpack_archive(a_name, r)
# Сам архив удаляем.
Path(a_name).unlink()
print('dir_1 разархивирован, сам архив удален!')
input('Нажмите любую клавишу...')
15.8. Напишите функцию mk_pkg(path, root_path='./'), создающую по переданному в виде строки относительному пути path готовый python-пакет (т.е. каталог с файлом инициализации __init__.py). В случае отсутствия в пути каких-либо промежуточных пакетов или наличии каталогов без файлов инициализации, функция должна создавать их. Необязательный аргумент root_path='./' должен принимать строку с каталогом, относительно которого будет отсчитываться местоположение целевого каталога (по умолчанию в качестве локального корня должен использоваться каталог скрипта). Когда функция будет готова, проверьте ее, предварительно создав в каталоге скрипта обычный каталог pkg_1, а затем осуществив два вызова функции: mk_pkg('pkg_1/pkg_2') и mk_pkg('pkg_1/pkg_3/pkg_4'). Показать решение.
# Импортируем класс в глобальное пространство.
from pathlib import Path
# Пишем заголовок функции.
def mk_pkg(path, root_path='./'):
# Импортируем классы в лок-ную обл. видимости.
from pathlib import Path, PurePath
# Формируем путь к целевому пакету.
pkg_path = root_path + path
# Создаем целевую цепочку каталогов.
Path(pkg_path).mkdir(parents=True, exist_ok=True)
# Получаем кортеж каталогов пути.
dirs_tpl = PurePath(path).parts
# Начальное значение пути при обходе циклом.
cur_dir = Path(root_path)
# Проверяем все каталоги на __init__.py.
for p in dirs_tpl:
# Сразу же наращиваем путь.
cur_dir /= p
# Если файл инициализации отсутствует.
if not Path(cur_dir / '__init__.py').exists():
# Создаем его.
Path(cur_dir / '__init__.py').touch()
# Создаем пустой каталог.
Path('pkg_1').mkdir()
# Проверяем функцию.
mk_pkg('pkg_1/pkg_2')
mk_pkg('pkg_1/pkg_3/pkg_4')
Задачи на исключения и ошибки
Теоретический материал по обработке исключений и ошибок можно почитать в нашем учебнике здесь.
16.1. Напишите пользовательскую функцию pow3_func(x), которая должна принимать в качестве аргумента число x и возводить его в куб. В случае успешных вычислений функция должна выводить на экран сообщение в формате «x^3 = res» и возвращать res. В противном случае должно выводиться соответствующее сообщение об ошибке и возвращаться None. Проверьте функцию, вызвав ее с аргументами 5 и '5'. Показать решение.
# Определяем функцию.
def pow3_func(x):
try:
# Пытаемся возвести x в куб.
res = pow(x, 3)
# Если что, перехватываем исключение.
except Exception as err:
# Помечаем, что рез-т не получен.
res = None
# Сообщаем о наличии ошибки.
print('Ошибка: «{}».'.format(err))
else:
# Выводим результат вычислений.
print('{}^3 = {}'.format(x, res))
# Возвращаем результат.
return res
# Вызываем функцию.
pow3_func(5)
pow3_func('5')
5^3 = 125
Ошибка: «unsupported operand type(s) for ** or pow(): 'str' and 'int'».
16.2. Напишите пользовательскую функцию write_file(f_obj, s), которая должна принимать в качестве аргумента объект открытого файла f_obj и пытаться записать в него строку s. В случае успешного завершения операции функция должна выводить на экран сообщение «Файл записан!». В противном случае должно выводиться соответствующее сообщение об ошибке. При любом исходе функция должна закрывать файловый объект перед завершением вызова и выводить сообщение «Файл закрыт!». Проверьте работу функции. Для этого создайте в папке скрипта пустой файл nums.py и запишите туда строку '1 2 3'. Далее откройте файл на чтение и попытайтесь записать в него строку '4 5 6'. Для решения задачи используйте в теле функции полную инструкцию try/except/else/finally. Показать решение.
# Функция записи и закрытия файла.
def write_file(f_obj: 'файловый объект', s):
try:
# Пытаемся записать в него строку.
f_obj.write(s)
# Если что, перехватываем исключение.
except Exception as err:
# Сообщаем о наличии ошибки.
print('Ошибка: «{}».'.format(err))
else:
# Выводим результат вычислений.
print('Файл записан!')
finally:
# В любом случае закрываем файл.
f_obj.close()
print('Файл закрыт!\n')
# Создаем в каталоге скрипта пустой файл.
f = open('nums.py', 'w', encoding='utf-8')
# Вызываем функцию.
write_file(f, '1 2 3')
# Теперь открываем файл на чтение.
f = open('nums.py', 'r', encoding='utf-8')
# Пытаемся его записать.
write_file(f, '4 5 6')
Файл записан!
Файл закрыт!
Ошибка: «not writable».
Файл закрыт!
16.3. Напишите пользовательскую функцию avg(x, y), которая должна принимать в качестве аргументов два положительных целых или вещественных числа, а возвращать их среднее геометрическое (z = pow(x*y, 0.5)). В случае передачи недопустимых значений функция должна возбуждать исключение ValueError. После того, как функция будет готова, используйте ее в скрипте, который будет запрашивать у пользователя два числа, обрабатывать ввод и выдавать либо среднее геометрическое чисел, либо сообщение об ошибке. Для решения задачи используйте в теле функции инструкцию raise, а в скрипте try/except. Показать решение.
# Определяем функцию.
def avg(x, y):
# Проверяем, чтобы оба числа были положительны.
if x > 0 and y > 0:
return pow(x*y, 0.5)
else:
# Возбуждаем исключение.
e = ValueError('Введите допустимые числовые значения!')
raise e
# Отлавливаем исключения.
try:
# Просим ввести числа.
print('Введите два неотрицательных числа.')
# Обрабатываем ввод чисел.
x = float(input('Введите x: '))
y = float(input('Введите y: '))
# Рассчитываем среднее геометрическое и округляем.
z = round(avg(x, y), 2)
# Выводим результат на экран.
s = 'Среднее геометрическое чисел {} и {} равно {}.'
print(s.format(x, y, z))
# Обработка исключения ValueError.
except ValueError as err:
print(err)
# Обработка остальных исключений.
except Exception as err:
print('Ошибка: «{}».'.format(err))
Введите два неотрицательных числа.
Введите x: 5
Введите y: 7
Среднее геометрическое чисел 5.0 и 7.0 равно 5.92.
-----------------------------
Введите два неотрицательных числа.
Введите x: -5
Введите y: 7
Введите допустимые числовые значения!
-----------------------------
Введите два неотрицательных числа.
Введите x: 7
Введите y: one
could not convert string to float: 'one'
16.4. Не используя возможности модуля abc стандартной библиотеки, создайте абстрактный класс геометрической фигуры Shape с конструктором, принимающим длину стороны и высоту, проведенную к этой стороне. Определите в классе абстрактный метод area(), который будет использоваться подклассами для расчета площади соответствующих им геометрических фигур. Для реализации абстрактности метода используйте возбуждение исключения NotImplementedError. Далее создайте классы Triangle и Rectangle, наследующие суперкласс Shape и реализующие его абстрактный метод под свои нужды. Продемонстрируйте использование созданных классов для нахождения площади треугольника и прямоугольника по известным значениям длины стороны и высоты, проведенной к этой стороне. Закомментируйте в одном из классов переопределяемый метод area(), использовав вместо него инструкцию pass, и повторно запустите скрипт. Объясните результат. Еще раз посмотрите решение задачи 13.11. Показать решение.
Ответ. Если абстрактный метод area() не переопределить в подклассе, будет вызвано исключение NotImplementedError, а на экран выведено соответствующее предупреждение.
# Определяем абстрактный суперкласс.
class Shape():
# Сразу инициализируем длину стороны и соответствующую высоту фигуры.
def __init__(self, length, height):
self.length = length
self.height = height
# Определяем абстрактный метод расчета площади треугольника.
def area(self):
# Используем перехват исключения и вывод его на экран.
try:
# Возбуждаем исключение
raise NotImplementedError("Вы забыли переопределить абстрактный метод!")
# Выводим информацию об исключении на экран.
except NotImplementedError as err:
print(err)
input()
# Определяем подкласс треугольника.
class Triangle(Shape):
# Определяем метод расчета площади треугольника.
def area(self):
# Площадь треугольника равна половине произведения основания на высоту.
return 0.5*self.length*self.height
# Определяем подкласс прямоугольника.
class Rectangle(Shape):
# Определяем метод расчета площади прямоугольника.
def area(self):
# Площадь прямоугольника равна произведению его сторон.
return self.length*self.height
# Создаем экземпляр класса треугольника.
trian = Triangle(20, 10)
# Рассчитываем площадь.
print('S треугольника:', trian.area())
# Создаем экземпляр класса прямоугольника.
rect = Rectangle(20, 10)
# Рассчитываем площадь.
print('S прямоугольника:', rect.area())
S треугольника: 100.0
S прямоугольника: 200
Использование утилиты pip и виртуальных окружений
Теоретический материал по работе с менеджером пакетов pip и виртуальными окружениями можно почитать в нашем учебнике здесь.
17.1. Выполните в консоли своей операционной системы с помощью менеджера пакетов pip следующее упражнение:
- выведите текущую версию pip;
- выведите справку по нему;
- выведите список пакетов, установленных в текущем окружении;
- установите пакет cowsay;
- выведите информацию о пакете cowsay;
- повторно выведите список пакетов, установленных в окружении;
- удалите пакет cowsay;
- еще раз выведите список пакетов, установленных в окружении.
Если имеется такая возможность, выполните упражнение как в ОС Windows, так и в ОС Ubuntu. Показать решение.
Ответ. Я выполнял упражнение в командной оболочке ОС Windows в виртуальном окружении созданного ранее проекта. В командной bash-оболочке ОС Ubuntu упражение выполняется в принципе также, но только с использованием обычных слешей вместо обратных. В случае выполнения упражнения вне виртуального окружения в ОС Ubuntu используйте слово python3 вместо обычного python.
(venv) D:\python\prj_manager\prjs\my_prj>pip3 --version pip 22.3.1 from D:\python\prj_manager\prjs\my_prj\venv\Lib\site-packages\pip (python 3.11) (venv) D:\python\prj_manager\prjs\my_prj>pip3 help Usage: pip3 <command> [options] Commands: install Install packages. ........................ --use-deprecated <feature> Enable deprecated functionality, that will be removed in the future. (venv) D:\python\prj_manager\prjs\my_prj>python -m pip list Package Version ---------- ------- pip 22.3.1 setuptools 65.5.0 (venv) D:\python\prj_manager\prjs\my_prj>python -m pip install cowsay Collecting cowsay Using cached cowsay-5.0.tar.gz (25 kB) Preparing metadata (setup.py) ... done Installing collected packages: cowsay DEPRECATION: cowsay is being installed using ... Successfully installed cowsay-5.0 (venv) D:\python\prj_manager\prjs\my_prj>pip3 show cowsay Name: cowsay Version: 5.0 Summary: The famous cowsay for GNU/Linux is now available for python Home-page: https://github.com/VaasuDevanS/cowsay-python Author: Vaasudevan Srinivasan Author-email: vaasuceg.96@gmail.com License: GNU-GPL Location: D:\python\prj_manager\prjs\my_prj\venv\Lib\site-packages Requires: Required-by: (venv) D:\python\prj_manager\prjs\my_prj>pip3 list Package Version ---------- ------- cowsay 5.0 pip 22.3.1 setuptools 65.5.0 (venv) D:\python\prj_manager\prjs\my_prj>pip3 uninstall cowsay Found existing installation: cowsay 5.0 Uninstalling cowsay-5.0: Would remove: d:\python\prj_manager\prjs\my_prj\venv\lib\site-packages\cowsay-5.0-py3.11.egg-info d:\python\prj_manager\prjs\my_prj\venv\lib\site-packages\cowsay\* d:\python\prj_manager\prjs\my_prj\venv\scripts\cowsay-script.py d:\python\prj_manager\prjs\my_prj\venv\scripts\cowsay.exe Proceed (Y/n)? y Successfully uninstalled cowsay-5.0 (venv) D:\python\prj_manager\prjs\my_prj>pip3 list Package Version ---------- ------- pip 22.3.1 setuptools 65.5.0 (venv) D:\python\prj_manager\prjs\my_prj>
17.2. Напишите класс PipManager, в котором определите следующие методы:
- show_pip_version() – вывод версии менеджера;
- show_pip_help() – вывод справки по менеджеру;
- install_package(package_name) – установка пакета;
- upgrade_package(package_name) – обновление пакета;
- show_package_info(package_name) – вывод информации о пакете;
- show_packages() – вывод списка установленных пакетов;
- uninstall_package(package_name) – удаление пакета.
Используя возможности созданного класса, дополните скрипт так, чтобы он смог выполнить предыдущее упражнение в автоматическом режиме. Показать решение.
# Импортируем требуемый модуль станд. библиотеки.
import os
# Класс с командами pip.
class PipManager:
# Выводит версию pip (os.system(command) исполняет системную команду).
def show_pip_version(self):
os.system('pip3 --version')
# Выводит в консоль справку по pip
def show_pip_help(self):
os.system('pip3 help')
# Пытается установить пакет или сообщает о том, что пакет уже установлен.
def install_package(self, package_name):
os.system('pip3 install ' + package_name)
# Обновить пакет, если в этом есть необходимость.
def upgrade_package(self, package_name):
os.system('pip3 install --upgrade ' + package_name)
# Показывает информацию об установленном пакете.
def show_package_info(self, package_name):
os.system('pip3 show ' + package_name)
# Выводит в консоль список уже установленных пакетов
# (см. в домашнем каталоге Питона в lib\site-packages).
def show_packages(self):
os.system('pip3 list')
# Пытается удалить пакет.
def uninstall_package(self, package_name):
os.system('pip3 uninstall ' + package_name)
# Главная функция программы.
def main():
# Создаем экземпляр класса PipManager.
pip_obj = PipManager()
# Выводим версию менеджера.
pip_obj.show_pip_version()
print()
# Выводим справку по нему.
pip_obj.show_pip_help()
print()
# Выводим список всех установленных пакетов.
pip_obj.show_packages()
print()
# Устанавливаем пакет cowsay.
pip_obj.install_package('cowsay')
print()
# Выводим информацию о нем.
pip_obj.show_package_info('cowsay')
print()
# Выводим список всех установленных пакетов.
pip_obj.show_packages()
print()
# Удаляем пакет cowsay.
pip_obj.uninstall_package('cowsay')
print()
# Выводим список всех установленных пакетов.
pip_obj.show_packages()
print()
input('Упражение выполнено!')
# Если модуль не импортируется, а запускается как программа.
if __name__ == '__main__':
# Вызываем основную функцию программы.
main()
17.3. Создайте вручную каталог проекта my_prj. Откройте командную оболочку, перейдя в каталог проекта, и выполните в ней следующее упражнение:
- создайте виртуальное окружение в подкаталоге my_venv проекта, использовав текущую версию Python;
- активируйте виртуальное окружение проекта;
- обновите менеджер пакетов pip окружения;
- выведите его версию;
- деактивируйте виртуальное окружение.
Если имеется такая возможность, выполните упражнение как в ОС Windows, так и в ОС Ubuntu. Показать решение.
-- ОС Windows -- D:\python>cd my_prj D:\python\my_prj>python -m venv .\my_venv D:\python\my_prj>.\my_venv\Scripts\activate.bat (my_venv) D:\python\my_prj>pip3 install --upgrade pip Requirement already satisfied: pip in d:\python\my_prj\my_venv\lib\site-packages (22.3.1) (my_venv) D:\python\my_prj>pip3 --version pip 22.3.1 from D:\python\my_prj\my_venv\Lib\site-packages\pip (python 3.11) (my_venv) D:\python\my_prj>deactivate D:\python\my_prj> -- ОС Ubuntu 20.04 -- okpy@SUPER:~$ cd my_prj okpy@SUPER:~/my_prj$ python3 -m venv ./my_venv okpy@SUPER:~/my_prj$ source ./my_venv/bin/activate (my_venv) okpy@SUPER:~/my_prj$ python -m pip install --upgrade pip Requirement already satisfied: pip in ./my_venv/lib/python3.10/site-packages (22.0.2) Collecting pip Downloading pip-22.3.1-py3-none-any.whl (2.1 MB) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.1/2.1 MB 201.1 kB/s eta 0:00:00 Installing collected packages: pip Attempting uninstall: pip Found existing installation: pip 22.0.2 Uninstalling pip-22.0.2: Successfully uninstalled pip-22.0.2 Successfully installed pip-22.3.1 (my_venv) okpy@SUPER:~/my_prj$ pip3 --version pip 22.3.1 from /home/okpy/my_prj/my_venv/lib/python3.10/site-packages/pip (python 3.10) (my_venv) okpy@SUPER:~/my_prj$ deactivate okpy@SUPER:~/my_prj$
17.4. Создайте вручную каталог проекта my_prj (или очистите старый). Откройте командную оболочку, перейдя в каталог проекта, и выполните в ней следующее упражнение:
- создайте виртуальное окружение в подкаталоге venv_2 проекта, использовав текущую версию Python;
- активируйте виртуальное окружение проекта;
- обновите менеджер пакетов pip окружения;
- установите пакет pillow;
- выведите список установленных пакетов;
- сохраните зависимости в файл requirements.txt в корневой каталог проекта;
- деактивируйте виртуальное окружение;
- удалите каталог виртуального окружения;
- заново создайте виртуальное окружение, но уже в подкаталоге venv_3 проекта, использовав текущую версию Python;
- активируйте виртуальное окружение проекта;
- обновите менеджер пакетов pip окружения;
- восстановите все зависимости проекта из файла requirements.txt;
- выведите список установленных пакетов;
- деактивируйте виртуальное окружение.
Если имеется такая возможность, выполните упражнение как в ОС Windows, так и в ОС Ubuntu. Показать решение.
-- ОС Windows -- D:\python\my_prj>python -m venv .\venv_2 D:\python\my_prj>.\venv_2\Scripts\activate.bat (venv_2) D:\python\my_prj>pip3 install --upgrade pip Requirement already satisfied: pip in d:\python\my_prj\venv_2\lib\site-packages (22.3.1) (venv_2) D:\python\my_prj>pip3 install pillow Collecting pillow Using cached Pillow-9.4.0-cp311-cp311-win_amd64.whl (2.5 MB) Installing collected packages: pillow Successfully installed pillow-9.4.0 (venv_2) D:\python\my_prj>pip3 list Package Version ---------- ------- Pillow 9.4.0 pip 22.3.1 setuptools 65.5.0 (venv_2) D:\python\my_prj>pip3 freeze>requirements.txt (venv_2) D:\python\my_prj>deactivate D:\python\my_prj>python -m venv .\venv_3 D:\python\my_prj>.\venv_3\Scripts\activate.bat (venv_3) D:\python\my_prj>pip3 install -r requirements.txt Collecting Pillow==9.4.0 Using cached Pillow-9.4.0-cp311-cp311-win_amd64.whl (2.5 MB) Installing collected packages: Pillow Successfully installed Pillow-9.4.0 (venv_3) D:\python\my_prj>pip3 list Package Version ---------- ------- Pillow 9.4.0 pip 22.3.1 setuptools 65.5.0 (venv_3) D:\python\my_prj>deactivate D:\python\my_prj> -- ОС Ubuntu 20.04 -- okpy@SUPER:~/my_prj$ python3 -m venv ./venv_2 okpy@SUPER:~/my_prj$ source ./venv_2/bin/activate (venv_2) okpy@SUPER:~/my_prj$ python -m pip install --upgrade pip Requirement already satisfied: pip in ./venv_2/lib/python3.10/site-packages (22.0.2) Collecting pip Using cached pip-22.3.1-py3-none-any.whl (2.1 MB) Installing collected packages: pip Attempting uninstall: pip Found existing installation: pip 22.0.2 Uninstalling pip-22.0.2: Successfully uninstalled pip-22.0.2 Successfully installed pip-22.3.1 (venv_2) okpy@SUPER:~/my_prj$ pip3 install pillow Collecting pillow Downloading Pillow-9.4.0-cp310-cp310-manylinux_2_28_x86_64.whl (3.4 MB) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.4/3.4 MB 25.2 kB/s eta 0:00:00 Installing collected packages: pillow Successfully installed pillow-9.4.0 (venv_2) okpy@SUPER:~/my_prj$ pip3 list Package Version ---------- ------- Pillow 9.4.0 pip 22.3.1 setuptools 59.6.0 (venv_2) okpy@SUPER:~/my_prj$ pip3 freeze>requirements.txt (venv_2) okpy@SUPER:~/my_prj$ deactivate okpy@SUPER:~/my_prj$ mc okpy@SUPER:~/my_prj$ python3 -m venv ./venv_3 okpy@SUPER:~/my_prj$ source ./venv_3/bin/activate (venv_3) okpy@SUPER:~/my_prj$ pip3 install -r requirements.txt Collecting Pillow==9.4.0 Using cached Pillow-9.4.0-cp310-cp310-manylinux_2_28_x86_64.whl (3.4 MB) Installing collected packages: Pillow Successfully installed Pillow-9.4.0 (venv_3) okpy@SUPER:~/my_prj$ pip3 list Package Version ---------- ------- Pillow 9.4.0 pip 22.0.2 setuptools 59.6.0 (venv_3) okpy@SUPER:~/my_prj$ deactivate okpy@SUPER:~/my_prj$
17.5. Создайте каталог проекта my_prj (или очистите старый). В нем создайте файл main.py, в котором напишите скрипт вывода информации об используемой версии Python. Откройте командную оболочку, перейдя в каталог проекта, и выполните в ней следующее упражнение:
- запустите файл на исполнение;
- создайте виртуальное окружение в подкаталоге my_venvs/venv_1 проекта, использовав при этом версию интерпретатора Python3.9;
- активируйте виртуальное окружение;
- запустите файл на исполнение;
- деактивируйте виртуальное окружение;
- внесите изменения в код файла так, чтобы при запуске на исполнение мог задействоваться интерпретатор виртуального окружения проекта, а не системный;
- запустите файл на исполнение под интерпретатором виртуального окружения проекта.
- запустите файл на исполнение под системным интерпретатором.
Если имеется такая возможность, выполните упражнение как в ОС Windows, так и в ОС Ubuntu. Показать решение.
-- ОС Windows -- D:\python\my_prj>main.py sys.version_info(major=3, minor=11, micro=1, releaselevel='final', serial=0) D:\python\my_prj>py -3.9 -m venv .\my_venvs\venv_1 D:\python\my_prj>.\my_venvs\venv_1\Scripts\activate.bat (venv_1) D:\python\my_prj>python main.py sys.version_info(major=3, minor=9, micro=10, releaselevel='final', serial=0) (venv_1) D:\python\my_prj>deactivate Здесь вносим изменения в файл: #!.\my_venvs\venv_1\Scripts\python.exe import sys print(sys.version_info) D:\python\my_prj>main.py sys.version_info(major=3, minor=9, micro=10, releaselevel='final', serial=0) D:\python\my_prj>python main.py sys.version_info(major=3, minor=11, micro=1, releaselevel='final', serial=0) D:\python\my_prj> -- ОС Ubuntu 20.04 -- okpy@SUPER:~/my_prj$ python3 main.py sys.version_info(major=3, minor=10, micro=6, releaselevel='final', serial=0) okpy@SUPER:~/my_prj$ python3.9 -m venv ./my_venvs/venv_1 okpy@SUPER:~/my_prj$ source ./my_venvs/venv_1/bin/activate (venv_1) okpy@SUPER:~/my_prj$ python main.py sys.version_info(major=3, minor=9, micro=16, releaselevel='final', serial=0) (venv_1) okpy@SUPER:~/my_prj$ deactivate okpy@SUPER:~/my_prj$ chmod 777 ./main.py Здесь вносим изменения в файл: #!./my_venvs/venv_1/bin/python import sys print(sys.version_info) okpy@SUPER:~/my_prj$ ./main.py sys.version_info(major=3, minor=9, micro=16, releaselevel='final', serial=0) okpy@SUPER:~/my_prj$ python3 main.py sys.version_info(major=3, minor=10, micro=6, releaselevel='final', serial=0) okpy@SUPER:~/my_prj$
Задачи на дату и время
Теоретический материал по работе с датой и временем можно почитать в нашем учебнике здесь.
18.1. Выведите на экран текущие дату и время, использовав для этого возможности модуля datetime стандартной библиотеки. Показать решение.
# Импортируем класс datetime одноименного модуля.
from datetime import datetime as dt
# Используем методы класса datetime.
# 2023-02-13 15:23:25.372217.
print(dt.today())
# 2023-02-13 15:23:25.372217.
print(dt.now())
2023-03-08 00:46:02.434220
2023-03-08 00:46:02.434220
18.2. Выведите на экран в ISO 8601 формате текущие дату и время с точностью до секунд. Для вывода даты используйте формат «Дата: {iso_date}», а для времени – «Время: {iso_time}». Показать решение.
# Импортируем класс datetime одноименного модуля.
from datetime import datetime
# Получаем объект текущей даты и времени.
today = datetime.today()
# Выделяем дату и время по отдельности.
d = today.date()
t = today.time()
# Переводим все в iso формат.
iso_date = d.isoformat()
iso_time = t.isoformat(timespec='seconds')
# Выводим результаты.
print('Дата:', iso_date)
print('Время:', iso_time)
Дата: 2023-03-09
Время: 10:17:48
18.3. Выведите на экран текущую дату и время в форматах «DD.MM.YY HH:MM:SS», «DD/MM/YY HH:MM:SS», «DD-MM-YY» и «HH:MM:SS». Показать решение.
# Импортируем класс datetime одноименного модуля.
from datetime import datetime
# Получаем объект текущей даты и времени.
today = datetime.today()
# Синтаксис метода смотрите в справочнике.
d_1 = today.strftime('%d.%m.%Y %H:%M:%S')
d_2 = today.strftime('%d/%m/%Y %H:%M:%S')
d_3 = today.strftime('%d-%m-%Y')
d_4 = today.strftime('%H:%M:%S')
# Выводим результаты.
print(today)
print(d_1)
print(d_2)
print(d_3)
print(d_4)
2023-03-10 20:17:26.011847
10.03.2023 20:17:26
10/03/2023 20:17:26
10-03-2023
20:17:26
18.4. Выведите на экран текущие компоненты даты и времи по отдельности: год в формате «YYYY», месяц в формате «MM», название месяца на русском языке, число, название дня недели на русском языке, часы, минуты и секунды. Показать решение.
# Импортируем класс datetime одноименного модуля.
from datetime import datetime
# Составляем списки названий месяцев и дней недели.
m_li = ['', 'Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь',
'Июль', 'Август', 'Сентябрь', 'Октябрь', 'Ноябрь', 'Декабрь']
d_li = ['Воскресенье', 'Понедельник', 'Вторник', 'Среда',
'Четверг', 'Пятница', 'Суббота']
# Получаем объект текущей даты и времени.
today = datetime.today()
# Выделяем требуемые компоненты даты и времени по отдельности.
dt_li = today.strftime('%Y %m %d %w %H %M %S').split()
# Выводим результаты.
print(dt_li)
print('Год:', dt_li[0])
print('Месяц:', dt_li[1])
print('Название месяца:', m_li[int(dt_li[1])])
print('Число:', dt_li[2])
print('Название дня недели:', d_li[int(dt_li[3])])
print('Часы:', dt_li[4])
print('Минуты:', dt_li[5])
print('Секунды:', dt_li[6])
['2023', '03', '10', '5', '20', '55', '11']
Год: 2023
Месяц: 03
Название месяца: Март
Число: 10
Название дня недели: Пятница
Часы: 20
Минуты: 55
Секунды: 11
18.5. Допустим, что сегодня 13 марта 2023 года. Сколько дней осталось до нового года? А сколько до следующего Международного женского дня? Показать решение.
# Импортируем класс datetime одноименного модуля.
from datetime import date, timedelta
# Получаем объект текущей даты.
today = date(2023, 3, 13)
# Получаем объект даты для нового года.
new_year = date(2024, 1, 1)
# Получаем объект даты для 8 марта.
w_day = date(2024, 3, 8)
# Получаем кол-во оставшихся дней (включая текущий).
t_new_year = (new_year - today).days
t_w_day = (w_day - today).days
# Выводим результаты.
print('Дней до НГ:', t_new_year)
print('Дней до 8 марта:', t_w_day)
Дней до НГ: 294
Дней до 8 марта: 361
18.6. Допустим, что сегодня 14 марта 2023 года, Катя работает по графику пятидневной рабочей недели и находится в заслуженном отпуске, который заканчивается через 17 календарных дней (не включая текущей даты). Придется ли ей выходить на работу сразу или же отпуск продлится за счет выходных дней? Показать решение.
# Импортируем классы модуля datetime.
from datetime import date, timedelta
# Получаем объект текущей даты.
today = date(2023, 3, 14)
# Получаем объект даты последнего дня отпуска.
last_day = today + timedelta(17)
# Получаем номер дня недели, где пн - это 0.
n = last_day.weekday()
# Если отпуск заканчивается в пятницу.
if n == 4:
print('Отпуск продляется на 2 дня!')
# Если отпуск заканчивается в субботу.
elif n == 5:
print('Отпуск продляется на 1 день!')
# Иначе.
else:
print('Эх, завтра придется выходить на работу!')
Отпуск продляется на 2 дня!
18.7. Напишите функцию, которая будет проверять входную строку с датой и временем на соответствие формату ISO 8601, возвращая при этом соответствующее булево значение True или False. Используйте функцию для проверки строк '2011-11-04T00:05:23' и '2011-11-04T00:05:23.' Показать решение.
# Импортируем класс datetime модуля datetime.
from datetime import datetime
# Определяем функцию проверки на соотв. формату iso.
def is_iso_format(s):
# Пытаемся преобразовать строку в объект даты и времени.
try:
datetime.fromisoformat(s)
# Если все хорошо, возвращаем True.
return True
# Если возникло исключение.
except ValueError:
# Возвращаем False.
return False
# Проверяем заданные строки.
print(is_iso_format('2011-11-04T00:05:23'))
print(is_iso_format('2011-11-04T00:05:23.'))
True
False
18.8. Установите сторонний модуль isodate. Используя его возможности, напишите функцию, которая будет проверять входную строку с промежутком времени в формате 'PyYmMdDThHmMsS', где y, m, d, h, m, s – это количество лет, месяцев и т.д., на соответствие формату ISO 8601, возвращая при этом соответствующее булево значение True или False. Используйте функцию для проверки строк 'P3Y7M4DT12H30M19S' и '2021-05-14T09:05:23'. Показать решение.
# https://pypi.org/project/isodate/
# Импортируем модуль isodate.
import isodate
# Проверка на соответствие строки продолжительности времени формату iso.
def is_iso_duration(s):
# Пытаемся преобразовать строку в объект timedelta.
try:
isodate.parse_duration(s)
# Если все хорошо, возвращаем True.
return True
# Если возникло исключение.
except isodate.ISO8601Error:
# Возвращаем False.
return False
# Проверяем заданные строки.
print(is_iso_duration('P3Y7M4DT12H30M19S'))
print(is_iso_duration('2021-05-14T09:05:23'))
True
False
Олимпиадные задачи
В разделе представлены адаптированные задачи начального и среднего уровня сложности по олимпиадному программированию. Здесь вам предстоит уже самостоятельно определяться с выбором способа решения той или иной задачи в пределах объема знаний и навыков, полученных вами в ходе решения задач во всех предыдущих разделах задачника. Кроме того, могут понадобиться знания из других областей, например, математики, а также наблюдательность и смекалка.
Далеко не факт, что мои решения будут оптимальными и совпадать с вашими. Какое решение мне пришло в голову первым, то я и указал. Так что не судите строго и присылайте ваши решения, если они более рациональные и отличаются от предложенных.
19.1. Дана строка целых чисел '36 787 0 9993754\n2253', отделённых друг от друга неравномерным количеством пробелов и переводов строк. Необходимо для каждого числа, начиная с последнего и заканчивая первым, вывести на экран в отдельной строке его квадратный корень с точностью до пяти знаков после десятичной точки. Показать решение.
# Сохраняем строку в переменной.
s = '36 787 0 9993754\n2253'
# Разбиваем ее в список по пробельным символам.
li = s.split()
# Переворачиваем список.
li.reverse()
# Циклом выводим корни с заданной точностью.
for n in li: print(round(int(n)**0.5, 5))
47.46578
3161.28993
0.0
28.05352
6.0
19.2. С клавиатуры вводится целое положительное число n < 10000. Напишите скрипт, который будет находить и выводить на экран минимальное положительное целое число q такое, что произведение цифр этого числа будет в точности равняться числу n. В случае отсутствия такого числа q скрипт должен выводить на экран сообщение «Искомого числа q не существует!». Например, для числа 70 искомым числом будет 257. Показать решение.
Ответ. Для решения задачи нужно догадаться, что цифрами искомого числа q будут все делители (и простые и составные) числа n меньшие десяти (включая единицу, на которую делятся все числа). А поскольку нам требуется найти минимальное из таких чисел, то найденные делители числа n должны идти в числе q в порядке возрастания. Для чисел от единицы до девяти искомыми числами будут 11, 12 и т.д.
# Требуем ввода допустимого значения.
while True:
# Просим пользователя ввести число для проверки.
n = input('Введите целое 0 < n < 10000: ')
# Число должно быть целым и большим нуля.
if n.isdigit():
n = int(n)
# Прерываем цикл и начинаем поиск числа.
if n > 0: break
# Делители числа n будем добавлять в список.
d_li = []
# Находим для числа n все делители d < 10.
for d in range(9, 1, -1):
# Пока текущее значение n делится на d.
while True:
# Делим n на d, получая частное и остаток.
dm = divmod(n, d)
# Если n делится без остатка на d.
if dm[1] == 0:
# Добавляем d в начало списка делителей
# числа n, чтобы меньшие из них шли первыми.
d_li.insert(0, str(d))
# n присваиваем частное от деления, т.е. dm[0].
n = dm[0]
# Прерываем внутр. цикл, т.к. n больше на d не делится.
else: break
# Если после нахождения всех делителей d < 10, число n
# еще полностью не разделилось (остался остаток).
if n != 1:
print('Искомого числа q не существует!')
# Если делители есть и n > 9.
elif len(d_li) > 1:
q = ''.join(d_li)
print('Искомое число q:', q)
else:
# Для чисел от 1 до 9.
print('Искомое число q:', '1' + d_li[0])
input()
Введите целое 0 < n < 10000: 70
Искомое число q: 257
19.3. Представьте, что у вас имеется некоторое количество камней n (1 ≤ n ≤ 100) известного веса w1, w2, w3, ..., где wi – это целые положительные числа от 1 до 1000000 включительно. Напишите скрипт, который распределит камни в две кучи так, чтобы разность весов этих двух куч была минимальной. Количество камней и веса должны генерироваться случайным образом. Сам скрипт должен возвращать число, равное минимальной разности весов двух куч. Например, для трех камней с весами 15, 20 и 3 скрипт должен возвращать число 2. На выполнение скрипта дается не более одной секунды. Показать решение.
Ответ. Для решения задачи нужно упорядочить список весов по возрастанию. Зная, что разница между двумя соседними элементами полученного списка минимальна, следует распределять камни попарно: самый тяжелый камень ложим в первую кучу, чуть легче – во вторую, затем распределяем следующую пару камней, но уже положив более тяжелый камень во вторую кучу, а более легкий – в первую. Таким образом мы будем постоянно поддерживать минимальную разницу в весах куч, т.к. уже имеющаяся разница будет постоянно изменяться на минимальную величину. Если число камней нечетное, то последний камень следует добавить в более легкую кучу.
# Импортируем time.
import time
# Начало выполнения программы.
start = time.time()
# Ииспользуем возможности модуля random.
from random import choice, choices
# Генерируем случайное количество камней.
n = choice(range(1, 101))
# Генерируем случайные веса камней.
w_li = choices(range(1, 1000000), k=n)
# Сортируем список по возрастанию весов.
w_li.sort()
# Начальные веса наших куч.
w_1 = 0; w_2 = 0
# Если камней четное количество.
if n%2 == 0:
# Остаточный вес примем за нуль.
w_min = 0
else:
# Удалим из списка минимальный вес,
# чтобы осталось четное число элементов,
# и сохраним его в переменной.
w_min = w_li.pop(0)
# Текущий флаг.
f = 0
# Пока список не станет пустым.
while w_li:
# Распределяем по два соседних камня
# по кучам, добавляя в одну и ту же
# кучу сперва камень с максимальным весом,
# а затем с минимальным из двух.
if f == 0:
w_1 += w_li.pop()
w_2 += w_li.pop()
f = 1
else:
w_2 += w_li.pop()
w_1 += w_li.pop()
f = 0
# Последний камень добавляем в кучу с минимальным весом.
if w_2 > w_1:
w_1 += w_min
else:
w_2 += w_min
# Выводим минимальную разность весов.
print(abs(w_2 - w_1))
# Время выполнения программы.
print('Выполнено за', time.time() - start, 'сек.')
119375
Выполнено за 0.006094932556152344 сек.
19.4. В кругу стоят n человек. Все они пронумерованны числами от 1 до n. Начинается расчет, при котором каждый k-й по счету человек выбывает из круга, после чего счет продолжается со следующего за ним человека. Напишите программу, которая будет определять номер человека, остающегося в кругу последним. Данная задача представляет собой один из вариантов классической задачи Иосифа Флавия, вошедшей в 1612 году в одну из ранних работ по занимательной математике французкого математика Баше де Мезириака. Показать решение.
Ответ. Первый вариант далеко не самый эффективный, но зато наглядный. Именно он пришел мне в голову после часа размышлений на бумаге. Второй и третий варианты были найдены на просторах интернета. Здесь уже используются рекуррентные соотношения, выведенные математиками.
''' 1-й вариант '''
# Просим ввести параметры для рассчета.
n = int(input('Введите кол-во человек n: '))
k = int(input('Введите шаг выбывания k: '))
# Создаем список со всеми n участниками. Например,
# при n = 5, получим [1, 2, 3, 4, 5].
people = list(range(1, n+1))
# Счетчики: кол-во оставшихся человек (т.е. len(people)),
# текущий отсчитываемый участник (т.е. индекс проверяемого
# элемента списка), счетчик отсчета шага k.
num_people, current_position, step = n, 0, 0
# Цикл прерываем, когда останется последний участник.
while num_people > 1:
# Увеличиваем счетчик отсчета шага.
step += 1
# Если индекс вышел за пределы списка,
if current_position >= num_people:
# Переходим в начало списка.
current_position = 0
# Для наглядности можете раскомментировать.
# print('step = ', step)
# print('current_position = ', current_position)
# print('people = ', people, end='\n\n')
# Проверяем не достиг ли отсчет заданного шага k.
if step == k:
# Если да, то удаляем участника из списка.
del people[current_position]
# Уменьшаем счетчик оставшихся участников и
num_people -= 1
# обнуляем счетчик отсчета шага.
step = 0
# Иначе
else:
# переходим к следующему элементу списка.
current_position += 1
# Выводим номер последнего оставшегося участника.
print('Номер последнего участника ', people[0], end='\n\n')
''' 2-й вариант '''
# Просим ввести параметры для рассчета.
n = int(input('Введите кол-во человек n: '))
k = int(input('Введите шаг выбывания k: '))
last = 0
# Используем цикл.
for i in range(1, n + 1):
last = (last + k)%i
print(last + 1, end='\n\n')
''' 3-й вариант '''
# Просим ввести параметры для рассчета.
n = int(input('Введите кол-во человек n: '))
k = int(input('Введите шаг выбывания k: '))
# Используем рекурсивную функцию.
def last_survivor(n, k):
if n == 1:
return 1
elif n > 1:
return (1 + (last_survivor(n - 1, k) + k - 1)%n)
print(last_survivor(n, k))
Введите кол-во человек n: 7
Введите шаг выбывания k: 3
Номер последнего участника 4
Введите кол-во человек n: 7
Введите шаг выбывания k: 3
4
Введите кол-во человек n: 7
Введите шаг выбывания k: 3
4
Первые скрипты и программы
В разделе представлены простейшие скрипты и программы, которые помогут вам закрепить первоначальные практические навыки, полученные в ходе решения задач во всех предыдущих разделах задачника. Если ранее вы уже писали программы на другом языке программирования, можете пробовать осилить все предлагаемые варианты самостоятельно. Что касается начинающих программистов, то им вначале следует внимательно разобраться в готовом решении и только затем приступать к обязательному самостоятельному набору кода. Важно понимать, что простое чтение исходного кода никакой практической пользы не принесет. Поэтому код набирать нужно в любом случае!
1. Шаблон №1. Напишите скрипт hello_world.py, который будет выводить на экран обычное приветствие «Привет, мир!». Оформите содержимое скрипта следующим образом:
- В начале скрипта напишите три комментария, описывающие порядок импортирования модулей и пакетов и начинающиеся словами «Импортируем модули ...».
- За ними определите простейшую функцию simple_func и простейший класс SimpleClass, использовав инструкцию pass.
- Далее определите основную функцию скрипта main, в теле которой вызовите функцию simple_func, создайте экзмепляр класса SimpleClass, осуществите вывод целевого сообщения и завершите все пустой инструкцией input, чтобы окно скрипта автоматически не закрывалось после вывода сообщения.
- В конец скрипта поместите условную инструкцию, которая будет осуществлять вызов основной функции, но только в том случае, если модуль будет запускаться как основная программа, а не импортироваться другим модулем.
# Импортируем модули стандартной библиотеки.
# Импортируем модули сторонних библиотек.
# Импортируем собственные модули.
# Функция «Пустышка».
def simple_func(): pass
# Класс «Пустышка».
class SimpleClass: pass
# Центральная функция программы.
def main():
# Вызываем функцию.
simple_func()
# Создаем экземпляр класса.
obj = SimpleClass()
# Выводим приветствие.
print('Привет, Мир!')
# Запрос ввода, чтобы программа не закрылась.
input()
# Если модуль не импортируется, а
# запускается как основная программа.
if __name__ == '__main__':
# Вызываем основную функцию программы.
main()
Привет, Мир!
2. Шаблон №2. Дополните код предыдущей задачи таким образом, чтобы после показа целевого сообщения пользователю выводился запрос на продолжение работы программы (символ 'y') либо выход из нее (символ 'n'). Для решения задачи используйте цикл с флагом «while flag:», прерывающийся по значению флага, либо бесконечный цикл «while True:», регулируемый условной инструкцией if в теле цикла. Показать решение.
# Импортируем модули стандартной библиотеки.
# Импортируем модули сторонних библиотек.
# Импортируем собственные модули.
# Функция «Пустышка».
def simple_func(): pass
# Класс «Пустышка».
class SimpleClass: pass
# Центральная функция программы.
def main():
# Используем флаг для контроля выхода из программы.
flag = 'y'
# Выполняем цикл, пока значение флага не изменится.
# Либо бесконечный цикл с прерыванием через if.
while flag != 'n':
# Вызываем функцию.
simple_func()
# Создаем экземпляр класса.
obj = SimpleClass()
# Выводим приветствие.
print('Привет, Мир!')
# Выводим запрос на изменение флага.
flag = input('Продолжить (y/n)? ')
# Или используем условие для цикла while True.
# if input('Продолжить (y/n)? ') == 'n': break
# Если модуль не импортируется, а запускается как программа.
if __name__ == '__main__':
# Вызываем основную функцию программы.
main()
Привет, Мир!
Продолжить (y/n): n
3. Менеджер пакетов Python. Напишите программу-оболочку для менеджера пакетов pip, которая будет выполнять команды из предлагаемого пользователю меню (см. пример запуска программы). В программе создайте класс PipInstaller с методами менеджера пакетов pip (см. пункт «Установка сторонних библиотек» нашего учебника). Дайте методам следующие имена: show_pip_version, show_pip_help, upgrade_pip, install_package, reinstall_package, upgrade_package, show_package_info, show_packages_list, uninstall_package, create_requirements и use_requirements. Последние два метода должны запрашивать путь к каталогу создания/расположения файла requirements.txt. Показать решение.
Менеджер пакетов Python, версия 1.0.
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
Сделайте выбор: 4
Введите имя пакета: pillow
Collecting pillow
Using cached Pillow-9.3.0-cp311-cp311-win_amd64.whl (2.5 MB)
Installing collected packages: pillow
Successfully installed pillow-9.3.0
[notice] A new release of pip available: 22.3 -> 22.3.1
[notice] To update, run: python.exe -m pip install --upgrade pip
Для продолжения нажмите 'Ввод'...
--------------
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
Сделайте выбор: 10
Укажите путь к целевому каталогу с последним слешем: ./test/
Файл успешно создан в каталоге ./test/ !
Для продолжения нажмите 'Ввод'...
# Импортируем требуемые модули станд. библиотеки.
import os, sys
from pathlib import Path
# Класс с командами pip.
class PipInstaller:
# Инициализируем путь к файлу менеджера pip
def __init__(self):
# Для Windows.
if os.name == 'nt':
# Префикс для команд консоли с пробелом в конце.
# Во избежание проблем с доступом используем «python -m».
self.cmd_prefix = 'python -m pip '
# Для Unix-подобных.
elif os.name == 'posix':
# Префикс для команд консоли с пробелом в конце.
# Во избежание проблем с доступом используем «python3 -m».
# Версии python 2.* не рассматриваем.
self.cmd_prefix = 'python3 -m pip '
else:
# Выводим предупреждение.
print('Ваша ОС не поддерживается!')
# Выходим из программы.
exit()
# Выводит версию pip (os.system(command) исполняет системную команду).
def show_pip_version(self):
os.system(self.cmd_prefix + '--version')
# Выводит в консоль справку по pip
def show_pip_help(self):
os.system(self.cmd_prefix + 'help')
# При необходимости обновляет менеджер.
def upgrade_pip(self):
os.system(self.cmd_prefix + 'install --upgrade pip')
# Пытается установить пакет или сообщает о том, что пакет уже установлен.
def install_package(self, package_name):
os.system(self.cmd_prefix + 'install ' + package_name)
# Устанавливает пакет, а если он уже установлен,
# то принудительно переустанавливает его.
def reinstall_package(self, package_name):
os.system(self.cmd_prefix + 'install --force-reinstall ' + package_name)
# Обновить пакет, если в этом есть необходимость.
def upgrade_package(self, package_name):
os.system(self.cmd_prefix + 'install --upgrade ' + package_name)
# Показывает информацию об установленном пакете.
def show_package_info(self, package_name):
os.system(self.cmd_prefix + 'show ' + package_name)
# Выводит в консоль список уже установленных пакетов
# (см. в домашнем каталоге Питона в lib\site-packages).
def show_packages_list(self):
os.system(self.cmd_prefix + 'list')
# Создает requirements.txt по указанному пути.
def create_requirements(self):
p = input('Укажите путь к целевому каталогу: ')
os.system(self.cmd_prefix + 'freeze > ' + p + '/requirements.txt')
print('Файл успешно создан в каталоге', p, '!')
# Устанавливает пакеты из requirements.txt.
def install_form_requirements(self):
p = input('Укажите путь к каталогу файла: ')
os.system(self.cmd_prefix + 'install -r ' + p + '/requirements.txt')
print('Пакеты успешно установлены!')
# Пытается удалить пакет.
def uninstall_package(self, package_name):
os.system(self.cmd_prefix + 'uninstall ' + package_name)
# Главная функция программы.
def main():
# Создаем экземпляр класса PipInstaller.
pip_obj = PipInstaller()
# Выводим список опций программы.
mes = '''
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
'''
# Выводим название программы и версию.
print('\nМенеджер пакетов Python, версия 1.0.')
# Цикл программы.
while True:
# Выводим на экран возможности программы.
print(mes)
# Получаем выбор пользователя.
enter = input('Сделайте выбор: ')
# Продолжаем в зависимости от выбора пользователя.
if enter == '1':
print()
pip_obj.show_pip_version()
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '2':
print()
pip_obj.show_pip_help()
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '3':
print()
pip_obj.upgrade_pip()
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '4':
print()
package_name = input('Введите имя пакета: ')
print()
pip_obj.install_package(package_name)
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '5':
print()
package_name = input('Введите имя пакета: ')
print()
pip_obj.reinstall_package(package_name)
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '6':
print()
package_name = input('Введите имя пакета: ')
print()
pip_obj.upgrade_package(package_name)
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '7':
print()
package_name = input('Введите имя пакета: ')
print()
pip_obj.uninstall_package(package_name)
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '8':
print()
package_name = input('Введите имя пакета: ')
print()
pip_obj.show_package_info(package_name)
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '9':
print()
pip_obj.show_packages_list()
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '10':
print()
pip_obj.create_requirements()
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '11':
print()
pip_obj.install_form_requirements()
print()
input('Для продолжения нажмите \'Ввод\'...')
print('\n--------------')
elif enter == '-1':
break
# Если модуль не импортируется, а запускается как программа.
if __name__ == '__main__':
# Вызываем основную функцию программы.
main()
Менеджер пакетов Python, версия 1.0.
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
Сделайте выбор: 4
Введите имя пакета: pillow
Collecting pillow
Using cached Pillow-9.3.0-cp311-cp311-win_amd64.whl (2.5 MB)
Installing collected packages: pillow
Successfully installed pillow-9.3.0
[notice] A new release of pip available: 22.3 -> 22.3.1
[notice] To update, run: python.exe -m pip install --upgrade pip
Для продолжения нажмите 'Ввод'...
--------------
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
Сделайте выбор: 10
Укажите путь к целевому каталогу с последним слешем: ./test/
Файл успешно создан в каталоге ./test/ !
Для продолжения нажмите 'Ввод'...
--------------
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
Сделайте выбор: 7
Введите имя пакета: pillow
Found existing installation: Pillow 9.3.0
Uninstalling Pillow-9.3.0:
Would remove:
c:\users\pi-13\appdata\local\programs\python\python311\lib\site-packages\pil\*
c:\users\pi-13\appdata\local\programs\python\python311\lib\site-packages\pillow-9.3.0.dist-info\*
Proceed (Y/n)? y
Successfully uninstalled Pillow-9.3.0
Для продолжения нажмите 'Ввод'...
--------------
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
Сделайте выбор: 11
Укажите путь к каталогу файла с последним слешем: ./test/
Collecting Pillow==9.3.0
Using cached Pillow-9.3.0-cp311-cp311-win_amd64.whl (2.5 MB)
Installing collected packages: Pillow
Successfully installed Pillow-9.3.0
[notice] A new release of pip available: 22.3 -> 22.3.1
[notice] To update, run: python.exe -m pip install --upgrade pip
Пакеты успешно установлены!
Для продолжения нажмите 'Ввод'...
--------------
Список доступных комманд:
показать версию pip: 1,
показать краткую справку по pip: 2,
обновить менеджер pip: 3,
установить пакет: 4,
установить пакет принудительно: 5,
обновить пакет: 6,
удалить пакет: 7,
показать информацию о пакете: 8,
показать список установленных пакетов: 9,
создать requirements.txt: 10,
установить пакеты из requirements.txt: 11,
выйти из программы: -1.
Сделайте выбор: -1
4. Таблица умножения. Напишите программу «тренажер_таблицы_умножения.py» для заучивания таблицы умножения. Программа должна:
- выводить свое название и версию;
- выводить меню, в котором пользователю будет предлагаться вывод таблицы умножения для повторения, запуск тренажера или выход из программы (см. пример запуска программы);
- после каждой попытки ответа пользователя программа должна выводить сообщение о правильности ответа и запрашивать подтверждение на продолжение работы программы либо выход из нее, а в случае неправильного ответа помимо сообщения об ошибке программа должна выводить еще и правильный ответ.
Вывод таблицы умножения и запуск тренажера оформите в виде функций, которые затем будут использоваться в теле основной функции программы. Показать решение.
Тренажер таблицы умножения, версия 1.0. Вывести таблицу умножения: t Запустить тренажер: r Выйти из программы: q >t Таблица умножения. ----+------------------------------------- | х | 1 2 3 4 5 6 7 8 9 | ----+------------------------------------- | 1 | 1 2 3 4 5 6 7 8 9 | | 2 | 2 4 6 8 10 12 14 16 18 | | 3 | 3 6 9 12 15 18 21 24 27 | | 4 | 4 8 12 16 20 24 28 32 36 | | 5 | 5 10 15 20 25 30 35 40 45 | | 6 | 6 12 18 24 30 36 42 48 54 | | 7 | 7 14 21 28 35 42 49 56 63 | | 8 | 8 16 24 32 40 48 56 64 72 | | 9 | 9 18 27 36 45 54 63 72 81 | ----+------------------------------------- Вывести таблицу умножения: t Запустить тренажер: r Выйти из программы: q >r 4*8 = 32 Верно! Продолжить/Меню (any_key/m): 7*4 = 30 Вы ошиблись! 7*4 = 28 Продолжить/Меню (any_key/m): m Вывести таблицу умножения: t Запустить тренажер: r Выйти из программы: q >
# Импортируем метод randint из модуля random.
from random import randint
# Функция вывода на экран таблицы умножения.
def print_table():
# Выводим шапку таблицы.
print('\n Таблица умножения.')
print(' ----+-------------------------------------')
print(' | х | 1 2 3 4 5 6 7 8 9 |')
print(' ----+-------------------------------------')
# Выводим произведения построчно.
for x in range(1, 10):
# Выводим левую метку текущей строки таблицы.
print(' |' + str(x).rjust(2) + ' |', end='')
# Организуем внутренний цикл.
for y in range(1, 10):
# Выводим произведение и пробел.
print(str(x*y).rjust(3), end=' ')
# Выводим символ для правой рамки и разрыв.
print('|')
# Выводим нижнюю рамку таблицы.
print(' ----+-------------------------------------')
# Функция запуска тренажера.
def run_traning():
# Организуем бесконечный цикл с прерыванием через if.
while True:
# Получаем случайные числа от 2 до 9.
a = randint(2, 9)
b = randint(2, 9)
# Вычисляем результат.
res = a*b
# Выводим пример на экран.
inp = '\n {}*{} = '.format(a, b)
ans = int(input(inp))
# Проверяем ответ.
if ans == res:
# Поздравляем пользователя.
print(' Верно!')
else:
# Сообщение об ошибке.
print(' Вы ошиблись!')
# Выводим сообщение на экран.
print(' {}*{} = {}'.format(a, b, res))
# Условие для выхода из цикла в меню программы.
if input(' Продолжить/Меню (any_key/m): ') == 'm': break
# Центральная функция программы.
def main():
# Выводим название программы и версию.
print('\n Тренажер таблицы умножения, версия 1.0.')
# Организуем бесконечный цикл с прерыванием через if.
while True:
# Выводим меню программы.
print('\n Вывести таблицу умножения: t')
print(' Запустить тренажер: r')
print(' Выйти из программы: q')
# Ждем выбора. Потом все переводим в нижний
# регистр и удаляем начальные и конечные пробелы
# для более стабильной работы программы.
user_move = input(' >').lower().strip()
# Условие для выхода из цикла while True и программы.
if user_move == 'q':
break
elif user_move == 't':
# Выводим таблицу умножения для заучивания.
print_table()
# Выводим меню программы.
continue
elif user_move == 'r':
# Запускаем тренажер.
run_traning()
else:
# Просим сделать допустимый выбор..
print(' Сделайте допустимый выбор!\n')
# Если модуль не импортируется, а запускается как программа.
if __name__ == '__main__':
# Вызываем основную функцию программы.
main()
Тренажер таблицы умножения, версия 1.0. Вывести таблицу умножения: t Запустить тренажер: r Выйти из программы: q >t Таблица умножения. ----+------------------------------------- | х | 1 2 3 4 5 6 7 8 9 | ----+------------------------------------- | 1 | 1 2 3 4 5 6 7 8 9 | | 2 | 2 4 6 8 10 12 14 16 18 | | 3 | 3 6 9 12 15 18 21 24 27 | | 4 | 4 8 12 16 20 24 28 32 36 | | 5 | 5 10 15 20 25 30 35 40 45 | | 6 | 6 12 18 24 30 36 42 48 54 | | 7 | 7 14 21 28 35 42 49 56 63 | | 8 | 8 16 24 32 40 48 56 64 72 | | 9 | 9 18 27 36 45 54 63 72 81 | ----+------------------------------------- Вывести таблицу умножения: t Запустить тренажер: r Выйти из программы: q >r 4*8 = 32 Верно! Продолжить/Меню (any_key/m): 7*4 = 30 Вы ошиблись! 7*4 = 28 Продолжить/Меню (any_key/m): m Вывести таблицу умножения: t Запустить тренажер: r Выйти из программы: q >
5. Игра «Камень, ножницы, бумага». Напишите программу для игры в «Камень, ножницы, бумага» с компьютером. Оформление и общий алгоритм хода игры представлены в примере запуска программы ниже. Для решения задачи вам понадобятся модули random, sys (выход из программы через sys.exit()), time (использование задержек через time.sleep(0.5)). Что касается функций, то их можете не использовать вообще, оформив все через циклы с прерыванием. Показать решение.
Игра «Камень, ножницы, бумага», версия 1.0.
----------------------------------------------
Каждый из игроков может выбрать «Камень»,
«Ножницы» или «Бумагу». Победитель определяется
по следующим правилам: «Камень» бьет «Ножницы»,
«Ножницы» — «Бумагу», а «Бумага» бьет «Камень».
----------------------------------------------
Победы: 0, проигрыши 0, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> к
«Камень» против ...
1...
2...
3...
«Бумага»
Вы проиграли!
----------------------------------------------
Победы: 0, проигрыши 1, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> н
«Ножницы» против ...
1...
2...
3...
«Бумага»
Вы выиграли!
----------------------------------------------
Победы: 1, проигрыши 1, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> б
«Бумага» против ...
1...
2...
3...
«Камень»
Вы выиграли!
----------------------------------------------
Победы: 2, проигрыши 1, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> в
Спасибо за игру!
# Импортируем требуемые модули.
import random, sys, time# Выводим название программы и версию.
print('\n Игра «Камень, ножницы, бумага», версия 1.0.')
print('\n ----------------------------------------------\n')
print(""" Каждый из игроков может выбрать «Камень»,
«Ножницы» или «Бумагу». Победитель определяется
по следующим правилам: «Камень» бьет «Ножницы»,
«Ножницы» — «Бумагу», а «Бумага» бьет «Камень».""")
# Счетчики выигрышей, проигрышей и ничьих.
wins = 0
losses = 0
ties = 0
# Основной цикл игры.
while True:
# Выходим, если игрок введет 'r', 'к', 'y', 'н', ',', 'б'.
while True:
# Разделитель игр.
print('\n ----------------------------------------------')
# Выводим статистику игры.
print('\n Победы: {}, проигрыши {}, ничьи {}.\n'.format(wins, losses, ties))
# Просим сделать выбор.
print(' Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?')
# Сохраняем выбор игрока в переменной, переведя
# символ в нижний регистр для однозначности.
player_move = input(' > ').lower()
print()
# Если игрок решил выйти из игры (страхуемся от раскладки клавиатуры).
if player_move == 'в':
# Благодарим за игру.
print(' Спасибо за игру!\n')
# Немножко ждем.
time.sleep(1.5)
# И выходим.
sys.exit()
# Если игрок решил играть (страхуемся от раскладки клавиатуры).
if player_move in ('к', 'н', 'б'):
# Выходим из внутреннего цикла.
break
else:
# Просим сделать допустимый выбор.
print(" Используйте 'к', 'н', 'б' или 'в'.")
# Отображаем на экране выбранный игроком ход:
if player_move == 'к':
print(' «Камень» против ...')
player_move = '«Камень»'
elif player_move == 'н':
print(' «Ножницы» против ...')
player_move = '«Ножницы»'
elif player_move == 'б':
print(' «Бумага» против ...')
player_move = '«Бумага»'
# Считаем до трех.
time.sleep(0.4)
print(' 1...')
time.sleep(0.4)
print(' 2...')
time.sleep(0.4)
print(' 3...')
time.sleep(0.5)
# Имитируем выбор компьютера.
random_number = random.randint(1, 3)
if random_number == 1:
computer_move = '«Камень»'
elif random_number == 2:
computer_move = '«Ножницы»'
elif random_number == 3:
computer_move = '«Бумага»'
# Отображаем результат выбора на экране.
print('', computer_move)
# Делаем небольшую паузу, после чего
# отображаем и фиксируем результат игры.
time.sleep(0.5)
print()
# Если выбор игрока и компьютера совпал.
if player_move == computer_move:
# Выводим сообщение.
print(' Ничья!')
# И увеличиваем счетчик ничьих на единицу.
ties += 1
elif player_move == '«Камень»' and computer_move == '«Ножницы»':
print(' Вы выиграли!')
# Увеличиваем счетчик побед игрока на единицу.
wins += 1
elif player_move == '«Бумага»' and computer_move == '«Камень»':
print(' Вы выиграли!')
wins += 1
elif player_move == '«Ножницы»' and computer_move == '«Бумага»':
print(' Вы выиграли!')
wins += 1
elif player_move == '«Камень»' and computer_move == '«Бумага»':
print(' Вы проиграли!')
# Увеличиваем счетчик поражений игрока на единицу.
losses += 1
elif player_move == '«Бумага»' and computer_move == '«Ножницы»':
print(' Вы проиграли!')
losses += 1
elif player_move == '«Ножницы»' and computer_move == '«Камень»':
print(' Вы проиграли!')
losses += 1
# Делаем небольшую паузу, после чего
# переходим к новой игре.
time.sleep(0.5)
Игра «Камень, ножницы, бумага», версия 1.0.
----------------------------------------------
Каждый из игроков может выбрать «Камень»,
«Ножницы» или «Бумагу». Победитель определяется
по следующим правилам: «Камень» бьет «Ножницы»,
«Ножницы» — «Бумагу», а «Бумага» бьет «Камень».
----------------------------------------------
Победы: 0, проигрыши 0, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> к
«Камень» против ...
1...
2...
3...
«Бумага»
Вы проиграли!
----------------------------------------------
Победы: 0, проигрыши 1, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> н
«Ножницы» против ...
1...
2...
3...
«Бумага»
Вы выиграли!
----------------------------------------------
Победы: 1, проигрыши 1, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> б
«Бумага» против ...
1...
2...
3...
«Камень»
Вы выиграли!
----------------------------------------------
Победы: 2, проигрыши 1, ничьи 0.
Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
> в
Спасибо за игру!
6. Квадратное уравнение. Напишите программу, которая по введенным пользователем коэффициентам квадратного уравнения ax2 + bx + c = 0 будет выдавать ответ с точностью до тысячных и готовое решение. Программа должна:
- выводить свое название и версию, а также краткое описание;
- принимать на ввод коэффициенты уравнения в виде действительных чисел, например, -3.27, или в виде обыкновенных дробей, например, -5/7;
- проверять вводимые значения на допустимость ввода, предлагая в случае ошибки повторный ввод коэффициента или запрашивая выход из программы в противном случае;
- выводить решение с пояснениями включая случаи, когда один или несколько коэффициентов равны нулю;
- после вывода решения выводить запрос на продолжение работы программы или выход из нее.
Решение квадратных уравнений, версия 1.0.
----------------------------------------------
1. Для решения уравнения необходимо ввести коэффициенты
в формате десятичной дроби, например, -1.35, либо в формате
обыкновенной дроби с числителем и знаменателем, например, -3/5.
2. Результат будет рассчитан с точностью до 0,001.
----------------------------------------------
Введите коэффициенты для a*x^2 + b*x + c = 0.
a = -5
b = -3
c = 2
Решаем уравнение -5.0*x^2 - 3.0*x + 2.0 = 0.
Находим дискриминант по формуле b^2 - 4*a*c:
D = b^2 - 4*a*c = 49.0.
Т.к. дискриминант больше нуля, уравнение имеет два корня:
x1 = (-b + √D)/(2*a) = (-(-3.0) + √49.0)/(2*(-5.0)) = -1.0,
x2 = (-b - √D)/(2*a) = (-(-3.0) - √49.0)/(2*(-5.0)) = 0.4.
Продолжить/выйти (any_key/q):
# Импортируем нужные компоненты.
from fractions import Fraction as frn
from math import sqrt
from sys import exit
# Выводим название программы и версию.
print('\n Решение квадратных уравнений, версия 1.0.')
print('\n ----------------------------------------------')
print('''\n 1. Для решения уравнения необходимо ввести коэффициенты
в формате десятичной дроби, например, -1.35, либо в формате
обыкновенной дроби с числителем и знаменателем, например, -3/5.
2. Результат будет рассчитан с точностью до 0,001.''')
print('\n ----------------------------------------------')
# Проверка вводимого значения на число.
# s - строка-подсказка для input().
def is_number(s):
# Переменная для хранения результата.
res = None
# Цикл, который прервется при вводе верного числа.
while True:
# Перехватываем неверный ввод значения.
try:
# Переводим вводимое значение в десят. дробь.
res = round(float(frn(input(s))), 3)
# Если исключение не брошено, выходим из цикла.
break
# Если введено не число.
except (ValueError, ZeroDivisionError):
# Выводим предупреждение.
print(' Введите допустимое значение!')
# Запрашиваем повтор ввода или выход из программы.
ans = input(' Продолжить/Выйти (any_key/q): ')
# Выходим из программы по желанию пользователя.
if ans == 'q' or 'й': exit()
# Возвращаем рез-т, после получения допустимого коэффициента.
return res
#<
# Строковое представление коэффициентов.
def k_to_str(k):
# Отрицательные значения будем выводить в скобках.
if k < 0:
s_k = '({})'.format(k)
else:
s_k = str(k)
# Возвращаем строку для вывода.
return s_k
#<
# Центральная функция программы.
def main():
# Организуем бесконечный цикл с прерыванием через if.
while True:
# Запрашиваем коэффициенты уравнения.
print('\n Введите коэффициенты для a*x^2 + b*x + c = 0:')
# Проверяем их и переводим в целевые дроби.
a = is_number(" a = ")
b = is_number(" b = ")
c = is_number(" c = ")
# Строковое представление коэффициентов.
s_a = k_to_str(a)
s_b = k_to_str(b)
s_c = k_to_str(c)
# Полное квадратное уравнение.
if a != 0 and b != 0 and c != 0:
# Выводим уравнение для решения.
s = '\n Решаем уравнение {}*x^2 + {}*x + {} = 0.'.format(a, b, c)
# Замену делаем для отрицательных b и c.
print(s.replace('+ -', '- '))
# Рассчитываем дискриминант и выводим на экран.
d = round(b**2 - 4*a*c, 3)
# Строка для вывода формулы дискриминанта.
s_d = 'b^2 - 4*a*c'
print('\n Находим дискриминант по формуле {}:'.format(s_d))
# Выводим ход расчета дискриминанта на экран.
print(' D = {}^2 - 4*{}*{} = {}.'.format(s_b, s_a, s_c, d))
# Если дискриминант больше нуля.
if d > 0:
# Получаем и выводим два корня уравнения.
print(' Т.к. дискриминант больше нуля, уравнение имеет два корня:')
# Вычисляем корни.
x_1 = round((-b + sqrt(d))/(2*a), 3)
x_2 = round((-b - sqrt(d))/(2*a), 3)
# Формулы для вывода.
s_1 = '(-b + \u221AD)/(2*a)'
s_2 = '(-b - \u221AD)/(2*a)'
print(' x1 = {} = (-{} + \u221A{})/(2*{}) = {},'.format(s_1, s_b, d, s_a, x_1))
print(' x2 = {} = (-{} - \u221A{})/(2*{}) = {}.'.format(s_2, s_b, d, s_a, x_2))
# Если дискриминант равен нулю.
elif d == 0:
# Получаем и выводим единственный корень уравнения.
print(' Т.к. дискриминант равен нулю, уравнение имеет один корень:')
x = -b/(2*a)
# Формула для вывода.
s = '-b/(2*a)'
print(' x = {} = -{}/2*{} = {}.'.format(s, s_b, s_a, x))
# Если дискриминант меньше нуля.
else:
# Сообщаем об отсутствии корней.
print(' т.к. дискриминант меньше нуля, уравнение не имеет корней.')
# Если 1-й коэффициент равен нулю.
elif a == 0 and b != 0 and c != 0:
# Сообщаем о линейности корней.
print('\n Т.к. a = 0, получаем линейное уравнение вида b*x + c = 0,')
# Выводим уравнение для решения.
s = ' т.е. {}*x + {} = 0, откуда'.format(b, c)
# Замену делаем для отрицательных c.
print(s.replace('+ -', '- '))
# Выводим решение и результат.
print(' x = -{}/{} = {}'.format(s_c, b, -b/c))
# Если 2-й коэффициент равен нулю.
elif a != 0 and b == 0 and c != 0:
# Сообщаем об изменении вида уравнения.
print('\n Т.к. b = 0, получаем ур-ние вида a*x^2 + c = 0,')
# Выводим уравнение для решения.
s = ' т.е. {}*x^2 + {} = 0, откуда'.format(a, c)
# Замену делаем для отрицательных c.
print(s.replace('+ -', '- '), end='')
# Выводим формулу получения корней.
print(' x = \u00B1\u221A-({}/{}).'.format(c, a))
if (a > 0 and c > 0) or (a < 0 and c < 0):
# Выводим сообщение.
print(' Т.к. под знаком корня получается отрицательное значение,')
print(' уравнение действительных корней не имеет.')
else:
# Получаем и выводим два корня уравнения.
print(' Т.к. a и c разного знака, ур-ние имеет два противоположных корня:')
# Вычисляем корни.
x = round(sqrt(-c/a), 3)
# Выводим решение.
print(' x = \u00B1\u221A-({}/{}) = \u00B1{},'.format(c, a, x))
# Если 3-й коэффициент равен нулю.
elif a != 0 and b != 0 and c == 0:
# Сообщаем об изменении вида уравнения.
print('\n Т.к. c = 0, получаем ур-ние вида a*x^2 + bx = 0, откуда')
print(' x*(a*x + b) = 0, или для нашего случая:')
# Выводим уравнение для решения.
s = ' x*({}*x + {}) = 0.'.format(a, b)
# Замену делаем для отрицательных b.
print(s.replace('+ -', '- '))
# Получаем и выводим два корня уравнения.
print(' Данное уравнение имеет два корня:')
print(' x1 = 0 и x2 = -{}/{} = {}'.format(s_b, a, -round(b/a, 3)))
# Если сразу a и b равны нулю.
elif a == 0 and b == 0 and c != 0:
# Сообщаем об изменении вида уравнения.
print('\n При таких условиях ур-ние упрощается до неверного ')
print(' равенства c = 0, а значит не имеет корней.')
# Если сразу a и c равны нулю.
elif a == 0 and b != 0 and c == 0:
# Сообщаем об изменении вида уравнения.
print('\n При таких условиях получаем ур-ние bx = 0, ')
print(' верное только при x = 0.')
# Если сразу b и c равны нулю.
elif a != 0 and b == 0 and c == 0:
# Сообщаем об изменении вида уравнения.
print('\n При таких условиях получаем ур-ние a*x^2 = 0, ')
print(' верное только при x = 0.')
# Если сразу все коэффициенты равны нулю.
elif a == 0 and c == 0 and b == 0:
# Сообщаем об изменении вида уравнения.
print('\n Ур-ние упрощается до верного равенства 0 = 0,')
print(' а значит имеет бесконечное множество корней.')
# Условие для выхода из цикла while True и программы.
if input('\n Продолжить/выйти (any_key/q): ') == 'q': break
#<
# Вызываем основную функцию программы.
main()
Решение квадратных уравнений, версия 1.0.
----------------------------------------------
1. Для решения уравнения необходимо ввести коэффициенты
в формате десятичной дроби, например, -1.35, либо в формате
обыкновенной дроби с числителем и знаменателем, например, -3/5.
2. Результат будет рассчитан с точностью до 0,001.
----------------------------------------------
Введите коэффициенты для a*x^2 + b*x + c = 0.
a = -5
b = -3
c = 2
Решаем уравнение -5.0*x^2 - 3.0*x + 2.0 = 0.
Находим дискриминант по формуле b^2 - 4*a*c:
D = b^2 - 4*a*c = 49.0.
Т.к. дискриминант больше нуля, уравнение имеет два корня:
x1 = (-b + √D)/(2*a) = (-(-3.0) + √49.0)/(2*(-5.0)) = -1.0,
x2 = (-b - √D)/(2*a) = (-(-3.0) - √49.0)/(2*(-5.0)) = 0.4.
Продолжить/выйти (any_key/q):
7. Менеджер проектов. Перейдите в раздел «Python :: Коды, программы, скрипты», найдите там учебный проект «Консольный менеджер проектов», внимательно изучите его исходный код, а затем наберите код программы самостоятельно.
8. Игра «Блек Джек». Напишите программу для игры в «Black Jack» с компьютером. Для этого перейдите на страницу учебного проекта, загрузите и внимательно изучите его код, после чего сверстайте игру самостоятельно.
9. Модуль оффлайн распознавания речи. Напишите скрипт для оффлайн распознавания речи, использовав для этого библиотеку Vosk и ее предобученную модель русского языка. Для этого перейдите в раздел «Python :: Коды, программы, скрипты», найдите там данный учебный проект, внимательно изучите его, а затем наберите код скрипта самостоятельно.
10. Приложение «Голосовой переводчик». Напишите русско-английский голосовой переводчик, который будет автоматически переводить речь пользователя с английского языка на русский или наоборот и сразу же произносить результат перевода. Для этого перейдите на страницу учебного проекта «Голосовой переводчик», загрузите и внимательно изучите его код, после чего сверстайте приложение самостоятельно.
Приложения с GUI
В разделе представлены различные утилиты, скрипты и программы с графическим интерфейсом пользователя (GUI). Для того, чтобы осилить верстку данных приложений, вам придется познакомиться с некоторыми дополнительными библиотеками и фрейворками, например, с библиотекой PyQt6 (PySide6). Но это того стоит! Ведь на ядре и стандартной библиотеке Python мир не заканчивается, и далее вам предстоит постоянно совершенствоваться, изучая все новые и новые сторонние инструменты, необходимые для эффективной разработки приложений в выбранной вами области.
Опять же, вначале следует внимательно разобраться в готом решении программы и только затем приступать к обязательному самостоятельному набору кода. Важно понимать, что простое чтение решений никакой практической пользы не принесет. Поэтому код набирать нужно в любом случае!
1. Электронные часы. Создайте простейший виджет электронных часов на Python с графическим интерфейсом на PyQt6 (Pyside6), который будет отображать на рабочем столе текущие время и дату. Для этого зайдите на страницу учебного проекта «Электронные часы», загрузите и внимательно изучите его код, после чего сверстайте виджет самостоятельно.
2. Калькулятор со скобками. Используя графическую библиотеку PyQt6 (Pyside6), напишите простейший калькулятор, который сможет вычислять выражения со скобками и следующими основными математическими операциями: сложение, вычитание, деление и умножение. Для этого зайдите на страницу учебного проекта «Калькулятор со скобками», загрузите и внимательно изучите его код, после чего сверстайте программу самостоятельно.