Как составить программу вычисления функции в питоне

Введение

Определение

Вот пример простой функции:

def compute_surface(radius):
    from math import pi
    return pi * radius * radius

Для определения функции нужно всего лишь написать ключевое слово def перед ее именем, а после — поставить двоеточие. Следом идет блок инструкций.

Последняя строка в блоке инструкций может начинаться с return, если нужно вернуть какое-то значение. Если инструкции return нет, тогда по умолчанию функция будет возвращать объект None. Как в этом примере:

i = 0
def increment():
    global i
    i += 1

Функция инкрементирует глобальную переменную i и возвращает None (по умолчанию).

Вызовы

Для вызова функции, которая возвращает переменную, нужно ввести:

surface = compute_surface(1.)

Для вызова функции, которая ничего не возвращает:

increment()

Еще

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

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

Функции могут быть вложенными:

def func1(a, b):

    def inner_func(x):
        return x*x*x

    return inner_func(a) + inner_func(b)

Функции — это объекты, поэтому их можно присваивать переменным.

Инструкция return

Возврат простого значения

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

Возврат нескольких значений

Пока что функция возвращала только одно значение или не возвращала ничего (объект None). А как насчет нескольких значений? Этого можно добиться с помощью массива. Технически, это все еще один объект. Например:

def stats(data):
    """данные должны быть списком"""
    _sum = sum(data) # обратите внимание на подчеркивание, чтобы избежать переименования встроенной функции sum
    mean = _sum / float(len(data)) # обратите внимание на использование функции float, чтобы избежать деления на целое число
    variance = sum([(x-mean)**2/len(data) for x in data])
    return mean,variance   # возвращаем x,y — кортеж!

m, v = stats([1, 2, 1])

Аргументы и параметры

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

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

def sum(x, y):
    return x + y

x и y — это параметры, а в этой:

sum(1, 2)

1 и 2 — аргументы.

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

def compute_surface(radius, pi=3.14159):
    return pi * radius * radius

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

Выходит, что в следующем примере допущена ошибка:

def compute_surface(radius=1, pi):
    return pi * radius * radius

Для вызовов это работает похожим образом. Сначала нужно указывать все позиционные аргументы, а только потом необязательные:

S = compute_surface(10, pi=3.14)

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

S = compute_surface(radius=10, pi=3.14)

А этот вызов некорректен:

S = compute_surface(pi=3.14, 10)

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

def compute_surface2(radius=1, pi=3.14159):
    return pi * radius * radius
S = compute_surface2(radius=1, pi=3.14)
S = compute_surface2(pi=3.14, radius=10.)
S = compute_surface2(radius=10.)

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

S = compute_surface2(10., 3.14)
S = compute_surface2(10.)

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

def f(a=1,b=2, c=3):
    return a + b + c

Второй аргумент можно пропустить:

f(1,,3)

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

params = {'a':10, 'b':20}
S = f(**params)

Значение по умолчанию оценивается и сохраняется только один раз при определении функции (не при вызове). Следовательно, если значение по умолчанию — это изменяемый объект, например, список или словарь, он будет меняться каждый раз при вызове функции. Чтобы избежать такого поведения, инициализацию нужно проводить внутри функции или использовать неизменяемый объект:

def inplace(x, mutable=[]):
   mutable.append(x)
   return mutable
res = inplace(1)
res = inplace(2)
print(inplace(3))

[1, 2, 3]

def inplace(x, lst=None):
   if lst is None: lst=[]
   lst.append()
   return lst

Еще один пример изменяемого объекта, значение которого поменялось при вызове:

def change_list(seq):
    seq[0] = 100
original = [0, 1, 2]
change_list(original)
original

[100, 1, 2]

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

original = [0, 1, 2]
change_list(original[:])
original

[0, 1, 2]

Указание произвольного количества аргументов

Позиционные аргументы

Иногда количество позиционных аргументов может быть переменным. Примерами таких функций могут быть max() и min(). Синтаксис для определения таких функций следующий:

def func(pos_params, *args):
    block statememt

При вызове функции нужно вводить команду следующим образом:

func(pos_params, arg1, arg2, ...)

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

Вот так:

def add_mean(x, *data):
    return x + sum(data)/float(len(data))

add_mean(10,0,1,2,-1,0,-1,1,2)

10.5

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

Произвольное количество аргументов-ключевых слов

Как и в случае с позиционными аргументами можно определять произвольное количество аргументов-ключевых слов следующим образом (в сочетании с произвольным числом необязательных аргументов из прошлого раздела):

def func(pos_params, *args, **kwargs):
    block statememt

При вызове функции нужно писать так:

func(pos_params, kw1=arg1, kw2=arg2, ...)

Python обрабатывает аргументы-ключевые слова следующим образом: подставляет обычные позиционные аргументы слева направо, а затем помещает другие позиционные аргументы в кортеж (*args), который можно использовать в функции (см. предыдущий раздел). В конце концов, он добавляет все лишние аргументы в словарь (**kwargs), который сможет использовать функция.

Есть функция:

def print_mean_sequences(**kwargs):
    def mean(data):
        return sum(data)/float(len(data))
    for k, v in kwargs.items():
        print k, mean(v)

print_mean_sequences(x=[1,2,3], y=[3,3,0])

y 2.0
x 2.0

Важно, что пользователь также может использовать словарь, но перед ним нужно ставить две звездочки (**):

print_mean_sequences(**{'x':[1,2,3], 'y':[3,3,0]})

y 2.0
x 2.0

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

Документирование функции

Определим функцию:

def sum(s,y): return x + y

Если изучить ее, обнаружатся два скрытых метода (которые начинаются с двух знаков нижнего подчеркивания), среди которых есть __doc__. Он нужен для настройки документации функции. Документация в Python называется docstring и может быть объединена с функцией следующим образом:

def sum(x, y):
    """Первая срока - заголовок

    Затем следует необязательная пустая строка и текст 
    документации.
    """
    return x+y

Команда docstring должна быть первой инструкцией после объявления функции. Ее потом можно будет извлекать или дополнять:

print(sum.__doc__)
sum.__doc__ += "some additional text"

Методы, функции и атрибуты, связанные с объектами функции

Если поискать доступные для функции атрибуты, то в списке окажутся следующие методы (в Python все является объектом — даже функция):

sum.func_closure   sum.func_defaults  sum.func_doc       sum.func_name
sum.func_code      sum.func_dict      sum.func_globals

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

>>> sum.__name__
"sum"
>>> sum.__module
"__main__"

Есть и другие. Вот те, которые не обсуждались:

sum.__call__          sum.__delattr__       sum.__getattribute__     sum.__setattr__
sum.__class__         sum.__dict__          sum.__globals__       sum.__new__           sum.__sizeof__
sum.__closure__       sum.__hash__          sum.__reduce__        sum.__str__
sum.__code__          sum.__format__        sum.__init__          sum.__reduce_ex__     sum.__subclasshook__
sum.__defaults__      sum.__get__           sum.__repr__

Рекурсивные функции

Рекурсия — это не особенность Python. Это общепринятая и часто используемая техника в Computer Science, когда функция вызывает сама себя. Самый известный пример — вычисление факториала n! = n * n — 1 * n -2 * … 2 *1. Зная, что 0! = 1, факториал можно записать следующим образом:

def factorial(n):
    if n != 0:
        return n * factorial(n-1)
    else:
        return 1

Другой распространенный пример — определение последовательности Фибоначчи:

f(0) = 1
f(1) = 1
f(n) = f(n-1) + f(n-2)

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

def fibbonacci(n):
    if n >= 2:
        else:
    return 1

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

def factorial(n):
    assert n > 0
    if n != 0:
        return n * factorial(n-1)
    else:
        return 1

Важно!
Рекурсия позволяет писать простые и элегантные функции, но это не гарантирует эффективность и высокую скорость исполнения.

Если рекурсия содержит баги (например, длится бесконечно), функции может не хватить памяти. Задать максимальное значение рекурсий можно с помощью модуля sys.

Глобальная переменная

Вот уже знакомый пример с глобальной переменной:

i = 0
def increment():
    global i
    i += 1

Здесь функция увеличивает на 1 значение глобальной переменной i. Это способ изменять глобальную переменную, определенную вне функции. Без него функция не будет знать, что такое переменная i. Ключевое слово global можно вводить в любом месте, но переменную разрешается использовать только после ее объявления.

За редкими исключениями глобальные переменные лучше вообще не использовать.

Присвоение функции переменной

С существующей функцией func синтаксис максимально простой:

variable = func

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

Менять название переменной также разрешается:

def func(x): return x
a1 = func
a1(10)

10

a2 = a1
a2()

