Разширени функции в Python. Част 8 от курса по Python от начинаещ до напреднал в 11 блог поста

Тази статия ще помогне на читателя да продължи от предишния блог за функции в Python, заедно с някои основни приложения в реалния свят. Ще използваме Visual Studio Code като наш редактор на код. Ако не сте инсталирали Visual Studio Code, инструкциите са дадени в първия блог.

Разширени функции в Python – съдържание:

1. Предаване на функции на други функции
2. Използване на функции вътре в функция
3. *Args в Python
4. “*” оператор в Python
5. **kwargs в Python

Предаване на функции на други функции

Както беше обсъдено в предишния блог, функциите в Python се третират като обекти. Така че, подобно на обектите в Python, функциите също могат да бъдат предавани като аргумент на друга функция.

Например:

def mul(x, y):
    return x*y
 
 
def add(mul, y):
    return mul+y
 
 
x = add(mul(9, 10), 10)
print(x)

В горния кодов блок може да се види, че функцията mul се предава като аргумент на функцията add и се съхранява в променливата x, която след това се отпечатва, за да се провери отговорът.

100

Използване на функции вътре в функция

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

Нека напишем нашата първа функция.

def mul(x, y):
 
    m = x*y
 
    def square(m):
        return m*m
 
    return square(m)
 
 
x = mul(9, 10)
 
print(x)

Изход:
8100

В горния кодов блок външната функция е “mul”, която връща функцията square, която приема аргумент “m”, който е произведението на двата аргумента, предадени на функцията “mul”. Изпълнението на кода започва с извикването на функцията “mul”, след което произведението на “x” и “y” се съхранява в променливата “m”. Тъй като тази функция връща функцията square, функцията “square” се извиква и крайният продукт, който е квадрат на “m”, се връща.

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

*Args в Python

Това са аргументите, които използваме като параметри на функцията. Нека напишем обикновена функция, използвайки това, което научихме до сега. Ще напишем функция, която може да ни даде максималната площ на правоъгълник, като предадем 2 площи на правоъгълници като параметри на функцията.

def maxarea(a, b):
    if a > b:
        return f'правоъгълник a има по-голяма площ, която е {a}'
    else:
        return f'правоъгълник a има по-голяма площ, която е {b}'
 
 
x = maxarea(100, 60)
print(x)
 

Изход:
правоъгълник a има по-голяма площ, която е 100
[code lang="js"]

Тази функция е добра за 2 параметъра или аргументи, но какво, ако трябва да сравним повече от 2 площи. Един подход би бил да предадем списък с площи на функцията.

def maxarea(lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"правоъгълникът с по-голяма площ е {max}"
 
 
x = maxarea([100, 60, 50])
print(x)

Изход:
правоъгълникът с по-голяма площ е 100

Този подход е добър, но трябва да знаем броя на параметрите или аргументите предварително. В реално време, изпълнението на кода би било затруднително. Следователно, за да улесни живота на програмистите, Python използва *args и **kwargs.

“*” оператор в Python

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

Разопаковане на аргументи в кортеж с помощта на * оператор

Както видяхме, операторът “*” се използва за разопаковане на стойности. Примерът е илюстриран по-долу.

x = [1, 2, 3, 4]
y = [5, 6, 7, 8]
 
z = *x, *y
 
print(type(z))
print(z)

Изход:
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 7, 8)

Както можем да видим, операторът за разопаковане е разопаковал списък x и списък y в кортеж, който е z. Можем също да видим, че резултатът е кортеж.

Нека напишем същата функция, използвайки *Args.

def maxarea(*lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"правоъгълникът с по-голяма площ е {max}"
 
 
x = maxarea(100, 60, 50, 200)
y = maxarea(100, 60, 50, 200, 9000)
z = maxarea(100, 60, 50, 20, 90)
print(x)
print(y)
print(z)

Изход:
правоъгълникът с по-голяма площ е 200
правоъгълникът с по-голяма площ е 9000
правоъгълникът с по-голяма площ е 100

В този кодов блок можем да видим, че сега аргументите са динамични, можем да добавим произволен брой аргументи, които ще бъдат разопаковани в функцията maxarea, за да ни дадат желания резултат. Също така можем да сравняваме произволен брой площи в този контекст.

**kwargs в Python

kwargs е подобен на args, но приема позиционни аргументи. Използва ** оператор, който има някои атрибути, като разопаковане на множество позиционни аргументи с произволна дължина, може също да разопакова речници, може също да се използва за комбиниране на два речника.

Обединяване на речници

a = {"h": 1, "n": 2}
b = {"m": 5, "l": 10}
 
c = {**a, **b}
 
print(type(c))
print(c)
 

Можем да видим от горния код, че имаме 2 речника a и b, които са обединени с помощта на ** оператор, за да дадат друг речник.
Изход:
 
<class 'dict'>
{'h': 1, 'n': 2, 'm': 5, 'l': 10}

Когато използваме * оператор вместо ** оператор, кодът за този случай е илюстриран по-долу.

a = {"h": 1, "n": 2}
b = {"m": 5, "l": 10}
 
c = {*a, *b}
 
print(type(c))
print(c)

Изход:
<class 'set'>
{'n', 'l', 'm', 'h'}

Следователно, когато операторът * се използва за обединяване на два речника, изходът ще бъде множество с само ключовете от речника.

Функцията maxarea, използваща **kwargs, е илюстрирана в долния кодов блок.

def maxarea(**lis):
 
    max = 0
    for i in lis.values():
        if i > max:
            max = i
 
    return f"правоъгълникът с по-голяма площ е {max}"
 
 
x = maxarea(a=1, b=2, c=3)
y = maxarea(a=1, b=2)
z = maxarea(a=1, b=2, c=3, d=9)
print(x)
print(y)
print(z)

Изход:
правоъгълникът с по-голяма площ е 3
правоъгълникът с по-голяма площ е 2
правоъгълникът с по-голяма площ е 9

В този блог за разширени функции в Python, ние разгледахме теми като предаване на функции на други функции, използване на функции вътре в функция, *Args в Python, “*” оператор в Python, **kwargs в Python и още. По-нататъшните теми, които включват класове, ще бъдат разгледани в следващия блог пост. Домашната работа относно разширените функции в Python е дадена по-долу.