okpython.net
Все для начинающих

Сборник упражнений и задач
по основам Python для начинающих

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

  • Чтобы посмотреть результат выполнения исходного кода решений, используйте кнопку «Результат».
  • Чтобы окно консоли после выполнения скрипта сразу не закрывалось, дописывайте в конец скрипта инструкцию input().
  • Решения задач группы А (*) доступны всем авторизованным пользователям, а группы В (*) – только пользователям, оформившим подписку на дополнительные учебные материалы сайта.
  • Если в ходе решения задач у вас возникнут трудности, будут обнаружены какие-либо ошибки или вы просто захотите поделиться своим вариантом решения какой-либо задачи, пишите мне в соцсети (в первую очередь стараюсь отвечать подписчикам).

Числа и математические выражения

Теоретический материал по числам, математическим операциям и модулю math можно почитать в нашем учебнике здесь.

1.1.* Выведите на экран строковые представления числа 53 в двоичной, восьмеричной и шестнадцатеричной системах счисления. Показать решение.

Решение Результат pythonCodes
# Переводим число в требуемые СС.
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' (шестнадцатеричная СС). Выведите на экран строковые представления этих чисел в десятичной системе счисления. Показать решение.

Решение Результат pythonCodes
# Представление числа в 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 является числом в восьмеричной системе счисления, выведите на экран значение этого числа в десятичной системе счисления. Показать решение.

Решение Результат pythonCodes
# Сохраним число в переменной.
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. Показать решение.

Решение Результат pythonCodes
# 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 = числитель/знаменатель'. Показать решение.

Решение Результат pythonCodes
# Получаем числ. и знам., т.е. кортеж (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. Выведите на экран его действительную и мнимую части, а также число, сопряженное к данному. Показать решение.

Решение Результат pythonCodes
# Сохраним число в переменной.
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. Округлите результаты до сотых и выведите их на экран. Показать решение.

Решение Результат pythonCodes
# Присваиваем значения переменным. 
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, округлив результат до трех знаков после десятичной точки и найдя его модуль. Показать решение.

Решение Результат pythonCodes
# Найдем результат выражения.
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. Выведите результат на экран. Показать решение.

Решение Результат pythonCodes
''' 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 тремя способами. Показать решение.

Решение Результат pythonCodes
# Нам понадобится модуль 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°) округлив результат до двух знаков после десятичной точки. Показать решение.

Решение Результат pythonCodes
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. Показать решение.

Решение Результат pythonCodes
# Присваиваем значения переменным. 
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. Показать решение.

Решение Результат pythonCodes
# Присваиваем значения переменным. 
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. Показать решение.

Решение Результат pythonCodes
# Присваиваем значения переменным. 
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. Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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. Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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. Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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. Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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). Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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√π. Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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. Округлите результат до сотых и выведите его на экран. Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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}'». Реализуйте вывод двумя способами, использовав в качестве внешних двойные и одинарные кавычки. Показать решение.

Решение Результат pythonCodes
'''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' " ' " '». Реализуйте вывод четырьмя способами, использовав в качестве внешних все виды кавычек, разрешенных для строк. Показать решение.

Решение Результат pythonCodes
'''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'. Реализуйте вывод двумя способами. Показать решение.

Решение Результат pythonCodes
'''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. Кроме того, при взятии среза нужно помнить, что символ с индексом равным последнему пределу среза в результат не попадает.

Решение Результат pythonCodes
# Сохраним строку в переменной.
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'. Используя срезы с шагом получите две строки: только с заглавными и только со строчными буквами. Выведите их на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним строку в переменной.
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.* Измените строку 'кот', записав ее символы в обратном порядке. Выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = 'кот'
# Получаем строку-перевертыш.
s = s[::-1]
# Выводим ее на экран.
print(s)
ток




			

2.7.* Дана строка '0123456789'. Удалите из нее первый, пятый и последний символы. Выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = '0123456789'
# Формируем новую строку.
s = s[1:4] + s[5:-1]       
# Выводим ее на экран.
print(s)
1235678




			

2.8.* При помощи строк '.', '!' и ' ' (один пробел) сформируйте новую строку '..... ! ! ! .....' и выведите ее на экран. Разрешается использовать только операторы + и *. Показать решение.

Решение Результат pythonCodes
# Формируем строку.
str_1 = '.'*5 + ' ' + ('!' + ' ')*3 + '.'*5	

# Выводим ее на экран.
print(str_1)
..... ! ! ! .....



			

2.9.* Дана строка 'Вот и пришла осень золотая!'. Возьмите ее в кавычки «» и выведите результат на экран. Шестнадцатиричные коды кавычек в Юникоде: 00AB и 00BB. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = 'Вот и пришла осень золотая!'
# Сохраняем результат.
s = '\u00AB' + s + '\u00BB'       
# Выводим результат на экран.
print(s)
«Вот и пришла осень золотая.»




			

2.10.* Подсчитайте количество символов в строке '1a\u0398\t\u03B43s'. Сделайте это сперва устно, а затем проверьте себя программно. Показать решение.

Решение Результат pythonCodes
# Получаем количество символов строки.
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 ' все пробелы и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = ' a b c   d e f '
# Удаляем пробелы и заменяем исх. строку.
s = s.replace(' ', '')        
# Выводим результат на экран.
print(s)
abcdef




			

2.12.* Дана строка "..-.--..-.--". После каждой точки допишите еще по одной точке и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = '..-.--..-.--'
# Заменяем каждую точку на две.
s = s.replace('.', '..')      
# Выводим измененную копию на экран.
print(s)
....-..--....-..--




			

2.13.* Дана строка '131231442145'. Подсчитайте в ней количество символов '1' и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = '131231442145'
# Считаем и выводим рез-т на экран.
print('Кол-во единиц:', s.count('1'))
Кол-во единиц: 4


			

2.14.* Посчитайте устно, а затем проверьте себя, выведя на экран сумму индексов символа 'а' в строках 'повар' и 'Пайтон'. Показать решение.

Решение Результат pythonCodes
# Находим индексы символа в строках.
ind_1 = 'повар'.index('а')
ind_2 = 'Пайтон'.index('а')
# Выводим рез-т на экран.
print('Сумма индексов:', ind_1 + ind_2)
Сумма индексов: 4



			

2.15.* Даны две переменные: a = 73 и b = 95. Используя метод форматирования строк, выведите на экран их сумму и произведение в форматах 'a + b = c' и 'a*b = c'. Показать решение.

Решение Результат pythonCodes
# Заданные переменные.
a = 73; b = 95
# Форматируем и выводим рез-ты на экран.
print('{} + {} = {}'.format(a, b, a+b))
# Или так.
print('{0}*{1} = {2}'.format(a, b, a*b))
73 + 95 = 168
73*95 = 6935



			

2.16.* Дана строка 'ABCDEF'. Поменяйте в ней первый и последний символы местами и выведите итоговую строку на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = 'ABCDEF'
# Заменяем строку измененной копией.
s = s[-1] + s[1:-1] + s[0]      
# Выводим ее на экран.
print(s)
FBCDEA




			

2.17.* Допишите в конец строки 'автопрогон' ее длину и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = 'автопрогон'
# Формируем новую строку.            
s += str(len(s))
# Выводим итог на экран.
print(s)
автопрогон10




			

2.18.* Дана строка 'в Ереване'. Подсчитайте в ней количество русских символов 'е' в любом регистре и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = 'в Ереване'
# Считаем и выводим рез-т на экран.
print((s.lower()).count('е'))
3


			

2.19.* Подсчитайте количество слов в строке 'Вот и пришла осень золотая!'. Разделителем слов считайте пробел. Выведите результат подсчета на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = 'Вот и пришла осень золотая!'
# Разбиваем на слова и считаем.
res = len(s.split(' '))       
# Выводим результат на экран.
print('Количество слов:', res)
Количество слов: 5




			

2.20.* Найдите количество вхождений подстроки 'ab' в строку 'ab bc ab bd ab be' и поменяйте в каждом случае символы 'a' и 'b' местами. Выведите результаты на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним исходную строку в переменной.
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)))'. Выведите результат проверки на экран в виде сообщения. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
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' хотя бы один символ арабской цифры от нуля до девяти и выведите результат проверки на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
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.' и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
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. Показать решение.

Решение Результат pythonCodes
# Преобразуем число в строку.
s = str(377.37177785772707)
# Получаем дробную часть числа.
n = s[s.find('.') + 1:]    
# Выводим кол-во цифр 7 в ней.
print(n.count('7'))
8




			

2.25.* Составьте строку, состоящую из заглавных букв латинского алфавита, и выведите ее на экран. В таблице символов Юникода заглавные буквы латинского алфавита занимают диапазон номеров с 65 по 90. Показать решение.

