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

    n = int(input("n = "))
    if n == 0:
    	print("Ноль - однозначное число")
    else:
    	if n > 0:
    		print("Положительное", end=' ')
    	else:
    		print("Отрицательное", end=' ')
    	if abs(n) < 10:
    		print("однозначное число")
    	elif 10 <= abs(n) < 100:
    		print("двузначное число")
    	else:
    		print("трехзначное или более число")

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

    n = 345
    Положительное трехзначное или более число

    n = -23
    Отрицательное двузначное число

Вывести содержимое списка по 10 элементов в строке так, чтобы вывод происходил
как-бы по спирали: каждая вторая строка должна выводиться задом наперед.
**Решение задачи:**
Зная номер строки и то, что элементов в строке 10, можно вычислить индексы
первого и последнего элементов в строке. А далее в цикле вывести элементы либо
от первого к последнему, либо от последнего к первому в зависимости от
четности строки.
Номер первого элемента в строке можно определить по формуле i * 10, где i -
это номер строки. Действительно, если строка нулевая, то индекс первого
элемента будет 0, а если строка первая, то индекс будет 10. Индекс же
последнего элемента в строке отличается от первого на 9 единиц, хотя всего
элементов в строке 10.
"Счетчиком" в цикле, выводящем строку элементов задом наперед, является индекс
последнего элемента; он же используется при выводе элемента.

    import random
    a = []
    for i in range(100):
    	a.append(round(random.random() * 50))
    i = 1 # обычный вывод для сравнения
    while i <= 100:
    	print('%4d' % a[i-1], end='')
    	if i%10 == 0: print()
    	i += 1
    print()
    i = 0 # вывод по спирали
    while i < 10:
    	if i%2 == 0:
    		j = i * 10
    		k = j + 9
    		while j <= k:
    			print('%4d' % a[j], end='')
    			j += 1
    		print()
    	else:
    		j = i * 10
    		k = j + 9
    		while j <= k:
    			print('%4d' % a[k], end='')
    			k -= 1
    		print()
    	i += 1

Пример выполнения скрипта:

      29   9  50  36  25   1   2  43  13  41
       0  23  43  45  26  40   1  41   1  44
      47  45   1  38  32   5  40  30  41  25
      25  43  37   9  45  33   6  38  13  47
      33   4  15  18  18  32  29  48  20  18
      49  11  50   8  37  23  25   3  18   5
      50  19  24  44   5  11  25  30  39  35
      17  31  33  18   7  21  41  41   6  48
      19   4  31   9  23  49  39   6  25  21
      27  12  27  25  26  47  18  15   3  33
      29   9  50  36  25   1   2  43  13  41
      44   1  41   1  40  26  45  43  23   0
      47  45   1  38  32   5  40  30  41  25
      47  13  38   6  33  45   9  37  43  25
      33   4  15  18  18  32  29  48  20  18
       5  18   3  25  23  37   8  50  11  49
      50  19  24  44   5  11  25  30  39  35
      48   6  41  41  21   7  18  33  31  17
      19   4  31   9  23  49  39   6  25  21
      33   3  15  18  47  26  25  27  12  27

Дана следующая функция y = f(x):

    y = x - 0.5, при x > 0;
    y = 0, при x = 0;
    y = |x|, при x < 0.

Написать программу, определяющую значение y по переданному значению x.
Поскольку существует три "пути" вычисления значения функции и при этом третий
"путь" однозначно определяется исключением первых двух, то в данном случае
можно использовать конструкцию if-elif-else, а не if-elif-elif.

    print("y = f(x):\n\t| y = x - 0.5, если x > 0\n\t| \
    y = 0, если x = 0\n\t| y = |x|, если x < 0")
    x = float(input("x = "))
    if x > 0:
    	y = x - 0.5
    elif x == 0:
    	y = 0
    else:
    	y = abs(x)
    print('y = %.2f' % y)

В строке, переданной в функцию print(), используются специальные символы '\n'
и '\t'. Первый обозначает переход на новую строку, а второй - табуляцию
(отступ).
Символ '\' в конце строки позволяет перенести длинную строку в коде Python. Но
при выводе она будет выведена в одну линию.
Можно было не использовать ветку else, а использовать еще одну ветку elif с
условием x < 0. Также, в данном случае, вместо выражения y = abs(x) можно было
использовать y = -x. Однако так делать нельзя, если был бы неизвестен знак x.
Пример работы программы:

    y = f(x):
    	| y = x - 0.5, если x > 0
    	| y = 0, если x = 0
    	| y = |x|, если x < 0
    x = 2.3
    y = 1.80

В тексте найти слово под определенным номером (например, пятое слово по
счету). Вывести на экран его первую букву.
В программе ниже переменная count используется, чтобы считать слова, а f -
чтобы определять, находимся ли мы внутри очередного слова или началось новое
слово.
Если началось новое слово, то счетчик слов увеличивается, и если счетчик равен
искомому по номеру слову, то цикл завершается.

    s = input()
    l = len(s)
    n = int(input("Номер слова: "))
    count = 0
    f = 0
    i = 0
    while i < l:
    	if s[i] != ' ' and f == 0:
    		count += 1
    		f = 1
    		if count == n: 
    			break
    	elif s[i] == ' ': 
    		f = 0
    	i += 1
    print(s[i])

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

    один два три четы пять шесть    Номер слова: 4
    ч

Однако с помощью Python решение этой задачи может быть существенно короче:

    s = input()
    l = len(s)
    n = int(input("Номер слова: "))
    s = s.split()
    print(s[n][0])

Метод split() без аргумента разбивает строку на слова по пробелу. Выражение
s[n][0] извлекает из списка n-ый элемент, а затем берет из сроки первый
символ.

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

    Понедельник
    	Физика (лекц.)
    	Физика (лаб.)
    	Алгебра (практ.)
    	
    Вторник
    	Геометрия (лекц.)
    	Физика (практ.)
    	Физика (лаб.)
    	Физкультура (практ.)
    ...

**Алгоритм решения задачи:**
Поскольку в одной строке может встречаться только одно из трех слов (лекц.,
практ., лаб.), то, если найдена одно из этих слов, нет смысла искать
остальные. Поэтому используется конструкция if-else. Если при более "раннем"
if выполняется условие, то вхождение остальных подстрок в строку не
проверяется.
Вхождение подстроки в строку проверяется с помощью метода find() для строк.
Если подстрока есть, то метод возвращает индекс первого символа подстроки в
строке. Если подстроки нет, то возвращается значение -1.

    f = open("lessons.txt")
    lec = pract = lab = 0
    for s in f:
    	i = s.find('лекц.')
    	if i > -1:
    		lec += 1
    	else:
    		i = s.find('практ.')
    		if i > -1:
    			pract += 1
    		else:
    			i = s.find('лаб.')
    			if i > -1:
    				lab += 1
    print('Лекций:', lec)
    print('Практических:', pract)
    print('Лабораторных:', lab)
    f.close()

В Python есть простые логические операторы (=, !=, <, >, <=, >=) и сложные
(and, or, not). Все логические операторы, за исключением not, являются
бинарными. Это значит, что слева и справа от них должны стоять выражения. С
помощью логических операторов эти выражения так или иначе сравниваются между
собой.
Результат логических операций имеет булевый тип данных (встроенный class
'bool' в Python). Нужно быть осторожным, сравнивая между собой разные типы
данных, т. к. это не всегда возможно. Например, нельзя сравнивать числа и
строки, но вещественные и целые числа - можно.
В сложных логических выражениях нужно учитывать последовательность операций.
Если нет уверенности, какая операция имеет приоритет, то лучше использовать
скобки.

    s1 = input("Введите первую строку: ")
    s2 = input("Введите вторую строку: ")
    f1 = input("Введите первое число: ")
    f2 = input("Введите второе число: ")
    f1 = float(f1)
    f2 = float(f2)
    bool_s = s1 > s2
    bool_f = f1 != f2
    bool_or = f1 + f2 > 0 or (s1 != '' and s2 != '')
    print('-'*10)
    print("Первая строка больше второй:", bool_s)
    print("Числа не равны друг другу:", bool_f)
    print("Первая строка больше второй и числа не равны друг другу:", bool_s and bool_f)
    print("Сумма чисел больше нуля ИЛИ ни одна из строк не пуста:", bool_or)

Примерный вывод:

    Введите первую строку: ty
    Введите вторую строку: kl;
    Введите первое число: 6.8
    Введите второе число: 8
    ----------
    Первая строка больше второй: True
    Числа не равны друг другу: True
    Первая строка больше второй и числа не равны друг другу: True
    Сумма чисел больше нуля ИЛИ ни одна из строк не пуста: True

    Введите первую строку: 
    Введите вторую строку: 
    Введите первое число: 7
    Введите второе число: -7
    ----------
    Первая строка больше второй: False
    Числа не равны друг другу: True
    Первая строка больше второй и числа не равны друг другу: False
    Сумма чисел больше нуля ИЛИ ни одна из строк не пуста: False

Квадратное уравнение имеет вид ax2 + bx + c = 0. При его решении сначала
вычисляют дискриминант по формуле D = b2 - 4ac. Если D > 0, то квадратное
уравнение имеет два корня; если D = 0, то 1 корень; и если D < 0, то делают
вывод, что корней нет.
Таким образом, программа для нахождения корней квадратного уравнения может
иметь три ветви условного оператора.
Функция float() преобразует переданный ей аргумент в вещественное число.

    print("Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    discr = b**2 - 4 * a * c;
    print("Дискриминант D = %.2f" % discr)
    if discr > 0:
    	import math
    	x1 = (-b + math.sqrt(discr)) / (2 * a)
    	x2 = (-b - math.sqrt(discr)) / (2 * a)
    	print("x1 = %.2f \nx2 = %.2f" % (x1, x2))
    elif discr == 0:
    	x = -b / (2 * a)
    	print("x = %.2f" % x)
    else:
    	print("Корней нет")

    Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):
    a = 2
    b = 4
    c = 2
    Дискриминант D = 0.00
    x = -1.00

    Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):
    a = 3.2
    b = -7.8
    c = 1
    Дискриминант D = 48.04
    x1 = 2.30 
    x2 = 0.14

    Введите коэффициенты для квадратного уравнения (ax^2 + bx + c = 0):
    a = 8
    b = 4
    c = 2
    Дискриминант D = -48.00
    Корней нет

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

    from random import random
    m1 = int(input())
    m2 = int(input())
    n = int(random() * (m2-m1+1)) + m1
    print(n)
    m1 = float(input())
    m2 = float(input())
    n = random() * (m2-m1) + m1
    print(round(n,3))
    m1 = ord(input())
    m2 = ord(input())
    n = int(random() * (m2-m1+1)) + m1
    print(chr(n))

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

    -10
    10
    8
    0
    1.1
    0.892
    h
    t
    s

