Цикл с одновременным изменением нескольких параметров
Вычислить таблицу значений 
from math import sin
a = float(input('input variable: '))
b = []
b = list( map(float, input('input list: ').split()) )
print(' k a b y')
for k in range(len(b)):
a = 0.1 * k
y = a * sin(b[k])
print('{:2d}{:6.1f}{:9.4f}{:14.8f}'.format(k, a, b[k], y))
Здесь одновременно изменяется переменная а от 0 с шагом 0.1, b – список. При этом вторая строка с a = float – лишняя, поскольку a в дальнейшем постоянно изменяется.
Лекция №6------------------------------------------------------------------------------------------------------------- 07.10.2015
//Лирическое отступление: решение задач из контрольной
Вычисление ряда с факториалом: 
from math import pow, factorial
x = float(input())
eps = float(input())
s = x
t = x
n = 1
while abs(t) > eps:
n2 = 2*n + 1
t = (-1)**n * pow(x, n2)/n2/factorial
n += 1
s += t
print(s)
Очередной элемент ряда можно получить на основе предыдущего: 
. Второй вариант:
x = float(input())
eps = float(input())
s = x
t = x
n = 1
while abs(t) > eps:
n = n+2
t = -t*x*x * (n-2)/(n-1)/n/n
s += t
print(s)
Вторая задача:
n = int(input())
y = 1
for i in range(2 - n%2, n+1, 2):
y *= i
y = y * ( 1 - 2*( (n+1)%2 ) )
print(y)
Третья задача:
a = list(map(int, input().split()))
print(a)
s = 0
k = 0
for i in range(len(a)):
if a[i] > 0:
s += a[i]
k += 1
if k > 0:
a[len(a)-1] = s/k
print(a)
else:
print('no positive elements in list')
На контрольных необязательно заморачиваться с приглашениями для ввода и длинными именами переменных – тратится драгоценное время.
Задана упорядоченная последовательность (возрастающая), в которой требуется найти элемент. Простой подход был рассмотрен ранее (см. прошлую лекцию). Рассмотрим алгоритм двоичного (бинарного) поиска:
A = [1,2,3,4,5]
X = 4 # искомое число
L = 0
N = len(A)
L = 0; R = N; # ; в конце необязательна, хотя ошибкой и не будет
while L < R-1:
t = (L+R) // 2
if X < A[t]:
R = t
else:
L = t
if A[L] == X:
print('A[', L, ']=', X, sep='')
else:
print('No')
Данный алгоритм применим только к упорядоченным последовательностям, но позволяет значительно увеличить скорость поиска. Мы рассматриваем интервал последовательности, делим пополам, берем в нем серединный элемент, и сравниваем с искомым. Если искомый больше середины – значит проверять дальше нужно только правую половину, если меньше – то левую.
A = list(map(int,input('input list: ').split()))
print(A)
Пусть нужно выделить из массива только четные числа. Первый вариант:
B = []
for x in A:
if x % 2 == 0:
B.append(x)
print(B)
Условие – не обязательно четность, критериев может быть много (нечетные, делящиеся на три, большие чем число и т.п.).
Второй вариант:
d = [t for t in A if t % 2 == 0]
print(d)
Данный вариант специфичен для питона. Другие языки такие конструкции обычно не поддерживают.
k = -1
N = len(A)
W = [0]*N
for i in range(N):
if A[i] % 2 == 0:
k += 1
W[k] = A[i]
# print(k)
for j in range(k+1):
print(W[j])
Данный вариант похож на реализацию, какой она была бы на Паскале. Создается массив нулей W, такого же размера, как исходный. Переменная k используется для определения "истинного" размера массива W.
Здесь мы печатаем массив в отдельном цикле. Как правило, "подпрограммы" вроде выделения элементов из массива используются в составе каких-то других программ, и печать в них излишня. В данном (и многих других) случаях нет ничего зазорного в том, чтобы пройтись по массиву три раза: для ввода, для обработки, и для печати.
Многоступенчатые циклы
Многоступенчатые – циклы, в которых один цикл располагается внутри другого. Другое название – вложенные циклы.
Рассмотрим задачу вычисления полинома (многочлена) по схеме Горнера.
Достоинство метода: количество операций сокращается по сравнению с решением в лоб.
/*Операции над числами можно разделить по сложности (времени) выполнения: сложение\вычитание легче умножения, а умножение, в свою очередь, легче возведения в степень. Здесь мы 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('введите номер слова: '))
l = len(s)
count = 0
k = 0
b = 0
while k < l:
if s[k] != ' 'and b == 0:
count += 1
b = 1
if count == num:
break
if s[k] == ' ':
b = 0
k += 1
print(s[k])
Печатает первую букву слова с указанным номером.
s = input('string of words: ')
l = len(s)
n = int(input('number of the word: '))
s = s.split()
print(s[n-1][0])
То же самое, только проще, python-way.
Лекция №9------------------------------------------------------------------------------------------------------------- 28.10.2015
Преобразование списка в строку
Иногда возникает необходимость преобразовать список в строку. Для этого используется метод строки .join(). Сама строка в этом случае строка используется для разделения элементов списка.
mas = ['abc', 'bb', 'cccc']
st = ', '.join(mas)
print(st) # 'aaa, bb, cccc'
Нельзя чтобы в исходном списке были отличные от строк символы, например числа! Обойти это ограничение можно с помощью следующей конструкции:
mas = ['abc', 'bb', 'cccc', 3, 5, 7]
st = ', '.join( [str(x) for x in mas] )
print(st) # 'aaa = bb = cccc = 3 = 5 = 7'
/*Другой вариант: с использованием map(): st = ' = '.join( map(str, mas) )*/
Кортежи
Кортежи весьма похожи на списки, но обладают одной важной особенностью – изменять кортежи нельзя (изменять элементы, удалять и т.п.)
Кортежи можно, к примеру, использовать для нахождения максимального (минимального) элемента в массиве, чтобы возвращать одновременно максимальный элемент с его индексом. Но, например, в сортировках использовать кортежи бессмысленно, поскольку требуется изменять порядок элементов.
/*Вообще, кортежи удобно использовать везде, где хочется две переменные «запаковать» в одну. Например, функцию расстояния между точками на плоскости можно объявить не как distance(x1, y1, x2, y2), а как distance(a, b), и вызывать через distance( (10,20), (30, 40) )*/
Создать кортеж можно с функции tuple() – эта функция позволяет преобразовать любую последовательность в кортеж. Функция принимает не более одного аргумента!
T = (1,2,3) создание кортежа вручную
T = (7,) кортеж из одного элемента; запятая обязательна!
T = tuple('xyz') получаем кортеж ('x','y','z')
/*Фактически, кортеж определяется именно запятыми, а не скобками. Запись T = (1,2,3) эквивалентна T = 1,2,3 и эквивалентна T = 1,2,3,. Но здесь запятые уже встречаются в середине; если же в случае одноэлементного кортежа забыть про запятую в конце, то интерпретатор расценит такую запись как инициализацию простой переменной, а не кортежа. Единственное исключение из этого правила – пустой кортеж a = ().
Можно ли опускать скобки при работе с кортежами? Лучше не надо, разве что ты полностью отдаёшь себе отчет в том, что происходит. К примеру, попытка сравнить (1,2,3) == 1,2,3 выдаст не ожидаемое True, а какую-то наркоманию: (False, 2, 3). А если пойти дальше и сравнить 1,2,3 == 1,2,3, то мозг может вообще вылететь форточку: (1, 2, False, 2, 3).
Почему кортежи определяются запятыми, а не скобками? Потому что, написав в арифметическом выражении (3+4)*5, программист обычно ожидает увидеть 35, а не (7, 7, 7, 7, 7). Да, в предыдущем примере на сравнения скобки определяют именно порядок работы с элементами: запаковать 1,2,3 в кортеж, сравнить его с 1, результат запаковать в кортеж с 2 и 3.*/
При работе с кортежами можно применять конкатенацию +, дублирование *, получение среза [], проверять на вхождение in и not in. Можно использовать комбинированные операторы присваивания (a = b = c). Кортежи допускается сравнивать: < <= == != >= >.
/*Также как и строки (и списки), кортежи сравниваются поэлементно, в лексикографическом порядке: (2,1,3) > (1,3,5), поскольку 2 > 1*/
Также можно использовать функции min, max, count, index.
Кортежи допускают вложения с любым уровнем вложенности.
t =(-13, 3.4, ('наташа', (6, 'вася'), 'оля', 'маша') )
print(t[2][1][1][2]) # выведет символ 'с'
Но отвлечемся от кортежей и рассмотрим ещё примеры на строки:
s = input('input words and numbers: ')
l = len(s)
int_s = []
k = 0
while k < l:
sp = ''
r = s[k]
while '0' <= r <= '9':
sp += r
k += 1
if k < l:
r = s[k]
else:
break
k += 1
if sp != '':
int_s.append(int(sp))
print('numbers')
print(int_s)
Все наборы цифр в введённой строке занесет в список чисел
input words and numbers: word123 56ivanofff7
numbers
[123, 56, 7]
Другой пример:
s = input('input words: ')
k = 0
while s[k] == ' ': k += 1
s = s[k:]
k = len(s)
while s[k-1] == ' ': k -= 1
s = s[:k]
s1 = s[0]
k = 1
while k < len(s):
if s[k] != ' ':
s1 += s[k]
elif s[k-1] != ' ':
s1 += '**'
k += 1
print(s1)
Убирает пробелы в начале и конце строки, а вместо остальных пробелов будет печатать звездочки:
input words and numbers: abc de 12 fg
abc**de**12**fg
А теперь то же самое, но уже на питоне, а не паскаль-стайл:
s = input()
l = s.split()
s1 = ''
for k in l:
s1 += k + '**'
s1 = s1[:-2] # пропустим заключительные две звездочки
print(s1)
/*И даже ещё более python-way:
s = input()
s1 = '**'.join( s.split() )
print(s1)
Ну не прекрасный ли язык?)*/
Множества
Множества в питоне – структура данных. Появились в версии 2.4. Данная структура данных эквивалентна множествам в математике. Множество может состоять из различных элементов, порядок которых не определен.
Элементами множества может быть неизменяемый тип данных: числа, строки, кортежи. Изменяемые типы данных не могут быть элементами множества. Так, нельзя создать множество списков или множество множеств.
Множество задается перечислением всех его элементов в фигурных скобках:
s = {1, 2, 3}
При этом для создания пустого множества нужно использовать функцию set(), но не пустые фигурные скобки {}.
Можно передавать этой функцией строку или кортеж:
a = set('qwerty')
print(a)
{'w', 'q', 'r', 'y', 'e', 't'}
Функция set(), как и tuple(), принимает не более одного аргумента.
/*Тут читатель должен поднять брови, сказать «как это нельзя использовать пустые фигурные скобки», написать в интерпретаторе a = {}; b = set(); a==b… И сильно удивиться при виде False. {} действительно можно использовать – для задания пустого словаря, а не множества. Убедиться в этом можно, введя вначале type( {} ), а затем type( set() ). А ещё можно поэкспериментировать, передавая в type() dict, list, tuple, int, set(), set, min, print…*/
Над множествами определено много методов и операций:
| s.add(x) | добавляет элемент х во множество, если он в нём отсутствует |
| s.discard(x) | удаляет из множества элемент х, если он в нём присутствует |
| s.remove(x) | удаляет из множества элемент x. Отличие от discard(): если элемента нет, будет выдано сообщение об ошибке. |
| s.clear() | удаляет из множества все элементы. При печати print(s) машина выведет set() |
| s.difference(t) либо s-t | разность множеств |
| s.difference_update(t) | удаляет из множества s все элементы множества t |
| s.intersection(t) либо s & t | пересечение множеств |
| s.intersection_update(t) | удаляет из множества s элементы, которые не входят в множество t |
| s.issubset(t) либо s <= t | Проверяет, является ли множество s подмножеством множества t |
| s.pop() |
/*Множества – суть надстройка над списками, поэтому к ним применимы все варианты работы со списками. В случае списка s = [1,2,3,4], s.pop() возвращает его последний элемент и удаляет его из самого списка. Поскольку в случае множеств словосочетание «последний элемент множества» не имеет смысла, то и использование .pop() для работы со множествами бессмысленно.*/
Лекция №10----------------------------------------------------------------------------------------------------------- 11.11.2015
Функции
Рассмотрим задачу вычисления площади четырехугольника по заданным длинам сторон и одной диагонали. Составим функцию вычисления площади одного треугольника, а дальше сложим две площади.
import math
def Triangle(a,b,c):
p = (a+b+c) / 2
sq = math.sqrt(p * (p-a) * (p-b) * (p-c))
return sq
a,b,c,d,l = map(float, input().split() )
print('Площадь = ', Triangle(a,b,l) + Triangle(c,d,l))
Структура функции
После ключевого слова def указывается имя функции. Далее в круглых скобках – список формальных параметров, разделенных запятыми. Если функция должна возвращать какое-то значение, то это делается с помощью ключевого слова return <переменная>.
Тело функции может содержать не только операторы присваивания, но и все другие допустимые конструкции.
Напишем программу для определения числа сочетаний C из n по m: 
. Программу напишем без использования модуля math, т.е. без применения стандартной функции factorial.
def factorial(n):
fact = 1
for i in range(1,n+1):
fact *= i
return fact
def combination(n, m):
# результат будет вещественным числом из-за операции деления
return factorial(n) / (factorial(n-m) * factorial(m))
n = int(input('введите n'))
m = int(input('введите n'))
c = combination(n,m)
print(c)
Параметры
При обращении к функциям задаются фактические параметры. При этом, в общем случае, имеется соответствие с формальными параметрами, их порядком и количеством.
Имена фактических и формальных параметров могут быть разными (что часто и происходит). Так, в первом примере функция Triangle принимает параметры a,b,c, а передаём мы a,b,l.
Фактические параметры могут быть разных типов. Пусть функция sum служит для сложения двух чисел:
def sum(a,b):
return a+b
К ней можно обратиться различными способами:
print(sum(3, 5)) # 8
print(sum(2.5, 5.5)) # 8.0
print(sum('3', '5')) # '35'
print(sum([1,2], [3,4])) # [1,2,3,4]
print(sum((1,2), (3,4))) # (1,2,3,4)
/*Кажется, я уже говорил, что питон – язык с динамической типизацией? Здесь она раскрывается во всей своей красе. Функциям питона во многом без разницы, что в них передаётся, до тех пор пока с передаваемым можно делать то, что предполагается в функции. «Если оно выглядит как утка, крякает как утка, и плавает как утка – то будем считать это уткой».*/
/*Важное замечание: sum - встроенная функция, которая может складывать сколь угодно много различных параметров. Здесь мы переопределяем эту функцию, после чего использовать sum(1,2,3,4,5) уже нельзя.*/
При разработке программ можно создавать функции-заглушки, что удобно делать на этапе отладки (и не только).
def f1(a):
pass
a = 1+2
f1(a)
a = a+1
/*Конкретно десь pass будет эквивалентно return None и даже просто return. Однако во многих других случаях, различие может быть кардинальным. pass буквально означает «не делать ничего» и используется там, где синтаксически что-то нужно, но практически ничего быть не должно. Аналог из какого-нибудь C/C++/Java – пустой блок { }. Например, в случае
if something:
pass
в случае выполнения условия ничего не произойдёт, а вот если pass заменить на return, функция немедленно завершится, вместо выполнения оставшейся части.*/
В функции может встречаться несколько операторов return. После выполнения любого из них функция завершает работу и возвращает указанное значение. Если значение не указано (например просто return вместо return sq), то возвращается значение None. При этом в операторе return в качестве результата можно указывать несколько переменных:
def add_subt(a,b):
s = a+b
d = a-b
return (s,d)
summa, raznost = add_subt(3,5)
print(summa, raznost)
/*В данном случае функция, на самом деле, возвращает кортеж, который затем распаковывается в переменные. Если мы напишем c = add_subt(3,5), то print(c) распечатает кортеж (3,5), а не два отдельных числа. Если бы функция возвращала три значения, а мы бы пытались распаковать их в два (через a1,a2 = fun3()), или наоборот (a1,a2,a3 = fun2()), питон бы выругался на несоответствие числа переменных.*/
Ещё один пример:
def mult(a,b):
return a*b
print(mult(3,5))
print(mult('вася',5))
Функция может не иметь оператора return – в этом случае её иногда называют процедурой.
Можно в качестве параметров передавать заполненные кортежи или списки. При этом при обращении нужно перед именем оного ставить символ *:
def add(a,b):
return a+b
l = [1,2]
print(add(*l))
t = (1,2)
print(add(*t))
t1 = (2,)
print(add(1,*t1))
В данном случае на размер кортежей и списков накладывается ограничение: их длина должна совпадать с числом параметров, которые ожидает функция. Если, например, в кортеж добавить еще один элемент, то при запуске возникнет ошибка.