Решение Результат pythonCodes
''' 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.* Выведите на экран сумму числовых кодов символов строки 'два пижона'. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
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 для букв Ё и ё. Показать решение.

Решение Результат pythonCodes
# Сохраним исходную строку в переменной.
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.* Дана строка '_*..*..*_'. Замените в ней все символы '*' числами, которые соответствуют их номеру вхождения в строку (первая слева имеет номер вхождения один и т.д.). Выведите измененную строку на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним исходную строку в переменной.
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.* Подсчитайте, сколько видов букв присутствует в строке 'синхрофазотрон', и выведите результаты на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним строку в переменной.
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.* Дана строка 'акваланг'. Замените в ней все символы 'а' числами, которые соответствуют индексу этого символа в строке. Выведите измененную строку на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним исходную строку в переменной.
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.* Подсчитайте количество каждого вида символов в строке 'выхухоль' и выведите результаты на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним строку в переменной.
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.* Измените строку 'Чья это корова там замычала?' таким образом, чтобы символы в словах были записаны в обратном порядке. Разделителем слов считайте пробел. Выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним исходную строку в переменной.
s = 'Чья это корова там замычала?'	

# Разбиваем на слова и переворачиваем их.
li = [w[::-1] for w in s.split(' ')]
# Собираем строку обратно.
s = ' '.join(li)
# Выводим измененную строку.
print(s)
яьЧ отэ аворок мат ?алачымаз





			

			

2.33.* Дано строковое представление времени таймера '03:25:57'. Выведите на экран количество секунд, оставшихся до момента срабатывания таймера. Используйте формат сообщения «До срабатывания таймера осталось {n} сек.». Показать решение.

Решение Результат pythonCodes
# Сохраним строку в переменной. 
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. Кроме того, при взятии среза нужно помнить, что символ с индексом равным последнему пределу среза в результат не попадает.

Решение Результат pythonCodes
# Сохраним список в переменной.
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!', использовав синтаксис доступа к элементу списка по его индексу. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
li = [[1, 2, ['Ok!', 3]], ['list', 4], 5]
# Используем цепочку доступа по индексу.		
print(li[0][2][0])
Ok!


			

3.3.* Создайте список-матрешку, в который поместите два элемента: целое число и вложенный список, в который поместите еще два элемента: вещественное число и вложенный список, в который поместите еще два элемента: комплексное число и вложенный список, в который поместите еще два элемента: строку и пустой список. Выведите на экран конечную строку. Показать решение.

Решение Результат pythonCodes
# Создаем наш список-матрешку.        
li = [1, [0.2, [0.3+4j, ['5р.', []]]]] 
# Выводим на экран нужное значение.        
print(li[1][1][1][0])
5р.


			

3.4.* Дан список ['Санкт', '+', 'Петербург']. Исправьте плюс на дефис и выведите название города на экран использовав доступ к элементам списка по индексам. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
li = ['Санкт', '+', 'Петербург']
# Меняем знак на верный.		
li[1] = '-'			

# Выводим название на экран.		
print(li[0], li[1], li[2], sep='', end='\n\n')
Санкт-Петербург

 
 
 

			

3.5.* Дан список ['a', '1', 'b', '2', 'c', '3']. Разбейте его на два списка: только с буквами и только с числами. Сам список затем удалите, а новые списки выведите на экран, каждый на отдельной строке. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
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. Переместите первый элемент конечного списка в предпоследнюю позицию списка. Выведите список на экран. Используйте в решении только доступ по индексу и срезы. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
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]. Выведите на экран: количество всех элементов в списке, количество единиц в списке, индекс первого вхождения единицы в список. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
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'. Выведите конечный результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
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', очистите список. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
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]. Выведите на экран: сумму его элементов, разность максимального и минимального значений. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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]. Выведите на экран количество отрицательных элементов. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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]. Выведите на экран индекс минимального элемента. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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]. Выведите на экран сумму абсолютных значений его элементов. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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]. Поменяйте местами максимальный и минимальный элементы списка. Выведите измененный список на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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]. Расположите числа в порядке убывания их значений, а затем добавьте в конец списка его длину. Выведите измененный список на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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]. Выведите измененный список на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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]. Удалите из него первое четное число, имеющее нечетный индекс. Выведите измененный список на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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.* Дан список строк ['три', '', 'конь', 'свет', '']. Удалите из него все пустые строки и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
li = ['три', '', 'конь', 'свет', '']

''' 1-й вариант '''        
# Цикл по кол-ву пустых строк.
for i in range(li.count('')):
    # Удаляем ее из списка.
    li.remove('')          

# Выводим список на экран.
print(li)              

''' 2-й вариант '''
# Восстанавливаем список.
li = ['три', '', 'конь', 'свет', '']        
# Можно и через генератор списков.
li = [x for x in li if x != '']
# Выводим список на экран.
print(li)    

''' 3-й вариант '''
# Восстанавливаем список.
li = ['три', '', 'конь', 'свет', '']        
#Используем фильтрацию эл-тов.
li = list(filter(lambda x: x != '', li))
# Выводим список на экран.
print(li)
['три', 'конь', 'свет']
['три', 'конь', 'свет']
['три', 'конь', 'свет']























			

3.19.* Дан список ['три', [2, 5], 0.7, 'home']. Создайте список типов элементов данного списка и выведите результат на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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 – это не дубли! Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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']. Сформируйте новый список, который будет состоять из строк, которые присутствуют хотя бы в одном из списков. Выведите полученный список на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем списки в переменных.
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']. Поменяйте в нем соседние элементы местами. Т.к. число элементов в списке нечетное, последний элемент оставьте на своем месте. Выведите измененный список на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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.* Создайте кортеж, в качестве элементов которого используйте целое, вещественное и комплексное числа, кортеж с одним элементом в виде строки, пустой кортеж и пустой список. Выведите на экран строку вложенного кортежа. Показать решение.

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

Решение Результат pythonCodes
# Создаем кортеж.        
tpl = (1, 0.2, 0.3+4j, ('5',), (), []) 
# Выводим строку вложенного кортежа на экран.        
print(tpl[3][0])
5


			

4.2.* Создайте кортеж-матрешку, в который поместите два элемента: целое число и вложенный кортеж, в который поместите еще два элемента: вещественное число и вложенный кортеж, в который поместите еще два элемента: комплексное число и вложенный кортеж, в который поместите еще два элемента: строку и пустой кортеж. Выведите на экран конечную строку. Обратите внимание на схожесть решения с задачей 3.3. Показать решение.

Решение Результат pythonCodes
# Создаем наш кортеж-матрешку.        
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. Кроме того, при взятии среза нужно помнить, что символ с индексом равным последнему пределу среза в результат не попадает.

Решение Результат pythonCodes
# Сохраним кортеж в переменной.
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. Показать решение.

Решение Результат pythonCodes
# Сохраняем кортеж в переменной.
tpl = ((1, 2, ('Ok!', 3)), ('tuple', 4), 5)
# Используем цепочку доступа по индексу.		
print(tpl[0][2][0])
Ok!


			

4.5.* Дан кортеж (3, 's', 1, 5, 's'). Выведите на экран: количество всех элементов кортежа, количество строк 's', индекс первого вхождения 's' в кортеж. Показать решение.

Решение Результат pythonCodes
# Сохраним кортеж в переменной.
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). Замените в списке 'кит' на 'кот', удалите единицу, а также измените значение последнего элемента списка, возведя тройку в квадрат. Выведите кортеж на экран. Попробуйте изменить второй элемент кортежа, умножив его на два. Объясните результат. Показать решение.

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

Решение Результат pythonCodes
# Сохраним кортеж в переменной.
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} тремя способами. Выведите полученный словарь на экран. Показать решение.

Решение Результат pythonCodes
''' 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.* Создайте словарь содержащий данные о человеке. В качестве строковых ключей используйте его имя, возраст и пол. Значения придумайте самостоятельно. Выведите полученный словарь на экран. Показать решение.

Решение Результат pythonCodes
''' 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, после чего добавьте результат в словарь, а затем выведите значение нового элемента на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем словарь в переменной.
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}. Выведите их на экран в виде списков. Показать решение.

Решение Результат pythonCodes
# Сохраняем словарь в переменной.
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}.

Решение Результат pythonCodes
# Сохраняем словари в переменных.
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'], использовав для второго элемента оператор удаления, а для первого имеющийся у словарей метод. Выведите результат на экран, после чего очистите словарь. Показать решение.

Решение Результат pythonCodes
# Сохраняем словарь в переменной.
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.
При создании хранилища в родительском словаре используйте ключи 'черный', 'серый' и 'белый', а во вложенных – 'name', 'rgb10' и 'rgb16'. Выведите на экран представление серого цвета по имени в виде строки 'color: name;', а также в 10-м формате в виде строки 'color: rgb(a, b, c);' и в 16-м формате в виде строки 'color: #RRGGBB;'. Показать решение.

Решение Результат pythonCodes
# Используем вложенные словари.
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!'. Выведите на экран конечную строку. Показать решение.

Решение Результат pythonCodes
# Создаем наш словарь-матрешку.        
d = {'1': {'0.2': {'0.3+4j': {'[]': {'(5,)': 'Ok!'}}}}} 
# Выводим на экран нужное значение.        
print(d['1']['0.2']['0.3+4j']['[]']['(5,)'])
Ok!


			

5.9.* Дан список ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс']. Создайте словарь с ключами 'd1', 'd2', ..., соответствующими индексам элементов списка. Выведите на экран элемент словаря, который соответствует среде, в формате ключ: значение. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
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: 'сто'}. Выведите на экран сумму ключей, максимальное и минимальное значения ключей, а также их количество. Показать решение.

Решение Результат pythonCodes
# Сохраним словарь в переменной.
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. Показать решение.

Решение Результат pythonCodes
# Сохраним словарь в переменной.
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'} ключи и значения местами. Выведите итоговый словарь на экран. Показать решение.

Решение Результат pythonCodes
# Сохраним словарь в переменной.
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} все элементы со строковыми ключами. Помните, что изменение размеров словаря во время итерации может привести к ошибке, поэтому для работы используйте копию словаря. Выведите итоговый словарь на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем словарь в переменной.
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 кг. Показать решение.

Условие pythonCodes
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}
} 
Решение Результат pythonCodes
# Словарь товаров.
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.* Создайте множество, в качестве элементов которого используйте целое, вещественное и комплексное числа, а также строки в формате кортежа, списка и словаря, содержащих по одному элементу. Выведите полученное множество на экран. Показать решение.

Ответ. Не забываем, что при создании множества следует использовать только неизменяемые элементы.

Решение Результат pythonCodes
# Создаем множество.        
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'. Выведите итоговое множество на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем множество в переменной.
s = {'a', 'b', 'c'}
           
# Удаляем указанный эл-т.
s.remove('c')		
# Добавляем эл-т.
s.add('d')
# Выводим итог на экран.
print(s)
{'a', 'b', 'd'}







			

6.3.* Даны множества {'a', 'b'} и {'b', 'c'}. Множества простые, поэтому сперва назовите результат их объединения, пересечения, разности и симметричной разницы устно, а затем проверьте себя, выведя результаты на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем множества в переменных.
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. Показать решение.

Решение Результат pythonCodes
# Сохраняем множества в переменных.
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. Показать решение.

Решение Результат pythonCodes
# Сохраним множество в переменной.
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.* Определите есть ли в строке 'Купить, нельзя оставить!' хотя бы одна точка или запятая. Выведите результат проверки на экран. Показать решение.

Решение Результат pythonCodes
# Приведем строку к множеству.
s_1 = set('Купить, нельзя оставить!')
# Создадим множество с запятой и точкой.
s_2 = set('.,')        
# Находим пересечение мн-в и выводим ре-т.
print(True if set(s_1)&set(s_2) else False)
True




			

6.7.* Даны три слова 'аквариум', 'мармелад' и 'рама'. Выведите на экран сперва все виды букв, которые присутствуют во всех словах сразу, а затем все виды букв, которые присутствуют в любом из них. Показать решение.

Решение Результат pythonCodes
# Преобразуем строки в множества символов.
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. Выведите на экран наименьшее из них, использовав для этого программную проверку. Показать решение.

Решение Результат pythonCodes
# Сохраняем числа в переменных.        
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']. Сколько уникальных ников представлено в обоих списках? В каком списке уникальных ников содержится больше? Выведите результаты на экран. Показать решение.

Решение Результат pythonCodes
# Преобразуем списки в множества ников.
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}.

Решение Результат pythonCodes
# Импортируем класс 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.* Перевести граммы в килограммы и вывести результат на экран. Значение граммов ввести с клавиатуры. Показать решение.

Решение Результат pythonCodes
# Вводим значение граммов для расчетов. 
grams = float(input('Введите вес в граммах: '))

# Переводим в килограммы.
kg = grams*1e-3
print('Получаем: {} кг.'.format(kg))
Введите вес в граммах: 550 
Получаем: 0.55 кг.



			

7.2.* Даны две переменные x = 10 и y = 55. Поменяйте их значения местами. Выведите значения переменных на экран до и после замены. Показать решение.

Решение Результат pythonCodes
# Исходные значения переменных. 
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 в метрах. Необходимо найти и вывести на экран количество полных километров в нем. Показать решение.

Решение Результат pythonCodes
# Вводим расстояние в метрах. 
L = float(input('Введите расстояние в метрах: '))
# Находим число полных километров.
km = L//1000
print('Полных км.:', km)
Введите расстояние в метрах: 5035
Полных км.: 5.0


			

7.4.* Вычислить и вывести на экран длину окружности и площадь круга одного и того же заданного радиуса R, который необходимо ввести с клавиатуры в сантиметрах. Результаты должны округляться до сотых. Показать решение.

Решение Результат pythonCodes
# Импортируем число Пи.
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.* С клавиатуры вводится некоторое число байт. Определите количество байт, которое нужно к нему добавить, чтобы получить целое число килобайт и мегабайт. Выведите результаты на экран. Показать решение.

Решение Результат pythonCodes
# Вводим значение байтов для расчетов. 
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). Значение длины маятника в метрах необходимо ввести с клавиатуры. Показать решение.

Решение Результат pythonCodes
# Импортируем число Пи.
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.* Вычислить и вывести на экран сумму цифр трехзначного натурального числа вводимого с клавиатуры. Показать решение.

Решение Результат pythonCodes
# Вводим число (получим строку). 
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 сек.». Показать решение.

Решение Результат pythonCodes
# Сохраним строку в переменной. 
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. Показать решение.

Решение Результат pythonCodes
# Запрашиваем число и сохраняем его.
n = input('Введите целое число: ')
# Приводим строку к списку.
li = list(n)
# Переворачиваем список.
li.reverse()
# Собираем строку обратно.
n = "".join(li)
# Выводим перевернутое число на экран.
print('Число обратное введенному:', n)
Введите целое число: 75476
Число обратное введенному: 67457







			

7.10.* Получите и преобразуйте текущую системную дату, возвращаемую методом date.today() модуля стандартной библиотеки datetime, из формата «год-месяц-день» в формат «день.месяц.год». Выведите оба формата даты на экран. Показать решение.

Решение Результат pythonCodes
# Импортируем модуль даты.
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 кратно двум или трем. Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
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 не кратно трем и оканчивается нулем. Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
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 имеет хотя бы один элемент. Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
res = "li"
print(res)        

# Небольшая проверка в инструкции.
li = [0]                      
if li:
    print(True)
else:
    print(False) 
li
True







			

8.4.* Записать и вывести на экран условие, которое является истинным, когда хотя бы одно из чисел x, y и z больше 80. Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
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 одновременно положительны или отрицательны. Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
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. Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
res = "not d"
print(res)        

# Небольшая проверка в инструкции.
d = {}                      
if not d:
    print(True)
else:
    print(False)
not d
True







			

8.7.* Записать и вывести на экран условие, которое является истинным, когда строка s является ключом словаря D, но отсутствует в списке строк L. Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
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). Показать решение.

Решение Результат pythonCodes
# Составляем условие.        
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 меньше нуля. Показать решение.

Решение Результат pythonCodes
'''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.* Записать и вывести на экран условие, которое является истинным, когда переменная принадлежит к классу целых или вещественных чисел. Показать решение.

