Funções avançadas em Python. Parte 8 do Curso de Python do Iniciante ao Avançado em 11 postagens de blog

Este artigo ajudará o leitor a continuar a partir do blog anterior sobre funções em Python, juntamente com algumas aplicações básicas no mundo real. Estaremos usando o Visual Studio Code como nosso editor de código. Se você não instalou o Visual Studio Code, as instruções estão disponíveis no primeiro blog.

Funções avançadas em Python – índice:

1. Passando funções para outras funções
2. Usando funções dentro de uma função
3. *Args em Python
4. Operador “*” em Python
5. **kwargs em Python

Passando funções para outras funções

Como discutido no blog anterior, funções em Python são tratadas como objetos. Assim como objetos em Python, funções também podem ser passadas como argumento para outra função.

Por exemplo:

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

No bloco de código acima, pode-se ver que a função mul é passada como um argumento para a função add e é armazenada na variável x, que é então impressa para verificar a resposta.

100

Usando funções dentro de uma função

Em Python, podemos definir uma função dentro de outra função. Essas funções são chamadas de funções aninhadas. Mas neste caso de uso, a função interna ou função aninhada não pode ser chamada separadamente. Ambos os exemplos são ilustrados no bloco de código a seguir.

Vamos escrever nossa primeira função.

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

Saída:
8100

No bloco de código acima, a função externa é “mul” que retorna a função square que recebe um argumento “m” que é a multiplicação de dois argumentos dados à função “mul”. A execução do código começa chamando a função “mul”, então o produto de “x” e “y” é armazenado na variável “m”. Como esta função está retornando a função square, a função “square” é chamada e o produto final, que é o quadrado de “m”, é retornado.

Vamos aprender algumas coisas importantes em Python, que tornarão sua jornada de codificação com Python muito melhor.

*Args em Python

Esses são os argumentos que usamos como parâmetros de função. Vamos escrever uma função usual usando o que aprendemos até agora. Estaremos escrevendo uma função que pode nos dar a área máxima de um retângulo dado 2 áreas de retângulos como parâmetros para a função.

def maxarea(a, b):
    if a > b:
        return f'o retângulo a tem a maior área que é {a}'
    else:
        return f'o retângulo a tem a maior área que é {b}'
 
 
x = maxarea(100, 60)
print(x)
 

Saída:
o retângulo a tem a maior área que é 100
[code lang="js"]

Esta função é boa para 2 parâmetros ou argumentos, mas e se precisarmos comparar mais de 2 áreas? Uma abordagem seria passar uma lista de áreas para a função.

def maxarea(lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"o retângulo que tem a maior área é {max}"
 
 
x = maxarea([100, 60, 50])
print(x)

Saída:
o retângulo que tem a maior área é 100

Essa abordagem é boa, mas devemos saber o número de parâmetros ou argumentos a serem dados com antecedência. Na execução de código em tempo real, isso seria um incômodo. Portanto, para facilitar a vida do programador, Python usa *args e **kwargs.

Operador “*” em Python

Este operador é um operador de desempacotamento que é geralmente usado para passar um número não especificado de parâmetros ou argumentos.

Desempacotando argumentos em tupla usando o operador *

Como vimos, o operador “*” é usado para desempacotar valores. O exemplo é ilustrado abaixo.

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

Saída:
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 7, 8)

Como podemos ver, o operador de desempacotamento desempacotou a lista x e a lista y em uma tupla que é z. Também podemos ver que o resultado é uma tupla.

Vamos escrever a mesma função usando *Args.

def maxarea(*lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"o retângulo que tem a maior área é {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)

Saída:
o retângulo que tem a maior área é 200
o retângulo que tem a maior área é 9000
o retângulo que tem a maior área é 100

Neste bloco de código, podemos ver que agora os argumentos são dinâmicos, podemos adicionar qualquer número de argumentos que serão desempacotados na função maxarea para nos dar o resultado desejado. Além disso, podemos comparar qualquer número de áreas neste contexto.

**kwargs em Python

Os kwargs são como args, mas aceitam argumentos posicionais. Ele usa o operador ** que possui alguns atributos, como desempacotar múltiplos argumentos posicionais de qualquer comprimento, também pode desempacotar dicionários, também pode ser usado para combinar dois dicionários.

Mesclando dicionários

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

Podemos ver pelo código acima que temos 2 dicionários a e b que são mesclados usando o operador ** para dar outro dicionário.
Saída:
 
<class 'dict'>
{'h': 1, 'n': 2, 'm': 5, 'l': 10}

Quando usamos o operador * em vez do operador **, o código para este caso é ilustrado abaixo.

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

Saída:
<class 'set'>
{'n', 'l', 'm', 'h'}

Portanto, quando o operador * é usado em dois dicionários para mesclar, o resultado será um conjunto com apenas as chaves do dicionário.

A função maxarea usando **kwargs é ilustrada no bloco de código abaixo.

def maxarea(**lis):
 
    max = 0
    for i in lis.values():
        if i > max:
            max = i
 
    return f"o retângulo que tem a maior área é {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)

Saída:
o retângulo que tem a maior área é 3
o retângulo que tem a maior área é 2
o retângulo que tem a maior área é 9

Neste blog sobre funções avançadas em Python, cobrimos tópicos como passar funções para outras funções, usar funções dentro de uma função, *Args em Python, operador “*” em Python, **kwargs em Python, e mais. Os tópicos futuros que incluem classes serão abordados no próximo post do blog. O dever de casa sobre funções avançadas em Python é dado abaixo.