Mundo ng Python Programming

Masterin ang def function ng Python: Buong Gabay

Mga Function, Klase, at Estruktura
目次

1. Ano ang def sa Python

Ang keyword na def sa Python ay ginagamit upang magdeklara ng mga function. Ang mga function ay mga pangunahing istruktura na nagpapahusay sa muling paggamit ng code at tumutulong upang maging mas organisado ang programa. Sa paggamit ng def, makakagawa ka ng isang bloke na naglalaman ng isang tiyak na gawain at magagamit ito nang paulit-ulit. Dahil dito, nagiging mas madaling basahin ang code at nababawasan ang posibilidad ng mga bug.

Pangunahing sintaks ng keyword na def

Ang pangunahing sintaks ay ganito:
def pangalanNgFunction(argumento1, argumento2, ...):
    proseso
    return ibinabalik na halaga
Pagkatapos ng def, isulat ang pangalan ng function at tukuyin ang mga kailangang argumento sa loob ng panaklong. Pagkatapos, sa isang naka-indent na bloke matapos ang colon, isulat ang nilalaman ng proseso. Kung kinakailangan, maaari kang magbalik ng halaga gamit ang pahayag na return.

2. Pangunahing sintaks at paraan ng paggamit ng def

Pangunahing paraan ng pagdeklara ng function

Kapag tinutukoy ang function gamit ang keyword na def, isinusulat mo ang pangalan ng function, ang listahan ng mga argumento, at ang nilalaman ng proseso. Halimbawa, ang sumusunod na code ay isang simpleng function na nagpi-print ng “Hello, World!”.
def say_hello():
    print("Hello, World!")
Ang function na ito, kapag tinawag gamit ang say_hello(), magpapakita ng “Hello, World!” sa console.

Kahalagahan ng indentasyon

Sa Python, napakahalaga ng indentasyon. Lahat ng code na nakasulat sa loob ng function ay kailangang nasa parehong antas ng indentasyon. Dahil ginagamit ang indentasyon upang pag-iba-ibahin ang mga antas at mga bloke ng code, ang maling indentasyon ay nagiging sanhi ng mga error.

Pagtawag ng function

Ang naideklarang function ay tinatawag sa pamamagitan ng paglalagay ng mga panaklong sa pangalan nito. Kung may mga argumento, ilagay ang mga ito sa loob ng mga panaklong.
say_hello()

3. Mga argumento ng function at mga default na halaga

Mga positional at keyword na argumento

Ang isang function ay maaaring tumanggap ng mga argumento, at nahahati ang mga ito sa mga positional na argumento at mga keyword na argumento. Ang mga positional na argumento ay ipinapasa ayon sa pagkakasunod-sunod, at pinoproseso ayon sa ayos na itinukoy kapag tinawag ang function. Ang mga keyword na argumento ay tinutukoy sa pamamagitan ng pangalan, at maaaring ipasa nang hindi alintana ang pagkakasunod-sunod kapag tinatawag ang function.
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")
Sa function sa itaas, may default na halaga na itinakda para sa greeting, at kapag tinawag ang greet("Alice"), maglalabas ito ng “Hello, Alice!”.

Mga argumentong may pabagu-bagong bilang

Minsan, kailangang tumanggap ang isang function ng hindi nakapirming bilang ng mga argumento. Sa Python, maaaring gamitin ang *args at **kwargs upang magpasa ng mga argumentong may pabagu-bagong bilang.
def print_args(*args):
    for arg in args:
        print(arg)

print_args(1, 2, 3)
Sa halimbawang ito, tinatanggap ng *args ang lahat ng argumento bilang isang tuple.

4. Magbalik ng halaga gamit ang return statement

Paano gamitin ang return statement

Kapag gusto mong ibalik ang halagang nakalkula sa isang function, gamitin ang return statement. Kung walang return statement, ang function ay magbabalik ng None bilang default.
def add(a, b):
    return a + b

result = add(3, 4)
print(result)  # 7
Ang function na add ay nagbabalik ng kabuuan ng dalawang numero. Sa pamamagitan ng return statement, maaari kang magbalik ng isang halaga mula sa function at iimbak ito sa isang variable.

Pagbabalik ng maraming halaga

Sa Python, posible ring magbalik ang isang function ng maraming halaga. Sa pamamagitan ng pagbabalik na pinaghihiwalay ng kuwit, maibabalik ang mga ito nang magkakasama bilang isang tuple.
def swap(a, b):
    return b, a

x, y = swap(1, 2)
print(x, y)  # 2 1
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

5. Saklaw at tagal ng buhay ng mga variable

Lokal na variable at global na variable

Ang mga variable na tinukoy sa loob ng isang function ay tinatawag na mga lokal na variable at magagamit lamang sa loob ng function na iyon. Ang mga variable na tinukoy sa labas ng function ay tinatawag na mga global na variable at magagamit sa buong programa.
x = "global"

def func():
    x = "local"
    print(x)

func()      # local
print(x)    # global
Sa halimbawang ito, ang x na tinukoy sa loob ng function na func ay isang lokal na variable at hindi nakaaapekto sa labas ng function.

Ang salitang-susi na global

Kung nais mong baguhin ang isang global na variable mula sa loob ng function, gamitin ang salitang-susi na global.
x = "global"

def change_global():
    global x
    x = "changed"

change_global()
print(x)  # changed

6. Mga praktikal na halimbawa at paraan ng paggamit

Pagpapahusay ng episyensya ng programa gamit ang mga function

Sa paggamit ng mga function, maaari mong lubos na mapahusay ang episyensya ng programa. Halimbawa, sa pamamagitan ng pagsasama-sama ng mga kalkulasyong paulit-ulit at pagproseso ng data sa mga function, maiiwasan mo ang pagdodoble ng code.
def calculate_area(radius):
    return 3.14 * radius * radius

area1 = calculate_area(5)
area2 = calculate_area(10)
Sa halimbawang ito, nagtatakda tayo ng function na calculate_area para kalkulahin ang lawak ng bilog, at maaari itong gamitin nang paulit-ulit ayon sa pangangailangan。

Mga halimbawa ng paggamit ng function

Bilang isa pang halimbawa, lilikha tayo ng function para mag-format ng teksto。
def format_text(text, alignment="left"):
    if alignment == "left":
        return text.ljust(20)
    elif alignment == "right":
        return text.rjust(20)
    elif alignment == "center":
        return text.center(20)

print(format_text("Hello", "center"))
Ifo-format ng function na ito ang teksto sa alinman sa kaliwa, kanan, o gitna。

7. Mga advanced na konsepto ng function

Mga nested na function

Sa Python, maaari kang magdeklara ng isa pang function sa loob ng isang function. Ito ay tinatawag na nested na function. Ang nested na function ay maa-access lamang sa loob ng panlabas na function.
def outer():
    def inner():
        print("This is the inner function")
    inner()

Anonymous na function（Lambda）

Sa paggamit ng keyword na lambda, maaari kang lumikha ng function na walang pangalan (anonymous na function). Mainam ito para sa paglikha ng mga simpleng function na gagamitin nang isang beses lang.
square = lambda x: x * x
print(square(5))  # 25

Decorator

Ang decorator ay isang paraan para palawigin ang kakayahan ng isang umiiral na function nang hindi ito binabago. Ito ay tinutukoy bilang isang function na tumatanggap ng function bilang argumento at nagbabalik ng bagong function.
def decorator(func):
    def wrapper():
        print("Before the function")
        func()
        print("After the function")
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()

8. Buod

Sa artikulong ito, tinalakay namin nang malawakan mula sa kung paano magdeklara ng mga function gamit ang keyword na def sa Python, hanggang sa mga argumento, mga ibinabalik na halaga, saklaw, at maging ang mas advanced na mga tampok. Sa paggamit ng mga function, maaari mong buuin ang programa nang mas episyente at mas organisado. Gawing sanggunian ang artikulong ito upang lumikha ng iba’t ibang function at paunlarin ang iyong kasanayan sa Python programming.

9. Mga Madalas Itanong (FAQs)

Ano ang pagkakaiba ng return at print?

return at print ay mukhang magkapareho, ngunit magkaiba ang kanilang mga tungkulin. Ang return ay nagbabalik ng isang halaga mula sa function upang magamit pa ito sa ibang bahagi ng programa. Halimbawa, ibinabalik nito ang resulta ng pagkalkula at itinatakda iyon sa ibang variable. Samantala, ang print ay nagpapakita lamang ng output ng function sa console, at hindi magagamit ang halagang iyon sa iba pang bahagi ng programa.
def add(a, b):
    return a + b

result = add(3, 4)  # 7 ang laman ng result
print(result)  # 7

def display_message():
    print("Hello, World!")

display_message()  # Hello, World! ang ipapakita sa console, ngunit walang ibinabalik na halaga

Ano ang pakinabang ng paggamit ng nested na mga function?

Ang paggamit ng nested na mga function ay nagbibigay-daan sa paglikha ng lokal na function na hindi maa-access mula sa labas, kaya nakakatulong sa pagkakapsula at muling paggamit ng code. Bukod dito, dahil may access ito sa saklaw ng panlabas na function, nakakatulong itong gumawa ng mga function na nakatuon lamang sa tiyak na proseso.

Kailan dapat gamitin ang mga argumentong may nababagong bilang?

Gumamit ng mga argumentong may nababagong bilang kapag hindi tiyak ang dami ng argumentong ipapasa sa function. Halimbawa, para matugunan ang mga sitwasyong nagbabago ang dami ng input, tulad ng isang function na nagkakalkula ng kabuuan ng kahit ilang numero.
def add_all(*args):
    return sum(args)

result = add_all(1, 2, 3, 4, 5)  # 15

Paano ginagamit ang recursive na pagtawag ng function?

Ang recursive na function ay tumutukoy sa function na tumatawag sa sarili nito. Ginagamit ito para malutas ang ilang problema nang maikli at malinaw, ngunit kung hindi ito gagamitin nang maingat, maaari itong magdulot ng stack overflow. Halimbawa, ginagamit ito sa pagkalkula ng factorial.
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

result = factorial(5)  # 120
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール