Get best of the week

Introdução ao Python Functools

Olá, Habrovsk. Preparamos uma tradução de outro material útil antes do início do curso Python Developer .



Python é uma linguagem de programação orientada a objetos de alto nível. Uma das maiores vantagens do Python é que ele possui uma funcionalidade especial que permite escrever código reutilizável usando as ferramentas de linguagem incorporadas.

Functools é uma biblioteca Python projetada para funcionar com funções de ordem superior. Tais funções podem assumir outras funções e retornar funções. Eles ajudam o desenvolvedor a escrever um código que pode ser reutilizado. As funções podem ser usadas ou estendidas sem reescrevê-las completamente. O módulo functools no Python fornece várias ferramentas que permitem alcançar o efeito descrito. Por exemplo, o seguinte:

  • Parcial
  • Pedido completo;
  • update_wrapperpara parcial .

A função parcial é uma das principais ferramentas fornecidas pelo functools . Vamos descobrir isso com exemplos.

Recurso parcial em Python


No módulo functools , a função parcial é considerada uma das ferramentas mais importantes. Usando uma função parcial , você pode substituir uma função existente que já tenha passado argumentos. Além disso, também podemos criar uma nova versão da função adicionando documentação de qualidade.

Podemos criar novas funções passando argumentos parciais. Também podemos congelar alguns argumentos de função, o que levará ao aparecimento de um novo objeto. Outra maneira de representar parcial é que, com sua ajuda, podemos criar uma função com valores padrão. Parcial suporta palavras-chave e argumentos posicionais como corrigidos.
Vejamos exemplos.

Como criar uma função parcial ?


Para criar uma função parcial , use functoolspartial() da biblioteca . Está escrito da seguinte maneira:

partial(func, /, *args, ** kwargs)

Então você cria uma função parcial que chama func , passando palavras-chave fixas e argumentos posicionais. Aqui, alguns argumentos necessários são geralmente passados ​​para chamar a função func . Os argumentos restantes são passados ​​em * args e ** kwargs .

Suponha que a função abaixo adicione dois números:

def multiply(x, y):
 
    return x * y

Agora considere o caso em que precisávamos duplicar ou triplicar um determinado número. Nesse caso, definimos novas funções, como mostrado abaixo:

def multiply(x, y):
        return x * y
 
def doubleNum(x):
       return multiply(x, 2)
 
def tripleNum(x):
       return multiply(x, 3)

Quando o script da função é apenas 2-3, é claro, é mais lógico, como mostrado acima. Mas quando você precisa escrever outras 100 funções, não faz sentido reescrever o mesmo código tantas vezes. É aqui que as funções parciais são úteis . Para usá-los, primeiro, precisamos importar parcialmente do Functools .

from functools import partial
 
def multiply(x, y):
       return x * y
 
doubleNum = partial(multiply, 2)
   tripleNum = partial(multiply, 3)
 
Print(doubleNum(10))
 
Output: 20

Como você pode ver no exemplo, os valores padrão serão substituídos pelas variáveis ​​à esquerda. Em vez de x, haverá 2 e, em vez de y, haverá 10 ao chamar doubleNum (10) . Neste exemplo, a ordem não importa, mas em outros usos, isso pode importar. Vejamos um exemplo para este caso para entender a ordem de substituição de variáveis.

from functools import partial
def orderFunc(a,b,c,d):
      return a*4 + b*3 + c*2 + d
 
result = partial(orderFunc,5,6,7)
print(result(8))
 
Output: 60

Encomenda completa


Temos uma função orderFunc()na qual multiplicamos apor 4, bpor 3, cpor 2 e adicionamos dvalores à soma.

Criamos uma função parcialresult() que chama orderFunc()com os valores 5, 6 e 7. Agora, os valores 5, 6 e 7 substituirão as variáveis e a, consequentemente. A variável será substituída por 8, pois é transmitida quando chamada . O resultado é (4 * 5 + 6 * 3 + 7 * 2 + 8) = 60.bcdresult()

Nesse caso, a ordem dos valores transmitidos será importante, porque se a ordem for alterada, o resultado também será alterado. Para corrigir variáveis, você pode usar palavras-chave em vez de argumentos posicionais. Vamos reescrever o código acima usando palavras-chave como argumentos.

from functools import partial
def orderFunc(a,b,c,d):
       return a*4 + b*3 + c*2 + d
 
 result = partial(orderFunc,c=5,d=6)
print(result(8,4))
 
Output: 60

Aqui nós fixamos o valor 5 para a variável ce 6 para a variável d. Em vez de variáveis a, os bvalores 8 e 4. Aparecerão (8 * 4 + 4 * 3 + 5 * 2 + 6) = 60. A função

Parcial pode ser determinada em um loop e usada para cálculos repetidos. Vejamos um exemplo:

from functools import partial
 
def add(x,y):
      return x + y
 
add_partials = []
for i in range (1, 10):
      function = partial(add, i)
      add_partials.append(function)
      print('Sum of {} and 2 is {}'.format(i,add_partials[i-1](2)))
 
  
Output:
 
Sum of 1 and 2 is 3
Sum of 2 and 2 is 4
Sum of 3 and 2 is 5
Sum of 4 and 2 is 6
Sum of 5 and 2 is 7
Sum of 6 and 2 is 8
Sum of 7 and 2 is 9
Sum of 8 and 2 is 10
Sum of 9 and 2 is 11

Neste exemplo, resumiremos um certo intervalo de valores com 2, reutilizando a função existente. Podemos chamar parcial no loop e usar sua funcionalidade para calcular as somas. Como pode ser visto pelos valores na saída, temos um ciclo de 1 a 10 e todos os valores nesse intervalo são adicionados a 2 usando a função parcial , que chama a função de adição.

Metadados


Embora as funções parciais sejam independentes, elas retêm a memória (metadados) de uma função que elas estendem.

from functools import partial
 
def add(x,y):
      return x + y
 
# create a new function that multiplies by 2
result = partial(add,y=5)
print(result.func)
print(result.keywords)
 
Output:
<function add at 0x7f27b1aab620>
{'y': 5}

A primeira chamada para func passará o nome da função e seu endereço na memória, e a segunda chamada com palavras - chave passará as palavras-chave para a função. Assim, funções parciais podem ser chamadas de auto-documentação usando metadados que eles recebem de uma função extensível. Podemos atualizar os metadados das funções usando outra ferramenta do functools . É uma ferramenta que você pode usar para atualizar os metadados dos recursos. Vamos descobrir isso com um exemplo.

update_wrapper partial

Update_wrapper

def multiply(x, y):
 
    """Test string."""
 
    return x * y
 
 result = functools.partial(multiply, y=2)
 
 try:
 
    print ('Function Name:'+result.__name__)
 
except AttributeError:
 
    print('Function Name: __no name__')
 
 print ('Function Doc:'+result.__doc__)
 
 print('Updating wrapper:')
 
functools.update_wrapper(result, multiply)
 
 print ('Function Name:'+result.__name__)
 
print ('Function Doc:'+result.__doc__)
 
Output:
 
Function Name: __no name__
 
Function Doc:partial(func, *args, **keywords) - new function with partial application
 
    of the given arguments and keywords.
 
 
Updating wrapper:
 
Function Name: multiply
Function Doc: Test string.

Agora, como você pode ver na saída, antes de usar o wrapper, a função não tinha um nome ou documento atribuído a ela. Assim que atualizamos as funções name e docupdate_wrapper , vimos o resultado correspondente na saída.

Conclusão


Com o functools , podemos nos livrar do código redundante e aumentar as possibilidades de reutilizar o código no Python. Quanto mais frequentemente você usar a função parcial , mais casos de uso serão abertos. Experimente e divirta-se!


Entre no curso.

More articles:


All Articles