Перегрузка операторов

Функции

Последнее обновление: 11.04.2018

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

def имя_функции ():
    инструкции

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

Например, определение простейшей функции:

def say_hello():
    print("Hello")

Функция называется . Она не имеет параметров и содержит одну единственную инструкцию,
которая выводит на консоль строку «Hello».

Для вызова функции указывается имя функции, после которого в скобках идет передача значений для всех ее параметров. Например:

def say_hello():
    print("Hello")
    
say_hello()
say_hello()
say_hello()

Здесь три раза подряд вызывается функция say_hello. В итоге мы получим следующий консольный вывод:

Hello
Hello
Hello

Теперь определим и используем функцию с параметрами:

def say_hello(name):
    print("Hello,",name)

say_hello("Tom")
say_hello("Bob")
say_hello("Alice")

Функция принимает параметр name, и при вызове функции мы можем передать вместо параметра какой-либо значение:

Hello, Tom
Hello, Bob
Hello, Alice

Значения по умолчанию

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

def say_hello(name="Tom"):
    print("Hello,", name)
	
say_hello()
say_hello("Bob")

Здесь параметр name является необязательным. И если мы не передаем при вызове функции для него значение, то применяется значение по умолчанию, то есть
строка «Tom».

Именованные параметры

При передаче значений функция сопоставляет их с параметрами в том порядке, в котором они передаются. Например, пусть есть следующая функция:

def display_info(name, age):
    print("Name:", name, "\t", "Age:", age)
	
display_info("Tom", 22)

При вызове функции первое значение «Tom» передается первому параметру — параметру name, второе значение — число 22 передается второму параметру — age. И так далее по порядку.
Использование именованных параметров позволяет переопределить порядок передачи:

def display_info(name, age):
    print("Name:", name, "\t", "Age:", age)
	
display_info(age=22, name="Tom")

Именованные параметры предполагают указание имени параметра с присвоением ему значения при вызове функции.

Неопределенное количество параметров

С помощью символа звездочки можно определить неопределенное количество параметров:

def sum(*params):
    result = 0
    for n in params:
        result += n
    return result


sumOfNumbers1 = sum(1, 2, 3, 4, 5)		# 15
sumOfNumbers2 = sum(3, 4, 5, 6)			# 18
print(sumOfNumbers1)
print(sumOfNumbers2)

В данном случае функция sum принимает один параметр — , но звездочка перед названием параметра указывает, что фактически на место этого
параметра мы можем передать неопределенное количество значений или набор значений. В самой функции с помощью цикла for можно пройтись по этому набору и произвести с переданными
значениями различные действия. Например, в данном случае возвращается сумма чисел.

Возвращение результата

Функция может возвращать результат. Для этого в функции используется оператор return, после которого указывается возвращаемое значение:

def exchange(usd_rate, money):
    result = round(money/usd_rate, 2)
    return result

result1 = exchange(60, 30000)
print(result1)
result2 = exchange(56, 30000)
print(result2)
result3 = exchange(65, 30000)
print(result3)

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

В Python функция может возвращать сразу несколько значений:

def create_default_user():
    name = "Tom"
    age = 33
    return name, age


user_name, user_age = create_default_user()
print("Name:", user_name, "\t Age:", user_age)

Здесь функция create_default_user возвращает два значения: name и age. При вызове функции эти значения по порядку присваиваются переменным
user_name и user_age, и мы их можем использовать.

Функция main

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

def main():
    say_hello("Tom")
    usd_rate = 56
    money = 30000
    result = exchange(usd_rate, money)
    print("К выдаче", result, "долларов")


def say_hello(name):
    print("Hello,", name)
    
    
def exchange(usd_rate, money):
    result = round(money/usd_rate, 2)
    return result

# Вызов функции main
main()

НазадВперед

Функции, которые когда-нибудь можно выучить

Следующие встроенные функции Python определённо не бесполезны, но они более специализированы.

Эти функции вам, возможно, будут нужны, но также есть шанс, что вы никогда не прибегнете к ним в своём коде.

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

Основные строковые функции

capitalize()	Преобразует первый символ строки в верхний регистр	str_name.capitalize()
casefold()	Он преобразует любую строку в нижний регистр независимо от ее регистра	str_name.casefold()
center()	Используется для выравнивания строки по центру	str_name.center (длина, символ)
count()	Для подсчета количества раз, когда определенное значение появляется в строке.	str_name.count (значение, начало, конец)
endswith()	Проверяет, заканчивается ли строка указанным значением, затем возвращает True	str_name.endswith (значение, начало, конец)
find()	Используется для определения наличия указанного значения в строке	str_name.find (значение, начало, конец)
index()	Он используется для поиска первого вхождения указанного значения в строке	str_name.index (значение, начало, конец)
isalnum()	Проверяет, все ли символы являются буквенно-цифровыми, затем возвращает True	str_name.isalnum()
isalpha()	Проверяет, все ли символы являются алфавитными (az), затем возвращает True	str_name.isalpha()
isdecimal()	Проверяет, все ли символы являются десятичными (0-9), затем возвращает True	str_name.isdecimal()
isdigit()	Проверяет, все ли символы являются цифрами, затем возвращает True	str_name.isdigit()
islower()	Проверяет, все ли символы в нижнем регистре, затем возвращает True	str_name.islower()
isnumeric()	Проверяет, все ли символы являются числовыми (0-9), затем возвращает True	str_name.isnumeric()
isspace()	Проверяет, все ли символы являются пробелами, затем возвращает True	str_name.isspace()
isupper()	Проверяет, все ли символы в верхнем регистре, затем возвращает True	str_name.isupper()
lower()	Используется для преобразования всех символов в нижний регистр	str_name.lower()
partition()	Используется для разделения строки на кортеж из трех элементов.	str_name.partition (значение)
replace()	Используется для замены указанного слова или фразы другим словом или фразой в строке.	str_name.replace (старое значение, новое значение, количество)
split()	Используется для разделения строки на список	str_name.split (разделитель, maxsplit)
splitlines()	Используется для разделения строки и составления ее списка. Разбивается на разрыв строки.	str_name.splitlines (keeplinebreaks)
startswith()	Проверяет, начинается ли строка с указанного значения, затем возвращает True	str_name.startswith (значение, начало, конец)
strip()	Используется для удаления символов, указанных в аргументе, с обоих концов	str_name.strip (символы)
swapcase()	Используется для замены строки верхнего регистра на нижний регистр или наоборот.	str_name.swapcase()
title()	Преобразует начальную букву каждого слова в верхний регистр	str_name.title()
upper()	Он используется для преобразования всех символов в строке в верхний регистр	str_name.upper()

Передача аргументов функции

Теперь мы готовы узнать о том, как создать функцию, которая может получать доступ к аргументам, а также узнаем, как передать аргументы функции. Создадим простую функцию, которая может суммировать два числа:

Python

def add(a, b):
return a + b

print( add(1, 2) ) # 3

1 2 3 4

defadd(a,b) returna+b print(add(1,2))# 3

Каждая функция выдает определенный результат. Если вы не указываете на выдачу конкретного результата, она, тем не менее, выдаст результат None (ничего). В нашем примере мы указали выдать результат a + b. Как вы видите, мы можем вызвать функцию путем передачи двух значений. Если вы передали недостаточно, или слишком много аргументов для данной функции, вы получите ошибку:

Python

add(1)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: add() takes exactly 2 arguments (1 given)

1 2 3 4 5

add(1) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErroradd()takes exactly2arguments(1given)

Вы также можете вызвать функцию, указав наименование аргументов:

Python

print( add(a = 2, b = 3) ) # 5

total = add(b = 4, a = 5)
print(total) # 9

1 2 3 4

print(add(a=2,b=3))# 5 total=add(b=4,a=5) print(total)# 9

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

Это стандартный путь вызова функции в случае, если вы хотите дальше использовать её результат.

Вы, возможно, подумаете: «А что, собственно, произойдет, если мы укажем аргументы, но они названы неправильно? Это сработает?» Давайте попробуем на примере:

Python

add(c=5, d=2)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: add() got an unexpected keyword argument ‘c’

1 2 3 4 5

add(c=5,d=2) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErroradd()got an unexpected keywordargument’c’

Ошибка. Кто бы мог подумать? Это значит, что мы указали ключевой аргумент, который функция не распознала. Кстати, ключевые аргументы описана ниже.

Логический оператор AND в Python

Вот простой пример логического оператора and.

x = 10
y = 20

if x > 0 and y > 0:
    print('Both x and y are positive numbers')

Вывод: и x, и y – положительные числа.

Перед выполнением логической операции выражения оцениваются. Таким образом, приведенное выше условие if аналогично приведенному ниже:

if (x > 0) and (y > 0):
    print('Both x and y are positive numbers')

В Python каждая переменная или объект имеет логическое значение.

if x and y:
    print('Both x and y have boolean value as True')

Вывод: И x, и y имеют логическое значение True, потому что функция len() ‘x’ и ‘y’ вернет 2, т.е.> 0.

Давайте подтвердим приведенное выше утверждение, определив настраиваемый объект. Python использует функцию __bool __() для получения логического значения объекта.

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __bool__(self):
        print('Data bool method called')
        return True if self.id > 0 else False


d1 = Data(-10)
d2 = Data(10)
if d1 and d2:
    print('Both d1 and d2 ids are positive')
else:
    print('Both d1 and d2 ids are not positive')

Вывод:

Data bool method called
At least one of d1 and d2 ids is negative

Обратите внимание, что функция __bool __() вызывается только один раз, что подтверждается выводом оператора печати. На диаграмме ниже изображена логическая блок-схема и схема работы

На диаграмме ниже изображена логическая блок-схема и схема работы.

Определение функции с документацией

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

Выход:

2019-02-1908:26:49.538434

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

• аргументы функции
• вычисления функций
• возвращаемое значение / с

Объем

Не все объекты (включая функции), которые мы определили, доступны везде в нашем коде Python. Объем программы представляетгде имя переменной или имя функции могут быть доступны, Python имеет 3 типа областей действия:местный,Глобальныйа такжевстроенныйобъем.

Разные

ascii()	Он возвращает строку, содержащую печатную форму объекта, и игнорирует значения, отличные от ASCII, в строке	ascii(объект)
bool()	Он возвращает логическое значение, то есть True или False для объекта.	bool(значение)
bytearray()	Он возвращает объект, содержащий массив байтов, предоставленных через ввод	bytearray(источник, кодировка, ошибки)
bytes()	Он возвращает объект байтов, который не может быть изменен и представляет собой последовательность целых чисел в диапазоне от 0 до 255.	bytes(источник, кодировка, ошибки)
enumerate()	Он используется для добавления счетчика к итерируемому объекту, а затем возвращает его значение	enumerate(итерация, начало = 0)
float()	Возвращает число с плавающей запятой из заданного аргумента.	float (аргумент)
hash()	Возвращает хеш-значение объекта, если применимо.	hash(объект)
id()	Он возвращает конкретную идентификацию объекта, которая является уникальным целым числом.	id(объект)
int()	Он возвращает целочисленный объект из заданного ввода, и база возвращаемого объекта всегда будет 10	int (x = 0, основание = 10)
len()	Возвращает длину последовательности, т.е. количество элементов в объекте.	len (последовательность)
map()	Он используется для применения заданной функции к каждому элементу итерации, который может быть кортежем, списком и т. Д., А также возвращает список, содержащий результирующие значения.	map(функция, итерация, …)
ord()	Он принимает строковый аргумент из одного символа Unicode и возвращает его точку уважения Unicode	ord(символ)
print()	Он печатает предоставленный объект на любом устройстве вывода	print (объект (ы), separator = separator, end = end, file = file, flush = flush)
slice()	Он создает объект, который представляет собой набор индексов, заданных его диапазоном (начало, остановка, шаг).	slice (стоп) срез (начало, остановка, шаг)
type()	Возвращает тип объекта	type(объект) тип (имя, базы, dict)

Лямбда-функции Python

Другим способом определения функций в Python является использование ключевого слова . Этот метод определения функций в основном используется для создания ; функций, у которых нет имени, отсюда и слово . По синтаксису могут иметь несколько аргументов, но ограничены только одним . Давайте переопределим нашу функцию с помощью ключевого слова :

lambda value1, value2: value1 + value2

Несколько вещей, которые следует отметить:

• В нашем определении функции нет оператора . Выражение после столбца ( ) по умолчанию является возвращаемым значением.
• Нет никакого способа повторно использовать нашу функцию, так как на нее нельзя ссылаться по имени.

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

#editor
list_of_numbers = 
halved_list = list(map(lambda value: value/2 , list_of_numbers)) 

print(halved_list)

#console
halved list: 

Чтобы иметь возможность повторно использовать лямбда-функцию, мы можем назначить ее переменной:

#editor
sum = lambda value1, value2: value1 + value2
result = sum(7, 9)

print(result)

#console
16

Функция внутри функции в Python

Функции в Python мы можем создавать, вызывать и возвращать из других функций. Кстати, на этом основана идея замыкания (closures) в Python.

Давайте создадим функцию, умножающую 2 числа:

def mul(a):
def helper(b):
return a * b
return helper

В этой функции в Python реализованы два важных свойства:
1) внутри функции mul() мы создаём ещё одну функцию helper();
2) функция mul() возвращает нам функцию helper() в качестве результата работы.

Вызов этой функции в Python:

>>>mul(4)(2)
8

Особенность заключается в том, что мы можем создавать на базе функции mul() собственные кастомизированные функции. Давайте создадим функцию в Python, умножающую на 3:

>>>three_mul = mul(3)
>>>three_mul(5)
15

В результате была построена функция three_mul(), умножающая на 3 любое переданное ей число.

Практическая работа

В программировании можно из одной функции вызывать другую. Для иллюстрации этой возможности напишите программу по следующему описанию.

Основная ветка программы, не считая заголовков функций, состоит из одной строки кода. Это вызов функции . В ней запрашивается на ввод целое число. Если оно положительное, то вызывается функция , тело которой содержит команду вывода на экран слова «Положительное». Если число отрицательное, то вызывается функция , ее тело содержит выражение вывода на экран слова «Отрицательное».

Понятно, что вызов должен следовать после определения функций. Однако имеет ли значение порядок определения самих функций? То есть должны ли определения и предшествовать или могут следовать после него? Проверьте вашу гипотезу, поменяв объявления функций местами. Попробуйте объяснить результат.

Аргументы

Python допускает три типа параметров в определении функции.

1. Формальные аргументы: те, которые мы видели в примерах до сих пор.
2. Переменное количество аргументов без ключевых слов: например, def add(*args)
3. Переменное количество аргументов ключевых слов или именованных аргументов: например, def add(**kwargs)

Некоторые важные моменты относительно переменных аргументов в Python:

• Порядок аргументов должен быть формальным, * args и ** kwargs.
• Не обязательно использовать имена параметров переменных как args и kwargs. Однако лучше всего использовать их для лучшей читаемости кода.
• Тип args — кортеж. Таким образом, мы можем передать кортеж для отображения с переменной * args.
• Тип кваргов — дикт. Таким образом, мы можем передать словарь для сопоставления с переменной ** kwargs.

Вот простой пример.

def add(x, y, *args, **kwargs):
    sum = x + y
    for a in args:
        sum += a

    for k, v in kwargs.items():
        sum += v
    return sum


total = add(1, 2, *(3, 4), **{"k1": 5, "k2": 6})
print(total)  # 21

Проверяет, что хотя бы один элемент в последовательности True.

Описание:

Функция возвращает , если какой-либо (любой) элемент в итерируемом объекте является истинным , в противном случае возвращает значение .

Если последовательность пуста, то функция возвращает .

Функция применяется для проверки истинности ЛЮБОГО из значений в итерируемом объекте и эквивалентна следующему коду:

def any(iterable):
    for element in iterable
        if element
            return True
    return False

Так же смотрите встроенную функцию .

В основном функция применяется в сочетании с оператором ветвления программы . Работу функции можно сравнить с оператором в Python, только работает с последовательностями:

>>> False or True or False
# True
>>> any()
# True

Но между и в Python есть два основных различия:

• Синтаксис.
• Возвращаемое значение.

Функция всегда возвращает или .

>>> any()
# True
>>> any()
# False

Оператор возвращает ПЕРВОЕ истинное значение, а если все значения , то ПОСЛЕДНЕЕ ложное значение.

>>>  or 2 or 1 or  or 
# 2
>>>  or  or ''
# ''


>>> bool( or 2 or 1 or  or )
# True
>>> bool( or  or '')
# False

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

num = 1, 2.0, 3.1, 4, 5, 6, 7.9
# использование встроенных функций 
# на примере 'isdigit()'
>>> str(x).isdigit() for x in num
# 

# использование операции сравнения
>>> x > 4 for x in num
# 

# использование оператора вхождения `in`
>>> '.' in str(x) for x in num
# 

# использование оператора идентичности `in`
>>> type(x) is int for x in num
# 

# использование функции map()
>>> list(map(lambda x x > 1, num))
False, True, True, True, True, True, True

Примеры проводимых проверок функцией .

Допустим у нас есть строка например с адресом и нам необходимо узнать, содержит ли адрес номер дома. Для этого разделим строку с адресом справа на лево методом по разделителю один раз.

>>> addr1 = '142100, г. Москва, ул. Свердлова, 15'
>>> addr2 = '142100, г. Москва, ул. Свердлова'
>>> any(map(str.isdigit, addr1.rsplit(' ',1)))
# True
>>> any(map(str.isdigit, addr2.rsplit(' ',1)))
# False

