Уточнение корней методом итераций
Случайные числа
Для генерации случайных чисел используется модуль random, содержащий следующие функции:
| random() | Возвращает случайное вещественное число из интервала [0..1). Единица не включается. |
| randint(a,b) | Возвращает случайное целое число из интервала [a..b]. Границы интервала включаются. |
| choice(L) | Выбирает случайный элемент из последовательности. |
/*Забегая вперёд. Например, мы можем выбрать случайный элемент из списка или случайную букву из строки:
l = [1,2,3]; n = choice(l); s = "abcd"; c = choice(s)*/
/*Также допускается "переименовывать" подключаемые модули. К примеру, можно написать import random as r и в дальнейшем использовать r.random() вместо random.random(). Хотя в данном случае это некритично и выглядит немного глупо (и наверняка не одобряется Борисовым), такой функционал может здорово сэкономить нервы в реальной практике в случае какого-нибудь import VeryVeryLongModuleName*/
Арифметические выражения
При записи длинных арифметических выражений, функций и т.п. можно использовать символ перехода на новую строку \
x = 5
y = x * 2 + 100 + \
10 * 5
Если в выражении используются скобки, и перенос происходит внутри скобок, то \ использовать необязательно:
y = (x + 5
- 1) / 2 * 100 +\
Существуют различные способы сокращения записи. Например, множественное присваивание:
a = b = c = 0
Также для сокращения записи можно использовать следующие операции:
a += b # a = a + b
a -= b # a = a - b
a *= b # a = a * b
a /= b # a = a / b
/*# - символ комментария в питоне. Строчка после комментария в программе не обрабатывается*/
Результатом деления всегда является действительное число, даже если и делимое и делитель - целые и делятся нацело. Для деления нацело вместо оператора деления / нужно использовать оператор деления нацело //; для получения остатка от деления используется оператор % :
85 // 10 # 8
85 % 10 # 5
-7 // 2 # -4
-7 % 2 # 1
Для извлечения квадратного корня из числа можно использовать целых три способа:
sqrt(x), x ** 0.5, pow(x, 0.5)
** – оператор возведения числа в степень.
Для сравнения и расширения кругозора. В Паскале нет стандартной функции возведения в степень; 
записывается как y = exp( a * ln(x) ). В Си в математической библиотеке присутствует функция pow().
Ввод значений с клавиатуры
Для ввода значений используется функция input(). В качестве параметра в функцию можно передать приглашение для ввода: x = input( 'Введите число: ' ). Ввод завершается нажатием Enter.
>>> x = input()
>>> 4
>>> x
x = '4'
Возвращаемое значение - всегда строка. Если требуется вводить числа, то необходимо проводить преобразование в нужный тип:
f = float( input('Введите вещественное число: ') )
i = int( input('Введите целое число: ') )
Можно вводить несколько значений через пробел:
x, y = map( int, input('Введите x и y: ').split() )
<строка>.split() - разбивает строку на список строк. По умолчанию разбиение происходит по символу пробела, но можно указать и другой символ: <строка>.split(',') будет разбивать строку по запятым вместо пробелов.
map(func, col) - применяет функцию func ко всем элементам коллекции col.
/*Небольшой экскурс в историю. Активно используются две версии питона: 2.7.x и 3.x .
Почему 2.7 до сих пор на плаву? Потому что под него написано огромное число библиотек и множество проектов.
Почему их до сих пор не обновили до 3.х? Потому что в языке произошло много изменений, затронувших даже такую неизменную вещь, как стандартная библиотека.
Так, к примеру: в 2.7.х input() автоматически преобразовывал вводимые строки в числа, а для обработки строк использовался raw_input(). В 3.х от raw_input() отказались. 3 / 2 в старом питоне давало 1, вместо 1.5 как в новом. Однако, в целом язык остался тем же. Пока что.*/
Вывод на экран
Используется функция print():
x = 1; y = 2; z = 3
print( x, '+', y, '=', z )
Выведет "1 + 2 = 3". Пробел между отдельными аргументами функции print() вставляется автоматически. Пробел можно заменить, указав другой символ после слова sep: print( x, '+', y, '=', z, sep='' ) - в качестве разделителя будет пустая строка, т.е. x+y=z будет написано слитно.
Возможен форматный вывод:
x = 567
print( '{:5d}'.format(x) ) # выведет __567 (вместо _ -пробелы)
print( '{:5d}{:5d}{:5d}'.format(x, x*x, x*x) )
Выводить вещественные числа можно в нескольких форматах.
z = 1 / 6
k = 2 / 8
print( '{:7.3f}{:5.1f}'.format(z, k) ) # десятичный формат
print( '{:9.3e}{:9.3e}'.format(z, k) ) # научный формат, спецификация Е
/*Первое число (после двоеточия): количество символов, отведённых под число; так, {:5 отводит пять символов, и перед 567 будет нарисовано два пробела. Второе число (после точки) (только для вещественных) - число цифр после запятой. При .3f 0.123456 будет отображено как 0.123*/
Условный оператор
if x > y:
m = x
else:
m = y
Если в блоке только один оператор, то можно записывать без отступа:
if x > y: m = x
else: m = y
Максимум на примере двух чисел:
m = x if x > y else y
/*Одной из отличительных (и знаменитых) черт питона является использование отступов для организации блоков кода. Жизненно необходимо, чтобы строчки кода в пределах одного блока (например, выполняющиеся при истинности условия) находились на одинаковом числе отступов от левой границы текста. Число отступов может быть любым: хоть один пробел, хоть два, хоть десять. Питоньим стандартом являются четыре пробела на один уровень:
if True:
if True:
print()
Преподаватели умиляются – криво отформатированная студенческая программа, на которую без слёз не взглянешь, просто не будет запускаться, что способствует привитию хороших манер. Великие гуру программирования тем временем плачут кровавыми слезами.*/
Поменяем значения х и у:
t = x; x = y; y = t
# либо
x, y = y, x
В питоне (а так же в C, C++) в условии оператора if можно использовать любое выражение, которое возвращает значение. В этом случае все значения кроме 0 и None трактуются как истина (True), а те два - как ложь (False).
/*Ещё раз напомню что питон - регистрозависимый язык. if True сработает, а вот if false выдаст ошибку "неизвестный идентификатор".*/
x = 1
if x:
print( x )
y = 0
if y:
print( y )
Напечатается только 1.
/*Внимательный читатель заметит, что здесь у меня отступы шире, чем в предыдущих примерах. Питон позволяет использовать для отступов как пробелы, так и символы табуляции. Нажимать один раз на таб выглядит заманчивее, чем четыре раза на пробел; но берегись, любитель идти против системы. Код, где в одном блоке перемешаны табы и пробелы, попросту не запустится, и можно потратить немало нервных клеток, устраняя ошибку:
if True:
print('a')
print('b')
Стандартный питоний редактор кода IDLE (как впрочем и любая более-менее продвинутая IDE) достаточно умён, чтобы нажатия на таб автоматически преобразовывать в четыре пробела. Любители программировать в стандартном виндовом блокноте нервно ёрзают.*/
Также используется конструкция elif:
if x < y:
z = -1
elif x == y:
z = 0
else:
z = 1
elif допускается использовать несколько раз.
if
...
elif
...
elif
...
else
...
В других языках часто можно встретить оператор switch/case, который последовательно сверяет значение переменной с различными константами. Питон такой прелести лишён.
Допускается использование вложенных операторов if:
if x == 1:
print(x)
if x == 3:
print(x)
else:
print(x*10)
Можно создавать сложные условия с использованием логических операторов и\или. Условия можно группировать с помощью скобок.
if (x >= 0 and x <= 1) or x < 0:
Допускается использование двойных (и более) неравенств:
if 0 < x < y < 1: # вместо if 0 < x and x < y and y < 1
Циклы
Простейший цикл:
while условие_истинно:
...
[else:
...]
Пример. Посчитаем сумму первых десяти натуральных чисел.
k = 0
s = 0
while k < 10:
k += 1
s += k
print( s )
Также в питоне существует цикл for: for <переменная> in <последовательность>. Рассмотрим на предыдущем примере:
s = 0
for k in range(1, 11):
s += k
print(s)
/*На заметку. for в питоне работает не так, как в других языках, и ему больше бы подошло название "for each". В питоне этому циклу необходима какая-либо последовательность, элементы которой он последовательно выбирает и обрабатывает. В паскале, си, джаве и им подобным, for обычно работает не с объектами напрямую, а со счётчиком: for (i = 0; i <= 10; i += 1). В питоне для этого приходится заводить последовательность чисел.*/
range(a,b,h) возвращает последовательность чисел из интервала [a..b) с указанным шагом h, не включая b. Таким образом, for k in range(0,100) означает "для всех k от 0 включительно до 99 включительно". Эту функцию можно использовать в трёх вариантах:
range(5) # 0, 1, 2, 3, 4
range(2, 5) # 2, 3, 4
range(2, 8, 2) # 2, 4, 6
Кроме того, шаг можно задать отрицательный - тогда значения последовательности будут уменьшаться: for k in range(0, -10, -1): print(k)
/*Здесь нужно сделать замечание, которое может стать понятнее после следующих лекций. В питоне существуют так называемые итерируемые (iterable) структуры данных. Экземпляры таких структур можно обходить — последовательно извлекать некоторые значения, определяемые данным экземпляром структуры. Пример — список, при обходе мы последовательно получаем его элементы. range — тоже итерируемая структура данных. При обходе мы получаем все числа от нижней границы, до верхней (не включительно) с заданным шагом. Обход итерируемой структуры осуществляется с помощью конструкции for x in struct; x пробегает все значения итерируемой структуры.*/
В качестве примера рассмотрим программу расчёта таблицы значений для функции 
в диапазоне от 0 до 1 с шагом 0.1
from math import exp, sqrt
x = -0.1
while x < 1:
x += 0.1
y = exp(-x) * sqrt(x)
print( '{:5.2f}{:9.4f}'.format(x, y) )
Лекция №3------------------------------------------------------------------------------------------------------------- 16.09.2015
//Лирическое отступление от Борисова
Шелл (интерпретатор) питона можно использовать в качестве калькулятора: >>> 4+6 выдаст результатом 10. Функции можно вызывать напрямую из шелла, не запуская саму программу. По нажатию Ctrl+Space (как в шелле, так и во встроенном редакторе IDLE) появляется список предложений, из которого можно выбирать функции и переменные.
/*Объявленные прямо в шелле переменные и функции действительны только в течение текущего сеанса. Сеанс шелла можно перезапустить через Shell -> Restart Shell (Ctrl+F6). Так, если задать a = 5 и перезапустить сеанс, то к a нельзя будет обратиться.*/
"_" - переменная, в которую записывается результат выполнения последнего действия.
>>> 4+6
>>> _+3
Написанную в редакторе программу перед запуском необходимо сохранить в файл. Запустить программу в интерпретаторе можно с помощью Run -> Run Module (F5)
a = 1
b = 2
print(a + b*2)
# F5 #
====Restart
>>>
Циклы (продолжение).
Рассматриваем программу печати таблицы с прошлой лекции.
from math import exp, sqrt
x = -0.1
while x < 1:
x += 0.1
y = exp(-x) * sqrt(x)
print( '{:5.2f}{:9.4f}'.format(x, y) )
Результат:
0.00 0.0
...
0.9 0.3857
1.0 0.3679
1.1 0.3491
Второй вариант:
from math import exp, sqrt
x = 0
while x < 1:
y = exp(-x) * sqrt(x)
print( '{:5.2f}{:9.5}'.format(x, y) )
x = x + 0.1
Результат:
0.00 0.0
...
1.80 0.22177
1.90 0.20617
/*"Парадокс" в первом случае возникает из-за накопления ошибки вещественного числа - питон округлит 0.99999999 до 1 при печати.
Для тех, кто в танке. Числа в информатике записываются двоичным кодом ограниченной размерности (обычно 32-64 бита) - невозможно поделить 2 / 3 и получить целую дробь, получится десятичная дробь 0.6666666667. Если сложить два таких результата деления, то получится 1,3333333334. Точно также при делении 1/100 получится не 0.1, а 0.100000000001 (или 0.999999999999). С выполнением арифметических операций эта ошибка округления в хвосте постепенно растёт. Таким образом, если 100 раз сложить по 0.01, то в итоге получим не ожидаемое 1.0, а 0.9999999999998 или 1.0000000000000007.*/
from math import exp, sqrt
xn, xk, hx = map( float, input('input xn, xk, hx: ').split() )
x = xn
print( ' x y')
while x < xk + hx/2:
y = exp(-x) * sqrt(x)
print( '{:5.2f}{:9.4f}'.format(x,y) )
x += hx
Здесь в цикле мы каждый раз увеличиваем переменную на шаг, но выходим из цикла только когда переменная становится больше чем конец+полшага. Это наиболее простой способ организации циклов while с итерацией по вещественной переменной.
Операторы continue и break
Вычисление таблицы значений функции: 
. Печатать только те значения, в которых знаменатель больше некоторого указанного числа.
from math import sin
x = 1.08; eps = 0.01 # НЕ РЕКОМЕНДУЕТСЯ писать в питоне несколько высказываний через ; в строчку, и это применимо не только к питону
while x < 1.14:
x += 0.01
znam = 1/x - sin(x)
if abs(znam) < eps:
print( 'if x=', x, ' y not calculated' )
continue
#break #в этом случае цикл бы моментально завершился
y = ( 1.5 + sin(x) ) / znam
print(' {:6.2f}{:12.5f}'.format(x, y) )
print( '******************' )
Результат:
1.09 77.47713
1.10 133.70989
if x= 1.11 y not calculate
if x= 1.12 y not calculate
1.13 -123.57926
1.14 -76.60923
Оператор continue переводит цикл на следующую итерацию, пропуская всё "оставшееся" тело цикла.
Оператор break завершает цикл.
Сумма бесконечного ряда
Для заданного значения Х и заданной точности 
необходимо найти сумму данного ряда.
Введём значения: n = значение ряда, t = текущий член ряда, y = сумма
При запуске указываются начальные значения n, t, y. В цикле while необходимо изменять n += 1, t = t * x / n, y += t.
eps = float( input('input precision: ') )
x = float( input('input number x: ') )
n = 0
t = 1
y = 1
while abs(t) > eps:
n += 1
t *= x / n
y += t
print( 'sum =', y )
/*Хорошей практикой является давать переменным осмысленные названия. В данном случае можно было бы вместо t и y использовать что-нибудь вроде curItem и seriesSum*/
Списки
Списки состоят из однотипных или разнотипных элементов и являются динамическими конструкциями. Размер списка можно изменять во время выполнения программы. Список можно создавать, перечисляя элементы через запятую в квадратных скобках:
s = ['q', 'w', 'e', 'r', 't', 'y']
x = [1, 6, 2, 7, 3]
Списки можно складывать: /*А вообще-то такая операция называется конкатенацией, соединением */
a = ['q', 'w', 'e', 'r', 't' ]
b = ['y']
c = a + b
y = [1, 6]
c += y
>>>
c = ['q', 'w', 'e', 'r', 't', 'y', 1, 6]
В питоне очень просто создаётся список из одинаковых элементов:
u = ['k']*5 # идентично ['k', 'k', 'k', 'k', 'k']
Так, например, можно задать список из нулей:
x = [0] * 100
Списки можно генерировать из целых чисел:
y = [k for k in range(7)] # 0 1 2 3 4 5 6
И даже так:
y = [k**2 for k in range(7)] # 0 1 4 9 16 25 36
При создании списка можно включать в него только те данные, удовлетворяющие некоторым условиям:
x = [k for k in range(7) if k % 3] # 1 2 4 5
Можно сгенерировать список из случайных чисел:
y = [random() for x in range(5)] #random() выдаёт вещественное 0..1 не включая 1
L = [] # пустой список
L = [L*2 for L in 'IU7']
L = [L*2 for L in 'IU7' if L != 'U']
Методы
| L | список |
| L.append(x) | вставляет объект х в конец списка |
| L.extend(s) | вставляет в конец списка L список s |
| L.reverse() | обращает список |
| L.index(x[, start[, end]]) | возвращает индекс первого вхождения объекта х в список L, генерирует исключение, если этот объект не найден |
| L.insert(i, x) | вставляет на i-ю позицию объект x |
| L.count(x) | возвращает количество элементов со значением x |
| L.remove(x) | удаляет первое вхождения элемента в список, если элемента нет – генерирует исключение |
Лекция №4------------------------------------------------------------------------------------------------------------- 23.09.2015
//Лирическое отступление от Борисова
 |  |  |