10

В этом примере a1, a2 и func имеют один и тот же id. Они ссылаются на один объект.

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

def sq(x): return x*x

Позже ее можно переименовать, используя более осмысленное имя. Первый вариант — просто сменить имя. Проблема в том, что если в другом месте кода используется sq, то этот участок не будет работать. Лучше просто добавить следующее выражение:

square = sq

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

dir = 3

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

del dir
dir()

Анонимная функция: лямбда

Лямбда-функция — это короткая однострочная функция, которой даже не нужно имя давать. Такие выражения содержат лишь одну инструкцию, поэтому, например, if, for и while использовать нельзя. Их также можно присваивать переменным:

product = lambda x,y: x*y

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

С помощью type() можно проверить тип:

>>> type(product)
function

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

power = lambda x=1, y=2: x**y
square = power
square(5.)

25

power = lambda x,y,pow=2: x**pow + y
[power(x,2, 3) for x in [0,1,2]]

[2, 3, 10]

Изменяемые аргументы по умолчанию

>>> def foo(x=[]):
...     x.append(1)
...     print x
...
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

Вместо этого нужно использовать значение «не указано» и заменить на изменяемый объект по умолчанию:

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]

Назад в начало

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

Функция позволяет использо­вать в про­грамме один и тот же фрагмент кода нес­колько раз.

Oбъявление функции в Python выглядит так:

def function_name(argument1, argument2, …):

    # код функции

# def – DEclare Function – “объявить функцию”

# function_name – имя функции

# (argument1, argument2, …) – список аргументов, поступающих на вход функции при ее вызове

# тело функции – это весь код, который идет после двоеточия

# Вывод


>> Hello, Max

>> Hello, Ivan

>> Hello, Alex

>> Hello, Kate

Оператор return возвращает значение из функции.

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

>> s1 = 12

>> s2 = 208

>> s3 = 4

>> m1 = 20

>> m2 = 10800

>> m3 = 3

Для параметров функции можно указывать значения по умолчанию. Это дает возможность вызывать функцию с меньшим числом параметров.

>> Hello, world

>> Hello, Ivan

Примеры

1. Квадрат

# Написать функцию square(), вычисляющую квадрат числа.


def square(number):

    return number * number # Возвращаем результат работы функции обратно в программу


a = square(2)

print(a)

>> 4

2. Периметр

>> 14

3. Четное число

>> True

>> False

4. Сумма списка

>> 6

>> Сумма списка [1, 2, 4, 8, 16] равна 31

5. Фибоначчи

>> 1

>> 2

>> 3

>> 5

>> 55

6. Факториал

>> 2

>> 6

>> 24

>> 120

Решение задач

1. Площадь круга

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

# Не забудьте написать функцию circle…


print(circle(4))

print(circle(1))

# Вывод:

>> 50.24

>> 3.14

2. На три

Напишите функцию, которая возвращает True, если число делится на 3, и False, если – нет.

# Не забудьте написать функцию three…


print(three(4))

print(three(3))

# Вывод:

>> False

>> True

3. Максимум в списке

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

# Напишите функцию maxList…

mylist = [1, 3, 2]

print(maxList(mylist))

# Вывод:

>> 3

4. Сколько четных

Напишите функцию, которая возвращает количество четных элементов в списке.

# Напишите функцию evenCounter…

mylist = [1, 10, 2, 4, 6]

evens = evenCounter(mylist)

print(even)

# Вывод:

>> 4

5. Уникальные

Напишите функцию, которая возвращает список с уникальными (неповторяющихся) элементам.

# Напишите функцию unique…

mylist = [1, 1, 2, 1, 3, 2, 3]

print(unique(mylist))

# Вывод:

>> [1, 2, 3]

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

Функции в Python – это организованный блок многократно используемого кода, который можно вызывать при необходимости.

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

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

Python предоставляет нам различные встроенные функции, такие как range() или print(). Пользователь также может создавать свои функции, которые можно назвать пользовательскими функциями.

В основном есть два типа функций:

• Функции, определяемые пользователем. Определяются пользователем для выполнения конкретной задачи.
• Встроенные функции. Это те функции, которые предварительно определены в Python.

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

Преимущество функций в Python

У функций Python есть следующие преимущества:

• Используя функции, мы можем избежать повторной перезаписи одной и той же логики / кода снова и снова в программе.
• Мы можем вызывать функции Python несколько раз и в любом месте программы.
• Мы можем легко отслеживать большую программу Python, если она разделена на несколько функций.
• Возможность повторного использования – главное достижение.
• Однако вызов функции всегда является накладным.

Создание

Python предоставляет ключевое слово def для определения функции. Синтаксис функции определения приведен ниже.

Синтаксис:

def my_function(parameters):
      function_block
return expression

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

• Ключевое слово def вместе с именем функции используется для определения функции.
• Правило идентификатора должно следовать за именем функции.
• Функция принимает параметр(аргумент), и они могут быть необязательными.
• Функциональный блок начинается с двоеточия(:), и операторы блока должны иметь такой же отступ.
• Оператор return используется для возврата значения. Функция может иметь только один возврат.

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

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

Рассмотрим простой пример, который выводит сообщение «Hello World».

#function definition
def hello_world():  
    print("hello world")  
# function calling
hello_world()    

Выход:
hello world


Оператор возврата return

Оператор return используется в конце функции и возвращает результат функции. Он завершает выполнение функции и передает результат туда, где функция вызывается. Оператор return не может использоваться вне функции.

Синтаксис:

return [expression_list]

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

Рассмотрим следующие примеры:

Пример 1.

# Defining function
def sum():
    a = 10
    b = 20
    c = a+b
    return c
# calling sum() function in print statement
print("The sum is:",sum())

Выход:
The sum is: 30

В приведенном выше коде мы определили функцию с именем sum, и у нее есть оператор c = a + b, который вычисляет заданные значения, а результат возвращается оператором return вызывающей функции.

Пример 2. Создание функции без оператора возврата

# Defining function
def sum():
    a = 10
    b = 20
    c = a+b
# calling sum() function in print statement
print(sum())

Выход:

None

В приведенном выше коде мы определили ту же функцию без оператора return, так как мы видим, что функция sum() вернула объект None вызывающей функции.

Аргументы в функции

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

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

Пример 1.

#defining the function  
def func(name):  
    print("Hi ",name) 
#calling the function   
func("Devansh")   

Выход:

Hi Devansh

Пример 2.

#Python function to calculate the sum of two variables   
#defining the function  
def sum(a,b):  
    return a+b;  
  
#taking values from the user  
a = int(input("Enter a: "))  
b = int(input("Enter b: "))  
  
#printing the sum of a and b  
print("Sum = ",sum(a,b))  

Выход:

Enter a: 10
Enter b: 20
Sum =  30

Вызов по ссылке в Python

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

Пример 1. Передача неизменяемого объекта(списка)

#defining the function  
def change_list(list1):  
    list1.append(20) 
    list1.append(30)  
    print("list inside function = ",list1)  
  
#defining the list  
list1 = [10,30,40,50]  
  
#calling the function   
change_list(list1)
print("list outside function = ",list1)

Выход:
list inside function = [10, 30, 40, 50, 20, 30]
list outside function = [10, 30, 40, 50, 20, 30]

Пример 2. Передача изменяемого объекта(строки)

#defining the function  
def change_string(str):  
    str = str + " Hows you "
    print("печать строки внутри функции :",str) string1 = "Hi I am there" #calling the function change_string(string1) print("печать строки вне функции :",string1)

Выход:
печать строки внутри функции: Hi I am there Hows you
печать строки вне функции: Hi I am there.


Типы аргументов

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

1. Обязательные аргументы.
2. Аргументы ключевого слова.
3. По умолчанию.
4. Переменной длины.

Обязательные

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

Рассмотрим следующие примеры.

Пример 1.

def func(name):  
    message = "Hi "+name
    return message
name = input("Enter the name:")  
print(func(name))  

Выход:
Введите имя: Джон
привет, Джон

Пример 2.

#the function simple_interest accepts three arguments and returns the simple interest accordingly  
def simple_interest(p,t,r):  
    return(p*t*r)/100  
p = float(input("Enter the principle amount? "))  
r = float(input("Enter the rate of interest? "))  
t = float(input("Enter the time in years? "))  
print("Simple Interest: ",simple_interest(p,r,t))  

Выход:
Введите основную сумму: 5000
Введите процентную ставку: 5
Введите время в годах: 3
Простой процент: 750,0

Пример 3

#the function calculate returns the sum of two arguments a and b  
def calculate(a,b):  
    return a+b  
calculate(10) # this causes an error as we are missing a required arguments b.  

