పైథాన్‌లో జాబితాలను ఎలా కలపాలి

ఉదాహరణ 1: “+” ఆపరేటర్‌తో జాబితాలను సంగ్రహించడం

మేము జాబితాలను సంగ్రహించడానికి పైథాన్‌లోని “+” ఆపరేటర్‌ని ఉపయోగించవచ్చు. “+” ఆపరేటర్‌ని ఉపయోగించి, మీరు కొత్త జాబితాను రూపొందించడానికి రెండు లేదా అంతకంటే ఎక్కువ జాబితాలలో చేరవచ్చు. మీరు జాబితాలతో “+” ఆపరేటర్‌ని ఉపయోగించినప్పుడు, కొత్త జాబితా సృష్టించబడుతుంది మరియు అసలు జాబితాల మూలకాలు అవి కనిపించే క్రమంలో కొత్త జాబితాకు కాపీ చేయబడతాయి.

ఇక్కడ ఒక సాధారణ ఉదాహరణ:

ఈ ఉదాహరణలో మాకు రెండు జాబితాలు ఉన్నాయి: “list1” మరియు “list2”. మేము వాటిని ఒకే జాబితాలోకి చేర్చడానికి '+' ఆపరేటర్‌ని ఉపయోగిస్తాము. జాబితాలతో ఉపయోగించినప్పుడు, '+' ఆపరేటర్ వాటిని కలుస్తుంది అంటే అది రెండవ జాబితాలోని మూలకాలను మొదటి దాని చివరి వరకు కలుపుతుంది. కాబట్టి, “ఫలితం_జాబితా = జాబితా1 + జాబితా2″ని అమలు చేసిన తర్వాత, “ఫలితం_జాబితా” “లిస్ట్1” మరియు “లిస్ట్2” రెండింటిలోని ఎలిమెంట్‌లను అవి సంగ్రహించిన క్రమంలో కలిగి ఉంటుంది.

ఈ పద్ధతి క్లుప్తంగా ఉన్నప్పటికీ, ఇది కాపీని సృష్టించే ఓవర్‌హెడ్ కారణంగా పెద్ద జాబితాల కోసం సమర్థవంతంగా పని చేయని కొత్త జాబితాను సృష్టిస్తుందని గుర్తుంచుకోండి.

ఉదాహరణ 2: పొడిగింపు() పద్ధతిని ఉపయోగించడం

విస్తరించదగిన() పద్ధతిని ఉపయోగించి ఇప్పటికే ఉన్న జాబితా చివరకి మళ్ళించదగిన అంశాలు జోడించబడతాయి. ఇది కొత్త జాబితాను సృష్టించే “+” ఆపరేటర్‌లా కాకుండా అసలు జాబితాను స్థానంలో మారుస్తుంది.

మేము ఒక తరగతిలో విద్యార్థుల జాబితాను కలిగి ఉన్నామని అనుకుందాం మరియు మేము ఈ జాబితాను పొడిగించాలనుకుంటున్నాము మరియు ఇటీవలే పొడిగింపు() పద్ధతిని ఉపయోగించి చేరిన కొత్త విద్యార్థుల పేర్లను జోడించాలనుకుంటున్నాము. మీరు దాని గురించి ఎలా వెళ్లవచ్చో ఇక్కడ ఉంది:

ఈ ఉదాహరణలో, “తరగతి_విద్యార్థులు” అసలు జాబితా ఇప్పటికే ఉన్న విద్యార్థుల పేర్లను కలిగి ఉంటుంది. 'కొత్త_విద్యార్థులు' జాబితాలో ఇటీవల తరగతిలో చేరిన విద్యార్థుల పేర్లు ఉన్నాయి. పొడిగింపు() పద్ధతిని వర్తింపజేయడం ద్వారా, మేము కొత్త విద్యార్థుల పేర్లను అసలు జాబితా చివరకి జోడిస్తాము.

ఉదాహరణ 3: సంయోగం కోసం “+=” ఆపరేటర్‌ని వర్తింపజేయడం

“+=” ఆపరేటర్ పొడిగింపు() పద్ధతికి సంక్షిప్తలిపి. ఇది కుడి-చేతి జాబితా యొక్క మూలకాలను ఎడమ చేతి జాబితాలోకి కలుపుతూ జాబితాను స్థానంలో మారుస్తుంది.

మనకు ఇష్టమైన రంగుల జాబితా ఉందని అనుకుందాం మరియు “+=” ఆపరేటర్‌ని ఉపయోగించి మరిన్ని రంగులను జోడించడం ద్వారా దానిని నవీకరించాలనుకుంటున్నాము.

ఈ దృష్టాంతంలో, మేము 'favorite_colors' ద్వారా సూచించబడే మా ఇష్టమైన రంగుల జాబితాతో ప్రారంభిస్తాము. ఆపై, మేము 'additional_colors' జాబితాలో చేర్చాలనుకుంటున్న కొన్ని కొత్త రంగులను కలిగి ఉన్నాము. “+= ఆపరేటర్”ని ఉపయోగించి, మేము కొత్త రంగులను మా ప్రస్తుత ఇష్టమైన వాటితో కలుపుతాము, “favorite_colors” జాబితాను సవరిస్తాము.

ఆపరేషన్ తర్వాత, మేము 'మా అప్‌డేట్ చేసిన ఇష్టమైన రంగులు' అని ప్రింట్ చేసినప్పుడు, మేము ఈ క్రింది ఫలితాన్ని చూడవచ్చు:

ఉదాహరణ 4: “*” ఆపరేటర్‌ని ఉపయోగించడం

జాబితా ప్రతిరూపణ కోసం '*' ఆపరేటర్‌ని ఉపయోగించవచ్చు. కానీ జాబితాలకు వర్తింపజేసినప్పుడు, అది మూలకాలను పునరావృతం చేయడం ద్వారా వాటిని సంగ్రహించవచ్చు.

ఇక్కడ ఒక ఉదాహరణ:

ఈ సందర్భంలో, మేము [1, 2, 3] మూలకాలను కలిగి ఉన్న “ఒరిజినల్_లిస్ట్”తో ప్రారంభిస్తాము. “*” ఆపరేటర్‌ని ఉపయోగించి, అసలు జాబితా నుండి మూలకాల యొక్క మూడు పునరావృత్తులు కలిగి ఉన్న “సంయోగ_జాబితా” అనే కొత్త జాబితాను మేము సృష్టిస్తాము.

సంయోగం కోసం ఈ విధానం తక్కువ సాధారణం అయితే, ఇది పైథాన్ ఆపరేటర్ల సౌలభ్యాన్ని ప్రదర్శిస్తుంది.

ఉదాహరణ 5: Itertools.chain() ఫంక్షన్‌ని వర్తింపజేయడం

itertools.chain() ఫంక్షన్ అనేది 'itertools' మాడ్యూల్‌లో భాగం మరియు మళ్ళించదగిన (జాబితాలు, tuples లేదా ఇతర మళ్ళించదగిన వస్తువులు వంటివి) ఒకే 'ఇటరబుల్'గా కలపడానికి ఉపయోగించబడుతుంది. కొన్ని ఇతర సంయోగ పద్ధతుల వలె కాకుండా, itertools.chain() కొత్త జాబితాను సృష్టించదు కానీ ఇన్‌పుట్ ఇటరబుల్స్ మూలకాలపై ఒక ఇటరేటర్‌ను ఉత్పత్తి చేస్తుంది.

ఇచ్చిన ఉదాహరణలో, మనకు రెండు జాబితాలు ఉన్నాయి - “L1” సంఖ్యా విలువలను కలిగి ఉంటుంది [1, 2, 3] మరియు “L2” అక్షర అక్షరాలను [“x”, “y”, “z”] కలిగి ఉంటుంది. itertools.chain() ఫంక్షన్‌ని ఉపయోగించి, మేము ఈ జాబితాలను 'concatenated_iterable' ద్వారా సూచించబడే ఒకే మళ్ళించదగినదిగా కలుపుతాము. జాబితా() ఫంక్షన్‌ని మళ్ళించదగిన జాబితాగా మార్చడానికి వర్తించబడుతుంది, దీని ఫలితంగా సంయుక్త జాబితా [1, 2, 3, “x”, “y”, “z”] వస్తుంది.

