Python Language
Functools-modul

partiell

Den partial funktionen skapar en del av funktionen från en annan funktion. Det används för att binda värden till några av funktionens argument (eller nyckelordargument) och producera en konverterbar utan de redan definierade argumenten.

>>> from functools import partial
>>> unhex = partial(int, base=16)
>>> unhex.__doc__ = 'Convert base16 string to int'
>>> unhex('ca11ab1e')
3390155550

partial() tillåter, som namnet antyder, en partiell utvärdering av en funktion. Låt oss titta på följande exempel:

In [2]: from functools import partial

In [3]: def f(a, b, c, x):
   ...:     return 1000*a + 100*b + 10*c + x
   ...: 

In [4]: g = partial(f, 1, 1, 1)

In [5]: print g(2)
1112

När g skapas utvärderas också f , som tar fyra argument ( a, b, c, x ) delvis för de första tre argumenten, a, b, c, Utvärderingen av f avslutas när g kallas, g(2) , vilket överför det fjärde argumentet till f .

Ett sätt att tänka på partial är ett skiftregister; trycka in ett argument åt gången in i någon funktion. partial är praktiskt för fall där data kommer in som ström och vi kan inte överföra mer än ett argument.

total_ordering

När vi vill skapa en ordningsbar klass måste vi normalt definiera metoderna __eq()__ , __lt__() , __le__() , __gt__() och __ge__() .

Den total_ordering , tillämpad på en klass, tillåter definitionen av __eq__() och endast en mellan __lt__() , __le__() , __gt__() och __ge__() , och tillåter fortfarande alla beställningsoperationer i klassen.

@total_ordering
class Employee:

    ...

    def __eq__(self, other):
        return ((self.surname, self.name) == (other.surname, other.name))

    def __lt__(self, other):
        return ((self.surname, self.name) < (other.surname, other.name))

Dekoratören använder en sammansättning av de angivna metoderna och algebraiska operationer för att härleda de andra jämförelsemetoderna. Om vi till exempel definierade __lt__() och __eq()__ och vi vill härleda __gt__() , kan vi helt enkelt inte kontrollera not __lt__() and not __eq()__ .

Obs total_ordering Funktionen total_ordering är endast tillgänglig sedan Python 2.7.

minska

I Python 3.x har reduce redan förklarats här tagits bort från de inbyggda och måste nu importeras från functools .

from functools import reduce
def factorial(n):
    return reduce(lambda a, b: (a*b), range(1, n+1))

lru_cache

@lru_cache dekoratören kan användas genom att lägga in en dyr, beräkningsintensiv funktion med en minst nyligen använda cache. Detta gör att funktionssamtal kan memoiseras, så att framtida samtal med samma parametrar kan återvända direkt istället för att behöva beräknas om.

@lru_cache(maxsize=None)  # Boundless cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

>>> fibonacci(15)

I exemplet ovan beräknas värdet på fibonacci(3) endast en gång, medan om fibonacci inte hade en LRU-cache, skulle fibonacci(3) ha beräknats uppåt 230 gånger. Därför är @lru_cache särskilt bra för rekursiva funktioner eller dynamisk programmering, där en dyr funktion kan kallas flera gånger med samma exakta parametrar.

@lru_cache har två argument

• maxsize : Antal samtal att spara. När antalet unika samtal överstiger maxsize LRU-cachen bort de minst nyligen använda samtalen.
• typed (tillagd i 3.3): Flagga för att avgöra om likvärdiga argument av olika typer tillhör olika cacheposter (dvs. om 3.0 och 3 räknas som olika argument)

Vi kan också se cachestatistik:

>>> fib.cache_info()
CacheInfo(hits=13, misses=16, maxsize=None, currsize=16)

OBS : Eftersom @lru_cache använder ordböcker för att cache-resultat måste alla parametrar för funktionen vara hashable för att cachen ska fungera.

Officiella Python-dokument för @lru_cache . @lru_cache lades till i 3.2.

cmp_to_key

Python ändrade sina sorteringsmetoder för att acceptera en nyckelfunktion. Dessa funktioner tar ett värde och returnerar en nyckel som används för att sortera matriserna.

Gamla jämförelsefunktioner som används för att ta två värden och returnera -1, 0 eller +1 om det första argumentet är litet, lika eller större än det andra argumentet. Detta är oförenligt med den nya nyckelfunktionen.

Det är där functools.cmp_to_key kommer in:

>>> import functools
>>> import locale
>>> sorted(["A", "S", "F", "D"], key=functools.cmp_to_key(locale.strcoll))
['A', 'D', 'F', 'S']

Exempel taget och anpassat från Python Standard Library Documentation .