Решение Результат pythonCodes
'''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'. Запишите и выведите на экран условие, которое является истинным только для строк, содержащих двузначное число. Показать решение.

Решение Результат pythonCodes
'''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.* Запишите и выведите на экран условие, которое является истинным только для положительных целых чисел, которые делятся сразу и на два, и на четыре. При этом используйте не прямое деление, которое для больших чисел даст значительный отрицательный эффект по производительности, а следующие правила математики:

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

Решение Результат pythonCodes
# Составляем условие.        
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/elif/else

Теоретический материал по условной инструкции if/elif/else можно почитать в нашем учебнике здесь.

9.1.* Определите, не является ли введенная пользователем с клавиатуры строка пустой. Результат проверки в виде True или False выведите на экран. Показать решение.

Решение Результат pythonCodes
# Выводим сообщение и призыв к вводу.
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.* Написать программу, которая будет делить введенные пользователем два вещественных числа и выводить результат на экран, сообщая об ошибке в случае деления на ноль. Показать решение.

Решение Результат pythonCodes
# Выводим сообщение и призыв к вводу.
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.* Определить, является ли введенное с клавиатуры натуральное число кратным трем. Вывести результат на экран. Показать решение.

Решение Результат pythonCodes
# Просим ввести число для проверки. 
n = int(input('Введите нат. число для проверки: '))

# Проверяем кратность трем.
if n%3 == 0:
    # Выводим результат на экран.
    print('Число', n, 'кратно трем.')
else:
    # Выводим результат на экран.
    print('Число', n, 'на 3 не делится.')
Введите нат. число для проверки: 81
Число 81 кратно трем.







			

9.4.* Рассчитать стоимость покупки с учетом скидки в 35%, которая предоставляется покупателю, если сумма покупки превышает 20 у.е. Сумму покупки ввести с клавиатуры, а результаты округлить до сотых (копейки, центы и т.д.). Вывести на экран итоговую стоимость и размер предоставленной скидки. Показать решение.

Решение Результат pythonCodes
# Вводим сумму покупки. 
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.* Напишите программу, которая будет проверять, является ли введенное пользователем значение цифрой десятичной системы счисления. Результат проверки должен выводиться пользователю на экран в виде сообщения. Показать решение.

Решение Результат pythonCodes
# Выводим сообщение и призыв к вводу.
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-й СС». Показать решение.

Решение Результат pythonCodes
# Выводим сообщение и призыв к вводу.
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. Показать решение.

Условие pythonCodes
Введите ответ: 2*65 = 120
Вы ошиблись, т.к. 2*65 = 130
			
----------------------				
			
Введите ответ: 2*47 = 94
Верно! 2*47 = 94
Решение Результат pythonCodes
# Импортируем метод 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» или «Извините, но размен невозможен!». Показать решение.

Условие pythonCodes
Введите сумму в рублях: 156
Размен: 100x1, 10x5, 2x3
			
----------------------				
			
Введите сумму в рублях: 35
Извините, но размен невозможен!	
Решение Результат pythonCodes
# Просим ввести число. 
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. Выведите на экран наименьшее из них, использовав для этого программную проверку. Показать решение.

Решение Результат pythonCodes
# Сохраняем числа в переменных.        
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). Координаты точки ввести с клавиатуры. Показать решение.

Решение Результат pythonCodes
# Запрашиваем координаты точки.
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.* По длинам трех отрезков, вводимых пользователем с клавиатуры, определить возможность существования треугольника, составленного из этих отрезков. Если такой треугольник существует, то определить, является ли он разносторонним, равнобедренным или равносторонним. Показать решение.

Решение Результат pythonCodes
# Просим ввести длины сторон. 
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, будет выводить на экран сообщение в виде названия месяца и времени года. Если пользователь введет недопустимое число, программа должна выдавать сообщение об ошибке. Показать решение.

Решение Результат pythonCodes
# Сохраним названия месяцев в словаре. 
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. Показать решение.

Условие pythonCodes
Какой из двух форматов подходит для инструкции 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
Верно!
Решение Результат pythonCodes
# Импортируем метод 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, выведите на экран: максимальное значение четных чисел, если их меньше, чем нечетных; максимальное значение нечетных чисел, если их меньше, чем четных; максимальное значение из двух, если в списке содержится равное количество четных и нечетных чисел. Использовать для решения задачи другие встроенные функции запрещается! Показать решение.

Условие pythonCodes
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
Решение Результат pythonCodes
# Импортируем ф-цию 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. Показать решение.

Решение Результат pythonCodes
# Сохраним строку символов в переменной.
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) - сумма чисел.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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'], предварительно приводя строки к целым числам. Показать решение.

Решение Результат pythonCodes
# Сохраним список в переменной.
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}. Выведите на экран только четные числа. Показать решение.

Решение Результат pythonCodes
''' 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".». Показать решение.

Решение Результат pythonCodes
# Сохраним строку символов в переменной.
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. Показать решение.

Решение Результат pythonCodes
# Запрашиваем число и сохраняем его.
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. Показать решение.

Решение Результат pythonCodes
# Запрашиваем число и сохраняем его.
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»' и выведите результаты на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
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']. Сформируйте новый список, который будет состоять из строк, которые присутствуют хотя бы в одном из списков. Выведите полученный список на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем списки в переменных.
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', которые находятся в нижнем регистре, не используя при этом срез строки. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
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генерируйте и выведите на экран мозаичное изображение гексагональной сетки, напоминающее мелкоячеистую проволочную сетку. Показать решение.

Условие pythonCodes
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/


			
Решение Результат pythonCodes
''' 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 (должны получиться тройные матрешки из вложенных циклов). Показать решение.

Решение Результат pythonCodes
# Структура вложенных списков для обхода.
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. Показать решение.

Решение Результат pythonCodes
# Запрашиваем число и сохраняем его.
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]}. Удалите из вложенных списков все четные значения элементов. Выведите измененный словарь на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем словарь в переменной.
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.* Выведите на экран таблицу умножения чисел от одного до девяти. Показать решение.

Условие pythonCodes
 ----+-------------------------------------
 | х |  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 |
 ----+-------------------------------------
