Функции в python

Что такое питон простыми словами

Для того чтобы понять, что такое Python нужно разобраться зачем вообще нужны языки программирования. Они нужны для взаимодействия человека и компьютера. Между собой люди общаются на естественном языке.

Язык программирования Python

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

Программирование при помощи машинных кодов ускоряет программу, но очень трудоемко и требует хорошего знания архитектуры компьютера. Одним из таких низкоуровневых языков является ассемблер. Чаще всего низкоуровневое программирование используется в промышленности для специализированных контроллеров, где нет большого объема памяти.

Python может использоваться для программирования контроллеров в станках ЧПУ и в робототехнике. Популярный во всем мире одноплатный микрокомпьютер Raspberry Pi также программируется на питоне. С помощью «малинки» можно программировать роботов, умные дома, квадрокоптеры и множество других вещей. Pi в названии миникомпьютера обозначает, что программирование происходит на Python.

одноплатный микрокомпьютер Raspberry Pi

На языке высокого уровня нужно уметь программировать при помощи понятий, обозначаемых словами. Чаще всего это английский язык, но есть и примеры кодирования на других языках. Например, программу «Бухгалтерия 1С» можно редактировать и изменять на русском.

Питон поддерживает объектно-ориентированное программирование и является интерпретируемым языком. Это означает, что программа выполняется построчно и для ее выполнения на компьютере должен быть установлен интерпретатор. Самым распространенным и популярным интерпретатором является CPython.

Синтаксис lambda-функции в Python

Мы уже посмотрели, как объявляетcя lambda-функция в Python, но, как и все, что состоит из частей, ее объявление предполагает различные варианты. Так давайте же посмотрим, что мы можем, а что не можем делать с lambda-функцией.

a. Аргументы в Python

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

a,b=1,2
y=lambda a,b:a+b
y()

Traceback (most recent call last):
File “<pyshell#167>”, line 1, in <module>
y()
TypeError: <lambda>() missing 2 required positional arguments: ‘a’ and ‘b’

Здесь отсутствуют значения и a и b

y=lambda a:a+b
y()

Traceback (most recent call last):
File “<pyshell#169>”, line 1, in <module>
y()
TypeError: <lambda>() missing 1 required positional argument: ‘a’

У переменной a все еще отсутствует значение

y=lambda :a+b
y()

3

Наконец здесь, так как нет аргументов с отсутствующим значением, все отлично работает. 

Рекомендуем ознакомиться со статьями Ошибки и Исключения в Python(англ.) и Как исправить ошибки в Python (англ.).

b. Пропускаем аргументы

Указывать аргументы в lambda-функции не обязательно. Она отлично работает и без них.

y=lambda :2+3
y()

5

Во втором примере давайте в качестве выражения используем функцию print()

(lambda :print("Привет"))()

Привет

Вывод напрашивается сам собой, — пропуск аргументов в lambda-функции является вполне приемлемым.

c. Пропускаем выражение

Теперь давайте попробуем запустить нашу функцию без выражения.

y=lambda a,b: 

SyntaxError: invalid syntax

Ясное дело ничего не сработало, да и почему оно должно было сработать, если значение выражение это как раз и есть то, что функция возвращает? Без выражения функция не имеет никакого смысла.

Условные операторы

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

В своей простейшей форме синтаксис условного выражения выглядит следующим образом:

<expr1> if <conditional_expr> else <expr2>

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

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

raining = False
print("Let's go to the", 'beach' if not raining else 'library')

raining = True
print("Let's go to the", 'beach' if not raining else 'library')


age = 12
s = 'minor' if age < 21 else 'adult'
s


'yes' if ('qux' in ) else 'no'

Примечание: условное выражение Python аналогично синтаксису ? : , используемому многими другими языками-C, Perl и Java. На самом деле, оператор ?: обычно называют тернарным оператором в этих языках, что, вероятно, является причиной того, что условное выражение Python иногда называют тернарным оператором Python.

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

Вы можете использовать стандартный оператор с предложением :

if a > b:
    m = a
else:
    m = b

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

m = a if a > b else b

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

В следующем примере оператор + связывается более плотно, чем условное выражение, поэтому сначала вычисляются +x и y + 2, а затем условное выражение. Скобки во втором случае не нужны и результат не меняется:

x = y = 40

z = 1 + x if x > y else y + 2
z


z = (1 + x) if x > y else (y + 2)
z

Если вы хотите, чтобы условное выражение было вычислено первым, вам нужно окружить его группирующими скобками. В следующем примере сначала вычисляется (x, если x > y, иначе y). В результате получается y, который равен 40, поэтому присваивается z 1 + 40 + 2 = 43:

x = y = 40

z = 1 + (x if x > y else y) + 2
z

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

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

В выражении , если иначе :

Если <conditional_expr> правда, <expr1> и <expr2> не вычисляется.
Если <conditional_expr> имеет значение false, то возвращается <expr2> и <expr1> не вычисляется.

Вы можете проверить это, используя термины, которые вызвали бы ошибку:

'foo' if True else 1/0

1/0 if False else 'bar'

В обоих случаях условия 1/0 не оцениваются, поэтому никаких исключений не возникнет.

Условные выражения также могут быть объединены вместе, как своего рода альтернативная структура , как показано здесь:

s = ('foo' if (x == 1) else
     'bar' if (x == 2) else
     'baz' if (x == 3) else
     'qux' if (x == 4) else
     'quux'
)
s

Неясно, имеет ли это какое-либо существенное преимущество перед соответствующим оператором , но это синтаксически правильно для Python.

Примеры функций

Рассмотрим следующие примеры определений функций, с маркерами (только позиционные) и (только ключевые) :

>>> def standard_arg(arg):
...     print(arg)
...
>>> def pos_only_arg(arg, ):
...     print(arg)
...
>>> def kwd_only_arg(*, arg):
...     print(arg)
...
>>> def combined_example(pos_only, , standard, *, kwd_only):
...     print(pos_only, standard, kwd_only)
>>>

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

>>> standard_arg(2)
2
>>> standard_arg(arg=2)
2
>>>

Вторая функция , ограничена использованием только позиционных параметров, поскольку в определении функции есть:

>>> pos_only_arg(1)
1
>>> pos_only_arg(arg=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError pos_only_arg() got an unexpected keyword argument 'arg'
>>>

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

>>> kwd_only_arg(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError kwd_only_arg() takes  positional arguments but 1 was given

>>> kwd_only_arg(arg=3)
3
>>>

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

>>> combined_example(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError combined_example() takes 2 positional arguments but 3 were given

>>> combined_example(1, 2, kwd_only=3)
1 2 3

>>> combined_example(1, standard=2, kwd_only=3)
1 2 3

>>> combined_example(pos_only=1, standard=2, kwd_only=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError combined_example() got an unexpected keyword argument 'pos_only'
>>>

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

def foo(name, **kwds):
    return 'name' in kwds

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

>>> foo(1, **{'name' 2})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError foo() got multiple values for argument 'name'
>>>

Но, используя (только позиционные аргументы), это возможно, так как он допускает в качестве позиционного аргумента и в качестве ключа в аргументах ключевое слово:

def foo(name, , **kwds):
    return 'name' in kwds

foo(1, **{'name' 2})
# выведет
True

Другими словами имена, только, позиционных параметров могут использоваться в ‘**kwds’ без двусмысленности.

В качестве руководства к использованию.

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

def f(pos1, pos2, , pos_or_kwd, *, kwd1, kwd2):

Хорошие практики использования специальных параметров и в определении функции:

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

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

• Для API используйте только позиционное, чтобы предотвратить нарушение API, если имя параметра будет изменено в будущем.

Функции Python 3 — возврат значения

Можно передавать значение аргумента функции в Python. При этом функция также может возвращать значение с помощью инструкции return, которая завершит выполнение функции и передаст значения к месту ее вызова. Используя return без аргументов, функция будет возвращать None.

До сих пор мы использовали print(), а не return. Создадим программу, которая вместо вывода в терминал будет возвращать переменную.

В новом текстовом файле создадим программу, которая будет возводить в квадрат параметр x и возвращать переменную y. Выполняем вызов, чтобы вывести переменную result после запуска функции square() с аргументом 3:

square.py
def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

Запускаем программу, чтобы увидеть результат:

python square.py

Результат
9

В качестве выходных данных получаем число 9, что и является результатом возведения в квадрат числа 3. Рассмотрим действие инструкции return в программе:

square.py
def square(x):
    y = x ** 2
    # return y

result = square(3)
print(result)

Снова запускаем программу:

python square.py

Результат
None

Без return программа не может вернуть значение, поэтому оно равно None.

В следующем примере математической функции в Python заменим print() из программы add_numbers.py на инструкцию return:

add_numbers.py
def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

Вне функции объявляем переменную sums, которая равна результату действия функции для чисел 1, 2 и 3 из примера, приведенного выше. Затем выводим переменную sums. Снова запускаем программу, теперь уже с инструкцией return:

python add_numbers.py

Результат

(3, 4, 5)

На выходе получаем те же числа, что и с использованием инструкции print(). Теперь результат предоставлен в виде кортежа, так как в списке выражений инструкции return имеется запятая.

Функции Python немедленно завершаются, когда встречают инструкцию return, независимо от того, возвращают они значение или нет:

return_loop.py
def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Функция останавливается на x == 5
            return
    print("Эта строка не будет выполняться.")

loop_five()

Инструкция return в цикле for завершает функцию, поэтому строка вне цикла не будет выполняться. При использовании инструкции break был бы завершен только цикл, и выполнялась последняя строка print().

Инструкция return завершает функцию и может возвращать значение в случае применения параметров.

Элементы функционального подохда к программированию

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

def max2(a, b):
    if a > b:
        return a
    return b

И вызвать мы ее
можем так:

print( max2(2, -3) )

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

def max3(a, b, c):
    return max2(a, max2(b, c))

И вызвать так:

print( max3(2, -3, 5) )

Смотрите, здесь
оператор return возвращает
значение, которое возвращает функция max2. Но, прежде чем она будет
выполнена, вызовется другая функция max2, которая определит максимальное
среди чисел b и c. То есть,
прежде чем вызвать первую функцию max2 необходимо вычислить ее
параметры: первый просто берется их x, а второй вычисляется вложенной
функцией max2. Вот так это
работает и вот что из себя представляет элемент функционального подхода к
программированию.

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

print( max3("ab", "cd", "abc") )

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

Синтаксис функций и return

Инструкция def в Python состоит из заголовка и пишется по следующим правилам:

>>>def (аргумент 1, аргумент 2, аргумент N):

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

Также в теле иногда находится return:

• def (аргумент 1, аргумент 2, аргумент N):
• .
• return

Return завершает работу функции и передает вызывающей программе объект-результат. Инструкция не является обязательной. Функция будет работать без return, и завершится, когда поток управления достигнет конца ее тела.

Returning a Value

You can pass a parameter value into a function, and a function can also produce a value.

A function can produce a value with the statement, which will exit a function and optionally pass an expression back to the caller. If you use a statement with no arguments, the function will return .

So far, we have used the statement instead of the statement in our functions. Let’s create a program that instead of printing will return a variable.

In a new text file called , we’ll create a program that squares the parameter and returns the variable . We issue a call to print the variable, which is formed by running the function with passed into it.

square.py

We can run the program and see the output:

The integer is returned as output, which is what we would expect by asking Python to find the square of 3.

To further understand how the statement works, we can comment out the statement in the program:

square.py

Now, let’s run the program again:

Without using the statement here, the program cannot return a value so the value defaults to .

As another example, in the program above, we could swap out the statement for a statement.

add_numbers.py

Outside of the function, we set the variable equal to the result of the function taking in , , and as we did above. Then we called a print of the variable.

Let’s run the program again now that it has the statement:

We receive the same numbers , , and as output that we received previously by using the statement in the function. This time it is delivered as a tuple because the statement’s has at least one comma.

Functions exit immediately when they hit a statement, whether or not they’re returning a value.

return_loop.py

Using the statement within the loop ends the function, so the line that is outside of the loop will not run. If, instead, we had used a , only the loop would have exited at that time, and the last line would run.

The statement exits a function, and may return a value when issued with a parameter.

Вызов функции

Рассмотрим полную версию программы с функцией:

def countFood():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")
 
print("Сколько бананов и ананасов для обезьян?")
countFood()
 
print("Сколько жуков и червей для ежей?")
countFood()
 
print("Сколько рыб и моллюсков для выдр?")
countFood()

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

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

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

print("Сколько бананов и ананасов для обезьян?")
countFood()
 
print("Сколько жуков и червей для ежей?")
countFood()
 
print("Сколько рыб и моллюсков для выдр?")
countFood()
 
def countFood():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")

Результат:

Сколько бананов и ананасов для обезьян?
Traceback (most recent call last):
  File "test.py", line 2, in <module>
    countFood()
NameError: name 'countFood' is not defined

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

Аргументы

Позиционные

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

Значения в позиционных аргументах подставляются согласно позиции имён аргументов:

Именованные

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

При вызове соответствие будет определяться по именам, а не по позициям аргументов.

Необязательные параметры (параметры по умолчанию)

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

Аргументы переменной длины (args, kwargs)

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

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

Функции в питоне могут также принимать и переменное количество именованных аргументов. В этом случае перед названием параметра ставится «»:

Здесь kwargs уже заключает аргументы не в кортеж, а в словарь.

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

• Числовые типы (int, float, complex).
• Строки (str).
• Кортежи (tuple).

В Python изменяемые объекты это:

• Списки (list).
• Множества (set).
• Словари (dict).

Будьте внимательны при передаче изменяемых объектов. Одна из частых проблем новичков.

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

Функциональный стиль в Python

В функциональном программировании вычисления выполняются путем объединения функций, которые принимают аргументы и возвращают конкретное значение (или значения). Эти функции не изменяют свои входные аргументы и не изменяют состояние программы. Они просто предоставляют результат данного вычисления. Такие функции обычно называются чистыми функциями (pure functions).

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

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

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

1. Сопоставление (Mapping) заключается в применении функции преобразования к итерируемому объекту для создания нового объекта. Элементы в новой итерации создаются путем вызова функции преобразования для каждого элемента в исходной итерации.
2. Фильтрация (Filtering) состоит из применения предиката или булевозначной функции (predicate or Boolean-valued function) к итерируемому объекту для создания нового итерируемого объекта. Элементы в новой итерации создаются путем фильтрации любых элементов в исходной итерации, которые заставляют функцию предиката возвращать false.
3. Сокращение (Reducing) состоит из применения функции reduce к итерируемому объекту для получения единственного накопленного значения.

По словам Гвидо ван Россума, на Python в большей степени влияют императивные языки программирования, чем функциональные языки:

Однако еще в 1993 году сообщество Python требовало некоторых функций функционального программирования. Они просили:

• Анонимные функции
• Функцию 
• Функцию  
• Функцию  

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

В этом руководстве мы рассмотрим одну из этих функциональных возможностей — встроенную карту функций map(). Вы также узнаете, как использовать составные части списковых включений (comprehensions) и выражения генератора (generator expressions), чтобы получить ту же функциональность, что и map(), в питоническом и удобочитаемом виде.

Использование vars() без аргументов

Как упоминалось ранее, она будет действовать как метод и вернет словарь локальной таблицы символов.

print(vars())

Выход

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x108508390>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/vijay/home/python_vars_function.py', '__cached__': None, 'Data': <class '__main__.Data'>, 'd': <__main__.Data object at 0x108565048>, 'math': <module 'math' from '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload/math.cpython-36m-darwin.so'>}

Использование для объекта класса

Если является типом класса или экземпляром класса, давайте выясним, что в этом случае делает .

Давайте создадим пример класса и определим некоторые атрибуты в его .

class MyClass:
    def __init__(self, i, j):
        self.a = i
        self.b = j

m = MyClass(10, 20)
print(vars(m))
print(vars(MyClass))

Выход

{'a': 10, 'b': 20}
{'__module__': '__main__', '__init__': <function MyClass.__init__ at 0x000001C24EA129D8>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}

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

Тогда как в случае класса он инкапсулирован в модуле и имеет метод вместе с атрибутом класса.

вызывает методы, такие как , и т. д.

Так что удобнее, если вы можете вызвать эту функцию напрямую, а не вызывать dunder методы. (Хотя разницы как таковой нет)

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

print(vars(str))
print(vars(list))

Это покажет все соответствующие атрибуты и методы экземпляра для обоих классов.

Docstrings

The first string after the function header is called the docstring and is short for documentation string. It is briefly used to explain what a function does.

Although optional, documentation is a good programming practice. Unless you can remember what you had for dinner last week, always document your code.

In the above example, we have a docstring immediately below the function header. We generally use triple quotes so that docstring can extend up to multiple lines. This string is available to us as the attribute of the function.

For example:

Try running the following into the Python shell to see the output.

To learn more about docstrings in Python, visit Python Docstrings.

Сравнение функции с методом

• Функция Python является частью файла сценария Python, в котором она определена, тогда как методы определены внутри определения класса.
• Мы можем вызвать функцию напрямую, если она находится в том же модуле. Если функция определена в другом модуле, мы можем импортировать модуль, а затем вызвать функцию напрямую. Нам нужен класс или объект класса для вызова методов.
• Функция Python может обращаться ко всем глобальным переменным, тогда как методы класса Python могут обращаться к глобальным переменным, а также к атрибутам и функциям класса.
• Тип данных функций Python — это «функция», а тип данных методов Python — «метод».

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

class Data:
    def foo(self):
        print('foo method')


def foo():
    print('foo function')


# calling a function
foo()

# calling a method
d = Data()
d.foo()

# checking data types
print(type(foo))
print(type(d.foo))

Вывод:

foo function
foo method
<class 'function'>
<class 'method'>

Преимущества

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

Ленивые вычисления

Такое название неспроста. В процессе lazy evaluations вычисления происходят лишь тогда, когда это нужно, а не заранее. Такой подход позволяет оперировать с бесконечными объектами. Расчёт происходит не постоянно, и в определенный момент времени вычисленными будут только те элементы, которые нужны прямо сейчас. Если возникнет необходимость в получении других элементов этого объекта, то они тоже будут вычислены и сохранены.

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

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

К примеру, штат из 55 сотрудников Facebook, используя функциональный Erlang, способен поддерживать 2 миллиарда пользователей WhatsApp-а. Данных с каждым днём становится всё больше, поэтому популярность ФП будет только расти, и этот рост уже хорошо прослеживается по числу релевантных вакансий на сайтах с вакансиями.

Библиотеки и фреймворки

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

Такое количество библиотек дает преимущество, и способствует популярности Python. Например, высокоуровневая библиотека Pandas. Назначение Pandas – это обработка и анализ данных. Она используется в таких профессиях как Data Science и продолжает активно развиваться.

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

Python бибиотека Pandas

Одним из самых популярных фреймворков с открытым свободным кодом является Django. С его помощь можно не добавлять разные библиотеки отдельно, а установить большинство стандартных функций одним пакетом. В 2010 году с помощью фреймворка Django был создан Instagram и в 2012 году Facebook купил его за миллиард долларов.

Pyramid является еще одним open-source популярным фреймворком. Он универсальный, и дает возможность работать с большими и малыми приложениями. У него хорошее и понятное руководство или пособие. Pyramid используется в тех случаях, когда не требуется разработки полноценной CMS, а хватает веб приложения. Этот фреймворк позволяет быстро собрать проект.