Функции и их концепции в Python

Программирование

Функции и их концепции в Python

Компоненты и типы аргументов в функциях

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

Темы для обсуждения:

• Вступление
• Аргументы функции и их типы
• Глобальная и локальная переменная
• Передача последовательности данных в функцию
• Анонимная функция - Lambda

Вступление

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

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

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

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

Функция работает с двумя функциями.

1. Ему нужно определить функцию.
2. Чтобы функция заработала, мы должны ее вызвать.

Синтаксис

def name_of_function():

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

Пример:

def india():                         # Defining a function
    print("People of this country are very great")
india()                              # Calling a function

• Мы определяем функцию и назначаем задачу для работы над ней.

#sum of a two numbers
def sum(x,y):
    a= x+y
    print(x)
#giving two arguments
sum(4,2)
#output: 6

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

Аргументы - это значения или переменные, передаваемые функции.

Аргументы делятся на два типа: фактические и формальные. Фактические аргументы - это значения / переменные, передаваемые во время вызова. Формальные аргументы - это значения / переменные в определении функции.

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

#passing a value                      #passing a variable
def num(x):                           def num(x)
                                          x= 10
    print(x)                              print(x)
#passing one value                    #passing one variable
num(2)                                a= 2
                                      num(a)
#output: 2                            #output: 10

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

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

def num(x):
 print(id(x))
 x[1] = 10
 print(“x: “, x)
 print(id(x))
a = [1,2,3]
print(“a: “, a)
print(id(a))
num(a)
print(“a: “, a)
print(id(a))
#output:
a:  [1, 2, 3]
82513288
82513288
x:  [1, 10, 3]
82513288
a:  [1, 10, 3]
82513288

Разница между ними - неизменяемые и изменяемые типы данных.

Фактический аргумент состоит из четырех типов, как показано ниже:

1. Позиция
2. Ключевое слово
3. Дефолт
4. Переменной длины

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

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

Например:

def person(country_name, code):
    print(country_name)
    print(code)
person('India', 2412)
#output:
India
2412

В приведенном выше примере позиция в коде означает, что «Индия» переходит на первую позицию формального аргумента, а «2412» - на вторую позицию формального аргумента.

Аргумент типа ключевого слова

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

Например:

def person(country_name, code):
    print(country_name)
    print(code)
person(code = 2412, country_name = 'India')
#output:
India
2412

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

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

Этот аргумент полезен, когда нам нужно установить какое-то условие и присвоить значение формальному аргументу.

Например:

def person(country_name, code = 2412):
    print(country_name)
    print(code)
person('India')
#output:
India
2412

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

переменной длины

В этом типе аргументов, когда у нас есть две переменные и нужно передать несколько значений одной переменной, тогда переменная переменной длины появляется на картинке со знаком «*» перед переменной.

Например:

def sum(a, *b):
    x= a+b
    print(x)
sum(5,4,7,3)
#output:
TypeError: unsupported operand type(s) for +: 'int' and 'tuple'

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

a = 5
*b = (4,7,3)

Вот почему мы получаем ошибку, потому что не можем складывать целые числа и кортежи. Итак, чтобы решить эту проблему, нам нужен цикл for, как показано в приведенном ниже примере.

def sum(a, *b):
    y = a
    for i in b:
        y = a+i
    print(y)
sum(5,4,7,3)
#output:
8

Вот еще один совет по использованию «**» для переменной длины с их ключевыми словами в фактических аргументах.

Например:

def sum(a, **b):
    print(a)
    print(b)
sum(5,State = 'Shillong', age = 20, mob = 235436)
#output:
5
{'State': 'Shillong', 'age': 20, 'mob': 235436}

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

Глобальная переменная: переменная, определенная вне функции.

Локальная переменная: переменная, определенная внутри функции.

Например:

x = 4               #Global Variable
def hello(x):
    x= 20           #Local Variable
    print(x)
hello(x)
print(x)
#output:
20
4

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

Например:

x = 4               #Global Variable
def hello():
    global x        #making local variable as global variable
    x= 20           #Local Variable
    print(x)
hello()
print(x)
#output:
20
20

Передача последовательности данных в функцию

В функции мы также можем передавать типы данных последовательности.

Например со списком:

def calculate(lst):
    even = 0
    odd = 0
    
    for i in lst:
        if i%2 ==0:
            even = even+1
        else:
            odd = odd+1
    print("Even: ", even, "odd: ", odd)
    #return even, odd
lst = [23, 33, 4, 22, 44, 16, 19]
calculate(lst)
#output:
Even:  4 odd:  3

Анонимная функция - Lambda

Лямбда-функция - очень полезная функция для экономии времени и памяти. Это однострочный код.

Например:

func = lambda x:x+x
result = func(3)
print(result)
#output:
6

Использование лямбда-функции со строками, как показано в следующем примере:

name = lambda first_name, surname: f'name: {first_name.title()} {surname.title()}'
name('Amit', 'Chauhan')
#Output:
'name: Amit Chauhan'

Заключение:

В этой статье рассмотрены основные понятия о функциях в Python.

Надеюсь, статья вам понравилась. Свяжитесь со мной в моих LinkedIn и twitter.

Рекомендуемые статьи

1. НЛП - от нуля до героя с Python
2. Структуры данных Python Типы данных и объекты
3. Концепции предварительной обработки данных с Python
4. Анализ главных компонентов в уменьшении размерности с Python
5. Полностью объясненная кластеризация K-средних с помощью Python
6. Полностью объясненная линейная регрессия с Python
7. Полностью объясненная логистическая регрессия с Python
8. Основы временных рядов с помощью Python
9. Преобразование данных с помощью Python - Часть 1
10. Матрица неточностей в машинном обучении