Решение Результат pythonCodes
''' 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. Простым называется натуральное число большее единицы, которое делится только на единицу и само себя. Если у натурального числа есть делители большие единицы, то все они не превышают корня квадратного из этого числа. Показать решение.

Решение Результат pythonCodes
# Запрашиваем число и сохраняем его.
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.* Создайте простейшую в мире функцию simple_func, а затем выведите на экран ее тип. Показать решение.

Решение Результат pythonCodes
# Простейшая в мире функция.
def simple_func(): pass

# Выводим тип объекта.                    
print(type(simple_func))
<class 'function'>



			

11.2.* Напишите функцию hello_friend, принимающую в качестве аргументов имя и фамилию пользователя и возвращающую строку в формате «Привет, {name} {surname}!». Вызовите функцию и выведите результат вызова на экран. Показать решение.

Решение Результат pythonCodes
# Определяем ф-цию с двумя позиционными аргументами.
def hello_friend(name, surname): 
    # Формируем приветствие.                    
    s = 'Привет, {} {}!'.format(name, surname)        
    # Возвращаем результат.        
    return s

# Вызываем ф-цию и выводим приветствие на экран.
print(hello_friend('Иван', 'Иванов'))
Привет, Иван Иванов!







			

11.3.* Создайте еще одну версию функции hello_friend из предыдущего задания, также принимающую в качестве аргументов имя и фамилию пользователя и возвращающую строку в формате «Привет, {name} {surname}!». Но на этот раз функция должна принимать только именованные аргументы со значениями по умолчанию. Вызовите функцию без аргументов и с аргументами, попутно выводя результаты вызовов на экран. Показать решение.

Решение Результат pythonCodes
# Определяем ф-цию с двумя именованными аргументами.
def hello_friend(*, name='Иван', surname='Иванов'): 
    # Формируем приветствие.                    
    s = 'Привет, {} {}!'.format(name, surname)        
    # Возвращаем результат.        
    return s

# Вызываем ф-цию без передачи аргументов.
print(hello_friend())         
# Вызываем ф-цию с аргументами.
print(hello_friend(name='Петр', surname='Романовский'))
Привет, Иван Иванов!
Привет, Петр Романовский!








			

11.4.* Создайте пользовательскую функцию, принимающую произвольное количество аргументов и выводящую их затем на экран. Для вывода элементов полученного списка используйте цикл for. Вызовите функцию, передав ей в качестве значений целое число, вещественное число, строку и пустой список. Показать решение.

Решение Результат pythonCodes
# Ф-ция с произвольным числом аргументов.
def print_args(*args): 
    # Заголовок цикла.                    
    for elem in args:        
        # Выводим элемент на экран.        
        print(elem)  
    
# Вызываем ф-цию.
print_args(5, 0.73, 'str', [])
5
0.73
str
[]




			

11.5.* Создайте пользовательскую функцию, принимающую произвольное количество именованных аргументов и выводящую их затем на экран в формате «key -> value». Для вывода элементов полученного словаря используйте цикл for. Вызовите функцию, передав ей в качестве значений целое число, вещественное число, строку и пустой список. Показать решение.

Решение Результат pythonCodes
# Ф-ция с произв-ным числом именованных арг-тов.
def print_args(**dict_args): 
    # Заголовок цикла.                    
    for item in dict_args.items():        
        # Выводим пару key -> value на экран.        
        print(item[0], '->', item[1])  
    
# Вызываем ф-цию.
print_args(n=5, f=0.73, s='str', li=[])
n -> 5
f -> 0.73
s -> str
li -> []




			

11.6.* Создайте и вызовите пользовательскую функцию-матрешку my_func_1, состоящую из четырех вложенных друг в друга определений аналогичных функций. Каждая функция должна выводить сообщение в формате 'In my_func_{номер функции}.', а также содержать определение и вызов следующей вложенной функции (в последней функции эта часть будет отсутствовать). Показать решение.

Условие pythonCodes
In my_func_1.
In my_func_2.
In my_func_3.
In my_func_4.
In my_func_5.
Решение Результат pythonCodes
# Создаем нашу функцию-матрешку.        
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.























			

11.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. Показать решение.

Решение Результат pythonCodes
# Объявляем функцию с аннотациями. 
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 

















11.8.* Создайте рекурсивную функцию recursive_func(text), которая будет выводить символы передаваемой ей строки на экран через пробел. Показать решение.

Решение Результат pythonCodes
# Объявляем нашу рекурсивную функцию. 
def recursive_func(text):
	# Если text == ''.
	if not text:
		# Завершаем рекурсии.
		return None
	# Иначе
	else:
		# выводим первый символ 
		print(text[0], end=' ')
		# и вызываем функцию опять, урезав
		# текст на один символ.
		return recursive_func(text[1:])

# Вызываем функцию.
recursive_func('Python 3.9')
P y t h o n   3 . 9 















11.9.* Напишите функцию, рассчитывающую стоимость поездки на такси в зависимости от расстояния. В качестве аргументов функция должна принимать именованные параметры: км – расстояние поездки в километрах, мин_цена – базовый тариф, включающий подачу такси и первые три километра пути, цена_за_км – цена за каждый километр, начиная с четвертого. Рассчитайте и выведите на экран стоимость поездки за 17.5 км, если по умолчанию базовый тариф составляет 2 у.е., а цена за километр сверх минимума – 0.3 у.е. Показать решение.

Решение Результат pythonCodes
# Заголовок функции.        
def func(*, км, мин_цена=2, цена_за_км=0.3):
    
    # Задаем стартовое значение стоимости поездки.
    стоимость = мин_цена
    
    # Проверяем километраж.
    if км > 3:
        # Увеличиваем итоговую стоимость.       
        стоимость += (км - 3)*цена_за_км            
    
    # Возвращаем результат в точку вызова.       
    return стоимость           

# Вызываем функцию и выводим результат.
print('Стоимость поездки:', func(км=17.5), 'y.e.')
Стоимость поездки: 6.35 y.e.














			

11.10.* Напишите функцию, которая будет генерировать случайный пароль. В пароле должно быть от 8 до 15 символов Юникода из диапазонов 48-57 (цифры), 65-90 (буквы латинского алфавита в верхнем регистре) и 97-122 (буквы латинского алфавита в нижнем регистре). Сгенерируйте и выведите на экран три пароля. Показать решение.

Решение Результат pythonCodes
# Импортируем метод 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

























			

11.11.* Напишите простейшую функцию-калькулятор, которая будет выполнять с двумя переданными ей числами следующие действия: сложение, вычитание, умножение и деление с указанной точностью. Соответственно, функция должна принимать два позиционных числовых аргумента для чисел, один именованный строковый аргумент op (по умолчанию функция должна выполнять операцию сложения) и один именованный числовой аргумент prec для требуемой точности результата (по умолчанию три знака после запятой). В случае деления на ноль функция должна возвращать NaN, а при попытке выполнения непредусмотренной операции – сообщение об ошибке «Неподдерживаемый тип операции!». Выведите на экран результаты вызовов функции с точностью до сотых для числовых выражений: -13.756 + 59.291, 599 - 783, -7/55, 7/0 и 57.75*33.2. Показать решение.

Решение Результат pythonCodes
# Заголовок функции.        
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



























			

11.12.* В григорианском календаре, который был введен в 1582 году папой римским Григорием XIII обычный год состоит из 365 дней. Но т.к. период обращения Земли вокруг Солнца составляет 365.2425 дней, для устранения накапливающейся ошибки было решено ввести в календарь дополнительные «високосные года» в 366 дней. Таковыми условились считать года кратные 4. Однако этого оказалось недостаточно, поэтому для сведения ошибки к минимуму в григорианский календарь ввели дополнительную коррекцию: каждый год, который делится без остатка на 100, является високосным только тогда, когда он делится еще и на 400. Например, високосным считается 1760 год, т.к. он делится на четыре, но год 1700 високосным не является, т.к. он делится на четыре и сто, но не делится на четыреста. Зная все эти нюансы, напишите функцию, которая будет определять, является ли переданный ей год високосным. Проверьте и выведите на экран годы 1782, 1900, 2000 и 2023. Показать решение.

Решение Результат pythonCodes
# Заголовок функции.        
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 год: невисокосный
















			

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

Решение Результат pythonCodes
# Импортируем метод 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

























			

11.14.* Напишите функцию для нахождения НОД произвольного количества чисел. Затем найдите и выведите на экран наибольший общий делитель чисел 165, 435 и 300. Показать решение.

Решение Результат pythonCodes
# Заголовок функции.        
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





























			

11.15.* Напишите функцию, которая будет тестировать скорость выполнения другой функции за указанное количество итераций. В качестве именованных аргументов функция должна принимать: f – объект другой функции, args=[] – список или кортеж аргументов тестируемой функции (по умолчанию без аргументов), i=1000 – количество итераций тестирования (по умолчанию тысяча итераций). На выходе функция должна возвращать список [<имя функции>, <количество проведенных итераций>, <затраченное время>]. Протестируйте скорость выполнения встроенных функций sum и min за 20000 итераций на списке целых чисел из диапазона от 1 до 10000. Выведите результаты тестирования на экран, как показано в условии. Показать решение.

Условие pythonCodes
Функция: sum
Кол-во итераций: 20000
Время выполнения: 1.2101598

Функция: min
Кол-во итераций: 20000
Время выполнения: 1.6920748
Решение Результат pythonCodes
# Заголовок функции.        
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



























			

Итерации и генераторы

Теоретический материал по итерациям и генераторам можно почитать в нашем учебнике здесь.

12.1.* Имеется список вещественных чисел [1.3, 2.5, 3.1]. Создайте множество квадратов этих чисел, использовав для этого генератор множеств. Выведите полученное множество на экран. Показать решение.

Решение Результат pythonCodes
# Используем генератор множеств.
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}


			

12.2.* Создайте список нечетных чисел, принадлежащих отрезку [10; 20], использовав для этого генератор списков. Выведите полученный список на экран. Показать решение.

Решение Результат pythonCodes
# Используем генератор списков.
li = [x for x in range(10, 21) if x%2 != 0]
# Выводим список на экран.
print(li)
[11, 13, 15, 17, 19]


			

12.3.* Преобразуйте кортеж чисел (3.27, 5.755, 7.321) в словарь, в качестве ключей которого будут использованы числа кортежа, а значениями будут их округленные до десятых значения. Используйте для решения задачи генератор словарей. Выведите полученный словарь на экран. Показать решение.

Решение Результат pythonCodes
# Используем генератор словарей.
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}


			

12.4.* Выведите на экран элементы списка [1, 2, 3], использовав для этого функцию next(). Показать решение.

Решение Результат pythonCodes
# Получаем итератор списка.
i_li = iter([1, 2, 3])
# Выводим элементы на экран.
print(next(i_li))        
print(next(i_li))     
print(next(i_li))
1
2
3


			

12.5.* С помощью генератора-выражений получите итератор для последовательности четных чисел из диапазона от 1 до 20 включительно. В ручном режиме выведите первые три числа последовательности, использовав метод __next__ итератора. Показать решение.

Ответ. Решим двумя способами: с использованием шага в функции range и с использованием условия в генераторе-выражений.

Решение Результат pythonCodes
'''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
















			

12.6.* Напишите функцию-генератор gen_func(n), которая при вызове будет возвращать итератор для последовательности четных чисел из диапазона от 1 до n включительно. Вызовите функцию, передав аргументу значение 20, и в ручном режиме выведите первые три числа сгенерированной последовательности, использовав метод __next__ итератора. Показать решение.

Решение Результат pythonCodes
# Определяем функцию-генератор.
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












			

12.7.* Выведите на экран сумму числовых кодов символов строки 'генераторы', использовав в решении генератор списков. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
s = 'генераторы'

# Встроенная ф-ция + генератор списков.
print(sum([ord(simb) for simb in s]))
10837



			

12.8.* Дан список [(1, 2), (3+4), (5,), (6+7, 8), (9+10,)]. Оставьте в нем только элементы, которые являются кортежами и содержат более одного элемента. Используйте для решения задачи генератор списков. Выведите итоговый и результирующий списки на экран. Показать решение.

Решение Результат pythonCodes
# Сохраняем список в переменной.
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)]






			

12.9.* Сформируйте множество из всех подходящих для этого элементов списка [3, 'ok', [1, 2], (True, False), {'flag': 1}] и выведите его на экран. Используйте для решения задачи генератор множеств и класс Hashable модуля collections.abc для проверки хешируемости элементов списка. Показать решение.

Решение Результат pythonCodes
# Импортируем класс 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'}






			

12.10.* Сформируйте словарь, в котором ключами будут строковые значения чисел из диапазона целых чисел от 20 до 30 кратные трем, но не кратные пяти, а значениями квадраты этих чисел. Используйте для решения задачи генератор словарей. Показать решение.

Решение Результат pythonCodes
# Формируем множество и выводим его на экран.
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}

			

12.11.* Напишите функцию-генератор gen_fib(n: 'int>0') для генерирования последовательности из n чисел Фибоначчи. Вместо проверки аргумента просто укажите аннотацию, сообщающую о том, что аргумент должен быть целым неотрицательным числом. Используя созданный генератор, выведите на экран 10-е число Фибоначчи, а также сумму первых 10-ти чисел последовательности.

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

Решение Результат pythonCodes
# Определяем функцию-генератор.
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













































			

ООП: классы и объекты

Теоретический материал по объектно-ориентированному программированию можно почитать в нашем учебнике здесь.

13.1.* Создайте простейший в мире класс SimplePass. Затем создайте экземпляр класса и выведите на экран его тип. Показать решение.

Решение Результат pythonCodes
# Простейший в мире класс.
class SimplePass: pass

# Создаем экземпляр класса.                    
simp = SimplePass()
# Выводим тип объекта.                    
print(type(simp))
<class '__main__.main.<locals>.SimplePass'>





			

13.2.* Определите класс A, включающий:

  • строку документирования класса '''Класс A''';
  • метод set_a() для установки значения атрибута a;
  • метод get_a() для получения значения этого атрибута.
Выведите на экран документацию класса. Затем создайте первый экземпляр класса и при помощи определенных методов установите и выведите на экран значение его атрибута a. Далее создайте второй экземпляр класса, после чего также установите и выведите на экран значение атрибута a, но уже при помощи прямого доступа к атрибуту по точке. Показать решение.

