• Tafsiri

Wakati wa kuzungumza juu ya programu ya kazi, mara nyingi watu huanza kutupa kundi la sifa za "kazi". Data isiyoweza kubadilika, vitendaji vya daraja la kwanza, na uboreshaji wa kujirudia mkia. Hizi ni sifa za lugha zinazokusaidia kuandika programu zinazofanya kazi. Wanataja uchoraji wa ramani, kuchuja, na kutumia vitendaji vya hali ya juu. Hizi ni mbinu za programu zinazotumiwa kuandika msimbo wa kazi. Wanataja ulinganifu, tathmini ya uvivu, na uamuzi. Hizi ni faida za programu za kazi.

Alama. Kanuni ya kazi ina mali moja: kutokuwepo kwa madhara. Haitegemei data nje ya chaguo za kukokotoa za sasa, na haibadilishi data nje ya chaguo za kukokotoa. "Sifa" zingine zote zinaweza kupatikana kutoka kwa hili.

Kitendaji kisichofanya kazi:

A = 0 def increment1(): kimataifa a += 1

Kipengele cha Utendaji:

Def increment2(a): rudisha + 1

Badala ya kurudia kupitia orodha, tumia ramani na upunguze

Ramani

Inakubali chaguo za kukokotoa na seti ya data. Huunda mkusanyiko mpya, hutekeleza chaguo la kukokotoa kwenye kila nafasi ya data, na kuongeza thamani ya kurejesha kwenye mkusanyiko mpya. Hurejesha mkusanyiko mpya.

Ramani rahisi ambayo inachukua orodha ya majina na kurudisha orodha ya urefu:

Name_lengths = ramani(len, ["Masha", "Petya", "Vasya"]) chapisha jina_lengths # =>

Ramani hii inaweka mraba kila kipengele:

Mraba = ramani(lambda x: x * x, ) chapisha miraba # =>

Haikubali chaguo la kukokotoa lililopewa jina, lakini huchukua isiyojulikana iliyofafanuliwa kupitia lambda. Vigezo vya Lambda vinafafanuliwa upande wa kushoto wa koloni. Mwili wa kazi uko upande wa kulia. Matokeo yanarejeshwa kwa ukamilifu.

Msimbo usiofanya kazi katika mfano ufuatao unachukua orodha ya majina na badala yake majina ya utani ya nasibu.

Leta majina nasibu = ["Masha", "Petya", "Vasya"] code_names = ["Shpuntik", "Vintik", "Funtik"] kwa i in range(len(majina)): names[i] = nasibu. chaguo(code_names) chapisha majina # => ["Shpuntik", "Vintik", "Shpuntik"]

Kanuni ya kanuni inaweza kuwapa mawakala tofauti wa siri majina ya utani sawa. Hebu tumaini hili halitasababisha matatizo wakati wa misheni ya siri.

Wacha tuandike tena hii kwa kutumia ramani:

Leta majina nasibu = ["Masha", "Petya", "Vasya"] secret_names = ramani(lambda x: random.choice(["Shpuntik", "Vintik", "Funtik"]), majina)

Zoezi 1. Jaribu kuandika tena nambari ifuatayo kwa kutumia ramani. Inachukua orodha ya majina halisi na kuchukua nafasi yao kwa majina ya utani kwa kutumia njia ya kuaminika zaidi.

Majina = ["Masha", "Petya", "Vasya"] kwa i in range(len(majina)): names[i] = hash(majina[i]) chapisha majina # =>

Uamuzi wangu:

majina = ["Masha", "Petya", "Vasya"] secret_names = ramani(heshi, majina)

Punguza

Kupunguza huchukua kazi na seti ya vitu. Hurejesha thamani iliyopatikana kwa kuchanganya vipengee vyote.

Mfano wa kupunguza rahisi. Hurejesha jumla ya vitu vyote katika seti:

Jumla = punguza(lambda a, x: a + x, ) chapisha jumla # => 10

X ndicho kipengee cha sasa, na ni betri. Hii ndio dhamana inayorejeshwa kwa kutekeleza lambda katika hatua iliyotangulia. reduce() inarudia kupitia thamani zote, na huendesha lambda kwa kila moja kwa thamani za sasa a na x, na hurejesha matokeo katika a kwa marudio yanayofuata.

Ni nini thamani ya a katika marudio ya kwanza? Ni sawa na kipengele cha kwanza cha mkusanyiko, na reduce() huanza kufanya kazi kutoka kwa kipengele cha pili. Hiyo ni, x ya kwanza itakuwa sawa na kipengee cha pili cha seti.

Mfano ufuatao huhesabu ni mara ngapi neno "nahodha" linaonekana katika orodha ya mifuatano:

Sentensi = ["Kapteni Jack Sparrow", "nahodha wa bahari", "mashua yako tayari, nahodha"] cap_count = 0 kwa sentensi katika sentensi: cap_count += sentence.count("captain") print cap_count # => 3

Nambari sawa kwa kutumia kupunguza:

Sentensi = ["nahodha jack sparrow", "nahodha wa bahari", "mashua yako iko tayari, nahodha"] cap_count = punguza(lambda a, x: a + x.count("nahodha"), sentensi, 0)

Thamani ya awali a inatoka wapi hapa? Haiwezi kuhesabiwa kutoka kwa idadi ya marudio katika mstari wa kwanza. Kwa hivyo, imepewa kama hoja ya tatu kwa kupunguza() kazi.

Kwa nini ramani ni bora na kupunguza?

Kwanza, kawaida hulingana kwenye mstari mmoja.

Pili, sehemu muhimu za kurudia-mkusanyiko, uendeshaji, na thamani ya kurudi-siku zote ziko mahali pamoja, ramani na kupunguza.

Tatu, msimbo katika kitanzi unaweza kubadilisha thamani ya vigezo vilivyoainishwa hapo awali, au kuathiri msimbo baada yake. Kwa makubaliano, ramani na kupunguza ni kazi.

Nne, ramani na punguza - shughuli za msingi. Badala ya kusoma loops mstari kwa mstari, ni rahisi kwa msomaji kutambua ramani na kupunguza kujengwa katika algoriti changamano.

Tano, wana marafiki wengi wanaoruhusu tabia muhimu, iliyorekebishwa kidogo ya vipengele hivi. Kwa mfano, chujio, yote, yoyote na pata.

