ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 5 · 4లో పాఠం 3కోర్సులో 19/36~12 min
మాడ్యూల్ పాఠాలు (3/4)

* args మరియు ** kwargs

కొన్నిసార్లు మీరు వేరియబుల్ నంబర్ని ఆమోదించే ఫంక్షన్ కావాలి వాదనలు. పైథాన్ మీకు రెండు సాధనాలను అందిస్తుంది: *args (స్థాన వాదనలను సేకరిస్తుంది టుపుల్‌లోకి) మరియు **kwargs (కీవర్డ్ ఆర్గ్యుమెంట్‌లను డిక్ట్‌గా సేకరిస్తుంది).

*args: వేరియబుల్ పొజిషనల్ ఆర్గ్యుమెంట్‌లు

Python
def somma_tutto(*nums):
    totale = 0
    for n in nums:
        totale += n
    return totale

somma_tutto(1, 2, 3)         # 6
somma_tutto(1, 2, 3, 4, 5)   # 15
somma_tutto()                # 0

ఫంక్షన్ లోపల, nums అనేది అన్ని విలువలతో కూడిన టుపుల్. ది పేరు కేవలం ఒక కన్వెన్షన్: *args అత్యంత సాధారణమైనది, కానీ *nums లేదా *valori ఖచ్చితంగా చెల్లుతుంది.

**kwargs: వేరియబుల్ కీవర్డ్ ఆర్గ్యుమెంట్‌లు

Python
def crea_config(**opzioni):
    return opzioni

crea_config(debug=True, port=8080)
# {'debug': True, 'port': 8080}

ఫంక్షన్ లోపల, opzioni అనేది {param_name: value}తో డిక్ట్.

ప్రతిదీ కలపడం

స్థిరమైన క్రమం: ** సాధారణ పారామితులు, * args, డిఫాల్ట్ పారామితులు, **kwargs**.

Python
def f(primo, *args, opzione="x", **kwargs):
    print(primo, args, opzione, kwargs)

f(1, 2, 3, opzione="y", extra=10)
# 1 (2, 3) y {'extra': 10}

కాల్‌లో అన్‌ప్యాక్ చేస్తోంది: * మరియు **

అదే ఆపరేటర్ మరో విధంగా పని చేస్తాడు: జాబితా/టుపుల్‌ను "పేలుడు" చేయడానికి స్థాన ఆర్గ్యుమెంట్‌లలోకి లేదా కీవర్డ్ ఆర్గ్యుమెంట్‌లలోకి డిక్ట్.

Python
def punto(x, y, z):
    return (x, y, z)

coords = [1, 2, 3]
punto(*coords)        # punto(1, 2, 3)  →  (1, 2, 3)

opts = {"x": 1, "y": 2, "z": 3}
punto(**opts)         # punto(x=1, y=2, z=3)

రేపర్ నమూనా

Python
def log_chiamata(fn, *args, **kwargs):
    print(f"chiamo {fn.__name__} con {args=} {kwargs=}")
    return fn(*args, **kwargs)

log_chiamata(max, 3, 1, 2)             # calls max(3, 1, 2)
log_chiamata(sorted, [3, 1, 2], reverse=True)

ఫంక్షన్ సంతకాలలో పారామీటర్ క్రమం

బహుళ ఆర్గ్యుమెంట్ రకాలను ఆమోదించే ఫంక్షన్‌ను నిర్వచించేటప్పుడు, మీరు తప్పనిసరిగా సంతకంలో ఖచ్చితమైన క్రమానికి కట్టుబడి ఉండాలి:

  1. ప్రామాణిక స్థాన పారామితులు.
  2. స్థాన varargs *args.
  3. డిఫాల్ట్ విలువలతో కీవర్డ్ పారామితులు.
  4. కీవర్డ్ varargs **kwargs.

దీనిని ప్రయత్నించండి

వ్యాయామం#python.m5.l3.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

అంకగణిత సగటు (మొత్తం / గణన)ని అందించే `సగటు(*సంఖ్యలు)`ని నిర్వచించండి. దీన్ని 10, 20, 30తో కాల్ చేసి, ఫలితాన్ని `m`కి కేటాయించండి. `m`ని మూల్యాంకనం చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

మొత్తం(సంఖ్యలు) / లెన్(సంఖ్యలు)

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం సమీక్షించండి

వ్యాయామం#python.m5.l3.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

`def point(x, y, z): రిటర్న్ x + y + z` మరియు డిక్ట్ `కోర్డ్స్ = {'x': 1, 'y': 2, 'z': 3}` ఫంక్షన్ ఇచ్చినట్లయితే, కాల్ పాయింట్ అన్‌ప్యాకింగ్ కోర్డ్స్ మరియు ఫలితాన్ని `s`కి కేటాయించండి. `s` మూల్యాంకనం చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

పాయింట్ (** కోర్డ్స్)

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

అదనపు సవాలు

వ్యాయామం#python.m5.l3.e3
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

Write a function `multiply_all(*args)` that returns the product of all numbers passed as arguments. If no arguments are passed, it should return `1`. Finally, evaluate the call `multiply_all(2, 3, 4)`.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

ఆర్గ్‌లలోని మూలకాలపై మళ్ళించడానికి మరియు వాటి ఉత్పత్తిని కూడబెట్టడానికి a for loopని ఉపయోగించండి.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది