Mga Function sa Python

Ang artikulong ito ay nagpapaliwanag ng mga function sa Python.

YouTube Video

Mga Function sa Python

Ang mga function sa Python ay mahalagang tampok para sa pagtukoy sa mga magagamit muli na mga bloke ng code, na nagpapahintulot sa iyo na isaayos at gawing mas simple ang iyong programa sa pamamagitan ng pagtawag sa mga ito kapag kinakailangan. Ang paggamit ng mga function ay maaaring magpabuti sa pagiging madaling mabasa ng code at sumunod sa prinsipyo ng DRY (Huwag Ulitin ang Iyong Sarili, iwasang isulat ang parehong code nang maraming beses).

Pagtukoy sa mga Function

Ang mga function ay itinatakda gamit ang keyword na def. Ang pangunahing syntax ay ganito:.

1def function_name(arg1, arg2, ..., argN):
2    """docstring (A brief description of the function)"""
3    processing
4    return return_value

Halimbawa, upang magtakda ng function na nagdadagdag ng dalawang numero, isusulat mo ito nang ganito:.

1def add(x, y):
2    """A function that adds two numbers and returns the result"""
3    return x + y

Pag-tawag ng mga Function

Ang isang itinalagang function ay maaaring tawagin at magamit nang ganito:.

1result = add(3, 4)
2print(result)  # Output: 7

Mga Bahagi ng isang Function

1. Pangalan ng Function: Ang pangalan ng function, ginagamit upang tawagin ito.

2. Mga Argumento (Parameter): Ang mga pangalan ng variable na tumatanggap ng datos na ipinapasa habang tinatawag ito. Maaari kang magtakda ng wala o higit pang mga argumento.

3. String ng Dokumentasyon (Docstring): Isang string na ginagamit upang ilarawan ang layunin at paggamit ng isang function. Opsyonal.

4. Katawan ng Function: Isang naka-indent na bloke kung saan nakasulat ang mga tagubilin na isinasagawa ng function.

5. Halaga ng Return: Ang halagang ibinabalik sa tumatawag gamit ang pahayag na return. Kung ang return ay tinanggal, ang None ang ibinabalik bilang default.

Mga Uri ng Argumento

Sa Python, may ilang uri ng mga argumento.

1. Mga Positional Argument: Ang karaniwang paraan ng pagpasa ng mga argumento sa mga function.
2. Mga Default Argument: Mga argumento na may default na halaga na maaaring hindi isama habang tinatawag.

1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"

3. Mga Argumentong May Variable na Haba: *args para tumanggap ng maraming positional arguments bilang isang tuple, at **kwargs para tumanggap ng mga ito bilang isang diksyunaryo.

1def func(*args, **kwargs):
2    print("args:", args)
3    print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}

Sa wastong paggamit ng mga function, maaari kang sumulat ng mas epektibo at episyenteng mga Python program.

Mga Lambda Function sa Python

Sa Python, ginagamit ang mga lambda function upang magtukoy ng mga anonymous at maikling function. Hindi tulad ng mga function na nakatakda gamit ang normal na keyword na def, pinapayagan ka ng lambda na lumikha ng maikli at isang-linyang function. Dito, ipapaliwanag namin nang detalyado ang mga lambda function sa Python.

Mga Pangunahing Kaalaman sa mga lambda Function

Ang mga lambda function, na tinatawag ding anonymous function, ay ginagamit upang magtukoy ng pansamantalang function na walang pangalan, tulad ng ipinapahiwatig ng pangalan. Ang pangunahing syntax ay ganito:.

1lambda arguments: expression

• arguments: Tukuyin ang mga argumento ng function. Maaaring magtukoy ng maraming argumento, na pinaghihiwalay ng mga kuwit.
• expression: Isang expression ito na sinusuri base sa mga argumento. Ang resulta ng expression ang nagiging return value ng function.

Halimbawa, ang sumusunod na code ay nagtutukoy at nagsasagawa ng isang lambda function na nagdadagdag ng dalawang numero.

1add = lambda x, y: x + y
2print(add(5, 3))  # Output: 8

Sa halimbawang ito, ang lambda x, y: x + y ay isang lambda function na tumatanggap ng dalawang argumento, x at y, at ibinabalik ang kanilang kabuuan.

Mga Gamit ng mga lambda Function

Ang mga lambda function ay kapaki-pakinabang sa mga sitwasyong kailangang magtukoy ng isang simpleng function agad-agad. Karaniwan itong ginagamit sa mga sumusunod na kaso:.

1. Kapag Ipinasa bilang Mga Argumento sa mga Function

   • Ito ay kapaki-pakinabang sa mga higher-order na function (mga function na tumatanggap ng iba pang function bilang argumento) kapag nagpapasa ng maiikli at pansamantalang mga function.

2. Kapag Tinutukoy ang Mga Key para sa Pag-aayos ng mga Listahan

   • Maginhawa itong gamitin sa pagtukoy ng mga pamantayan sa pag-aayos (mga key) sa mga function tulad ng sort() o sorted().

Halimbawa ng Paggamit sa mga Higher-Order Function

Mga tipikal na halimbawa ng mga higher-order function ay kinabibilangan ng map(), filter(), at reduce(). Ang mga function na ito ay tumatanggap ng ibang function bilang mga argumento at inilalapat ang mga ito sa mga sequence tulad ng mga listahan.

1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared)  # Output: [1, 4, 9, 16, 25]

Sa halimbawang ito, isang lambda function ang ipinasa sa map() function upang i-square ang bawat numero sa isang listahan.

Mga halimbawa ng paggamit ng list sorting

Minsan, maaaring gamitin ang lambda function upang magtakda ng custom na key kapag nagso-sort ng listahan. Halimbawa, ang sumusunod na code ay nagso-sort ng isang listahan ng tuples batay sa ikalawang elemento.

1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

Sa halimbawang ito, ginamit ang isang lambda function upang i-sort ang mga tuples batay sa kanilang ikalawang elemento (isang string).

filter() at lambda

Ang filter() function ay ginagamit upang salain ang mga elemento sa isang listahan (o iba pang iterable) batay sa isang tinukoy na kondisyon.

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3print(even_numbers)  # Output: [2, 4, 6, 8]

Sa halimbawang ito, ang mga even number sa isang listahan ay sinala upang makabuo ng isang bagong listahan.

lambda at reduce()

Ang reduce() function ay ginagamit upang bawasan ang isang listahan sa isang solong halaga. Ito ay madaling maipatupad gamit ang isang lambda function.

1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product)  # Output: 120

Sa halimbawang ito, ang lahat ng elemento sa listahan ay pinagsama-sama upang makabuo ng resulta.

Iwasan ang paggamit ng komplikadong lambda functions

Ang bentahe ng lambda functions ay ang kanilang pagka-maikli, ngunit nagiging mahirap basahin ang mga ito kapag ginamit sa pagpapatupad ng komplikadong lohika. Samakatuwid, angkop itong gamitin para sa mga simpleng operasyon na maaaring ipahayag sa isang linya. Para sa mga komplikadong operasyon, mas madaling basahin at alagaan ang isang function na tinukoy gamit ang def.

Halimbawa, dapat mong iwasan ang paggamit ng komplikadong lambda functions tulad ng nasa ibaba.

1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)

Sa pagkakataong ito, mas mainam gumamit ng isang function na tinukoy gamit ang def, tulad ng ipinakita sa ibaba.

1def complex_func(x, y):
2    if x > y:
3        return x * 2 + y
4    else:
5        return x + y * 2

Konklusyon

Ang lambda functions sa Python ay isang maginhawang tool para sa pagtukoy ng mga pansamantalang, maikling functions. Karaniwang ginagamit ang mga ito sa mga higher-order functions o mga operasyon sa listahan upang maikli ang pagtukoy ng mga partikular na kondisyon. Gayunpaman, ang mga lambda functions ay dapat limitado lamang sa mga simpleng gawain, at mas angkop gamitin ang def functions para sa komplikadong lohika.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video