Zoezi 2: Andika upya msimbo ufuatao kwa kutumia ramani, punguza na chujio. Kichujio kinakubali chaguo za kukokotoa na mkusanyiko. Hurejesha mkusanyiko wa vitu hivyo ambavyo chaguo la kukokotoa hurejesha Kweli.

People = [("jina": "Masha", "height": 160), ("height": "Sasha", "height": 80), ("jina": "Pasha")] height_total = 0 height_count = 0 kwa mtu katika watu: ikiwa "urefu" ana kwa ana: urefu_jumla += mtu["urefu"] urefu_hesabu += 1 ikiwa urefu_hesabu > 0: wastani_urefu = urefu_jumla / urefu_hesabu chapa urefu_wastani # => 120

Uamuzi wangu:

people = [("jina": "Masha", "height": 160), ("height": "Sasha", "height": 80), ("jina": "Pasha")] urefu = ramani(lambda x: x["urefu"], kichujio(lambda x: "urefu" katika x, watu)) ikiwa len(urefu) > 0: kutoka kwa uingizaji wa opereta ongeza wastani_height = punguza(ongeza, urefu) / len(urefu)

Andika kwa kutangaza, sio lazima.

Mpango unaofuata unaiga mbio za magari matatu. Kwa kila wakati wa wakati, gari linasonga mbele au la. Kila wakati programu inaonyesha umbali unaosafirishwa na magari. Baada ya vipindi vitano mbio huisha.

Mifano ya pato:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Maandishi ya programu:

Kutoka kwa muda wa kuleta nasibu = nafasi_za_gari 5 = wakati: # muda wa kupungua -= kuchapisha 1 "" kwa i katika masafa(len(nafasi_ya_gari)): # sogeza gari ikiwa nasibu() > 0.3: nafasi_ya_gari[i] += 1 # chora chapa ya gari "-" * nafasi_ya_gari[i]

Kanuni ni muhimu. Toleo la utendaji lingekuwa la kutangaza - lingeelezea kile kinachohitajika kufanywa, sio jinsi inapaswa kufanywa.

Kwa kutumia vipengele

Utangazaji unaweza kupatikana kwa kuingiza nambari kwenye vitendaji:

Kutoka kwa kuagiza bila mpangilio def move_cars(): kwa i, _ katika hesabu(nafasi_za_gari): ikiwa nasibu() > 0.3: nafasi_ya_gari[i] += 1 def draw_car(car_position): chapisha "-" * car_position def run_step_of_race(): wakati wa ulimwengu -= 1 move_cars() def draw(): chapisha "" kwa car_position katika car_positions: draw_car(car_position) time = 5 car_positions = while time: run_step_of_race() draw()

Ili kuelewa programu, msomaji anaangalia kitanzi kikuu. "Ikiwa kuna wakati uliobaki, tutapitia hatua moja ya kinyang'anyiro na kuonyesha matokeo. Hebu tuangalie saa tena." Ikiwa msomaji anahitaji kuelewa jinsi hatua ya mbio inavyofanya kazi, wanaweza kusoma msimbo tofauti.

Hakuna maoni yanayohitajika, nambari inajielezea yenyewe.

Kuvunja msimbo kuwa vitendakazi hufanya msimbo kusomeka zaidi. Mbinu hii hutumia kazi, lakini tu kama subroutines. Wanafunga msimbo, lakini usiifanye ifanye kazi. Kazi huathiri msimbo unaozizunguka na kubadilisha vigeu vya kimataifa badala ya kurudisha thamani. Ikiwa msomaji atakutana na tofauti, atahitaji kupata ilitoka wapi.

Hapa kuna toleo la kazi la programu hii:

Kutoka kwa uagizaji nasibu def move_cars(car_positions): rudisha ramani(lambda x: x + 1 ikiwa nasibu() > 0.3 else x, car_positions) def output_car(car_position): rudisha "-" *car_position def run_step_of_race(state): return ( "muda": hali["wakati"] - 1, "nafasi_za_gari": hoja_gari(jimbo["nafasi_za_gari"])) def draw(jimbo): chapisha "" chapisha "\n".jiunge(ramani(uto_gari, jimbo[ "gari_nafasi"])) def mbio(jimbo): sare(jimbo) ikiwa hali["wakati"]: mbio(kukimbia_hatua_ya_race(jimbo)) mbio(("muda": 5, "nafasi_za_gari": ))

Nambari sasa imegawanywa katika vitendaji vya kazi. Kuna ishara tatu za hii. Ya kwanza ni kwamba hakuna vigezo vilivyoshirikiwa. wakati na nafasi_za gari hupitishwa moja kwa moja kwenye mbio (). Pili, kazi huchukua vigezo. Tatu, vigeuzo havibadilishi vitendakazi vya ndani; maadili yote yanarejeshwa. Kila wakati run_step_of_race() inapofanya hatua inayofuata, inarudishwa hadi inayofuata.

Hapa kuna kazi mbili zero() na moja():

Def sufuri: ikiwa s == "0": rudisha s def moja: ikiwa s == "1": rudisha s

Zero() inachukua kamba s. Ikiwa herufi ya kwanza ni 0, basi inarudisha safu iliyobaki. Ikiwa sivyo, basi Hakuna. one() hufanya vivyo hivyo ikiwa mhusika wa kwanza ni 1.

Wacha tufikirie rule_sequence() kazi. Inachukua kamba na orodha ya kazi za sheria, zinazojumuisha kazi sifuri na moja. Inaita sheria ya kwanza, kupita kwa kamba. Ikiwa Hakuna itarejeshwa, basi chukua thamani iliyorejeshwa na simu kanuni inayofuata. Nakadhalika. Ikiwa Hakuna itarejeshwa, rule_sequence() itasimama na kurudisha Hakuna. Vinginevyo - maana ya kanuni ya mwisho.

Mifano ya data ya pembejeo na pato:

Print rule_sequence("0101", ) # => 1 print rule_sequence("0101", ) # => Hakuna

Toleo la lazima la rule_sequence():

Def rule_sequence(s, sheria): kwa sheria katika kanuni: s = sheria(s) if s == None: break return s

Zoezi 3. Msimbo huu hutumia kitanzi. Iandike upya kwa kutangaza kwa kutumia urejeshaji.

Uamuzi wangu:

def rule_sequence(s, sheria): ikiwa s == Hakuna au si sheria: return s else: return rule_sequence(kanuni), sheria)

Tumia mabomba

Sasa hebu tuandike upya aina nyingine ya kitanzi kwa kutumia mbinu inayoitwa bomba.