Решение Результат pythonCodes
# Определяем класс.
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() для получения значения этого атрибута.
Выведите на экран документацию класса. Затем создайте экземпляр класса obj и при помощи метода экземпляра выведите на экран значение его атрибута b. Показать решение.

Решение Результат pythonCodes
# Определяем класс.
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.
Выведите на экран документацию класса. Затем создайте экземпляр класса obj, после чего при помощи соответствующих методов экземпляра выведите на экран значения его атрибутов a, b и c. Показать решение.

Решение Результат pythonCodes
# Определяем класс.
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):             
        # Инициализируем a.
        self.a = a
        # Вызываем конструктор класса B,
        # инициализируя атрибут b.
        B.__init__(self, b)
        # Инициализируем c.
        self.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, выводящий на экран словарь атрибутов своего класса.
Создайте экземпляр класса obj и, вызвав оба метода из этого экземпляра, выведите на экран словарь атрибутов класса D. Объясните различие в использовании методов. Показать решение.

Ответ. Следует помнить, что статический метод ничего не знает ни о своем классе, ни о его экземпляре. Поэтому при вызове ему нужно обязательно передавать объект класса D. А вот метод класса знает о нем, т.к. он либо вызывается через объект своего класса, либо определяет класс по его экземпляру, из которого он вызывается.

Решение Результат pythonCodes
# Определяем класс 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 и также, вызвав оба метода из этого экземпляра, выведите на экран словарь атрибутов этого класса. Объясните результаты. Показать решение.

Ответ. Опять же, следует помнить, что статический метод ничего не знает ни о своем классе, ни о его экземпляре. Поэтому при вызове ему нужно обязательно передавать объект класса. А вот метод класса знает о нем, т.к. он либо вызывается через объект своего класса, либо определяет класс по его экземпляру, из которого он вызывается. При этом оба вида методов наследуются точно также, как и обычные методы. Поэтому мы можем вызывать их из любых допустимых объектов классов или их экземпляров.

Решение Результат pythonCodes
# Определяем класс 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 установлен!'.
Выведите на экран документацию класса. Затем создайте экземпляр класса obj, после чего выведите его документацию и далее, при помощи соответствующих методов экземпляра, установите и выведите на экран значение его атрибута a. При расширении метода set_a() используйте по-очереди три варианта синтаксиса для доступа к методу суперкласса (незадействованные инструкции закомментируйте). Показать решение.

Решение Результат pythonCodes
# Определяем класс.
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(A, self).set_a(a)
        # или A.set_a(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.* Определите класс Counter, реализующий десятичный счетчик, который может увеличивать или уменьшать свое значение на единицу в заданном диапазоне, включая границы диапазона. В классе должны быть предусмотрены следующие возможности:

  • конструктор для инициализации счетчика значениями по умолчанию (стартовое значение, нижняя и верхняя границы диапазона),
  • метод для его инициализации произвольными значениями,
  • а также методы для увеличения и уменьшения текущего значения счетчика.
Все методы класса должны принимать только именованные параметры и проверять выход текущего значения счетчика за допустимый диапазон. Создайте экземпляр счетчика со значениями по умолчанию и выведите на экран его начальные параметры. Далее проверьте его работу циклом в пределах диапазона, увеличивая и выводя на экран его текущее значение от минимально возможного до максимального. Затем переустановите счетчик, задав отрицательную нижнюю и положительную верхнюю границы, а также установив положительное стартовое значение для отсчета. Опять же, проверьте его работу циклом, уменьшая и выводя на экран его текущее значение от стартового до минимально возможного. Задайте заведомо большее количество итераций циклов в обоих случаях, обеспечив прерывание их работы при попытке выхода счетчика за пределы диапазона. Показать решение.

Решение Результат pythonCodes
# Создаем класс.
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

























































			

13.9.* Определите класс Circle, представляющий окружность и включающий:

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

Решение Результат pythonCodes
# Определяем класс.
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
               
    # Получаем длину окружности.
    def get_len(self): 
        # Длина окружности.
        return round(2*3.14*self.r, 2) 
    
    # Получаем площадь окружности.
    def get_s(self): 
        # Площадь окружности.
        return round(3.14*self.r**2, 2)     

# Переводим радиус окружности из метров в см.
r = Circle.m_to_cm(2.55)
# Создаем экземпляр класса.                    
obj = Circle(r)
# Выводим на экран длину окружности.
print('Длина окружности: {}см.'.format(obj.get_len()))        
print('Площадь окружности: {}кв.см.'.format(obj.get_s()))
Длина окружности: 1601.4см.
Площадь окружности: 204178.5кв.см.
































			

13.10.* Определите класс A, включающий метод plus() для сложения двух чисел, и класс B, включающий метод minus() для нахождения разности двух чисел. Оба метода должны инициализировать атрибуты last_res своих экземпляров списками формата [a, b, a op b] и возвращать результат арифметической операции. Затем определите класс C, содержащий конструктор для инициализации его атрибутов plus и minus соответствующими объектами методов первых двух классов. Далее создайте экземпляр класса obj, после чего найдите сумму и разность двух чисел, используя возможности созданного экземпляра. Показать решение.

Решение Результат pythonCodes
# Определяем класс A.
class A: 

    # Метод получения суммы 2-х чисел.
    def plus(self, a, b):            
        # Последняя операция.                
        self.last_res = [a, b, a + b]
        # Возвращаем результат.
        return self.last_res[2]

# Определяем класс B.
class B: 

    # Метод получения разности 2-х чисел.
    def minus(self, a, b):            
        # Последняя операция.                
        self.last_res = [a, b, a - b]
        # Возвращаем результат.
        return self.last_res[2]        

# Определяем класс C.
class C: 
                           
    # Конструктор класса C.
    def __init__(self):             
        # Создаем экземпляр класса A.
        p = A()
        # Инициализируем объектом метода.
        self.plus = p.plus
        # Создаем экземпляр класса B.
        m = B()
        # Инициализируем объектом метода.
        self.minus = m.minus                

# Создаем экземпляр класса.                    
obj = C()

# Получаем и выводим сумму аргументов.                    
print('3 + 5 =', obj.plus(3, 5))                    
# Получаем и выводим разность аргументов.                    
print('3 - 5 =', obj.minus(3, 5))
3 + 5 = 8
3 - 5 = -2






































			

13.11.* Определите суперкласс Сотрудник, включающий:

  • конструктор, инициализирующий имя работника, его должность (по умолчанию None) и оклад (по умолчанию 0);
  • метод экземпляра для повышения оклада на какую-то часть (например, на 0.3, т.е. на 30%) с округлением результата до копеек;
  • магический метод __str__ для перегрузки строкового представления объекта, который должен выводить данные о работнике в формате 'Атрибут: объект.атрибут' по одной записи на каждой строке.
Также определите подкласс Менеджер, наследующий суперкласс Сотрудник и переопре­деляющий метод повышения оклада таким образом, чтобы он еще больше повышал оклад за счет дополнительного бонуса в виде какой-то части оклада. Далее:
  • создайте экземпляр иван_менеджер созданного подкласса с начальным окладом в 1700 рублей;
  • повысьте сотруднику оклад за счет стандартной надбавки в 0.335 и бонуса за должность в 0.25;
  • выведите строковое представление объекта экземпляра с информацией о сотруднике на экран.
Показать решение.

Решение Результат pythonCodes
# Суперкласс.
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 руб.





























			

Модули и пакеты

Теоретический материал по импортированию, модулям и пакетам можно почитать в нашем учебнике здесь.

14.1.* Импортируйте из стандартной библиотеки модуль math. Используя необходимые атрибуты модуля выведите на экран результаты вычисления выражений: cosπ (см. косинус и число Пи), √e (см. число e) и 5! (см. факториал). Показать решение.

Решение Результат pythonCodes
# Импортируем модуль 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(), которая как раз и вернет текущее время. Показать решение.

Решение Результат pythonCodes
# Импортируем из модуля datetime класс datetime.
from datetime import datetime         

# Выводим текущее время.
print(datetime.now().time())
14:10:32.657780



			

14.3.* Импортируйте из модуля random стандартной библиотеки функции randint и choice, использовав для них псевдонимы rnd и chc. Создайте список li и заполните его пятью случайными целыми числами от 1 до 20. Выведите на экран сам список, а также случайный элемент списка. Показать решение.

Решение Результат pythonCodes
# Импортируем требуемые функции.        
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.4.* Напишите функцию без параметров py_version, выводящую на экран текущую версию интерпретатора в формате «Python major.micro.minor.». Для выполнения задания импортируйте в локальную область видимости функцию version_info модуля sys стандартной библиотеки. Показать решение.

Решение Результат pythonCodes
# Функция получения используемой версии Питона.
def py_version(): 
    # Импортируем нужную переменную.
    from sys import version_info
    # Выводим версию Питона на экран.                    
    print('Python {0[0]}.{0[1]}.{0[2]}.'.format(version_info))        

# Вызываем функцию.
py_version()
Python 3.10.2.







			

14.5.* Напишите функцию imp_mods(mods), импортирующую в глобальную область видимости текущего модуля необходимые пакеты и модули. В качестве аргумента функция должна принимать список имен пакетов и модулей для импорта. Импортируйте при помощи созданной функции модули random и math, а затем выведите на экран факториал случайного положительного целого числа не превышающего десяти. Показать решение.

Решение Результат pythonCodes
# Объявляем функцию.
def imp_mods(mods):
                    
    # Импортируем ф-цию в лок. обл. видимости.
    from importlib import import_module
    # Получаем словарь глоб-ных переменных модуля.
    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.* Используя соответствующую встроенную функцию создайте в папке скрипта файл li.py и запишите туда строку li_1 = [1, 2]. Далее, используя менеджер контекста, допишите в файл строку li_2 = ['red', 'green'] и, не выходя за область видимости менеджера, выведите на экран содержимое файла используя для чтения цикл for. Показать решение.

Решение Результат pythonCodes
# Создаем и записываем файл 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: print(s) 
li_1 = [1, 2]

li_2 = ['red', 'green']












			

15.2.* Используя возможности модуля pathlib cоздайте в каталоге скрипта каталог test_dir, а в нем пустой файл test_file.txt. Запишите в файл строку 'Python Ok или Ok Python.', после чего выведите содержимое файла на экран. Удалите каталог и файл. Результаты всех операций должны отображаться на экране, как показано в кодовом блоке ниже. Показать решение.

Условие pythonCodes
Каталог и файл созданы!
Нажмите любую клавишу...

Python Ok или Ok Python?

Файл записан и прочитан!
Нажмите любую клавишу...

Все удалено!
Нажмите любую клавишу...
Решение Результат pythonCodes
# Импортируем из модуля класс.
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.3.* Напишите скрипт, в котором объявите три функции:

  • 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, которые импортируйте в глобальное пространство скрипта. Показать решение.

Условие pythonCodes
Счет N3335 создан, баланс пополнен!
Текущий баланс счета N3335: 5000 руб.

Счет N3336 создан, баланс пополнен!
Текущий баланс счета N3336: 300 руб.

Баланс счета N3336 обновлен!
Текущий баланс счета N3336: 1000 руб.
Решение Результат pythonCodes
# Импортируем модуль 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.4.* Выполните следующее упражнение:

  • создайте в папке скрипта корневой каталог упражнения 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. Выполняйте упражнение поэтапно, при необходимости удаляя корневой каталог упражнения воизбежание ошибок. Показать решение.

Решение pythonCodes
# Импортируем модуль.
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.5.* Напишите функцию 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'). Показать решение.

Решение pythonCodes
# Импортируем класс в глобальное пространство.
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'. Для решения задачи используйте в теле функции инструкцию try/except/else. Показать решение.

Решение Результат pythonCodes
# Определяем функцию.   
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. Показать решение.

Решение Результат pythonCodes
# Функция записи и закрытия файла.
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. Показать решение.

Решение Результат pythonCodes
# Определяем функцию.
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'









			

Утилита pip и виртуальные окружения

Теоретический материал по работе с менеджером пакетов pip и виртуальными окружениями можно почитать в нашем учебнике здесь.

17.1.* Выполните в консоли своей операционной системы с помощью менеджера пакетов pip следующее упражнение:

  • выведите текущую версию pip;
  • выведите справку по нему;
  • выведите список пакетов, установленных в текущем окружении;
  • установите пакет cowsay;
  • выведите информацию о пакете cowsay;
  • повторно выведите список пакетов, установленных в окружении;
  • удалите пакет cowsay;
  • еще раз выведите список пакетов, установленных в окружении.

Если имеется такая возможность, выполните упражнение как в ОС Windows, так и в ОС Ubuntu. Показать решение.

Ответ. Я выполнял упражнение в командной оболочке ОС Windows в виртуальном окружении созданного ранее проекта. В командной bash-оболочке ОС Ubuntu упражение выполняется в принципе также, но только с использованием обычных слешей вместо обратных. В случае выполнения упражнения вне виртуального окружения в ОС Ubuntu используйте слово python3 вместо обычного python.

Решение pythonCodes
(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) – удаление пакета.

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

Решение pythonCodes
# Импортируем требуемый модуль станд. библиотеки.
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. Показать решение.

Решение pythonCodes
-- ОС 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. Показать решение.

Решение pythonCodes
-- ОС Windows --

D:\python\my_prj&gt;python -m venv .\venv_2

D:\python\my_prj&gt;.\venv_2\Scripts\activate.bat

(venv_2) D:\python\my_prj&gt;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&gt;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&gt;pip3 list
Package    Version
---------- -------
Pillow     9.4.0
pip        22.3.1
setuptools 65.5.0

(venv_2) D:\python\my_prj&gt;pip3 freeze&gt;requirements.txt

(venv_2) D:\python\my_prj&gt;deactivate

D:\python\my_prj&gt;python -m venv .\venv_3

D:\python\my_prj&gt;.\venv_3\Scripts\activate.bat

(venv_3) D:\python\my_prj&gt;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&gt;pip3 list
Package    Version
---------- -------
Pillow     9.4.0
pip        22.3.1
setuptools 65.5.0

(venv_3) D:\python\my_prj&gt;deactivate
D:\python\my_prj&gt;


-- ОС 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&gt;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. Показать решение.

Решение pythonCodes
-- ОС 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.* Дана строка целых чисел '36 787 0 9993754\n2253', отделённых друг от друга неравномерным количеством пробелов и переводов строк. Необходимо для каждого числа, начиная с последнего и заканчивая первым, вывести на экран в отдельной строке его квадратный корень с точностью до пяти знаков после десятичной точки. Показать решение.

Решение Результат pythonCodes
# Сохраняем строку в переменной.
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


			

18.2.* С клавиатуры вводится целое положительное число n < 10000. Напишите скрипт, который будет находить и выводить на экран минимальное положительное целое число q такое, что произведение цифр этого числа будет в точности равняться числу n. В случае отсутствия такого числа q скрипт должен выводить на экран сообщение «Искомого числа q не существует!». Например, для числа 70 искомым числом будет 257. Показать решение.

Ответ. Для решения задачи нужно догадаться, что цифрами искомого числа q будут все делители (и простые и составные) числа n меньшие десяти (включая единицу, на которую делятся все числа). А поскольку нам требуется найти минимальное из таких чисел, то найденные делители числа n должны идти в числе q в порядке возрастания. Для чисел от единицы до девяти искомыми числами будут 11, 12 и т.д.

Решение Результат pythonCodes
# Требуем ввода допустимого значения.    
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







































			

18.3.* Представьте, что у вас имеется некоторое количество камней n (1 ≤ n ≤ 100) известного веса w1, w2, w3, ..., где wi – это целые положительные числа от 1 до 1000000 включительно. Напишите скрипт, который распределит камни в две кучи так, чтобы разность весов этих двух куч была минимальной. Количество камней и веса должны генерироваться случайным образом. Сам скрипт должен возвращать число, равное минимальной разности весов двух куч. Например, для трех камней с весами 15, 20 и 3 скрипт должен возвращать число 2. На выполнение скрипта дается не более одной секунды. Показать решение.

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

Решение Результат pythonCodes
# Импортируем 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 сек.





















































			

Первые скрипты и программы

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

Шаблон №1.* Напишите скрипт hello_world.py, который будет выводить на экран обычное приветствие «Привет, мир!». Оформите содержимое скрипта следующим образом:

  • В начале скрипта напишите три комментария, описывающие порядок импортирования модулей и пакетов и начинающиеся словами «Импортируем модули ...».
  • За ними определите простейшую функцию simple_func и простейший класс SimpleClass, использовав инструкцию pass.
  • Далее определите основную функцию скрипта main, в теле которой вызовите функцию simple_func, создайте экзмепляр класса SimpleClass, осуществите вывод целевого сообщения и завершите все пустой инструкцией input, чтобы окно скрипта автоматически не закрывалось после вывода сообщения.
  • В конец скрипта поместите условную инструкцию, которая будет осуществлять вызов основной функции, но только в том случае, если модуль будет запускаться как основная программа, а не импортироваться другим модулем.
Посмотрите решение данной задачи и запомните один из способов оформления программ: импорт модулей (стандартная библиотека, сторонние модули, собственные модули), определение констант, функций и классов, определение основной функции программы, содержащей последовательность действий для реализации целей программы, и, в самом низу модуля, вспомогательные инструкции с вызовом основной функции для запуска всей программы. Если модуль создается с возможностью использования не только в качестве программы, но и в качестве импорти­руемого модуля, вызов основной функции следует помещать в тело условной инструкции, проверяющей условие « __name__ == '__main__'». Показать решение.

Решение Результат pythonCodes
# Импортируем модули стандартной библиотеки.
# Импортируем модули сторонних библиотек.    
# Импортируем собственные модули.     

# Функция «Пустышка».
def simple_func(): pass   
# Класс «Пустышка».
class SimpleClass: pass      

# Центральная функция программы.
def main():
    
    # Вызываем функцию.
    simple_func()      
    # Создаем экземпляр класса.
    obj = SimpleClass()        
    # Выводим приветствие.    
    print('Привет, Мир!')
    # Запрос ввода, чтобы программа не закрылась.
    input()
    
# Если модуль не импортируется, а 
# запускается как основная программа.
if __name__ == '__main__':
    # Вызываем основную функцию программы.
    main()
Привет, Мир!
























			

Шаблон №2.* Дополните код предыдущей задачи таким образом, чтобы после показа целевого сообщения пользователю выводился запрос на продолжение работы программы (символ 'y') либо выход из нее (символ 'n'). Для решения задачи используйте цикл с флагом «while flag:», прерывающийся по значению флага, либо бесконечный цикл «while True:», регулируемый условной инструкцией if в теле цикла. Показать решение.

Решение Результат pythonCodes
# Импортируем модули стандартной библиотеки.
# Импортируем модули сторонних библиотек.    
# Импортируем собственные модули.     

# Функция «Пустышка».
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
































			

Менеджер пакетов 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. Показать решение.

Условие pythonCodes

Менеджер пакетов 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/ !


Для продолжения нажмите 'Ввод'...

			
Решение Результат pythonCodes
# Импортируем требуемые модули станд. библиотеки.
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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Таблица умножения.* Напишите программу «тренажер_таблицы_умножения.py» для заучивания таблицы умножения. Программа должна:

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

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

Условие pythonCodes
 Тренажер таблицы умножения, версия 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 >


			
Решение Результат pythonCodes
# Функция вывода на экран таблицы умножения.
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(): 

    # Импортируем метод randint из модуля random.
    from random import randint

    # Организуем бесконечный цикл с прерыванием через 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 >
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
















 

Игра «Камень, ножницы, бумага».* Напишите программу для игры в «Камень, ножницы, бумага» с компьютером. Оформление и общий алгоритм хода игры представлены в примере запуска программы ниже. Для решения задачи вам понадобятся модули random, sys (выход из программы через sys.exit()), time (использование задержек через time.sleep(0.5)). Что касается функций, то их можете не использовать вообще, оформив все через циклы с прерыванием. Показать решение.

Условие pythonCodes
 Игра «Камень, ножницы, бумага», версия 1.0.

 ----------------------------------------------

 Каждый из игроков может выбрать «Камень»,
 «Ножницы» или «Бумагу». Победитель определяется
 по следующим правилам: «Камень» бьет «Ножницы»,
 «Ножницы» — «Бумагу», а «Бумага» бьет «Камень».

 ----------------------------------------------

 Победы: 0, проигрыши 0, ничьи 0.

 Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
 > к

 «Камень» против ...
 1...
 2...
 3...
 «Бумага»

 Вы проиграли!

 ----------------------------------------------

 Победы: 0, проигрыши 1, ничьи 0.

 Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
 > н

 «Ножницы» против ...
 1...
 2...
 3...
 «Бумага»

 Вы выиграли!

 ----------------------------------------------

 Победы: 1, проигрыши 1, ничьи 0.

 Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
 > б

 «Бумага» против ...
 1...
 2...
 3...
 «Камень»

 Вы выиграли!

 ----------------------------------------------

 Победы: 2, проигрыши 1, ничьи 0.

 Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
 > в

 Спасибо за игру!


			
Решение Результат pythonCodes
# Выводим название программы и версию.
print('\n Игра «Камень, ножницы, бумага», версия 1.0.')

print('\n ----------------------------------------------\n')

print(""" Каждый из игроков может выбрать «Камень», 
 «Ножницы» или «Бумагу». Победитель определяется 
 по следующим правилам: «Камень» бьет «Ножницы», 
 «Ножницы» — «Бумагу», а «Бумага» бьет «Камень».""")

# Импортируем требуемые модули.
import random, sys, time

# Счетчики выигрышей, проигрышей и ничьих.
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.

 Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?
 > в

 Спасибо за игру!
























































			

Квадратное уравнение.* Напишите программу, которая по введенным пользователем коэффициентам квадратного уравнения ax2 + bx + c = 0 будет выдавать ответ с точностью до тысячных и готовое решение. Программа должна:

  • выводить свое название и версию, а также краткое описание;
  • принимать на ввод коэффициенты уравнения в виде действительных чисел, например, -3.27, или в виде обыкновенных дробей, например, -5/7;
  • проверять вводимые значения на допустимость ввода, предлагая в случае ошибки повторный ввод коэффициента или запрашивая выход из программы в противном случае;
  • выводить решение с пояснениями включая случаи, когда один или несколько коэффициентов равны нулю;
  • после вывода решения выводить запрос на продолжение работы программы или выход из нее.
Показать решение.

Условие pythonCodes
 Решение квадратных уравнений, версия 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):


			
