Dumaan sa Sanggunian kumpara sa Halaga sa Python

Pass Reference Vs



Matapos malaman ang Python, maaari kang makahanap ng mga pagkakataon kung saan ang mga pag-andar ay hindi binabago ang mga argument sa isang lugar tulad ng aasahan mo, lalo na kung pamilyar ka sa maraming iba pang mga wika sa computer. Maraming mga wika ang gumagamit ng mga argumento ng pamamaraan bilang mga sanggunian, na tinukoy bilang pagpasa ng Sanggunian sa kasalukuyang mga variable. Kung ikaw ay isang advanced na developer ng Python na nais na maunawaan ang partikular na paraan ng Python sa paggamot sa mga argumento ng pamamaraan, kung gayon ang gabay na ito ay talagang para sa iyo.

Sinusuportahan ng Python na Pass sa pamamagitan ng Sanggunian ng Bagay

Ang pass-by-refer at pass-by-value ay hindi maikakaila ang dalawang pinakahusay na kinikilala at madaling maunawaan na mga paraan sa pagpasa ng parameter sa pagitan ng mga wika ng programa. Ang Python ay, nakalulungkot, 'pass-by-object-reference,' ni Pass by Value o Pass by Reference, na madalas na tinatawag na Call by Object Reference pati na rin ang Call by Sharing. Kapaki-pakinabang na tingnan nang mas malapit ang konsepto mismo sa pamamagitan ng paghahati nito sa mga segment habang sumasabog ka sa mga teknikal na detalye ng pagpasa ng Sanggunian:







Pumasa: nangangahulugan ito ng pagbibigay ng isang pamamaraan sa isang pagtatalo.



Sa pamamagitan ng Sanggunian: nangangahulugan ito na ang argumentong inilipat mo sa pamamaraan ay tumutukoy sa isang variable na naninirahan ngayon sa imbakan sa halip na isang iba't ibang mga replica ng variable na iyon.



Habang itinatalaga mo ang pamamaraan ng isang sanggunian sa isang tinukoy na variable, ang variable na tumutugma dito ay malinaw na maiimpluwensyahan ng lahat ng mga pagpapatakbo sa Sanggunian na ito. Ngayon isaalang-alang natin ang isang halimbawa kung paano, sa pagsasanay, ito gumagana. Sa halimbawang ito, tinukoy namin ang isang variable na ‘ galit' pagkakaroon ng halaga ng 4 . Sa buong senaryong ito, ang variable na ‘ galit' ay hindi nabago sa lugar nito. Tila hawakan ng Python ang iyong ibinigay na argument sa halip na isang sanggunian sa isang kasalukuyang variable bilang isang self-nilalaman na halaga.





Mangangahulugan ba ito na sa halip na sa pamamagitan ng Sanggunian, inililipat ng Python ang mga argumento ayon sa halaga? Ang Python ay naglilipat ng mga argumento sa pamamagitan ng pagtatalaga, kaya't hindi sa pamamagitan ng Sanggunian o may halaga. Ang lohika para dito ay dalawang beses:



Sa kasalukuyan, ang parameter na pumapasok ay isang pointer sa isang object. Ang ilang mga uri ng data ay nababagabag, at ang ilan ay hindi nababagabag.

Kung ilipat namin ang isang nababagabag na bagay sa isang pag-andar, nakakakuha ang pagpapaandar ng isang sanggunian sa parehong bagay sa gayon maaari mong baguhin ang lahat sa kasiyahan ng iyong kaluluwa; gayunpaman, ang panlabas na saklaw ay walang alam bago ka sumali muli sa Sanggunian sa pagpapaandar. Kapag tapos ka na, ang panlabas na Sanggunian ay maglalayon lamang sa aktwal na object. Kung ilipat mo ang isang hindi nababago na bagay sa isang pagpapaandar, ang panlabas na Sanggunian ay maaaring hindi laging mai-bonding muli, at hindi mo lang mai-mutate ang bagay. Upang gawing prangka ang mga bagay, isa-isang nating unawain.

Dumaan Sa Sanggunian

Una sa lahat, dapat mong maunawaan na ang variable na 'mylist' mismo ay hindi isang listahan ngunit tumutukoy sa isang listahan na mayroong mga halaga. Maaari mong tawagan ang variable na 'mylist' isang lalagyan na mayroong mga halaga sa loob nito. Ang mga halaga ng listahan ay mga bagay. Ang variable na 'mylist' ay tuwid na naihatid sa pagpapaandar kasama ang mga nilalaman nito.