Допустим, у нас есть список чисел, из которого надо удалить элементы,
удовлетворяющие определенному условию. Будем удалять из списка, состоящего из
20 чисел в диапазоне от 0 до 100, все элементы, которые больше 35 и меньше 65.
При этом удаляемые числа сохраним в другом списке.
В Python с помощью инструкции del можно удалить элемент списка, указав сам
список и индекс удаляемого элемента.
Алгоритм решения задачи выглядит вроде бы простым: достаточно перебрать
элементы списка и удалить те, которые удовлетворяют условию. Но все не так
просто. При удалении элемента на его место становится следующий, но поскольку
мы переходим к следующему элементу, то пропускаем проверку того, что стал на
место удаленного. Цикл for использовать нельзя, т.к. меняется количество
элементов списка.
Можно использовать цикл while, измеряя на каждой его итерации длину списка,
индекс же увеличивать только в том случае, если удаления элемента не
произошло.

    import random
    a = []
    for i in range(20):
    	n = round(random.random() * 100) # от 0 до 100 включительно
    	a.append(n)
    print("A =",a)
    b = []
    i = 0
    while i < len(a):
    	if 35 < a[i] < 65:
    		b.append(a[i])
    		del a[i]
    	else:
    		i += 1
    print("A =",a)
    print("B =",b)

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

    A = [80, 35, 30, 98, 35, 4, 94, 51, 22, 22, 52, 97, 67, 90, 9, 1, 87, 78, 100, 29]
    A = [80, 35, 30, 98, 35, 4, 94, 22, 22, 97, 67, 90, 9, 1, 87, 78, 100, 29]
    B = [51, 52]

    A = [68, 88, 64, 39, 13, 99, 6, 35, 50, 76, 47, 82, 76, 87, 44, 86, 75, 46, 8, 32]
    A = [68, 88, 13, 99, 6, 35, 76, 82, 76, 87, 86, 75, 8, 32]
    B = [64, 39, 50, 47, 44, 46]

В Python v.3 для строк используется кодировка Unicode. (Следует помнить, что в
Python, в отличие от других языков программирования, вообще нет такого типа
как одиночный символ; любой символ это строка, длина которой равна 1.)
Первые 128 символов по таблице Unicode такие же как и в таблице символов
ASCII. Выведим их (начиная с пробела - 32-й символ). Чтобы привести вывод к
табличной форме будем переходить на новую строку после каждого десятого
символа (инструкция if в коде ниже).
Функция chr() возвращает символ из таблицы Unicode, соответствующий
переданному коду-числу.

    for i in range(32,128):
    	print(chr(i), end=' ')
    	if (i-2) % 10 == 0:
    		print()
    print()

Результат выполнения кода:

      ! " # $ % & ' ( ) * 
    + , - . / 0 1 2 3 4 
    5 6 7 8 9 : ; < = > 
    ? @ A B C D E F G H 
    I J K L M N O P Q R 
    S T U V W X Y Z [ \ 
    ] ^ _ ` a b c d e f 
    g h i j k l m n o p 
    q r s t u v w x y z 
    { | } ~  

Но допустим, нам захотелось или потребовалось узнать коды символов русских
букв (кирилицы). Таблица Unicode очень большая и включает почти все алфавиты
Земли. Однако предположим, что кирилица должна быть закодирована где-то в
начале таблицы (ведь русский - один из распространенных языков мира).
Переберем коды символов от 256 до 10000), и если какой-либо код из этого
диапазона соответствует русской букве (прописной или строчной), то выведем на
экран сам код и букву, которой он соответствует.

    for i in range(256,10000):
    	if 'а'<=chr(i)<='я' or 'А'<=chr(i)<='Я':
    		print(i,'-', chr(i))

Результат выполнения кода:

    1040 - А
    1041 - Б
    1042 - В
    1043 - Г
    1044 - Д
    1045 - Е
    1046 - Ж
    1047 - З
    1048 - И
    1049 - Й
    1050 - К
    1051 - Л
    1052 - М
    1053 - Н
    1054 - О
    1055 - П
    1056 - Р
    1057 - С
    1058 - Т
    1059 - У
    1060 - Ф
    1061 - Х
    1062 - Ц
    1063 - Ч
    1064 - Ш
    1065 - Щ
    1066 - Ъ
    1067 - Ы
    1068 - Ь
    1069 - Э
    1070 - Ю
    1071 - Я
    1072 - а
    1073 - б
    1074 - в
    1075 - г
    1076 - д
    1077 - е
    1078 - ж
    1079 - з
    1080 - и
    1081 - й
    1082 - к
    1083 - л
    1084 - м
    1085 - н
    1086 - о
    1087 - п
    1088 - р
    1089 - с
    1090 - т
    1091 - у
    1092 - ф
    1093 - х
    1094 - ц
    1095 - ч
    1096 - ш
    1097 - щ
    1098 - ъ
    1099 - ы
    1100 - ь
    1101 - э
    1102 - ю
    1103 - я

Теперь мы знаем коды русских букв по таблице Unicode. Но вывод получился
какой-то некомпактный. К тому же мы видим, что буквы алфавита идут одна за
другой. Поэтому достаточно сначала узнать только код первой большой буквы
алфавита (прописные символы идут всегда впереди строчных) и код последней
маленькой буквы алфавита. Кроме того, если мы нашли коды символов, то незачем
далее продолжать цикл. Поэтому перепишем программу следующим образом:

    first = 0
    last = 0
    for i in range(255,10000):
    	if chr(i) == 'А':
    		first = i
    	elif chr(i) == 'я':
    		last = i
    		break # выход из цикла
    j = 0		
    for i in range(first,last+1):
    	print(i,'-', chr(i), end=' ')
    	j += 1
    	if j%10 == 0: print()
    print()

Результат выполнения кода:

    1040 - А 1041 - Б 1042 - В 1043 - Г 1044 - Д 1045 - Е 1046 - Ж 1047 - З 1048 - И 1049 - Й 
    1050 - К 1051 - Л 1052 - М 1053 - Н 1054 - О 1055 - П 1056 - Р 1057 - С 1058 - Т 1059 - У 
    1060 - Ф 1061 - Х 1062 - Ц 1063 - Ч 1064 - Ш 1065 - Щ 1066 - Ъ 1067 - Ы 1068 - Ь 1069 - Э 
    1070 - Ю 1071 - Я 1072 - а 1073 - б 1074 - в 1075 - г 1076 - д 1077 - е 1078 - ж 1079 - з 
    1080 - и 1081 - й 1082 - к 1083 - л 1084 - м 1085 - н 1086 - о 1087 - п 1088 - р 1089 - с 
    1090 - т 1091 - у 1092 - ф 1093 - х 1094 - ц 1095 - ч 1096 - ш 1097 - щ 1098 - ъ 1099 - ы 
    1100 - ь 1101 - э 1102 - ю 1103 - я 

В стороке заменить подстроку, находящуюся между первой открывающей квадратной
скобкой и соответствующей ей закрывающей.
Сложность данной задачи заключается в том, что между первой открывающей и
соответствующей ей закрывающей скобками, могут быть другие скобки. Например, в
строке 'a[bc[de]f]gh[jkl]' первая открывающая находится после символа 'a', а
соответствующая ей закрывающая - после символа 'f'. Т. е. по условию задачи в
данном примере замене подлежит подстрока '[bc[de]f]'.
Чтобы найти соответствующую закрывающую, в программе ниже вводится счетчик
последующих открывающих скобок, и пока он не будет равен нулю, все закрывающие
скобки соответствующими первой открывающей не считаются.

    s = input("Введите исходную строку: ")
    p1 = -1 # индекс первой открывающей скобки
    i = 0
    while i < len(s):
    	if s[i] == '[':
    		p1 = i # мы нашли скобку (ее индекс), 
    		break # дальше просматривать строку бессмысленно
    	i += 1
    if p1 == -1: exit() # открывающей скобки нет, выходим из программы
    p2 = -1 # индекс закрывающей скобки, соответствующей первой открывающей
    count = 0 # счетчик остальных открывающих скобок
    i += 1 # будем просматривать строку со следующего символа за тем, на котором остановились ранее
    while i < len(s): 
    	if s[i] == '[': 
    		count += 1
    	elif s[i] == ']': # встретилась закрывающая скобка 
    		if count == 0: # и счетчик равен нулю
    			p2 = i # значит это закрывающая скобка от первой открывающей
    			break # нет смысла просматривать дальше
    		else: # встретилась закрывающая скобка, но счетчик открыващих не равен нулю,
    			count -= 1 # значит была закрыта какая-то другая, но не первая скобка.
    	i += 1
    if p2 == -1: exit() # закрывающей скобки нет, выходим из программы
    s_in = input("Введите подстроку для вставки: ")
    s_out = s[p1+1:p2] # скобки не берем
    print("Вырезанная подстрока:", s_out)
    s = s[:p1] + s_in + s[p2+1:]
    print("Новая строка:", s)

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

    Введите исходную строку: [who[is]it] is big master-[kunfu?].
    Введите подстроку для вставки: Bob Green 
    Вырезанная подстрока: who[is]it
    Новая строка: Bob Green is big master-[kunfu?].
========
    Введите исходную строку: hello [world]
    Введите подстроку для вставки: space
    Вырезанная подстрока: world
    Новая строка: hello space

Вводится целое число. Вывести число, обратное по порядку составляющих его цифр
введенному. Например, введено 3425, надо вывести 5243.
**Алгоритм:**
1. Найдем остаток от деления на 10 исходного числа. Получим последнюю его цифру.
2. Добавим эту цифру к новому числу.
3. Разделим нацело на 10 исходное число. Тем самым избавимся от последней цифры в нем.
4. Снова найдем остаток от деления на 10 того, что осталось от первого числа. Запомним эту цифру.
5. Умножим на 10 второе число. Тем самым увеличим его разрядность до двух и сдвинем первую цифру в разряд десятков.
6. Добавим к полученному второму числу запомненную ранее цифру из первого числа.
7. Будем повторять действия п.3-6 пока исходное число не уменьшится до нуля, т.е. пока не избавимся от всех его разрядов.

    n1 = int(input("Введите целое число: "))
    n2 = 0
    while n1 > 0:
    	digit = n1 % 10; # находим остаток - последнюю цифру числа
    	n1 = n1 // 10; # делим нацело - убираем из числа последнюю цифру
    	n2 = n2 * 10 # увеличиваем разрядность второго числа
    	n2 = n2 + digit # добавляем очередную цифру
    print('"Обратное" ему число:',n2)

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

    Введите целое число: 32809
    "Обратное" ему число: 90823

    Введите целое число: 78290
    "Обратное" ему число: 9287

Написать программу, умеющую выполнять над двумя вещественными числами
арифметические операции (сложение, вычитание, умножение, деление) и
завершающуюся по желанию пользователя.
**Алгоритм:**
1. Запустить бесконечный цикл. Выход из него осуществлять с помощью оператора break, если пользователь вводит определенный символ вместо знака арифметической операции.
2. Если пользователь ввел знак, который не является ни знаком арифметической операции, ни символом-"прерывателем" работы программы, то вывести сообщение о некорректном вводе.
3. Если был введен один из четырех знаков операции, то запросить ввод двух чисел.
4. В зависимости от знака операции выполнить соответствующее арифметическое действие.
5. Если было выбрано деление, то необходимо проверить не является ли нулем второе число. Если это так, то сообщить о невозможности деления.

    print("Ноль в качестве знака операции завершит работу программы")
    while True:
    	s = input("Знак (+,-,*,/): ")
    	if s == '0': break
    	if s in ('+','-','*','/'):
    		x = float(input("x="))
    		y = float(input("y="))
    		if s == '+':
    			print("%.2f" % (x+y))
    		elif s == '-':
    			print("%.2f" % (x-y))
    		elif s == '*':
    			print("%.2f" % (x*y))
    		elif s == '/':
    			if y != 0:
    				print("%.2f" % (x/y))
    			else:
    				print("Деление на ноль!")
    	else:
    		print("Неверный знак операции!")

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

    Ноль в качестве знака операции завершит работу программы
    Знак (+,-,*,/): h
    Неверный знак операции!
    Знак (+,-,*,/): +
    x=78.456
    y=23.567
    102.02
    Знак (+,-,*,/): -
    x=3.44
    y=10.25
    -6.81
    Знак (+,-,*,/): *
    x=0.012
    y=-2.15
    -0.03
    Знак (+,-,*,/): /
    x=5 
    y=0
    Деление на ноль!
    Знак (+,-,*,/): /
    x=-2.3
    y=5
    -0.46
    Знак (+,-,*,/): 0

Уравнение прямой на координатной плоскости имеет следующий вид: y = kx + b.
Если известны координаты двух точек, лежащих на этой прямой, то можно, решая
систему уравнений, определить значения коэффициентов k и b. Таким образом
выводится уравнение конкретной прямой, например, у = 3x - 1.
Решаем систему уравнений:
| y1 = kx1 + b
| y2 = kx2 + b
b = y2 - kx2
y1 = kx1 + y2 - kx2
k = (y1 - y2) / (x1 - x2)

    print("Координаты точки A(x1;y1):")
    x1 = float(input("\tx1 = "))
    y1 = float(input("\ty1 = "))
    print("Координаты точки B(x2;y2):")
    x2 = float(input("\tx2 = "))
    y2 = float(input("\ty2 = "))
    print("Уравнение прямой, проходящей через эти точки:")
    k = (y1 - y2) / (x1 - x2)
    b = y2 - k*x2
    print(" y = %.2f*x + %.2f" % (k, b))

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

    Координаты точки A(x1;y1):
    	x1 = 4.3
    	y1 = -1.2
    Координаты точки B(x2;y2):
    	x2 = -8.5
    	y2 = 4
    Уравнение прямой, проходящей через эти точки:
     y = -0.41*x + 0.55

    Координаты точки A(x1;y1):
    	x1 = -10
    	y1 = -1
    Координаты точки B(x2;y2):
    	x2 = 10
    	y2 = -2 
    Уравнение прямой, проходящей через эти точки:
     y = -0.05*x + -1.50

Вводятся два числа в двоичной системе счисления. Требуется выполнить над ними
побитовые операции И, ИЛИ и исключающего ИЛИ. В конце вывести результат
операций также в двоичном представлении.
Побитовые операции выполняются над разрядами числа. Так если имеем два числа
101 и 100, над которыми выполняется побитовая операция ИЛИ, то получим
двоичное число 101:
101
100
101
В языке программирования Python побитовые операции выполняются над числами,
представленными в десятичной системе счисления. Знаки побитовых операций: | -
ИЛИ, & - И, ^ - искл. ИЛИ.
Функция int() всегда преобразует переданную ей строку в десятичную систему
счисления. Но можно указать, в какой системе счисления содержатся данные в
этой строке (двоичной, восьмеричной, шестнадцатеричной).
Функция bin() наоборот принимает десятичное число и возвращает строку,
являющуюся представлением переданного числа в двоичном виде.

    n1 = input("Введите первое двоичное число: ")
    n2 = input("Введите второе двоичное число: ")
    n1 = int(n1,2)
    n2 = int(n2,2)
    bit_or = n1 | n2
    bit_and = n1 & n2
    bit_xor = n1 ^ n2
    print("Результат побитового OR: %10s" % bin(bit_or))
    print("Результат побитового AND: %10s" % bin(bit_and))
    print("Результат побитового XOR: %10s" % bin(bit_xor))

Результат:

    Введите первое двоичное число: 10100
    Введите второе двоичное число: 10001
    Результат побитового  OR:    0b10101
    Результат побитового AND:    0b10000
    Результат побитового XOR:      0b101

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

    print("Загадайте в уме число от 1 до 5", end = ' ')
    input("и нажмите Enter")
    a = input("Ваше число больше 3-х? (y/n) ")
    if a == 'y':
    	a = input("Ваше число 4? (y/n) ")
    	if a == 'n':
    		print("Ваше число 5")
    else:
    	a = input("Ваше число 1? (y/n) ")
    	if a == 'n':
    		a = input("Ваше число 2? (y/n) ")
    		if a == 'n':
    			print("Ваше число 3")
    print("Я угадал!")

Варианты выполнения программы

    Загадайте в уме число от 1 до 5 и нажмите Enter 
    Ваше число больше 3-х? (y/n) n
    Ваше число 1? (y/n) y
    Я угадал!

    Загадайте в уме число от 1 до 5 и нажмите Enter
    Ваше число больше 3-х? (y/n) y
    Ваше число 4? (y/n)y
    Я угадал!

Возьмем, например, такое уравнение: 5x + 10y + 15z = 100. Какие значения
должны иметь переменные x, y, z, чтобы уравнение было верным (т. е. каковы
корни уравнения)? Они могут быть такими: x = 1, y = 8, z = 1. Или такими: x =
4, y = 2, z = 4. Становится понятно, что корней у подобных уравнений может
быть множество.
Требуется написать программу, выводящую на экран все возможные корни уравнения
вида ax + by + cz = d, где a, b, c, d - коэффициенты (известны), а x, y, z -
переменные (требуется найти). При этом пусть все числа должны быть
натуральными числами (т. е. > 0).
Решается данная задача методом перебора всех возможных значений x, y, z с
учетом их коэффициентов. Так если a = 10 и d = 100, то x может принять
значения от 1 до 10, т.к. 10 * 10 = 100.

    # Найти все возможные корни уравнения вида
    # ax + by + cz = d, где a, b, c, d - задаются,
    # x, y, z - требуется найти.
    # Все числа (коэффициенты и переменные) - натуральные числа (т.е. > 0).
    d = int(input('s = '))
    a = int(input('a = '))
    b = int(input('b = '))
    c = int(input('c = '))
    for i in range(1,d//a):
    	for j in range(1,d//b):
    		for k in range(1,d//c):
    			if i*a + j*b + k*c == d:
    				print("%d*%d + %d*%d + %d*%d = %d" % (a,i,b,j,c,k,d))

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

    s = 20
    a = 2
    b = 4
    c = 6
    2*1 + 4*3 + 6*1 = 20
    2*2 + 4*1 + 6*2 = 20
    2*3 + 4*2 + 6*1 = 20
    2*5 + 4*1 + 6*1 = 20

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

    summa = int(input("Сколько у вас денег? "))
    subj1 = int(input("Цена экземпляра товара 1: "))
    subj2 = int(input("Цена экземпляра товара 2: "))
    subj3 = int(input("Цена экземпляра товара 3: "))
    for i in range(1, summa // subj1):
    	for j in range(1,summa // subj2):
    		for k in range(1,summa // subj3):
    			if subj1 * (i) + subj2*(j)+subj3*(k) == summa: 
    				print(i,j,k)

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

    Сколько у вас денег? 100
    Цена экземпляра товара 1: 10
    Цена экземпляра товара 2: 20
    Цена экземпляра товара 3: 30
    1 3 1
    2 1 2
    3 2 1
    5 1 1

При этом если ставится условие, чтобы всего количество предметов равнялось
какому-то числу или было не меньше какого-то числа, то в условии инструкции if
следует через логический оператор and добавить второе условие (например, a + b
+ c > 5).

Вводится строка. Необходимо определить в ней проценты прописных (больших) и
строчных (малых) букв.
Как известно в кодировках символы упорядочены, т.е. коды 'a' < 'b'. Поэтому
если очередной символ принадлежит диапазону от 'a' до 'z', значит это строчная
буква; если диапазону от 'A' до 'Z' - то прописная.
Следует использовать ветку elif, а не else, т. к. помимо букв могут быть иные
символы (пробелы, цифры, знаки препинания и др.).
В языке программирования Python можно выполнять "групповое" присваивание. Так
выражение let_s = let_b = 0 является допустимым и означает, что сначала
переменной let_b был присвоен 0, затем значение let_b было присвоено let_s.

    string = input("Введите текст: ")
    length = len(string)
    let_s = let_b = 0
    for i in string:
    	if 'a'<=i<='z':
    		let_s += 1
    	elif 'A'<=i<='Z':
    		let_b += 1
    print("%% строчных букв: %.2f" % (let_s/length * 100))
    print("%% прописных букв: %.2f" % (let_b/length * 100))

Удвоенный знак процента в начале строки вывода стоит для того, чтобы вывести
один знак процента. Иначе одиночный % интерпретируется как начало формата
вывода.
Пример выполнения кода:

    Введите текст: Hello, M!
    % строчных букв: 44.44
    % прописных букв: 22.22

Вывести степени натуральных чисел, не превосходящие данного числа n.
Пользователь задает показатель степени и число n.
**Алгоритм решения задачи:**
1. Ввести показатель степени и присвоить его переменной p.
2. Ввести число n.
3. Пока натуральное число (i) возведенное в степень p меньше или равно n, то
4. выводить на экран i в степени p и
5. увеличивать i на 1 (т.е. переходить к следующему натуральному числу).

    # возведение чисел в заданную степень до заданного предела
    p = int(input("Показатель степени: "))
    n = int(input("Максимальный предел степени: "))
    i = 1
    while i**p <= n:
    	print(i**p, end=' ')
    	i += 1
    print("\nПоследнее число, возводимое в степень:", i-1)

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

    Показатель степени: 2
    Максимальный предел степени: 100
    1 4 9 16 25 36 49 64 81 100 
    Последнее число, возводимое в степень: 10

    Показатель степени: 3
    Максимальный предел степени: 555
    1 8 27 64 125 216 343 512 
    Последнее число, возводимое в степень: 8

Тема:
Строки

Вводится натуральное число (> 0). Необходимо найти сумму и произведение цифр,
из которых состоит это число. При этом если в числе встречается цифра 0, то ее
не надо учитывать при нахождении произведения.
Алгоритм решения задачи сводится к извлечению последней цифры числа путем
нахождения остатка от деления на 10 и добавлению ее к произведению и сумме.
Далее следует само число разделить нацело на 10, чтобы избавится от последней
цифры. Эти действия следует выполнять до тех пор, пока число больше 0. На
последней итерации цикла однозначное число делится нацело на 10, в результате
чего получается 0 и цикл завершается.
В коде ниже выражение добавления цифры к сумме также можно поместить в ветку if.

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

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

    n = input()
    mult = 1
    summa = 0
    for i in n:
    	summa += int(i)
    	if int(i) != 0:
    		mult *= int(i)
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)

Примечание. Выражение summa += int(i) - это то же самое, что summa = summa +
int(i). Та же сокращенная форма используется и для умножения.
Через строковое представлениие легко решить и более сложную задачу. Например,
надо посчитать сумму и произведение цифр дробного числа или всех цифр,
встречающихся в строке. В таком случае решение может быть таким:

    n = input()
    mult = 1
    summa = 0
    for i in n:
    	if i in ['1','2','3','4','5','6','7','8','9']: # или '1' <= i <= '9'
    		summa += int(i)
    		if int(i) != 0:
    			mult *= int(i)
    print("Сумма цифр:", summa)
    print("Произведение значащих цифр:", mult)

В прямоугольной системе координат на плоскости выделяют четверти:
![Четверти в прямоугольной системе координат](http://upload.wikimedia.org/wiki
pedia/commons/thumb/d/dd/Descartes_system_2D.png/300px-
Descartes_system_2D.png)
1. I-й четветри соответствуют точки, имеющие обе (x и y) положительные координаты.
2. II-ая четверть: x < 0, y > 0.
3. III-ая четверть: x < 0, y < 0.
4. IV-ая четверть: x > 0, y < 0.

    print("Введите координаты точки:")
    x = float(input("x = "))
    y = float(input("y = "))
    if x > 0 and y > 0:
    	print("Точка находится в I четверти")
    elif x < 0 and y > 0:
    	print("Точка находится в II четверти")
    elif x < 0 and y < 0:
    	print("Точка находится в III четверти")
    elif x > 0 and y < 0:
    	print("Точка находится в IV четверти")
    elif x == 0 and y == 0:
    	print("Точка находится в начале координат")
    elif x == 0:
    	print("Точка находится на оси 'x'")
    elif y == 0:
    	print("Точка находится на оси 'y'")

Задачу можно решить и так:

    if x == 0 and y == 0:
    	print("Точка находится в начале координат")
    elif x == 0:
    	print("Точка находится на оси 'x'")
    elif y == 0:
    	print("Точка находится на оси 'y'") 
    elif x > 0:
    	if y > 0:
    		print("Точка находится в I четверти")
    	elif y < 0:
    		print("Точка находится в IV четверти")
    elif x < 0:
    	if y > 0:
    		print("Точка находится в II четверти")
    	elif y < 0:
    		print("Точка находится в III четверти

Результат:

    Введите координаты точки:
    x = 6
    y = -3
    Точка находится в IV четверти

Определить, принадлежит ли точка с координатами (x;y) кругу радиуса R с
центром в начале координат.
Пользователь вводит координаты точки и радиус круга.
Если выбрать точку на координатной плоскости, то можно увидеть, что проекции
ее координат на оси x и y являются катетами прямоугольного треугольника. А
гипотенуза этого прямоугольного треугольника как раз показывает расстояние от
начала координат до точки. Таким образом, если длина гипотенузы будет меньше
радиуса круга, то точка будет принадлежать кругу; иначе она будет находится за
его пределами.
Длину гипотенузы можно вычислить по теореме Пифагора: квадрат гипотенузы равен
сумме квадратов катетов.

    import math
    print("Введите координаты точки и радиус круга")
    x = float(input("x = "))
    y = float(input("y = "))
    r = float(input("R = "))
    r_xy = math.sqrt(x**2 + y**2)
    if r_xy <= r:
    	print("Точка принадлежит кругу")
    else:
    	print("Точка НЕ принадлежит кругу")

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

    x = 1
    y = -1
    R = 3
    Точка принадлежит кругу

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

Определить, сколько в введенном пользотелем числе четных цифр, а сколько
нечетных.
Если число делится без остатка на 2 (т. е. остаток равен нулю), значит оно
четное. Увеличиваем на 1 счетчик четных цифр (even). Иначе число нечетное,
увеличиваем счетчик нечетных цифр (odd). В Python операцию нахождения остатка
от деления выполняет знак %.
Чтобы избавиться от младшего (уже учтенного) разряда число следует разделить
нацело на 10. Деление нацело обозначается так: //.

    a = input()
    a = int(a)
    even = 0
    odd = 0
    while a > 0:
    	if a % 2 == 0:
    		even += 1
    	else:
    		odd += 1
    	a = a // 10
    print("Even: %d, odd: %d" % (even, odd))

Примерный результат:

    65439
    Even: 2, odd: 3

Пользователь вводит либо количество байт, либо килобайт, мегабайт или
гигабайт. Следует перевести значение во все другие единицы измерения.
В 1Кб 1024 байт, 1Мб = 1024Кб и т. д. 1024 - это 210.

    units = input("Выберите единицы измерения:\n \
    \t1 - байты,\n \
    \t2 - килобайты,\n \
    \t3 - мегабайты,\n \
    \t4 - гигабайты.\n№: ")
    qty = float(input("Введите значение: "))
    if units == '1':
    	print("Килобайты: %10.3f" % (qty / 2**10))
    	print("Мегабайты: %10.3f" % (qty / 2**20))
    	print("Гигабайты: %10.3f" % (qty / 2**30))
    elif units == '2':
    	print("Байты: %14d" % (qty * 2**10))
    	print("Мегабайты: %10.3f" % (qty / 2**10))
    	print("Гигабайты: %10.3f" % (qty / 2**20))
    elif units == '3':
    	print("Байты: %14d" % (qty * 2**20))
    	print("Килобайты: %10d" % (qty * 2**10))
    	print("Гигабайты: %10.3f" % (qty / 2**10))
    elif units == '4':
    	print("Байты: %14d" % (qty * 2**30))
    	print("Килобайты: %10d" % (qty * 2**20))
    	print("Мегабайты: %10d" % (qty * 2**10))

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

    Выберите единицы измерения:
     	1 - байты,
     	2 - килобайты,
     	3 - мегабайты,
     	4 - гигабайты.
    №: 2
    Введите значение: 1679
    Байты:        1719296
    Мегабайты:      1.640
    Гигабайты:      0.002

    Выберите единицы измерения:
     	1 - байты,
     	2 - килобайты,
     	3 - мегабайты,
     	4 - гигабайты.
    №: 4
    Введите значение: 1.345
    Байты:     1444182753
    Килобайты:    1410334
    Мегабайты:       1377

Найти остаток от деления целой части значения функции y = log(x²+ab) на 7 и, в
зависимости от его величины, напечатать сообщение об одном из дней недели.
Значения переменных а, b, x получить случайным образом на указанном
пользователем интервале.
Поскольку три случайных числа вычисляются по одной и той же формуле, то лучше
ее оформить в отдельную функцию.
Функци log модуля math вычисляет натуральный логарифм (если ей не передан
второй аргумент-основание алгоритма).
Для определения дня недели можно было бы использовать условный оператор, но
вариант со списком намного короче.

    import random
    import math
    def rand(s,m):
    	return random.random() * (m - s) + s
    minim = float(input('min: '))
    maxim = float(input('max: '))
    a = rand(minim, maxim)
    b = rand(minim, maxim)
    x = rand(minim, maxim)
    y = math.log(x**2 + a * b)
    n = int(y) % 7
    days = ['пн','вт','ср','чт','пт','сб','вс']
    print(days[n])

    min: 1.6
    max: 9.9
    пт

В списке, состоящем из положительных и отрицательных целых чисел, найти
первый, третий и шестой положительные элементы и вычислить их произведение.
Задача усложнена тем, что, например, третий по счету положительный элемент
может быть далеко не третим в списке, а каким угодно.
**Основная часть алгоритма решения задачи:**
1. Ввести в программу счетчик положительных элементов (j). Присвоить ему значение 1 (т.е. он указывает на первый положительный элемент).
2. Перебирать элементы массива-списка по-очереди. Если очередной элемент положительный и счетчик положительных элементов равен 1 или 3 или 6, то сохранить в соответствующей переменной индекс данного элемента. Кроме того, если шестой положительный элемент найден, то нет смысла продолжать цикл дальше и можно его завершить (оператор `break`).
3. Если в массиве был найден шестой положительный элемент (первый и третий тогда точно найдены), то вычислить произведение.
В программе ниже для заполнения списка используется так называемый генератор.
В данном случае выражение `round(random.random() * 100) - 50` используется в
цикле, который выполняется 20 раз. И на каждой итерации цикла получившееся
число помещается в список a.

    import random
    a = [round(random.random() * 100) - 50 for i in range(20)]
    print(a)
    i = j = 0
    i1 = i3 = i6 = -1
    while i < 20:
    while i < 20:
    	if a[i] > 0:
    		if j == 1:
    			i1 = i
    		elif j == 3:
    			i3 = i
    		elif j == 6:
    			i6 = i
    			break
    		j += 1
    	i += 1
    if i6 > 0:
    	mult = a[i1] * a[i3] * a[i6]
    	print("Индексы элементов:", i1, i3, i6)
    	print("%d * %d * %d = %d" % (a[i1], a[i3], a[i6], mult))

    [-45, 30, 31, -40, 22, -48, -18, -24, -21, 25, -38, 43, 30, 15, -33, -41, -8, 29, 26, 24]
    Индексы элементов: 1 4 12
    30 * 22 * 30 = 19800

В решении данной задачи можно выделить три части:
1. Заполнение квадратной матрицы
2. Вызов функции
3. Функция
#### Заполнение квадратной матрицы
В терминах языка программирования Python матрица - это список с вложенными
списками одинаковой длины. Если говорить о квадратной матрице (а только в этом
случае имеет смысл говорить о ее диагоналях), то количество вложенных списков
и количество элементов в них должно совпадать. Например, список
[[12,45,18][0,3,10][21,18,6]] можно назвать квадратной матрицей.
Пусть квадратная матрица заполняется случайными числами и ее размерность будет
равна 10 (т. е. 10 строк и 10 столбцов). Перед заполнением матрицы, создается
пустой список. Во внешнем цикле осуществляется проход по строкам, которые
представляют собой вложенные списки. Сначала создается пустой вложенный
список, потом во внутреннем цикле он заполняется случайными числами, после
чего уже заполненный добавляется в основной список. При заполнении матрицы
может также осуществляться вывод ее на экран.
#### Вызов функции
Поскольку функция должна уметь по выбору вычислять как сумму главной, так и
побочной диагонали, то в нее необходимо передавать не только список, но и
"сигнал" о том, по какому пути ей идти. Если функция будет возвращать
полученную сумму в основную ветку программы, то вызов функции надо связать с
переменной или поместить как аргумент в функцию `print()`.
Перед вызовом функции надо получить значение переменной-"сигнала". Сумму какой
диагонали вычислять, может выбрать пользователь. Например, если он вводит
символ '1', то вычислять главную диагональ, если '2', то побочную. Так как
пользователь может ввести не только эти символы, а какие угодно, то разумно
заключить вызов функции и вывод результата на экран в конструкцию `if`,
условием выполнения которой будет правильно введенный символ.
#### Функция
При написании функции надо сделать выбор, будет ли она выводить результат на
экран в своем теле или возвращать в основную ветку программы. Пусть функция
возвращает результат, в таком случае она должна содержать оператор return
(обычно, но не обязательно, в конце тела функции), после которого указывается
возвращаемое значение.
Главная диагональ квадратной матрицы идет от левого верхнего угла до нижнего
правого, и, следовательно, каждый элемент такой диагонали имеет совпадающие
первый и второй индексы. При этом индексы следующего элемента диагонали
отличаются от предыдущего на 1. Т.е. первый элемент главной диагонали имеет
индексы [0][0], второй - [1][1] и т.д. Поэтому для нахождения суммы элементов
главной диагонали, надо построчно перебрать матрицу и в каждой строке взять
элемент, номер которого совпадает с номером строки, и добавить его значение в
общую сумму.
Побочная диагональ идет из верхнего правого угла в нижний левый. Индексы ее
элементов обратны. В первой строке это будет последний элемент, во второй -
предпоследний и т.д. Если i - это номер строки, равный в начале 0, то второй
индекс будет вычисляться как (N-1)-i. Выражение (N-1) - это индекс последнего
элемента при индексации с нуля.

    def diagonal(l,c):
        s = 0
        i = 0
        while i < N:
            if c == '1':
                s += l[i][i]
            else:
                s += l[i][N-i-1]
            i += 1
        return s
    from random import random
    N = 10
    a = []
    for i in range(N):
        b = []
        for j in range(N):
            n = int(random()*10)
            b.append(n)
            print("%3d" % n, end='')
        a.append(b)
        print()
    ch = input("Главная (1) или побочная (2): ")
    if ch == '1' or ch == '2':
        summa = diagonal(a,ch)
        print(summa)

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

      1  0  3  6  9  1  6  6  4  1
      2  2  5  2  5  7  0  9  9  0
      4  6  2  1  2  4  0  7  2  8
      6  8  6  3  8  8  5  8  6  9
      0  1  2  1  0  3  8  5  0  1
      5  2  2  7  4  6  4  8  4  1
      1  2  3  9  8  1  1  6  0  6
      9  8  5  3  5  3  6  2  8  7
      8  9  1  4  3  0  0  4  4  1
      3  3  2  2  4  6  1  2  2  4
    Главная (1) или побочная (2): 1
    25

Требуется вычислить, сколько банок краски потребуется, чтобы окрасить
поверхность бака цилиндрической формы. Покрасить надо и снаружи, и изнутри.
Пользователь вводит диаметр и высоту бака, а также какую площадь можно
окрасить одной банкой краски.
Чтобы понять, сколько банок краски потребуется, надо знать площадь цилиндра.
Она представляет собой сумму площадей двух кругов (крышка баки и дно) и
площади непосредственно цилиндрической поверхности. Кроме того, если бак
красится и изнутри, найденную площедь следует умножить на 2.
Площадь круга через диаметр равна pi * d2 / 4.
Площадь цилиндра: pi * d * h (где d и h - диаметр и высота цилиндра).

    d = input("Диаметр бака: ")
    d = float(d)
    h = input("Высота бака: ")
    h = float(h)
    S = input("Окрашиваемая площадь одной банкой: ")
    S = int(S)
    import math
    circle = math.pi * d**2 / 4 
    cylinder = math.pi * d * h
    total = circle * 4 + cylinder * 2 # учитываем и внутреннюю поверхность
    qty = total / S # количество банок краски
    qty = int(qty) + 1 
    print("Количество требуемых банок:", qty)

Выражение `int(qty) + 1` требуется, если надо найти целое значение количества
банок (ведь пол банки не купишь).

Найти сумму и количество элементов последовательности, которые по модулю
больше 0.001. Последовательность: 1/2 - 2/4 + 3/8 - 4/16 + ... - ...
В данной последовательности каждый последующий элемент отличается от
предыдущего:
* знаком,
* числитель увеличен на 1,
* знаменатель увеличен в 2 раза.
Значит каждый следующий элемент ряда вычисляется из текущего по формуле
-(a+1)/(b*2), где a и b \- числитель и знаменатель дроби числа ряда.

    a = 1 # числитель
    b = 2 # знаменатель
    sign = 1 # умножаем на 1 или -1, чтобы поменять знак числа
    n = 0 # количество чисел ряда
    summa = 0 # сумма n-элементов ряда чисел
    while a/b > 0.001:
    	summa += sign * a / b
    	n += 1
    	a = a + 1
    	b = b * 2
    	sign = -sign
    print(summa)
    print(n)

Результат выполнения кода:

    0.2227783203125
    13

Найти расстояние между точками с заданными координатами в n-мерном
пространстве. Расстояние находится по формуле d = sqrt((a1 - b1)2 + (a2 -
b2)^2 + ... + (an - bn)^2), где sqrt - квадратный корень, а1...an -
координаты первой точки, b1..bn - соответствующие координаты второй точки.
#### Особенности решения задачи
Чтобы не вводить каждую координату отдельно, можно запросить сразу все для
каждой точки. Поскольку данные будут иметь строковый тип, то преобразовать их
к списку можно с помощью функции split(). В качестве аргумента функции
передается строка-разделитель, по которому отделяются элементы; если аргумент
отсутствует, то строка разделяется по пробелу. Несмотря на такое разделение,
каждый элемент списка по-прежнему является строкой, а не числом.
Фунция zip() возвращает кортежи соответствующих элементов последовательностей.
Т.е. если ей передать два списка, то на первой итерации будет возвращен кортеж
из первых элементов обоих списков, на второй - из вторых и т. д.

    import math
    n = input("Количество измерений пространства: ")
    print("Через пробел")
    a = input("введите " + n + " координаты 1-ой точки: ")
    b = input("введите " + n + " координаты 2-ой точки: ")
    n = int(n)
    a = a.split()
    b = b.split()
    if len(a) != n or len(b) != n: 
    	print("Неверный ввод!")
    	exit()
    sum_sqr = 0
    for i, j in zip(a,b):
    	sum_sqr += (int(i)-int(j))**2
    distance = math.sqrt(sum_sqr)
    print("Расстояние между точками: %.2f" % distance)

Пример работы программы:

    Количество измерений пространства: 4
    Через пробел
    введите 4 координаты 1-ой точки: 2 3 -7 4
    введите 4 координаты 2-ой точки: 0 0 0 0
    Расстояние между точками: 8.83

Вычислить продолжительность года на двух планетах по введенным их радиусам
орбит и скорости движения по орбитам.
Выяснить, правда ли, что год на первой платете длиннее, чем на второй.
Продолжительность года вычисляется по формуле 2 * радиус_орбиты * пи /
орбитальная_скорость.

    import math
    planet1 = input("Планета №1: ")
    r1 = float(input("Радиус ее орбиты (млн. км): "))
    v1 = float(input("Ее орбитальная скорость (км/с): "))
    r1 = r1 * 1000000 # переводим миллионы км в просто км
    year1 = 2 * math.pi * r1 / v1
    year1 = year1 / (60 * 60 * 24) # переводим секунды в дни
    planet2 = input("Планета №2: ")
    r2 = float(input("Радиус ее орбиты (млн. км): "))
    v2 = float(input("Ее орбитальная скорость (км/с): "))
    r2 = r2 * 1000000 
    year2 = 2 * math.pi * r2 / v2
    year2 = year2 / (60 * 60 * 24) 
    print("Длина года в днях на планете %s: %2.f" % (planet1, year1))
    print("Длина года в днях на планете %s: %2.f" % (planet2, year2))
    print("Длина года на %s больше, чем на %s? %s" % (planet1, planet2, year1 > year2))

Примерные результаты выполнения программы:

    Планета №1: Земля
    Радиус ее орбиты (млн. км): 150
    Ее орбитальная скорость (км/с): 30
    Планета №2: Венера
    Радиус ее орбиты (млн. км): 108
    Ее орбитальная скорость (км/с): 35
    Длина года в днях на планете Земля: 364
    Длина года в днях на планете Венера: 224
    Длина года на Земля больше, чем на Венера? True

    Планета №1: Земля
    Радиус ее орбиты (млн. км): 149.598261
    Ее орбитальная скорость (км/с): 29.783
    Планета №2: Марс
    Радиус ее орбиты (млн. км): 227.94382
    Ее орбитальная скорость (км/с): 24.13
    Длина года в днях на планете Земля: 365
    Длина года в днях на планете Марс: 687
    Длина года на Земля больше, чем на Марс? False

Найти площадь и периметр прямоугольного треугольника по двум заданным катетам.
Площадь прямоугольного треугольника равна половине площади прямоугольника,
стороны которого равны длинам катетов. Периметр же находится путем сложения
длин всех сторон треугольника.
Поскольку известны только катеты, то гипотенузу можно найти по теореме
Пифагора: c2 = a2 \+ b2.
Чтобы извлечь квадратный корень в Python можно воспользоваться функцией sqrt()
из модуля math.

    import math
    AB = input("Длина первого катета: ")
    AC = input("Длина второго катета: ")
    AB = float(AB)
    AC = float(AC)
    BC = math.sqrt(AB**2 + AC**2)
    S = (AB * AC) / 2
    P = AB + AC + BC
    print("Площадь треугольника: %.2f" % S)
    print("Периметр треугольника: %.2f" % P)

Результат:

    Длина первого катета: 5.4
    Длина второго катета: 2.1
    Площадь треугольника: 5.67
    Периметр треугольника: 13.29

Вводится строка, состоящая из слов, разделенных пробелами. Требуется
отсортировать слова в строке так, чтобы наиболее короткие из них были вначале
строки, а наиболее длинные в конце.
**Алгоритм решения задачи:**
1. Преобразуем строку в список слов. Для этого следует воспользоваться методом `split()`.
2. Измерим длину получившегося списка. Это значение показывает количество элементов списка, т.е. количество слов.
3. Используя метод пузырька, отсортируем элементы списка по их длине. Во внутреннем цикле сортировки должны сравниваться не значения элементов, а их длина.
4. Создадим пустую строку. В цикле по элементам списка будем добавлять каждое слово в конец этой новой строки, а также добавлять пробел после каждого слова.

    s = input()
    l = s.split()
    ln = len(l)
    for i in range(ln-1):
        for j in range(ln-1-i):
            if len(l[j]) > len(l[j+1]):
                l[j],l[j+1] = l[j+1],l[j]
    s = ''
    for i in range(ln):
        s += l[i] + ' '
    print(s)

Пример работы программы:

    ab aaab ba baaaaa a aba
    a ab ba aba aaab baaaaa

В зависимости от того, что выберет пользователь, вычислить площадь либо
прямоугольника, либо треугольника, либо круга. Если выбраны прямоугольник или
треугольник, то надо запросить длины сторон, если круг, то его радиус.
Площадь треугольника вычисляется по формуле Герона:
![Формула Герона](http://yandex.st/serp/0xdd2480d/libs/z-math/blocks/z-math/fo
rmula/z-math__formula_for_tri-square-abc-f.png)

    figure = input("Выберите фигуру (1-прямоугольник, 2-треугольник, 3-круг): ")
    if figure == '1':
    	print("Длины сторон прямоугольника:")
    	a = float(input("a = "))
    	b = float(input("b = "))
    	print("Площадь: %.2f" % (a*b))
    elif figure == '2':
    	print("Длины сторон треугольника:")
    	a = float(input("a = "))
    	b = float(input("b = "))
    	c = float(input("c = "))
    	p = (a + b + c) / 2
    	import math
    	s = math.sqrt(p * (p - a) * (p - b) * (p - c))
    	print("Площадь: %.2f" % s)
    elif figure == '3':
    	r = float(input("Радиус круга R = "))
    	import math
    	print("Площадь: %.2f" % (math.pi*r**2))
    else:
    	print("Ошибка ввода")

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

    Выберите фигуру (1-прямоугольник, 2-треугольник, 3-круг): 2
    Длины сторон треугольника:
    a = 4.5
    b = 2.8
    c = 6.1
    Площадь: 5.87

В заданной строке найти самое короткое слово. Слова могут быть разделены
пробелами, несколькими пробелами, знаками препинания.
**Алгоритм решения задачи:**
1. Длина очередного слова будет храниться в переменной w. Вначале присвоим этой переменно 0, т. к. в строке слов может вообще не быть.
2. Длина самого короткого слова будет записана в переменной min_w. Вначале этой переменной присваивается максимально возможная длина слова. Самое длинное слово может быть, если вся строка состоит только из одного слова. Поэтому сначала min_w равна длине строки.
3. Перебираем строку посимвольно в цикле for.
4. Если очередной символ является буквой, то увеличиваем значение w.
5. Иначе проверяем не меньше ли длина только что "измеренного" слова, чем значение min_w. Если это так, то меняем значение min_w на значение w.
6. Также в ветке else (иначе) обнуляем w, т.к. очередное слово закончилось и необходимо будет "измерять" новое.

    s = input()
    w = 0
    min_w = len(s)
    for i in s:
    	if 'a'<=i<='z' or 'A'<=i<='Z' \
    	or 'а'<=i<='я' or 'А'<=i<='Я':
    		w += 1
    	else:
    		if w < min_w and w != 0:
    			min_w = w
    		w = 0
    print(min_w)

Пример работы программы:

    Кто сказал мяу?            3
========
    1   what 
    4

Бывают ситуации, когда данные на экран надо вывести не через один пробел, а
как бы в виде таблицы. Другими словами, в полях определенной ширина, где
ширина измеряется в знакоместах. Рассмотрим пример. Допустим надо вывести
числа второй строки под числами первой. Если выполнить функцию print() так:

    print(10,235)
    print(1000,50)

то результат будет выглядеть так:

    10 235
    1000 50

Поэтому, чтобы вывод выглядел красиво, необходимо задать ширину поля. Делается
это так:

    print("%5d%7d" % (10,235))
    print("%5d%7d" % (1000,50))

Результат:

       10     235
     1000     50

Здесь в кавычках указаны форматы данных и ширина полей. После знака % за
кавычками указаны данные, которые будут подставлены вместо каждого указанного
формата. Если количество форматов не совпадает с количеством данных, то
возникнет ошибка.
Форматы данных могут быть: d - целое число, s - строка, f - вещественное
число.
По умолчанию данные выравниваются по правому краю поля. Чтобы выровнять их по
левому достаточно поставить знак минус перед числом, обозначающим ширину поля.
Пример:

    print("%-5d%7d" % (10,235))
    print("%-5d%7d" % (1000,50))

Вывод:

    10       235
    1000      50

Дан массив слов. Требуется заменить последние три символа слов, имеющих
определенную длину, на символ $.
Если длина очередного слова больше определенной длины, то взять срез от начала
слова и до конца, но без трех последних символов и присоединить к этому срезу
символ $. Далее следует заменить в массиве старую строку на полученную.
Выражение words[i][0:-3] означает, что из массива-списка сначала "берется"
очередная строка, а далее из нее берется указанный срез.

    words = []
    for i in range(10):
    	words.append(input())
    i = 0
    while i < len(words):
    	if len(words[i]) > 5:
    		words[i] = words[i][0:-3] + '$'
    	i += 1
    print(words)

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

    keybord
    display
    processor
    where
    you
    kitchen
    window
    small
    big
    monster
    ['keyb$', 'disp$', 'proces$', 'where', 'you', 'kitc$', 'win$', 'small', 'big', 'mons$']

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

    s = input()
    l = len(s)
    integ = []
    i = 0
    while i < l:
        s_int = ''
        a = s[i]
        while '0' <= a <= '9':
            s_int += a
            i += 1
            if i < l:
                a = s[i]
            else:
                break
        i += 1
        if s_int != '':
            integ.append(int(s_int))
    print(integ)

    5 dkfj78df 9 8 dkfj8
    [5, 78, 9, 8, 8]

Дан ряд чисел 1, -0.5, 0.25, -0.125, ... Требуется найти сумму стольких его
элементов, сколько указал пользователь. Например, если n = 3, то надо сложить
1, -0.5, 0.25, что в результате даст 0.75.
При решении таких задач сначала необходимо определить, в чем заключается
особенность предложенного ряда. В данном случае видим, что каждый последующий
элемент в 2 раза меньше предыдущего по модулю, но взят с противоположным
знаком. Далее следует найти арифметическое действие, которое из предыдущего
элемента дает последующий. Здесь, например, надо предыдущий элемент делить на
-2.
**Алгоритм решения задачи:**
1. Присвоим переменной a первое число ряда.
2. Создадим счетчик суммированных элементов ряда (i).
3. Создадим переменную для накопления суммы элементов ряда.
4. Пока счетчик не отсчитает заданного количества элементов ряда (пока i < n) будем выполнять нижеследующие действия.
5. К сумме будем добавлять значение текущего элемента.
6. Изменим значение текущего элемента на то, которое должно быть следующим (разделим на -2).
7. Увеличим значение счетчика на 1.

    n = input("Количество элементов ряда: ")
    n = int(n)
    a = 1
    i = 0
    summa = 0
    while i < n:
    	summa += a
    	a = a/-2
    	i += 1
    print(summa)

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

    Количество элементов ряда: 4
    0.625

    Количество элементов ряда: 10
    0.666015625

Допустим, дана строка слов, разделенных пробелами. Необходимо найти в ней
самое длинное слово и заменить в нем буквы 'a' на буквы 'b'.
Сразу следует оговорить, что в отличие, скажем от Pascal, в Python строки
неизменяемы. Т.е. в Питоне изменить символы в строке в принципе нельзя.
Поэтому есть только один выход: сформировать новую измененую строку, или
просто заменять определенные символы при выводе их на экран. Выберем первый
путь.
Сформировать новую строку также можно двумя способами (как минимум):
* преобразовать исходную в список, выполнить в нем замену, а затем элементы списка соединить в новую строку,
* вырезать из первой строки все символы до самого длинного слова, посимвольно добавить к ней изменяемое длинное слово, досоединить остаток первой строки.
Логически первый способ проще.
Сам алгоритм поиска самого длинного слова выгляд так:
1. Если очередной символ не пробел, то увеличиваем счетчик букв слова.
2. Если все же пробел, то проверяем не самое ли это длинное на данный момент слов. Если это так, то запоминаем длину этого слова (max_w) и индекс начала слова (id_w).
3. Поскольку последнее слово могло быть не проверено в цикле, то делаем еще одну проверку длины слова за пределами цикла.
При замене букв символы слова перебираются, и если встретиться "нужная" буква,
то вместо нее записывается другая.

    s = input()
    s = list(s) # преобразуем в список
    l = len(s)
    max_w = 0
    id_w = 0
    count = 0
    i = 0
    while i < l:
    	if s[i] != ' ':
    		count += 1
    	else:
    		if count > max_w:
    			max_w = count
    			id_w = i - count
    		count = 0
    	i += 1
    if count > max_w: # проверяем последнее слово
    	max_w = count
    	id_w = i - count
    id_w_end = id_w + max_w
    while id_w < id_w_end:
    	if s[id_w] == 'a':
    		s[id_w] = 'b'
    	id_w += 1
    s1 = ''
    for i in s:
    	s1 += i	
    print(s1)

Второй способ - через срезы. Здесь не надо в начале программы преобразовывать
строку к списку.

    # часть кода - только замена символов
    s1 = s[0:id_w]
    id_w_end = id_w + max_w
    while id_w < id_w_end:
    	if s[id_w] == 'a':
    		s1 += 'b'
    	else:
    		s1 += s[id_w]
    	id_w += 1
    s1 += s[id_w:]
    print(s1)

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

    very many variants and variables
    very many variants and vbribbles

В общем случае алгоритм решения данной задачи можно свести к следующему:
1. Если очередной элемент меньше нуля, то увеличиваем счетчик отрицательных элементов и добавляем значение элемента к общей сумме отрицательных элементов.
2. Находим среднее арифметическое среди отрицательных элементов, разделив сумму значений элементов на количество найденных элементов.
3. Находим минимальный элемент в массиве. Определяем его индекс. Заменяем значение по найденному индексу на вычисленное выше среднее арифметическое.
Третью подзадачу (замену минимального элемента) можно решить двумя подходами:
1) написать цикл поиска минимального элемента и его индекса или 2)
воспользоваться фунциями встроенными в язык Python (по-сравнению с тем же
Pascal в Python много "дополнительных инструментов").
Функция min() возвращает минимальный элемент из переданного ей аргумента.
(Передавать можно не только список.)
Метод index() возвращает индекс переданного ему элемента в последовательности,
к которой он применяется.

    arr = []
    count = 0 # количество отрицательных элементов
    summa = 0 # сумма отрицательных элементов
    for i in range(10):
    	item = int(input(str(i) + ' item: '))
    	arr.append(item)
    	if item < 0:
    		count += 1
    		summa += item
    if count != 0:
    	mean = summa/count # среднее арифметическое
    	minimal = min(arr) # значение минимального элемента в списке-массиве
    	min_id = arr.index(minimal) # индекс минимального элемента 
    	arr[min_id] = round(mean)
    	print(mean)
    	print(arr)

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

    0 item: 4
    1 item: 5
    2 item: 6
    3 item: 7
    4 item: 8
    5 item: 9
    6 item: -2
    7 item: -6
    8 item: -3
    9 item: 0
    -3.6666666666666665
    [4, 5, 6, 7, 8, 9, -2, -4, -3, 0]

Решение задачи в "классическом" стиле (без использования функций min() и
index() может выглядеть так:

    arr = []
    count = 0 
    summa = 0 
    min_id = 0 # индекс минимального элемента
    for i in range(10):
    	item = int(input(str(i) + ' item: '))
    	arr.append(item)
    	if item < 0:
    		count += 1
    		summa += item
    		if item < arr[min_id]:
    			min_id = i
    if count != 0:
    	mean = summa/count 
    	arr[min_id] = round(mean)
    	print(mean)
    	print(arr)

Дан список-массив, заполненный случайным образом нулями и единицами. Найти
самую длинную непрерывную последовательность единиц и определить индексы
первого и последнего элементов в ней.
**Решение задачи:**
1. Пусть переменная count содержит текущее значение количества единиц, а max_count - максимально найденное на данный момент. Переменная index хранит индекс последнего элемента в самой длинной на данный момент последовательности единиц.
2. Если очередной элемент 0, то переменная count обнуляется. Однако перед этим ее значение сравнивается с max_count и, если count больше, то max_count перезаписывается на него. В index помещается индекс последнего элемента найденной последовательности единиц.
3. При выводе данных на экран, чтобы получить индекс первого элемента последовательности, надо из последнего вычесть уменьшенную на единицу длину последовательности.

    import random
    a = []
    for i in range(50):
    	n = int(random.random() * 2)
    	a.append(n)
    	print(n,end=' ')
    	if (i+1) % 10 == 0: print()
    count = 0
    max_count = 0
    index = 0
    i = 0 
    while i < len(a):
    	if a[i] == 1:
    		count += 1
    	else:
    		if count > max_count:
    			max_count = count
    			index = i-1 # последовательность закончилась на предыдущем элементе
    		count = 0
    	i += 1
    print("Количество элементов: ", max_count)
    print("id первого элемента: ", index-max_count+1)
    print("id последнего элемента: ", index)

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

    1 0 1 0 0 1 0 1 1 0 
    1 1 0 0 1 1 1 1 1 0 
    1 1 1 1 0 0 1 1 0 1 
    0 0 0 0 1 1 0 1 1 0 
    1 1 0 1 0 0 0 0 0 1 
    Количество элементов:  5
    id первого элемента:  14
    id последнего элемента:  18

В строке заменить пробельные символы знаком звездочки ("*"). Если встречается
подряд несколько пробелов, то их следует заменить одним знаком "*", пробелы в
начале и конце строки удалить.
**Алгоритм решения задачи:**
1. Посимвольно просмотреть строку с ее начала. Запомнить номер первого непробельного символа. Взять срез из строки от первого непробельного символа до ее конца.
2. Просмотреть строку с конца. Запомнить номер первого непробельного символа с конца. Взять срез из строки от ее начала до первого непробельного символа с конца.
3. Присвоить новой строке первый символ старой (он в любом случае не пробел).
4. Посимвольно просматривать старую строку. Если очередной символ не является пробелом, то формировать новую строку добавлением к ней этого символа. В ветку `elif` попадают символы пробела, но здесь проверяется не был ли равен предыдущий символ пробелу. И если это не так (не был равен), то только тогда к новой строке добавляется "*". Лишние пробелы будут просто пропущены и не добавлены к новой строке.

    s = input()
    i = 0
    while s[i] == ' ': i+=1
    s = s[i:]
    i = len(s)
    while s[i-1] == ' ': i-=1
    s = s[:i]
    s1 = s[0]
    i = 1
    while i < len(s):
    	if s[i] != ' ':
    		s1 += s[i]
    	elif s[i-1] != ' ':
    		s1 += '*'
    	i += 1
    print(s1+'!')

Пример выполнения скрипта:

       one    two three four f*ve    six seven      one*two*three*four*f*ve*six*seven!

Однако в языке программирования Python данную задачу проще решить,
преобразовав строку в список или возможно через регулярные выражения.
С помощью метода split() строка разделяется на слова по пробелам. При этом
неважно сколько их. Далее остается только снова собрать слова в строку через
"*":

    s = input()
    l = s.split()
    s1 = ''
    for i in l:
    	s1 += i + '*'
    s1 = s1[:-1] # удаляем последнюю "*"	
    print(s1)

Требуется убедиться, что брать кредиты не выгодно. Т. е. надо вычислить,
сколько придется платить в месяц по займу и сколько всего отдать денег банку
за весь период.
Месячная выплата по займу вычисляется по такой загадочной формуле:
m = (s * p * (1 + p)n) / (12 * ((1 + p)n – 1)).
Мы не будем разбирать ее смысл, т.к. все-равно не осилим.
Достаточно знать, что в этой формуле:
m - размер месячной выплаты;
s - сумма займа (кредита);
p - процент банка, выраженный в долях единицы (т. е. если 20%, то будет 0.2).
n - количество лет, на которые берется займ.
Код решения данной задачи на языке Python может выглядеть так:

    amount = input("Сколько хотите взять денег: ")
    amount = int(amount)
    pct = input("Под какой процент вам их дают: ")
    pct = int(pct)
    years = input("Насколько лет берете: ")
    years = float(years)
    pct = pct / 100 
    month_pay = (amount * pct * (1 + pct)**years) / (12 * ((1 + pct)**years - 1))
    print("Ваш месячный платеж составит: %.2f" % month_pay)
    summa = month_pay * years * 12
    print("За весь период вы заплатите: %.2f" % summa)
    print("Это составит %.2f%% от первоначальной суммы" % ((summa / amount) * 100))

Здесь следует обратить внимание на операции с различными типами данных.
Значение years преобразутеся к вещественному типу, т.к. кредит можно взять не
на целое количество лет. В выражении pct = pct / 100 получается дробное число
(т.е. переменная pct теперь связана с вещественным типом данных).
Примерные результаты:

    Сколько хотите взять денег: 1000000
    Под какой процент вам их дают: 15
    Насколько лет берете: 10
    Ваш месячный платеж составит: 16604.34
    За весь период вы заплатите: 1992520.63
    Это составит 199.25% от первоначальной суммы

    Сколько хотите взять денег: 2000000
    Под какой процент вам их дают: 20
    Насколько лет берете: 20
    Ваш месячный платеж составит: 34226.09
    За весь период вы заплатите: 8214261.23
    Это составит 410.71% от первоначальной суммы

    Сколько хотите взять денег: 35000
    Под какой процент вам их дают: 10
    Насколько лет берете: 0.5
    Ваш месячный платеж составит: 6267.36
    За весь период вы заплатите: 37604.15
    Это составит 107.44% от первоначальной суммы

Определить количество простых чисел введенных пользователем.
**Алгоритм решения задачи:**
1. Пока не будет введено число меньшее или равное 1 (т.к. простым числом может быть только натуральное число большее единицы) будем выполнять нижеследующие действия.
2. Установим флаговую переменную в значение True.
3. Проверим число на простоту путем деления на него всех целых чисел от 2 до корня из него (почему именно до корня см. математику).
4. Если число делится нацело хотя бы на один делитель, то оно не простое. Меняем значение флаговой переменной на False.
5. Если же флаговая переменная не была изменена, то число простое, и мы увеличиваем счетчик количества введенных простых чисел.

    import math
    count = 0
    n = int(input())
    while n > 1:
    	f = True 
    	for i in range(2, round(math.sqrt(n))+1):
    		if n % i == 0:
    			f = False
    	if f:
    		count += 1
    	n = int(input())
    print("Было введено", count, "простых чисел")

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

    35
    18
    10
    11
    197
    3
    17
    1
    Было введено 4 простых чисел

В Python над двумя строками можно выполнить операцию, обозначаемую знаком +.
Однако, в отличие от чисел, выполняетя не сложение (что для строк в принципе
невозможно), а соединение, т. е. к концу первой строки добавляется вторая. По-
другому операция соединения строк называется **конкатенацией**.
Кроме того, в Python есть операция повторения (мультипликации) строки. Она
обозначается знаком * (также как операция умножения для чисел). При повторении
строки с одной стороны от знака * ставится строка, а с другой число,
обозначающее количество повторов. При этом не важно, какой объект с какой
стороны находится (слева от знака можно писать число, а справа - строку).
В одном выражении можно сочетать операции конкатенации и мультипликация. При
этом более высокий приоритет у операции повторения строки. Это видно в примере
ниже: когда опущены скобки, то сначала строка s2 повторяется n раз, а затем
результат присоединяется к s1.

    s1 = input("Введите первую строку: ")
    s2 = input("Введите вторую строку: ")
    n = int(input("Введите количество повторов: "))
    print(s1 + s2 * n)
    print((s1 + s2) * n)
    print(s1 + str(n)) # error if just (s1 + n)
    print('^' * 20)
    print('Hello' + 'world')
    print('Hello','world')

В последней строке кода конкатенации нет. Просто функции print() передано два
аргумента, которые она выводит на экран.
Результат выполнения скрипта:

    Введите первую строку: rt
    Введите вторую строку: -
    Введите количество повторов: 5
    rt-----
    rt-rt-rt-rt-rt-
    rt5
    ^^^^^^^^^^^^^^^^^^^^
    Helloworld
    Hello world

Вывести таблицу значений заданной функции на отрезке и с шагом, которые вводит
пользователь.
Пусть фунция будет такой: y = -3x2 - 4x + 20.
**Алгоритм решения задачи:**
1. Запросить у пользователя точки начала и конца отрезка, а также шаг.
2. Если значение точки начала отрезка больше значения точки конца, то поменять значения.
3. Пока значение первой точки не достигнет второй
4. вычислить значение функции,
5. вывести на экран текущие значения x и y,
6. увеличить значение первой точки на шаг.

    x1 = float(input("Точка начала отрезка: " ))
    x2 = float(input("Точка конца отрезка: " ))
    step = float(input("Шаг: " ))
    if x1 > x2:
    	x1, x2 = x2, x1
    print("Функция: y = -3x**2 - 4x + 20")
    print("   x        y")
    while x1 <= x2:
    	y = -3*x1**2 - 4*x1 + 20
    	print('%5.2f | %7.2f' % (x1, y))
    	x1 += step

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

    Точка начала отрезка: 6
    Точка конца отрезка: 10.5
    Шаг: 0.7
    Функция: y = -3x**2 - 4x + 20
       x        y
     6.00 | -112.00
     6.70 | -141.47
     7.40 | -173.88
     8.10 | -209.23
     8.80 | -247.52
     9.50 | -288.75
    10.20 | -332.92

Обмен значений двух переменных - это "действие", в результате которого одна
переменная принимает значение, равное второй переменной, а вторая - первой.
Понятно, что если попытаться сделать такой обмен "по-простому", т. е. сначала
первой переменной присвоить значение второй, а второй - значение первой, то
ничего не получится. Допустим, есть две переменные a и b. При этом `a = 5` и
`b = 6`. Если выполнить выражение `a = b`, то переменная a будет ссылаться на
число 6, также как и `b`. Число 5 будет утеряно, т. к. на него уже не будет
ссылаться ни одна переменная, и выражение `b = a` бессмысленно, т. к. b будет
присвоено его же текущее значение (6 в данном случае).
Поэтому во многих языках программирования (например, Pascal) приходится
вводить третью переменную, играющую роль буфера (ее иногда называют буферной
переменной). В этой переменной сохраняют значение первой переменной, потом
первой переменной присваивают значение второй, в новое значение для второй
переменной берут из буфера. Поэтому алгоритм обмена значений двух переменных
выглядит примерно так:

    a = 5
    b = 6
    buf = a
    a = b
    b = buf

Однако есть более "хитрый" способ, позволяющий избавиться от третьей
переменной. Но этим способом не всегда рекомендуют пользоваться. Выглядит он
так:

    a = 5
    b = 7
    a = a + b # 12
    b = a - b # 12-7=5
    a = a - b # 12-5=7

В отличие от многих других языков программирования, в Python обмен значений
переменных можно выполнить вообще в одну строчку:

    >>> a = 10
    >>> b = 20
    >>> a,b = b,a
    >>> a
    20
    >>> b
    10

Почему такое возможно? Это связано с тем, что в Питоне существует такая
структура данных как кортеж.
При выполнении `a,b = b,a` интерпретатор Python сначала получает значения
связанные с переменными b и a (правая часть) и помещает их в кортеж, в данном
случае получится (10, 20). После этого он связывает каждый элемент кортежа в
определенной позиции с переменной в той же позиции, но в кортеже слева
`(a,b)`.
Таким образом можно поменять значения ни только двух переменных, но и трех,
четырех и т. д. Кроме того в Python можно обменять значения переменных разных
типов. Такая возможность связана с тем, что тип данных в Питоне привязан не к
переменной, а к значению:

    >>> a = 14
    >>> b = 18
    >>> c = 16
    >>> a,b,c = c,a,b
    >>> a,b,c
    (16, 14, 18)
    >>> d = 4.56
    >>> e = "hi"
    >>> d,e = e,d
    >>> d
    'hi'
    >>> e
    4.56

Дан список положительных и отрицательных вещественных чисел. Получить из этого
списка другой список, состоящий только из положительных элементов первого,
стоящих на четных местах.
Алгоритм решения задачи достаточно прост. Надо проверять каждый второй элемент
первого списка, и если он больше нуля, то добавлять во второй список.
Особенностью алгоритма для языка Python является то, что индексация начинается
с 0, а значит четные элементы имеют нечетные индексы.
Особенности скрипта ниже. Выражение random.random()*10-5 генерирует
вещественное число от -5 до 5. Выражение round(x, 2) - округляет x до двух
знаков после запятой. Метод append() списка добавляет элемент в конец списка,
к которому применяется.

    import random
    listA = []
    for i in range(20):
    	listA.append(round(random.random()*10-5, 2))
    print("Список A:\n", listA)
    listB = []
    i = 1
    while i < 20:
    	if listA[i] > 0:
    		listB.append(listA[i])
    	i += 2
    print("Список B:\n", listB)

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

    Список A:
     [0.09, 4.56, 2.57, -0.47, 2.78, -4.59, 4.19, 1.68, 2.8, -0.84, 4.72, -1.4, 2.77, 4.64, 0.68, 3.81, -2.09, -3.16, -4.78, 3.88]
    Список B:
     [4.56, 1.68, 4.64, 3.81, 3.88]

У треугольника сумма любых двух сторон должна быть больше третьей. Иначе две
стороны просто "лягут" на третью и треугольника не получится.
Пользователь вводит длины трех сторон. Программа должна определять, может ли
существовать треугольник при таких длинах. Т. е. нужно сравнить суммы двух
любых строн с оставшейся третьей стороной. Чтобы треугольник существовал,
сумма всегда должна быть больше отдельной стороны.
Поскольку всего три стороны, то можно составить три варианта сложения двух
сторон: a + b, b + c, a + c. Первую сумму сравниваем с оставшейся стороной c,
вторую - с a и третью - с b. Если хотя бы в одном случае сумма окажется не
больше третьей стороны, то можно сделать вывод, что треугольник не существует.

    print("Введите длины сторон предполагаемого треугольника:")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    if a + b > c and a + c > b and b + c > a:
    	print("Треугольник существует")
    else:
    	print("Треугольник не существует")

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

    print("Введите длины сторон предполагаемого треугольника:")
    a = float(input("a = "))
    b = float(input("b = "))
    c = float(input("c = "))
    flag = ''
    if a + b > c:
    	if a + c > b:
    		if b + c > a:
    			print("Треугольник существует")
    		else:
    			flag = 'a'
    	else:
    		flag = 'b'
    else:
    	flag = 'c'
    if flag != '':
    	print("Треугольник НЕ существует. ", end='')
    	print("Сторона '%s' длиннее или равна сумме двух других." % flag)

Особого смысла использовать переменную flag здесь нет. Она просто позволяет
лишний раз не писать в программе строки, информирующие о том, что треугольник
не существует. Большего внимания заслуживает использование вложенных
конструкций if-else.
Примерный результат выполнения программы:

    Введите длины сторон предполагаемого треугольника:
    a = 10
    b = 2
    c = 3
    Треугольник НЕ существует. Сторона 'a' длиннее или равна сумме двух других.