Цикл с одновременным изменением нескольких параметров

Вычислить таблицу значений

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

 

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