Выход:
TypeError: calculate() отсутствует 1 обязательный позиционный аргумент: 'b'


Аргументы по умолчанию

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

Пример 1.

def printme(name,age=22):  
    print("My name is",name,"and age is",age)  
printme(name = "john")

Выход:
My name is John and age is 22
Пример 2.

def printme(name,age=22):  
    print("My name is",name,"and age is",age)  
printme(name = "john") #the variable age is not passed into the function however the default value of age is considered in the function  
printme(age = 10,name="David") #the value of age is overwritten here, 10 will be printed as age 

Выход:
My name is john and age is 22
My name is David and age is 10

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

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

Однако при определении функции мы определяем аргумент переменной длины, используя * args(звездочку) как * <переменная – имя>.

Рассмотрим следующий пример:

def printme(*names):  
    print("type of passed argument is ",type(names))  
    print("printing the passed arguments...")  
    for name in names:  
        print(name)  
printme("john","David","smith","nick")  

Выход:
type of passed argument is <class 'tuple'>
printing the passed arguments...
john
David
smith
nick

В приведенном выше коде мы передали * имена в качестве аргумента переменной длины. Мы вызвали функцию и передали значения, которые внутри обрабатываются как кортежи. Кортеж – это итеративная последовательность, такая же, как и список. Чтобы напечатать заданные значения, мы повторили имена * arg, используя цикл for в Python.

Аргументы ключевого слова(** kwargs)

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

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

Рассмотрим следующие примеры.

Пример 1.

#function func is called with the name and message as the keyword arguments  
def func(name,message):  
    print("printing the message with",name,"and ",message)  
    
    #name and message is copied with the values John and hello respectively  
    func(name = "John",message="hello") 

Выход:
printing the message with John and hello

Пример 2. С указанием значений в другом порядке при вызове.

#The function simple_interest(p, t, r) is called with the keyword arguments the order of arguments doesn't matter in this case  
def simple_interest(p,t,r):  
    return(p*t*r)/100  
print("Simple Interest: ",simple_interest(t=10,r=10,p=1900))   

Выход:
Simple Interest: 1900.0
Если мы предоставим другое имя аргументов во время вызова функции, будет выдана ошибка.

Рассмотрим следующий пример.

Пример 3.

#The function simple_interest(p, t, r) is called with the keyword arguments.   
def simple_interest(p,t,r):  
    return(p*t*r)/100  

# doesn't find the exact match of the name of the arguments(keywords)    
print("Simple Interest: ",simple_interest(time=10,rate=10,principle=1900)) 

Выход:
TypeError: simple_interest() got an unexpected keyword argument 'time'

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

Рассмотрим следующие примеры.

Пример 4.

def func(name1,message,name2):  
    print("printing the message with",name1,",",message,",and",name2)  
#the first argument is not the keyword argument  
func("John",message="hello",name2="David") 

Выход:
printing the message with John , hello ,and David

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

Пример 5.

def func(name1,message,name2): 
    print("printing the message with",name1,",",message,",and",name2)  
func("John",message="hello","David")      

Выход:
SyntaxError: positional argument follows keyword argument

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

Рассмотрим следующий пример:

Пример 6. Многие аргументы используют аргумент ключевого слова.

def food(**kwargs):
    print(kwargs)
food(a="Apple")
food(fruits="Orange", Vagitables="Carrot")

Выход:

{'a': 'Apple'}
{'fruits': 'Orange', 'Vagitables': 'Carrot'}

Объем переменных

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

В Python переменные определяются с двумя типами областей видимости:

1. Глобальны.
2. Локальные.

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

Рассмотрим следующий пример.

Пример 1. Локальная переменная

def print_message():  
    message = "hello !! I am going to print a message." # the variable message is local to the function itself  
    print(message)  
print_message()  
print(message) # this will cause an error since a local variable cannot be accessible here.    

Выход:
hello !! I am going to print a message.
File "/root/PycharmProjects/PythonTest/Test1.py", line 5, in
print(message)
NameError: name 'message' is not defined

Пример 2. Глобальная переменная

def calculate(*args):  
    sum=0  
    for arg in args:  
        sum = sum +arg  
    print("The sum is",sum)  
sum=0  
calculate(10,20,30) #60 will be printed as the sum  
print("Value of sum outside the function:",sum) # 0 will be printed  Output:

Выход:
The sum is 60
Value of sum outside the function: 0