Módulo de funciones en Python

Posted on by Rudeus Greyrat

El módulo Functools es para funciones de orden superior que funcionan en otras funciones. Proporciona funciones para trabajar con otras funciones y objetos a los que se puede llamar para usarlos o ampliarlos sin reescribirlos por completo. Este módulo tiene dos clases: parcial y método parcial .

clase parcial

Una función parcial es una función original para valores de argumento particulares. Se pueden crear en Python usando «parcial» de la biblioteca de funciones. Los atributos __name__y __doc__deben ser creados por el programador ya que no se crean automáticamente. Los objetos creados por partial()tienen tres atributos de solo lectura:

Sintaxis:

partial(func[, *args][, **keywords])
  • parcial.func : devuelve el nombre de la función principal junto con la dirección hexadecimal.
  • parcial.args : devuelve los argumentos posicionales proporcionados en la función parcial.
  • parcial.palabras clave : devuelve los argumentos de palabras clave proporcionados en la función parcial.

Ejemplo:

from functools import partial
  
  
def power(a, b):
    return a**b
  
# partial functions
pow2 = partial(power, b = 2)
pow4 = partial(power, b = 4)
power_of_5 = partial(power, 5)
  
print(power(2, 3))
print(pow2(4))
print(pow4(3))
print(power_of_5(2))
  
print('Function used in partial function pow2 :', pow2.func)
print('Default keywords for pow2 :', pow2.keywords)
print('Default arguments for power_of_5 :', power_of_5.args)

Producción :

8
16
81
25
Función utilizada en la función parcial pow2: <function power at 0x000001CCBBE8C7B8>
Palabras clave predeterminadas para pow2: {‘b’: 2}
Argumentos predeterminados para power_of_5: (5, )

clase de método parcial

Es una definición de método de una función ya definida para argumentos específicos como una función parcial. Sin embargo, no es invocable sino que es solo un descriptor de método. Devuelve un nuevo descriptor de método parcial.

Sintaxis:

partialmethod(func, *args, **keywords)

Ejemplo:

from functools import partialmethod
  
  
class Demo:
    def __init__(self):
        self.color = 'black'
    def _color(self, type):
        self.color = type
  
    set_red = partialmethod(_color, type ='red')
    set_blue = partialmethod(_color, type ='blue')
    set_green = partialmethod(_color, type ='green')
  
  
obj = Demo()
print(obj.color)
obj.set_blue()
print(obj.color)

Producción :

black
blue

Funciones

  • Cmp_to_key

    Convierte una función de comparación en una función clave. La función de comparación debe devolver 1, -1 y 0 para diferentes condiciones. Se puede utilizar en funciones clave como sorted(), min(), max().

    Sintaxis:

    function(iterable, key=cmp_to_key(cmp_function))

    Ejemplo:

    from functools import cmp_to_key
      
    # function to sort according to last character
    def cmp_fun(a, b):
        if a[-1] > b[-1]:
            return 1
        elif a[-1] < b[-1]:
            return -1
        else:
            return 0
      
    list1 = ['geeks', 'for', 'geeks']
    l = sorted(list1, key = cmp_to_key(cmp_fun))
    print('sorted list :', l)

    Producción :

    sorted list : ['for', 'geeks', 'geeks']
  • Reducir

    Aplica una función de dos argumentos repetidamente sobre los elementos de una secuencia para reducir la secuencia a un solo valor. Por ejemplo, reduce(lambda x, y: x^y, [1, 2, 3, 4])calcula (((1^2)^3)^4). Si la inicial está presente, se coloca primero en el cálculo, y si el resultado predeterminado cuando la secuencia está vacía.
    Sintaxis:

    reduce(function, sequence[, initial]) -> value

    Ejemplo:

    from functools import reduce
    list1 = [2, 4, 7, 9, 1, 3]
    sum_of_list1 = reduce(lambda a, b:a + b, list1)
      
    list2 = ["abc", "xyz", "def"]
    max_of_list2 = reduce(lambda a, b:a if a>b else b, list2)
      
    print('Sum of list1 :', sum_of_list1)
    print('Maximum of list2 :', max_of_list2)

    Producción :

    Sum of list1 : 26