Второй пример с числовой последовательностью. Необходимо узнать, есть ли в последовательности числа больше определенного значения.

>>> num1 = range(, 20, 2)
>>> num2 = range(, 15, 2)
>>> any()
# True
>>> any()
# False

Так же можно проверять строку на наличие, каких то определенных символов.

>>> simbols = '(', ')', '\''
>>> line1 = "функция 'any()' всегда возвращает 'False' или 'True'"
>>> line2 = "функция any всегда возвращает значение bool"
>>> any()
# True
>>> any()
# False

Рекурсивная функция Python

Когда функция вызывает сама себя, она называется рекурсивной функцией. В программировании этот сценарий называется рекурсией.

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

def fibonacci_numbers_at_index(count):
    if count <= 1:
        return count
    else:
        return fibonacci_numbers_at_index(count - 1) + fibonacci_numbers_at_index(count - 2)


count = 5
i = 1
while i <= count:
    print(fibonacci_numbers_at_index(i))
    i += 1

Полезно знать о рекурсии, но в большинстве случаев при программировании это не нужно. То же самое можно сделать с помощью цикла for или while.

Примеры создания и изменения классов «на лету» при помощи type():

Например, следующие два определения создают идентичные объекты.

>>> class Foo(object):
...       bar = True
>>> Foo = type('Foo', (), {'bar'True})

Класс , созданный через метакласс можно использовать как обычный класс:

>>> Foo
# <class '__main__.Foo'>
>>> f = Foo()
>>> f.bar
# True

# можно наследоваться от него
>>>   class FooChild(Foo): pass
...
>>> FooChild
# <class '__main__.FooChild'>
>>> FooChild.bar # bar унаследован от Foo
# True

Добавим методы в класс . Для этого определим функцию и добавим ее как атрибут.

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar' echo_bar})
>>> hasattr(Foo, 'echo_bar')
# False
>>> hasattr(FooChild, 'echo_bar')
# True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
# True

# после динамического создания класса добавим еще один метод 
>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
# True

Обязательные строковые функции

format()	Он используется для создания форматированной строки из строки шаблона и предоставленных значений.
split()	Функция string split() используется для разделения строки на список строк на основе разделителя.
join()	Эта функция возвращает новую строку, которая является конкатенацией строк в итерируемом объекте со строковым объектом в качестве разделителя.
strip()	Используется для удаления пробелов в строковом объекте.
format_map()	Функция string format_map() возвращает отформатированную версию строки с использованием подстановок из предоставленного сопоставления.
upper()	Мы можем преобразовать строку в верхний регистр в Python с помощью функции str.upper().
lower()	Эта функция создает новую строку в нижнем регистре.
replace()	Функция string replace() используется для создания новой строки путем замены некоторых частей другой строки.
find()	Метод String find() используется для поиска индекса подстроки в строке.
translate()	Функция String translate() возвращает новую строку, в которой каждый символ в строке заменяется с использованием данной таблицы перевода.

Функция как объект в Python

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

>>> # исходный список
>>> a = 1, 2, 3, 4, 5
>>> # функция, которая возводит в квадрат переданное ей число 
>>> sq = lambda x x**2
>>> # проверка работы функции в Python
>>> print(sq(5))
25

>>> # получение списка квадратов
>>> b = list(map(sq, a))
>>> print(b)
1, 4, 9, 16, 25

В нашем примере мы передали функции map в виде первого аргумента функцию sq. Последняя будет по очереди применяться ко всем элементам нашего списка a.

Кроме того, в Python функция является специальным объектом, имеющим метод __call__(). Представьте, что мы создали следующий класс:

class DemoCall():
def __call__(self):
return "Hello!"

Объект такого класса в Python мы сможем вызывать как функцию:

>>> hello = DemoCall()
>>> hello()
'Hello!'

Синтаксис

Простой пример: Вы торгуете мёдом, и после каждой продажи вам нужно печатать чек. В нём должно быть указано: название фирмы, дата продажи, список наименований проданных товаров, их количество, цены, общая сумма, а также сакраментальная фраза «Спасибо за покупку!».

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

А теперь представьте, что произойдёт, когда вы раскрутитесь, и покупатели станут приходить один за другим. В таком случае, чеки надо будет выдавать очень быстро. Но что делать, если вдруг нагрянет ваш любимый клиент и купит 10 сортов мёда в разных количествах? Далеко не все в очереди согласятся ждать, пока вы посчитаете общую сумму и внесёте её в чек.

Хорошо, что данный процесс можно легко оптимизировать с использованием функций.

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

Теперь этот список передадим в функцию как аргумент, и самостоятельно считать больше не придётся.

Да, код стал более массивным. Однако теперь для печати чека вам не придётся самостоятельно вычислять итог. Достаточно лишь изменить количество и цену товаров в списке. Существенная экономия времени! Слава функциям!

Область действия переменной

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

#editor
def example_function():
  word = "inevitable"
  return word

print(word)

#console
NameError: name 'word' is not defined

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

Чтобы сделать нашу переменную доступной для каждого оператора и выражения в нашем коде, мы должны объявить ее вне определения функции. Таким образом, он глобально ограничен :

#editor
word = "inevitable"
def example_function():
  return word

print(word)

#console
inevitable

Дополнительные строковые функции

encode()	Функция string encode() используется для кодирования строки с использованием предоставленной кодировки.
count()	Функция String count() возвращает количество вхождений подстроки в заданной строке.
startwith()	Функция startwith() возвращает True, если строка начинается с заданного префикса, в противном случае возвращает False.
stringndswith()	Функция stringndswith() возвращает True, если строка заканчивается заданным суффиксом, в противном случае возвращает False.
capitalize()	Функция String capitalize() возвращает версию строки с заглавной буквы.
center()	Функция string center() возвращает центрированную строку указанного размера.
casefold()	Функция casefold() строки в Python возвращает копию строки в развернутом виде. Эта функция используется для сравнения строк без учета регистра.
expandtabs()	Функция Python string expandtabs() возвращает новую строку, в которой символы табуляции (\t) заменены одним или несколькими пробелами.
index()	Функция String index() возвращает наименьший индекс, в котором находится указанная подстрока.
__contains__()	Класс String имеет функцию __contains __(), которую мы можем использовать, чтобы проверить, содержит ли он другую строку или нет. Мы также можем использовать оператор «in» для выполнения этой проверки.

** kwargs

Эти аргументы называютсяименованные аргументы переменной длины,

Выход:

<class 'dict'>{'age': 24, 'position': 'data analyst'}<class 'dict'>{'name': 'Jake', 'email': '', 'position': 'machine learning engineer'}

Мы видим, что синтаксис ** kwargsпередал все аргументык функциикак словарь называется, Таким образом, мы можем делать все, что мы можем делать с типом данных словаря.

Выход:

age 24position data analystname Jakeemail position machine learning engineer

На самом деле, имя переменной может быть любым, нам просто нужно вставитьодна звездочка*или две звездочки **перед этим.

Выход:

10.0age 24position data analyst

Функция reduce

Наконец, когда требуется обработать список значений таким образом, чтобы свести процесс к единственному результату, для этого используется функция reduce. Функция имеется в модуле functools стандартной библиотеки, но здесь она будет приведена целиком, чтобы показать, как она работает:

Вот общий формат функции :

В данном формате функция – это ссылка на редуцирующую функцию; ею может быть стандартная функция либо лямбда-функция, последовательность – это итерируемая последовательность, т.е. список, кортеж, диапазон или строковые данные, и инициализатор – это параметрическая переменная, которая получает начальное значение для накопителя. Начальным значением может быть значение любого примитивного типа данных либо мутабельный объект – список, кортеж и т.д. Начальное значение инициирует накапливающую переменную, которая прежде чем она будет возвращена, будет обновляться редуцирующей функцией по каждому элементу в списке.

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

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

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

В чем преимущества функций более высокого порядка?

• Они нередко состоят из одной строки.

• Все важные компоненты итерации – объект-последовательность, операция и возвращаемое значение – находятся в одном месте.

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

• Они представляются собой элементарные операции. Глядя на цикл , приходится построчно отслеживать его логику. При этом в качестве опоры для создания своего понимания программного кода приходится отталкиваться от нескольких структурных закономерностей. Напротив, функции более высокого порядка одновременно являются строительными блоками, которые могут быть интегрированы в сложные алгоритмы, и элементами, которые читатель кода может мгновенно понять и резюмировать в своем уме. «Этот код преобразовывает каждый элемент в новую последовательность. Этот отбрасывает некоторые элементы. А этот объединяет оставшиеся элементы в единый результат».

• Они имеют большое количество похожих функций, которые предоставляют возможности, которые служат дополнением к их основному поведению. Например, , или собственные их версии.

Приведем еще пару полезных функций.