Дана квадратная матрица. Необходимо из всех строк матрицы, кроме последней,
вычесть последнюю строку. Следует написать программу с использованием функций.
В Python нельзя обратиться по индексу к элементу списка, которого еще не
существует. Поэтому при заполнении матрицы можно сначала создавать одномерный
список-массив (очередную строку матрицы), а затем добавить его в основной
список-матрицу. Таким образом, при заполнении двумерного списка также
используется метод append(), как и при заполнении одномерного.
В Python в функции передаются "указатели" на списки, а не сами списки. Поэтому
в функциях отсутствует оператор return.

    import random
    def make_matrix(m,n):
    	for i in range(0,n):
    		a = []
    		for j in range(0,n):
    			a.append(int(random.random() * 100))
    		m.append(a)
    def minus_last(m):
    	l = len(m)
    	for i in range(0,l-1):
    		for j in range(0,l):
    			m[i][j] = m[i][j] - m[l-1][j]
    def print_matrix(m):
    	for i in m:
    		print(i)
    	print()
    arr = []
    make_matrix(arr,4)	
    print_matrix(arr)
    minus_last(arr)
    print_matrix(arr)

    [62, 54, 47, 44]
    [84, 84, 64, 83]
    [87, 96, 32, 30]
    [3, 74, 42, 21]
    [59, -20, 5, 23]
    [81, 10, 22, 62]
    [84, 22, -10, 9]
    [3, 74, 42, 21]

Необходимо определить индексы элементов списка, значение которых не меньше
заданного минимума и не больше заданного максимума.
Пусть исследуемый массив (список в Python) заполняется случайными числами в
диапазоне от 0 до 99 (включительно) и состоит из 100 элементов.
Далее минимум и максимум для поиска значений задается пользователем.

    import random
    arr = []
    for i in range(100):
    	x = int(random.random()*100)  #  0<=x<=99
    	arr.append(x)
    	print("%3d" % x, end='')
    	if (i+1) % 10 == 0:	print()
    minimum = int(input('Min: '))
    maximum = int(input('Max: '))
    index = []
    for i in arr:
    	if minimum <= i <= maximum:
    		index.append(arr.index(i))
    print("Total: ", len(index))
    print("Id: ", index)

      9 96  8 23 41 93 17 88 52 21
     88 60 25 29 14 41 73 60 31  8
     44 51 26 38 79  1 78 11 48 59
     36 64 20 98 31  1 24 75  4 85
     93 46 15 76 35 34  6 72  9 11
     67 60 73 88 69 19 47 67 74 37
     64 35 53 90 56 39 73 83 73 80
     35  0 26 55 27 22 88 14 63 58
     49 95  7 32 34 14 91 55 31 70
     92 61 70 21 25 10 21 60 19 82
    Min: 77
    Max: 85
    Total:  6
    Id:  [24, 26, 39, 67, 69, 99]

Псевдослучайные числа в Python можно сгенерировать, используя функцию random()
одноименного модуля.
Метод append() позволяет добавлять элемент в конец списка; index() определяет
индекс элемента в списке.

Пользователь вводит трехзначное число. Программа должна сложить цифры, из
которых состоит это число. Например, если было введено 349, то программа
должна вывести на экран число 16 (т. к. 3 + 4 + 9 = 16).
Как извлечь отдельные цифры из числа? Если число разделить нацело на десять,
то в остатке будет последняя цифра этого числа. Например, если 349 разделить
нацело на 10, то получится частное 34 и остаток 9. Если потом 34 разделить
также, то получится частное 3 и остаток 4; далее при делении 3 на 10 получим
частное 0 и остаток 3.
В языках программирования обычно нет такой арифметической операции, которая бы
давала два результата: частное и остаток. Зато есть две отдельные операции: 1)
нахождение целого при делении нацело и 2) нахождение остатка при делении
нацело. В языке программирования Python v.3 первая операция обозначается //
(двумя знаками деления), а вторая - % (знаком процента). Например:

    >>> 34 // 10
    3
    >>> 34 % 10
    4

Примечание. Необходимо знать, что операции деления нацело и нахождения остатка
с точки зрения арифметики применимы только к целым числам. Но в Python их
можно использовать и по отношению к дробным числам: ... [>>>]

Гипотеза Сиракуз гласит, что любое натуральное число сводимо к единице при
следующих действиях над ним: а) если число четное, то разделить его пополам,
б) если нечетное - умножить на 3, прибавить 1 и результат разделить на 2. Над
вновь полученным числом вновь повторить действия a) или б) в зависимости от
его четности. Рано или поздно число станет равным 1.
Напишем программу, проверяющую гипотезу Сиракуз. Пусть пользователь вводит
любое натуральное число. Будем выполнять в цикле над ним вышеуказанные
действия, пока оно не станет равным 1. Если гипотеза верна, то рано или позно
цикл закончится, а если нет - то произойдет зацикливание программы.

    n = int(input())
    while n != 1:
    	if n % 2 == 0:
    		n = n // 2
    	else:
    		n = (3*n + 1) // 2
    	print(n, end=' ')

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

    100
    50 25 38 19 29 44 22 11 17 26 13 20 10 5 8 4 2 1

    9999
    14999 22499 33749 50624 25312 12656 6328 3164 1582 791 1187 1781 2672 1336 668 334 167 251 377 566 283 425 638 319 479 719 1079 1619 2429 3644 1822 911 1367 2051 3077 4616 2308 1154 577 866 433 650 325 488 244 122 61 92 46 23 35 53 80 40 20 10 5 8 4 2 1

Программа зациклится, если ввести отрицательное число. Чтобы этого избежать,
ввод числа можно запрограммировать так:

    n = 0

... [>>>]

В матрице заменить последний элемент каждой строки на сумму предыдущих
элементов той же строки.
**Алгоритм решения основной части задачи** (только сложение и замена):
1. Для каждой строки присвоить переменной summa значение 0, индексу элемента (i) также значение 0.
2. Пока индекс элемента не дошел до последнего элемента строки, увеличивать значение summa на значение очередного элемента строки матрицы.
3. Иначе (когда индекс элемента указывает на последний элемент строки) изменить значение последнего элемента строки на значение переменной summa.

    import random
    n = 4
    m = 6
    matrix = []
    for i in range(n): # формируем исходную матрицу
    	line = []
    	for j in range(m):
    		line.append(round(random.random() * 10) - 5) # от -5 до 5
    	matrix.append(line)
    for line in matrix: # вывод исходной матрицы
    	for i in line:
    		print('%4d' % i, end='')
    	print()
    print()
    for line in matrix: # изменение матрицы
    	summa = 0 
    	i = 0
    	while i < m-1:
    		summa += line[i]
    		i += 1
    	else:
    		line[m-1] = summa
    for line in matrix: # вывод измененной матрицы
    	for i in line:
    		print('%4d' % i, end='')
    	print()

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

      -5   2   1   2  -4   1
      -3   5  -4  -5   2   1
      -4  -1   2   2   4   4
       3  -4   2  -2  -5   0
      -5   2   1   2  -4  -4
      -3   5  -4  -5   2  -5
      -4  -1   2   2   4   3
       3  -4   2  -2  -5  -6

... [>>>]

У треугольника сумма любых двух сторон должна быть больше третьей. Иначе две
стороны просто "лягут" на третью и треугольника не получится.
Пользователь вводит длины трех сторон. Программа должна определять, может ли
существовать треугольник при таких длинах. Т. е. нужно сравнить суммы двух
любых строн с оставшейся третьей стороной. Чтобы треугольник существовал,
сумма всегда должна быть больше отдельной стороны.
Поскольку всего три стороны, то можно составить три варианта сложения двух
сторон: 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("Введите длины сторон предполагаемого треугольника:")

... [>>>]

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

Однако есть более "хитрый" способ, позволяющий избавиться от третьей ... [>>>]

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

В 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)

... [>>>]

Определить количество простых чисел введенных пользователем.
**Алгоритм решения задачи:**
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 простых чисел

Требуется убедиться, что брать кредиты не выгодно. Т. е. надо вычислить,
сколько придется платить в месяц по займу и сколько всего отдать денег банку
за весь период.
Месячная выплата по займу вычисляется по такой загадочной формуле:
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 преобразутеся к вещественному типу, т.к. кредит можно взять не ... [>>>]

В строке заменить пробельные символы знаком звездочки ("*"). Если встречается
подряд несколько пробелов, то их следует заменить одним знаком "*", пробелы в
начале и конце строки удалить.
**Алгоритм решения задачи:**
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):

... [>>>]

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

... [>>>]

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

    arr = []
    count = 0 # количество отрицательных элементов
    summa = 0 # сумма отрицательных элементов

... [>>>]

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

Дан ряд чисел 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("Количество элементов ряда: ")

... [>>>]

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

    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]

Дан массив слов. Требуется заменить последние три символа слов, имеющих
определенную длину, на символ $.
Если длина очередного слова больше определенной длины, то взять срез от начала
слова и до конца, но без трех последних символов и присоединить к этому срезу
символ $. Далее следует заменить в массиве старую строку на полученную.
Выражение 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$']

Бывают ситуации, когда данные на экран надо вывести не через один пробел, а
как бы в виде таблицы. Другими словами, в полях определенной ширина, где
ширина измеряется в знакоместах. Рассмотрим пример. Допустим надо вывести
числа второй строки под числами первой. Если выполнить функцию 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))

... [>>>]

В заданной строке найти самое короткое слово. Слова могут быть разделены
пробелами, несколькими пробелами, знаками препинания.
**Алгоритм решения задачи:**
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

... [>>>]

В зависимости от того, что выберет пользователь, вычислить площадь либо
прямоугольника, либо треугольника, либо круга. Если выбраны прямоугольник или
треугольник, то надо запросить длины сторон, если круг, то его радиус.
Площадь треугольника вычисляется по формуле Герона:
![Формула Герона](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. Преобразуем строку в список слов. Для этого следует воспользоваться методом `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

Найти площадь и периметр прямоугольного треугольника по двум заданным катетам.
Площадь прямоугольного треугольника равна половине площади прямоугольника,
стороны которого равны длинам катетов. Периметр же находится путем сложения
длин всех сторон треугольника.
Поскольку известны только катеты, то гипотенузу можно найти по теореме
Пифагора: 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

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

... [>>>]

Найти расстояние между точками с заданными координатами в 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-ой точки: ")

... [>>>]

Найти сумму и количество элементов последовательности, которые по модулю
больше 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

Требуется вычислить, сколько банок краски потребуется, чтобы окрасить
поверхность бака цилиндрической формы. Покрасить надо и снаружи, и изнутри.
Пользователь вводит диаметр и высоту бака, а также какую площадь можно
окрасить одной банкой краски.
Чтобы понять, сколько банок краски потребуется, надо знать площадь цилиндра.
Она представляет собой сумму площадей двух кругов (крышка баки и дно) и
площади непосредственно цилиндрической поверхности. Кроме того, если бак
красится и изнутри, найденную площедь следует умножить на 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` требуется, если надо найти целое значение количества
банок (ведь пол банки не купишь).

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

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

Найти остаток от деления целой части значения функции 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Кб 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

... [>>>]

Определить, сколько в введенном пользотелем числе четных цифр, а сколько
нечетных.
Если число делится без остатка на 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

Определить, принадлежит ли точка с координатами (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
    Точка принадлежит кругу

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

В прямоугольной системе координат на плоскости выделяют четверти:
![Четверти в прямоугольной системе координат](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:

... [>>>]

Тема:
Строки

Вводится натуральное число (> 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

... [>>>]

Вывести степени натуральных чисел, не превосходящие данного числа 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

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

Возьмем, например, такое уравнение: 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

... [>>>]

Пользователь загадывает число от 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
    Я угадал!

Вводятся два числа в двоичной системе счисления. Требуется выполнить над ними
побитовые операции И, ИЛИ и исключающего ИЛИ. В конце вывести результат
операций также в двоичном представлении.
Побитовые операции выполняются над разрядами числа. Так если имеем два числа
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))

... [>>>]

Уравнение прямой на координатной плоскости имеет следующий вид: 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

Написать программу, умеющую выполнять над двумя вещественными числами
арифметические операции (сложение, вычитание, умножение, деление) и
завершающуюся по желанию пользователя.
**Алгоритм:**
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 == '/':

... [>>>]

Вводится целое число. Вывести число, обратное по порядку составляющих его цифр
введенному. Например, введено 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

... [>>>]

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

... [>>>]

В 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), и если какой-либо код из этого ... [>>>]

Допустим, у нас есть список чисел, из которого надо удалить элементы,
удовлетворяющие определенному условию. Будем удалять из списка, состоящего из
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:

... [>>>]

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

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

Квадратное уравнение имеет вид 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 есть простые логические операторы (=, !=, <, >, <=, >=) и сложные
(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)

... [>>>]