Kitanzi kinachofuata hurekebisha kamusi zilizo na jina, nchi asilia isiyo sahihi na hadhi ya baadhi ya vikundi.

Bendi = [("name": "sunset rubdown", "country": "UK", "active": False), ("name": "women", "country": "Germany", "active": Si kweli ), ("name": "a silver mt. zion", "country": "Spain", "active": True)] def format_bands(bendi): kwa bendi katika bendi: bendi["country"] = "Kanada " bendi["jina"] = bendi["jina"].replace(".", "") bendi["name"] = bendi["jina"].title() format_bands(bendi) chapisha bendi # => [("name": "Sunset Rubdown", "active": False, "country": "Canada"), # ("name": "Wanawake", "active": False, "country": "Canada" ) , # ("name": "A Silver Mt Zion", "active": True, "country": "Canada")]

Jina la chaguo la kukokotoa "umbizo" ni la jumla sana. Kwa ujumla, kanuni husababisha wasiwasi fulani. Mambo matatu tofauti hutokea katika mzunguko mmoja. Thamani ya ufunguo wa "nchi" inabadilishwa kuwa "Kanada". Dots huondolewa na herufi ya kwanza ya jina inabadilishwa kuwa kubwa. Ni ngumu kuelewa ni nini nambari inapaswa kufanya, na ni ngumu kusema ikiwa inafanya hivyo. Ni vigumu kutumia, kupima na kusawazisha.

Linganisha:

Chapisha bomba_kila(bendi, )

Ni rahisi. Vitendo vya usaidizi vinaonekana kufanya kazi kwa sababu vimefungwa pamoja. Matokeo ya uliopita ni pembejeo ya ijayo. Ni rahisi kuzijaribu, kuzitumia tena, kuhalalisha na kusawazisha.

Pipeline_each() hurudia kupitia vikundi moja baada ya nyingine na kuvipitisha kwa vitendaji vya ugeuzaji kama vile set_canada_as_country(). Baada ya kutumia kitendakazi kwa vikundi vyote, pipeline_each() hufanya orodha yao na kuipitisha kwa inayofuata.

Wacha tuangalie kazi za mabadiliko.

Def assoc(_d, key, value): kutoka kwa nakala leta deepcopy d = deepcopy(_d) d = value return d def set_canada_as_country(bendi): return assoc(bendi, "country", "Canada") def strip_punctuation_from_name(bendi): return assoc(bendi, "jina", bendi["jina"].replace(".", "")) def capitalize_names(bendi): return assoc(bendi, "jina", bendi["jina"].title( ))

Kila mmoja huhusisha ufunguo wa kikundi na thamani mpya. Hii ni ngumu kufanya bila kubadilisha data asili, kwa hivyo tunatatua hii na assoc(). Inatumia deepcopy() kuunda nakala ya kamusi iliyopitishwa. Kila chaguo la kukokotoa hubadilisha nakala na kurudisha nakala hiyo.

Kila kitu kinaonekana kuwa sawa. Data asili inalindwa dhidi ya mabadiliko. Lakini kuna nafasi mbili zinazowezekana katika msimbo wa mabadiliko ya data. Katika strip_punctuation_from_name() jina bila dots huundwa kwa kupiga simu replace() na jina asili. Capitalize_names() huunda jina na la kwanza herufi kubwa kulingana na kichwa() na jina la asili. Ikiwa nafasi na wakati hazifanyi kazi, basi strip_punctuation_from_name() na capitalize_names() hazifanyi kazi.

Kwa bahati nzuri, wao ni kazi. Katika Python, kamba hazibadiliki. Vipengele hivi hufanya kazi na nakala za mifuatano. Uff, asante Mungu.

Tofauti hii kati ya masharti na kamusi (asili yao inayoweza kubadilika) katika Python inaonyesha faida za lugha kama Clojure. Huko, mpangaji programu sio lazima afikirie ikiwa atabadilisha data. Haitabadilika.

Zoezi 4. Jaribu kutengeneza pipeline_kila kitendakazi. Fikiria juu ya mlolongo wa shughuli. Vikundi viko katika safu, hupitishwa moja baada ya nyingine hadi kitendakazi cha kwanza cha ubadilishaji. Kisha safu inayotokana hupitishwa kipande kimoja kwa kazi ya pili, na kadhalika.

Uamuzi wangu:

def pipeline_each(data, fns): rudisha punguza(lambda a, x: ramani(x, a), fns, data)

Vitendaji vyote vitatu vya mageuzi husababisha kubadilisha uga mahususi kwa kikundi. call() inaweza kutumika kuunda kifupi kwa hili. Inakubali chaguo za kukokotoa na ufunguo ambao itatumiwa.

Set_canada_as_country = call(lambda x: "Canada", "country") strip_punctuation_from_name = call(lambda x: x.replace(".", ""), "name") capitalize_names = call(str.title, "jina") chapisha bomba_kila(bendi, )

Au, kujinyima usomaji:

Chapisha bomba_kila(bendi, )

Nambari ya simu ():

Def assoc(_d, key, value): kutoka kwa nakala leta deepcopy d = deepcopy(_d) d = value return d def call(fn, key): def apply_fn(rekodi): return assoc(rekodi, key, fn(rekodi. get(key))) rudisha apply_fn

Nini kinaendelea hapa?

Moja. wito ni kazi ya utaratibu wa juu, kwa sababu huchukua chaguo jingine la kukokotoa kama hoja na kurudisha chaguo la kukokotoa.

Mbili. apply_fn() ni sawa na kazi za ubadilishaji. Inapata kiingilio (kikundi). Inatafuta rekodi ya thamani. Inapiga simu kwa fn. Hukabidhi matokeo kwa nakala ya rekodi na kuirejesha.

Tatu. simu yenyewe haifanyi chochote. apply_fn() hufanya kazi yote. Katika pipeline_each() mfano, mfano mmoja wa apply_fn() huweka "nchi" kuwa "Kanada". Nyingine ina herufi kubwa ya kwanza.

Nne. Wakati wa kutekeleza mfano wa apply_fn(), fn na utendakazi muhimu hazitapatikana katika wigo. Hizi sio hoja za kuomba_fn() au anuwai za ndani. Lakini kutakuwa na upatikanaji wao. Chaguo za kukokotoa zinapofafanuliwa, huhifadhi marejeleo ya vigeu vinavyofunga—vile ambavyo vilibainishwa nje ya chaguo za kukokotoa na kutumika ndani. Chaguo la kukokotoa linapoendeshwa, vigeu hutafutwa kati ya zile za kawaida, kisha kati ya hoja, na kisha kati ya marejeleo ya kufungwa. Huko utapata fn na ufunguo.

Tano. Hakuna kutajwa kwa vikundi kwenye simu. Hii ni kwa sababu simu inaweza kutumika kuunda mabomba yoyote, bila kujali yaliyomo. Programu inayofanya kazi, haswa, huunda maktaba ya vitendaji vya kawaida vinavyofaa kwa utunzi na matumizi tena.

Umefanya vizuri. Kufungwa, utendaji wa mpangilio wa juu na upeo - yote katika aya chache. Unaweza pia kunywa chai na biskuti.

Bado uchakataji mmoja zaidi wa data ya kikundi. Ondoa kila kitu isipokuwa jina na nchi. extract_name_and_country() kazi:

Def extract_name_and_country(bendi): plucked_band = () plucked_band["name"] = bendi["jina"] plucked_band["nchi"] = bendi["nchi"] rudisha plucked_band chapa bomba_kila(bendi, ) # => [(" name": "Sunset Rubdown", "country": "Canada"), # ("name": "Women", "country": "Canada"), # ("name": "A Silver Mt Zion", " nchi": "Canada")]

Extract_name_and_country() inaweza kuandikwa kwa njia ya kawaida inayoitwa pluck(). Ingetumika kama hii:

Chapisha bomba_kila(bendi, )])

Zoezi 5. pluck inakubali orodha ya vitufe ili kutoa kutoka kwa rekodi. Jaribu kuiandika. Hii itakuwa kazi ya utaratibu wa juu.

Ipo idadi kubwa ya machapisho yaliyotolewa kwa utekelezaji wa dhana za programu za kazi katika Python, lakini nyenzo nyingi hizi ziliandikwa na mwandishi mmoja - David Mertz. Kwa kuongeza, mengi ya makala haya tayari yamepitwa na wakati na yametawanyika katika rasilimali mbalimbali za mtandao. Katika makala hii tutajaribu kurejea mada hii ili kuburudisha na kupanga taarifa zilizopo, hasa kutokana na tofauti kubwa zilizopo kati ya matoleo ya mstari wa 2 na mstari wa 3 wa Python.

Kazi katika Python

Kazi katika Python hufafanuliwa kwa njia 2: kupitia ufafanuzi def au kupitia maelezo yasiyojulikana lambda. Njia zote mbili za ufafanuzi zinapatikana, kwa viwango tofauti, katika lugha zingine za programu. Ubora wa Python ni kwamba chaguo la kukokotoa ni kitu kilichopewa jina, kama kitu kingine chochote cha aina fulani ya data, sema, kama kigezo kamili. Kuorodhesha maonyesho 1 mfano rahisi zaidi(faili func.py kutoka kwa kumbukumbu python_functional.tgz

Kuorodhesha 1. Ufafanuzi wa kazi

#!/usr/bin/python # -*- usimbaji: utf-8 -*- import sys def show(furaha, arg): print("() : ()".format(aina(ya kufurahisha), ya kufurahisha)) print("arg=() => fun(arg)=()".format(arg, fun(arg))) kama len(sys.argv) > 1: n = float(sys.argv[ 1 ]) vinginevyo : n = kuelea(input("nambari?: ")) def pow3(n): # 1 ufafanuzi wa utendakazi kurudi n * n * n onyesho(pow3, n) pow3 = lambda n: n * n * n # 2 -th ufafanuzi wa chaguo za kukokotoa zilizo na onyesho sawa la jina(pow3, n) onyesho((lambda n: n * n * n), n) # 3, matumizi ya ufafanuzi wa utendakazi usiojulikana.

Tunapoita vitu vyote vitatu vya kazi, tutapata matokeo sawa:

$ python func.py 1.3 : arg=1.3 => furaha(arg)=2.197 : katika 0xb7662bc4> arg=1.3 => furaha(arg)=2.197 : katika 0xb7662844> arg=1.3 => furaha(arg)=2.197

Hii inatamkwa zaidi katika toleo la 3 la Python, ambalo kila kitu ni darasa (pamoja na kutofautisha kamili), na kazi ni vitu vya programu ambavyo ni vya darasa. kazi:

$python3 func.py 1.3 : arg=1.3 => furaha(arg)=2.19700000000000005 : kwa 0xb745432c> arg=1.3 => furaha(arg)=2.19700000000000005 : kwa 0xb74542ec> arg=1.3 => furaha(arg)=2.19700000000000005

Kumbuka. Kuna aina 2 zaidi za vitu vinavyoruhusu wito wa kazi - njia ya darasa la kazi na functor, ambayo tutazungumzia baadaye.

Ikiwa vitu vya kazi vya Python ni vitu kama vitu vingine vya data, basi unaweza kufanya nao kila kitu ambacho unaweza kufanya na data yoyote:

• kwa nguvu mabadiliko inaendelea;
• kupachika katika miundo ngumu zaidi ya data (mikusanyiko);
• kupita kama vigezo na maadili ya kurudi, nk.

Hii (udanganyifu na vitu vinavyofanya kazi kama vitu vya data) ndio msingi wa programu ya kufanya kazi. Python, kwa kweli, sio lugha halisi ya programu inayofanya kazi; kwa mfano, kuna lugha maalum za programu inayofanya kazi kikamilifu: Lisp, Mpangaji, na zile za hivi karibuni zaidi: Scala, Haskell. Ocaml, ... Lakini katika Python unaweza "kupachika" mbinu za utendakazi za programu katika mtiririko wa jumla wa msimbo muhimu (amri), kwa mfano, tumia mbinu zilizokopwa kutoka kwa lugha kamili za kazi. Wale. "kunja" vipande vya mtu binafsi vya msimbo muhimu (wakati mwingine ni kubwa kabisa) hadi vielezi vya utendaji.

Wakati mwingine watu huuliza: "Ni faida gani za mtindo wa kufanya kazi wa kuandika vipande vya mtu binafsi kwa programu?" Faida kuu ya programu ya kufanya kazi ni kwamba baada ya kurekebisha kipande hicho mara moja, matumizi ya mara kwa mara ya baadaye hayatasababisha makosa kutokana na madhara yanayohusiana na kazi na migogoro ya majina.

Mara nyingi wakati wa kupanga katika Python, miundo ya kawaida kutoka kwa uwanja wa programu ya kufanya kazi hutumiwa, kwa mfano:

chapisha ([ (x,y) kwa x katika (1, 2, 3, 4, 5) \ kwa y katika (20, 15, 10) \ ikiwa x * y > 25 na x + y< 25 ])

Kama matokeo ya kukimbia tunapata:

$ python funcp.py [(2,20), (2,15), (3,20), (3,15), (3,10), (4,20), (4,15), (4 ,10), (5,15), (5,10)]

Hufanya kazi kama vitu

Wakati wa kuunda kitu cha kufanya kazi na opereta lambda, kama inavyoonyeshwa katika Orodha ya 1, unaweza kufunga kipengee cha kazi iliyoundwa kwa jina pow3 kwa njia sawa na vile mtu anavyoweza kuambatisha nambari kwa jina hili 123 au kamba "Habari!". Mfano huu unathibitisha hali ya kazi kama vitu vya daraja la kwanza kwenye Python. Kazi katika Python ni dhamana nyingine tu ambayo unaweza kufanya kitu nayo.

Kitendo cha kawaida kinachofanywa na vitu vya utendakazi vya daraja la kwanza ni kuvipitisha kwa vitendaji vya mpangilio wa juu vilivyojumuishwa: ramani (), punguza () Na chujio (). Kila moja ya chaguo hizi za kukokotoa huchukua kipengele cha kukokotoa kama hoja yake ya kwanza.

• ramani () inatumia kipengele cha kukokotoa kilichopitishwa kwa kila kipengele katika orodha iliyopitishwa na kurudisha orodha ya matokeo (kipimo sawa na ingizo);
• punguza () hutumika kitendakazi kilichopitishwa kwa kila thamani katika orodha na kwa kikusanyia matokeo ya ndani, k.m. punguza(lambda n,m: n * m, masafa(1, 10)) maana yake 10! (kiwanda);
• chujio () hutumika kitendakazi kilichopitishwa kwa kila kipengele cha orodha na hurejesha orodha ya vipengele hivyo vya orodha asili ambavyo utendakazi uliopitishwa ulirejesha kuwa kweli.

Kwa kuchanganya vipengele hivi vitatu, unaweza kutekeleza aina mbalimbali za kushangaza za uendeshaji wa mtiririko wa udhibiti bila kutumia taarifa za lazima, lakini kwa kutumia tu misemo ya mtindo wa utendaji, kama inavyoonyeshwa katika Orodha ya 2 (faili. funcH.py kutoka kwa kumbukumbu python_functional.tgz

Kuorodhesha 2. Vitendaji vya mpangilio wa juu wa Python

#!/usr/bin/python # -*- usimbaji: utf-8 -*- import sys def input_arg(): global arg = (lambda: (len(sys.argv) > 1 na int(sys.argv[ 1 ])) au \ int(input("nambari?: ")))() rudisha arg print("hoja = ()".format(input_arg()))) chapa(orodha(ramani(lambda x: x + 1) , range(arg))) chapisha(orodha(kichujio(lambda x: x > 4, range(arg)))) leta functools print("()! = ()".format(arg, functools.reduce(lambda x , y: x * y, masafa(1, arg))))

Kumbuka. Nambari hii ni ngumu zaidi kuliko mfano uliopita kwa sababu ya maswala yafuatayo ya utangamano kati ya matoleo ya 2 na 3 ya Python:

• Kazi punguza (), iliyotangazwa kama iliyojengwa ndani ya Python 2, ilihamishwa hadi moduli katika Python 3 functools na kuiita moja kwa moja kwa jina kutatupa ubaguzi Hitilafu ya Jina, kwa hivyo ili ifanye kazi kwa usahihi simu lazima ifomati kama ilivyo kwenye mfano au ni pamoja na mstari: kutoka kwa uingizaji wa functools *
• Kazi ramani () Na chujio () kwenye Python 3 hawarudishi orodha (kama ilivyoonyeshwa tayari wakati wa kujadili tofauti za toleo), lakini vitu vya iterator vya fomu:

Ili kupata orodha nzima ya maadili kwao, kazi inaitwa orodha ().

Kwa hivyo, nambari hii itaweza kufanya kazi katika matoleo yote mawili ya Python:

$python3 funcH.py 7 hoja = 7 7! = 720

Ikiwa usambazaji wa msimbo kati ya matoleo tofauti hauhitajiki, basi vipande vile vinaweza kutengwa, ambayo itaruhusu msimbo kurahisishwa kwa kiasi fulani.

Kujirudia

Katika upangaji wa kazi, urejeshaji ni utaratibu wa kimsingi, sawa na matanzi katika upangaji wa kurudia.

Katika mijadala mingine juu ya Python, nimekutana na taarifa mara kwa mara kwamba katika Python kina cha kujirudia kimepunguzwa na "vifaa", na kwa hivyo vitendo vingine haviwezi kutekelezwa kwa kanuni. Python haina kikomo cha kina cha kurudi nyuma cha 1000, lakini huu ni mpangilio wa nambari ambao unaweza kubatilishwa kila wakati, kama inavyoonyeshwa kwenye Orodha ya 3 (kwa nambari kamili ya mfano, tazama faili. ukweli2.py kutoka kwa kumbukumbu python_functional.tgz

Kuorodhesha 3. Kukokotoa kipengele kwa kina kiholela cha kujirudia

#!/usr/bin/python # -*- usimbaji: utf-8 -*- import sys arg = lambda: (len(sys.argv) > 1 na int(sys.argv[ 1])) au \ int( pembejeo("nambari?: ")) factorial = lambda x: ((x == 1) na 1) au x * factorial(x - 1) n = arg() m = sys.getrecursionlimit() if n >= m - 1: sys.setrecursionlimit(n + 2) print("kina cha kujirudia kinazidi ile iliyowekwa kwenye mfumo (), weka upya hadi ()".\ format(m, sys.getrecursionlimit())) print("n=( ) => n!=()".umbizo(n, factorial(n))) ikiwa sys.getrecursionlimit() > m: chapisha("kina cha kujirudia kimerejeshwa hadi ()".format(m)) sys.setrecursionlimit(m) )

Hivi ndivyo utekelezaji wa mfano huu unavyoonekana katika Python 3 na Python2 (ingawa kwa ukweli nambari inayosababishwa haiwezekani kutoshea kwenye skrini moja ya terminal ya koni):

$ python3 fact2.py 1001 kina cha kujirudia kinazidi mfumo uliowekwa 1000, weka upya hadi 1003 n=1001 => n!=4027....................... . .......................0000000000000 kina cha kujirudia kimerejeshwa hadi 1000

Mifano michache rahisi

Wacha tufanye mabadiliko kadhaa rahisi ya nambari ya kawaida ya lazima (amri, mwendeshaji) ili kubadilisha vipande vyake vya kibinafsi kuwa vya kufanya kazi. Kwanza, wacha tubadilishe waendeshaji wa matawi na hali ya kimantiki, ambayo, kwa sababu ya mahesabu "yaliyoahirishwa" (wavivu, wavivu), huturuhusu kudhibiti utekelezaji au kutotekelezwa kwa matawi ya nambari ya kibinafsi. Kwa hivyo, muundo wa lazima:

kama<условие>: <выражение 1>kwingine:<выражение 2>

Sawa kabisa na kipande kifuatacho cha utendaji (kwa sababu ya uwezo "ulioahirishwa" wa waendeshaji kimantiki. na Na au):

# kazi bila vigezo: lambda: (<условие>na<выражение 1>) au (<выражение 2>)

Wacha tutumie hesabu ya ukweli tena kama mfano. Orodha ya 4 inaonyesha nambari ya kazi ya kuhesabu kipengele (faili ukweli1.py kwenye kumbukumbu python_functional.tgz katika sehemu ya "Pakua Nyenzo"):

Kuorodhesha 4. Ufafanuzi wa Opereta (lazima) wa factorial

#!/usr/bin/python # -*- usimbaji: utf-8 -*- agiza sys def factorial(n): ikiwa n == 1: rudisha 1 kingine: rudisha n * factorial(n - 1) ikiwa len( sys.argv) > 1: n = int(sys.argv[ 1 ]) kingine: n = int(ingizo("nambari?: ")) chapisha("n=() => n!=()".umbizo (n, kihalisi(n)))

Hoja ya kuhesabiwa inatokana na thamani ya kigezo mstari wa amri(ikiwa ipo) au imeingia kutoka kwa terminal. Badiliko la kwanza lililoonyeshwa hapo juu tayari limetumika katika Orodha ya 2, ambapo misemo ya utendakazi imebadilishwa:

• Ufafanuzi wa kipengele cha utendaji: factorial = lambda x: ((x == 1) na 1) au x * factorial(x - 1)
• ombi la kuingiza dhamana ya hoja kutoka kwa koni ya terminal: arg = lambda: (len(sys.argv) > 1 na int(sys.argv[ 1 ])) au \ int(ingizo("nambari?: ")) n = arg()

Katika faili ukweli3.py ufafanuzi mwingine wa kazi unaonekana, unaofanywa kupitia kazi ya utaratibu wa juu punguza ():

factorial = factorial = lambda z: punguza(lambda x, y: x * y, masafa(1, z + 1))

Hapa pia tutarahisisha usemi kwa n, ikiipunguza kuwa simu moja kwa kazi isiyojulikana (isiyotajwa):

n = (lambda: (len(sys.argv) > 1 na int(sys.argv[ 1 ])) au \ int(ingizo("nambari?: ")))()

Mwishowe, unaweza kugundua kuwa kupeana thamani kwa kutofautisha n inahitajika tu kwa matumizi yake katika simu chapa () kutoa thamani hii. Ikiwa tutaachana na kizuizi hiki, basi programu nzima itabadilika kuwa mwendeshaji mmoja anayefanya kazi (tazama faili ukweli4.py kwenye kumbukumbu python_functional.tgz katika sehemu ya "Pakua Nyenzo"):

kutoka kwa sys import * kutoka kwa functools import reduce print("computed factorial = ()".format(\ (lambda z: punguza(lambda x, y: x * y, range(1, z + 1))) \ ((lambda : (len(argv) > 1 na int(argv[ 1 ])) au \ int(ingizo("nambari?: ")))())))

Simu hii moja ndani ya chaguo la kukokotoa chapa () na inawakilisha programu nzima katika hali yake ya utendaji:

Nambari ya $python3 fact4.py?: factorial 5 iliyokokotwa = 120

Je! msimbo huu (faili ukweli4.py) unasoma vizuri zaidi kuliko nukuu muhimu (faili ukweli1.py)? Uwezekano mkubwa zaidi hapana kuliko ndiyo. Je, heshima yake ni nini? Ukweli ni kwamba wakati yoyote mabadiliko kwa msimbo unaozunguka, operesheni ya kawaida hii kipande kitahifadhiwa, kwani hakuna hatari ya athari mbaya kwa sababu ya mabadiliko ya maadili ya anuwai inayotumika.

Kazi za utaratibu wa juu

Katika mtindo wa kufanya kazi wa programu, mazoezi ya kawaida ni kizazi chenye nguvu kitu kinachofanya kazi wakati wa utekelezaji wa nambari, na simu yake inayofuata katika nambari sawa. Kuna idadi ya maeneo ambapo mbinu kama hii inaweza kuwa muhimu.

Kufungwa

Moja ya dhana ya kuvutia ya programu ya kazi ni kufungwa(kufungwa). Wazo hili liligeuka kuwa la kuvutia sana kwa watengenezaji wengi hata lilitekelezwa katika lugha zingine zisizofanya kazi za programu (Perl). David Mertz anatoa ufafanuzi ufuatao wa kufungwa: "Kufungwa ni utaratibu pamoja na seti ya data iliyounganishwa nayo" (kinyume na vitu katika upangaji wa kitu, kama: "data pamoja na seti ya taratibu zilizounganishwa nao").

Maana ya kufungwa ni kwamba ufafanuzi wa chaguo za kukokotoa "husimamisha" muktadha unaozunguka wakati wa uamuzi. Hii inaweza kufanywa kwa njia mbalimbali, kwa mfano kwa kuweka vigezo vya uundaji wa chaguo la kukokotoa, kama inavyoonyeshwa kwenye Orodha 5 (faili funga1.py kwenye kumbukumbu python_functional.tgz katika sehemu ya "Pakua Nyenzo"):

Kuorodhesha 5. Kuunda kufungwa

# -*- usimbaji: utf-8 -*- def multiplier(n): # kizidishi hurejesha kitendakazi ambacho huzidisha kwa n def mul(k): return n * k return mul mul3 = multiplier(3) # mul3 ni chaguo la kukokotoa ambayo huzidisha kwa chapa 3(mul3(3), mul3(5))

Hivi ndivyo kazi iliyofafanuliwa kwa nguvu inavyofanya kazi:

$ chatu clos1.py (9, 15) $ python3 clos1.py 9 15

Njia nyingine ya kuunda kufungwa ni kutumia thamani ya parameta chaguo-msingi katika sehemu ya ufafanuzi wa kazi, kama inavyoonyeshwa kwenye Orodha 6 (faili. kufunga3.py kutoka kwa kumbukumbu python_functional.tgz katika sehemu ya "Pakua Nyenzo"):

Kuorodhesha 6. Njia nyingine ya kuunda kufungwa

n = 3 def mult(k, mul = n): rudisha mul * k n = 7 chapa(mult(3)) n = 13 chapa(mult(5)) n = 10 mult = lambda k, mul=n: mul * k chapisha(zingi(3))

Hakuna kazi zinazofuata za kigezo chaguo-msingi zitabadilisha kazi iliyofafanuliwa hapo awali, lakini chaguo la kukokotoa lenyewe linaweza kubatilishwa:

$ python clos3.py 9 15 30

Programu ya utendaji wa sehemu

Utendakazi wa sehemu ya maombi huchukua kulingana na chaguo la kukokotoa N ufafanuzi wa kutofautiana kipengele kipya na vigezo vichache M < N, wakati wengine N-M Vigezo hupokea maadili ya "waliohifadhiwa" (moduli inatumika functools) Mfano sawa utajadiliwa hapa chini.

Kitendaji

Kitendaji sio kazi, lakini kitu cha darasa ambacho njia iliita __wito__(). Katika kesi hii, simu inaweza kutumika kwa mfano wa kitu kama hicho, kama inavyotokea kwa kazi. Katika Orodha ya 7 (faili sehemu.py kutoka kwa kumbukumbu python_functional.tgz(angalia sehemu ya Vipakuliwa) inaonyesha jinsi ya kutumia kufungwa, ufafanuzi wa utendakazi sehemu, na kigeuzi kutoa matokeo sawa.

Kuorodhesha 7. Kulinganisha kufungwa, ufafanuzi wa sehemu, na kitendaji

# -*- usimbaji: utf-8 -*- def multiplier(n): # kufungwa def mul(k): return n * k return mul mul3 = multiplier(3) kutoka functools leta partial def mulPart(a, b ): Utumizi # wa sehemu ya chaguo za kukokotoa hurejesha a * b par3 = partial(mulSehemu, 3) darasa mulFunctor: # kitendaji sawa def __init__(binafsi, val1): self.val1 = val1 def __call__(self, val2): return self.val1 * val2 fun3 = mulFunctor(3) chapa("() . () . ()".format(mul3(5), par3(5), fun3(5)))

Kuita miundo yote mitatu kwa hoja sawa na 5 itatoa matokeo sawa, ingawa watatumia mifumo tofauti kabisa:

$ python part.py 15 . 15 . 15

Karring

Curring (au currying) ni badiliko la chaguo za kukokotoa kutoka kwa vigeu vingi kuwa kitendakazi ambacho huchukua hoja zake moja baada ya nyingine.

Kumbuka. Mabadiliko haya yalianzishwa na M. Sheinfinkel na G. Frege na yalipewa jina la mwanahisabati Haskell Curry, ambaye pia lugha ya programu ya Haskell inaitwa.

Ubebaji hautumiki vipengele vya kipekee programu ya kazi, hivyo mabadiliko ya currying yanaweza kuandikwa, kwa mfano, katika Perl au C ++. Opereta ya curry imeundwa hata katika lugha zingine za programu (ML, Haskell), ambayo huruhusu vitendaji vya sehemu nyingi kusababisha uwakilishi uliohifadhiwa. Lakini lugha zote zinazounga mkono kufungwa hukuruhusu kuandika vitendaji vilivyowekwa, na Python sio ubaguzi katika suala hili.

Orodha ya 8 inaonyesha mfano rahisi kwa kutumia currying (file curry1.py kwenye kumbukumbu python_functional.tgz katika sehemu ya "Pakua Nyenzo"):

Kuorodhesha 8. Curring

# -*- usimbaji: utf-8 -*- def spam(x, y): chapisha("param1=(), param2=()".format(x, y)) spam1 = lambda x: lambda y: spam (x, y) def spam2(x) : def new_spam(y) : rudisha spam(x, y) rudisha new_spam spam1(2)(3) # currying spam2(2)(3)

Hivi ndivyo utekelezaji wa simu hizi unavyoonekana:

$ chatu curry1.py param1=2, param2=3 param1=2, param2=3

Hitimisho

Nakala hii ilianzisha baadhi ya vipengele vya lugha ya Python vinavyokuwezesha kuitumia kuandika programu kwa kutumia mtindo wa utendakazi wa programu. Kwa hiyo, tulielezea mbinu za msingi za programu za kazi na tulionyesha mifano ya utekelezaji wao katika Python. Kama katika vifungu vilivyotangulia, mifano ya nambari imeandikwa kwa njia ambayo inaweza kuendeshwa kwa mafanikio na kutekelezwa katika matoleo yote mawili ya Python.

Katika makala inayofuata tutajadili maswala ya kupanga utekelezaji sambamba wa nambari katika mazingira ya Python.

3.2.3 Ufahamu wa Kamusi

Sema tunayo kamusi ambayo funguo zake ni herufi na maadili ambayo ramani ya idadi ya mara herufi inaonekana katika maandishi fulani. Kamusi kwa sasa inatofautisha kati ya herufi kubwa na ndogo.

Tunahitaji kamusi ambamo matukio ya herufi kubwa na ndogo yanaunganishwa:

dct = ( "a" : 10 , "b" : 34 , "A" : 7 , "Z" : 3 ) frequency = ( k . chini () : dct . pata ( k . chini () , 0 ) + dct . pata ( k . juu () , 0 ) kwa k in dct . funguo()) masafa ya kuchapisha #("a": 17, "z": 3, "b": 34)

Python inasaidia uundaji wa kazi zisizojulikana (yaani kazi ambazo sio imefungwa kwa jina) wakati wa kukimbia, kwa kutumia muundo unaoitwa "lambda". Hii si sawa kabisa na lambda katika lugha tendaji za programu, lakini ni dhana yenye nguvu sana ambayo imeunganishwa vyema kwenye Python na mara nyingi hutumiwa pamoja na dhana za utendaji kazi kama filter() , map() na reduce() .

Vitendaji visivyojulikana kwa namna ya usemi vinaweza kuundwa kwa kutumia lambda
kauli:

args ni orodha ya hoja iliyotenganishwa kwa koma, na usemi ni usemi unaohusisha hoja hizo. Sehemu hii ya nambari inaonyesha tofauti kati ya ufafanuzi wa kawaida wa kazi na kazi ya lambda:

def kazi (x) : kurudi x *x kazi ya kuchapisha(2) #4 #-----------------------# kazi = lambda x : x * x kazi ya kuchapisha(2) #4

Kama unavyoona, zote mbili function() hufanya sawa na zinaweza kutumika kwa njia sawa. Kumbuka kuwa ufafanuzi wa lambda haujumuishi taarifa ya "kurudi" - huwa na usemi ambao hurejeshwa. Pia kumbuka kuwa unaweza kuweka ufafanuzi wa lambda mahali popote kazi inavyotarajiwa, na sio lazima uikabidhi kwa kutofautisha hata kidogo.

Vipande vya msimbo vifuatavyo vinaonyesha matumizi ya vitendaji vya lambda.

def increment (n) : rudisha lambda x : x + n nyongeza ya uchapishaji(2) # kwa 0x022B9530> nyongeza ya uchapishaji (2) (20) #22

Nambari iliyo hapo juu inafafanua nyongeza ya chaguo la kukokotoa ambayo huunda kitendakazi kisichojulikana kwenye nzi na kuirejesha. Chaguo za kukokotoa zilizorejeshwa huongeza hoja yake kwa thamani ambayo ilibainishwa wakati iliundwa.

Unaweza sasa unda kazi nyingi tofauti za nyongeza na uzipe kwa anuwai, kisha uzitumie huru kutoka kwa kila mmoja. Kama taarifa ya mwisho inavyoonyesha, si lazima hata kukabidhi chaguo la kukokotoa popote - unaweza kuitumia mara moja na kuisahau wakati haihitajiki tena.

Q3. Lambda ni nzuri kwa nini?
Jibu.
Jibu ni:

• Hatuhitaji lambda, tunaweza kuishi vizuri bila hiyo. Lakini...
• kuna hali fulani ambapo ni rahisi - hurahisisha kuandika msimbo, na msimbo ulioandikwa kuwa safi zaidi.

Q4. Ni hali gani?

Kweli, hali ambazo tunahitaji kazi rahisi ya mara moja: kazi ambayo itatumika mara moja tu.

Kwa kawaida, chaguo za kukokotoa huundwa kwa mojawapo ya madhumuni mawili: (a) kupunguza urudiaji wa msimbo, au (b) kurekebisha msimbo.

• Ikiwa programu yako ina sehemu mbili za msimbo katika sehemu mbalimbali, basi unaweza kuweka nakala moja ya msimbo huo kwenye chaguo za kukokotoa, upe chaguo la kukokotoa jina, na kisha - kwa kutumia jina la chaguo la kukokotoa - liite kutoka sehemu mbalimbali kwenye msimbo wako.
• Ikiwa una sehemu ya msimbo ambayo hufanya operesheni moja iliyofafanuliwa vizuri - lakini ni ndefu sana na inakatiza mtiririko unaoweza kusomeka wa programu yako - basi unaweza kutoa msimbo huo mrefu wa gnarly na kuiweka kwenye utendaji yenyewe.

Lakini tuseme unahitaji kuunda kitendakazi ambacho kitatumika mara moja tu - kinachoitwa kutoka kimoja tu weka katika maombi yako. Naam, kwanza kabisa, huna haja ya kutoa kazi jina. Inaweza kuwa "isiyojulikana". Na unaweza kufafanua moja kwa moja mahali ambapo unataka kuitumia. Hapo ndipo lambda inafaa.

Kwa kawaida, lambda hutumiwa katika muktadha wa operesheni nyingine, kama vile kupanga au kupunguza data:

majina = [ "David Beazley" , "Brian Jones" , "Raymond Hettinger" , "Ned Batchelder" ] chapisha kimepangwa (majina , ufunguo = jina lambda : jina . mgawanyiko () [- 1 ] . chini ()) # ["Ned Batchelder", "David Beazley", "Raymond Hettinger", "Brian Jones"]

Ingawa lambda hukuruhusu kufafanua kazi rahisi, matumizi yake yamezuiliwa sana. Katika
haswa, usemi mmoja tu unaweza kubainishwa, matokeo yake ni kurudi
thamani. Hii ina maana kwamba hakuna vipengele vingine vya lugha, ikiwa ni pamoja na kauli nyingi, masharti, marudio na ushughulikiaji wa kipekee, vinaweza kujumuishwa.
Unaweza kuandika kwa furaha nambari nyingi za Python bila kutumia lambda. Hata hivyo,
mara kwa mara utakutana nayo katika programu ambapo mtu anaandika vidogo vingi
kazi zinazotathmini misemo mbalimbali, au katika programu zinazohitaji watumiaji kutoa
kazi za kurudi nyuma.

Umefafanua chaguo la kukokotoa lisilojulikana kwa kutumia lambda, lakini pia unahitaji kunasa faili ya
maadili ya vigezo fulani wakati wa ufafanuzi.

>>> x = 10 >>> a = lambda y : x + y >>> x = 20 >>> b = lambda y : x + y

Sasa jiulize swali. Je, maadili ya a(10) na b(10) ni yapi? Ikiwa unafikiri
matokeo yanaweza kuwa 20 na 30, utakuwa umekosea:

Shida hapa ni kwamba thamani ya x inayotumika katika usemi wa lambda ni tofauti ya bure
ambayo hufungwa wakati wa kukimbia, sio wakati wa ufafanuzi. Kwa hivyo, thamani ya x kwenye lambda
misemo ni chochote thamani ya utofauti wa x hutokea wakati wa utekelezaji.
Kwa mfano:

Ikiwa unataka chaguo la kukokotoa lisilojulikana kukamata thamani katika hatua ya ufafanuzi na
ihifadhi, jumuisha dhamana kama dhamana chaguo-msingi, kama hii:

Tatizo linaloshughulikiwa hapa ni jambo ambalo huwa linajitokeza kwa kificho kwamba
inajaribu kuwa wajanja kidogo tu na matumizi ya vitendaji vya lambda. Kwa mfano,
kuunda orodha ya misemo ya lambda kwa kutumia ufahamu wa orodha au katika kitanzi cha aina fulani na kutarajia vitendaji vya lambda kukumbuka utofauti wa kurudia wakati wa ufafanuzi. Kwa mfano:

>>> funcs = [ lambda x : x + n kwa n katika masafa (5 )]