Ang parehong listahan at ang aking listahan ay tila magkakaibang variable ng imbakan sa halimbawa ng code sa ibaba at sa gayon ay nalalapat sa parehong bagay ng imbakan. Iyon ang dahilan kung bakit sa output, naka-print ito ng 'Saeed.'

Ang anumang pagkilos na ginawa sa variable o entity ay agad na makikita sa paraan ng tumatawag. Maaaring ganap na baguhin ng pamamaraan ang halaga ng variable at i-target ito sa isang buong natatanging object. Tulad ng nakikita mo sa pagpapaandar na ‘set_list,’ binago namin ang mga nilalaman ng listahan at nagpi-print ng isang bagong listahan na mayroong elemento na ‘Aqsa.’ Ito ay dahil naibalik namin ang binagong listahan at na-print ito sa parehong linya ng tumatawag.

Maaari ding i-reallocate ng pamamaraan ang mga elemento ng variable para sa parehong resulta tulad ng nasa ibaba. Maaari mong makita na naidagdag namin ang isang bagong halaga sa listahan, at ang pagbabago ay nasasalamin. Nagdagdag kami ng isang natatanging string sa isang listahan at ibinalik ito sa tumatawag. Upang tapusin, ang pamamaraan at ang tumatawag ay gumagamit ng parehong variable at object sa buong pass-by na ugnayan.

Dumaan sa Halaga

Sa pamamagitan ng pass by value, ang pamamaraan ay ibinibigay ng isang duplicate ng object ng argument na itinalaga ng tumatawag dito. Tinitiyak nito na ang orihinal na item ay mananatiling hindi nagbabago at lahat ng ginawang pagbabago ay napanatili sa magkakahiwalay na lokasyon ng memorya sa isang kopya ng parehong bagay.

Ito ay pantay na wasto sa anumang pagpapatakbo na naisakatuparan sa isang variable o entity ng pamamaraan. Ang mga duplicate ng mga variable at object sa saklaw ng pamamaraan ng tumatawag ay buong pinaghiwalay upang maibubuod ang mga ito.

Pass Object sa pamamagitan ng Sanggunian

Sa buong sitwasyong ito, dahil ang Python ay naiiba, ang mga pamamaraan ng Python ay nakakakuha ng katulad na sanggunian ng bagay sa imbakan na tinukoy ng tumatawag. Sa kabaligtaran, ang diskarteng hindi nakakakuha ng variable na 'mylist' (ang lalagyan). Ang pamamaraan ng tumatawag ay nag-iimbak ng parehong bagay; ang pamamaraan ay bumubuo ng isang lalagyan at bumubuo ng isang kabuuan sariwang index para sa sarili nitong, tulad ng sa pass-by-value.

Ang tumatawag at ang pamamaraan ay nagsasalita ng parehong bagay sa imbakan, ngunit kapag ang naidugtong na pamamaraan ay naglalapat ng isang panlabas na item sa isang listahan, nabago ang nilalang na tumatawag. Marami silang mga label, ngunit pareho ang mga ito. Ang parehong mga variable ay nagtataglay ng magkatulad na bagay. Iyon ang katuturan sa likuran nito kaugnay sa paglipat ng bagay. Sa imbakan, ang pamamaraan at tumatawag ay gumagamit ng isang katulad na bagay ngunit nahuhuli ang mga ito sa maraming mga variable. Ang variable ng tumatawag (ang lalagyan) ay hindi mababago ng anumang mga pagbabago na ginawa sa variable ng pamamaraan (ang lalagyan); ang data lamang o ang nilalaman ang nabago.

Konklusyon

Ang Python ay nagpapatakbo nang nakapag-iisa mula sa mga wika na tumatanggap ng paglipat ng sanggunian o halaga ng mga argumento. Ang mga argumento ng pamamaraan ay mga lokal na variable na inilaan sa bawat halagang inilipat sa pamamaraan. Ngunit hindi ka pa rin mapipigilan ng pagkuha ng parehong mga kalalabasan na mahahanap mo sa ibang mga wika habang inililipat ang mga argumento sa pamamagitan ng proxy.