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

# Переводим число в требуемые СС.
print('53 в 2-й СС:', bin(53))
print('53 в 8-й СС:', oct(53))		
print('53 в 16-й СС:', hex(53))

53 в 2-й СС: 0b110101
53 в 8-й СС: 0o65
53 в 16-й СС: 0x35
			

# Представление числа в 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










			

# Сохраним число в переменной.
num_oct = str(1372)
# Выведет 762 (10-я СС).        
print(int(num_oct, base=8))

762


			

# 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





			

# Получаем числ. и знам., т.е. кортеж (115, 8).
num = 14.375.as_integer_ratio()
# Составляем и выводим строку.       
print('14.375 = ', num[0], '/', num[1], sep='')

14.375 = 115/8


			

# Сохраним число в переменной.
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)




 

# Присваиваем значения переменным. 
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







			

# Найдем результат выражения.
res = (10/2.3 - 3**4)*0.7 + 9**0.5
# Округлим и найдем модуль.
res = abs(round(res, 3))	
# Выведем результат на экран.
print('Ответ:', res)	

				
Ответ: 50.657

				
				
			

''' 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






















			

# Нам понадобится модуль 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



			

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

# Присваиваем значения переменным. 
a = 3
b = 2.5
# Вычисляем выражение.
res = 5.2*pow(a, 3) + 3*b**5 - 7.3
print(res)

426.06874999999997




			

# Присваиваем значения переменным. 
x = -4.1
y = 2        
# Вычисляем выражение.
res = x*(3.3 + 2*y) - abs(64/(x + y))
print(res)

-60.406190476190474




			

# Присваиваем значения переменным. 
m = 2
n = 5        
# Вычисляем выражение.
res = abs(m**(2*m - 1) - 35.5)/pow((3*n + 0.8*m), 2)
print(res) 

0.09979677747133109




			

# Импортируем модуль 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







			

# Импортируем модуль 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







			

# Импортируем модуль 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







			

# Импортируем модуль 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))





			

# Импортируем модуль 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)





			

# Импортируем модуль 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)





			

# Импортируем модуль 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





			

'''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'




			

'''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' " ' " '














			

'''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





			

# Сохраним строку в переменной.
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





			

# Сохраним строку в переменной.
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



			

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

ток




			

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

1235678




			

# Формируем строку.
str_1 = '.'*5 + ' ' + ('!' + ' ')*3 + '.'*5	

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

..... ! ! ! .....



			

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

«Вот и пришла осень золотая!»




			

# Получаем количество символов строки.
n = len('1a\u0398\t\u03B43s')
# Выведет 7.
print('В строке "1a\\u0398\\t\\u03B43s" ', n, ' символов.', sep='')

В строке "1a\u0398\t\u03B43s" 7 символов.


			

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

abcdef




			

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

....-..--....-..--




			

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

Кол-во единиц: 4


			

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

Сумма индексов: 4



			

# Заданные переменные.
a = 73; b = 95

# Форматируем и выводим рез-ты на экран.
print('{} + {} = {}'.format(a, b, a+b))
print('{0}*{1} = {2}'.format(a, b, a*b))

# Используем f-строки.
print(f'\n{a} + {b} = {a+b}')
print(f"{a}*{b} = {a*b}") 

73 + 95 = 168
73*95 = 6935

73 + 95 = 168
73*95 = 6935




			

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

FBCDEA




			

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

автопрогон10




			

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

3


			

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

Количество слов: 5




			

# Сохраним исходную строку в переменной.
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





			

# Сохраняем строку в переменной.
s = 'abs(math.sin(pow((5*a - b), 3)))'
# Вычисляем разность количества скобок.
res = s.count('(') - s.count(')')      

# Выводим сообщение в зависимости от рез-та.
if res>0:
    print('Открывающих скобок больше.')        
elif res<0:
    print('Закрывающих скобок больше.')         
else:
    print('Количество скобок обоих видов равно.')

Количество скобок обоих видов равно.










			

# Сохраняем строку в переменной.
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









































			

# Сохраняем строку в переменной.
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























			

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

8




			