| объединение множеств | разность множеств | пересечение множеств |
L = [2, 7, 5, 9, 5]
L.insert(1,0) # [2, 0, 7, 5, 9, 5]
L.append(5) # [2, 0, 7, 5, 9, 5, 5]
L.index(5) # 3
L.remove(5) #[2, 0, 7, 9, 5, 5]
Ввод-вывод списков (массивов)
/*Массивов в питоне, в отличие от многих других языков, нет. Только списки и кортежи (о которых будет сказано позже).*/
n = int(input('input size of list: '))
x = [0]*n # создает список x из n нулей
for i in range(N):
print( 'x[', i, ']=', sep='', end='' )
x[i] = int(input())
print(x)
Оформление лабораторной по ряду: задается x, эпсилон (точность), n (количество просуммированных членов ряда), hn (шаг), m (максимальное количество членов ряда). Таблица: n | текущая сумма. После завершения цикла отобразить строку "При х .. с точностью е .. получен результат .."
Использование конструкции sep в функции print() позволяет вставлять пробелы до и после i; конструкция end будет выводить указанное число пробелов после символа =.
Результат будет выведен в квадратных скобках через запятую и пробел.
/*На самом деле, sep и end – это так называемые именованные параметры функции. В sep передаётся строка, которой будут разделяться остальные аргументы, в end – строка, которой будет завершаться вывод. Так, print(1, 2, 3.0, "4567890", sep=" and ", end=' finish') выведет 1 and 2 and 3.0 and 4567890 finish. */
Второй вариант ввода:
x = [int(input()) for i in range(N)]
Также:
L = input('Введите массив в одну строку: ').split()
m = map(int, L)
x = list(m)
/*Обратите внимание – L является списком строк; m – итерируемым объектом типа map. Для создания списка на основе итерируемого объекта используется функция list() – так, можно проверить выполнение r = list( range(5) ).*/
Вывод списка без квадратных скобок и запятых:
x = [3, 7, 5]
for i in range(3):
print(x[i], end=' ')
print()
/*Поскольку здесь мы указываем, что после печатаемой строки должен стоять пробел, нам необходим последний print() для того, чтобы перевести строку. В противном случае, если бы после печати списка мы хотели бы распечатать "test", то получили бы 3 7 5 test вместо
3 7 5
test
*/
Или:
for a in x:
print(a, end='; ')
print('')
Ввод списка чисел, и печать только чётных из списка:
x = [] # список можно предварительно создать пустым, хотя в данном случае это и не обязательно
x = list(map(int, input().split()))
s = 0
for i in range(len(x)):
if x[i] % 2 == 0:
s += x[i]
Поиск максимума в списке
x = []
x = list(map(int,input().split()))
xMax = x[0]
for r in x:
if r > xMax:
xMax = r
print(xMax)
Может потребоваться искать не только максимальное число, но и его позицию:
xMax = x[0]
nMax = 0
for i in range(1, len(x)):
if x[i] > xMax:
xMax = x[i]
nMax = i
print(xMax, nMax)
Третий способ нахождения:
nMax = 0
for i in range(1, len(x)):
if x[i] > xMax:
nMax = i
print(xMax[nMax],' ', nMax)
Наконец, можно воспользоваться стандартной функцией
xMax = max(X)
nMax = x.index(xMax)
print(xMax, nMax)
Стандартная печать списка печатает его в одну строку, даже если в списке множество элементов. Может потребоваться ограничивать количество элементов, печатаемых на строке.
a = []
# ввод по одному числу в строке
for i in range(int(input('Введите количество элементов: '))):
a.append(int(input('> ')))
print(a)
for i in range(len(a)):
if ( i+1 ) % 3 == 0:
print(a[i])
else:
print(a[i], end = ' ')
print('\n')
В этом примере печатается одномерный массив (список) по 3 элемента в строке. Второй вариант:
for i in range(len(a)):
print(a[i], end = ' ')
if (i + 1) % 2 == 0:
print()
print('\n')
Другие способы печати:
for i in range(len(a)):
print(a[i])
# или
for r in a:
print(r, end=' ')
print()
Лекция №5------------------------------------------------------------------------------------------------------------- 30.09.2015
Срезы
Срезы полезны для создания копий последовательности или её частей. Зададим список: x = [1,2,3,4,5]. Рассмотрим возможности срезов.
| R = x[:] | создает копию списка: [1,2,3,4,5] |
| R1 = x[0:3] | формируется список c 0-го элемента х по : x[0], x[1], x[2]: [1,2,3] |
| R2 = x[1:] | выбираются все элементы, кроме первого: [2,3,4,5] |
| R3 = x[:3] | первые 3 элемента массива: [1,2,3] |
| R4 = x[:-1] | все элементы, кроме последнего: [1,2,3,4] |
| R5 = x[-3:] | три последних элемента: [3,4,5] |
| R6 = x[1:-2] | отсутствуют первый элементы и два последних: [2,3] |
Срезы могут быть с тремя параметрами.
/*Можно указывать шаг среза через второе двоеточие. Так, для списка s = [1,2,3,4,5,6,7,8] срез s[1:6:2] даст [2,4,6], а срез s[::3] даст [1,4,7].*/
Стандарт написания кода Python
/*Интересно, почему Борисов решил рассказать про это только к пятой лекции?..*/
1. максимальная длина строки – 79 символов. Для переноса длинных строк используются скобки
2. не всегда целесообразно использовать обратный слэш для перехода на новую строку
3. отступы – всегда одинаковое число пробелов, крайне желательно – 4.
4. никогда не следует смешивать табуляцию и пробелы; предпочтение отдаётся пробелам
5. для строк можно применять как апострофы, так и двойные кавычки
6. не использовать точки с запятой для отделения команд, находящихся на одной строке; по одной команде на строку (за редким исключением)
7. пустые строки – полезная и нужная вещь. Не злоупотреблять – объединять блоки кода по смыслу, а не ставить новую строку после каждой строчки кода
8. не ставить пробелы перед , ; . :
9. никаких пробелов перед открывающей скобкой (которая начинает список аргументов, индексы или срезы)
10. не использовать пробелы для вертикального выравнивания кусков последовательных строк:
x =1
y =2
val =3 # зло!
11. всегда ставить пробелы вокруг символа =
12. всегда ставить одиночные пробелы перед символами операций сравнения (< == != и т.п.), in, in not, is, is not, or, and, not
13. в арифметических выражениях можно ставить пробелы для повышения наглядности: h = x*x + y*y
14. комментарии – обязательны. При изменении кода нужно изменять комментарии. Если комментарий – фраза или предложения, то первая буква должна быть заглавной. На комментарии так же распространяется правило 79 символов.
15. блоковые комментарии – состоят из полных предложений; каждое предложение заканчивается точкой и двумя пробелами. Блоковые комментарии обычно располагаются перед блоками кода. Каждая строка начинается с символа комментария и одного пробела.
16. строковые комментарии – использовать умеренно. Отделять одним пробелом от комментируемой строки
17. не писать очевидных комментариев. /*Комментарий должен пояснять особенности кода – сложные участки, прикрученные костыли, "почему код написан именно так".*/
/*Данный список во многом основывается на широко известном в питоньих кругах положении PEP8. Смекалистые программисты даже придумали специальные фичи автоматической проверки кода на соответствие стандарту.*/
Задан список чисел и число. Найти номер элемента, если он встречается в списке.
X = [1, 4, 9, 3, 2]
R = 9
k = 0
while X[k] != R:
k += 1
print('X[', k, ']=', R, sep='')
Если элемент R отсутствует в списке, то программа выдаст ошибку – после обработки всех элементов списка произойдёт обращение к несуществующему элементу.
Корректный вариант:
X = [1, 4, 9, 3, 2]
R = 8
k = 0
N = len(X)
while k < N and X[k] != R:
k += 1
if k < N:
print(k)
else:
print('нет элемента')
Либо с использованием цикла for:
X = [1, 4, 9, 3, 2]
R = 8
k = 0
nom = -1
for k in range(len(X)):
if X[k] == R:
nom = k
break
if nom >= 0:
print(nom)
else:
print('нет элемента')
Здесь в случае обнаружения элемента запоминается его номер, в противном случае "возвращается" значение -1.
Ещё один вариант:
X = [1, 4, 9, 3, 2]
R = 8
k = 0
for k in range(len(X)):
if X[k] == R:
print(k)
break
else:
print('нет элемента')
Здесь else связано с циклом, а не с if – данная конструкция специфична для питона.
/*Код, находящийся в блоке else цикла вызывается только в том случае, если цикл завершается "стандартно". Для for – если перебраны все элементы коллекции, для while – если перестало выполняться условие. Если цикл завершается с помощью break, переход к блоку else не происходит.*/
X = [1, 4, 9, 3, 2]
R = 9
if R in X:
nom = X.index(R)
print(nom)
else:
print('нет элемента')
Здесь мы вместо цикла используем условный оператор. Если элемент присутствует в списке, то выводится его индекс.
Многоступенчатые циклы
Многоступенчатые – циклы, в которых один цикл располагается внутри другого. Другое название – вложенные циклы.
Рассмотрим задачу вычисления полинома (многочлена) по схеме Горнера.
Достоинство метода: количество операций сокращается по сравнению с решением в лоб.
/*Операции над числами можно разделить по сложности (времени) выполнения: сложение\вычитание легче умножения, а умножение, в свою очередь, легче возведения в степень. Здесь мы N возведений в степень заменяем на N умножений, получая выигрыш в производительности.*/
Кроме того, легко организовать цикл: * + * + … * +
При решении задачи будем считать, что задается много значений Х: 
и так далее.
n = int(input('input exponent of polynom: '))
a = [0]*(n+1)
m = int(input("input number of points (x's): "))
x = [0]*m
y = [0]*m # возможен также вариант y = x[:], но ни в коем случае не y = x !
# ввод по одному числу в строке
print('input ', n+1, 'coefficients of the polynom:')
for i in range(n+1):
a[i] = float(input())
print(a)
print('input values of the ', m, 'points:')
for i in range(m):
x[i] = float(input())
print(x)
# непосредственно вычисления
for k in range(m):
y[k] = a[n-1]
for i in range(n-2, -1, -1): # внимание: до -1 НЕ ВКЛЮЧИТЕЛЬНО
y[k] = y[k]*x[k] + a[i]
print('argument function')
for k in range(m):
print('{:6.2f}{:13.5f}'.format(x[k], y[k]))
Здесь y – массив значений полинома для разных 
.
Сортировка массива
Сортировка пузырьком:
n = int(input('введите количество элементов списка:'))
x = [0]*n
print('введите список элементов (по одному на строку): ')
x = [int(input()) for i in range(n)]
print(x)
for i in range(n-1):
for j in range(n-2, i-1, -1):
if x[j] > x[j+1]:
x[j], x[j+1] = x[j+1], x[j]
print(x)
Второй вариант:
n = int(input('введите количество элементов списка:'))
x = [0]*n
print('введите список элементов (по одному на строку): ')
x = [int(input()) for i in range(n)]
print(x)
for i in range(n):
for j in range(n-i-1):
if x[j] > x[j+1]:
x[j], x[j+1] = x[j+1], x[j]
print(x)
Третий вариант:
print('введите список элементов (в строчку): ')
x = list(map(int, input().split()))
print(x)
for i in range(n):
for j in range(n-i-1):
if x[j] > x[j+1]:
x[j], x[j+1] = x[j+1], x[j]
print(x)
/*Поскольку в питоне списки можно создавать "на лету" из вводимых пользователем значений – данный способ ввода является предпочтительным.*/
Сортировка выбором:
print('введите список элементов (в строчку): ')
x = list(map(int, input().split()))
print(x)
n = len(x)
for i in range(n-1):
nmin = i
for j in range(i+1,n):
if x[j] < x[nmin]:
nmin = j
x[i], x[nmin] = x[nmin], x[i]
print(x)
Матрицы
Прямоугольная матрица размерности [3х4]. Первый индекс – номер строки, второй индекс – номер столбца.
Широко используются квадратные матрицы: количество строк и столбцов одинаковое, и можно задавать одной величиной (порядок) вместо двух.
В квадратных матрицах выделяют диагонали: главную (индексы равны) и побочную (сумма индексов на 1 больше порядка)
a11 a12 a13 a14
a21 a22 a23 a24
a31 a32 a33 a34
a41 a42 a43 a44
В каждой строке может быть разное количество элементов. Используется редко, но используется.
Может понадобиться работать только с элементами, находящимися под\над главной\побочной диагональю.
Лекция №7------------------------------------------------------------------------------------------------------------- 14.10.2015
Печать матрицы в виде матрицы:
x = [[1,2,3],[4,5],[6,7,8,9]]
for i in range(len(x)):
for j in range(len(x[i])):
print(x[i][j], end=' ')
print()
или
for row in x:
for r in row:
print(r, end=' ')
print()
Результат (в обоих случаях):
1 2 3
4 5
6 7 8 9
Обращение к элементам матрицы происходит в формате матрица[строка][столбец].
/*Если нет необходимости работать с индексами, достаточно только с элементами, то второй вариант использовать предпочтительнее.*/
Для задания матрицы с какими-то начальными значениями можно использовать три способа:
n = 4
m = 3
# 1)
x = [0]*n
for i in range(n):
x[i] = [0]*m
print(x)
print()
# или
# 2)
x = []
for i in range(n):
x.append([1]*m)
print(x)
print()
# или
# 3)
x = [[2]*m for i in range(n)]
print(x)
print()
/*или
# 4)
x = [[3]*m]*n
print(x)
print()
Третий способ может оказаться полезнее, потому что с его помощью матрицу можно заполнять на основе некоторых условий, а не просто константными значениями.*/
Ввод значений в матрицу:
n = 2
m = 2
print('Введите матрицу',n,'X',m,'по одному числу в строке:')
x = [[0]*m for i in range(n)]
for i in range(n):
for j in range(m):
x[i][j] = int(input('> '))
print(x)
print('Введите матрицу',n,'X','.. построчно:')
n = 3
x = []
for i in range(n):
x.append([int(j) for j in input().split()])
print(x)
# данный случай скорее иллюстрирует, как НЕ НАДО делать)
# потому что через месяц, посмотрев на этот код, может оказаться
# проблематично понять, а что здесь черт возьми происходит
n = 4
x = []
x = [[int(j) for j in input().split()] for i in range(n)]
print(x)
Рассмотрим простую задачку на матрицы.
# определить: сумму элементов каждой строки;
# количество положительных элементов в матрице
n = int(input('количество строк: '))
m = int(input('количество столбцов: '))
print('введите матрицу, по одному элементу в строке:')
a = []
for i in range(n):
a.append([])
for j in range(m):
a[i].append( int(input('> ')) )
# печатаем матрицу в строчку
print(a); print()
# печатаем матрицу в n строк
for q in a:
print(q)
count = 0
for i in range(n):
s = 0
for j in range(m):
s += a[i][j]
if a[i][j] > 0:
count += 1
print(s)
print(count)
Результаты выводить – С ПОЯСНЯЮЩИМ ТЕКСТОМ! Особенно в лабах! Отдельно от вычислений – через один-два print().
В данной задаче целесообразно было бы сформировать последовательность (одномерный массив) для хранения сумм строк и организовать отдельный вывод этого массива сумм после обработки матрицы.
Пусть задана матрица.
x = [[-1,2,7,9],
[-1,2,7,2],
[-1,2,7,6],
[-1,2,7,0]]
print(x)
Поменяем местами столбцы 1 и 2: /*считая от нуля, ага)*/
n = 4
for i in range(n):
b = x[i][2]
x[i][2] = x[i][1]
x[i][1] = r
for q in x:
print(q)
print()
# или, с учетом возможностей питона:
for i in range(n):
x[i][2], x[i][1] = x[i][1], x[i][2]
for q in x:
print(q)
print()
Если нужно поменять местами две строки, задача упрощается:
x[1], x[2] = x[2], x[1]
Если бы нам понадобилась копия строки 1 матрицы:
s = x[1][:]
А вот копию столбца 3 получить уже не так просто:
c = [row[3] for row in x]
Аналогичным образом можно получить и главную диагональ:
d = [x[i][i] for i in range(n)]
Лекция №8------------------------------------------------------------------------------------------------------------- 21.10.2015
Задачки с контрольной:
Задан список, в котором могут встречаться повторяющиеся числа. Оставить на месте списка только неповторяющиеся числа.
z = list(map(int, input().split()))
k = len(z)
for i in range(len(z)):
if z.count(z[i]) == 1:
z.insert(len(z), z[i])
z = z[k:]
Переставить элементы так, чтобы в начале массива шли элементы, стоявшие ранее на нечетных местах, а затем элементы, стоявшие на четных.
r = list(map(int, input('input array').split()))
r = r[::2] + r[1::2]
/*См. пункт «Списки -> Срезы», если в шоке от непонимания «демоны, что это за чёрная магия»*/
Строки
s = 'Вася иногда учится'
Ввод строки:
s = input('What is your name ')
Обращение к символам строки с помощью индекса в квадратных скобках: s[3]
Важнейшее отличие питона: изменять символы в строке нельзя! В отличие от, например, Си или Паскаля, нельзя написать s[1] = '1'!
Для изменения отдельных символов необходимо создавать новую строку:
s = 'Kondrashenka'
s1 = ''
for x in s:
if x == 'a':
x = 'o'
s1 += (x)
print(s1)
Управляющие коды строковых констант:
| \n | перевод строки |
| \r | возврат каретки |
| \t | горизонтальная табуляция |
| \v | вертикальная табуляция |
| \a | звуковой сигнал |
| \b | возврат на одну позицию |
| \f | перевод страницы |
| \0 | нулевой символ. Конец строки не символизирует – тут вам не там, питон вам не си. |
| \" | двойные кавычки |
| \' | одинарные кавычки (апостроф) |
| \\ | обратный слэш |
| \uHHHH | 16-битный символ Unicode |
| \uHHHHHHHH | 32-битный символ Unicode |
/*Касательно юникодных символов. H – шестнадцатеричная (hexadecimal) цифра, 0123456780ABCDEF. Если искомое число содержит меньше четырех таких цифр – необходимо использовать лидирующие нули. Так, если мы захотим напечатать символ '>': его порядковый номер в таблице символов – 62, в шестнадцатеричном формате – 3e, и распечатаем мы его как print('\u003e')*/
Операции над строками
Индексация символов – с нуля. Если по указанному индексу нет символа, то возникает ошибка.
В качестве индекса можно указывать отрицательное число (как и для списков). В этом случае индекс отсчитывается от конца строки.
>>> a = [1,2,3]
>>> a[-1]
В этом случае, чтобы получить положительный символ, указанное значение вычитается из длины строки. Т.е. последний символ можно получить двумя способами: s[-1] эквивалентно s[len(s)-1].
410 < 42: true
pascal > Pascal: true
На больше-меньше строки сравниваются посимвольно, в лексикографическом порядке.
| s1 + s2 | конкатенация (соединение) двух строк |
| s*n или n*s | n-кратное повторение строки |
| min(s) | символ с наименьшим номером в кодовой таблице |
| max(s) | символ с наибольшим номером |
Методы строк
| s.center(n) | дополнение пробелами справа и слева, чтобы длина строки стала n |
| s.ljust(n) | выравнивание по левому краю (пробелы добавляются в конец) |
| s.rjust(n) | по правому (пробелы добавляются в начало) |
| s.count(t[, i, j]) | количество вхождений подстроки t в строку s (результат – число). i – позиция начала поиска, j – конца поиска |
| s.find(t[, i, j]) | позиция первого вхождения подстроки t в строку s |
| s.rfind(t[, i, j]) | позиция последнего вхождения |
| s.strip() | создается копия строки, в которой удалены пробелы в начале и в конце |
| s.lstrip() | копия, в которой удалены пробелы только в начале |
| s.rstrip() | только в конце |
| s.replace(t1, t2[, n]) | создается новая строка, в которой фрагмент t1 исходной строки заменяется на фрагмент t2. n – максимальное количество замен. |
Рассмотрим пример:
s = input('введите слово: ')
word = 0
min_len = len(s)
for k in s:
if 'a' <= k <= 'z':
word += 1
else:
if word < min_len and word != 0:
min_len = word
word = 0
print(min_len)
Программа вычисляет длину наименьшей последовательности строчных букв в строке. Если строчных букв не было – выведет длину строки.
Другой пример:
s = input('введите строку: ')
num = int(input('введите номер слова: '))