Mundo ng Python Programming

Argumento ng Python: Positional, Keyword, *args, **kwargs

Mga Function, Klase, at Estruktura
目次

1. Ano ang mga argumento sa Python?

Sa Python, ang mga argumento ay paraan kung saan tumatanggap ang mga function at method ng data mula sa labas upang magsagawa ng tiyak na proseso. Sa pamamagitan ng pagpapasa ng mga argumento sa function, nagiging flexible ang pagproseso ng data, at napapabuti ang muling paggamit at extensibility ng programa. Sa artikulong ito, tatalakayin natin ang mga batayan hanggang sa mga advanced na konsepto ng mga argumento sa Python, hakbang-hakbang.

Pangunahing Gampanin ng mga Function at Argumento

Ang mga function ay koleksyon ng mga utos na nagsasagawa ng tiyak na gawain. Ang mga argumento ay input data na ipinapasa sa function, at ginagamit tulad ng sumusunod.
def greet(name):
    print(f"Kumusta, {name}！")
Sa halimbawang ito, sa pamamagitan ng pagpapasa ng anumang pangalan sa argumento name, maaaring magpakita ng indibidwal na mensahe.
greet("佐川")  # Output: Kumusta, 佐川！

2. Mga Pangunahing Argumento sa Python

Susunod, titingnan natin kung paano gamitin ang mga argumento sa Python mula sa pananaw ng positional arguments, keyword arguments, at default arguments.

Positional Arguments at ang Kahalagahan Nito

Ang positional arguments ay ipinapasa sa mga parameter ng function ayon sa pagkakasunod-sunod ng mga argumentong ibinigay kapag tinawag ang function.
def add(a, b):
    return a + b

result = add(5, 3)  # Resulta: 8

Paggamit ng Keyword Arguments

Sa paggamit ng keyword arguments, hindi mo na kailangang alalahanin ang pagkakasunod-sunod ng mga argumento; maaari mong tahasang ipasa ang mga halaga sa function.
def introduce(name, age):
    print(f"Ako si {name}. Ang edad ay {age} taon.")

introduce(age=25, name="Sagawa")  # Output: Ako si Sagawa. Ang edad ay 25 taon.

Paggamit ng Default Arguments

Sa pamamagitan ng pagtatakda ng default arguments, maaaring gamitin ang default na halaga kapag ang argumento ay hindi ibinigay.
def greet(name="Guest"):
    print(f"Kumusta, {name}!")

greet()  # Output: Kumusta, Guest!

Pagkakasunud-sunod ng mga Argumento

Kapag sabay na ginagamit ang positional at keyword arguments, kailangang ilista muna ang positional arguments at sundan ng keyword arguments. Kung mali ang pagkakasunod-sunod, magdudulot ito ng error.
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

3. Variable-length arguments ng Python (*args at **kwargs)

Paggamit ng *args

*args ay ginagamit upang ipasa ang anumang bilang ng positional arguments sa isang function. Dahil dito, maaaring gawing mas generic ang function.
def print_numbers(*args):
    for number in args:
        print(number)

print_numbers(1, 2, 3)

Paggamit ng **kwargs

**kwargs ay nagbibigay-daan upang tumanggap ng anumang keyword arguments sa anyo ng dictionary.
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Sagawa", age=30, job="Manunulat")

Pagsasama ng *args at **kwargs

Sa pamamagitan ng pagsasama ng *args at **kwargs, maaari kang lumikha ng flexible na function na tumatanggap ng parehong positional at keyword arguments.
def process_data(*args, **kwargs):
    total = sum(args)
    print(f"Kabuuan: {total}")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

process_data(1, 2, 3, name="Sagawa", age=30)

4. Pag-aaplay at Halimbawa ng Paggamit ng Argumento

Praktikal na Halimbawa ng Pag-aaplay: Pagproseso ng mga Parameter ng API

Sa pagtawag ng API, kailangan mong iproseso ang mga dynamic na parameter. *args at **kwargs gamit, maaaring mong flexible na pamahalaan ang maraming parameter.
def api_call(endpoint, **params):
    print(f"API endpoint: {endpoint}")
    for key, value in params.items():
        print(f"{key}: {value}")

api_call("/user", id=123, action="view")

Pag-aaplay sa Malawakang Pagproseso ng Data

Kahit sa mga function na nagpoproseso ng napakalaking data, maaari mong gamitin ang *args upang epektibong pamahalaan ang variable-length na mga argumento.
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

5. Paghawak ng Error at Pagpapatunay ng Argumento

Paghawak ng Error para sa Bilang ng mga Argumento

Kung kulang ang bilang ng mga argumentong inaasahan ng function, maaaring maiwasan ang pag-crash ng programa sa pamamagitan ng paghawak ng error.
def add_numbers(*args):
    if len(args) < 2:
        raise ValueError("Kailangan ng hindi bababa sa 2 na argumento")
    return sum(args[:2])

Pagpapatunay ng Uri

Sa pamamagitan ng pagsuri sa uri ng mga argumento, maaaring maiwasan ang hindi inaahang mga error.
def multiply(a, b):
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
        raise TypeError("Ang mga argumento ay dapat na numero")
    return a * b

Paghawak ng Error gamit ang try-except

Sa pamamagitan ng paggamit ng try-except na syntax, maaaring mahuli ang mga error at maproseso nang tama.
def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        return "Hindi maaaring hatiin sa 0"
    except TypeError:
        return "Mangyaring maglagay ng numero"
    return result

6. Buod

Sa pamamagitan ng artikulong ito, tinakpan namin ang mga batayan hanggang sa mga advanced na aspeto ng mga argumento sa Python. Lalo naming binigyang-diin ang mga paraan ng flexible na pagdeklara ng function gamit ang *args at **kwargs, pati na rin ang kahalagahan ng error handling at validation.

Mga pangunahing punto:

  • Mga batayan ng positional arguments, keyword arguments, at default arguments
  • Flexible na pagdeklara ng function gamit ang *args at **kwargs
  • Kahalagahan ng error handling at validation para sa mga argumento
Sa pamamagitan ng kaalamang ito, magagawa mong lumikha ng flexible at matibay na Python code na magagamit sa praktikal na trabaho.
年収訴求