''' 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


















			

# Сохраняем строку в переменной.
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

















			

# Сохраним исходную строку в переменной.
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






























			

# Сохраним исходную строку в переменной.
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_






























			

# Сохраним строку в переменной.
s = 'синхрофазотрон'	

''' 1-й вариант '''
# Архив отработанных символов.
simbls = ''
# Цикл по символам целевой строки.
for simb in s:
    # Если символ еще не считался.
    if simb not in simbls:   
        # Обновляем архив.
        simbls += simb                

# Выводим результат на экран. 
print('Кол-во видов букв :', len(simbls))        

''' 2-й вариант '''
# Множество включает неповторяющиеся элементы. 
print('Кол-во видов букв :', len(set(s)))

Кол-во видов букв : 10
Кол-во видов букв : 10














			

			

# Сохраним исходную строку в переменной.
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нг



















			

			

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



























			

			

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

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

яьЧ отэ аворок мат ?алачымаз





			

			

# Сохраним строку в переменной. 
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 сек.













			

# Сохраним список в переменной.
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]





			

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

Ok!


			

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

5р.


			

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

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

Санкт-Петербург

 
 
 

			

# Сохраним список в переменной.
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']
 
 
 
 
 
 
 
			

# Сохраним список в переменной.
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]
	
	
	
		
	
	
	
	
	
	
	
	
	
	
	
			

# Сохраним список в переменной.
li = [3, 4, 1, 1, 5, 1]

# Выводим кол-во элементов списка.
print('Количество эл-тов в списке:', len(li))		
# Выводим кол-во единиц.
print('Количество единиц:', li.count(1))
# Выводим индекс первого вхождения.
print('Индекс первой единицы:', li.index(1))

Количество эл-тов в списке: 6
Количество единиц: 3
Индекс первой единицы: 2
	
	
	
	
	
			

# Сохраним список в переменной.
li = []

# Добавляем первые два эл-та.
li.append('a')
li.append('b')

# Расширяем за счет списка.
li.extend(['c', 'e'])		
# Вставляем перед последним эл-том.
li.insert(li.index('e'), 'd')			

# Выводим результат на экран.
print(li)

['a', 'b', 'c', 'd', 'e']
	
	
	
	
	
	
	
	
	
	
	
	
			

# Сохраним список в переменной.
li = ['a', 'b', 'c', 'd', 'e']

# Удаляем последний эл-т списка.
li.pop()
# Инверсируем список.
li.reverse()
# Удаляем из списка строку 'c'.
li.remove('c')
# Очищаем список.
li.clear()

# Выводим результат на экран.
print(li)

[]
	
	
	
	
	
	
	
	
	
	
	
	
			

# Сохраняем список в переменной.
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



			

# Сохраняем список в переменной.
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


















			

# Сохраняем список в переменной.
li = [0.3, -2.4, 4.5, 0.0, -3.1]
# Получаем индекс мин. эл-та.
i = li.index(min(li))
# Выводим рез-т на экран.
print('Индекс мин. эл-та:', i)

Индекс мин. эл-та: 4




			

# Сохраняем список в переменной.
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





















			

# Сохраняем список в переменной.
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]









			

# Сохраняем список в переменной.
li = [3, 2, 3, 2, 1, 4]
# Сортируем эл-ты списка.
li.sort(reverse=True)
# Добавляем в конец списка его длинну.
li.append(len(li))        
# Выводим список на экран.
print(li)

[4, 3, 3, 2, 2, 1, 6]






			

# Сохраняем список в переменной.
li = [True, 5, 'go', 3+0.1j]

# Удаляем последний эл-т и вставляем в начало.
li.insert(0, li.pop())
# Выводим список на экран.
print(li)

[(3+0.1j), True, 5, 'go']





			

# Сохраняем список в переменной.
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]












			

''' 1-й вариант '''
# Создаем список для манипуляций.	
li = ['уж', 'змея', '', 'питон']
# Выведем для наглядности.
print('Стартовый список:', li)

# Стартовое значение индекса.
i = 0
# Длина списка.
ln = len(li)
# Запускаем цикл по индексам списка.
while i < ln:
    # Если в строке менее 5 символов.
    if len(li[i]) < 5: 
        # Удаляем элемент.
        del li[i]    
        # Не забываем уменьшить длину списка,
        # иначе индекс может выйти за его пределы.
        ln -= 1      
    else:
        # Если элемент удален не был,
        # наращиваем индекс.
        i += 1          

# Получим ['питон'].
print('Конечный результат: ', li, end='\n\n')	

''' 2-й вариант '''
# Восстанавливаем список.
li = ['уж', 'змея', '', 'питон']        
# Выведем для наглядности.
print('Стартовый список:', li)        

# Можно и через генератор списков.
li = [x for x in li if len(x) > 4]
# Получим ['питон'].
print('Конечный результат: ', li, end='\n\n')       

''' 3-й вариант '''
# Восстанавливаем список.
li = ['уж', 'змея', '', 'питон']        
# Выведем для наглядности.
print('Стартовый список:', li)    

# Используем фильтрацию эл-тов.
li = list(filter(lambda x: len(x) > 4, li))
# Получим ['питон'].
print('Конечный результат: ', li)   

Стартовый список: ['уж', 'змея', '', 'питон']
Конечный результат:  ['питон']

Стартовый список: ['уж', 'змея', '', 'питон']
Конечный результат:  ['питон']

Стартовый список: ['уж', 'змея', '', 'питон']
Конечный результат:  ['питон']







































			

# Сохраняем список в переменной.
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'>]






















			

# Сохраняем список в переменной.
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]

















			

# Сохраняем списки в переменных.
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']


























			

# Сохраняем список в переменной.
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']








			

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

5


			

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

5р.


			

# Сохраним кортеж в переменной.
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)





			

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

Ok!


			

# Сохраним кортеж в переменной.
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
	
	
	
	
	
			

# Сохраним кортеж в переменной.
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
 
 
 
 
 
 
 
 
 
 
 
 
			

''' 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}











			

''' 1-й вариант '''         
# Пары «ключ: значение» перечисляем через запятую.
person = {'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}
print(person) 	

''' 2-й вариант '''         
# Используем пары «идентификатор = значение».
person = dict(имя = 'Олег', пол = 'муж.', возраст = 25)
print(person)

''' 3-й вариант '''        
# Используем список с кортежами пар.
person = dict([('имя', 'Олег'), ('пол', 'муж.'), ('возраст', 25)])
print(person)

{'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}
{'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}
{'имя': 'Олег', 'пол': 'муж.', 'возраст': 25}










			

# Сохраняем словарь в переменной.
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

 
  

			

# Сохраняем словарь в переменной.
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)]







 
 

# Сохраняем словари в переменных.
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








 

# Сохраняем словарь в переменной.
d = {'a': 1, 'b': 2, 'c': 3}		

# Удаляем d['a'].
d.pop('a')
# Удаляем d['c'].
del d['c']				

# Выводим словарь на экран.
print(d) 
# Очищаем его.
d.clear()

{'b': 2}










			

# Используем вложенные словари.
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;











			

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

Ok!


			

# Сохраним список в переменной.
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: Чт














			

# Сохраним словарь в переменной.
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













			

# Сохраним словарь в переменной.
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






			

# Сохраним словарь в переменной.
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}


























			

# Сохраняем словарь в переменной.
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}


















			

# Словарь товаров.
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'])

Яблоки
Сливы











			

# Создаем множество.        
st = {1, 0.2, 0.3+4j, '(5,)', '[6]', '{7: 8}'} 
# Выводим его на экран.        
print(st)

{0.2, 1, '[6]', '{7: 8}', '(5,)', (0.3+4j)}


			

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

{'a', 'b', 'd'}







			

# Сохраняем множества в переменных.
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'}







			

# Сохраняем множества в переменных.
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'}











			

# Сохраним множество в переменной.
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


















			

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

True




			

# Преобразуем строки в множества символов.
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)

Общие виды букв {'а', 'м', 'р'}
Все имеющиеся виды букв: {'и', 'а', 'д', 'е', 'в', 'к', 'у', 'р', 'л', 'м'}







			

# Сохраняем числа в переменных.        
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



























			

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














			

# Импортируем класс 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)}






			

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

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

Введите вес в граммах: 550 
Получаем: 0.55 кг.



			

# Исходные значения переменных. 
x = 10
y = 55

# Выводим их на экран.
print('x = {}, y = {}.'.format(x, y))        

# Меняем значения местами.
y, x = x, y         
# Выводим их на экран.
print('x = {}, y = {}.'.format(x, y))

x = 10, y = 55.
x = 55, y = 10.








			

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

Введите расстояние в метрах: 5035
Полных км.: 5.0


			

# Импортируем число Пи.
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 см. кв.








			

# Вводим значение байтов для расчетов. 
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.













			

# Импортируем число Пи.
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.





			

# Вводим число (получим строку). 
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



















			

# Сохраним строку в переменной. 
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 сек.













			

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

Введите целое число: 75476
Число обратное введенному: 67457







			

# Импортируем модуль даты.
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












			

# Составляем условие.        
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







			

# Составляем условие.        
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







			

# Составляем условие.        
res = "li"
print(res)        

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

li
True







			

# Составляем условие.        
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







			

# Составляем условие.        
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







			

# Составляем условие.        
res = "not d"
print(res)        

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

not d
True







			

# Составляем условие.        
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







			

# Составляем условие.        
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







			

'''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





















			

'''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


















			

'''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




















			

# Составляем условие.        
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







			

# Выводим сообщение и призыв к вводу.
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










			

# Выводим сообщение и призыв к вводу.
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





			

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

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

Введите нат. число для проверки: 81
Число 81 кратно трем.







			

# Вводим сумму покупки. 
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 у.е.












			

# Выводим сообщение и призыв к вводу.
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-ной СС!








			

# Выводим сообщение и призыв к вводу.
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 - это пять














			

# Импортируем метод 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




















			

# Просим ввести число. 
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














			

# Сохраняем числа в переменных.        
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



























			

# Запрашиваем координаты точки.
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 четверти.












			

# Просим ввести длины сторон. 
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
Равнобедренный.
Равнобедренный.




























			

# Сохраним названия месяцев в словаре. 
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
Ноябрь, осень.





























			

# Импортируем метод 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.







































			

# Импортируем ф-цию 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




















































			

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























			

# Сохраняем список в переменной.
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,) 
 


















 
 
 
			

# Сохраним список в переменной.
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
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	







	
	
	
	
	
	
				

''' 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




























			

# Сохраним строку символов в переменной.
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".




















			

# Запрашиваем число и сохраняем его.
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


























			

# Запрашиваем число и сохраняем его.
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





















			

# Сохраняем строку в переменной.
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

































			

# Сохраняем списки в переменных.
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']











































			

# Сохраняем строку в переменной.
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






















			

''' 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 

/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/

/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_
\_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/

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


































			

# Запрашиваем число и сохраняем его.
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 





















			

# Сохраняем словарь в переменной.
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]}















































			

''' 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 |
 ----+-------------------------------------





























			

# Запрашиваем число и сохраняем его.
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 




























































			

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


			

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

[11, 13, 15, 17, 19]


			

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


			

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

1
2
3


			

'''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
















			

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












			

# Сохраняем строку в переменной.
s = 'генераторы'

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

10837



			

# Сохраняем список в переменной.
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)]






			

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






			

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

			

# Запрашиваем число и сохраняем его.
num_str = input('Введите целое число: ')   

# Удаляем - или +.
num_str = num_str.lstrip('-+')    
# Начальное значение суммы.
digit_sum = 0

# Суммируем элементы генератора выражения.
digit_sum = sum((int(d) for d in num_str))
# Выводим результат на экран. 
print('Сумма цифр числа равна:', digit_sum)

Введите целое число: -9720
Сумма цифр числа равна: 18

...

Введите целое число: 0
Сумма цифр числа равна: 0

...

Введите целое число: +3531
Сумма цифр числа равна: 12

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













































			

# Простейшая в мире функция.
def simple_pass(): pass

# Выводим тип объекта.                    
print(type(simple_pass))

<class 'function'>



			

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

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

Привет, Иван Иванов!







			

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

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

Привет, Иван Иванов!
Привет, Петр Романовский!








			

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

5
0.73
str
[]




			

# Ф-ция с произв-ным числом именованных арг-тов.
def print_args(**dict_args): 
    # Заголовок цикла.                    
    for item in dict_args.items():        
        # Выводим пару key -> value на экран.        
        print(item[0], '->', item[1])  
    
# Вызываем ф-цию.
print_args(c=5+3j, b=(True, False), st=set())

c -> (5+3j)
b -> (True, False)
st -> set()





			

# Создаем нашу функцию-матрешку.        
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.























			

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

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

# Вызываем функцию.
recursive_func('Python 3.12')

P y t h o n   3 . 1 2 

# Рек-вная ф-ция для вычисления суммы цифр нат. числа.
def sum_digits(n):
    # Базовый случай для числа меньше 10. 
    if n < 10:
        # Просто возвращаем само число.
        return n
    # Рекурсивный случай для чисел больше 10. 
    else:
        # Возвращаем последнюю цифру числа (остаток от 
        # деления на 10) плюс сумму цифр оставшейся 
        # части (частное от деления числа на 10).
        return n%10 + sum_digits(n//10)

# Выводим суммы цифр заданных чисел на экран.
mes = 'Сумма цифр числа {} равна {}.'
print(mes.format(7, sum_digits(7)))
print(mes.format(39574, sum_digits(39574)))

Сумма цифр числа 7 равна 7.
Сумма цифр числа 39574 равна 28. 














 

# Определяем нашу функцию.
def my_abs(x):
    # Если x < 0,
    if x < 0:
        # меняем знак и возвращаем.
        return -x
    # Если x >= 0,
    else:
        # возвращаем x без изменений.
        return x

# Проверяем функцию на числах.
print(my_abs(-5))
print(abs(-5))    

print(my_abs(0))
print(abs(0))     

print(my_abs(10))
print(abs(10)) 

5
5
0
0
10
10













			

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

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

Стоимость поездки: 6.35 y.e.














			

# Импортируем метод 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

























			

# Заголовок функции.        
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



























			

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
















			

# Импортируем метод 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

























			

# Импортируем требуемую функцию.
from importlib import import_module

# Объявляем функцию.
def imp_mods(mods):
    # Получаем словарь глоб-ных переменных модуля.
    glb = globals()
            
    # Если список имен не пустой.
    if mods:
        # Циклом импортируем все модули.
        for m in mods:
            # И добавляем их в глобальное 
            # пространство имен модуля.
            glb[m] = import_module(m)
    
# Импортируем требуемые модули.
imp_mods(('random', 'math'))        
    
# Выводим факториал случайного числа.
print(math.factorial(random.randint(1, 10)))

6



















			

# Заголовок функции.        
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





























			

# Заголовок функции.        
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



























			

# Простейший в мире класс.
class SimplePass: pass

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

<class '__main__.main.<locals>.SimplePass'>





			

# Определяем класс.
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
























			

# Определяем класс.
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


















			

# Определяем класс.
class A: 
    
    '''Класс A'''
                           
    # Метод установки значения атрибута a.
    def set_a(self, a):            
        # Инициализируем a.
        self.a = a
         
    # Метод получения значения атрибута a.
    def get_a(self):            
        # Возвращаем a.
        return self.a
       
# Определяем класс.
class B: 
    
    '''Класс B'''
                           
    # Конструктор класса B.
    def __init__(self, b):             
        # Инициализируем b.
        self.b = b
         
    # Метод получения значения атрибута b.
    def get_b(self):            
        # Возвращаем b.
        return self.b
       
# Наследуем оба класса.
class C(A, B): 
    
    '''Класс C = A + B'''
                           
    # Конструктор класса C.
    def __init__(self, a, b, c):             
        # Вызываем конструктор класса B,
        # инициализируя атрибут b.
        B.__init__(self, b)
        # Инициализируем a (унаследован).
        self.set_a(a)
        # Инициализируем c (определен здесь).
        self.set_c(c)                 
        
    # Метод установки значения атрибута b.
    def set_b(self, b):            
        # Возвращаем b.
        self.b = b        

    # Метод установки значения атрибута c.
    def set_c(self, c):            
        # Инициализируем c.
        self.c = c
         
    # Метод получения значения атрибута c.
    def get_c(self):            
        # Возвращаем c.
        return self.c

# Выводим документацию класса C.
print(C.__doc__, end='\n\n')

# Создаем экземпляр класса.                    
obj = C('a_ok', 'b_ok', 'c_ok',)
# Выводим значения атрибутов.                    
print('obj.get_a():', obj.get_a())          
print('obj.get_b():', obj.get_b())
print('obj.get_c():', obj.get_c())

Класс C = A + B

obj.get_a(): a_ok
obj.get_b(): b_ok
obj.get_c(): c_ok































































			

# Определяем класс 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': ...}


















			

# Определяем класс 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}





























			

# Определяем класс.
class A: 
    
    '''Класс A'''
                           
    # Метод установки значения атрибута a.
    def set_a(self, a):            
        # Инициализируем a.
        self.a = a
         
    # Метод получения значения атрибута a.
    def get_a(self):            
        # Возвращаем a.
        return self.a

# Определяем класс F.
class F(A): 
         
    '''Класс F(A)'''
    
    # Конструктор класса F.
    def __init__(self):             
        # Обновляем документацию.
        self.__doc__ = 'Объект класса F'            
        
    # Расширяем метод.
    def set_a(self, a):            
        # Вызываем метод суперкласса.
        # Можно super(F, self).set_a(a)
        # или A.set_a(self, a) 
        super().set_a(a)
        # Выводим сообщение.
        print('Атрибут a установлен!')              

# Выводим строку документирования класса.
print(F.__doc__, end='\n\n')

# Создаем экземпляр класса.                    
obj = F()
# Выводим его документацию.                    
print(obj.__doc__)       
# Устанавливаем и выводим значение атрибута a.                    
obj.set_a('a_ok')
print('obj.get_a():', obj.get_a())

Класс F(A)

Объект класса F
Атрибут a установлен!
obj.get_a(): a_ok






































			

# Определяем класс числа Пи.
class PiNum: 
    # Инициализируем экземпляр. 
    def __init__(self, prec=2):
        # Задаем текущую точность Пи.
        self.set_pi_prec(prec)
    
    # Оформляем строковое представление. 
    def __str__(self):
        # Выводим значение Пи.
        # с текущей точностью.
        return str(self.cur_pi)        
    
    # Создаем управляемый атрибут.
    @property
    def max_pi(self):
        # Неизменяемая макс-ная точность числа Пи.
        return 3.1415926535897

    # Запрещаем изменение и удаление атрибута.
    @max_pi.setter
    def max_pi(self, val): pass
    @max_pi.deleter
    def max_pi(self): pass              
    
    # Изменение точности представления числа Пи. 
    def set_pi_prec(self, prec=2):
        # Задаем текущую точность.
        self.cur_pi = round(self.max_pi, prec)        
    

# Создаем экземпляр класса.                    
pi = PiNum(3)
# Выводим строковое представление объекта.
print(pi)
# Изменяем точность представления числа.
pi.set_pi_prec(5)
# Выводим текущее значение на экран.
print(pi.cur_pi)    
# Выводим значение с макс. допустимой точностью.
print(pi.max_pi)

3.142
3.14159
3.1415926535897





































			

# Определяем класс числа Пи.
class PiNum: 
    # Инициализируем экземпляр. 
    def __init__(self, prec=2):
        # Задаем текущую точность Пи.
        self.set_pi_prec(prec)
    
    # Оформляем строковое представление. 
    def __str__(self):
        # Выводим значение Пи.
        # с текущей точностью.
        return str(self.cur_pi)        
    
    # Создаем управляемый атрибут.
    @property
    def max_pi(self):
        # Неизменяемая макс-ная точность числа Пи.
        return 3.1415926535897

    # Запрещаем изменение и удаление атрибута.
    @max_pi.setter
    def max_pi(self, val): pass
    @max_pi.deleter
    def max_pi(self): pass              
    
    # Изменение точности представления числа Пи. 
    def set_pi_prec(self, prec=2):
        # Задаем текущую точность.
        self.cur_pi = round(self.max_pi, prec)        
    

# Определяем класс окружности.
class Circle: 
    
    # Если понадобится перевод.
    @staticmethod
    def m_to_cm(n, flag=1):            
        # Проверка флага.
        if flag == 0:
            # Переводим см в метры.
            return n/100
        # Переводим метры в см.
        return n*100           
        
    # Конструктор класса.
    def __init__(self, r=1):            
        # Радиус окружности.
        self.r = r
        # Число Пи с требуемой точностью.
        self.pi = PiNum(3).cur_pi            

    # Получаем длину окружности.
    def get_len(self): 
        # Длина окружности.
        return round(2*self.pi*self.r, 3) 
    
    # Получаем площадь окружности.
    def get_s(self): 
        # Площадь окружности.
        return round(self.pi*self.r**2, 3)     

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

Длина окружности: 1614.988 см.
Площадь окружности: 207525.958 кв.см.

































































			

# Суперкласс.
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 руб.





























			

# Импортируем класс и декоратор.
from abc import ABC, abstractmethod

# Определяем абстрактный суперкласс.
class Shape(ABC):
    # Сразу инициализируем длину стороны и соответствующую высоту фигуры.
    def __init__(self, length, height):
        self.length = length
        self.height = height
    
    # Определяем абстрактный метод расчета площади треугольника.
    @abstractmethod
    def area(self):
        pass

# Определяем подкласс треугольника.
class Triangle(Shape):
    # Определяем метод расчета площади треугольника.
    def area(self):
        # Площадь треугольника равна половине произведения основания на высоту.
        return 0.5*self.length*self.height

# Определяем подкласс прямоугольника.
class Rectangle(Shape):
    # Определяем метод расчета площади прямоугольника.
    def area(self):
        # Площадь прямоугольника равна произведению его сторон.
        return self.length*self.height

# Создаем экземпляр класса треугольника.                    
trian = Triangle(20, 10)
# Рассчитываем площадь.         
print('S треугольника:', trian.area())

# Создаем экземпляр класса прямоугольника. 
rect = Rectangle(20, 10)
# Рассчитываем площадь.         
print('S прямоугольника:', rect.area())

S треугольника: 100.0
S прямоугольника: 200



































			

# Создаем класс.
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

























































			

# Импортируем модуль 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






			

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

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

14:10:32.657780



			

# Импорт в глоб. обл. видимости.
from sys import version_info

# Выводим версию Питона на экран.                    
print('Python {0[0]}.{0[1]}.{0[2]}.'.format(version_info))

Python 3.11.3.



			

# Импортируем требуемые функции.        
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











			

# Импортируем модули в глоб. обл. видимости.
from pkg_1 import mod_1
from pkg_2 import mod_2    

# Можно, например, и так.
# import pkg_1.mod_1 as mod_1
# import pkg_2.mod_2 as mod_2

# Выводим сумму значений переменных.                    
res = mod_1.x + mod_2.x
print('{} + {} = {}'.format(mod_1.x, mod_2.x, res))

1 + 2 = 3









			

# Импортируем все переменные модулей.
from pkg_1.mod_1 import *
from pkg_2.mod_2 import *   

# Можно, например, и так.
# from pkg_1.mod_1 import x, z_1
# from pkg_2.mod_2 import y, z_2  

# Выводим сумму значений переменных.                    
res = x + y + z_1 +z_2
print('{} + {} + {} + {} = {}'.format(x, y, z_1, z_2, res))

1 + 2 + 3 + 3 = 9









			

# Импортируем требуемую функцию.
from importlib import import_module

# Объявляем функцию.
def imp_mods(mods):
    # Получаем словарь глоб-ных переменных модуля.
    glb = globals()
            
    # Если список имен не пустой.
    if mods:
        # Циклом импортируем все модули.
        for m in mods:
            # И добавляем их в глобальное 
            # пространство имен модуля.
            glb[m] = import_module(m)
    
# Импортируем требуемые модули.
imp_mods(('random', 'math'))        
    
# Выводим факториал случайного числа.
print(math.factorial(random.randint(1, 10)))

6



















			

# Создаем и открываем файл на запись.
f_obj = open('text_1.txt', 'w', encoding='utf-8')
# Записываем в него строку.
f_obj.write('Пайтон практика: упражнения и задачи.')
# Закрываем файловый объект.
f_obj.close()

# Открываем файл в режиме чтения.
f_obj = open('text_1.txt', 'r', encoding='utf-8')
# Считываем все содержимое.
text = f_obj.read()
# Закрываем файловый объект.
f_obj.close()    

# Выводим содержимое файла на экран.
print(text)

Пайтон практика: упражнения и задачи.














			

# Создаем и открываем файл на запись и чтение.
f_obj = open('text_2.txt', 'w+', encoding='utf-8')
# Записываем в него строку.
f_obj.write('0123456789')
# Перемещаем указатель в начало файла.
f_obj.seek(0)
# Считываем содержимое.
text = f_obj.read()    
# Выводим все на экран.
print(text)     
# Закрываем файловый объект.
f_obj.close()

# Открываем файл в режиме дозаписи и чтения.
f_obj = open('text_2.txt', 'a+', encoding='utf-8')
# Дописываем в него строку.
f_obj.write('abcdef')
# Перемещаем указатель в начало файла.
f_obj.seek(0)
# Считываем содержимое и выводим на экран.    
print(f_obj.read())
# Закрываем файловый объект.
f_obj.close()

0123456789
0123456789abcdef




















			

# Создаем и записываем файл li.py.    
f = open('li.py', 'w', encoding='utf-8')
# Записываем в него первую строку.     
f.write('li_1 = [1, 2]\n')
# Закрываем файловый объект.
f.close()    

# Открываем файл li.py в менеджере контекста.
with open('li.py', 'a+', encoding='utf-8') as f:
    # Дописываем в него еще одну строку.    
    f.write("li_2 = ['red', 'green']")
    # Перемещаем файловый указатель в начало файла.
    f.seek(0)
    # Выводим строки на экран. 
    for s in f.readlines(): print(s, end='') 
    # Еще раз перемещаем указатель в начало файла.
    f.seek(0)        
    print('\n\nИ еще раз...\n')
    # Т.к. файловый объект итерируем и его эл-ми 
    # являются строки, можно сделать и так.         
    for s in f: print(s, end='')

li_1 = [1, 2]
li_2 = ['red', 'green']

И еще раз...

li_1 = [1, 2]
li_2 = ['red', 'green']













			

# Импортируем функцию перезагрузки модулей.
from importlib import reload

# Сохраняем числа в переменных.    
x, y = 10, 20
# Сохраняем объявление функции в переменной.
s = '''def sum_func(x, y):
return x + y''' 

# Создаем и открываем файл на запись.
with open('mod.py', 'w', encoding='utf-8') as f:
    # Записываем в него содержимое.    
    f.write(s)

# Импортируем созданный модуль.
import mod
# Выводим сумму на экран.
print('x + y =', mod.sum_func(x, y))

# Формируем еще одно определение функции.
s = '''

def mul_func(a, b):
return a*b'''  

# Открываем файл на дозапись.
with open('mod.py', 'a+', encoding='utf-8') as f:
    # Дописываем еще одну инструкцию.    
    f.write(s)    

# Перезагружаем модуль.
reload(mod)
# Выводим на экран произведение.
print('x*y =', mod.mul_func(x, y))

x + y = 30
x*y = 200































			

# Импортируем из модуля класс.
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?

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

Все удалено!
Нажмите любую клавишу...





















			

# Импортируем модуль 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 руб.






























































			

# Импортируем модуль.
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('Нажмите любую клавишу...')

# Импортируем класс в глобальное пространство.
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')

# Определяем функцию.   
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'».


















			

# Функция записи и закрытия файла.
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».
Файл закрыт!




















			

# Определяем функцию.
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'









			

# Определяем абстрактный суперкласс.
class Shape():
    # Сразу инициализируем длину стороны и соответствующую высоту фигуры.
    def __init__(self, length, height):
        self.length = length
        self.height = height
    
    # Определяем абстрактный метод расчета площади треугольника.
    def area(self):
        # Используем перехват исключения и вывод его на экран.
        try:
            # Возбуждаем исключение 
            raise NotImplementedError("Вы забыли переопределить абстрактный метод!")        
        # Выводим информацию об исключении на экран.    
        except NotImplementedError as err:
            print(err)
            input()
        
# Определяем подкласс треугольника.
class Triangle(Shape):
    # Определяем метод расчета площади треугольника.
    def area(self):
        # Площадь треугольника равна половине произведения основания на высоту.
        return 0.5*self.length*self.height
    
# Определяем подкласс прямоугольника.
class Rectangle(Shape):
    # Определяем метод расчета площади прямоугольника.
    def area(self):
        # Площадь прямоугольника равна произведению его сторон.
        return self.length*self.height

# Создаем экземпляр класса треугольника.                    
trian = Triangle(20, 10)
# Рассчитываем площадь.         
print('S треугольника:', trian.area())

# Создаем экземпляр класса прямоугольника. 
rect = Rectangle(20, 10)
# Рассчитываем площадь.         
print('S прямоугольника:', rect.area())

S треугольника: 100.0
S прямоугольника: 200






































			

(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>

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

-- ОС 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$

-- ОС Windows --

D:\python\my_prj>python -m venv .\venv_2

D:\python\my_prj>.\venv_2\Scripts\activate.bat

(venv_2) D:\python\my_prj>pip3 install --upgrade pip
Requirement already satisfied: pip in d:\python\my_prj\venv_2\lib\site-packages (22.3.1)

(venv_2) D:\python\my_prj>pip3 install pillow
Collecting pillow
  Using cached Pillow-9.4.0-cp311-cp311-win_amd64.whl (2.5 MB)
Installing collected packages: pillow
Successfully installed pillow-9.4.0

(venv_2) D:\python\my_prj>pip3 list
Package    Version
---------- -------
Pillow     9.4.0
pip        22.3.1
setuptools 65.5.0

(venv_2) D:\python\my_prj>pip3 freeze>requirements.txt

(venv_2) D:\python\my_prj>deactivate

D:\python\my_prj>python -m venv .\venv_3

D:\python\my_prj>.\venv_3\Scripts\activate.bat

(venv_3) D:\python\my_prj>pip3 install -r requirements.txt
Collecting Pillow==9.4.0
  Using cached Pillow-9.4.0-cp311-cp311-win_amd64.whl (2.5 MB)
Installing collected packages: Pillow
Successfully installed Pillow-9.4.0

(venv_3) D:\python\my_prj>pip3 list
Package    Version
---------- -------
Pillow     9.4.0
pip        22.3.1
setuptools 65.5.0

(venv_3) D:\python\my_prj>deactivate
D:\python\my_prj>


-- ОС Ubuntu 20.04 --


okpy@SUPER:~/my_prj$ python3 -m venv ./venv_2

okpy@SUPER:~/my_prj$ source ./venv_2/bin/activate

(venv_2) okpy@SUPER:~/my_prj$ python -m pip install --upgrade pip
Requirement already satisfied: pip in ./venv_2/lib/python3.10/site-packages (22.0.2)
Collecting pip
  Using cached pip-22.3.1-py3-none-any.whl (2.1 MB)
Installing collected packages: pip
  Attempting uninstall: pip
    Found existing installation: pip 22.0.2
    Uninstalling pip-22.0.2:
      Successfully uninstalled pip-22.0.2
Successfully installed pip-22.3.1
(venv_2) okpy@SUPER:~/my_prj$ pip3 install pillow
Collecting pillow
  Downloading Pillow-9.4.0-cp310-cp310-manylinux_2_28_x86_64.whl (3.4 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.4/3.4 MB 25.2 kB/s eta 0:00:00
Installing collected packages: pillow
Successfully installed pillow-9.4.0

(venv_2) okpy@SUPER:~/my_prj$ pip3 list
Package    Version
---------- -------
Pillow     9.4.0
pip        22.3.1
setuptools 59.6.0

(venv_2) okpy@SUPER:~/my_prj$ pip3 freeze>requirements.txt

(venv_2) okpy@SUPER:~/my_prj$ deactivate
okpy@SUPER:~/my_prj$ mc

okpy@SUPER:~/my_prj$ python3 -m venv ./venv_3

okpy@SUPER:~/my_prj$ source ./venv_3/bin/activate

(venv_3) okpy@SUPER:~/my_prj$ pip3 install -r requirements.txt
Collecting Pillow==9.4.0
  Using cached Pillow-9.4.0-cp310-cp310-manylinux_2_28_x86_64.whl (3.4 MB)
Installing collected packages: Pillow
Successfully installed Pillow-9.4.0

(venv_3) okpy@SUPER:~/my_prj$ pip3 list
Package    Version
---------- -------
Pillow     9.4.0
pip        22.0.2
setuptools 59.6.0

(venv_3) okpy@SUPER:~/my_prj$ deactivate
okpy@SUPER:~/my_prj$

-- ОС 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$

# Импортируем класс datetime одноименного модуля.
from datetime import datetime as dt

# Используем методы класса datetime.

# 2023-02-13 15:23:25.372217.
print(dt.today())
# 2023-02-13 15:23:25.372217.
print(dt.now())

2023-03-08 00:46:02.434220
2023-03-08 00:46:02.434220






			

# Импортируем класс datetime одноименного модуля.
from datetime import datetime

# Получаем объект текущей даты и времени.
today = datetime.today()

# Выделяем дату и время по отдельности.
d = today.date()
t = today.time()

# Переводим все в iso формат.
iso_date = d.isoformat()
iso_time = t.isoformat(timespec='seconds')

# Выводим результаты.
print('Дата:', iso_date)
print('Время:', iso_time)

Дата: 2023-03-09
Время: 10:17:48














			

# Импортируем класс datetime одноименного модуля.
from datetime import datetime

# Получаем объект текущей даты и времени.
today = datetime.today()

# Синтаксис метода смотрите в справочнике.
d_1 = today.strftime('%d.%m.%Y %H:%M:%S')
d_2 = today.strftime('%d/%m/%Y %H:%M:%S')
d_3 = today.strftime('%d-%m-%Y')
d_4 = today.strftime('%H:%M:%S')

# Выводим результаты.
print(today)
print(d_1)
print(d_2)
print(d_3)
print(d_4)

2023-03-10 20:17:26.011847
10.03.2023 20:17:26
10/03/2023 20:17:26
10-03-2023
20:17:26












			

# Импортируем класс datetime одноименного модуля.
from datetime import datetime

# Составляем списки названий месяцев и дней недели.
m_li = ['', 'Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь', 
		'Июль', 'Август', 'Сентябрь', 'Октябрь', 'Ноябрь', 'Декабрь'] 

d_li = ['Воскресенье', 'Понедельник', 'Вторник', 'Среда', 
         'Четверг', 'Пятница', 'Суббота']

# Получаем объект текущей даты и времени.
today = datetime.today()
# Выделяем требуемые компоненты даты и времени по отдельности.
dt_li = today.strftime('%Y %m %d %w %H %M %S').split() 

# Выводим результаты.
print(dt_li)
print('Год:', dt_li[0])
print('Месяц:', dt_li[1])
print('Название месяца:', m_li[int(dt_li[1])])
print('Число:', dt_li[2])
print('Название дня недели:', d_li[int(dt_li[3])])
print('Часы:', dt_li[4])
print('Минуты:', dt_li[5])
print('Секунды:', dt_li[6])

['2023', '03', '10', '5', '20', '55', '11']
Год: 2023
Месяц: 03
Название месяца: Март
Число: 10
Название дня недели: Пятница
Часы: 20
Минуты: 55
Секунды: 11















			

# Импортируем класс datetime одноименного модуля.
from datetime import date, timedelta

# Получаем объект текущей даты.
today = date(2023, 3, 13)

# Получаем объект даты для нового года.
new_year = date(2024, 1, 1)
# Получаем объект даты для 8 марта.
w_day = date(2024, 3, 8)

# Получаем кол-во оставшихся дней (включая текущий).
t_new_year = (new_year - today).days
t_w_day = (w_day - today).days

# Выводим результаты.
print('Дней до НГ:', t_new_year)
print('Дней до 8 марта:', t_w_day)

Дней до НГ: 294
Дней до 8 марта: 361















			

# Импортируем классы модуля datetime.
from datetime import date, timedelta

# Получаем объект текущей даты.
today = date(2023, 3, 14)

# Получаем объект даты последнего дня отпуска.
last_day = today + timedelta(17)
# Получаем номер дня недели, где пн - это 0.
n = last_day.weekday()

# Если отпуск заканчивается в пятницу.
if n == 4:
    print('Отпуск продляется на 2 дня!')
# Если отпуск заканчивается в субботу.
elif n == 5:
    print('Отпуск продляется на 1 день!')
# Иначе.
else:
    print('Эх, завтра придется выходить на работу!')

Отпуск продляется на 2 дня!


















			

# Импортируем класс datetime модуля datetime.
from datetime import datetime

# Определяем функцию проверки на соотв. формату iso.
def is_iso_format(s):
    # Пытаемся преобразовать строку в объект даты и времени.
    try:
        datetime.fromisoformat(s)
        # Если все хорошо, возвращаем True.
        return True
    # Если возникло исключение.
    except ValueError:
        # Возвращаем False.
        return False

# Проверяем заданные строки.
print(is_iso_format('2011-11-04T00:05:23'))
print(is_iso_format('2011-11-04T00:05:23.'))

True
False















			

# https://pypi.org/project/isodate/
# Импортируем модуль isodate.
import isodate

# Проверка на соответствие строки продолжительности времени формату iso.
def is_iso_duration(s):
    # Пытаемся преобразовать строку в объект timedelta.
    try:
        isodate.parse_duration(s)
        # Если все хорошо, возвращаем True.
        return True
    # Если возникло исключение.
    except isodate.ISO8601Error:
        # Возвращаем False.
        return False

# Проверяем заданные строки.
print(is_iso_duration('P3Y7M4DT12H30M19S'))
print(is_iso_duration('2021-05-14T09:05:23'))

True
False
















			

# Сохраняем строку в переменной.
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


			

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







































			

# Импортируем 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-й вариант '''
# Просим ввести параметры для рассчета.
n = int(input('Введите кол-во человек n: '))
k = int(input('Введите шаг выбывания k: '))

# Создаем список со всеми n участниками. Например, 
# при n = 5, получим [1, 2, 3, 4, 5].
people = list(range(1, n+1))

# Счетчики: кол-во оставшихся человек (т.е. len(people)), 
# текущий отсчитываемый участник (т.е. индекс проверяемого 
# элемента списка), счетчик отсчета шага k.
num_people, current_position, step = n, 0, 0

# Цикл прерываем, когда останется последний участник.
while num_people > 1:
	# Увеличиваем счетчик отсчета шага.
	step += 1            
	# Если индекс вышел за пределы списка,
	if current_position >= num_people:
		# Переходим в начало списка.
		current_position = 0 
	
	# Для наглядности можете раскомментировать.
	# print('step = ', step)
	# print('current_position = ', current_position)
	# print('people = ', people, end='\n\n')
	
	# Проверяем не достиг ли отсчет заданного шага k.
	if step == k:
		# Если да, то удаляем участника из списка.
		del people[current_position]
		# Уменьшаем счетчик оставшихся участников и 
		num_people -= 1
		# обнуляем счетчик отсчета шага.
		step = 0            
	# Иначе 
	else:
		# переходим к следующему элементу списка.
		current_position += 1

# Выводим номер последнего оставшегося участника.
print('Номер последнего участника ', people[0], end='\n\n')


''' 2-й вариант '''    
# Просим ввести параметры для рассчета.
n = int(input('Введите кол-во человек n: '))
k = int(input('Введите шаг выбывания k: '))    

last = 0
# Используем цикл.
for i in range(1, n + 1):
	last = (last + k)%i
print(last + 1, end='\n\n')    


''' 3-й вариант '''    
# Просим ввести параметры для рассчета.
n = int(input('Введите кол-во человек n: '))
k = int(input('Введите шаг выбывания k: '))        

# Используем рекурсивную функцию.
def last_survivor(n, k):
	if n == 1:
		return 1
	elif n > 1:
		return (1 + (last_survivor(n - 1, k) + k - 1)%n)
 
print(last_survivor(n, k))

Введите кол-во человек n: 7
Введите шаг выбывания k: 3
Номер последнего участника  4

Введите кол-во человек n: 7
Введите шаг выбывания k: 3
4

Введите кол-во человек n: 7
Введите шаг выбывания k: 3
4


























































			

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

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

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

Привет, Мир!
























			

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

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
































			

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

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

# Функция вывода на экран таблицы умножения.
def print_table():    
    
    # Выводим шапку таблицы.
    print('\n Таблица умножения.')
    print(' ----+-------------------------------------')
    print(' | х |  1   2   3   4   5   6   7   8   9 |')
    print(' ----+-------------------------------------')
        
    # Выводим произведения построчно.
    for x in range(1, 10):
        # Выводим левую метку текущей строки таблицы.
        print(' |' + str(x).rjust(2) + ' |', end='')
        
        # Организуем внутренний цикл.
        for y in range(1, 10):            
            # Выводим произведение и пробел.
            print(str(x*y).rjust(3), end=' ')
                        
        # Выводим символ для правой рамки и разрыв.
        print('|')

    # Выводим нижнюю рамку таблицы.
    print(' ----+-------------------------------------') 


# Функция запуска тренажера.
def run_traning(): 

    # Организуем бесконечный цикл с прерыванием через if.    
    while True:
         
        # Получаем случайные числа от 2 до 9.        
        a = randint(2, 9)
        b = randint(2, 9)
        # Вычисляем результат.
        res = a*b       
                
        # Выводим пример на экран.
        inp = '\n {}*{} = '.format(a, b)
        ans = int(input(inp))

        # Проверяем ответ.
        if ans == res:
            # Поздравляем пользователя.
            print(' Верно!')           
        else:
            # Сообщение об ошибке.
            print(' Вы ошиблись!')        
            # Выводим сообщение на экран.
            print(' {}*{} = {}'.format(a, b, res))   
        
        # Условие для выхода из цикла в меню программы.     
        if input(' Продолжить/Меню (any_key/m): ') == 'm': break


# Центральная функция программы.
def main():

    # Выводим название программы и версию.
    print('\n Тренажер таблицы умножения, версия 1.0.')
        
    # Организуем бесконечный цикл с прерыванием через if.    
    while True:
    
        # Выводим меню программы.
        print('\n Вывести таблицу умножения: t')
        print(' Запустить тренажер: r')        
        print(' Выйти из программы: q')        
        
        # Ждем выбора. Потом все переводим в нижний 
        # регистр и удаляем начальные и конечные пробелы
        # для более стабильной работы программы.
        user_move = input(' >').lower().strip()
        
        # Условие для выхода из цикла while True и программы.     
        if user_move == 'q': 
            break
        elif user_move == 't':
            # Выводим таблицу умножения для заучивания.
            print_table()
            # Выводим меню программы.
            continue
        elif user_move == 'r':        
            # Запускаем тренажер.
            run_traning()        
        else:
            # Просим сделать допустимый выбор..
            print(' Сделайте допустимый выбор!\n')              
    
# Если модуль не импортируется, а запускается как программа.
if __name__ == '__main__':
    # Вызываем основную функцию программы.
    main()

 Тренажер таблицы умножения, версия 1.0.

 Вывести таблицу умножения: t
 Запустить тренажер: r
 Выйти из программы: q
 >t

 Таблица умножения.
 ----+-------------------------------------
 | х |  1   2   3   4   5   6   7   8   9 |
 ----+-------------------------------------
 | 1 |  1   2   3   4   5   6   7   8   9 |
 | 2 |  2   4   6   8  10  12  14  16  18 |
 | 3 |  3   6   9  12  15  18  21  24  27 |
 | 4 |  4   8  12  16  20  24  28  32  36 |
 | 5 |  5  10  15  20  25  30  35  40  45 |
 | 6 |  6  12  18  24  30  36  42  48  54 |
 | 7 |  7  14  21  28  35  42  49  56  63 |
 | 8 |  8  16  24  32  40  48  56  64  72 |
 | 9 |  9  18  27  36  45  54  63  72  81 |
 ----+-------------------------------------

 Вывести таблицу умножения: t
 Запустить тренажер: r
 Выйти из программы: q
 >r

 4*8 = 32
 Верно!
 Продолжить/Меню (any_key/m):

 7*4 = 30
 Вы ошиблись!
 7*4 = 28
 Продолжить/Меню (any_key/m): m

 Вывести таблицу умножения: t
 Запустить тренажер: r
 Выйти из программы: q >
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
















 

# Импортируем требуемые модули.
import random, sys, time# Выводим название программы и версию.

print('\n Игра «Камень, ножницы, бумага», версия 1.0.')

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

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

# Счетчики выигрышей, проигрышей и ничьих.
wins = 0
losses = 0
ties = 0

# Основной цикл игры.
while True:  
    
    # Выходим, если игрок введет 'r', 'к', 'y', 'н', ',', 'б'.
    while True:  
        
        # Разделитель игр.
        print('\n ----------------------------------------------')        
        
        # Выводим статистику игры.
        print('\n Победы: {}, проигрыши {}, ничьи {}.\n'.format(wins, losses, ties))
        # Просим сделать выбор.
        print(' Выберите (К)амень, (Н)ожницы, (Б)умагу или (В)ыход?')
        # Сохраняем выбор игрока в переменной, переведя 
        # символ в нижний регистр для однозначности.
        player_move = input(' > ').lower()
        print()
        
        # Если игрок решил выйти из игры (страхуемся от раскладки клавиатуры).
        if player_move == 'в':
            # Благодарим за игру.
            print(' Спасибо за игру!\n')
            # Немножко ждем.
            time.sleep(1.5)
            # И выходим.
            sys.exit()

        # Если игрок решил играть (страхуемся от раскладки клавиатуры).
        if player_move in ('к', 'н', 'б'):
            # Выходим из внутреннего цикла.
            break
        else:
            # Просим сделать допустимый выбор.
            print(" Используйте 'к', 'н', 'б' или 'в'.")
    
    # Отображаем на экране выбранный игроком ход:
    if player_move == 'к':
        print(' «Камень» против ...')
        player_move = '«Камень»'
    elif player_move == 'н':
        print(' «Ножницы» против ...')
        player_move = '«Ножницы»'
    elif player_move == 'б':
        print(' «Бумага» против ...')
        player_move = '«Бумага»'

    # Считаем до трех.
    time.sleep(0.4)
    print(' 1...')
    time.sleep(0.4)
    print(' 2...')
    time.sleep(0.4)
    print(' 3...')
    time.sleep(0.5)

    # Имитируем выбор компьютера.
    random_number = random.randint(1, 3)
    if random_number == 1:
        computer_move = '«Камень»'
    elif random_number == 2:
        computer_move = '«Ножницы»'
    elif random_number == 3:
        computer_move = '«Бумага»'
    # Отображаем результат выбора на экране.
    print('', computer_move)
    
    # Делаем небольшую паузу, после чего 
    # отображаем и фиксируем результат игры.
    time.sleep(0.5)
    print()
    
    # Если выбор игрока и компьютера совпал.
    if player_move == computer_move:
        # Выводим сообщение. 
        print(' Ничья!')
        # И увеличиваем счетчик ничьих на единицу.
        ties += 1
    elif player_move == '«Камень»' and computer_move == '«Ножницы»':
        print(' Вы выиграли!')
        # Увеличиваем счетчик побед игрока на единицу.
        wins += 1
    elif player_move == '«Бумага»' and computer_move == '«Камень»':
        print(' Вы выиграли!')
        wins += 1
    elif player_move == '«Ножницы»' and computer_move == '«Бумага»':
        print(' Вы выиграли!')
        wins += 1
    elif player_move == '«Камень»' and computer_move == '«Бумага»':
        print(' Вы проиграли!')
        # Увеличиваем счетчик поражений игрока на единицу.
        losses += 1
    elif player_move == '«Бумага»' and computer_move == '«Ножницы»':
        print(' Вы проиграли!')
        losses += 1
    elif player_move == '«Ножницы»' and computer_move == '«Камень»':
        print(' Вы проиграли!')
        losses += 1
    
    # Делаем небольшую паузу, после чего 
    # переходим к новой игре.
    time.sleep(0.5)

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

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

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

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

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

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

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

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

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

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

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

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

 Вы выиграли!

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

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

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

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

 Вы выиграли!

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

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

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

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























































			

# Импортируем нужные компоненты.
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):