పైథాన్‌లో ఫంక్షన్ ఆర్గ్యుమెంట్‌లుగా జాబితాలు, టుపుల్స్ మరియు డిక్షనరీలను విస్తరించడం మరియు పాస్ చేయడం

పైథాన్‌లో, జాబితాలు (శ్రేణులు), టుపుల్‌లు మరియు నిఘంటువులను విస్తరించవచ్చు (అన్ ప్యాక్ చేయబడి) మరియు వాటి సంబంధిత మూలకాలను కలిసి ఫంక్షన్ ఆర్గ్యుమెంట్‌లుగా పంపవచ్చు.

ఫంక్షన్‌కు కాల్ చేస్తున్నప్పుడు, జాబితాలు మరియు టుపుల్స్ కోసం ** మరియు నిఘంటువుల కోసం **తో ఆర్గ్యుమెంట్‌ని పేర్కొనండి. ఆస్టరిస్క్‌ల సంఖ్యను గమనించండి*.

కింది వివరాలు ఇక్కడ వివరించబడ్డాయి.

• * (ఒక నక్షత్రం)తో జాబితా లేదా టుపుల్‌ని విస్తరించండి (అన్ప్యాక్ చేయండి)
  • డిఫాల్ట్ ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం
  • వేరియబుల్-పొడవు ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం
• ** (రెండు నక్షత్రాలు)తో నిఘంటువును విస్తరించండి (అన్ప్యాక్ చేయండి)
  • డిఫాల్ట్ ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం
  • వేరియబుల్-పొడవు ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం

పైథాన్ ఫంక్షన్‌లు, డిఫాల్ట్ ఆర్గ్యుమెంట్‌లు మరియు ఫంక్షన్‌లను నిర్వచించేటప్పుడు *,**తో వేరియబుల్ లెంగ్త్ ఆర్గ్యుమెంట్‌ల ప్రాథమిక వినియోగం కోసం క్రింది కథనాన్ని చూడండి.

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

* (ఒక నక్షత్రం)తో జాబితా లేదా టుపుల్‌ని విస్తరించండి (అన్ప్యాక్ చేయండి)

జాబితా లేదా టుపుల్ *తో ఆర్గ్యుమెంట్‌గా పేర్కొనబడినప్పుడు, అది విస్తరించబడుతుంది మరియు ప్రతి మూలకం ప్రత్యేక ఆర్గ్యుమెంట్‌గా పాస్ చేయబడుతుంది.

def func(arg1, arg2, arg3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

l = ['one', 'two', 'three']

func(*l)
# arg1 = one
# arg2 = two
# arg3 = three

func(*['one', 'two', 'three'])
# arg1 = one
# arg2 = two
# arg3 = three

t = ('one', 'two', 'three')

func(*t)
# arg1 = one
# arg2 = two
# arg3 = three

func(*('one', 'two', 'three'))
# arg1 = one
# arg2 = two
# arg3 = three

కింది వివరణ జాబితా కోసం, కానీ అదే టుపుల్‌కు వర్తిస్తుంది.

మూలకాల సంఖ్య ఆర్గ్యుమెంట్‌ల సంఖ్యతో సరిపోలకపోతే, TypeError ఎర్రర్ ఏర్పడుతుంది.

# func(*['one', 'two'])
# TypeError: func() missing 1 required positional argument: 'arg3'

# func(*['one', 'two', 'three', 'four'])
# TypeError: func() takes 3 positional arguments but 4 were given

డిఫాల్ట్ ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం

డిఫాల్ట్ ఆర్గ్యుమెంట్ సెట్ చేయబడితే, మూలకాల సంఖ్య సరిపోకపోతే డిఫాల్ట్ ఆర్గ్యుమెంట్ ఉపయోగించబడుతుంది. మూలకాల సంఖ్య చాలా పెద్దగా ఉంటే, టైప్‌ఎర్రర్ లోపం ఏర్పడుతుంది.

def func_default(arg1=1, arg2=2, arg3=3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

func_default(*['one', 'two'])
# arg1 = one
# arg2 = two
# arg3 = 3

func_default(*['one'])
# arg1 = one
# arg2 = 2
# arg3 = 3

# func_default(*['one', 'two', 'three', 'four'])
# TypeError: func_default() takes from 0 to 3 positional arguments but 4 were given

వేరియబుల్-పొడవు ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం

వేరియబుల్-లెంగ్త్ ఆర్గ్యుమెంట్ సెట్ చేయబడితే, స్థాన ఆర్గ్యుమెంట్ కోసం మూలకం తర్వాత అన్ని మూలకాలు వేరియబుల్-లెంగ్త్ ఆర్గ్యుమెంట్‌కి పంపబడతాయి.

def func_args(arg1, *args):
    print('arg1 =', arg1)
    print('args =', args)

func_args(*['one', 'two'])
# arg1 = one
# args = ('two',)

func_args(*['one', 'two', 'three'])
# arg1 = one
# args = ('two', 'three')

func_args(*['one', 'two', 'three', 'four'])
# arg1 = one
# args = ('two', 'three', 'four')

** (రెండు నక్షత్రాలు)తో నిఘంటువును విస్తరించండి (అన్ప్యాక్ చేయండి)

డిక్షనరీ డిక్ట్‌ని **తో ఆర్గ్యుమెంట్‌గా పేర్కొన్నప్పుడు, ఎలిమెంట్ కీలు ఆర్గ్యుమెంట్ పేర్లుగా మరియు విలువలు ఆర్గ్యుమెంట్ విలువలుగా విస్తరించబడతాయి మరియు ప్రతి ఒక్కటి ప్రత్యేక ఆర్గ్యుమెంట్‌గా పాస్ చేయబడతాయి.

def func(arg1, arg2, arg3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

d = {'arg1': 'one', 'arg2': 'two', 'arg3': 'three'}

func(**d)
# arg1 = one
# arg2 = two
# arg3 = three

func(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three'})
# arg1 = one
# arg2 = two
# arg3 = three

ఆర్గ్యుమెంట్ పేరుకు సరిపోలే కీ ఏదీ లేకుంటే లేదా సరిపోలని కీ ఉంటే, TypeError ఎర్రర్ ఏర్పడుతుంది.

# func(**{'arg1': 'one', 'arg2': 'two'})
# TypeError: func() missing 1 required positional argument: 'arg3'

# func(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three', 'arg4': 'four'})
# TypeError: func() got an unexpected keyword argument 'arg4'

డిఫాల్ట్ ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం

డిక్షనరీలోని కీలకు సరిపోలే ఆర్గ్యుమెంట్ పేర్ల విలువలు మాత్రమే నవీకరించబడిన చిత్రం.

ఆర్గ్యుమెంట్ పేరుతో సరిపోలని కీ TypeError ఎర్రర్‌కు దారి తీస్తుంది.

def func_default(arg1=1, arg2=2, arg3=3):
    print('arg1 =', arg1)
    print('arg2 =', arg2)
    print('arg3 =', arg3)

func_default(**{'arg1': 'one'})
# arg1 = one
# arg2 = 2
# arg3 = 3

func_default(**{'arg2': 'two', 'arg3': 'three'})
# arg1 = 1
# arg2 = two
# arg3 = three

# func_default(**{'arg1': 'one', 'arg4': 'four'})
# TypeError: func_default() got an unexpected keyword argument 'arg4'

వేరియబుల్-పొడవు ఆర్గ్యుమెంట్‌లతో ఫంక్షన్‌ల కోసం

వేరియబుల్-పొడవు ఆర్గ్యుమెంట్‌లు సెట్ చేయబడితే, ఆర్గ్యుమెంట్‌గా పేర్కొనబడిన ఆర్గ్యుమెంట్ పేరు కాకుండా ఇతర కీ ఉన్న ఏదైనా మూలకం వేరియబుల్-లెంగ్త్ ఆర్గ్యుమెంట్‌కి పంపబడుతుంది.

def func_kwargs(arg1, **kwargs):
    print('arg1 =', arg1)
    print('kwargs =', kwargs)

func_kwargs(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three'})
# arg1 = one
# kwargs = {'arg2': 'two', 'arg3': 'three'}

func_kwargs(**{'arg1': 'one', 'arg2': 'two', 'arg3': 'three', 'arg4': 'four'})
# arg1 = one
# kwargs = {'arg2': 'two', 'arg3': 'three', 'arg4': 'four'}

func_kwargs(**{'arg1': 'one', 'arg3': 'three'})
# arg1 = one
# kwargs = {'arg3': 'three'}