ఉదాహరణ 6: జాబితా స్లైసింగ్

సూచికల శ్రేణిని అందించడం ద్వారా, జాబితా స్లైసింగ్ అనేది జాబితా యొక్క ఉపసమితిని తిరిగి పొందేందుకు మమ్మల్ని అనుమతించే టెక్నిక్. స్టార్ట్, స్టాప్ మరియు ఐచ్ఛికంగా దశల విలువలను సూచించడానికి స్క్వేర్ బ్రాకెట్‌లలోని కోలన్ (:) ఆపరేటర్‌ని ఉపయోగించడం ఇందులో ఉంటుంది.

ఉదాహరణ కోడ్ ఇక్కడ ఉంది:

మేము [1, 2, 3, 4, 5] మూలకాలను కలిగి ఉన్న 'వాస్తవ_జాబితా'గా సూచించబడే సంఖ్యల అసలైన జాబితాతో దృష్టాంతాన్ని ప్రారంభిస్తాము. పైథాన్‌లో శక్తివంతమైన ఫీచర్ అయిన జాబితా స్లైసింగ్‌ని ఉపయోగించడం ద్వారా మేము జాబితా యొక్క నిర్దిష్ట విభాగాన్ని సంగ్రహిస్తాము. ఈ సందర్భంలో “అసలు_జాబితా[1:4]” స్లైస్ ఉపయోగించబడుతుంది మరియు ఇది ఇండెక్స్ 1 నుండి ఇండెక్స్ 3 వరకు ఎలిమెంట్‌లను ఎంచుకుంటుంది (కానీ ఇండెక్స్ 4 నుండి కాదు). ఫలితంగా 'sliced_list' అనే కొత్త జాబితా, ముక్కలు చేయబడిన భాగాన్ని కలిగి ఉంటుంది [2, 3, 4].

ఉదాహరణ 7: జిప్() ఫంక్షన్‌తో సంయోగం

జిప్() ఫంక్షన్ బహుళ ఇటరబుల్స్ నుండి మూలకాలను మిళితం చేస్తుంది, సంబంధిత మూలకాల జతల లేదా టుపుల్‌లను సృష్టిస్తుంది. ఈ జతలను సృష్టించడానికి ఒకే సూచికలోని ప్రతి పునరావృత మూలకాలు ఉపయోగించబడతాయి.

ఈ ఉదాహరణలో, జిప్() ఫంక్షన్ 'విద్యార్థులు' జాబితా నుండి విద్యార్థుల పేర్లను 'గ్రేడ్‌లు' జాబితా నుండి వారి సంబంధిత గ్రేడ్‌లతో జత చేస్తుంది, దీని ఫలితంగా ప్రతి విద్యార్థి వారి సంబంధిత గ్రేడ్‌తో అనుబంధించబడిన నిఘంటువుని కలిగి ఉంటుంది.

ముగింపు

ముగింపులో, పైథాన్ జాబితాలను కలపడానికి అనేక మార్గాలను అందిస్తుంది, ప్రతి దాని ప్రయోజనాలతో. మేము సరళమైన “+” ఆపరేటర్ నుండి మరింత సూక్ష్మమైన జిప్() ఫంక్షన్ వరకు వివిధ పద్ధతులను అన్వేషించినప్పుడు, పైథాన్ విభిన్న ప్రోగ్రామింగ్ శైలులు మరియు ప్రాధాన్యతలను అందిస్తుంది అని స్పష్టమైంది. చేతిలో ఉన్న పనిని బట్టి, రీడబిలిటీ, మెమరీ సామర్థ్యం మరియు ప్రాసెస్ చేయబడిన డేటా రకం వంటి అంశాలు ఏ పద్ధతి ఉత్తమమో నిర్ణయిస్తాయి.