పైథాన్‌లోని నక్షత్రం (*) ఆపరేటర్ చాలా శక్తివంతమైనది మరియు చాలా పనులు చేయగలదు. ఈ పోస్ట్‌లో, మేము దాని శక్తులను వెలికితీస్తాము. కాబట్టి, మరింత శ్రమ లేకుండా, ప్రారంభిద్దాం.
గుణకారం మరియు శక్తి
* ఆపరేటర్ రెండు సంఖ్యలను గుణించవచ్చు. మేము ఆపరాండ్‌ల మధ్య డబుల్ ఆస్టరిస్క్‌లను (**) ఉపయోగిస్తే, అది ఘాతాంక (పవర్) గణనను నిర్వహిస్తుంది. ఉదాహరణకు, 3**2 = 9, అంటే, ఇది 3ని పవర్ 2కి లెక్కిస్తుంది. వాటి ఉదాహరణలను చూద్దాం.
x = 4 y = 5 product = x*y #* as a multiplication operator power = x**3 #* to calculate power print(product, power)
అవుట్‌పుట్
20 64
పునరావృతం
పునరావృతమయ్యే (జాబితా, స్ట్రింగ్ మొదలైనవి) మరియు పూర్ణాంకం మధ్య * ఆపరేటర్‌ని ఉపయోగించినప్పుడు x , ఇది ద్వారా ఆ క్రమాన్ని పునరావృతం చేస్తుంది x-1 సార్లు. కింది ఉదాహరణను పరిగణించండి.
x = 4 lst = [2]*x #repeats 2 in the list x-1 times print(lst) string = "abc"*x #repeats abc x-1 times print(string)
అవుట్‌పుట్
[2, 2, 2, 2] abcabcabcabc
ఇటరాబుల్స్ మరియు డిక్షనరీలను అన్‌ప్యాక్ చేస్తోంది
అన్‌ప్యాకింగ్ ఆపరేటర్ * మళ్ళించదగిన దాన్ని అన్‌ప్యాక్ చేయవచ్చు. నిఘంటువుల కోసం, ** ఉపయోగించండి. చూద్దాము.
list1 = ["football", "basketball", "cricket"] list2 = ["hockey", "volleyball"] sports = [*list1, *list2] #unpacking list1 and list2 to merge them into a new list print(sports)
అవుట్‌పుట్
['football', 'basketball', 'cricket', 'hockey', 'volleyball']
మరొక ఉదాహరణను పరిగణించండి.
list1 = ["football", "basketball", "cricket"]
first, *others = list1
print("The first item:", first)
print("Rest of the items:", others)
అవుట్‌పుట్
The first item: football Rest of the items: ['basketball', 'cricket']
నిఘంటువులను ఎలా అన్‌ప్యాక్ చేయాలో చూద్దాం.
#unpacking dictionaries
dictt1 = {"name":"Ashton", "age": 25}
dictt2 = {"cpga": 4.5}
dictt = {**dictt1, **dictt2}
print(dictt)
అవుట్‌పుట్
{'name': 'Ashton', 'age': 25, 'cpga': 4.5}
ఫంక్షన్ కాల్‌లోకి ఇటరబుల్‌లను అన్‌ప్యాక్ చేస్తోంది
మేము మళ్ళించదగిన (జాబితాలు, స్ట్రింగ్) ఐటెమ్‌లను ఒక ఫంక్షన్‌కి ఆర్గ్యుమెంట్‌లుగా విడిగా పాస్ చేయాలనుకుంటే, మీరు * ఆపరేటర్‌ని ఉపయోగించి అలా చేయవచ్చు. కింది ఉదాహరణను పరిగణించండి.
name = "ashton agar"
print("The letters in the string are:", *name)
అవుట్‌పుట్
The letters in the string are: a s h t o n a g a r
వివిధ స్థాన వాదనల సంఖ్య
* ఆపరేటర్ ఒక ఫంక్షన్‌కు ఎన్ని స్థాన ఆర్గ్యుమెంట్‌లనైనా పాస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. అంతేకాకుండా, ఈ వాదనలు టుపుల్‌గా ఆమోదించబడతాయి. చూద్దాము.
def calculateAverage(*values):
n = len(values)
summ =0
for i in range(0, n):
summ += values[i]
return summ/n
avg = calculateAverage(2,6, 7, 8, 8)
print("The average is:", avg)
లీగ్ ఆఫ్ లెజెండ్స్ ప్యాచ్ 4.20
అవుట్‌పుట్
The average is: 6.2
పై ఉదాహరణలో, దానికి పంపబడిన సంఖ్యల సగటును లెక్కించడానికి మేము ఒక ఫంక్షన్‌ను సృష్టిస్తాము. మేము దీనికి ఆమోదించిన వాదనలను పరిమితం చేయడం లేదని మీరు ఇక్కడ గమనించవచ్చు. మేము ఆస్టరిస్క్ ఆపరేటర్‌ని ఉపయోగించి చేస్తాము.
కీవర్డ్ ఆర్గ్యుమెంట్‌ల సంఖ్య మారుతోంది
* ఆపరేటర్ ఎన్ని స్థాన ఆర్గ్యుమెంట్‌లనైనా పాస్ చేయడానికి అనుమతిస్తుంది, ** ఆపరేటర్ కీవర్డ్ ఆర్గ్యుమెంట్‌ల వేరియబుల్ నంబర్‌ను పాస్ చేయడానికి ఉపయోగించవచ్చు. చూద్దాము.
def test(**info): print(info) test(name="Ashton", age=3)
అవుట్‌పుట్
{'name': 'Ashton', 'age': 3}
కీవర్డ్-మాత్రమే పరామితి
మీరు మీ ఫంక్షన్‌లో కీవర్డ్-మాత్రమే పరామితిని కలిగి ఉండాలనుకుంటే, మీరు దీన్ని చేయడానికి *ని ఉపయోగించవచ్చు. ఎలాగో చూడడానికి క్రింది ఉదాహరణను పరిశీలించండి.
def test(name, age, *, grade):
print(name, age, grade)
test("ashton", 18, grade=9)
అవుట్‌పుట్
ashton 18 9
పై ఉదాహరణలో, ది పరీక్ష() ఫంక్షన్ మూడు వాదనలను తీసుకుంటుంది. వేరియబుల్స్ పేరు మరియు వయస్సు స్థానాలు ఉన్నాయి, కానీ గ్రేడ్ కీవర్డ్-మాత్రమే వాదన.
def test(name, age, *, grade):
print(name, age, grade)
test("ashton", 18, 9)
అవుట్‌పుట్
పైథాన్‌లో ఏమి చేస్తుంది?
మీరు చూడగలిగినట్లుగా, మీరు కీవర్డ్ ఆర్గ్యుమెంట్‌ను సరిగ్గా పాస్ చేయనప్పుడు మీకు లోపం వస్తుంది.
* ఆపరేటర్‌కి చాలా అర్థాలు ఉన్నాయని మనం చూశాము. కాబట్టి, దీన్ని బాగా అర్థం చేసుకోవడానికి దానితో ఆడుకోమని నేను మిమ్మల్ని ప్రోత్సహిస్తాను.