Решение Результат pythonCodes
# Импортируем нужные компоненты.
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):








































































































































































			

Игра «Блек-джек».* Напишите программу для игры в «Блек-джек» с компьютером. Ознакомиться с правилами игры можно на википедии. Здесь же мы будем придерживаться следующей линии.

  • В качестве диллера должен выступать компьютер.
  • Банк игрока должен составлять 5000.
  • Первая карта диллера должна быть скрыта от игрока (т.е. находится на столе рубашкой вверх), остальные открыты (американский вариант игры).
  • После раздачи у игрока должна быть единовременная возможность увеличить ставку.
  • После того, как игрок наберет необходимое количество очков и больше не будет запрашивать карту, диллер должен запрашивать карты до тех пор, пока сумма его очков не превысит 16.
  • Подсчет очков: цифровые карты – от 2 до 10 очков соответственно их номиналам, фигурные карты (валет, дама и король) – 10 очков, туз 11 очков, если это не приводит к перебору, и 1 очко в противном случае.

Коды мастей: 9829 – черва, 9830 – бубна, 9824 – пика, 9827 – трефа. Показать решение.

Условие pythonCodes
Карточная игра «Блек-джек», версия 1.0.

----------------------------------------------
Блек-джек – это классическая карточная игра,
известная также как «двадцать одно». Цель игры –
набрать количество очков, как можно более близкое
к 21, но не больше.

Подсчет очков:
цифровые карты – от 2 до 10 очков соответственно их номиналам,
фигурные карты (валет, дама и король) – 10 очков,
туз – 11 очков, если не будет перебора, и 1 очко в противном случае.

----------------------------------------------

Ваш банк: 5000
Сделайте вашу ставку (от 1 до 5000 или «q» – выход) > 100
Ваша ставка: 100

Диллер: ???
 ___   ___
|## | |Q  |
|###| | ♦ |
|_##| |__Q|

Игрок: 8
 ___   ___
|4  | |4  |
| ♥ | | ♦ |
|__4| |__4|

0 - хватит, 1 - еще, 2 – повысить ставку > 1
Вам выпала карта A масти ♥.

Диллер: ???
 ___   ___
|## | |Q  |
|###| | ♦ |
|_##| |__Q|

Игрок: 19
 ___   ___   ___
|4  | |4  | |A  |
| ♥ | | ♦ | | ♥ |
|__4| |__4| |__A|

0 - хватит, 1 - еще > 0

***** Итог игры *****

Диллер: 20
 ___   ___
|K  | |Q  |
| ♦ | | ♦ |
|__K| |__Q|

Игрок: 19
 ___   ___   ___
|4  | |4  | |A  |
| ♥ | | ♦ | | ♥ |
|__4| |__4| |__A|

Вы проиграли!
Нажмите Enter для продолжения ...

Ваш банк: 4900
Сделайте вашу ставку (от 1 до 4900 или «q» – выход) >

			
Решение Результат pythonCodes
# Выводим название программы и версию.
print('\nКарточная игра «Блек-джек», версия 1.0.')

print('\n----------------------------------------------')

print("""Блек-джек – это классическая карточная игра, 
известная также как «двадцать одно». Цель игры – 
набрать количество очков, как можно более близкое
к 21, но не больше. 

Подсчет очков: 
цифровые карты – от 2 до 10 очков соответственно их номиналам,
фигурные карты (валет, дама и король) – 10 очков,
туз – 11 очков, если не будет перебора, и 1 очко в противном случае.""")

print('\n----------------------------------------------')

# Импортируем требуемые модули.
import random, sys

# Задаем значения констант.

# Получаем символ '♥'.
HEARTS = chr(9829) 
# Получаем символ '♦'.
DIAMONDS = chr(9830) 
# Получаем символ '♠'.
SPADES = chr(9824) 
# Получаем символ '♣'.
CLUBS = chr(9827) 
# Обратная сторона карты.
BACKSIDE = 'backside'

# Определяем функции программы.

# Запрос ставки у игрока на текущий раунд.
def get_bet(max_bet):
    
    """Функция принимает текущее значение банка игрока."""
    
    # Продолжаем, пока не будет введено допустимое значение.
    while True:  
        # Выводим запрос ставки, а затем сохраняем выбор 
        # пользователя в переменной, переведя строку в нижний 
        # регистр и удалив начальные и конечные пробелы.
        s = 'Сделайте вашу ставку (от 1 до {} или «q» – выход) > '
        bet = input(s.format(max_bet)).lower().strip()
        
        # Если пользователь захотел завершить игру.
        if bet == 'q': sys.exit()
        
        # Если введено не десятичное число.
        if not bet.isdecimal():
            # Просим сделать выбор.
            print('Недопустимый выбор!')
            # Начинаем цикл заново.
            continue  
        
        # Если было введено допустимое значение,
        # преобразуем строку в число для проверки.
        bet = int(bet)
        # Проверяем возможность ставки.
        if 1 <= bet <= max_bet:
            # Возвращаем ставку игрока.
            return bet  
        elif bet == 0:
            print('Нулевые ставки запрещены!')
        else:
            print('В вашем банке не хватает средств!')
        
# Функция формирует колоду из 52 карт.
def get_deck():
    
    """Функция формирует колоду из 52 карт, перемешивает ее, 
    и возвращает в виде списка кортежей (номинал, масть)."""
    
    # Список для хранения 52 карт колоды (deck – колода).
    # Хранить будем в виде кортежей (номинал, масть)
    deck = []
    
    # Внешний цикл для мастей колоды (suit – масть).
    for suit in (HEARTS, DIAMONDS, SPADES, CLUBS):
        
        # Для числовых номиналов карт от 2 до 10.
        for rank in range(2, 11):
            # Добавляем числовые карты в колоду.
            deck.append((str(rank), suit))  
        
        # Для фигурных номиналов карт и тузов.
        for rank in ('J', 'Q', 'K', 'A'):
            # Добавляем фигурные карты и тузы.
            deck.append((rank, suit))  
    
    # Перемешиваем колоду.
    random.shuffle(deck)
    # Возвращаем ее.
    return deck


# Функция отображает карты игрока и диллера на экране.
def display_hands(player_hand, dealer_hand, show_dealer_hand):
    
    """Отображаем карты игрока и дилера. Скрываем первую карту
    дилера, если show_dealer_hand равно False."""
        
    # Если пора открыть карты.
    if show_dealer_hand:
        # Выводим количество очков диллера.
        print('Диллер:', get_hand_value(dealer_hand))
        # Вскрываем (отображаем) все карты диллера.
        display_cards(dealer_hand)
    # Если игра еще продолжается.
    else:
        # Очки пока не отображаем (одна карта скрыта).
        print('\nДиллер: ???')
        # Первую карту дилера не отображаем.
        display_cards([BACKSIDE] + dealer_hand[1:])

    # Все карты игрока отображаются всегда.
    print('Игрок:', get_hand_value(player_hand))
    display_cards(player_hand)


# Функция подсчитывает итоговые очки (стоимость всех карт).
def get_hand_value(cards):
    
    """ Цифровые карты стоят от 2 до 10 очков, фигурные 
    карты — 10, тузы — 11 или 1 очко (функция рассчитывает 
    подходящую стоимость карты)."""
    
    # Стартовое количество очков.
    value = 0
    # Стартовое количество тузов.
    number_of_aces = 0

    # Добавляем стоимость карты — не туза.
    for card in cards:
        # card — это кортеж (номинал, масть).
        rank = card[0]  
        # Для туза.
        if rank == 'A':
            # Увеличиваем счетчик тузов на 1.
            number_of_aces += 1
        # Для фигурной карты.
        elif rank in ('K', 'Q', 'J'):  
            # Фигурные карты стоят 10 очков.
            value += 10
        # Для обычной карты.
        else:
            # Стоимость числовых карт равна их номиналу.
            value += int(rank)  

    # Добавляем минимальную стоимость всех тузов.
    value += number_of_aces  
    
    # Теперь пробуем добавить еще 10 очков. 
    for i in range(number_of_aces):
        # Если можно добавить еще 10.
        if value + 10 <= 21: 
            # Реализуем полную стоимость туза.
            value += 10
            
    # Возвращаем количество очков.
    return value


# Функция отображения изображений карт на экране.
def display_cards(cards):
    
    """Отображает все карты из переданного списка 
    карт (список кортежей)."""
    
    # Для рисования карты используем 4 строки.
    rows = ['', '', '', '', '']  

    # Циклом проходимся по кортежам списка.
    for i, card in enumerate(cards):
        # Выводим верхнюю строку карты.
        rows[0] += ' ___  '  
        # Выводим рубашку карты:
        if card == BACKSIDE:
            rows[1] += '|## | '
            rows[2] += '|###| '
            rows[3] += '|_##| '
        # Выводим лицевую сторону карты.
        else:
            # card — это кортеж (rank, suit).
            rank, suit = card  
            rows[1] += '|{} | '.format(rank.ljust(2))
            rows[2] += '| {} | '.format(suit)
            rows[3] += '|_{}| '.format(rank.rjust(2, '_'))

    # Выводим все строки на экран:
    for row in rows: print(row)


# Функция запрашивает у пользователя выбор хода.
def get_move(player_hand, money):
    
    """Спрашиваем, какой ход хочет сделать игрок, и возвращаем
    1, если он хочет взять еще карту, 0, если ему хватит, 
    и 2, если он решил увеличить ставку."""
    
    # Продолжается, пока игрок не сделает допустимый ход.
    while True:  
        
        # Определяем, какие действия доступны игроку:
        moves = ['0 - хватит', '1 - еще']

        # После первого хода у игрока на руках будет 2 карты,
        # поэтому он сможет повысить сделанную вначале ставку. 
        if len(player_hand) == 2 and money > 0:
            # Добавим эту возможность.
            moves.append('2 – повысить ставку')

        # Просим игрока сделать выбор.
        move = input(', '.join(moves) + ' > ')
        
        # Если игрок выбрал .
        if move in ('0', '1'): 
            # Возвращаем выбор.
            return move  
        
        # После 1-го хода возможно повышение ставки.
        if move == '2' and '2 – повысить ставку' in moves:
            # Возвращаем выбор.
            return move  


# Конец блока определения функций.


# Центральная функция программы.
def main():
    
    # Доступные средства игрока.
    money = 5000
    
    # Основной цикл игры.
    while True:  
        
        # Проверяем, не закончились ли у игрока деньги.
        if money <= 0:
            print('\n\nПополните банк, тогда продолжим!')
            print('Cпасибо за игру!')
            input('Нажмите любую клавишу для выхода ...')
            sys.exit()

        # Даем возможность игроку сделать ставку на раунд.
        print('\nВаш банк: {}'.format(money))
        bet = get_bet(money)

        # Сдаем дилеру и игроку по две карты из колоды.
        # Формируем и перемешиваем колоду карт.
        deck = get_deck()
        # Даем 2 карты на руки диллеру.
        dealer_hand = [deck.pop(), deck.pop()]
        # Даем 2 карты на руки игроку.
        player_hand = [deck.pop(), deck.pop()]

        # Обработка действий игрока.
        print('Ваша ставка:', bet)
        
        # Выполняем цикл до тех пор, пока игрок не
        # скажет «хватит» или у него не получится перебор.
        while True:  
            # Отображаем карты игрока и диллера на экране.                          
            display_hands(player_hand, dealer_hand, False)
            
            # Проверка на перебор у игрока.
            if get_hand_value(player_hand) > 21: break

            # Получаем ход игрока: 1, 0 или 2.
            move = get_move(player_hand, money - bet)

            # Обработка действий игрока.
            if move == '2':
                # Пытаемся увеличить ставку игрока.
                add_bet = get_bet(min(bet, (money - bet)))
                bet += add_bet
                print('Ваша ставка увеличена до {}.'.format(bet))
                print('Ваша ставка:', bet)

            # После раздачи игрок может продолжить или увеличить ставку.
            if move in ('1', '2'):
                # Добавляем ему еще одну карту.
                new_card = deck.pop()
                rank, suit = new_card
                print('Вам выпала карта {} масти {}.'.format(rank, suit))
                player_hand.append(new_card)

                # Если у игрока перебор, идем в начало цикла.
                if get_hand_value(player_hand) > 21: continue

            # Передаем ход диллеру.
            if move in ('0', '2'): break

        # Если у игрока не перебор, разбираемся с диллером.
        if get_hand_value(player_hand) <= 21:
            
            # Дилер берет карты, пока сумма не превысит 16.
            while get_hand_value(dealer_hand) < 17:
                
                # Выводим сообщение на экран.
                print('Диллер берет еще карту ...')
                
                # Добавляем еще карту.
                dealer_hand.append(deck.pop())
                # Отображаем их все на экране (1-я пока скрыта).
                display_hands(player_hand, dealer_hand, False)
                
                # Если у диллера перебор, подводим итог игры.
                if get_hand_value(dealer_hand) > 21: break  
                
                # Ждем ввода от пользователя.
                input('Нажмите Enter для продолжения ...')
                
        print('\n***** Итог игры *****\n')
        
        # Отображаем итоговые карты на руках игрока и диллера.
        display_hands(player_hand, dealer_hand, True)
        # Результат игрока.
        player_value = get_hand_value(player_hand)
        # Результат диллера.
        dealer_value = get_hand_value(dealer_hand)
        
        # Проверяем, игрок выиграл, проиграл или сыграл вничью.
        if dealer_value > 21:
            print('У диллера перебор! Вы выиграли ${}!'.format(bet))
            # Добавляем выигрыш в банк игрока.
            money += bet
        elif player_value > 21:
            print('У вас перебор! Вы проиграли!')
            # Вычитаем сумму проигрыша из банка игрока.
            money -= bet
        elif player_value < dealer_value:
            print('Вы проиграли!')
            # Вычитаем сумму проигрыша из банка игрока.
            money -= bet        
        elif player_value > dealer_value:
            print('Вы выиграли ${}!'.format(bet))
            # Добавляем выигрыш в банк игрока.
            money += bet
        elif player_value == dealer_value:
            # Просто выводим сообщение, не трогая банк.
            print('Ничья. Ставка возвращается в ваш банк!')

        input('Нажмите Enter для продолжения ...')
        
# Если программа не импортируется, а запускается, производим запуск.
if __name__ == '__main__':
    main()
Карточная игра «Блек-джек», версия 1.0.

----------------------------------------------
Блек-джек – это классическая карточная игра,
известная также как «двадцать одно». Цель игры –
набрать количество очков, как можно более близкое
к 21, но не больше.

Подсчет очков:
цифровые карты – от 2 до 10 очков соответственно их номиналам,
фигурные карты (валет, дама и король) – 10 очков,
туз – 11 очков, если не будет перебора, и 1 очко в противном случае.

----------------------------------------------

Ваш банк: 5000
Сделайте вашу ставку (от 1 до 5000 или «q» – выход) > 55
Ваша ставка: 55

Диллер: ???
 ___   ___
|## | |J  |
|###| | ♣ |
|_##| |__J|

Игрок: 6
 ___   ___
|4  | |2  |
| ♦ | | ♠ |
|__4| |__2|

0 - хватит, 1 - еще, 2 – повысить ставку > 1
Вам выпала карта 3 масти ♠.

Диллер: ???
 ___   ___
|## | |J  |
|###| | ♣ |
|_##| |__J|

Игрок: 9
 ___   ___   ___
|4  | |2  | |3  |
| ♦ | | ♠ | | ♠ |
|__4| |__2| |__3|

0 - хватит, 1 - еще > 1
Вам выпала карта 10 масти ♦.

Диллер: ???
 ___   ___
|## | |J  |
|###| | ♣ |
|_##| |__J|

Игрок: 19
 ___   ___   ___   ___
|4  | |2  | |3  | |10 |
| ♦ | | ♠ | | ♠ | | ♦ |
|__4| |__2| |__3| |_10|

0 - хватит, 1 - еще > 0

***** Итог игры *****

Диллер: 20
 ___   ___
|Q  | |J  |
| ♣ | | ♣ |
|__Q| |__J|

Игрок: 19
 ___   ___   ___   ___
|4  | |2  | |3  | |10 |
| ♦ | | ♠ | | ♠ | | ♦ |
|__4| |__2| |__3| |_10|

Вы проиграли!
Нажмите Enter для продолжения ...

Ваш банк: 4945
Сделайте вашу ставку (от 1 до 4945 или «q» – выход) > 500
Ваша ставка: 500

Диллер: ???
 ___   ___
|## | |6  |
|###| | ♠ |
|_##| |__6|

Игрок: 14
 ___   ___
|5  | |9  |
| ♠ | | ♠ |
|__5| |__9|

0 - хватит, 1 - еще, 2 – повысить ставку > 1
Вам выпала карта K масти ♣.

Диллер: ???
 ___   ___
|## | |6  |
|###| | ♠ |
|_##| |__6|

Игрок: 24
 ___   ___   ___
|5  | |9  | |K  |
| ♠ | | ♠ | | ♣ |
|__5| |__9| |__K|


***** Итог игры *****

Диллер: 13
 ___   ___
|7  | |6  |
| ♣ | | ♠ |
|__7| |__6|

Игрок: 24
 ___   ___   ___
|5  | |9  | |K  |
| ♠ | | ♠ | | ♣ |
|__5| |__9| |__K|

У вас перебор! Вы проиграли!
Нажмите Enter для продолжения ...

Ваш банк: 4445
Сделайте вашу ставку (от 1 до 4445 или «q» – выход) > 1000
Ваша ставка: 1000

Диллер: ???
 ___   ___
|## | |7  |
|###| | ♥ |
|_##| |__7|

Игрок: 4
 ___   ___
|2  | |2  |
| ♠ | | ♦ |
|__2| |__2|

0 - хватит, 1 - еще, 2 – повысить ставку > 1
Вам выпала карта 9 масти ♥.

Диллер: ???
 ___   ___
|## | |7  |
|###| | ♥ |
|_##| |__7|

Игрок: 13
 ___   ___   ___
|2  | |2  | |9  |
| ♠ | | ♦ | | ♥ |
|__2| |__2| |__9|

0 - хватит, 1 - еще > 1
Вам выпала карта 8 масти ♣.

Диллер: ???
 ___   ___
|## | |7  |
|###| | ♥ |
|_##| |__7|

Игрок: 21
 ___   ___   ___   ___
|2  | |2  | |9  | |8  |
| ♠ | | ♦ | | ♥ | | ♣ |
|__2| |__2| |__9| |__8|

0 - хватит, 1 - еще > 0
Диллер берет еще карту ...

Диллер: ???
 ___   ___   ___
|## | |7  | |5  |
|###| | ♥ | | ♣ |
|_##| |__7| |__5|

Игрок: 21
 ___   ___   ___   ___
|2  | |2  | |9  | |8  |
| ♠ | | ♦ | | ♥ | | ♣ |
|__2| |__2| |__9| |__8|

Нажмите Enter для продолжения ...

***** Итог игры *****

Диллер: 17
 ___   ___   ___
|5  | |7  | |5  |
| ♦ | | ♥ | | ♣ |
|__5| |__7| |__5|

Игрок: 21
 ___   ___   ___   ___
|2  | |2  | |9  | |8  |
| ♠ | | ♦ | | ♥ | | ♣ |
|__2| |__2| |__9| |__8|

Вы выиграли $1000!
Нажмите Enter для продолжения ...

Ваш банк: 5445
Сделайте вашу ставку (от 1 до 5445 или «q» – выход) > 1000
Ваша ставка: 1000

Диллер: ???
 ___   ___
|## | |A  |
|###| | ♦ |
|_##| |__A|

Игрок: 13
 ___   ___
|8  | |5  |
| ♠ | | ♥ |
|__8| |__5|

0 - хватит, 1 - еще, 2 – повысить ставку > 1
Вам выпала карта 6 масти ♠.

Диллер: ???
 ___   ___
|## | |A  |
|###| | ♦ |
|_##| |__A|

Игрок: 19
 ___   ___   ___
|8  | |5  | |6  |
| ♠ | | ♥ | | ♠ |
|__8| |__5| |__6|

0 - хватит, 1 - еще > 0

***** Итог игры *****

Диллер: 20
 ___   ___
|9  | |A  |
| ♦ | | ♦ |
|__9| |__A|

Игрок: 19
 ___   ___   ___
|8  | |5  | |6  |
| ♠ | | ♥ | | ♠ |
|__8| |__5| |__6|

Вы проиграли!
Нажмите Enter для продолжения ...

Ваш банк: 4445
Сделайте вашу ставку (от 1 до 4445 или «q» – выход) > 2000
Ваша ставка: 2000

Диллер: ???
 ___   ___
|## | |J  |
|###| | ♥ |
|_##| |__J|

Игрок: 16
 ___   ___
|6  | |K  |
| ♣ | | ♦ |
|__6| |__K|

0 - хватит, 1 - еще, 2 – повысить ставку > 1
Вам выпала карта Q масти ♦.

Диллер: ???
 ___   ___
|## | |J  |
|###| | ♥ |
|_##| |__J|

Игрок: 26
 ___   ___   ___
|6  | |K  | |Q  |
| ♣ | | ♦ | | ♦ |
|__6| |__K| |__Q|


***** Итог игры *****

Диллер: 14
 ___   ___
|4  | |J  |
| ♥ | | ♥ |
|__4| |__J|

Игрок: 26
 ___   ___   ___
|6  | |K  | |Q  |
| ♣ | | ♦ | | ♦ |
|__6| |__K| |__Q|

У вас перебор! Вы проиграли!
Нажмите Enter для продолжения ...

Ваш банк: 2445
Сделайте вашу ставку (от 1 до 2445 или «q» – выход) > 1000
Ваша ставка: 1000

Диллер: ???
 ___   ___
|## | |8  |
|###| | ♦ |
|_##| |__8|

Игрок: 14
 ___   ___
|J  | |4  |
| ♠ | | ♦ |
|__J| |__4|

0 - хватит, 1 - еще, 2 – повысить ставку > 0

***** Итог игры *****

Диллер: 18
 ___   ___
|Q  | |8  |
| ♥ | | ♦ |
|__Q| |__8|

Игрок: 14
 ___   ___
|J  | |4  |
| ♠ | | ♦ |
|__J| |__4|

Вы проиграли!
Нажмите Enter для продолжения ...









 

Менеджер проектов.* Перейдите в раздел «Python :: Коды, программы, скрипты», найдите там учебный проект «Консольный менеджер проектов», внимательно изучите его исходный код, а затем наберите код программы самостоятельно.