Maximum of list2 : xyz
  • Total_ordering
    Es un decorador de clases que completa los métodos de comparación que faltan (__lt__, __gt__, __eq__, __le__, __ge__). Si se da una clase que define uno o más métodos de comparación, «@total_ordering» proporciona automáticamente el resto según las definiciones dadas. Sin embargo, la clase debe definir uno de __lt__(), __le__(), __gt__(),o __ge__()y, además, la clase debe proporcionar un __eq__()método.

    Ejemplo:

    from functools import total_ordering
      
    @total_ordering
    class N:
        def __init__(self, value):
            self.value = value
        def __eq__(self, other):
            return self.value == other.value
      
        # Reverse the function of 
        # '<' operator and accordingly
        # other rich comparison operators
        # due to total_ordering decorator
        def __lt__(self, other):
            return self.value > other.value
      
      
    print('6 > 2 :', N(6)>N(2))
    print('3 < 1 :', N(3)<N(1))
    print('2 <= 7 :', N(2)<= N(7))
    print('9 >= 10 :', N(9)>= N(10))
    print('5 == 5 :', N(5)== N(5))

    Producción :

    6 > 2 : False
3 < 1 : True
2 = 10 : True
5 == 5 : True
  • Update_wrapper

    Actualiza una función contenedora para que se parezca a la función envuelta. Por ejemplo, en el caso de funciones parciales, podemos actualizar la función parcial para que se parezca a su función principal usando update_wrapper (parcial, principal). Esto actualizará la documentación (__doc__) y el nombre (__name__) de la función parcial al mismo que la función principal.

    Sintaxis:

    update_wrapper(wrapper, wrapped[, assigned][, updated])

    Ejemplo:

    from functools import update_wrapper, partial
      
    def power(a, b):
        ''' a to the power b'''
        return a**b
      
    # partial function
    pow2 = partial(power, b = 2)
    pow2.__doc__='''a to the power 2'''
    pow2.__name__ = 'pow2'
      
    print('Before wrapper update -')
    print('Documentation of pow2 :', pow2.__doc__)
    print('Name of pow2 :', pow2.__name__)
    print()
    update_wrapper(pow2, power)
    print('After wrapper update -')
    print('Documentation of pow2 :', pow2.__doc__)
    print('Name of pow2 :', pow2.__name__)

    Producción :

    Before wrapper update -
Documentation of pow2 : a to the power 2
Name of pow2 : pow2

After wrapper update -
Documentation of pow2 :  a to the power b
Name of pow2 : power
  • Wraps
    Es un decorador de funciones que aplica update_wrapper() a la función decorada. Es equivalente a parcial (update_wrapper, envuelto=envuelto, asignado=asignado, actualizado=actualizado).

    Ejemplo:

    from functools import wraps
      
    def decorator(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            """Decorator's docstring"""
            return f(*args, **kwargs)
      
        print('Documentation of decorated :', decorated.__doc__)
        return decorated
      
    @decorator
    def f(x):
        """f's Docstring"""
        return x
      
    print('f name :', f.__name__)
    print('Documentation of f :', f.__doc__)

    Producción :

    Documentation of decorated : f's Docstring
f name : f
Documentation of f : f's Docstring
  • LRU_caché

    LRU_cache es un decorador de funciones que se utiliza para guardar hasta el tamaño máximo de las llamadas más recientes de una función. Esto puede ahorrar tiempo y memoria en caso de llamadas repetidas con los mismos argumentos.
    Si *maxsize* se establece en Ninguno, la memoria caché puede crecer sin límites. Si *typed* es True, los argumentos de diferentes tipos de datos se almacenarán en caché por separado. Por ejemplo, f(1.0) y f(1) se memorizarán claramente.

    Sintaxis:

    lru_cache(maxsize=128, typed=False)

    Ejemplo:

    from functools import lru_cache
      
    @lru_cache(maxsize = None)
    def factorial(n):
        if n<= 1:
            return 1
        return n * factorial(n-1)
    print([factorial(n) for n in range(7)])
    print(factorial.cache_info())

    Producción :

    [1, 1, 2, 6, 24, 120, 720]
CacheInfo(hits=5, misses=7, maxsize=None, currsize=7)
  • SingleDispatch
    Es un decorador de funciones. Transforma una función en una función genérica para que pueda tener diferentes comportamientos dependiendo del tipo de su primer argumento. Se usa para la sobrecarga de funciones, las implementaciones sobrecargadas se registran usando el atributo register() del

    Ejemplo:

    from functools import singledispatch
      
    @singledispatch
    def fun(s):
        print(s)
    @fun.register(int)
    def _(s):
        print(s * 2)
      
    fun('GeeksforGeeks')
    fun(10)

    Producción :

    GeeksforGeeks
20

Publicación traducida automáticamente

Artículo escrito por naina024 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *